3 (eval-when (:compile-toplevel
:load-toplevel
)
4 (defconstant +false
+ 0)
8 ;; Key and button state/action definitions
9 (defconstant +release
+ 0)
10 (defconstant +press
+ 1)
12 ;; Keyboard key definitions: 8-bit ISO-8859-1 (Latin 1) encoding is used
13 ;; for printable keys (such as A-Z, 0-9 etc), and values above 256
14 ;; represent special (non-printable) keys (e.g. F1, Page Up etc).
15 (defconstant +key-unknown
+ -
1)
16 (defconstant +key-space
+ 32)
17 (defconstant +key-special
+ 256)
18 (defconstant +key-esc
+ (+ +key-special
+ 1))
19 (defconstant +key-f1
+ (+ +key-special
+ 2))
20 (defconstant +key-f2
+ (+ +key-special
+ 3))
21 (defconstant +key-f3
+ (+ +key-special
+ 4))
22 (defconstant +key-f4
+ (+ +key-special
+ 5))
23 (defconstant +key-f5
+ (+ +key-special
+ 6))
24 (defconstant +key-f6
+ (+ +key-special
+ 7))
25 (defconstant +key-f7
+ (+ +key-special
+ 8))
26 (defconstant +key-f8
+ (+ +key-special
+ 9))
27 (defconstant +key-f9
+ (+ +key-special
+ 10))
28 (defconstant +key-f10
+ (+ +key-special
+ 11))
29 (defconstant +key-f11
+ (+ +key-special
+ 12))
30 (defconstant +key-f12
+ (+ +key-special
+ 13))
31 (defconstant +key-f13
+ (+ +key-special
+ 14))
32 (defconstant +key-f14
+ (+ +key-special
+ 15))
33 (defconstant +key-f15
+ (+ +key-special
+ 16))
34 (defconstant +key-f16
+ (+ +key-special
+ 17))
35 (defconstant +key-f17
+ (+ +key-special
+ 18))
36 (defconstant +key-f18
+ (+ +key-special
+ 19))
37 (defconstant +key-f19
+ (+ +key-special
+ 20))
38 (defconstant +key-f20
+ (+ +key-special
+ 21))
39 (defconstant +key-f21
+ (+ +key-special
+ 22))
40 (defconstant +key-f22
+ (+ +key-special
+ 23))
41 (defconstant +key-f23
+ (+ +key-special
+ 24))
42 (defconstant +key-f24
+ (+ +key-special
+ 25))
43 (defconstant +key-f25
+ (+ +key-special
+ 26))
44 (defconstant +key-up
+ (+ +key-special
+ 27))
45 (defconstant +key-down
+ (+ +key-special
+ 28))
46 (defconstant +key-left
+ (+ +key-special
+ 29))
47 (defconstant +key-right
+ (+ +key-special
+ 30))
48 (defconstant +key-lshift
+ (+ +key-special
+ 31))
49 (defconstant +key-rshift
+ (+ +key-special
+ 32))
50 (defconstant +key-lctrl
+ (+ +key-special
+ 33))
51 (defconstant +key-rctrl
+ (+ +key-special
+ 34))
52 (defconstant +key-lalt
+ (+ +key-special
+ 35))
53 (defconstant +key-ralt
+ (+ +key-special
+ 36))
54 (defconstant +key-tab
+ (+ +key-special
+ 37))
55 (defconstant +key-enter
+ (+ +key-special
+ 38))
56 (defconstant +key-backspace
+ (+ +key-special
+ 39))
57 (defconstant +key-insert
+ (+ +key-special
+ 40))
58 (defconstant +key-del
+ (+ +key-special
+ 41))
59 (defconstant +key-pageup
+ (+ +key-special
+ 42))
60 (defconstant +key-pagedown
+ (+ +key-special
+ 43))
61 (defconstant +key-home
+ (+ +key-special
+ 44))
62 (defconstant +key-end
+ (+ +key-special
+ 45))
63 (defconstant +key-kp-0
+ (+ +key-special
+ 46))
64 (defconstant +key-kp-1
+ (+ +key-special
+ 47))
65 (defconstant +key-kp-2
+ (+ +key-special
+ 48))
66 (defconstant +key-kp-3
+ (+ +key-special
+ 49))
67 (defconstant +key-kp-4
+ (+ +key-special
+ 50))
68 (defconstant +key-kp-5
+ (+ +key-special
+ 51))
69 (defconstant +key-kp-6
+ (+ +key-special
+ 52))
70 (defconstant +key-kp-7
+ (+ +key-special
+ 53))
71 (defconstant +key-kp-8
+ (+ +key-special
+ 54))
72 (defconstant +key-kp-9
+ (+ +key-special
+ 55))
73 (defconstant +key-kp-divide
+ (+ +key-special
+ 56))
74 (defconstant +key-kp-multiply
+ (+ +key-special
+ 57))
75 (defconstant +key-kp-subtract
+ (+ +key-special
+ 58))
76 (defconstant +key-kp-add
+ (+ +key-special
+ 59))
77 (defconstant +key-kp-decimal
+ (+ +key-special
+ 60))
78 (defconstant +key-kp-equal
+ (+ +key-special
+ 61))
79 (defconstant +key-kp-enter
+ (+ +key-special
+ 62))
80 (defconstant +key-kp-num-lock
+ (+ +key-special
+ 63))
81 (defconstant +key-caps-lock
+ (+ +key-special
+ 64))
82 (defconstant +key-scroll-lock
+ (+ +key-special
+ 65))
83 (defconstant +key-pause
+ (+ +key-special
+ 66))
84 (defconstant +key-lsuper
+ (+ +key-special
+ 67))
85 (defconstant +key-rsuper
+ (+ +key-special
+ 68))
86 (defconstant +key-menu
+ (+ +key-special
+ 69))
87 (defconstant +key-last
+ +key-menu
+)
89 ;; Mouse button definitions
90 (defconstant +mouse-button-1
+ 0)
91 (defconstant +mouse-button-2
+ 1)
92 (defconstant +mouse-button-3
+ 2)
93 (defconstant +mouse-button-4
+ 3)
94 (defconstant +mouse-button-5
+ 4)
95 (defconstant +mouse-button-6
+ 5)
96 (defconstant +mouse-button-7
+ 6)
97 (defconstant +mouse-button-8
+ 7)
98 (defconstant +mouse-button-last
+ +mouse-button-8
+)
100 ;; Mouse button aliases
101 (defconstant +mouse-button-left
+ +mouse-button-1
+)
102 (defconstant +mouse-button-right
+ +mouse-button-2
+)
103 (defconstant +mouse-button-middle
+ +mouse-button-3
+)
105 ;; Joystick identifiers
106 (defconstant +joystick-1
+ 0)
107 (defconstant +joystick-2
+ 1)
108 (defconstant +joystick-3
+ 2)
109 (defconstant +joystick-4
+ 3)
110 (defconstant +joystick-5
+ 4)
111 (defconstant +joystick-6
+ 5)
112 (defconstant +joystick-7
+ 6)
113 (defconstant +joystick-8
+ 7)
114 (defconstant +joystick-9
+ 8)
115 (defconstant +joystick-10
+ 9)
116 (defconstant +joystick-11
+ 10)
117 (defconstant +joystick-12
+ 11)
118 (defconstant +joystick-13
+ 12)
119 (defconstant +joystick-14
+ 13)
120 (defconstant +joystick-15
+ 14)
121 (defconstant +joystick-16
+ 15)
122 (defconstant +joystick-last
+ +joystick-16
+)
125 ;;========================================================================
127 ;;========================================================================
129 ;; glfwOpenWindow modes
130 (defconstant +window
+ #x00010001
)
131 (defconstant +fullscreen
+ #x00010002
)
133 ;; glfwGetWindowParam tokens
134 (defconstant +opened
+ #x00020001
)
135 (defconstant +active
+ #x00020002
)
136 (defconstant +iconified
+ #x00020003
)
137 (defconstant +accelerated
+ #x00020004
)
138 (defconstant +red-bits
+ #x00020005
)
139 (defconstant +green-bits
+ #x00020006
)
140 (defconstant +blue-bits
+ #x00020007
)
141 (defconstant +alpha-bits
+ #x00020008
)
142 (defconstant +depth-bits
+ #x00020009
)
143 (defconstant +stencil-bits
+ #x0002000a
)
145 ;; The following constants are used for both glfwGetWindowParam
146 ;; and glfwOpenWindowHint
147 (defconstant +refresh-rate
+ #x0002000b
)
148 (defconstant +accum-red-bits
+ #x0002000c
)
149 (defconstant +accum-green-bits
+ #x0002000d
)
150 (defconstant +accum-blue-bits
+ #x0002000e
)
151 (defconstant +accum-alpha-bits
+ #x0002000f
)
152 (defconstant +aux-buffers
+ #x00020010
)
153 (defconstant +stereo
+ #x00020011
)
154 (defconstant +window-no-resize
+ #x00020012
)
155 (defconstant +fsaa-samples
+ #x00020013
)
156 (defconstant +opengl-version-major
+ #x00020014
)
157 (defconstant +opengl-version-minor
+ #x00020015
)
158 (defconstant +opengl-forward-compat
+ #x00020016
)
159 (defconstant +opengl-debug-context
+ #x00020017
)
160 (defconstant +opengl-profile
+ #x00020018
)
162 (defconstant +opengl-core-profile
+ #x00050001
)
163 (defconstant +opengl-compat-profile
+ #x00050002
)
165 ;; glfwEnable/glfwDisable tokens
166 (defconstant +mouse-cursor
+ #x00030001
)
167 (defconstant +sticky-keys
+ #x00030002
)
168 (defconstant +sticky-mouse-buttons
+ #x00030003
)
169 (defconstant +system-keys
+ #x00030004
)
170 (defconstant +key-repeat
+ #x00030005
)
171 (defconstant +auto-poll-events
+ #x00030006
)
173 ;; glfwWaitThread wait modes
174 (defconstant +wait
+ #x00040001
)
175 (defconstant +nowait
+ #x00040002
)
177 ;; glfwGetJoystickParam tokens
178 (defconstant +present
+ #x00050001
)
179 (defconstant +axes
+ #x00050002
)
180 (defconstant +buttons
+ #x00050003
)
182 ;; glfwReadImage/glfwLoadTexture2D flags
183 (defconstant +no-rescale-bit
+ #x00000001
) ; Only for glfwReadImage
184 (defconstant +origin-ul-bit
+ #x00000002
)
185 (defconstant +build-mipmaps-bit
+ #x00000004
) ; Only for glfwLoadTexture2D
186 (defconstant +alpha-map-bit
+ #x00000008
)
188 ;; Time spans longer than this (seconds) are considered to be infinity
189 (defconstant +infinity
+ 100000d0
))
191 (defparameter *was-init
* nil
192 "True if we have already initialized.")
193 (declaim (type cl
:boolean
*was-init
*))
195 (defparameter *init-hooks
* nil
196 "A list of funcallable objects invoked just after initialization.")
197 (defparameter *terminate-hooks
* nil
198 "A list of funcallable objects invoked just before termination.")
199 (declaim (type list
*init-hooks
* *terminate-hooks
*))
201 (cffi:defcfun
("glfwInit" %init
) boolean
)
205 If the function succeeds, t is returned.
206 If the function fails, nil is returned.
208 The glfwInit function initializes GLFW. No other GLFW functions may be used before this function
211 On successful initialization, the list of functions in *init-hooks* is called.
214 This function may take several seconds to complete on some systems, while on other systems it may
215 take only a fraction of a second to complete."
218 (mapc #'funcall
*init-hooks
*)
221 (cffi:defcfun
("glfwTerminate" %terminate
) :void
)
224 "The function terminates GLFW. Among other things it closes the window, if it is opened, and kills any
225 running threads. This function must be called before a program exits.
227 Before termination, the list of functions in *terminate-hooks* is called.
229 (mapc #'funcall
*terminate-hooks
*)
230 (setf *was-init
* nil
)
233 (defcfun+out
+doc
("glfwGetVersion" get-version
) :void
((:out major
:int
)
237 The function returns the major and minor version numbers and the revision for the currently linked
238 GLFW library as a list (major minor rev).")
240 (defmacro with-init
(&body forms
)
241 "Call glfw:init, execute forms and clean-up with glfw:terminate once finished.
242 This makes a nice wrapper to an application higher-level form.
243 Signals an error on failure to initialize. Wrapped in a block named glfw:with-init."
246 (block with-init
,@forms
)
248 (error "Error initializing glfw.")))
250 (defcfun ("glfwOpenWindow" %open-window
) boolean
251 (width :int
) (height :int
)
252 (redbits :int
) (greenbits :int
) (bluebits :int
) (alphabits :int
)
253 (depthbits :int
) (stencilbits :int
) (mode :int
))
255 (declaim (inline open-window
))
256 (defun open-window (&key
(width 0) (height 0)
257 (redbits 0) (greenbits 0) (bluebits 0) (alphabits 0)
258 (depthbits 0) (stencilbits 0) (mode +window
+)
261 (refresh-rate 0 refresh-rate-p
)
262 (accum-red-bits 0 accum-red-bits-p
)
263 (accum-green-bits 0 accum-green-bits-p
)
264 (accum-blue-bits 0 accum-blue-bits-p
)
265 (accum-alpha-bits 0 accum-alpha-bits-p
)
266 (aux-buffers 0 aux-buffers-p
)
267 (stereo nil stereo-p
)
268 (window-no-resize nil window-no-resize-p
)
269 (fsaa-samples 0 fsaa-samples-p
)
270 (opengl-version-major 1 opengl-version-major-p
)
271 (opengl-version-minor 1 opengl-version-minor-p
)
272 (opengl-forward-compat nil opengl-forward-compat-p
)
273 (opengl-debug-context nil opengl-debug-context-p
)
274 (opengl-profile 0 opengl-profile-p
)
275 (opengl-core-profile 0 opengl-core-profile-p
)
276 (opengl-compat-profile 0 opengl-compat-profile-p
))
278 The width of the window. If width is zero, it will be calculated as width = 4/3 height, if height is
279 not zero. If both width and height are zero, then width will be set to 640.
281 The height of the window. If height is zero, it will be calculated as height = 3/4 width, if width is
282 not zero. If both width and height are zero, then height will be set to 480.
283 redbits, greenbits, bluebits
284 The number of bits to use for each color component of the color buffer (0 means default color
285 depth). For instance, setting redbits=5, greenbits=6, and bluebits=5 will generate a 16-bit color
288 The number of bits to use for the alpha buffer (0 means no alpha buffer).
290 The number of bits to use for the depth buffer (0 means no depth buffer).
292 The number of bits to use for the stencil buffer (0 means no stencil buffer).
294 Selects which type of OpenGL window to use. mode can be either +WINDOW+, which
295 will generate a normal desktop window, or +FULLSCREEN+ which will generate a
296 window which covers the entire screen. When +FULLSCREEN+ is selected, the video
297 mode will be changed to the resolution that closest matches the width and height parameters.
300 If the function succeeds, t is returned.
301 If the function fails, nil is returned.
305 The function opens a window that best matches the parameters given to
306 the function. How well the resulting window matches the desired window
307 depends mostly on the available hardware and OpenGL drivers. In
308 general, selecting a fullscreen mode has better chances of generating
309 a close match than does a normal desktop window, since GLFW can freely
310 select from all the available video modes. A desktop window is
311 normally restricted to the video mode of the desktop.
315 For additional control of window properties, see glfw::OpenWindowHint.
316 In fullscreen mode the mouse cursor is hidden by default, and any system screensavers are prohibited
317 from starting. In windowed mode the mouse cursor is visible, and screensavers are allowed to start. To
318 change the visibility of the mouse cursor, use glfwEnable or glfwDisable with the argument
320 In order to determine the actual properties of an opened window, use glfw::GetWindowParam and
321 glfw::GetWindowSize (or glfw::SetWindowSizeCallback).
323 (macrolet ((output-int-hints (&rest names
)
325 ,@(loop for name in names collect
326 `(when ,(intern (format nil
"~a-P" name
) '#:cl-glfw
)
327 (open-window-hint ,(intern (format nil
"+~A+" name
) '#:cl-glfw
)
329 (output-boolean-hints (&rest names
)
331 ,@(loop for name in names collect
332 `(when ,(intern (format nil
"~a-P" name
) '#:cl-glfw
)
333 (open-window-hint ,(intern (format nil
"+~A+" name
) '#:cl-glfw
)
334 (if ,name
+true
+ +false
+)))))))
335 (output-int-hints refresh-rate
336 accum-red-bits accum-green-bits accum-blue-bits
344 opengl-compat-profile
)
345 (output-boolean-hints stereo
347 opengl-forward-compat
348 opengl-debug-context
))
349 (if (%open-window width height redbits greenbits bluebits alphabits depthbits stencilbits mode
)
350 (when title
(set-window-title title
))
351 (error "Error initializing glfw window.")))
355 (defcfun+doc
("glfwOpenWindowHint" open-window-hint
) :void
((target :int
) (hint :int
))
357 Can be any of the constants in the table 3.1.
359 An integer giving the value of the corresponding target (see table 3.1).
362 The function sets additional properties for a window that is to be opened. For a hint to be registered, the
363 function must be called before calling glfw::OpenWindow. When the glfw::OpenWindow function is
364 called, any hints that were registered with the glfw::OpenWindowHint function are used for setting the
365 corresponding window properties, and then all hints are reset to their default values.
368 In order to determine the actual properties of an opened window, use glfw::GetWindowParam (after the
369 window has been opened).
370 +STEREO+ is a hard constraint. If stereo rendering is requested, but no stereo rendering capable
371 pixel formats / visuals are available, glfw::OpenWindow will fail.
372 The +REFRESH_RATE+ property should be used with caution. Most systems have default values
373 for monitor refresh rates that are optimal for the specific system. Specifying the refresh rate can
374 override these settings, which can result in suboptimal operation. The monitor may be unable to display
375 the resulting video signal, or in the worst case it may even be damaged!
378 (defcfun+doc
("glfwCloseWindow" close-window
) :void
()
379 "The function closes an opened window and destroys the associated OpenGL context.")
381 (defmacro with-open-window
((&rest open-window-keys
)
383 "Wraps forms such that there is an open window for them to execute in and cleans up the
384 window afterwards. An error is signalled if there was an error opening the window.
385 Takes the same parameters as open-window, with the addition of 'title' which will
386 set the window title after opening.
387 Wrapped in a block named glfw:with-open-window."
389 (open-window ,@open-window-keys
)
391 (block with-open-window
,@forms
)
392 (when (= +true
+ (glfw:get-window-param glfw
:+opened
+))
395 (defmacro with-init-window
((&rest open-window-keys
)
397 "Wraps forms in with-init, with-open-window. Passes through the other arguments to open-window."
399 (with-open-window (,@open-window-keys
)
402 (defmacro do-open-window
((&rest open-window-keys
)
405 "High-level convenience macro for opening a window (given the optional window parameters),
406 setting the title given,
407 running setup-forms and then running forms in a loop, with calls to swap-buffers after each loop iteration.
408 The loop is in a block named do-open-window [so can be exited by a call to (return-from glfw:do-window)].
409 If the window is closed, the loop is also exited."
410 `(with-open-window (,@open-window-keys
)
412 (loop named do-open-window do
416 (unless (= +true
+ (glfw:get-window-param glfw
:+opened
+))
417 (return-from do-open-window
))))))
419 (defmacro do-window
((&rest open-window-keys
)
422 "High-level convenience macro for initializing glfw, opening a window (given the optional window parameters),
423 setting the title given,
424 running setup-forms and then running forms in a loop, with calls to swap-buffers after each loop iteration.
425 The loop is in a block named do-window [so can be exited by a call to (return-from glfw:do-window)].
426 If the window is closed, the loop is also exited."
429 (do-open-window (,@open-window-keys
) (,@setup-forms
) ,@forms
))))
431 (defmacro define-callback-setter
(c-name callback-prefix return-type
(&body args
) &key before-form after-form documentation
)
432 (let* ((callback-name (intern (format nil
"~A-CALLBACK" callback-prefix
)))
433 (cffi-callback-name #+(or win32 windows
) (list callback-name
:convention
:stdcall
)
434 #-
(or win32 windows
) callback-name
)
435 (special-name (intern (format nil
"*~S*" callback-name
)))
436 (setter-name (intern (format nil
"SET-~S" callback-name
)))
437 (internal-setter-name (intern (format nil
"%~S" setter-name
))))
439 (defparameter ,special-name nil
)
440 (cffi:defcallback
,cffi-callback-name
,return-type
,args
444 (funcall ,special-name
,@(mapcar #'car args
))
446 (cffi:defcfun
(,c-name
,internal-setter-name
) :void
(cbfun :pointer
))
447 (defun ,setter-name
(callback)
448 ,(format nil
"GENERAL CL-GLFW CALLBACK NOTES
450 All callback setting functions can take either a pointer to a C function,
451 a function object, a function symbol, or nil to clear the callback function.
453 THIS CALLBACK FUNCTION
458 (,internal-setter-name
(cffi:null-pointer
)))
460 (setf ,special-name callback
)
461 (,internal-setter-name
(cffi:callback
,callback-name
)))
462 ((functionp callback
)
463 (setf ,special-name callback
)
464 (,internal-setter-name
(cffi:callback
,callback-name
)))
465 ((cffi:pointerp callback
)
466 (,internal-setter-name callback
))
467 (t (error "Not an acceptable callback. Must be foreign pointer, function object, function's symbol, or nil.")))))))
470 (define-callback-setter "glfwSetWindowCloseCallback" #:window-close
:int
()
473 Function that will be called when a user requests that the window should be
474 closed, typically by clicking the window close icon (e.g. the cross in the upper right corner of a
475 window under Microsoft Windows). The function should have the following type:
476 (function () integer)
478 The return value of the callback function indicates whether or not the window close action should continue. If the function returns
479 gl:+true+, the window will be closed. If the function returns gl:+false+, the window will not
480 be closed. If you give a CFFI callback returning glfw:boolean, you can use t and nil as return types.
483 Window close events are recorded continuously, but only reported when glfwPollEvents,
484 glfwWaitEvents or glfwSwapBuffers is called.
485 The OpenGL context is still valid when this function is called.
486 Note that the window close callback function is not called when glfwCloseWindow is called, but only
487 when the close request comes from the window manager.
488 Do not call glfwCloseWindow from a window close callback function. Close the window by returning
489 gl:+true+ from the function.
493 (defcfun+doc
("glfwSetWindowTitle" set-window-title
) :void
((title :string
))
496 Pointer to a null terminated ISO 8859-1 (8-bit Latin 1) string that holds the title of the window.
499 The function changes the title of the opened window.
502 The title property of a window is often used in situations other
503 than for the window title, such as the title of an application icon
504 when it is in iconified state.")
506 (defcfun+doc
("glfwSetWindowSize" set-window-size
) :void
((width :int
) (height :int
))
511 Height of the window.
516 The function changes the size of an opened window. The width and
517 height parameters denote the size of the client area of the
518 window (i.e. excluding any window borders and decorations). If the
519 window is in fullscreen mode, the video mode will be changed to a
520 resolution that closest matches the width and height parameters (the
521 number of color bits will not be changed).
525 The OpenGL context is guaranteed to be preserved after calling glfwSetWindowSize, even if the
526 video mode is changed.
529 (defcfun+doc
("glfwSetWindowPos" set-window-pos
) :void
((x :int
) (y :int
))
532 Horizontal position of the window, relative to the upper left corner of the desktop.
534 Vertical position of the window, relative to the upper left corner of the desktop.
538 The function changes the position of an opened window. It does not have any effect on a fullscreen
542 (defcfun ("glfwGetWindowSize" %get-window-size
) :void
(width :pointer
) (height :pointer
))
543 (defun get-window-size ()
544 "The function is used for determining the size of an opened window. The returned values are dimensions
545 of the client area of the window (i.e. excluding any window borders and decorations).
547 (cffi:with-foreign-objects
((width :int
)
549 (%get-window-size width height
)
550 (list (mem-ref width
:int
)
551 (mem-ref height
:int
))))
553 (define-callback-setter "glfwSetWindowSizeCallback" #:window-size
:void
((width :int
) (height :int
))
556 Function that will be called every time the window size changes. The
557 function should takes the arguments (width height) giving the new width and height of the window client area.
559 A window has to be opened for this function to have any effect.
561 Window size changes are recorded continuously, but only reported when glfwPollEvents,
562 glfwWaitEvents or glfwSwapBuffers is called. ")
564 (defcfun+doc
("glfwIconifyWindow" iconify-window
) :void
()
565 "Iconify a window. If the window is in fullscreen mode, then the desktop video mode will be restored.")
567 (defcfun+doc
("glfwRestoreWindow" restore-window
) :void
()
568 "Restore an iconified window. If the window that is restored is in fullscreen mode, then the fullscreen
569 video mode will be restored.")
571 (defcfun+doc
("glfwGetWindowParam" get-window-param
) :int
((param :int
))
574 A token selecting which parameter the function should return (see table 3.2).
578 The function returns different parameters depending on the value of
579 param. Table 3.2 lists valid param values, and their corresponding
583 The function is used for acquiring various properties of an opened window.
585 Notes: GLFW_ACCELERATED is only supported under Windows. Other systems
586 will always return GL_TRUE. Under Windows, GLFW_ACCELERATED means that
587 the OpenGL renderer is a 3rd party renderer, rather than the fallback
588 Microsoft software OpenGL renderer. In other words, it is not a real
589 guarantee that the OpenGL renderer is actually hardware accelerated.
592 (defcfun+doc
("glfwSwapBuffers" swap-buffers
) :void
()
593 "The function swaps the back and front color buffers of the window. If +AUTO_POLL_EVENTS+
594 is enabled (which is the default), glfwPollEvents is called before swapping the front and back buffers.")
597 (defcfun+doc
("glfwSwapInterval" swap-interval
) :void
((interval :int
))
600 Minimum number of monitor vertical retraces between each buffer swap performed by
601 glfwSwapBuffers. If interval is zero, buffer swaps will not be synchronized to the vertical
602 refresh of the monitor (also known as VSync off).
606 The function selects the minimum number of monitor vertical retraces
607 that should occur between two buffer swaps. If the selected swap
608 interval is one, the rate of buffer swaps will never be higher than
609 the vertical refresh rate of the monitor. If the selected swap
610 interval is zero, the rate of buffer swaps is only limited by the
611 speed of the software and the hardware.
615 This function will only have an effect on hardware and drivers that
616 support user selection of the swap interval. ")
619 (define-callback-setter "glfwSetWindowRefreshCallback" #:window-refresh
:void
()
622 Function that will be called when the window client area needs to be
623 refreshed. The function takes no arguments and returns nothing (void).
627 The function selects which function to be called upon a window refresh
628 event, which occurs when any part of the window client area has been
629 damaged, and needs to be repainted (for instance, if a part of the
630 window that was previously occluded by another window has become
631 visible). A window has to be opened for this function to have any
635 Window refresh events are recorded continuously, but only reported when glfwPollEvents,
636 glfwWaitEvents or glfwSwapBuffers is called.
646 (defcfun ("glfwGetVideoModes" %get-video-modes
) :int
(list :pointer
) (maxcount :int
))
648 (defun get-video-modes (maxcount)
651 Maximum number of video modes that list vector can hold.
654 The function returns the number of detected video modes (this number will never exceed maxcount).
655 The list vector is filled out with the video modes that are supported by the system.
658 The function returns a list of supported video modes. Each video mode is represented by a
660 (width height redbits greenbits bluebits)
663 The returned list is sorted, first by color depth (RedBits + GreenBits + BlueBits), and then by
664 resolution (Width * Height), with the lowest resolution, fewest bits per pixel mode first. "
665 (declare (optimize (debug 3)))
666 (with-foreign-object (list 'vidmode maxcount
)
667 (let ((count (%get-video-modes list maxcount
)))
668 (loop for i below count
670 (let ((mode (cffi:mem-aref list
'vidmode i
)))
671 (list (foreign-slot-value mode
'vidmode
'width
)
672 (foreign-slot-value mode
'vidmode
'height
)
673 (foreign-slot-value mode
'vidmode
'redbits
)
674 (foreign-slot-value mode
'vidmode
'greenbits
)
675 (foreign-slot-value mode
'vidmode
'bluebits
)))))))
677 (defcfun ("glfwGetDesktopMode" %get-desktop-mode
) :void
(mode :pointer
))
678 (defun get-desktop-mode ()
681 Pointer to a GLFWvidmode structure, which will be filled out by the function.
683 The GLFWvidmode structure pointed to by mode is filled out with the desktop video mode.
685 The function returns the desktop video mode in a GLFWvidmode structure. See glfwGetVideoModes
686 for a definition of the GLFWvidmode structure.
688 The color depth of the desktop display is always reported as the number of bits for each individual color
689 component (red, green and blue), even if the desktop is not using an RGB or RGBA color format. For
690 instance, an indexed 256 color display may report RedBits = 3, GreenBits = 3 and BlueBits = 2, which
691 adds up to 8 bits in total.
692 The desktop video mode is the video mode used by the desktop, not the current video mode (which may
693 differ from the desktop video mode if the GLFW window is a fullscreen window).
695 (with-foreign-object (mode 'vidmode
)
696 (%get-desktop-mode mode
)
697 (list (foreign-slot-value mode
'vidmode
'width
)
698 (foreign-slot-value mode
'vidmode
'height
)
699 (foreign-slot-value mode
'vidmode
'redbits
)
700 (foreign-slot-value mode
'vidmode
'greenbits
)
701 (foreign-slot-value mode
'vidmode
'bluebits
))))
703 (defcfun+doc
("glfwPollEvents" poll-events
) :void
()
705 The function is used for polling for events, such as user input and window resize events. Upon calling
706 this function, all window states, keyboard states and mouse states are updated. If any related callback
707 functions are registered, these are called during the call to glfwPollEvents.
710 glfwPollEvents is called implicitly from glfwSwapBuffers if +AUTO_POLL_EVENTS+ is
711 enabled (default). Thus, if glfwSwapBuffers is called frequently, which is normally the case, there is
712 no need to call glfwPollEvents.
715 (defcfun+doc
("glfwWaitEvents" wait-events
) :void
()
717 The function is used for waiting for events, such as user input and window resize events. Upon calling
718 this function, the calling thread will be put to sleep until any event appears in the event queue. When
719 events are ready, the events will be processed just as they are processed by glfwPollEvents.
720 If there are any events in the queue when the function is called, the function will behave exactly like
721 glfwPollEvents (i.e. process all messages and then return, without blocking the calling thread).
724 It is guaranteed that glfwWaitEvents will wake up on any event that can be processed by
725 glfw::PollEvents. However, glfwWaitEvents may wake up on events that are not processed or reported
726 by glfw::PollEvents too, and the function may behave differently on different systems. Do no make any
727 assumptions about when or why glfw::WaitEvents will return.
730 (defmacro key-int-to-symbol
(key-form)
733 (loop for special-key in
'("backspace" "del" "down" "end" "enter" "esc" "f1" "f10" "f11" "f12" "f13"
734 "f14" "f15" "f16" "f17" "f18" "f19" "f2" "f20" "f21" "f22" "f23" "f24" "f25"
735 "f3" "f4" "f5" "f6" "f7" "f8" "f9" "home" "insert" "kp-0" "kp-1" "kp-2" "kp-3"
736 "kp-4" "kp-5" "kp-6" "kp-7" "kp-8" "kp-9" "kp-add" "kp-decimal" "kp-divide"
737 "kp-enter" "kp-equal" "kp-multiply" "kp-subtract" "lalt" "lctrl" "left"
738 "lshift" "pagedown" "pageup" "ralt" "rctrl" "right" "rshift"
739 "special" "tab" "unknown" "up"
740 "kp-num-lock" "caps-lock" "scroll-lock" "pause" "lsuper" "rsuper" "menu")
742 `(,(symbol-value (find-symbol (string-upcase (format nil
"+key-~a+" special-key
)) (find-package '#:glfw
)))
743 ,(intern (string-upcase special-key
) (find-package '#:keyword
))))
744 #'(lambda (a b
) (< (car a
) (car b
))))))
747 (defun lispify-key (key-int)
748 "Convert key-int from GLFW's integer representation to lisp characters if from 0 to 255, or keywords, if not within 0-255 inclusive."
749 (if (and (>= key-int
0) (< key-int
256))
751 (key-int-to-symbol key-int
)))
754 (defcfun+doc
("glfwGetKey" get-key
) :int
((key :int
))
757 A keyboard key identifier, which can be either an uppercase printable ISO 8859-1 (Latin 1)
758 character (e.g. 'A', '3' or '.'), or a special key identifier. Table 3.3 lists valid special key
761 The function returns +PRESS+ if the key is held down, or +RELEASE+ if the key is not
765 The function queries the current state of a specific keyboard key. The physical location of each key
766 depends on the system keyboard layout setting.
769 The constant +KEY_SPACE+ is equal to 32, which is the ISO 8859-1 code for space.
770 Not all key codes are supported on all systems. Also, while some keys are available on some keyboard
771 layouts, they may not be available on other keyboard layouts.
772 For systems that do not distinguish between left and right versions of modifier keys (shift, alt and
773 control), the left version is used (e.g. +KEY_LSHIFT+)
774 A window must be opened for the function to have any effect, and glfw::PollEvents, glfw::WaitEvents or
775 glfw::SwapBuffers must be called before any keyboard events are recorded and reported by
780 (defun lispify-mouse-button (button-int)
781 "Convert button-int from GLFW's integer representation to a lisp keyword."
783 (#.glfw
:+mouse-button-left
+ :left
)
784 (#.glfw
:+mouse-button-middle
+ :middle
)
785 (#.glfw
:+mouse-button-right
+ :right
)
786 (#.glfw
:+mouse-button-4
+ :button-4
)
787 (#.glfw
:+mouse-button-5
+ :button-5
)
788 (#.glfw
:+mouse-button-6
+ :button-6
)
789 (#.glfw
:+mouse-button-7
+ :button-7
)
790 (#.glfw
:+mouse-button-8
+ :button-8
)))
793 (defcfun+doc
("glfwGetMouseButton" get-mouse-button
) :int
((button :int
))
796 A mouse button identifier, which can be one of the mouse button identifiers listed in table 3.4.
798 The function returns +PRESS+ if the mouse button is held down, or +RELEASE+ if the
799 mouse button is not held down.
801 The function queries the current state of a specific mouse button.
803 A window must be opened for the function to have any effect, and glfw::PollEvents, glfw::WaitEvents or
804 glfw::SwapBuffers must be called before any mouse button events are recorded and reported by
805 glfw::GetMouseButton.
806 +MOUSE_BUTTON_LEFT+ is equal to +MOUSE_BUTTON_1+
807 +MOUSE_BUTTON_RIGHT+ is equal to +MOUSE_BUTTON_2+
808 +MOUSE_BUTTON_MIDDLE+ is equal to +MOUSE_BUTTON_3+
812 (defcfun+out
+doc
("glfwGetMousePos" get-mouse-pos
) :void
((:out xpos
:int
) (:out ypos
:int
))
814 The function returns the current mouse position in xpos and ypos.
817 The function returns the current mouse position. If the cursor is not hidden, the mouse position is the
818 cursor position, relative to the upper left corner of the window and limited to the client area of the
819 window. If the cursor is hidden, the mouse position is a virtual absolute position, not limited to any
820 boundaries except to those implied by the maximum number that can be represented by a signed integer
821 (normally -2147483648 to +2147483647).
824 A window must be opened for the function to have any effect, and glfw::PollEvents, glfw::WaitEvents or
825 glfw::SwapBuffers must be called before any mouse movements are recorded and reported by
830 (defcfun+doc
("glfwSetMousePos" set-mouse-pos
) :void
((xpos :int
) (ypos :int
))
833 Horizontal position of the mouse.
835 Vertical position of the mouse.
838 The function changes the position of the mouse. If the cursor is visible (not disabled), the cursor will be
839 moved to the specified position, relative to the upper left corner of the window client area. If the cursor
840 is hidden (disabled), only the mouse position that is reported by GLFW is changed.
843 (defcfun+doc
("glfwGetMouseWheel" get-mouse-wheel
) :int
()
845 The function returns the current mouse wheel position.
847 The function returns the current mouse wheel position. The mouse wheel can be thought of as a third
848 mouse axis, which is available as a separate wheel or up/down stick on some mice.
850 A window must be opened for the function to have any effect, and glfw::PollEvents, glfw::WaitEvents or
851 glfw::SwapBuffers must be called before any mouse wheel movements are recorded and reported by
855 (defcfun+doc
("glfwSetMouseWheel" set-mouse-wheel
) :void
((pos :int
))
858 Position of the mouse wheel.
860 The function changes the position of the mouse wheel.
864 (define-callback-setter "glfwSetKeyCallback" #:key
:void
((key :int
) (action :int
))
865 :before-form
(setf key
(lispify-key key
))
868 Function that will be called every time a key is pressed or released.
869 Function should take the arguments (key action), where key is either a character,
870 if the key pressed was a member of iso-8859-1, or a keyword representing the key pressed if not.
871 See the GLFW manual, table 3.3 for special key identifiers. Action is either glfw:+press+ or
872 glfw:+release+. Use set-char-callback instead if you want to read just characters.
875 The function selects which function to be called upon a keyboard key event. The callback function is
876 called every time the state of a single key is changed (from released to pressed or vice versa). The
877 reported keys are unaffected by any modifiers (such as shift or alt).
878 A window has to be opened for this function to have any effect.
881 Keyboard events are recorded continuously, but only reported when glfw::PollEvents, glfw::WaitEvents
882 or glfw::SwapBuffers is called.
884 (define-callback-setter "glfwSetCharCallback" #:char
:void
((character :int
) (action :int
))
885 :before-form
(setf character
(code-char character
))
888 Function that will be called every time a printable character is generated by
889 the keyboard. The function should take the arguments (character action)
890 where character is a lisp character and action is either glfw:+press+ or glfw:+release+.
892 NB this makes the presumption that your lisp implementation will use Unicode for code-char.
895 The function selects which function to be called upon a keyboard character event. The callback function
896 is called every time a key that results in a printable Unicode character is pressed or released. Characters
897 are affected by modifiers (such as shift or alt).
898 A window has to be opened for this function to have any effect.
901 Character events are recorded continuously, but only reported when glfw::PollEvents, glfw::WaitEvents
902 or glfw::SwapBuffers is called.
903 Control characters, such as tab and carriage return, are not reported to the character callback function,
904 since they are not part of the Unicode character set. Use the key callback function for such events (see
905 glfw::SetKeyCallback).
906 The Unicode character set supports character codes above 255, so never cast a Unicode character to an
907 eight bit data type (e.g. the C language char type) without first checking that the character code is less
908 than 256. Also note that Unicode character codes 0 to 255 are equal to ISO 8859-1 (Latin 1).
911 (define-callback-setter "glfwSetMouseButtonCallback" #:mouse-button
:void
((button :int
) (action :int
))
912 :before-form
(setf button
(lispify-mouse-button button
))
915 Function that will be called every time a mouse button is pressed or released.
916 The function takes the arguments (button action), where button is a keyword symbol as returned by
917 lispify-mouse-button and action is either glfw:+press+ or glfw:+release+.
920 The function selects which function to be called upon a mouse button event.
921 A window has to be opened for this function to have any effect.
924 Mouse button events are recorded continuously, but only reported when glfw::PollEvents,
925 glfw::WaitEvents or glfw::SwapBuffers is called.
926 +MOUSE_BUTTON_LEFT+ is equal to +MOUSE_BUTTON_1+
927 +MOUSE_BUTTON_RIGHT+ is equal to +MOUSE_BUTTON_2+
928 +MOUSE_BUTTON_MIDDLE+ is equal to +MOUSE_BUTTON_3+
930 (define-callback-setter "glfwSetMousePosCallback" #:mouse-pos
:void
((x :int
) (y :int
))
933 Function that will be called every time the mouse is moved.
934 The function takes the arguments (x y), where x and y are the current position of the mouse.
937 The function selects which function to be called upon a mouse motion event.
938 A window has to be opened for this function to have any effect.
941 Mouse motion events are recorded continuously, but only reported when glfw::PollEvents,
942 glfw::WaitEvents or glfw::SwapBuffers is called.
945 (defparameter *mouse-wheel-cumulative
* nil
)
946 (define-callback-setter "glfwSetMouseWheelCallback" #:mouse-wheel
:void
((pos :int
))
947 :after-form
(unless *mouse-wheel-cumulative
* (glfw:set-mouse-wheel
0))
950 Function that will be called every time the mouse wheel is moved.
951 The function takes one argument: the position of the mouse wheel.
952 This DIFFERS FROM GLFW's DEFAULT behaviour in that the position is
953 reset after every call to this function, effectively giving the delta.
954 As most programs are only interested in the delta anyway, this is thought
955 to save others recording the state of it again.
956 If you wish to have the original GLFW behaviour, set cl-glfw:*mouse-wheel-cumulative* to t.
959 The function selects which function to be called upon a mouse wheel event.
960 A window has to be opened for this function to have any effect.
962 Mouse wheel events are recorded continuously, but only reported when glfw::PollEvents,
963 glfw::WaitEvents or glfw::SwapBuffers is called.
966 (defcfun+doc
("glfwGetJoystickParam" get-joystick-param
) :int
((joy :int
) (param :int
))
969 A joystick identifier, which should be +JOYSTICK_n+ where n is in the range 1 to 16.
971 A token selecting which parameter the function should return (see table 3.5).
973 The function returns different parameters depending on the value of param. Table 3.5 lists valid param
974 values, and their corresponding return values.
976 The function is used for acquiring various properties of a joystick.
978 The joystick information is updated every time the function is called.
979 No window has to be opened for joystick information to be valid.
982 (defcfun ("glfwGetJoystickPos" %get-joystick-pos
) :int
(joy :int
) (pos :pointer
) (numaxes :int
))
984 (defun get-joystick-pos (joy numaxes
)
987 A joystick identifier, which should be +JOYSTICK_n+ where n is in the range 1 to 16.
989 Specifies how many axes should be returned.
991 An list that will hold the positional values for all requested axes.
992 If the joystick is not supported or connected, the function will
996 The function queries the current position of one or more axes of a joystick. The positional values are
997 returned in an array, where the first element represents the first axis of the joystick (normally the X
998 axis). Each position is in the range -1.0 to 1.0. Where applicable, the positive direction of an axis is
999 right, forward or up, and the negative direction is left, back or down.
1000 If numaxes exceeds the number of axes supported by the joystick, or if the joystick is not available, the
1001 unused elements in the pos array will be set to 0.0 (zero).
1004 The joystick state is updated every time the function is called, so there is no need to call glfw::PollEvents
1005 or glfw::WaitEvents for joystick state to be updated.
1006 Use glfw::GetJoystickParam to retrieve joystick capabilities, such as joystick availability and number of
1008 No window has to be opened for joystick input to be valid.
1010 (with-foreign-object (pos :float numaxes
)
1011 (let ((numaxes (%get-joystick-pos joy pos numaxes
)))
1012 (loop for i below numaxes collecting
(mem-aref pos
:float i
)))))
1015 (defcfun ("glfwGetJoystickButtons" %get-joystick-buttons
) :int
(joy :int
) (buttons :pointer
) (numbuttons :int
))
1016 (defun get-joystick-buttons (joy numbuttons
)
1019 A joystick identifier, which should be +JOYSTICK_n+ where n is in the range 1 to 16.
1021 Specifies how many buttons should be returned.
1023 A list that will hold the button states for all requested buttons.
1024 The function returns the number of actually returned buttons. This is the minimum of numbuttons and
1025 the number of buttons supported by the joystick. If the joystick is not supported or connected, the
1026 function will return 0 (zero).
1029 The function queries the current state of one or more buttons of a joystick. The button states are
1030 returned in an array, where the first element represents the first button of the joystick. Each state can be
1031 either +PRESS+ or +RELEASE+
1032 If numbuttons exceeds the number of buttons supported by the joystick, or if the joystick is not
1033 available, the unused elements in the buttons array will be set to +RELEASE+
1036 The joystick state is updated every time the function is called, so there is no need to call glfw::PollEvents
1037 or glfw::WaitEvents for joystick state to be updated.
1038 Use glfw::GetJoystickParam to retrieve joystick capabilities, such as joystick availability and number of
1040 No window has to be opened for joystick input to be valid.
1042 (with-foreign-object (buttons :unsigned-char numbuttons
)
1043 (let ((numbuttons (%get-joystick-buttons joy buttons numbuttons
)))
1044 (loop for i below numbuttons collecting
(mem-aref buttons
:unsigned-char i
)))))
1047 (defcfun+doc
("glfwGetTime" get-time
) :double
()
1049 The function returns the value of the high precision timer. The time is measured in seconds, and is
1050 returned as a double precision floating point value.
1053 The function returns the state of a high precision timer. Unless the timer has been set by the
1054 glfw::SetTime function, the time is measured as the number of seconds that have passed since glfw::Init
1058 The resolution of the timer depends on which system the program is running on. The worst case
1059 resolution is somewhere in the order of 10 ms, while for most systems the resolution should be better
1063 (defcfun+doc
("glfwSetTime" set-time
) :void
((time :double
))
1066 Time (in seconds) that the timer should be set to.
1069 The function sets the current time of the high precision timer to the specified time. Subsequent calls to
1070 glfw::GetTime will be relative to this time. The time is given in seconds.
1073 (defcfun+doc
("glfwSleep" sleep
) :void
((time :double
))
1076 Time, in seconds, to sleep.
1079 The function puts the calling thread to sleep for the requested period of time. Only the calling thread is
1080 put to sleep. Other threads within the same process can still execute.
1083 There is usually a system dependent minimum time for which it is possible to sleep. This time is
1084 generally in the range 1 ms to 20 ms, depending on thread sheduling time slot intervals etc. Using a
1085 shorter time as a parameter to glfw::Sleep can give one of two results: either the thread will sleep for the
1086 minimum possible sleep time, or the thread will not sleep at all (glfw::Sleep returns immediately). The
1087 latter should only happen when very short sleep times are specified, if at all. ")
1093 (bytes-per-pixel :int
)
1096 (defcfun+doc
("glfwReadImage" read-image
) boolean
1097 ((name :string
) (img image
) (flags :int
))
1100 A null terminated ISO 8859-1 string holding the name of the file that should be read.
1102 Pointer to a GLFWimage struct, which will hold the information about the loaded image (if the
1103 read was successful).
1105 Flags for controlling the image reading process. Valid flags are listed in table 3.6
1107 The function returns t if the image was loaded successfully. Otherwise nil is
1110 The function reads an image from the file specified by the parameter name and returns the image
1111 information and data in a GLFWimage structure, which has the following definition:
1114 int Width, Height; // Image dimensions
1115 int Format; // OpenGL pixel format
1116 int BytesPerPixel; // Number of bytes per pixel
1117 unsigned char *Data; // Pointer to pixel data
1120 Width and Height give the dimensions of the image. Format specifies an OpenGL pixel format,
1121 which can be GL_LUMINANCE or GL_ALPHA (for gray scale images), GL_RGB or GL_RGBA.
1122 BytesPerPixel specifies the number of bytes per pixel. Data is a pointer to the actual pixel data.
1124 By default the read image is rescaled to the nearest larger 2m ? 2n resolution using bilinear
1125 interpolation, if necessary, which is useful if the image is to be used as an OpenGL texture. This
1126 behavior can be disabled by setting the GLFW_NO_RESCALE_BIT flag.
1127 Unless the flag GLFW_ORIGIN_UL_BIT is set, the first pixel in img->Data is the lower left corner of
1128 the image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left corner.
1129 For single component images (i.e. gray scale), Format is set to GL_ALPHA if the flag
1131 +ALPHA_MAP_BIT+ flag is set, otherwise Format is set to GL_LUMINANCE.
1133 glfw::ReadImage supports the Truevision Targa version 1 file format (.TGA). Supported pixel formats
1134 are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color + alpha.
1135 Paletted images are translated into true color or true color + alpha pixel formats.
1136 Please note that OpenGL 1.0 does not support single component alpha maps, so do not use images
1137 with Format = GL_ALPHA directly as textures under OpenGL 1.0.
1140 (defcfun+doc
("glfwReadMemoryImage" read-memory-image
) boolean
1141 ((data :pointer
) (size :long
) (img image
) (flags :int
))
1144 The memory buffer holding the contents of the file that should be read.
1146 The size, in bytes, of the memory buffer.
1148 Pointer to a GLFWimage struct, which will hold the information about the loaded image (if the
1149 read was successful).
1151 Flags for controlling the image reading process. Valid flags are listed in table 3.6
1153 The function returns t if the image was loaded successfully. Otherwise nil is
1156 The function reads an image from the memory buffer specified by the parameter data and returns the
1157 image information and data in a GLFWimage structure, which has the following definition:
1160 int Width, Height; // Image dimensions
1161 int Format; // OpenGL pixel format
1162 int BytesPerPixel; // Number of bytes per pixel
1163 unsigned char *Data; // Pointer to pixel data
1166 Width and Height give the dimensions of the image. Format specifies an OpenGL pixel format,
1167 which can be GL_LUMINANCE or GL_ALPHA (for gray scale images), GL_RGB or GL_RGBA.
1168 BytesPerPixel specifies the number of bytes per pixel. Data is a pointer to the actual pixel data.
1170 By default the read image is rescaled to the nearest larger 2m ? 2n resolution using bilinear
1171 interpolation, if necessary, which is useful if the image is to be used as an OpenGL texture. This
1172 behavior can be disabled by setting the GLFW_NO_RESCALE_BIT flag.
1173 Unless the flag GLFW_ORIGIN_UL_BIT is set, the first pixel in img->Data is the lower left corner of
1174 the image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left corner.
1175 For single component images (i.e. gray scale), Format is set to GL_ALPHA if the flag
1176 +ALPHA_MAP_BIT+ flag is set, otherwise Format is set to GL_LUMINANCE.
1178 glfw::ReadMemoryImage supports the Truevision Targa version 1 file format (.TGA). Supported pixel
1179 formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color +
1181 Paletted images are translated into true color or true color + alpha pixel formats.
1182 Please note that OpenGL 1.0 does not support single component alpha maps, so do not use images
1183 with Format = GL_ALPHA directly as textures under OpenGL 1.0.
1186 (defcfun+doc
("glfwFreeImage" free-image
) :void
((img image
))
1189 Pointer to a GLFWimage struct.
1191 The function frees any memory occupied by a loaded image, and clears all the fields of the GLFWimage
1192 struct. Any image that has been loaded by the glfw::ReadImage function should be deallocated using
1193 this function, once the image is not needed anymore. ")
1195 (defcfun+doc
("glfwLoadTexture2D" load-texture-2d
) boolean
((name :string
) (flags :int
))
1198 An ISO 8859-1 string holding the name of the file that should be loaded.
1200 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1202 The function returns t if the texture was loaded successfully. Otherwise nil is
1207 The function reads an image from the file specified by the parameter
1208 name and uploads the image to OpenGL texture memory (using the
1209 glTexImage2D function). If the GLFW_BUILD_MIPMAPS_BIT flag is set,
1210 all mipmap levels for the loaded texture are generated and uploaded to
1211 texture memory. Unless the flag +ORIGIN_UL_BIT+ is set, the origin of
1212 the texture is the lower left corner of the loaded image. If the flag
1213 +ORIGIN_UL_BIT+ is set, however, the first pixel is the upper left
1214 corner. For single component images (i.e. gray scale), the texture is
1215 uploaded as an alpha mask if the flag +ALPHA_MAP_BIT+ flag is set,
1216 otherwise it is uploaded as a luminance texture.
1219 glfw::LoadTexture2D supports the Truevision Targa version 1 file format (.TGA). Supported pixel
1220 formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color +
1222 Paletted images are translated into true color or true color + alpha pixel formats.
1223 The read texture is always rescaled to the nearest larger 2m ? 2n resolution using bilinear interpolation,
1224 if necessary, since OpenGL requires textures to have a 2m ? 2n resolution.
1225 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1226 the OpenGL implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1227 generated by GLFW in software.
1229 Since OpenGL 1.0 does not support single component alpha maps, alpha map textures are converted
1230 to RGBA format under OpenGL 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1231 texture is a single component texture. The red, green and blue components are set to 1.0.
1234 (defcfun+doc
("glfwLoadMemoryTexture2D" load-memory-texture-2d
) boolean
1235 ((data :pointer
) (size :long
) (flags :int
))
1238 The memory buffer holding the contents of the file that should be loaded.
1240 The size, in bytes, of the memory buffer.
1242 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1244 The function returns t if the texture was loaded successfully. Otherwise nil is
1248 The function reads an image from the memory buffer specified by the parameter data and uploads the
1249 image to OpenGL texture memory (using the glTexImage2D function).
1250 If the GLFW_BUILD_MIPMAPS_BIT flag is set, all mipmap levels for the loaded texture are
1251 generated and uploaded to texture memory.
1252 Unless the flag +ORIGIN_UL_BIT+ is set, the origin of the texture is the lower left corner of the
1253 loaded image. If the flag +ORIGIN_UL_BIT+ is set, however, the first pixel is the upper left
1255 For single component images (i.e. gray scale), the texture is uploaded as an alpha mask if the flag
1256 +ALPHA_MAP_BIT+ flag is set, otherwise it is uploaded as a luminance texture.
1259 glfw::LoadMemoryTexture2D supports the Truevision Targa version 1 file format (.TGA). Supported
1260 pixel formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color
1262 Paletted images are translated into true color or true color + alpha pixel formats.
1263 The read texture is always rescaled to the nearest larger 2m ? 2n resolution using bilinear interpolation,
1264 if necessary, since OpenGL requires textures to have a 2m ? 2n resolution.
1265 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1266 the OpenGL implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1267 generated by GLFW in software.
1269 Since OpenGL 1.0 does not support single component alpha maps, alpha map textures are converted
1270 to RGBA format under OpenGL 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1271 texture is a single component texture. The red, green and blue components are set to 1.0.
1275 (defcfun+doc
("glfwLoadTextureImage2D" load-texture-image-2d
) boolean
((img image
)
1279 Pointer to a GLFWimage struct holding the information about the image to be loaded.
1281 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1283 The function returns t if the texture was loaded successfully. Otherwise nil is
1287 The function uploads the image specified by the parameter img to OpenGL texture memory (using
1288 the glTexImage2D function).
1289 If the +BUILD_MIPMAPS_BIT+ flag is set, all mipmap levels for the loaded texture are
1290 generated and uploaded to texture memory.
1291 Unless the flag +ORIGIN_UL_BIT+ is set, the origin of the texture is the lower left corner of the
1292 loaded image. If the flag +ORIGIN_UL_BIT+ is set, however, the first pixel is the upper left
1294 For single component images (i.e. gray scale), the texture is uploaded as an alpha mask if the flag
1295 +ALPHA_MAP_BIT+ flag is set, otherwise it is uploaded as a luminance texture.
1298 glfw::LoadTextureImage2D supports the Truevision Targa version 1 file format (.TGA). Supported
1299 pixel formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color
1301 Paletted images are translated into true color or true color + alpha pixel formats.
1302 The read texture is always rescaled to the nearest larger 2m ? 2n resolution using bilinear interpolation,
1303 if necessary, since OpenGL requires textures to have a 2m ? 2n resolution.
1304 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1305 the OpenGL implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1306 generated by GLFW in software.
1308 Since OpenGL 1.0 does not support single component alpha maps, alpha map textures are converted
1309 to RGBA format under OpenGL 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1310 texture is a single component texture. The red, green and blue components are set to 1.0. ")
1313 (defcfun+doc
("glfwExtensionSupported" extension-supported
) boolean
((extension :string
))
1316 A null terminated ISO 8859-1 string containing the name of an OpenGL extension.
1318 The function returns t if the extension is supported. Otherwise it returns nil.
1320 The function does a string search in the list of supported OpenGL extensions to find if the specified
1321 extension is listed.
1324 An OpenGL context must be created before this function can be called (i.e. an OpenGL window
1325 must have been opened with glfwOpenWindow).
1326 In addition to checking for OpenGL extensions, GLFW also checks for extensions in the operating
1327 system ?glue API?, such as WGL extensions under Windows and glX extensions under the X Window
1331 (defcfun+doc
("glfwGetProcAddress" get-proc-address
) :pointer
((procname :string
))
1334 A null terminated ISO 8859-1 string containing the name of an OpenGL extension function.
1336 The function returns the pointer to the specified OpenGL function if it is supported, otherwise
1339 The function acquires the pointer to an OpenGL extension function. Some (but not all) OpenGL
1340 extensions define new API functions, which are usually not available through normal linking. It is
1341 therefore necessary to get access to those API functions at runtime.
1344 An OpenGL context must be created before this function can be called (i.e. an OpenGL window
1345 must have been opened with glfwOpenWindow).
1346 Some systems do not support dynamic function pointer retrieval, in which case glfwGetProcAddress
1347 will always return NULL.
1350 (defcfun+out
+doc
("glfwGetGLVersion" get-gl-version
) :void
((:out major
:int
)
1354 The function returns the major and minor version numbers and the revision for the currently used
1355 OpenGL implementation as a list (major minor rev).
1358 The function returns the OpenGL implementation version. This is a convenient function that parses
1359 the version number information from the string returned by calling
1360 glGetString( GL_VERSION ). The OpenGL version information can be used to determine
1361 what functionality is supported by the used OpenGL implementation.
1364 An OpenGL context must be created before this function can be called (i.e. an OpenGL window
1365 must have been opened with glfwOpenWindow). ")
1367 (defctype thread
:int
)
1368 (defctype threadfun
:pointer
)
1369 (defctype mutex
:pointer
)
1370 (defctype cond
:pointer
)
1372 (defcfun+doc
("glfwCreateThread" create-thread
) thread
((fun threadfun
) (arg :pointer
) )
1375 A pointer to a function that acts as the entry point for the new thread. The function should have
1376 the following C language prototype:
1377 void GLFWCALL functionname( void *arg );
1378 Where functionname is the name of the thread function, and arg is the user supplied argument
1381 An arbitrary argument for the thread. arg will be passed as the argument to the thread function
1382 pointed to by fun. For instance, arg can point to data that is to be processed by the thread.
1384 The function returns a thread identification number if the thread was created successfully. This number
1385 is always positive. If the function fails, a negative number is returned.
1387 The function creates a new thread, which executes within the same address space as the calling process.
1388 The thread entry point is specified with the fun argument.
1389 Once the thread function fun returns, the thread dies.
1391 Even if the function returns a positive thread ID, indicating that the thread was created successfully, the
1392 thread may be unable to execute, for instance if the thread start address is not a valid thread entry point.
1394 (defcfun+doc
("glfwDestroyThread" destroy-thread
) :void
((id thread
))
1397 A thread identification handle, which is returned by glfw::CreateThread or glfw::GetThreadID.
1399 The function kills a running thread and removes it from the thread list.
1401 This function is a very dangerous operation, which may interrupt a thread in the middle of an important
1402 operation, and its use is discouraged. You should always try to end a thread in a graceful way using
1403 thread communication, and use glfw::WaitThread in order to wait for the thread to die.
1405 (defcfun+doc
("glfwWaitThread" wait-thread
) boolean
((id thread
) (waitmode :int
) )
1408 A thread identification handle, which is returned by glfw::CreateThread or glfw::GetThreadID.
1410 Can be either +WAIT+ or +NOWAIT+
1412 The function returns t if the specified thread died after the function was called, or the thread
1413 did not exist, in which case glfw::WaitThread will return immediately regardless of waitmode. The
1414 function returns nil if waitmode is +NOWAIT+ and the specified thread exists and is still
1417 (defcfun+doc
("glfwGetThreadID" get-thread-id
) thread
()
1419 The function returns a thread identification handle for the calling thread.
1421 The function determines the thread ID for the calling thread. The ID is the same value as was returned
1422 by glfw::CreateThread when the thread was created.
1425 (defcfun+doc
("glfwCreateMutex" create-mutex
) mutex
()
1427 The function returns a mutex handle, or NULL if the mutex could not be created.
1429 The function creates a mutex object, which can be used to control access to data that is shared between
1432 (defcfun+doc
("glfwDestroyMutex" destroy-mutex
) :void
((mutex mutex
))
1435 A mutex object handle.
1437 The function destroys a mutex object. After a mutex object has been destroyed, it may no longer be
1440 (defcfun+doc
("glfwLockMutex" lock-mutex
) :void
((mutex mutex
))
1443 A mutex object handle.
1445 The function will acquire a lock on the selected mutex object. If the mutex is already locked by another
1446 thread, the function will block the calling thread until it is released by the locking thread. Once the
1447 function returns, the calling thread has an exclusive lock on the mutex. To release the mutex, call
1450 (defcfun+doc
("glfwUnlockMutex" unlock-mutex
) :void
((mutex mutex
))
1453 A mutex object handle.
1455 The function releases the lock of a locked mutex object.
1458 (defmacro with-lock-mutex
(mutex &body forms
)
1461 A mutex object handle.
1463 Body of code to execute
1465 This macro will acquire a lock on the selected mutex object using glfw::LockMutex and release it afterwards
1466 using glfw::UnlockMutex.
1467 So, forms will not execute until an exclusive lock is held.
1468 The lock is then released when the stack is unwound."
1469 (let ((smutex (gensym "MUTEX-")))
1470 `(let ((,smutex
,mutex
))
1471 (glfw:lock-mutex
,smutex
)
1472 (unwind-protect (progn ,@forms
)
1473 (glfw:unlock-mutex
,smutex
)))))
1475 (defcfun+doc
("glfwCreateCond" create-cond
) cond
()
1477 The function returns a condition variable handle, or NULL if the condition variable could not be
1480 The function creates a condition variable object, which can be used to synchronize threads.
1482 (defcfun+doc
("glfwDestroyCond" destroy-cond
) :void
((cond cond
))
1485 A condition variable object handle.
1487 The function destroys a condition variable object. After a condition variable object has been destroyed,
1488 it may no longer be used by any thread.
1490 (defcfun+doc
("glfwWaitCond" wait-cond
) :void
((cond cond
) (mutex mutex
) (timeout :double
))
1493 A condition variable object handle.
1495 A mutex object handle.
1497 Maximum time to wait for the condition variable. The parameter can either be a positive time (in
1498 seconds), or +INFINITY+
1500 The function atomically unlocks the mutex specified by mutex, and waits for the condition variable cond
1501 to be signaled. The thread execution is suspended and does not consume any CPU time until the
1502 condition variable is signaled or the amount of time specified by timeout has passed. If timeout is
1503 +INFINITY+ glfw::WaitCond will wait forever for cond to be signaled. Before returning to the
1504 calling thread, glfw::WaitCond automatically re-acquires the mutex.
1506 The mutex specified by mutex must be locked by the calling thread before entrance to glfw::WaitCond.
1507 A condition variable must always be associated with a mutex, to avoid the race condition where a thread
1508 prepares to wait on a condition variable and another thread signals the condition just before the first
1509 thread actually waits on it.
1511 (defcfun+doc
("glfwSignalCond" signal-cond
) :void
((cond cond
))
1514 A condition variable object handle.
1516 The function restarts one of the threads that are waiting on the condition variable cond. If no threads are
1517 waiting on cond, nothing happens. If several threads are waiting on cond, exactly one is restarted, but it
1518 is not specified which.
1520 When several threads are waiting for the condition variable, which thread is started depends on
1521 operating system scheduling rules, and may vary from system to system and from time to time.
1523 (defcfun+doc
("glfwBroadcastCond" broadcast-cond
) :void
((cond cond
))
1526 A condition variable object handle.
1528 The function restarts all the threads that are waiting on the condition variable cond. If no threads are
1529 waiting on cond, nothing happens.
1531 When several threads are waiting for the condition variable, the order in which threads are started
1532 depends on operating system scheduling rules, and may vary from system to system and from time to
1536 (defcfun+doc
("glfwGetNumberOfProcessors" get-number-of-processors
) :int
()
1538 The function returns the number of active processors in the system.
1540 The function determines the number of active processors in the system.
1542 Systems with several logical processors per physical processor, also known as SMT (Symmetric Multi
1543 Threading) processors, will report the number of logical processors.
1545 (defcfun+doc
("glfwEnable" enable
) :void
((token :int
))
1548 A value specifying a feature to enable or disable. Valid tokens are listed in table 3.8.
1552 glfw::Enable is used to enable a certain feature, while glfw::Disable is used to disable it. Below follows a
1553 description of each feature.
1555 When +AUTO_POLL_EVENTS+ is enabled, glfw::PollEvents is automatically called each time
1556 that glfw::SwapBuffers is called.
1557 When +AUTO_POLL_EVENTS+ is disabled, calling glfw::SwapBuffers will not result in a call to
1558 glfw::PollEvents. This can be useful if glfw::SwapBuffers needs to be called from within a callback
1559 function, since calling glfw::PollEvents from a callback function is not allowed.
1561 When +KEY_REPEAT+ is enabled, the key and character callback functions are called repeatedly
1562 when a key is held down long enough (according to the system key repeat configuration).
1563 When +KEY_REPEAT+ is disabled, the key and character callback functions are only called once
1564 when a key is pressed (and once when it is released).
1566 When +MOUSE_CURSOR+ is enabled, the mouse cursor is visible, and mouse coordinates are
1567 relative to the upper left corner of the client area of the GLFW window. The coordinates are limited to
1568 the client area of the window.
1569 When +MOUSE_CURSOR+ is disabled, the mouse cursor is invisible, and mouse coordinates are
1570 not limited to the drawing area of the window. It is as if the mouse coordinates are recieved directly
1571 from the mouse, without being restricted or manipulated by the windowing system.
1573 When +STICKY_KEYS+ is enabled, keys which are pressed will not be released until they are
1574 physically released and checked with glfw::GetKey. This behavior makes it possible to catch keys that
1575 were pressed and then released again between two calls to glfw::PollEvents, glfw::WaitEvents or
1576 glfw::SwapBuffers, which would otherwise have been reported as released. Care should be taken when
1577 using this mode, since keys that are not checked with glfw::GetKey will never be released. Note also that
1578 enabling +STICKY_KEYS+ does not affect the behavior of the keyboard callback functionality.
1579 When +STICKY_KEYS+ is disabled, the status of a key that is reported by glfw::GetKey is always
1580 the physical state of the key. Disabling +STICKY_KEYS+ also clears the sticky information for
1582 +STICKY_MOUSE_BUTTONS+
1583 When +STICKY_MOUSE_BUTTONS+ is enabled, mouse buttons that are pressed will not be
1584 released until they are physically released and checked with glfw::GetMouseButton. This behavior
1585 makes it possible to catch mouse buttons which were pressed and then released again between two calls
1586 to glfw::PollEvents, glfw::WaitEvents or glfw::SwapBuffers, which would otherwise have been reported
1587 as released. Care should be taken when using this mode, since mouse buttons that are not checked with
1588 glfw::GetMouseButton will never be released. Note also that enabling
1589 +STICKY_MOUSE_BUTTONS+ does not affect the behavior of the mouse button callback
1591 When +STICKY_MOUSE_BUTTONS+ is disabled, the status of a mouse button that is reported
1592 by glfw::GetMouseButton is always the physical state of the mouse button. Disabling
1593 +STICKY_MOUSE_BUTTONS+ also clears the sticky information for all mouse buttons.
1595 When +SYSTEM_KEYS+ is enabled, pressing standard system key combinations, such as
1596 ALT+TAB under Windows, will give the normal behavior. Note that when ALT+TAB is issued under
1597 Windows in this mode so that the GLFW application is deselected when GLFW is operating in
1598 fullscreen mode, the GLFW application window will be minimized and the video mode will be set to
1599 the original desktop mode. When the GLFW application is re-selected, the video mode will be set to
1600 the GLFW video mode again.
1601 When +SYSTEM_KEYS+ is disabled, pressing standard system key combinations will have no
1602 effect, since those key combinations are blocked by GLFW. This mode can be useful in situations when
1603 the GLFW program must not be interrupted (normally for games in fullscreen mode).
1605 (defcfun+doc
("glfwDisable" disable
) :void
((token :int
))
1608 A value specifying a feature to enable or disable. Valid tokens are listed in table 3.8.
1612 glfw::Enable is used to enable a certain feature, while glfw::Disable is used to disable it. Below follows a
1613 description of each feature.
1615 When +AUTO_POLL_EVENTS+ is enabled, glfw::PollEvents is automatically called each time
1616 that glfw::SwapBuffers is called.
1617 When +AUTO_POLL_EVENTS+ is disabled, calling glfw::SwapBuffers will not result in a call to
1618 glfw::PollEvents. This can be useful if glfw::SwapBuffers needs to be called from within a callback
1619 function, since calling glfw::PollEvents from a callback function is not allowed.
1621 When +KEY_REPEAT+ is enabled, the key and character callback functions are called repeatedly
1622 when a key is held down long enough (according to the system key repeat configuration).
1623 When +KEY_REPEAT+ is disabled, the key and character callback functions are only called once
1624 when a key is pressed (and once when it is released).
1626 When +MOUSE_CURSOR+ is enabled, the mouse cursor is visible, and mouse coordinates are
1627 relative to the upper left corner of the client area of the GLFW window. The coordinates are limited to
1628 the client area of the window.
1629 When +MOUSE_CURSOR+ is disabled, the mouse cursor is invisible, and mouse coordinates are
1630 not limited to the drawing area of the window. It is as if the mouse coordinates are recieved directly
1631 from the mouse, without being restricted or manipulated by the windowing system.
1633 When +STICKY_KEYS+ is enabled, keys which are pressed will not be released until they are
1634 physically released and checked with glfw::GetKey. This behavior makes it possible to catch keys that
1635 were pressed and then released again between two calls to glfw::PollEvents, glfw::WaitEvents or
1636 glfw::SwapBuffers, which would otherwise have been reported as released. Care should be taken when
1637 using this mode, since keys that are not checked with glfw::GetKey will never be released. Note also that
1638 enabling +STICKY_KEYS+ does not affect the behavior of the keyboard callback functionality.
1639 When +STICKY_KEYS+ is disabled, the status of a key that is reported by glfwGetKey is always
1640 the physical state of the key. Disabling +STICKY_KEYS+ also clears the sticky information for
1642 +STICKY_MOUSE_BUTTONS+
1643 When +STICKY_MOUSE_BUTTONS+ is enabled, mouse buttons that are pressed will not be
1644 released until they are physically released and checked with glfw::GetMouseButton. This behavior
1645 makes it possible to catch mouse buttons which were pressed and then released again between two calls
1646 to glfw::PollEvents, glfw::WaitEvents or glfw::SwapBuffers, which would otherwise have been reported
1647 as released. Care should be taken when using this mode, since mouse buttons that are not checked with
1648 glfw::GetMouseButton will never be released. Note also that enabling
1649 +STICKY_MOUSE_BUTTONS+ does not affect the behavior of the mouse button callback
1651 When +STICKY_MOUSE_BUTTONS+ is disabled, the status of a mouse button that is reported
1652 by glfwGetMouseButton is always the physical state of the mouse button. Disabling
1653 +STICKY_MOUSE_BUTTONS+ also clears the sticky information for all mouse buttons.
1655 When +SYSTEM_KEYS+ is enabled, pressing standard system key combinations, such as
1656 ALT+TAB under Windows, will give the normal behavior. Note that when ALT+TAB is issued under
1657 Windows in this mode so that the GLFW application is deselected when GLFW is operating in
1658 fullscreen mode, the GLFW application window will be minimized and the video mode will be set to
1659 the original desktop mode. When the GLFW application is re-selected, the video mode will be set to
1660 the GLFW video mode again.
1661 When +SYSTEM_KEYS+ is disabled, pressing standard system key combinations will have no
1662 effect, since those key combinations are blocked by GLFW. This mode can be useful in situations when
1663 the GLFW program must not be interrupted (normally for games in fullscreen mode).