| blob | 139ce377d5af6f14a4b10ceda197e974ccf50666 |
7 ;; Key and button state/action definitions
11 ;; Keyboard key definitions: 8-bit ISO-8859-1 (Latin 1) encoding is used
12 ;; for printable keys (such as A-Z, 0-9 etc), and values above 256
13 ;; represent special (non-printable) keys (e.g. F1, Page Up etc).
81 ;; Mouse button definitions
92 ;; Mouse button aliases
97 ;; Joystick identifiers
117 ;;========================================================================
118 ;; Other definitions
119 ;;========================================================================
121 ;; glfwOpenWindow modes
125 ;; glfwGetWindowParam tokens
137 ;; The following constants are used for both glfwGetWindowParam
138 ;; and glfwOpenWindowHint
149 ;; glfwEnable/glfwDisable tokens
157 ;; glfwWaitThread wait modes
161 ;; glfwGetJoystickParam tokens
166 ;; glfwReadImage/glfwLoadTexture2D flags
172 ;; Time spans longer than this (seconds) are considered to be infinity
176 "Return values
177 If the function succeeds, t is returned.
178 If the function fails, nil is returned.
180 The glfwInit function initializes GLFW. No other GLFW functions may be used before this function
181 has been called.
183 Notes
184 This function may take several seconds to complete on some systems, while on other systems it may
188 "The function terminates GLFW. Among other things it closes the window, if it is opened, and kills any
194 "Return values
195 The function returns the major and minor version numbers and the revision for the currently linked
199 "Call glfw:init, execute forms and clean-up with glfw:terminate once finished.
200 This makes a nice wrapper to an application higher-level form.
201 Signals an error on failure to initialize. Wrapped in a block named glfw:with-init."
217 "width
218 The width of the window. If width is zero, it will be calculated as width = 4/3 height, if height is
219 not zero. If both width and height are zero, then width will be set to 640.
220 height
221 The height of the window. If height is zero, it will be calculated as height = 3/4 width, if width is
222 not zero. If both width and height are zero, then height will be set to 480.
223 redbits, greenbits, bluebits
224 The number of bits to use for each color component of the color buffer (0 means default color
225 depth). For instance, setting redbits=5, greenbits=6, and bluebits=5 will generate a 16-bit color
226 buffer, if possible.
227 alphabits
228 The number of bits to use for the alpha buffer (0 means no alpha buffer).
229 depthbits
230 The number of bits to use for the depth buffer (0 means no depth buffer).
231 stencilbits
232 The number of bits to use for the stencil buffer (0 means no stencil buffer).
233 mode
234 Selects which type of OpenGL window to use. mode can be either GLFW_WINDOW, which
235 will generate a normal desktop window, or GLFW_FULLSCREEN, which will generate a
236 window which covers the entire screen. When GLFW_FULLSCREEN is selected, the video
237 mode will be changed to the resolution that closest matches the width and height parameters.
239 Return values
240 If the function succeeds, t is returned.
241 If the function fails, nil is returned.
243 Description
244 The function opens a window that best matches the parameters given to the function. How well the
245 resulting window matches the desired window depends mostly on the available hardware and
246 OpenGL drivers. In general, selecting a fullscreen mode has better chances of generating a close
247 match than does a normal desktop window, since GLFW can freely select from all the available video
248 modes. A desktop window is normally restricted to the video mode of the desktop.
250 Notes
251 For additional control of window properties, see glfw::OpenWindowHint.
252 In fullscreen mode the mouse cursor is hidden by default, and any system screensavers are prohibited
253 from starting. In windowed mode the mouse cursor is visible, and screensavers are allowed to start. To
254 change the visibility of the mouse cursor, use glfwEnable or glfwDisable with the argument
255 +MOUSE_CURSOR+
256 In order to determine the actual properties of an opened window, use glfw::GetWindowParam and
257 glfw::GetWindowSize (or glfw::SetWindowSizeCallback).
258 "
263 "target
264 Can be any of the constants in the table 3.1.
265 hint
266 An integer giving the value of the corresponding target (see table 3.1).
268 Description
269 The function sets additional properties for a window that is to be opened. For a hint to be registered, the
270 function must be called before calling glfw::OpenWindow. When the glfw::OpenWindow function is
271 called, any hints that were registered with the glfw::OpenWindowHint function are used for setting the
272 corresponding window properties, and then all hints are reset to their default values.
274 Notes
275 In order to determine the actual properties of an opened window, use glfw::GetWindowParam (after the
276 window has been opened).
277 +STEREO+ is a hard constraint. If stereo rendering is requested, but no stereo rendering capable
278 pixel formats / visuals are available, glfw::OpenWindow will fail.
279 The +REFRESH_RATE+ property should be used with caution. Most systems have default values
280 for monitor refresh rates that are optimal for the specific system. Specifying the refresh rate can
281 override these settings, which can result in suboptimal operation. The monitor may be unable to display
282 the resulting video signal, or in the worst case it may even be damaged!
292 "Wraps forms such that there is an open window for them to execute in and cleans up the
293 window afterwards. An error is signalled if there was an error opening the window.
294 Takes the same parameters as open-window, with the addition of 'title' which will
295 set the window title after opening.
296 Wrapped in a block named glfw:with-open-window."
297 `(if (%open-window ,width ,height ,redbits ,greenbits ,bluebits ,alphabits ,depthbits ,stencilbits ,mode)
310 "Wraps forms in with-init, with-open-window. Passes through the other arguments to open-window."
312 (with-open-window (,title ,width ,height ,redbits ,greenbits ,bluebits ,alphabits ,depthbits ,stencilbits ,mode)
320 "High-level convenience macro for initializing glfw, opening a window (given the optional window parameters),
321 setting the title given,
322 running setup-forms and then running forms in a loop, with calls to swap-buffers after each loop iteration.
323 The loop is in a block named do-window [so can be exited by a call to (return-from glfw:do-window)].
324 If the window is closed, the loop is also exited."
325 `(with-init-window (,title ,width ,height ,redbits ,greenbits ,bluebits ,alphabits ,depthbits ,stencilbits ,mode)
326 ,@setup-forms
328 ,@forms
334 "Parameters
335 cbfun
336 Pointer to a callback function that will be called when a user requests that the window should be
337 closed, typically by clicking the window close icon (e.g. the cross in the upper right corner of a
338 window under Microsoft Windows). The function should have the following C language
339 prototype:
340 int GLFWCALL functionname( void );
341 Where functionname is the name of the callback function. The return value of the callback
342 function indicates wether or not the window close action should continue. If the function returns
343 GL_TRUE, the window will be closed. If the function returns GL_FALSE, the window will not
344 be closed.
345 If cbfun is NULL, any previously selected callback function will be deselected.
347 If you declare your callback as returning glfw:boolean, you can use t and nil as return types.
349 Description
350 The function selects which function to be called upon a window close event.
351 A window has to be opened for this function to have any effect.
353 Notes
354 Window close events are recorded continuously, but only reported when glfwPollEvents,
355 glfwWaitEvents or glfwSwapBuffers is called.
356 The OpenGL context is still valid when this function is called.
357 Note that the window close callback function is not called when glfwCloseWindow is called, but only
358 when the close request comes from the window manager.
359 Do not call glfwCloseWindow from a window close callback function. Close the window by returning
360 GL_TRUE from the function.
364 "Parameters
365 title
366 Pointer to a null terminated ISO 8859-1 (8-bit Latin 1) string that holds the title of the window.
368 Description
369 The function changes the title of the opened window.
371 Notes
372 The title property of a window is often used in situations other than for the window title, such as the title
376 "Parameters
377 width
378 Width of the window.
379 height
380 Height of the window.
381 Return values
382 none
383 Description
384 The function changes the size of an opened window. The width and height parameters denote the size of
385 the client area of the window (i.e. excluding any window borders and decorations).
386 If the window is in fullscreen mode, the video mode will be changed to a resolution that closest matches
387 the width and height parameters (the number of color bits will not be changed).
388 Notes
389 The OpenGL context is guaranteed to be preserved after calling glfwSetWindowSize, even if the
390 video mode is changed.
394 "Parameters
395 x
396 Horizontal position of the window, relative to the upper left corner of the desktop.
397 y
398 Vertical position of the window, relative to the upper left corner of the desktop.
399 Return values
400 none
401 Description
402 The function changes the position of an opened window. It does not have any effect on a fullscreen
403 window.
408 "The function is used for determining the size of an opened window. The returned values are dimensions
409 of the client area of the window (i.e. excluding any window borders and decorations).
410 (list width height)"
418 "Parameters
419 cbfun
420 Pointer to a callback function that will be called every time the window size changes. The
421 function should have the following C language prototype:
422 void GLFWCALL functionname( int width, int height );
423 Where functionname is the name of the callback function, and width and height are the
424 dimensions of the window client area.
425 If cbfun is NULL, any previously selected callback function will be deselected.
426 Return values
427 none
428 Description
429 The function selects which function to be called upon a window size change event.
430 A window has to be opened for this function to have any effect.
431 Notes
432 Window size changes are recorded continuously, but only reported when glfwPollEvents,
436 "Iconify a window. If the window is in fullscreen mode, then the desktop video mode will be restored.")
439 "Restore an iconified window. If the window that is restored is in fullscreen mode, then the fullscreen
443 "Parameters
444 param
445 A token selecting which parameter the function should return (see table 3.2).
447 Return values
449 The function returns different parameters depending on the value of
450 param. Table 3.2 lists valid param values, and their corresponding
451 return values.
453 Description
454 The function is used for acquiring various properties of an opened window.
456 Notes: GLFW_ACCELERATED is only supported under Windows. Other systems
457 will always return GL_TRUE. Under Windows, GLFW_ACCELERATED means that
458 the OpenGL renderer is a 3rd party renderer, rather than the fallback
459 Microsoft software OpenGL renderer. In other words, it is not a real
460 guarantee that the OpenGL renderer is actually hardware accelerated.
464 "The function swaps the back and front color buffers of the window. If +AUTO_POLL_EVENTS+
465 is enabled (which is the default), glfwPollEvents is called before swapping the front and back buffers.")
469 "Parameters
470 interval
471 Minimum number of monitor vertical retraces between each buffer swap performed by
472 glfwSwapBuffers. If interval is zero, buffer swaps will not be synchronized to the vertical
473 refresh of the monitor (also known as VSync off).
475 Description
477 The function selects the minimum number of monitor vertical retraces
478 that should occur between two buffer swaps. If the selected swap
479 interval is one, the rate of buffer swaps will never be higher than
480 the vertical refresh rate of the monitor. If the selected swap
481 interval is zero, the rate of buffer swaps is only limited by the
482 speed of the software and the hardware.
484 Notes
486 This function will only have an effect on hardware and drivers that
490 (defcfun+doc ("glfwSetWindowRefreshCallback" set-window-refresh-callback) :void ((cbfun :pointer))
491 "Parameters
492 cbfun
493 Pointer to a callback function that will be called when the window client area needs to be
494 refreshed. The function should have the following CFFI prototype:
495 (cffi:defcallback callback-name :void ((width :int) (height :int)) .. body ..)
496 Where callback is the name of the callback function.
497 If cbfun is the null-pointer, any previously selected callback function will be deselected.
499 Description
501 The function selects which function to be called upon a window refresh
502 event, which occurs when any part of the window client area has been
503 damaged, and needs to be repainted (for instance, if a part of the
504 window that was previously occluded by another window has become
505 visible). A window has to be opened for this function to have any
506 effect.
508 Notes
509 Window refresh events are recorded continuously, but only reported when glfwPollEvents,
510 glfwWaitEvents or glfwSwapBuffers is called.
523 "Parameters
524 maxcount
525 Maximum number of video modes that list vector can hold.
527 Return values
528 The function returns the number of detected video modes (this number will never exceed maxcount).
529 The list vector is filled out with the video modes that are supported by the system.
531 Description
532 The function returns a list of supported video modes. Each video mode is represented by a
533 list of the form:
534 (width height redbits greenbits bluebits)
536 Notes
537 The returned list is sorted, first by color depth (RedBits + GreenBits + BlueBits), and then by
538 resolution (Width * Height), with the lowest resolution, fewest bits per pixel mode first. "
543 collecting
553 "Parameters
554 mode
555 Pointer to a GLFWvidmode structure, which will be filled out by the function.
556 Return values
557 The GLFWvidmode structure pointed to by mode is filled out with the desktop video mode.
558 Description
559 The function returns the desktop video mode in a GLFWvidmode structure. See glfwGetVideoModes
560 for a definition of the GLFWvidmode structure.
561 Notes
562 The color depth of the desktop display is always reported as the number of bits for each individual color
563 component (red, green and blue), even if the desktop is not using an RGB or RGBA color format. For
564 instance, an indexed 256 color display may report RedBits = 3, GreenBits = 3 and BlueBits = 2, which
565 adds up to 8 bits in total.
566 The desktop video mode is the video mode used by the desktop, not the current video mode (which may
567 differ from the desktop video mode if the GLFW window is a fullscreen window).
568 "
578 "Description
579 The function is used for polling for events, such as user input and window resize events. Upon calling
580 this function, all window states, keyboard states and mouse states are updated. If any related callback
581 functions are registered, these are called during the call to glfwPollEvents.
583 Notes
584 glfwPollEvents is called implicitly from glfwSwapBuffers if +AUTO_POLL_EVENTS+ is
585 enabled (default). Thus, if glfwSwapBuffers is called frequently, which is normally the case, there is
586 no need to call glfwPollEvents.
590 "Description
591 The function is used for waiting for events, such as user input and window resize events. Upon calling
592 this function, the calling thread will be put to sleep until any event appears in the event queue. When
593 events are ready, the events will be processed just as they are processed by glfwPollEvents.
594 If there are any events in the queue when the function is called, the function will behave exactly like
595 glfwPollEvents (i.e. process all messages and then return, without blocking the calling thread).
597 Notes
598 It is guaranteed that glfwWaitEvents will wake up on any event that can be processed by
599 glfw::PollEvents. However, glfwWaitEvents may wake up on events that are not processed or reported
600 by glfw::PollEvents too, and the function may behave differently on different systems. Do no make any
601 assumptions about when or why glfw::WaitEvents will return.
605 "Parameters
606 key
607 A keyboard key identifier, which can be either an uppercase printable ISO 8859-1 (Latin 1)
608 character (e.g. 'A', '3' or '.'), or a special key identifier. Table 3.3 lists valid special key
609 identifiers.
610 Return values
611 The function returns +PRESS+ if the key is held down, or +RELEASE+ if the key is not
612 held down.
614 Description
615 The function queries the current state of a specific keyboard key. The physical location of each key
616 depends on the system keyboard layout setting.
618 Notes
619 The constant +KEY_SPACE+ is equal to 32, which is the ISO 8859-1 code for space.
620 Not all key codes are supported on all systems. Also, while some keys are available on some keyboard
621 layouts, they may not be available on other keyboard layouts.
622 For systems that do not distinguish between left and right versions of modifier keys (shift, alt and
623 control), the left version is used (e.g. +KEY_LSHIFT+)
624 A window must be opened for the function to have any effect, and glfw::PollEvents, glfw::WaitEvents or
625 glfw::SwapBuffers must be called before any keyboard events are recorded and reported by
626 glfw::GetKey.
630 "Parameters
631 button
632 A mouse button identifier, which can be one of the mouse button identifiers listed in table 3.4.
633 Return values
634 The function returns +PRESS+ if the mouse button is held down, or +RELEASE+ if the
635 mouse button is not held down.
636 Description
637 The function queries the current state of a specific mouse button.
638 Notes
639 A window must be opened for the function to have any effect, and glfw::PollEvents, glfw::WaitEvents or
640 glfw::SwapBuffers must be called before any mouse button events are recorded and reported by
641 glfw::GetMouseButton.
642 +MOUSE_BUTTON_LEFT+ is equal to +MOUSE_BUTTON_1+
643 +MOUSE_BUTTON_RIGHT+ is equal to +MOUSE_BUTTON_2+
644 +MOUSE_BUTTON_MIDDLE+ is equal to +MOUSE_BUTTON_3+
649 "Return values
650 The function returns the current mouse position in xpos and ypos.
652 Description
653 The function returns the current mouse position. If the cursor is not hidden, the mouse position is the
654 cursor position, relative to the upper left corner of the window and limited to the client area of the
655 window. If the cursor is hidden, the mouse position is a virtual absolute position, not limited to any
656 boundaries except to those implied by the maximum number that can be represented by a signed integer
657 (normally -2147483648 to +2147483647).
659 Notes
660 A window must be opened for the function to have any effect, and glfw::PollEvents, glfw::WaitEvents or
661 glfw::SwapBuffers must be called before any mouse movements are recorded and reported by
662 glfw::GetMousePos.
667 "Parameters
668 xpos
669 Horizontal position of the mouse.
670 ypos
671 Vertical position of the mouse.
673 Description
674 The function changes the position of the mouse. If the cursor is visible (not disabled), the cursor will be
675 moved to the specified position, relative to the upper left corner of the window client area. If the cursor
676 is hidden (disabled), only the mouse position that is reported by GLFW is changed.
680 "Return values
681 The function returns the current mouse wheel position.
682 Description
683 The function returns the current mouse wheel position. The mouse wheel can be thought of as a third
684 mouse axis, which is available as a separate wheel or up/down stick on some mice.
685 Notes
686 A window must be opened for the function to have any effect, and glfw::PollEvents, glfw::WaitEvents or
687 glfw::SwapBuffers must be called before any mouse wheel movements are recorded and reported by
688 glfw::GetMouseWheel.
692 "Parameters
693 pos
694 Position of the mouse wheel.
695 Description
696 The function changes the position of the mouse wheel.
701 "Parameters
702 cbfun
703 Pointer to a callback function that will be called every time a key is pressed or released. The
704 function should have the following C language prototype:
705 void GLFWCALL functionname( int key, int action );
706 Where functionname is the name of the callback function, key is a key identifier, which is an
707 uppercase printable ISO 8859-1 character or a special key identifier (see table 3.3), and action is
708 either +PRESS+ or +RELEASE+
709 If cbfun is NULL, any previously selected callback function will be deselected.
710 Return values
711 none
712 Description
713 The function selects which function to be called upon a keyboard key event. The callback function is
714 called every time the state of a single key is changed (from released to pressed or vice versa). The
715 reported keys are unaffected by any modifiers (such as shift or alt).
716 A window has to be opened for this function to have any effect.
717 Notes
718 Keyboard events are recorded continuously, but only reported when glfw::PollEvents, glfw::WaitEvents
719 or glfw::SwapBuffers is called.
722 "Parameters
723 cbfun
724 Pointer to a callback function that will be called every time a printable character is generated by
725 the keyboard. The function should have the following C language prototype:
726 void GLFWCALL functionname( int character, int action );
727 Where functionname is the name of the callback function, character is a Unicode (ISO 10646)
728 character, and action is either +PRESS+ or +RELEASE+
729 If cbfun is NULL, any previously selected callback function will be deselected.
730 Return values
731 none
732 Description
733 The function selects which function to be called upon a keyboard character event. The callback function
734 is called every time a key that results in a printable Unicode character is pressed or released. Characters
735 are affected by modifiers (such as shift or alt).
736 A window has to be opened for this function to have any effect.
737 Notes
738 Character events are recorded continuously, but only reported when glfw::PollEvents, glfw::WaitEvents
739 or glfw::SwapBuffers is called.
740 Control characters, such as tab and carriage return, are not reported to the character callback function,
741 since they are not part of the Unicode character set. Use the key callback function for such events (see
742 glfw::SetKeyCallback).
743 The Unicode character set supports character codes above 255, so never cast a Unicode character to an
744 eight bit data type (e.g. the C language char type) without first checking that the character code is less
745 than 256. Also note that Unicode character codes 0 to 255 are equal to ISO 8859-1 (Latin 1).
748 "Parameters
749 cbfun
750 Pointer to a callback function that will be called every time a mouse button is pressed or released.
751 The function should have the following C language prototype:
752 void GLFWCALL functionname( int button, int action );
753 Where functionname is the name of the callback function, button is a mouse button identifier (see
754 table 3.4 on page 56), and action is either +PRESS+ or +RELEASE+
755 If cbfun is NULL, any previously selected callback function will be deselected.
756 Return values
757 none
758 Description
759 The function selects which function to be called upon a mouse button event.
760 A window has to be opened for this function to have any effect.
761 Notes
762 Mouse button events are recorded continuously, but only reported when glfw::PollEvents,
763 glfw::WaitEvents or glfw::SwapBuffers is called.
764 +MOUSE_BUTTON_LEFT+ is equal to +MOUSE_BUTTON_1+
765 +MOUSE_BUTTON_RIGHT+ is equal to +MOUSE_BUTTON_2+
766 +MOUSE_BUTTON_MIDDLE+ is equal to +MOUSE_BUTTON_3+
769 "Parameters
770 cbfun
771 Pointer to a callback function that will be called every time the mouse is moved. The function
772 should have the following C language prototype:
773 void GLFWCALL functionname( int x, int y );
774 Where functionname is the name of the callback function, and x and y are the mouse coordinates
775 (see glfw::GetMousePos for more information on mouse coordinates).
776 If cbfun is NULL, any previously selected callback function will be deselected.
777 Return values
778 none
779 Description
780 The function selects which function to be called upon a mouse motion event.
781 A window has to be opened for this function to have any effect.
782 Notes
783 Mouse motion events are recorded continuously, but only reported when glfw::PollEvents,
784 glfw::WaitEvents or glfw::SwapBuffers is called.
787 "Parameters
788 cbfun
789 Pointer to a callback function that will be called every time the mouse wheel is moved. The
790 function should have the following C language prototype:
791 void GLFWCALL functionname( int pos );
792 Where functionname is the name of the callback function, and pos is the mouse wheel position.
793 If cbfun is NULL, any previously selected callback function will be deselected.
794 Return values
795 none
796 Description
797 The function selects which function to be called upon a mouse wheel event.
798 A window has to be opened for this function to have any effect.
799 Notes
800 Mouse wheel events are recorded continuously, but only reported when glfw::PollEvents,
801 glfw::WaitEvents or glfw::SwapBuffers is called.
805 "Parameters
806 joy
807 A joystick identifier, which should be +JOYSTICK_n+ where n is in the range 1 to 16.
808 param
809 A token selecting which parameter the function should return (see table 3.5).
810 Return values
811 The function returns different parameters depending on the value of param. Table 3.5 lists valid param
812 values, and their corresponding return values.
813 Description
814 The function is used for acquiring various properties of a joystick.
815 Notes
816 The joystick information is updated every time the function is called.
817 No window has to be opened for joystick information to be valid.
820 (defcfun ("glfwGetJoystickPos" %get-joystick-pos) :int (joy :int) (pos :pointer) (numaxes :int))
823 "Parameters
824 joy
825 A joystick identifier, which should be +JOYSTICK_n+ where n is in the range 1 to 16.
826 numaxes
827 Specifies how many axes should be returned.
828 Return values
829 An list that will hold the positional values for all requested axes.
830 If the joystick is not supported or connected, the function will
831 return nil.
833 Description
834 The function queries the current position of one or more axes of a joystick. The positional values are
835 returned in an array, where the first element represents the first axis of the joystick (normally the X
836 axis). Each position is in the range -1.0 to 1.0. Where applicable, the positive direction of an axis is
837 right, forward or up, and the negative direction is left, back or down.
838 If numaxes exceeds the number of axes supported by the joystick, or if the joystick is not available, the
839 unused elements in the pos array will be set to 0.0 (zero).
841 Notes
842 The joystick state is updated every time the function is called, so there is no need to call glfw::PollEvents
843 or glfw::WaitEvents for joystick state to be updated.
844 Use glfw::GetJoystickParam to retrieve joystick capabilities, such as joystick availability and number of
845 supported axes.
846 No window has to be opened for joystick input to be valid.
847 "
853 (defcfun ("glfwGetJoystickButtons" %get-joystick-buttons) :int (joy :int) (buttons :pointer) (numbuttons :int))
855 "Parameters
856 joy
857 A joystick identifier, which should be +JOYSTICK_n+ where n is in the range 1 to 16.
858 numbuttons
859 Specifies how many buttons should be returned.
860 Return values
861 A list that will hold the button states for all requested buttons.
862 The function returns the number of actually returned buttons. This is the minimum of numbuttons and
863 the number of buttons supported by the joystick. If the joystick is not supported or connected, the
864 function will return 0 (zero).
866 Description
867 The function queries the current state of one or more buttons of a joystick. The button states are
868 returned in an array, where the first element represents the first button of the joystick. Each state can be
869 either +PRESS+ or +RELEASE+
870 If numbuttons exceeds the number of buttons supported by the joystick, or if the joystick is not
871 available, the unused elements in the buttons array will be set to +RELEASE+
873 Notes
874 The joystick state is updated every time the function is called, so there is no need to call glfw::PollEvents
875 or glfw::WaitEvents for joystick state to be updated.
876 Use glfw::GetJoystickParam to retrieve joystick capabilities, such as joystick availability and number of
877 supported buttons.
878 No window has to be opened for joystick input to be valid.
879 "
886 "Return values
887 The function returns the value of the high precision timer. The time is measured in seconds, and is
888 returned as a double precision floating point value.
890 Description
891 The function returns the state of a high precision timer. Unless the timer has been set by the
892 glfw::SetTime function, the time is measured as the number of seconds that have passed since glfw::Init
893 was called.
895 Notes
896 The resolution of the timer depends on which system the program is running on. The worst case
897 resolution is somewhere in the order of 10 ms, while for most systems the resolution should be better
898 than 1us.
902 "Parameters
903 time
904 Time (in seconds) that the timer should be set to.
906 Description
907 The function sets the current time of the high precision timer to the specified time. Subsequent calls to
908 glfw::GetTime will be relative to this time. The time is given in seconds.
912 "Parameters
913 time
914 Time, in seconds, to sleep.
916 Description
917 The function puts the calling thread to sleep for the requested period of time. Only the calling thread is
918 put to sleep. Other threads within the same process can still execute.
920 Notes
921 There is usually a system dependent minimum time for which it is possible to sleep. This time is
922 generally in the range 1 ms to 20 ms, depending on thread sheduling time slot intervals etc. Using a
923 shorter time as a parameter to glfw::Sleep can give one of two results: either the thread will sleep for the
924 minimum possible sleep time, or the thread will not sleep at all (glfw::Sleep returns immediately). The
936 "Parameters
937 name
938 A null terminated ISO 8859-1 string holding the name of the file that should be read.
939 img
940 Pointer to a GLFWimage struct, which will hold the information about the loaded image (if the
941 read was successful).
942 flags
943 Flags for controlling the image reading process. Valid flags are listed in table 3.6
944 Return values
945 The function returns t if the image was loaded successfully. Otherwise nil is
946 returned.
947 Description
948 The function reads an image from the file specified by the parameter name and returns the image
949 information and data in a GLFWimage structure, which has the following definition:
951 typedef struct {
952 int Width, Height; // Image dimensions
953 int Format; // OpenGL pixel format
954 int BytesPerPixel; // Number of bytes per pixel
955 unsigned char *Data; // Pointer to pixel data
956 } GLFWimage;
958 Width and Height give the dimensions of the image. Format specifies an OpenGL pixel format,
959 which can be GL_LUMINANCE or GL_ALPHA (for gray scale images), GL_RGB or GL_RGBA.
960 BytesPerPixel specifies the number of bytes per pixel. Data is a pointer to the actual pixel data.
962 By default the read image is rescaled to the nearest larger 2m ? 2n resolution using bilinear
963 interpolation, if necessary, which is useful if the image is to be used as an OpenGL texture. This
964 behavior can be disabled by setting the GLFW_NO_RESCALE_BIT flag.
965 Unless the flag GLFW_ORIGIN_UL_BIT is set, the first pixel in img->Data is the lower left corner of
966 the image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left corner.
967 For single component images (i.e. gray scale), Format is set to GL_ALPHA if the flag
969 +ALPHA_MAP_BIT+ flag is set, otherwise Format is set to GL_LUMINANCE.
970 Notes
971 glfw::ReadImage supports the Truevision Targa version 1 file format (.TGA). Supported pixel formats
972 are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color + alpha.
973 Paletted images are translated into true color or true color + alpha pixel formats.
974 Please note that OpenGL 1.0 does not support single component alpha maps, so do not use images
975 with Format = GL_ALPHA directly as textures under OpenGL 1.0.
980 "Parameters
981 data
982 The memory buffer holding the contents of the file that should be read.
983 size
984 The size, in bytes, of the memory buffer.
985 img
986 Pointer to a GLFWimage struct, which will hold the information about the loaded image (if the
987 read was successful).
988 flags
989 Flags for controlling the image reading process. Valid flags are listed in table 3.6
990 Return values
991 The function returns t if the image was loaded successfully. Otherwise nil is
992 returned.
993 Description
994 The function reads an image from the memory buffer specified by the parameter data and returns the
995 image information and data in a GLFWimage structure, which has the following definition:
997 typedef struct {
998 int Width, Height; // Image dimensions
999 int Format; // OpenGL pixel format
1000 int BytesPerPixel; // Number of bytes per pixel
1001 unsigned char *Data; // Pointer to pixel data
1002 } GLFWimage;
1004 Width and Height give the dimensions of the image. Format specifies an OpenGL pixel format,
1005 which can be GL_LUMINANCE or GL_ALPHA (for gray scale images), GL_RGB or GL_RGBA.
1006 BytesPerPixel specifies the number of bytes per pixel. Data is a pointer to the actual pixel data.
1008 By default the read image is rescaled to the nearest larger 2m ? 2n resolution using bilinear
1009 interpolation, if necessary, which is useful if the image is to be used as an OpenGL texture. This
1010 behavior can be disabled by setting the GLFW_NO_RESCALE_BIT flag.
1011 Unless the flag GLFW_ORIGIN_UL_BIT is set, the first pixel in img->Data is the lower left corner of
1012 the image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left corner.
1013 For single component images (i.e. gray scale), Format is set to GL_ALPHA if the flag
1014 +ALPHA_MAP_BIT+ flag is set, otherwise Format is set to GL_LUMINANCE.
1015 Notes
1016 glfw::ReadMemoryImage supports the Truevision Targa version 1 file format (.TGA). Supported pixel
1017 formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color +
1018 alpha.
1019 Paletted images are translated into true color or true color + alpha pixel formats.
1020 Please note that OpenGL 1.0 does not support single component alpha maps, so do not use images
1021 with Format = GL_ALPHA directly as textures under OpenGL 1.0.
1025 "Parameters
1026 img
1027 Pointer to a GLFWimage struct.
1028 Description
1029 The function frees any memory occupied by a loaded image, and clears all the fields of the GLFWimage
1030 struct. Any image that has been loaded by the glfw::ReadImage function should be deallocated using
1034 "Parameters
1035 name
1036 An ISO 8859-1 string holding the name of the file that should be loaded.
1037 flags
1038 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1039 Return values
1040 The function returns t if the texture was loaded successfully. Otherwise nil is
1041 returned.
1043 Description
1045 The function reads an image from the file specified by the parameter
1046 name and uploads the image to OpenGL texture memory (using the
1047 glTexImage2D function). If the GLFW_BUILD_MIPMAPS_BIT flag is set,
1048 all mipmap levels for the loaded texture are generated and uploaded to
1049 texture memory. Unless the flag +ORIGIN_UL_BIT+ is set, the origin of
1050 the texture is the lower left corner of the loaded image. If the flag
1051 +ORIGIN_UL_BIT+ is set, however, the first pixel is the upper left
1052 corner. For single component images (i.e. gray scale), the texture is
1053 uploaded as an alpha mask if the flag +ALPHA_MAP_BIT+ flag is set,
1054 otherwise it is uploaded as a luminance texture.
1056 Notes
1057 glfw::LoadTexture2D supports the Truevision Targa version 1 file format (.TGA). Supported pixel
1058 formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color +
1059 alpha.
1060 Paletted images are translated into true color or true color + alpha pixel formats.
1061 The read texture is always rescaled to the nearest larger 2m ? 2n resolution using bilinear interpolation,
1062 if necessary, since OpenGL requires textures to have a 2m ? 2n resolution.
1063 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1064 the OpenGL implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1065 generated by GLFW in software.
1067 Since OpenGL 1.0 does not support single component alpha maps, alpha map textures are converted
1068 to RGBA format under OpenGL 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1069 texture is a single component texture. The red, green and blue components are set to 1.0.
1074 "Parameters
1075 data
1076 The memory buffer holding the contents of the file that should be loaded.
1077 size
1078 The size, in bytes, of the memory buffer.
1079 flags
1080 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1081 Return values
1082 The function returns t if the texture was loaded successfully. Otherwise nil is
1083 returned.
1085 Description
1086 The function reads an image from the memory buffer specified by the parameter data and uploads the
1087 image to OpenGL texture memory (using the glTexImage2D function).
1088 If the GLFW_BUILD_MIPMAPS_BIT flag is set, all mipmap levels for the loaded texture are
1089 generated and uploaded to texture memory.
1090 Unless the flag +ORIGIN_UL_BIT+ is set, the origin of the texture is the lower left corner of the
1091 loaded image. If the flag +ORIGIN_UL_BIT+ is set, however, the first pixel is the upper left
1092 corner.
1093 For single component images (i.e. gray scale), the texture is uploaded as an alpha mask if the flag
1094 +ALPHA_MAP_BIT+ flag is set, otherwise it is uploaded as a luminance texture.
1096 Notes
1097 glfw::LoadMemoryTexture2D supports the Truevision Targa version 1 file format (.TGA). Supported
1098 pixel formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color
1099 + alpha.
1100 Paletted images are translated into true color or true color + alpha pixel formats.
1101 The read texture is always rescaled to the nearest larger 2m ? 2n resolution using bilinear interpolation,
1102 if necessary, since OpenGL requires textures to have a 2m ? 2n resolution.
1103 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1104 the OpenGL implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1105 generated by GLFW in software.
1107 Since OpenGL 1.0 does not support single component alpha maps, alpha map textures are converted
1108 to RGBA format under OpenGL 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1109 texture is a single component texture. The red, green and blue components are set to 1.0.
1115 "Parameters
1116 img
1117 Pointer to a GLFWimage struct holding the information about the image to be loaded.
1118 flags
1119 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1120 Return values
1121 The function returns t if the texture was loaded successfully. Otherwise nil is
1122 returned.
1124 Description
1125 The function uploads the image specified by the parameter img to OpenGL texture memory (using
1126 the glTexImage2D function).
1127 If the +BUILD_MIPMAPS_BIT+ flag is set, all mipmap levels for the loaded texture are
1128 generated and uploaded to texture memory.
1129 Unless the flag +ORIGIN_UL_BIT+ is set, the origin of the texture is the lower left corner of the
1130 loaded image. If the flag +ORIGIN_UL_BIT+ is set, however, the first pixel is the upper left
1131 corner.
1132 For single component images (i.e. gray scale), the texture is uploaded as an alpha mask if the flag
1133 +ALPHA_MAP_BIT+ flag is set, otherwise it is uploaded as a luminance texture.
1135 Notes
1136 glfw::LoadTextureImage2D supports the Truevision Targa version 1 file format (.TGA). Supported
1137 pixel formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color
1138 + alpha.
1139 Paletted images are translated into true color or true color + alpha pixel formats.
1140 The read texture is always rescaled to the nearest larger 2m ? 2n resolution using bilinear interpolation,
1141 if necessary, since OpenGL requires textures to have a 2m ? 2n resolution.
1142 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1143 the OpenGL implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1144 generated by GLFW in software.
1146 Since OpenGL 1.0 does not support single component alpha maps, alpha map textures are converted
1147 to RGBA format under OpenGL 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1152 "Parameters
1153 extension
1154 A null terminated ISO 8859-1 string containing the name of an OpenGL extension.
1155 Return values
1156 The function returns t if the extension is supported. Otherwise it returns nil.
1157 Description
1158 The function does a string search in the list of supported OpenGL extensions to find if the specified
1159 extension is listed.
1160 Notes
1162 An OpenGL context must be created before this function can be called (i.e. an OpenGL window
1163 must have been opened with glfwOpenWindow).
1164 In addition to checking for OpenGL extensions, GLFW also checks for extensions in the operating
1165 system ?glue API?, such as WGL extensions under Windows and glX extensions under the X Window
1166 System.
1170 "Parameters
1171 procname
1172 A null terminated ISO 8859-1 string containing the name of an OpenGL extension function.
1173 Return values
1174 The function returns the pointer to the specified OpenGL function if it is supported, otherwise
1175 NULL is returned.
1176 Description
1177 The function acquires the pointer to an OpenGL extension function. Some (but not all) OpenGL
1178 extensions define new API functions, which are usually not available through normal linking. It is
1179 therefore necessary to get access to those API functions at runtime.
1180 Notes
1182 An OpenGL context must be created before this function can be called (i.e. an OpenGL window
1183 must have been opened with glfwOpenWindow).
1184 Some systems do not support dynamic function pointer retrieval, in which case glfwGetProcAddress
1185 will always return NULL.
1191 "Return values
1192 The function returns the major and minor version numbers and the revision for the currently used
1193 OpenGL implementation as a list (major minor rev).
1195 Description
1196 The function returns the OpenGL implementation version. This is a convenient function that parses
1197 the version number information from the string returned by calling
1198 glGetString( GL_VERSION ). The OpenGL version information can be used to determine
1199 what functionality is supported by the used OpenGL implementation.
1201 Notes
1202 An OpenGL context must be created before this function can be called (i.e. an OpenGL window
1211 "Parameters
1212 fun
1213 A pointer to a function that acts as the entry point for the new thread. The function should have
1214 the following C language prototype:
1215 void GLFWCALL functionname( void *arg );
1216 Where functionname is the name of the thread function, and arg is the user supplied argument
1217 (see below).
1218 arg
1219 An arbitrary argument for the thread. arg will be passed as the argument to the thread function
1220 pointed to by fun. For instance, arg can point to data that is to be processed by the thread.
1221 Return values
1222 The function returns a thread identification number if the thread was created successfully. This number
1223 is always positive. If the function fails, a negative number is returned.
1224 Description
1225 The function creates a new thread, which executes within the same address space as the calling process.
1226 The thread entry point is specified with the fun argument.
1227 Once the thread function fun returns, the thread dies.
1228 Notes
1229 Even if the function returns a positive thread ID, indicating that the thread was created successfully, the
1230 thread may be unable to execute, for instance if the thread start address is not a valid thread entry point.
1233 "Parameters
1234 ID
1235 A thread identification handle, which is returned by glfw::CreateThread or glfw::GetThreadID.
1236 Description
1237 The function kills a running thread and removes it from the thread list.
1238 Notes
1239 This function is a very dangerous operation, which may interrupt a thread in the middle of an important
1240 operation, and its use is discouraged. You should always try to end a thread in a graceful way using
1241 thread communication, and use glfw::WaitThread in order to wait for the thread to die.
1244 "Parameters
1245 ID
1246 A thread identification handle, which is returned by glfw::CreateThread or glfw::GetThreadID.
1247 waitmode
1248 Can be either +WAIT+ or +NOWAIT+
1249 Return values
1250 The function returns t if the specified thread died after the function was called, or the thread
1251 did not exist, in which case glfw::WaitThread will return immediately regardless of waitmode. The
1252 function returns nil if waitmode is +NOWAIT+ and the specified thread exists and is still
1253 running.
1256 "Return values
1257 The function returns a thread identification handle for the calling thread.
1258 Description
1259 The function determines the thread ID for the calling thread. The ID is the same value as was returned
1260 by glfw::CreateThread when the thread was created.
1264 "Return values
1265 The function returns a mutex handle, or NULL if the mutex could not be created.
1266 Description
1267 The function creates a mutex object, which can be used to control access to data that is shared between
1268 threads.
1271 "Parameters
1272 mutex
1273 A mutex object handle.
1274 Description
1275 The function destroys a mutex object. After a mutex object has been destroyed, it may no longer be
1276 used by any thread.
1279 "Parameters
1280 mutex
1281 A mutex object handle.
1282 Description
1283 The function will acquire a lock on the selected mutex object. If the mutex is already locked by another
1284 thread, the function will block the calling thread until it is released by the locking thread. Once the
1285 function returns, the calling thread has an exclusive lock on the mutex. To release the mutex, call
1286 glfw::UnlockMutex.
1289 "Parameters
1290 mutex
1291 A mutex object handle.
1292 Description
1293 The function releases the lock of a locked mutex object.
1297 "Parameters
1298 mutex
1299 A mutex object handle.
1300 forms
1301 Body of code to execute
1302 Description
1303 This macro will acquire a lock on the selected mutex object using glfw::LockMutex and release it afterwards
1304 using glfw::UnlockMutex.
1305 So, forms will not execute until an exclusive lock is held.
1306 The lock is then released when the stack is unwound."
1314 "Return values
1315 The function returns a condition variable handle, or NULL if the condition variable could not be
1316 created.
1317 Description
1318 The function creates a condition variable object, which can be used to synchronize threads.
1321 "Parameters
1322 cond
1323 A condition variable object handle.
1324 Description
1325 The function destroys a condition variable object. After a condition variable object has been destroyed,
1326 it may no longer be used by any thread.
1329 " arameters
1330 cond
1331 A condition variable object handle.
1332 mutex
1333 A mutex object handle.
1334 timeout
1335 Maximum time to wait for the condition variable. The parameter can either be a positive time (in
1336 seconds), or +INFINITY+
1337 Description
1338 The function atomically unlocks the mutex specified by mutex, and waits for the condition variable cond
1339 to be signaled. The thread execution is suspended and does not consume any CPU time until the
1340 condition variable is signaled or the amount of time specified by timeout has passed. If timeout is
1341 +INFINITY+ glfw::WaitCond will wait forever for cond to be signaled. Before returning to the
1342 calling thread, glfw::WaitCond automatically re-acquires the mutex.
1343 Notes
1344 The mutex specified by mutex must be locked by the calling thread before entrance to glfw::WaitCond.
1345 A condition variable must always be associated with a mutex, to avoid the race condition where a thread
1346 prepares to wait on a condition variable and another thread signals the condition just before the first
1347 thread actually waits on it.
1350 "Parameters
1351 cond
1352 A condition variable object handle.
1353 Description
1354 The function restarts one of the threads that are waiting on the condition variable cond. If no threads are
1355 waiting on cond, nothing happens. If several threads are waiting on cond, exactly one is restarted, but it
1356 is not specified which.
1357 Notes
1358 When several threads are waiting for the condition variable, which thread is started depends on
1359 operating system scheduling rules, and may vary from system to system and from time to time.
1362 "Parameters
1363 cond
1364 A condition variable object handle.
1365 Description
1366 The function restarts all the threads that are waiting on the condition variable cond. If no threads are
1367 waiting on cond, nothing happens.
1368 Notes
1369 When several threads are waiting for the condition variable, the order in which threads are started
1370 depends on operating system scheduling rules, and may vary from system to system and from time to
1371 time.
1375 "Return values
1376 The function returns the number of active processors in the system.
1377 Description
1378 The function determines the number of active processors in the system.
1379 Notes
1380 Systems with several logical processors per physical processor, also known as SMT (Symmetric Multi
1381 Threading) processors, will report the number of logical processors.
1384 "Parameters
1385 token
1386 A value specifying a feature to enable or disable. Valid tokens are listed in table 3.8.
1387 Return values
1388 none
1389 Description
1390 glfw::Enable is used to enable a certain feature, while glfw::Disable is used to disable it. Below follows a
1391 description of each feature.
1392 +AUTO_POLL_EVENTS+
1393 When +AUTO_POLL_EVENTS+ is enabled, glfw::PollEvents is automatically called each time
1394 that glfw::SwapBuffers is called.
1395 When +AUTO_POLL_EVENTS+ is disabled, calling glfw::SwapBuffers will not result in a call to
1396 glfw::PollEvents. This can be useful if glfw::SwapBuffers needs to be called from within a callback
1397 function, since calling glfw::PollEvents from a callback function is not allowed.
1398 +KEY_REPEAT+
1399 When +KEY_REPEAT+ is enabled, the key and character callback functions are called repeatedly
1400 when a key is held down long enough (according to the system key repeat configuration).
1401 When +KEY_REPEAT+ is disabled, the key and character callback functions are only called once
1402 when a key is pressed (and once when it is released).
1403 +MOUSE_CURSOR+
1404 When +MOUSE_CURSOR+ is enabled, the mouse cursor is visible, and mouse coordinates are
1405 relative to the upper left corner of the client area of the GLFW window. The coordinates are limited to
1406 the client area of the window.
1407 When +MOUSE_CURSOR+ is disabled, the mouse cursor is invisible, and mouse coordinates are
1408 not limited to the drawing area of the window. It is as if the mouse coordinates are recieved directly
1409 from the mouse, without being restricted or manipulated by the windowing system.
1410 +STICKY_KEYS+
1411 When +STICKY_KEYS+ is enabled, keys which are pressed will not be released until they are
1412 physically released and checked with glfw::GetKey. This behavior makes it possible to catch keys that
1413 were pressed and then released again between two calls to glfw::PollEvents, glfw::WaitEvents or
1414 glfw::SwapBuffers, which would otherwise have been reported as released. Care should be taken when
1415 using this mode, since keys that are not checked with glfw::GetKey will never be released. Note also that
1416 enabling +STICKY_KEYS+ does not affect the behavior of the keyboard callback functionality.
1417 When +STICKY_KEYS+ is disabled, the status of a key that is reported by glfw::GetKey is always
1418 the physical state of the key. Disabling +STICKY_KEYS+ also clears the sticky information for
1419 all keys.
1420 +STICKY_MOUSE_BUTTONS+
1421 When +STICKY_MOUSE_BUTTONS+ is enabled, mouse buttons that are pressed will not be
1422 released until they are physically released and checked with glfw::GetMouseButton. This behavior
1423 makes it possible to catch mouse buttons which were pressed and then released again between two calls
1424 to glfw::PollEvents, glfw::WaitEvents or glfw::SwapBuffers, which would otherwise have been reported
1425 as released. Care should be taken when using this mode, since mouse buttons that are not checked with
1426 glfw::GetMouseButton will never be released. Note also that enabling
1427 +STICKY_MOUSE_BUTTONS+ does not affect the behavior of the mouse button callback
1428 functionality.
1429 When +STICKY_MOUSE_BUTTONS+ is disabled, the status of a mouse button that is reported
1430 by glfw::GetMouseButton is always the physical state of the mouse button. Disabling
1431 +STICKY_MOUSE_BUTTONS+ also clears the sticky information for all mouse buttons.
1432 +SYSTEM_KEYS+
1433 When +SYSTEM_KEYS+ is enabled, pressing standard system key combinations, such as
1434 ALT+TAB under Windows, will give the normal behavior. Note that when ALT+TAB is issued under
1435 Windows in this mode so that the GLFW application is deselected when GLFW is operating in
1436 fullscreen mode, the GLFW application window will be minimized and the video mode will be set to
1437 the original desktop mode. When the GLFW application is re-selected, the video mode will be set to
1438 the GLFW video mode again.
1439 When +SYSTEM_KEYS+ is disabled, pressing standard system key combinations will have no
1440 effect, since those key combinations are blocked by GLFW. This mode can be useful in situations when
1441 the GLFW program must not be interrupted (normally for games in fullscreen mode).
1444 "Parameters
1445 token
1446 A value specifying a feature to enable or disable. Valid tokens are listed in table 3.8.
1447 Return values
1448 none
1449 Description
1450 glfw::Enable is used to enable a certain feature, while glfw::Disable is used to disable it. Below follows a
1451 description of each feature.
1452 +AUTO_POLL_EVENTS+
1453 When +AUTO_POLL_EVENTS+ is enabled, glfw::PollEvents is automatically called each time
1454 that glfw::SwapBuffers is called.
1455 When +AUTO_POLL_EVENTS+ is disabled, calling glfw::SwapBuffers will not result in a call to
1456 glfw::PollEvents. This can be useful if glfw::SwapBuffers needs to be called from within a callback
1457 function, since calling glfw::PollEvents from a callback function is not allowed.
1458 +KEY_REPEAT+
1459 When +KEY_REPEAT+ is enabled, the key and character callback functions are called repeatedly
1460 when a key is held down long enough (according to the system key repeat configuration).
1461 When +KEY_REPEAT+ is disabled, the key and character callback functions are only called once
1462 when a key is pressed (and once when it is released).
1463 +MOUSE_CURSOR+
1464 When +MOUSE_CURSOR+ is enabled, the mouse cursor is visible, and mouse coordinates are
1465 relative to the upper left corner of the client area of the GLFW window. The coordinates are limited to
1466 the client area of the window.
1467 When +MOUSE_CURSOR+ is disabled, the mouse cursor is invisible, and mouse coordinates are
1468 not limited to the drawing area of the window. It is as if the mouse coordinates are recieved directly
1469 from the mouse, without being restricted or manipulated by the windowing system.
1470 +STICKY_KEYS+
1471 When +STICKY_KEYS+ is enabled, keys which are pressed will not be released until they are
1472 physically released and checked with glfw::GetKey. This behavior makes it possible to catch keys that
1473 were pressed and then released again between two calls to glfw::PollEvents, glfw::WaitEvents or
1474 glfw::SwapBuffers, which would otherwise have been reported as released. Care should be taken when
1475 using this mode, since keys that are not checked with glfw::GetKey will never be released. Note also that
1476 enabling +STICKY_KEYS+ does not affect the behavior of the keyboard callback functionality.
1477 When +STICKY_KEYS+ is disabled, the status of a key that is reported by glfwGetKey is always
1478 the physical state of the key. Disabling +STICKY_KEYS+ also clears the sticky information for
1479 all keys.
1480 +STICKY_MOUSE_BUTTONS+
1481 When +STICKY_MOUSE_BUTTONS+ is enabled, mouse buttons that are pressed will not be
1482 released until they are physically released and checked with glfw::GetMouseButton. This behavior
1483 makes it possible to catch mouse buttons which were pressed and then released again between two calls
1484 to glfw::PollEvents, glfw::WaitEvents or glfw::SwapBuffers, which would otherwise have been reported
1485 as released. Care should be taken when using this mode, since mouse buttons that are not checked with
1486 glfw::GetMouseButton will never be released. Note also that enabling
1487 +STICKY_MOUSE_BUTTONS+ does not affect the behavior of the mouse button callback
1488 functionality.
1489 When +STICKY_MOUSE_BUTTONS+ is disabled, the status of a mouse button that is reported
1490 by glfwGetMouseButton is always the physical state of the mouse button. Disabling
1491 +STICKY_MOUSE_BUTTONS+ also clears the sticky information for all mouse buttons.
1492 +SYSTEM_KEYS+
1493 When +SYSTEM_KEYS+ is enabled, pressing standard system key combinations, such as
1494 ALT+TAB under Windows, will give the normal behavior. Note that when ALT+TAB is issued under
1495 Windows in this mode so that the GLFW application is deselected when GLFW is operating in
1496 fullscreen mode, the GLFW application window will be minimized and the video mode will be set to
1497 the original desktop mode. When the GLFW application is re-selected, the video mode will be set to
1498 the GLFW video mode again.
1499 When +SYSTEM_KEYS+ is disabled, pressing standard system key combinations will have no
1500 effect, since those key combinations are blocked by GLFW. This mode can be useful in situations when
1501 the GLFW program must not be interrupted (normally for games in fullscreen mode).