| blob | 8405571372974326ff87dcfa1f7a71c2c1dcd69b |
7 #:cond
9 (:export
10 #:+accelerated+ #:+accum-alpha-bits+ #:+accum-blue-bits+ #:+accum-green-bits+ #:+accum-red-bits+ #:+active+ #:+alpha-bits+ #:+alpha-map-bit+ #:+auto-poll-events+ #:+aux-buffers+ #:+axes+ #:+blue-bits+ #:+build-mipmaps-bit+ #:+buttons+ #:+depth-bits+ #:+fsaa-samples+ #:+fullscreen+ #:+green-bits+ #:+iconified+ #:+infinity+ #:+joystick-1+ #:+joystick-10+ #:+joystick-11+ #:+joystick-12+ #:+joystick-13+ #:+joystick-14+ #:+joystick-15+ #:+joystick-16+ #:+joystick-2+ #:+joystick-3+ #:+joystick-4+ #:+joystick-5+ #:+joystick-6+ #:+joystick-7+ #:+joystick-8+ #:+joystick-9+ #:+joystick-last+ #:+key-backspace+ #:+key-del+ #:+key-down+ #:+key-end+ #:+key-enter+ #:+key-esc+ #:+key-f1+ #:+key-f10+ #:+key-f11+ #:+key-f12+ #:+key-f13+ #:+key-f14+ #:+key-f15+ #:+key-f16+ #:+key-f17+ #:+key-f18+ #:+key-f19+ #:+key-f2+ #:+key-f20+ #:+key-f21+ #:+key-f22+ #:+key-f23+ #:+key-f24+ #:+key-f25+ #:+key-f3+ #:+key-f4+ #:+key-f5+ #:+key-f6+ #:+key-f7+ #:+key-f8+ #:+key-f9+ #:+key-home+ #:+key-insert+ #:+key-kp-0+ #:+key-kp-1+ #:+key-kp-2+ #:+key-kp-3+ #:+key-kp-4+ #:+key-kp-5+ #:+key-kp-6+ #:+key-kp-7+ #:+key-kp-8+ #:+key-kp-9+ #:+key-kp-add+ #:+key-kp-decimal+ #:+key-kp-divide+ #:+key-kp-enter+ #:+key-kp-equal+ #:+key-kp-multiply+ #:+key-kp-subtract+ #:+key-lalt+ #:+key-last+ #:+key-lctrl+ #:+key-left+ #:+key-lshift+ #:+key-pagedown+ #:+key-pageup+ #:+key-ralt+ #:+key-rctrl+ #:+key-repeat+ #:+key-right+ #:+key-rshift+ #:+key-space+ #:+key-special+ #:+key-tab+ #:+key-unknown+ #:+key-up+ #:+mouse-button-1+ #:+mouse-button-2+ #:+mouse-button-3+ #:+mouse-button-4+ #:+mouse-button-5+ #:+mouse-button-6+ #:+mouse-button-7+ #:+mouse-button-8+ #:+mouse-button-last+ #:+mouse-button-left+ #:+mouse-button-middle+ #:+mouse-button-right+ #:+mouse-cursor+ #:+no-rescale-bit+ #:+nowait+ #:+opened+ #:+origin-ul-bit+ #:+present+ #:+press+ #:+red-bits+ #:+refresh-rate+ #:+release+ #:+stencil-bits+ #:+stereo+ #:+sticky-keys+ #:+sticky-mouse-buttons+ #:+system-keys+ #:+wait+ #:+window+ #:+window-no-resize+ #:broadcast-cond #:close-window #:create-cond #:create-mutex #:create-thread #:defcfun+doc #:defcfun+out+doc #:destroy-cond #:destroy-mutex #:destroy-thread #:disable #:enable #:extension-supported #:free-image #:get-desktop-mode #:get-gl-version #:get-joystick-buttons #:get-joystick-param #:get-joystick-pos #:get-key #:get-mouse-button #:get-mouse-pos #:get-mouse-wheel #:get-number-of-processors #:get-proc-address #:get-thread-id #:get-time #:get-version #:get-video-modes #:get-window-param #:get-window-size #:iconify-window #:init #:load-memory-texture-2d #:load-texture-2d #:load-texture-image-2d #:lock-mutex #:open-window #:open-window-hint #:poll-events #:read-image #:read-memory-image #:restore-window #:set-char-callback #:set-key-callback #:set-mouse-button-callback #:set-mouse-pos #:set-mouse-pos-callback #:set-mouse-wheel #:set-mouse-wheel-callback #:set-time #:set-window-close-callback #:set-window-pos #:set-window-refresh-callback #:set-window-size #:set-window-size-callback #:set-window-title #:signal-cond #:sleep #:swap-buffers #:swap-interval #:terminate #:unlock-mutex #:wait-cond #:wait-events #:wait-thread
11 ))
21 |#
34 args)))
37 args))))
44 args))
46 ,docstring
51 out-args)))))))
59 ;; Key and button state/action definitions
63 ;; Keyboard key definitions: 8-bit ISO-8859-1 (Latin 1) encoding is used
64 ;; for printable keys (such as A-Z, 0-9 etc), and values above 256
65 ;; represent special (non-printable) keys (e.g. F1, Page Up etc).
133 ;; Mouse button definitions
144 ;; Mouse button aliases
149 ;; Joystick identifiers
169 ;;========================================================================
170 ;; Other definitions
171 ;;========================================================================
173 ;; glfwOpenWindow modes
177 ;; glfwGetWindowParam tokens
189 ;; The following constants are used for both glfwGetWindowParam
190 ;; and glfwOpenWindowHint
201 ;; glfwEnable/glfwDisable tokens
209 ;; glfwWaitThread wait modes
213 ;; glfwGetJoystickParam tokens
218 ;; glfwReadImage/glfwLoadTexture2D flags
224 ;; Time spans longer than this (seconds) are considered to be infinity
227 ;; (declaim (ftype (function () (member gl:+true+ gl:+false+)) init))
229 "Return values
230 If the function succeeds, GL_TRUE is returned.
231 If the function fails, GL_FALSE is returned.
233 The glfwInit function initializes GLFW. No other GLFW functions may be used before this function
234 has been called.
236 Notes
237 This function may take several seconds to complete on some systems, while on other systems it may
241 "The function terminates GLFW. Among other things it closes the window, if it is opened, and kills any
247 "Return values
248 The function returns the major and minor version numbers and the revision for the currently linked
252 ;; (declaim (ftype (function () (member gl:+true+ gl:+false+)) open-window))
257 "width
258 The width of the window. If width is zero, it will be calculated as width = 4 height, if height is
259 3
260 not zero. If both width and height are zero, then width will be set to 640.
261 height
262 3
263 The height of the window. If height is zero, it will be calculated as height = 4 width, if width is
264 not zero. If both width and height are zero, then height will be set to 480.
265 redbits, greenbits, bluebits
266 The number of bits to use for each color component of the color buffer (0 means default color
267 depth). For instance, setting redbits=5, greenbits=6, and bluebits=5 will generate a 16-bit color
268 buffer, if possible.
269 alphabits
270 The number of bits to use for the alpha buffer (0 means no alpha buffer).
271 depthbits
272 The number of bits to use for the depth buffer (0 means no depth buffer).
273 stencilbits
274 The number of bits to use for the stencil buffer (0 means no stencil buffer).
275 mode
276 Selects which type of OpenGL™ window to use. mode can be either GLFW_WINDOW, which
277 will generate a normal desktop window, or GLFW_FULLSCREEN, which will generate a
278 window which covers the entire screen. When GLFW_FULLSCREEN is selected, the video
279 mode will be changed to the resolution that closest matches the width and height parameters.
281 Return values
282 If the function succeeds, GL_TRUE is returned.
283 If the function fails, GL_FALSE is returned.
285 Description
286 The function opens a window that best matches the parameters given to the function. How well the
287 resulting window matches the desired window depends mostly on the available hardware and
288 OpenGL™ drivers. In general, selecting a fullscreen mode has better chances of generating a close
289 match than does a normal desktop window, since GLFW can freely select from all the available video
290 modes. A desktop window is normally restricted to the video mode of the desktop.
292 Notes
293 For additional control of window properties, see glfwOpenWindowHint.
294 In fullscreen mode the mouse cursor is hidden by default, and any system screensavers are prohibited
295 from starting. In windowed mode the mouse cursor is visible, and screensavers are allowed to start. To
296 change the visibility of the mouse cursor, use glfwEnable or glfwDisable with the argument
297 GLFW_MOUSE-CURSOR.
298 In order to determine the actual properties of an opened window, use glfwGetWindowParam and
299 glfwGetWindowSize (or glfwSetWindowSizeCallback).
303 "target
304 Can be any of the constants in the table 3.1.
305 hint
306 An integer giving the value of the corresponding target (see table 3.1).
308 Description
309 The function sets additional properties for a window that is to be opened. For a hint to be registered, the
310 function must be called before calling glfwOpenWindow. When the glfwOpenWindow function is
311 called, any hints that were registered with the glfwOpenWindowHint function are used for setting the
312 corresponding window properties, and then all hints are reset to their default values.
314 Notes
315 In order to determine the actual properties of an opened window, use glfwGetWindowParam (after the
316 window has been opened).
317 GLFW_STEREO is a hard constraint. If stereo rendering is requested, but no stereo rendering capable
318 pixel formats / visuals are available, glfwOpenWindow will fail.
319 The GLFW_REFRESH-RATE property should be used with caution. Most systems have default values
320 for monitor refresh rates that are optimal for the specific system. Specifying the refresh rate can
321 override these settings, which can result in suboptimal operation. The monitor may be unable to display
322 the resulting video signal, or in the worst case it may even be damaged!
329 "Parameters
330 cbfun
331 Pointer to a callback function that will be called when a user requests that the window should be
332 closed, typically by clicking the window close icon (e.g. the cross in the upper right corner of a
333 window under Microsoft Windows). The function should have the following C language
334 prototype:
335 int GLFWCALL functionname( void );
336 Where functionname is the name of the callback function. The return value of the callback
337 function indicates wether or not the window close action should continue. If the function returns
338 GL_TRUE, the window will be closed. If the function returns GL_FALSE, the window will not
339 be closed.
340 If cbfun is NULL, any previously selected callback function will be deselected.
342 Description
343 The function selects which function to be called upon a window close event.
344 A window has to be opened for this function to have any effect.
346 Notes
347 Window close events are recorded continuously, but only reported when glfwPollEvents,
348 glfwWaitEvents or glfwSwapBuffers is called.
349 The OpenGL™ context is still valid when this function is called.
350 Note that the window close callback function is not called when glfwCloseWindow is called, but only
351 when the close request comes from the window manager.
352 Do not call glfwCloseWindow from a window close callback function. Close the window by returning
353 GL_TRUE from the function.
357 "Parameters
358 title
359 Pointer to a null terminated ISO 8859-1 (8-bit Latin 1) string that holds the title of the window.
361 Description
362 The function changes the title of the opened window.
364 Notes
365 The title property of a window is often used in situations other than for the window title, such as the title
369 "Parameters
370 width
371 Width of the window.
372 height
373 Height of the window.
374 Return values
375 none
376 Description
377 The function changes the size of an opened window. The width and height parameters denote the size of
378 the client area of the window (i.e. excluding any window borders and decorations).
379 If the window is in fullscreen mode, the video mode will be changed to a resolution that closest matches
380 the width and height parameters (the number of color bits will not be changed).
381 Notes
382 The OpenGL™ context is guaranteed to be preserved after calling glfwSetWindowSize, even if the
383 video mode is changed.
387 "Parameters
388 x
389 Horizontal position of the window, relative to the upper left corner of the desktop.
390 y
391 Vertical position of the window, relative to the upper left corner of the desktop.
392 Return values
393 none
394 Description
395 The function changes the position of an opened window. It does not have any effect on a fullscreen
396 window.
401 "The function is used for determining the size of an opened window. The returned values are dimensions
402 of the client area of the window (i.e. excluding any window borders and decorations).
403 (list width height)"
411 "Parameters
412 cbfun
413 Pointer to a callback function that will be called every time the window size changes. The
414 function should have the following C language prototype:
415 void GLFWCALL functionname( int width, int height );
416 Where functionname is the name of the callback function, and width and height are the
417 dimensions of the window client area.
418 If cbfun is NULL, any previously selected callback function will be deselected.
419 Return values
420 none
421 Description
422 The function selects which function to be called upon a window size change event.
423 A window has to be opened for this function to have any effect.
424 Notes
425 Window size changes are recorded continuously, but only reported when glfwPollEvents,
429 "Iconify a window. If the window is in fullscreen mode, then the desktop video mode will be restored.")
432 "Restore an iconified window. If the window that is restored is in fullscreen mode, then the fullscreen
436 "Parameters
437 param
438 A token selecting which parameter the function should return (see table 3.2).
440 Return values
441 The function returns different parameters depending on the value of param. Table 3.2 lists valid param
442 values, and their corresponding return values.
444 Description
445 The function is used for acquiring various properties of an opened window.
447 Notes
448 GLFW_ACCELERATED is only supported under Windows. Other systems will always return
449 GL_TRUE. Under Windows, GLFW_ACCELERATED means that the OpenGL™ renderer is a 3rd
450 party renderer, rather than the fallback Microsoft software OpenGL™ renderer. In other words, it is
451 not a real guarantee that the OpenGL™ renderer is actually hardware accelerated.
455 "The function swaps the back and front color buffers of the window. If GLFW_AUTO-POLL-EVENTS
456 is enabled (which is the default), glfwPollEvents is called before swapping the front and back buffers.")
460 "Parameters
461 interval
462 Minimum number of monitor vertical retraces between each buffer swap performed by
463 glfwSwapBuffers. If interval is zero, buffer swaps will not be synchronized to the vertical
464 refresh of the monitor (also known as ’VSync off’).
466 Description
467 The function selects the minimum number of monitor vertical retraces that should occur between two
468 buffer swaps. If the selected swap interval is one, the rate of buffer swaps will never be higher than the
469 vertical refresh rate of the monitor. If the selected swap interval is zero, the rate of buffer swaps is only
470 limited by the speed of the software and the hardware.
472 Notes
473 This function will only have an effect on hardware and drivers that support user selection of the swap
477 (defcfun+doc ("glfwSetWindowRefreshCallback" set-window-refresh-callback) :void ((cbfun :pointer))
478 "Parameters
479 cbfun
480 Pointer to a callback function that will be called when the window client area needs to be
481 refreshed. The function should have the following C language prototype:
482 void GLFWCALL functionname( void );
483 Where functionname is the name of the callback function.
484 If cbfun is NULL, any previously selected callback function will be deselected.
486 Description
487 The function selects which function to be called upon a window refresh event, which occurs when any
488 part of the window client area has been damaged, and needs to be repainted (for instance, if a part of the
489 window that was previously occluded by another window has become visible).
490 A window has to be opened for this function to have any effect.
492 Notes
493 Window refresh events are recorded continuously, but only reported when glfwPollEvents,
494 glfwWaitEvents or glfwSwapBuffers is called.
507 "Parameters
508 maxcount
509 Maximum number of video modes that list vector can hold.
511 Return values
512 The function returns the number of detected video modes (this number will never exceed maxcount).
513 The list vector is filled out with the video modes that are supported by the system.
515 Description
516 The function returns a list of supported video modes. Each video mode is represented by a
517 list of the form:
518 (width height redbits greenbits bluebits)
520 Notes
521 The returned list is sorted, first by color depth (RedBits + GreenBits + BlueBits), and then by
522 resolution (Width × Height), with the lowest resolution, fewest bits per pixel mode first. "
527 collecting
537 "Parameters
538 mode
539 Pointer to a GLFWvidmode structure, which will be filled out by the function.
540 Return values
541 The GLFWvidmode structure pointed to by mode is filled out with the desktop video mode.
542 Description
543 The function returns the desktop video mode in a GLFWvidmode structure. See glfwGetVideoModes
544 for a definition of the GLFWvidmode structure.
545 Notes
546 The color depth of the desktop display is always reported as the number of bits for each individual color
547 component (red, green and blue), even if the desktop is not using an RGB or RGBA color format. For
548 instance, an indexed 256 color display may report RedBits = 3, GreenBits = 3 and BlueBits = 2, which
549 adds up to 8 bits in total.
550 The desktop video mode is the video mode used by the desktop, not the current video mode (which may
551 differ from the desktop video mode if the GLFW window is a fullscreen window).
552 "
562 "Description
563 The function is used for polling for events, such as user input and window resize events. Upon calling
564 this function, all window states, keyboard states and mouse states are updated. If any related callback
565 functions are registered, these are called during the call to glfwPollEvents.
567 Notes
568 glfwPollEvents is called implicitly from glfwSwapBuffers if GLFW_AUTO_POLL_EVENTS is
569 enabled (default). Thus, if glfwSwapBuffers is called frequently, which is normally the case, there is
570 no need to call glfwPollEvents.
574 "Description
575 The function is used for waiting for events, such as user input and window resize events. Upon calling
576 this function, the calling thread will be put to sleep until any event appears in the event queue. When
577 events are ready, the events will be processed just as they are processed by glfwPollEvents.
578 If there are any events in the queue when the function is called, the function will behave exactly like
579 glfwPollEvents (i.e. process all messages and then return, without blocking the calling thread).
581 Notes
582 It is guaranteed that glfwWaitEvents will wake up on any event that can be processed by
583 glfwPollEvents. However, glfwWaitEvents may wake up on events that are not processed or reported
584 by glfwPollEvents too, and the function may behave differently on different systems. Do no make any
585 assumptions about when or why glfwWaitEvents will return.
589 "Parameters
590 key
591 A keyboard key identifier, which can be either an uppercase printable ISO 8859-1 (Latin 1)
592 character (e.g. 'A', '3' or '.'), or a special key identifier. Table 3.3 lists valid special key
593 identifiers.
594 Return values
595 The function returns GLFW_PRESS if the key is held down, or GLFW_RELEASE if the key is not
596 held down.
598 Description
599 The function queries the current state of a specific keyboard key. The physical location of each key
600 depends on the system keyboard layout setting.
602 Notes
603 The constant GLFW_KEY_SPACE is equal to 32, which is the ISO 8859-1 code for space.
604 Not all key codes are supported on all systems. Also, while some keys are available on some keyboard
605 layouts, they may not be available on other keyboard layouts.
606 For systems that do not distinguish between left and right versions of modifier keys (shift, alt and
607 control), the left version is used (e.g. GLFW_KEY_LSHIFT).
608 A window must be opened for the function to have any effect, and glfwPollEvents, glfwWaitEvents or
609 glfwSwapBuffers must be called before any keyboard events are recorded and reported by
610 glfwGetKey.
614 "Parameters
615 button
616 A mouse button identifier, which can be one of the mouse button identifiers listed in table 3.4.
617 Return values
618 The function returns GLFW_PRESS if the mouse button is held down, or GLFW_RELEASE if the
619 mouse button is not held down.
620 Description
621 The function queries the current state of a specific mouse button.
622 Notes
623 A window must be opened for the function to have any effect, and glfwPollEvents, glfwWaitEvents or
624 glfwSwapBuffers must be called before any mouse button events are recorded and reported by
625 glfwGetMouseButton.
626 GLFW_MOUSE_BUTTON_LEFT is equal to GLFW_MOUSE_BUTTON_1.
627 GLFW_MOUSE_BUTTON_RIGHT is equal to GLFW_MOUSE_BUTTON_2.
628 GLFW_MOUSE_BUTTON_MIDDLE is equal to GLFW_MOUSE_BUTTON_3.
633 "Return values
634 The function returns the current mouse position in xpos and ypos.
636 Description
637 The function returns the current mouse position. If the cursor is not hidden, the mouse position is the
638 cursor position, relative to the upper left corner of the window and limited to the client area of the
639 window. If the cursor is hidden, the mouse position is a virtual absolute position, not limited to any
640 boundaries except to those implied by the maximum number that can be represented by a signed integer
641 (normally -2147483648 to +2147483647).
643 Notes
644 A window must be opened for the function to have any effect, and glfwPollEvents, glfwWaitEvents or
645 glfwSwapBuffers must be called before any mouse movements are recorded and reported by
646 glfwGetMousePos.
651 "Parameters
652 xpos
653 Horizontal position of the mouse.
654 ypos
655 Vertical position of the mouse.
657 Description
658 The function changes the position of the mouse. If the cursor is visible (not disabled), the cursor will be
659 moved to the specified position, relative to the upper left corner of the window client area. If the cursor
660 is hidden (disabled), only the mouse position that is reported by GLFW is changed.
664 "Return values
665 The function returns the current mouse wheel position.
666 Description
667 The function returns the current mouse wheel position. The mouse wheel can be thought of as a third
668 mouse axis, which is available as a separate wheel or up/down stick on some mice.
669 Notes
670 A window must be opened for the function to have any effect, and glfwPollEvents, glfwWaitEvents or
671 glfwSwapBuffers must be called before any mouse wheel movements are recorded and reported by
672 glfwGetMouseWheel.
676 "Parameters
677 pos
678 Position of the mouse wheel.
679 Description
680 The function changes the position of the mouse wheel.
685 "Parameters
686 cbfun
687 Pointer to a callback function that will be called every time a key is pressed or released. The
688 function should have the following C language prototype:
689 void GLFWCALL functionname( int key, int action );
690 Where functionname is the name of the callback function, key is a key identifier, which is an
691 uppercase printable ISO 8859-1 character or a special key identifier (see table 3.3), and action is
692 either GLFW_PRESS or GLFW_RELEASE.
693 If cbfun is NULL, any previously selected callback function will be deselected.
694 Return values
695 none
696 Description
697 The function selects which function to be called upon a keyboard key event. The callback function is
698 called every time the state of a single key is changed (from released to pressed or vice versa). The
699 reported keys are unaffected by any modifiers (such as shift or alt).
700 A window has to be opened for this function to have any effect.
701 Notes
702 Keyboard events are recorded continuously, but only reported when glfwPollEvents, glfwWaitEvents
703 or glfwSwapBuffers is called.
706 "Parameters
707 cbfun
708 Pointer to a callback function that will be called every time a printable character is generated by
709 the keyboard. The function should have the following C language prototype:
710 void GLFWCALL functionname( int character, int action );
711 Where functionname is the name of the callback function, character is a Unicode (ISO 10646)
712 character, and action is either GLFW_PRESS or GLFW_RELEASE.
713 If cbfun is NULL, any previously selected callback function will be deselected.
714 Return values
715 none
716 Description
717 The function selects which function to be called upon a keyboard character event. The callback function
718 is called every time a key that results in a printable Unicode character is pressed or released. Characters
719 are affected by modifiers (such as shift or alt).
720 A window has to be opened for this function to have any effect.
721 Notes
722 Character events are recorded continuously, but only reported when glfwPollEvents, glfwWaitEvents
723 or glfwSwapBuffers is called.
724 Control characters, such as tab and carriage return, are not reported to the character callback function,
725 since they are not part of the Unicode character set. Use the key callback function for such events (see
726 glfwSetKeyCallback).
727 The Unicode character set supports character codes above 255, so never cast a Unicode character to an
728 eight bit data type (e.g. the C language ’char’ type) without first checking that the character code is less
729 than 256. Also note that Unicode character codes 0 to 255 are equal to ISO 8859-1 (Latin 1).
732 "Parameters
733 cbfun
734 Pointer to a callback function that will be called every time a mouse button is pressed or released.
735 The function should have the following C language prototype:
736 void GLFWCALL functionname( int button, int action );
737 Where functionname is the name of the callback function, button is a mouse button identifier (see
738 table 3.4 on page 56), and action is either GLFW_PRESS or GLFW_RELEASE.
739 If cbfun is NULL, any previously selected callback function will be deselected.
740 Return values
741 none
742 Description
743 The function selects which function to be called upon a mouse button event.
744 A window has to be opened for this function to have any effect.
745 Notes
746 Mouse button events are recorded continuously, but only reported when glfwPollEvents,
747 glfwWaitEvents or glfwSwapBuffers is called.
748 GLFW_MOUSE_BUTTON_LEFT is equal to GLFW_MOUSE_BUTTON_1.
749 GLFW_MOUSE_BUTTON_RIGHT is equal to GLFW_MOUSE_BUTTON_2.
750 GLFW_MOUSE_BUTTON_MIDDLE is equal to GLFW_MOUSE_BUTTON_3.
753 "Parameters
754 cbfun
755 Pointer to a callback function that will be called every time the mouse is moved. The function
756 should have the following C language prototype:
757 void GLFWCALL functionname( int x, int y );
758 Where functionname is the name of the callback function, and x and y are the mouse coordinates
759 (see glfwGetMousePos for more information on mouse coordinates).
760 If cbfun is NULL, any previously selected callback function will be deselected.
761 Return values
762 none
763 Description
764 The function selects which function to be called upon a mouse motion event.
765 A window has to be opened for this function to have any effect.
766 Notes
767 Mouse motion events are recorded continuously, but only reported when glfwPollEvents,
768 glfwWaitEvents or glfwSwapBuffers is called.
771 "Parameters
772 cbfun
773 Pointer to a callback function that will be called every time the mouse wheel is moved. The
774 function should have the following C language prototype:
775 void GLFWCALL functionname( int pos );
776 Where functionname is the name of the callback function, and pos is the mouse wheel position.
777 If cbfun is NULL, any previously selected callback function will be deselected.
778 Return values
779 none
780 Description
781 The function selects which function to be called upon a mouse wheel event.
782 A window has to be opened for this function to have any effect.
783 Notes
784 Mouse wheel events are recorded continuously, but only reported when glfwPollEvents,
785 glfwWaitEvents or glfwSwapBuffers is called.
789 "Parameters
790 joy
791 A joystick identifier, which should be GLFW_JOYSTICK_n, where n is in the range 1 to 16.
792 param
793 A token selecting which parameter the function should return (see table 3.5).
794 Return values
795 The function returns different parameters depending on the value of param. Table 3.5 lists valid param
796 values, and their corresponding return values.
797 Description
798 The function is used for acquiring various properties of a joystick.
799 Notes
800 The joystick information is updated every time the function is called.
801 No window has to be opened for joystick information to be valid.
804 (defcfun ("glfwGetJoystickPos" %get-joystick-pos) :int (joy :int) (pos :pointer) (numaxes :int))
807 "Parameters
808 joy
809 A joystick identifier, which should be GLFW_JOYSTICK_n, where n is in the range 1 to 16.
810 numaxes
811 Specifies how many axes should be returned.
812 Return values
813 An list that will hold the positional values for all requested axes.
814 If the joystick is not supported or connected, the function will
815 return nil.
817 Description
818 The function queries the current position of one or more axes of a joystick. The positional values are
819 returned in an array, where the first element represents the first axis of the joystick (normally the X
820 axis). Each position is in the range -1.0 to 1.0. Where applicable, the positive direction of an axis is
821 right, forward or up, and the negative direction is left, back or down.
822 If numaxes exceeds the number of axes supported by the joystick, or if the joystick is not available, the
823 unused elements in the pos array will be set to 0.0 (zero).
825 Notes
826 The joystick state is updated every time the function is called, so there is no need to call glfwPollEvents
827 or glfwWaitEvents for joystick state to be updated.
828 Use glfwGetJoystickParam to retrieve joystick capabilities, such as joystick availability and number of
829 supported axes.
830 No window has to be opened for joystick input to be valid.
831 "
837 (defcfun ("glfwGetJoystickButtons" %get-joystick-buttons) :int (joy :int) (buttons :pointer) (numbuttons :int))
839 "Parameters
840 joy
841 A joystick identifier, which should be GLFW_JOYSTICK_n, where n is in the range 1 to 16.
842 numbuttons
843 Specifies how many buttons should be returned.
844 Return values
845 A list that will hold the button states for all requested buttons.
846 The function returns the number of actually returned buttons. This is the minimum of numbuttons and
847 the number of buttons supported by the joystick. If the joystick is not supported or connected, the
848 function will return 0 (zero).
850 Description
851 The function queries the current state of one or more buttons of a joystick. The button states are
852 returned in an array, where the first element represents the first button of the joystick. Each state can be
853 either GLFW_PRESS or GLFW_RELEASE.
854 If numbuttons exceeds the number of buttons supported by the joystick, or if the joystick is not
855 available, the unused elements in the buttons array will be set to GLFW_RELEASE.
857 Notes
858 The joystick state is updated every time the function is called, so there is no need to call glfwPollEvents
859 or glfwWaitEvents for joystick state to be updated.
860 Use glfwGetJoystickParam to retrieve joystick capabilities, such as joystick availability and number of
861 supported buttons.
862 No window has to be opened for joystick input to be valid.
863 "
870 "Return values
871 The function returns the value of the high precision timer. The time is measured in seconds, and is
872 returned as a double precision floating point value.
874 Description
875 The function returns the state of a high precision timer. Unless the timer has been set by the
876 glfwSetTime function, the time is measured as the number of seconds that have passed since glfwInit
877 was called.
879 Notes
880 The resolution of the timer depends on which system the program is running on. The worst case
881 resolution is somewhere in the order of 10 ms, while for most systems the resolution should be better
882 than 1 μs.
886 "Parameters
887 time
888 Time (in seconds) that the timer should be set to.
890 Description
891 The function sets the current time of the high precision timer to the specified time. Subsequent calls to
892 glfwGetTime will be relative to this time. The time is given in seconds.
896 "Parameters
897 time
898 Time, in seconds, to sleep.
900 Description
901 The function puts the calling thread to sleep for the requested period of time. Only the calling thread is
902 put to sleep. Other threads within the same process can still execute.
904 Notes
905 There is usually a system dependent minimum time for which it is possible to sleep. This time is
906 generally in the range 1 ms to 20 ms, depending on thread sheduling time slot intervals etc. Using a
907 shorter time as a parameter to glfwSleep can give one of two results: either the thread will sleep for the
908 minimum possible sleep time, or the thread will not sleep at all (glfwSleep returns immediately). The
920 "Parameters
921 name
922 A null terminated ISO 8859-1 string holding the name of the file that should be read.
923 img
924 Pointer to a GLFWimage struct, which will hold the information about the loaded image (if the
925 read was successful).
926 flags
927 Flags for controlling the image reading process. Valid flags are listed in table 3.6
928 Return values
929 The function returns GL_TRUE if the image was loaded successfully. Otherwise GL_FALSE is
930 returned.
931 Description
932 The function reads an image from the file specified by the parameter name and returns the image
933 information and data in a GLFWimage structure, which has the following definition:
934 § ¤
935 typedef struct {
936 int Width, Height; // Image dimensions
937 int Format; // OpenGL pixel format
938 int BytesPerPixel; // Number of bytes per pixel
939 unsigned char *Data; // Pointer to pixel data
940 } GLFWimage;
941 ¦ ¥
942 Width and Height give the dimensions of the image. Format specifies an OpenGL™ pixel format,
943 which can be GL_LUMINANCE or GL_ALPHA (for gray scale images), GL_RGB or GL_RGBA.
944 BytesPerPixel specifies the number of bytes per pixel. Data is a pointer to the actual pixel data.
945 By default the read image is rescaled to the nearest larger 2m × 2n resolution using bilinear
946 interpolation, if necessary, which is useful if the image is to be used as an OpenGL™ texture. This
947 behavior can be disabled by setting the GLFW_NO_RESCALE_BIT flag.
948 Unless the flag GLFW_ORIGIN_UL_BIT is set, the first pixel in img->Data is the lower left corner of
949 the image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left corner.
950 For single component images (i.e. gray scale), Format is set to GL_ALPHA if the flag
951 GLFW_ALPHA_MAP_BIT flag is set, otherwise Format is set to GL_LUMINANCE.
952 Notes
953 glfwReadImage supports the Truevision Targa version 1 file format (.TGA). Supported pixel formats
954 are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color + alpha.
955 Paletted images are translated into true color or true color + alpha pixel formats.
956 Please note that OpenGL™ 1.0 does not support single component alpha maps, so do not use images
957 with Format = GL_ALPHA directly as textures under OpenGL™ 1.0.
962 "Parameters
963 data
964 The memory buffer holding the contents of the file that should be read.
965 size
966 The size, in bytes, of the memory buffer.
967 img
968 Pointer to a GLFWimage struct, which will hold the information about the loaded image (if the
969 read was successful).
970 flags
971 Flags for controlling the image reading process. Valid flags are listed in table 3.6
972 Return values
973 The function returns GL_TRUE if the image was loaded successfully. Otherwise GL_FALSE is
974 returned.
975 Description
976 The function reads an image from the memory buffer specified by the parameter data and returns the
977 image information and data in a GLFWimage structure, which has the following definition:
978 § ¤
979 typedef struct {
980 int Width, Height; // Image dimensions
981 int Format; // OpenGL pixel format
982 int BytesPerPixel; // Number of bytes per pixel
983 unsigned char *Data; // Pointer to pixel data
984 } GLFWimage;
985 ¦ ¥
986 Width and Height give the dimensions of the image. Format specifies an OpenGL™ pixel format,
987 which can be GL_LUMINANCE or GL_ALPHA (for gray scale images), GL_RGB or GL_RGBA.
988 BytesPerPixel specifies the number of bytes per pixel. Data is a pointer to the actual pixel data.
989 By default the read image is rescaled to the nearest larger 2m × 2n resolution using bilinear
990 interpolation, if necessary, which is useful if the image is to be used as an OpenGL™ texture. This
991 behavior can be disabled by setting the GLFW_NO_RESCALE_BIT flag.
992 Unless the flag GLFW_ORIGIN_UL_BIT is set, the first pixel in img->Data is the lower left corner of
993 the image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left corner.
994 For single component images (i.e. gray scale), Format is set to GL_ALPHA if the flag
995 GLFW_ALPHA_MAP_BIT flag is set, otherwise Format is set to GL_LUMINANCE.
996 Notes
997 glfwReadMemoryImage supports the Truevision Targa version 1 file format (.TGA). Supported pixel
998 formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color +
999 alpha.
1000 Paletted images are translated into true color or true color + alpha pixel formats.
1001 Please note that OpenGL™ 1.0 does not support single component alpha maps, so do not use images
1002 with Format = GL_ALPHA directly as textures under OpenGL™ 1.0.
1006 "Parameters
1007 img
1008 Pointer to a GLFWimage struct.
1009 Description
1010 The function frees any memory occupied by a loaded image, and clears all the fields of the GLFWimage
1011 struct. Any image that has been loaded by the glfwReadImage function should be deallocated using
1015 "Parameters
1016 name
1017 An ISO 8859-1 string holding the name of the file that should be loaded.
1018 flags
1019 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1020 Return values
1021 The function returns GL_TRUE if the texture was loaded successfully. Otherwise GL_FALSE is
1022 returned.
1024 Description
1025 The function reads an image from the file specified by the parameter name and uploads the image to
1026 OpenGL™ texture memory (using the glTexImage2D function).
1027 If the GLFW_BUILD_MIPMAPS_BIT flag is set, all mipmap levels for the loaded texture are
1028 generated and uploaded to texture memory.
1029 Unless the flag GLFW_ORIGIN_UL_BIT is set, the origin of the texture is the lower left corner of the
1030 loaded image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left
1031 corner.
1032 For single component images (i.e. gray scale), the texture is uploaded as an alpha mask if the flag
1033 GLFW_ALPHA_MAP_BIT flag is set, otherwise it is uploaded as a luminance texture.
1035 Notes
1036 glfwLoadTexture2D supports the Truevision Targa version 1 file format (.TGA). Supported pixel
1037 formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color +
1038 alpha.
1039 Paletted images are translated into true color or true color + alpha pixel formats.
1040 The read texture is always rescaled to the nearest larger 2m × 2n resolution using bilinear interpolation,
1041 if necessary, since OpenGL™ requires textures to have a 2m × 2n resolution.
1042 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1043 the OpenGL™ implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1044 generated by GLFW in software.
1045 Since OpenGL™ 1.0 does not support single component alpha maps, alpha map textures are converted
1046 to RGBA format under OpenGL™ 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1047 texture is a single component texture. The red, green and blue components are set to 1.0.
1052 "Parameters
1053 data
1054 The memory buffer holding the contents of the file that should be loaded.
1055 size
1056 The size, in bytes, of the memory buffer.
1057 flags
1058 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1059 Return values
1060 The function returns GL_TRUE if the texture was loaded successfully. Otherwise GL_FALSE is
1061 returned.
1063 Description
1064 The function reads an image from the memory buffer specified by the parameter data and uploads the
1065 image to OpenGL™ texture memory (using the glTexImage2D function).
1066 If the GLFW_BUILD_MIPMAPS_BIT flag is set, all mipmap levels for the loaded texture are
1067 generated and uploaded to texture memory.
1068 Unless the flag GLFW_ORIGIN_UL_BIT is set, the origin of the texture is the lower left corner of the
1069 loaded image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left
1070 corner.
1071 For single component images (i.e. gray scale), the texture is uploaded as an alpha mask if the flag
1072 GLFW_ALPHA_MAP_BIT flag is set, otherwise it is uploaded as a luminance texture.
1074 Notes
1075 glfwLoadMemoryTexture2D supports the Truevision Targa version 1 file format (.TGA). Supported
1076 pixel formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color
1077 + alpha.
1078 Paletted images are translated into true color or true color + alpha pixel formats.
1079 The read texture is always rescaled to the nearest larger 2m × 2n resolution using bilinear interpolation,
1080 if necessary, since OpenGL™ requires textures to have a 2m × 2n resolution.
1081 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1082 the OpenGL™ implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1083 generated by GLFW in software.
1084 Since OpenGL™ 1.0 does not support single component alpha maps, alpha map textures are converted
1085 to RGBA format under OpenGL™ 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1086 texture is a single component texture. The red, green and blue components are set to 1.0.
1092 "Parameters
1093 img
1094 Pointer to a GLFWimage struct holding the information about the image to be loaded.
1095 flags
1096 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1097 Return values
1098 The function returns GL_TRUE if the texture was loaded successfully. Otherwise GL_FALSE is
1099 returned.
1101 Description
1102 The function uploads the image specified by the parameter img to OpenGL™ texture memory (using
1103 the glTexImage2D function).
1104 If the GLFW_BUILD_MIPMAPS_BIT flag is set, all mipmap levels for the loaded texture are
1105 generated and uploaded to texture memory.
1106 Unless the flag GLFW_ORIGIN_UL_BIT is set, the origin of the texture is the lower left corner of the
1107 loaded image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left
1108 corner.
1109 For single component images (i.e. gray scale), the texture is uploaded as an alpha mask if the flag
1110 GLFW_ALPHA_MAP_BIT flag is set, otherwise it is uploaded as a luminance texture.
1112 Notes
1113 glfwLoadTextureImage2D supports the Truevision Targa version 1 file format (.TGA). Supported
1114 pixel formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color
1115 + alpha.
1116 Paletted images are translated into true color or true color + alpha pixel formats.
1117 The read texture is always rescaled to the nearest larger 2m × 2n resolution using bilinear interpolation,
1118 if necessary, since OpenGL™ requires textures to have a 2m × 2n resolution.
1119 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1120 the OpenGL™ implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1121 generated by GLFW in software.
1122 Since OpenGL™ 1.0 does not support single component alpha maps, alpha map textures are converted
1123 to RGBA format under OpenGL™ 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1128 "Parameters
1129 extension
1130 A null terminated ISO 8859-1 string containing the name of an OpenGL™ extension.
1131 Return values
1132 The function returns GL_TRUE if the extension is supported. Otherwise it returns GL_FALSE.
1133 Description
1134 The function does a string search in the list of supported OpenGL™ extensions to find if the specified
1135 extension is listed.
1136 Notes
1137 An OpenGL™ context must be created before this function can be called (i.e. an OpenGL™ window
1138 must have been opened with glfwOpenWindow).
1139 In addition to checking for OpenGL™ extensions, GLFW also checks for extensions in the operating
1140 system “glue API”, such as WGL extensions under Windows and glX extensions under the X Window
1141 System.
1145 "Parameters
1146 procname
1147 A null terminated ISO 8859-1 string containing the name of an OpenGL™ extension function.
1148 Return values
1149 The function returns the pointer to the specified OpenGL™ function if it is supported, otherwise
1150 NULL is returned.
1151 Description
1152 The function acquires the pointer to an OpenGL™ extension function. Some (but not all) OpenGL™
1153 extensions define new API functions, which are usually not available through normal linking. It is
1154 therefore necessary to get access to those API functions at runtime.
1155 Notes
1156 An OpenGL™ context must be created before this function can be called (i.e. an OpenGL™ window
1157 must have been opened with glfwOpenWindow).
1158 Some systems do not support dynamic function pointer retrieval, in which case glfwGetProcAddress
1159 will always return NULL.
1165 "Return values
1166 The function returns the major and minor version numbers and the revision for the currently used
1167 OpenGL™ implementation as a list (major minor rev).
1169 Description
1170 The function returns the OpenGL™ implementation version. This is a convenient function that parses
1171 the version number information from the string returned by calling
1172 glGetString( GL_VERSION ). The OpenGL™ version information can be used to determine
1173 what functionality is supported by the used OpenGL™ implementation.
1175 Notes
1176 An OpenGL™ context must be created before this function can be called (i.e. an OpenGL™ window
1185 "Parameters
1186 fun
1187 A pointer to a function that acts as the entry point for the new thread. The function should have
1188 the following C language prototype:
1189 void GLFWCALL functionname( void *arg );
1190 Where functionname is the name of the thread function, and arg is the user supplied argument
1191 (see below).
1192 arg
1193 An arbitrary argument for the thread. arg will be passed as the argument to the thread function
1194 pointed to by fun. For instance, arg can point to data that is to be processed by the thread.
1195 Return values
1196 The function returns a thread identification number if the thread was created successfully. This number
1197 is always positive. If the function fails, a negative number is returned.
1198 Description
1199 The function creates a new thread, which executes within the same address space as the calling process.
1200 The thread entry point is specified with the fun argument.
1201 Once the thread function fun returns, the thread dies.
1202 Notes
1203 Even if the function returns a positive thread ID, indicating that the thread was created successfully, the
1204 thread may be unable to execute, for instance if the thread start address is not a valid thread entry point.
1207 "Parameters
1208 ID
1209 A thread identification handle, which is returned by glfwCreateThread or glfwGetThreadID.
1210 Description
1211 The function kills a running thread and removes it from the thread list.
1212 Notes
1213 This function is a very dangerous operation, which may interrupt a thread in the middle of an important
1214 operation, and its use is discouraged. You should always try to end a thread in a graceful way using
1215 thread communication, and use glfwWaitThread in order to wait for the thread to die.
1218 "Parameters
1219 ID
1220 A thread identification handle, which is returned by glfwCreateThread or glfwGetThreadID.
1221 waitmode
1222 Can be either GLFW_WAIT or GLFW_NOWAIT.
1223 Return values
1224 The function returns GL_TRUE if the specified thread died after the function was called, or the thread
1225 did not exist, in which case glfwWaitThread will return immediately regardless of waitmode. The
1226 function returns GL_FALSE if waitmode is GLFW_NOWAIT, and the specified thread exists and is still
1227 running.
1230 "Return values
1231 The function returns a thread identification handle for the calling thread.
1232 Description
1233 The function determines the thread ID for the calling thread. The ID is the same value as was returned
1234 by glfwCreateThread when the thread was created.
1238 "Return values
1239 The function returns a mutex handle, or NULL if the mutex could not be created.
1240 Description
1241 The function creates a mutex object, which can be used to control access to data that is shared between
1242 threads.
1245 "Parameters
1246 mutex
1247 A mutex object handle.
1248 Description
1249 The function destroys a mutex object. After a mutex object has been destroyed, it may no longer be
1250 used by any thread.
1253 "Parameters
1254 mutex
1255 A mutex object handle.
1256 Description
1257 The function will acquire a lock on the selected mutex object. If the mutex is already locked by another
1258 thread, the function will block the calling thread until it is released by the locking thread. Once the
1259 function returns, the calling thread has an exclusive lock on the mutex. To release the mutex, call
1260 glfwUnlockMutex.
1263 "Parameters
1264 mutex
1265 A mutex object handle.
1266 Description
1267 The function releases the lock of a locked mutex object.
1271 "Return values
1272 The function returns a condition variable handle, or NULL if the condition variable could not be
1273 created.
1274 Description
1275 The function creates a condition variable object, which can be used to synchronize threads.
1278 "Parameters
1279 cond
1280 A condition variable object handle.
1281 Description
1282 The function destroys a condition variable object. After a condition variable object has been destroyed,
1283 it may no longer be used by any thread.
1286 " arameters
1287 cond
1288 A condition variable object handle.
1289 mutex
1290 A mutex object handle.
1291 timeout
1292 Maximum time to wait for the condition variable. The parameter can either be a positive time (in
1293 seconds), or GLFW_INFINITY.
1294 Description
1295 The function atomically unlocks the mutex specified by mutex, and waits for the condition variable cond
1296 to be signaled. The thread execution is suspended and does not consume any CPU time until the
1297 condition variable is signaled or the amount of time specified by timeout has passed. If timeout is
1298 GLFW_INFINITY, glfwWaitCond will wait forever for cond to be signaled. Before returning to the
1299 calling thread, glfwWaitCond automatically re-acquires the mutex.
1300 Notes
1301 The mutex specified by mutex must be locked by the calling thread before entrance to glfwWaitCond.
1302 A condition variable must always be associated with a mutex, to avoid the race condition where a thread
1303 prepares to wait on a condition variable and another thread signals the condition just before the first
1304 thread actually waits on it.
1307 "Parameters
1308 cond
1309 A condition variable object handle.
1310 Description
1311 The function restarts one of the threads that are waiting on the condition variable cond. If no threads are
1312 waiting on cond, nothing happens. If several threads are waiting on cond, exactly one is restarted, but it
1313 is not specified which.
1314 Notes
1315 When several threads are waiting for the condition variable, which thread is started depends on
1316 operating system scheduling rules, and may vary from system to system and from time to time.
1319 "Parameters
1320 cond
1321 A condition variable object handle.
1322 Description
1323 The function restarts all the threads that are waiting on the condition variable cond. If no threads are
1324 waiting on cond, nothing happens.
1325 Notes
1326 When several threads are waiting for the condition variable, the order in which threads are started
1327 depends on operating system scheduling rules, and may vary from system to system and from time to
1328 time.
1332 "Return values
1333 The function returns the number of active processors in the system.
1334 Description
1335 The function determines the number of active processors in the system.
1336 Notes
1337 Systems with several logical processors per physical processor, also known as SMT (Symmetric Multi
1338 Threading) processors, will report the number of logical processors.
1341 "Parameters
1342 token
1343 A value specifying a feature to enable or disable. Valid tokens are listed in table 3.8.
1344 Return values
1345 none
1346 Description
1347 glfwEnable is used to enable a certain feature, while glfwDisable is used to disable it. Below follows a
1348 description of each feature.
1349 GLFW_AUTO_POLL_EVENTS
1350 When GLFW_AUTO_POLL_EVENTS is enabled, glfwPollEvents is automatically called each time
1351 that glfwSwapBuffers is called.
1352 When GLFW_AUTO_POLL_EVENTS is disabled, calling glfwSwapBuffers will not result in a call to
1353 glfwPollEvents. This can be useful if glfwSwapBuffers needs to be called from within a callback
1354 function, since calling glfwPollEvents from a callback function is not allowed.
1355 GLFW_KEY_REPEAT
1356 When GLFW_KEY_REPEAT is enabled, the key and character callback functions are called repeatedly
1357 when a key is held down long enough (according to the system key repeat configuration).
1358 When GLFW_KEY_REPEAT is disabled, the key and character callback functions are only called once
1359 when a key is pressed (and once when it is released).
1360 GLFW_MOUSE_CURSOR
1361 When GLFW_MOUSE_CURSOR is enabled, the mouse cursor is visible, and mouse coordinates are
1362 relative to the upper left corner of the client area of the GLFW window. The coordinates are limited to
1363 the client area of the window.
1364 When GLFW_MOUSE_CURSOR is disabled, the mouse cursor is invisible, and mouse coordinates are
1365 not limited to the drawing area of the window. It is as if the mouse coordinates are recieved directly
1366 from the mouse, without being restricted or manipulated by the windowing system.
1367 GLFW_STICKY_KEYS
1368 When GLFW_STICKY_KEYS is enabled, keys which are pressed will not be released until they are
1369 physically released and checked with glfwGetKey. This behavior makes it possible to catch keys that
1370 were pressed and then released again between two calls to glfwPollEvents, glfwWaitEvents or
1371 glfwSwapBuffers, which would otherwise have been reported as released. Care should be taken when
1372 using this mode, since keys that are not checked with glfwGetKey will never be released. Note also that
1373 enabling GLFW_STICKY_KEYS does not affect the behavior of the keyboard callback functionality.
1374 When GLFW_STICKY_KEYS is disabled, the status of a key that is reported by glfwGetKey is always
1375 the physical state of the key. Disabling GLFW_STICKY_KEYS also clears the sticky information for
1376 all keys.
1377 GLFW_STICKY_MOUSE_BUTTONS
1378 When GLFW_STICKY_MOUSE_BUTTONS is enabled, mouse buttons that are pressed will not be
1379 released until they are physically released and checked with glfwGetMouseButton. This behavior
1380 makes it possible to catch mouse buttons which were pressed and then released again between two calls
1381 to glfwPollEvents, glfwWaitEvents or glfwSwapBuffers, which would otherwise have been reported
1382 as released. Care should be taken when using this mode, since mouse buttons that are not checked with
1383 glfwGetMouseButton will never be released. Note also that enabling
1384 GLFW_STICKY_MOUSE_BUTTONS does not affect the behavior of the mouse button callback
1385 functionality.
1386 When GLFW_STICKY_MOUSE_BUTTONS is disabled, the status of a mouse button that is reported
1387 by glfwGetMouseButton is always the physical state of the mouse button. Disabling
1388 GLFW_STICKY_MOUSE_BUTTONS also clears the sticky information for all mouse buttons.
1389 GLFW_SYSTEM_KEYS
1390 When GLFW_SYSTEM_KEYS is enabled, pressing standard system key combinations, such as
1391 ALT+TAB under Windows, will give the normal behavior. Note that when ALT+TAB is issued under
1392 Windows in this mode so that the GLFW application is deselected when GLFW is operating in
1393 fullscreen mode, the GLFW application window will be minimized and the video mode will be set to
1394 the original desktop mode. When the GLFW application is re-selected, the video mode will be set to
1395 the GLFW video mode again.
1396 When GLFW_SYSTEM_KEYS is disabled, pressing standard system key combinations will have no
1397 effect, since those key combinations are blocked by GLFW. This mode can be useful in situations when
1398 the GLFW program must not be interrupted (normally for games in fullscreen mode).
1401 "Parameters
1402 token
1403 A value specifying a feature to enable or disable. Valid tokens are listed in table 3.8.
1404 Return values
1405 none
1406 Description
1407 glfwEnable is used to enable a certain feature, while glfwDisable is used to disable it. Below follows a
1408 description of each feature.
1409 GLFW_AUTO_POLL_EVENTS
1410 When GLFW_AUTO_POLL_EVENTS is enabled, glfwPollEvents is automatically called each time
1411 that glfwSwapBuffers is called.
1412 When GLFW_AUTO_POLL_EVENTS is disabled, calling glfwSwapBuffers will not result in a call to
1413 glfwPollEvents. This can be useful if glfwSwapBuffers needs to be called from within a callback
1414 function, since calling glfwPollEvents from a callback function is not allowed.
1415 GLFW_KEY_REPEAT
1416 When GLFW_KEY_REPEAT is enabled, the key and character callback functions are called repeatedly
1417 when a key is held down long enough (according to the system key repeat configuration).
1418 When GLFW_KEY_REPEAT is disabled, the key and character callback functions are only called once
1419 when a key is pressed (and once when it is released).
1420 GLFW_MOUSE_CURSOR
1421 When GLFW_MOUSE_CURSOR is enabled, the mouse cursor is visible, and mouse coordinates are
1422 relative to the upper left corner of the client area of the GLFW window. The coordinates are limited to
1423 the client area of the window.
1424 When GLFW_MOUSE_CURSOR is disabled, the mouse cursor is invisible, and mouse coordinates are
1425 not limited to the drawing area of the window. It is as if the mouse coordinates are recieved directly
1426 from the mouse, without being restricted or manipulated by the windowing system.
1427 GLFW_STICKY_KEYS
1428 When GLFW_STICKY_KEYS is enabled, keys which are pressed will not be released until they are
1429 physically released and checked with glfwGetKey. This behavior makes it possible to catch keys that
1430 were pressed and then released again between two calls to glfwPollEvents, glfwWaitEvents or
1431 glfwSwapBuffers, which would otherwise have been reported as released. Care should be taken when
1432 using this mode, since keys that are not checked with glfwGetKey will never be released. Note also that
1433 enabling GLFW_STICKY_KEYS does not affect the behavior of the keyboard callback functionality.
1434 When GLFW_STICKY_KEYS is disabled, the status of a key that is reported by glfwGetKey is always
1435 the physical state of the key. Disabling GLFW_STICKY_KEYS also clears the sticky information for
1436 all keys.
1437 GLFW_STICKY_MOUSE_BUTTONS
1438 When GLFW_STICKY_MOUSE_BUTTONS is enabled, mouse buttons that are pressed will not be
1439 released until they are physically released and checked with glfwGetMouseButton. This behavior
1440 makes it possible to catch mouse buttons which were pressed and then released again between two calls
1441 to glfwPollEvents, glfwWaitEvents or glfwSwapBuffers, which would otherwise have been reported
1442 as released. Care should be taken when using this mode, since mouse buttons that are not checked with
1443 glfwGetMouseButton will never be released. Note also that enabling
1444 GLFW_STICKY_MOUSE_BUTTONS does not affect the behavior of the mouse button callback
1445 functionality.
1446 When GLFW_STICKY_MOUSE_BUTTONS is disabled, the status of a mouse button that is reported
1447 by glfwGetMouseButton is always the physical state of the mouse button. Disabling
1448 GLFW_STICKY_MOUSE_BUTTONS also clears the sticky information for all mouse buttons.
1449 GLFW_SYSTEM_KEYS
1450 When GLFW_SYSTEM_KEYS is enabled, pressing standard system key combinations, such as
1451 ALT+TAB under Windows, will give the normal behavior. Note that when ALT+TAB is issued under
1452 Windows in this mode so that the GLFW application is deselected when GLFW is operating in
1453 fullscreen mode, the GLFW application window will be minimized and the video mode will be set to
1454 the original desktop mode. When the GLFW application is re-selected, the video mode will be set to
1455 the GLFW video mode again.
1456 When GLFW_SYSTEM_KEYS is disabled, pressing standard system key combinations will have no
1457 effect, since those key combinations are blocked by GLFW. This mode can be useful in situations when
1458 the GLFW program must not be interrupted (normally for games in fullscreen mode).