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
|
CHANGES for GLUT API version 3
-------------------------------
GLUT API version 3 should be (almost) fully compatible with the
GLUT API version 2. See the GLUT 3 specification for full details.
Please be aware of two obscure reasons that programs that worked
under GLUT API version 2 may need slight modification for GLUT 3.
1) You are now _required_ to have a display callback registered
for any GLUT window displayed to the screen. Otherwise a
fatal error is generated. It would be a bug in your program
otherwise! In conjunction with this, you can no longer
call glutDisplayFunc(NULL) to unregister a display callback.
2) It is a fatal error now to modify a GLUT pop-up menu while
menus are in use. There were too many semantic problems with
changing menus that may be currently displayed. To determine
if menus are in use, you can use the "menu use" callback registered
with glutMenuStatusFunc
Here are the GLUT API version 3 additions in more detail:
void glutSetCursor(int cursor)
int glutGet(GLUT_WINDOW_CURSOR)
Provides a way to set (and get) the window's cursor to one
of several enumerated cursor shapes including "none",
"stop-watch", "arrow", "crosshair", "pull left/up/down/etc.",
or "inherit".
void glutFullScreen(void)
Attempts to make the window as large as the window system
permits (ie, the screen size). Borders will be automatically
disabled if possible.
void glutMenuStatus(void (*)(int status, int x, int y))
The existing glutMenuState routine's callback did not
provide the X & Y location when the menu state changed
which made it impossible to correctly implement locate
highlight in conjunction with menus. glutMenuStatus
returns the location.
GLUT_BITMAP_HELVETICA_10
GLUT_BITMAP_HELVETICA_12
GLUT_BITMAP_HELVETICA_18
New bitmap fonts in a nicer font at nicer sizes.
int glutStrokeLength(void *, char *string)
int glutBitmapLength(void *, char *string)
Given a font handle and a string, returns the length in
modelview units or pixels respectively for the string
if rendered with the font.
int glutCurrentModifiers(void)
When called from within a keyboard, special keyboard, mouse
button, or mouse callback, returns a bitmask representing
the modifier keys active when the event generating the callback
occured. This will let you implement Alt+<key> combinations
and such.
void glutEstablishOverlays(void)
void glutRemoveOverlays(void)
void glutOverlayDisplayFunc(void (*func)(void))
void glutPostOverlayRedisplay(void)
void glutUseLayer(GLenum layer)
void glutLayerGet(GLenum type)
void glutShowOverlay(void)
void glutHideOverlay(void)
This API provides a way to "add" an overlay to a GLUT window.
The overlay is like IRIS GL overlay support in that the overlay
completely overlaps the window. You setup the layer with
glutEstablishOverlay. You switch between the normal plane
and overlay using glutUseLayer. You can register an independent
callback for redisplaying the overlay, or use a unified display
callback for both layers.
I believe this is a very simple overlay facility that will be
readily useful for OpenGL programs wanting access to overlay
planes.
GLUT_LUMINANCE
This is a new display mode that is like OpenGL's basic RGBA
color model, but has no Green or Blue components (and Alpha
is optional). The Red component represents single component
(or "luminance") data (between 0.0 and 1.0). The component
is integerized to between 0 and glutGet(GLUT_WINDOW_COLORMAP_SIZE)-1
and looked up in a per-window color map. GLUT's glutSetColor,
glutGetColor, and glutCopyColormap work on a GLUT_LUMINANCE
window. The initial colormap of GLUT_LUMINANCE windows is
initialized to be a linear gray ramp.
GLUT_LUMINANCE is very much like a color index window with
an RGBA rendering model. GLUT_LUMINANCE should be useful for
scientific visualization.
Only some platforms will support GLUT_LUMINANCE. SGI's IMPACT
and InfiniteReality systems should provide GLUT_LUMINANCE
support, however while the GLUT version 3 API provides GLUT_LUMINANCE,
GLUT 3.0 does not implement GLUT_LUMINANCE support.
Exact specifics of how GLUT_LUMINANCE operates are subject to
change.
Also there are a handful of minor bug fixes (of course).
|
