1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
--------------------------------------------------------------------------------
-- |
-- Module : Graphics.UI.GLUT.Colormap
-- Copyright : (c) Sven Panne 2002-2005
-- License : BSD-style (see the file libraries/GLUT/LICENSE)
--
-- Maintainer : sven.panne@aedion.de
-- Stability : stable
-- Portability : portable
--
-- OpenGL supports both RGBA and color index rendering. The RGBA mode is
-- generally preferable to color index because more OpenGL rendering
-- capabilities are available and color index mode requires the loading of
-- colormap entries.
--
-- The GLUT color index state variables are used to read and write entries in a
-- window\'s color index colormap. Every GLUT color index window has its own
-- logical color index colormap. The size of a window\'s colormap can be
-- determined by reading 'numColorMapEntries'.
--
-- GLUT color index windows within a program can attempt to share colormap
-- resources by copying a single color index colormap to multiple windows using
-- 'copyColormap'. If possible GLUT will attempt to share the actual colormap.
-- While copying colormaps using 'copyColormap' can potentially allow sharing of
-- physical colormap resources, logically each window has its own colormap. So
-- changing a copied colormap of a window will force the duplication of the
-- colormap. For this reason, color index programs should generally load a
-- single color index colormap, copy it to all color index windows within the
-- program, and then not modify any colormap cells.
--
-- Use of multiple colormaps is likely to result in colormap installation
-- problems where some windows are displayed with an incorrect colormap due to
-- limitations on colormap resources.
--
--------------------------------------------------------------------------------
module Graphics.UI.GLUT.Colormap (
colorMapEntry,
copyColormap,
numColorMapEntries,
transparentIndex
) where
import Foreign.C.Types ( CInt )
import Graphics.Rendering.OpenGL.GL.BasicTypes ( GLint, GLfloat )
import Graphics.Rendering.OpenGL.GL.StateVar (
GettableStateVar, makeGettableStateVar, StateVar, makeStateVar )
import Graphics.Rendering.OpenGL.GL.VertexSpec ( Color3(..), Index1(..) )
import Graphics.UI.GLUT.Constants (
glut_RED, glut_GREEN, glut_BLUE,
glut_WINDOW_COLORMAP_SIZE, glut_TRANSPARENT_INDEX )
import Graphics.UI.GLUT.QueryUtils ( simpleGet, layerGet )
import Graphics.UI.GLUT.Window ( Window )
--------------------------------------------------------------------------------
-- | Controls the color index colormap entry of the /current window/\'s logical
-- colormap for the /layer in use/. The /layer in use/ of the /current window/
-- should be a color index window. The color index should be zero or greater and
-- less than the total number of colormap entries for the window (see
-- 'numColorMapEntries') and different from an overlay\'s transparent index (see
-- 'transparentIndex').
--
-- If the /layer in use/\'s colormap was copied by reference, setting a colormap
-- entry will force the duplication of the colormap.
colorMapEntry :: Index1 GLint -> StateVar (Color3 GLfloat)
colorMapEntry (Index1 cell) =
makeStateVar (getColorMapEntry (fromIntegral cell))
(setColorMapEntry (fromIntegral cell))
setColorMapEntry :: CInt -> Color3 GLfloat -> IO ()
setColorMapEntry cell (Color3 r g b) = glutSetColor cell r g b
foreign import CALLCONV unsafe "glutSetColor" glutSetColor ::
CInt -> GLfloat -> GLfloat -> GLfloat -> IO ()
getColorMapEntry :: CInt -> IO (Color3 GLfloat)
getColorMapEntry cell = do
r <- glutGetColor cell glut_RED
g <- glutGetColor cell glut_GREEN
b <- glutGetColor cell glut_BLUE
return $ Color3 r g b
foreign import CALLCONV unsafe "glutGetColor" glutGetColor ::
CInt -> CInt -> IO GLfloat
--------------------------------------------------------------------------------
-- | Copy (lazily if possible to promote sharing) the logical colormap from a
-- specified window to the /current window/\'s /layer in use/. The copy will be
-- from the normal plane to the normal plane; or from the overlay to the overlay
-- (never across different layers). Once a colormap has been copied, avoid
-- setting cells in the colormap via 'colorMapEntry' since that will force an
-- actual copy of the colormap if it was previously copied by reference.
-- 'copyColormap' should only be called when both the /current window/ and the
-- specified window are color index windows.
foreign import CALLCONV unsafe "glutCopyColormap" copyColormap ::
Window -> IO ()
--------------------------------------------------------------------------------
-- | Contains the number of entries in the colormap of the /current window/\'s
-- current layer (0 in RGBA mode).
numColorMapEntries :: GettableStateVar GLint
numColorMapEntries =
makeGettableStateVar $ simpleGet fromIntegral glut_WINDOW_COLORMAP_SIZE
--------------------------------------------------------------------------------
-- | Contains the transparent color index of the overlay of the /current window/
-- or -1 if no overlay is in use.
transparentIndex :: GettableStateVar (Index1 GLint)
transparentIndex =
makeGettableStateVar $
layerGet (Index1 . fromIntegral) glut_TRANSPARENT_INDEX
|
