| blob | ea192738e7e95e86820824b8f5a0278c69b4caf0 |
7 #:cond
9 (:export #:+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 #:do-window #: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 #:with-init #:with-init-window #:with-lock-mutex #:with-open-window))
19 |#
32 args)))
35 args))))
42 args))
44 ,docstring
49 out-args)))))))
57 ;; Key and button state/action definitions
61 ;; Keyboard key definitions: 8-bit ISO-8859-1 (Latin 1) encoding is used
62 ;; for printable keys (such as A-Z, 0-9 etc), and values above 256
63 ;; represent special (non-printable) keys (e.g. F1, Page Up etc).
131 ;; Mouse button definitions
142 ;; Mouse button aliases
147 ;; Joystick identifiers
167 ;;========================================================================
168 ;; Other definitions
169 ;;========================================================================
171 ;; glfwOpenWindow modes
175 ;; glfwGetWindowParam tokens
187 ;; The following constants are used for both glfwGetWindowParam
188 ;; and glfwOpenWindowHint
199 ;; glfwEnable/glfwDisable tokens
207 ;; glfwWaitThread wait modes
211 ;; glfwGetJoystickParam tokens
216 ;; glfwReadImage/glfwLoadTexture2D flags
222 ;; Time spans longer than this (seconds) are considered to be infinity
226 "Return values
227 If the function succeeds, t is returned.
228 If the function fails, nil is returned.
230 The glfwInit function initializes GLFW. No other GLFW functions may be used before this function
231 has been called.
233 Notes
234 This function may take several seconds to complete on some systems, while on other systems it may
238 "The function terminates GLFW. Among other things it closes the window, if it is opened, and kills any
244 "Return values
245 The function returns the major and minor version numbers and the revision for the currently linked
249 "Call glfw:init, execute forms and clean-up with glfw:terminate once finished.
250 This makes a nice wrapper to an application higher-level form.
251 Signals an error on failure to initialize. Wrapped in a block named glfw:with-init."
267 "width
268 The width of the window. If width is zero, it will be calculated as width = 4/3 height, if height is
269 not zero. If both width and height are zero, then width will be set to 640.
270 height
271 The height of the window. If height is zero, it will be calculated as height = 3/4 width, if width is
272 not zero. If both width and height are zero, then height will be set to 480.
273 redbits, greenbits, bluebits
274 The number of bits to use for each color component of the color buffer (0 means default color
275 depth). For instance, setting redbits=5, greenbits=6, and bluebits=5 will generate a 16-bit color
276 buffer, if possible.
277 alphabits
278 The number of bits to use for the alpha buffer (0 means no alpha buffer).
279 depthbits
280 The number of bits to use for the depth buffer (0 means no depth buffer).
281 stencilbits
282 The number of bits to use for the stencil buffer (0 means no stencil buffer).
283 mode
284 Selects which type of OpenGL™ window to use. mode can be either GLFW_WINDOW, which
285 will generate a normal desktop window, or GLFW_FULLSCREEN, which will generate a
286 window which covers the entire screen. When GLFW_FULLSCREEN is selected, the video
287 mode will be changed to the resolution that closest matches the width and height parameters.
289 Return values
290 If the function succeeds, t is returned.
291 If the function fails, nil is returned.
293 Description
294 The function opens a window that best matches the parameters given to the function. How well the
295 resulting window matches the desired window depends mostly on the available hardware and
296 OpenGL™ drivers. In general, selecting a fullscreen mode has better chances of generating a close
297 match than does a normal desktop window, since GLFW can freely select from all the available video
298 modes. A desktop window is normally restricted to the video mode of the desktop.
300 Notes
301 For additional control of window properties, see glfwOpenWindowHint.
302 In fullscreen mode the mouse cursor is hidden by default, and any system screensavers are prohibited
303 from starting. In windowed mode the mouse cursor is visible, and screensavers are allowed to start. To
304 change the visibility of the mouse cursor, use glfwEnable or glfwDisable with the argument
305 GLFW_MOUSE-CURSOR.
306 In order to determine the actual properties of an opened window, use glfwGetWindowParam and
307 glfwGetWindowSize (or glfwSetWindowSizeCallback).
308 "
313 "target
314 Can be any of the constants in the table 3.1.
315 hint
316 An integer giving the value of the corresponding target (see table 3.1).
318 Description
319 The function sets additional properties for a window that is to be opened. For a hint to be registered, the
320 function must be called before calling glfwOpenWindow. When the glfwOpenWindow function is
321 called, any hints that were registered with the glfwOpenWindowHint function are used for setting the
322 corresponding window properties, and then all hints are reset to their default values.
324 Notes
325 In order to determine the actual properties of an opened window, use glfwGetWindowParam (after the
326 window has been opened).
327 GLFW_STEREO is a hard constraint. If stereo rendering is requested, but no stereo rendering capable
328 pixel formats / visuals are available, glfwOpenWindow will fail.
329 The GLFW_REFRESH-RATE property should be used with caution. Most systems have default values
330 for monitor refresh rates that are optimal for the specific system. Specifying the refresh rate can
331 override these settings, which can result in suboptimal operation. The monitor may be unable to display
332 the resulting video signal, or in the worst case it may even be damaged!
342 "Wraps forms such that there is an open window for them to execute in and cleans up the
343 window afterwards. An error is signalled if there was an error opening the window.
344 Takes the same parameters as open-window, with the addition of 'title' which will
345 set the window title after opening.
346 Wrapped in a block named glfw:with-open-window."
347 `(if (%open-window ,width ,height ,redbits ,greenbits ,bluebits ,alphabits ,depthbits ,stencilbits ,mode)
360 "Wraps forms in with-init, with-open-window. Passes through the other arguments to open-window."
362 (with-open-window (,title ,width ,height ,redbits ,greenbits ,bluebits ,alphabits ,depthbits ,stencilbits ,mode)
370 "High-level convenience macro for initializing glfw, opening a window (given the optional window parameters),
371 setting the title given,
372 running setup-forms and then running forms in a loop, with calls to swap-buffers after each loop iteration.
373 The loop is in a block named do-window [so can be exited by a call to (return-from glfw:do-window)].
374 If the window is closed, the loop is also exited."
375 `(with-init-window (,title ,width ,height ,redbits ,greenbits ,bluebits ,alphabits ,depthbits ,stencilbits ,mode)
376 ,@setup-forms
378 ,@forms
384 "Parameters
385 cbfun
386 Pointer to a callback function that will be called when a user requests that the window should be
387 closed, typically by clicking the window close icon (e.g. the cross in the upper right corner of a
388 window under Microsoft Windows). The function should have the following C language
389 prototype:
390 int GLFWCALL functionname( void );
391 Where functionname is the name of the callback function. The return value of the callback
392 function indicates wether or not the window close action should continue. If the function returns
393 GL_TRUE, the window will be closed. If the function returns GL_FALSE, the window will not
394 be closed.
395 If cbfun is NULL, any previously selected callback function will be deselected.
397 If you declare your callback as returning gl:boolean, you can use t and nil as return types.
399 Description
400 The function selects which function to be called upon a window close event.
401 A window has to be opened for this function to have any effect.
403 Notes
404 Window close events are recorded continuously, but only reported when glfwPollEvents,
405 glfwWaitEvents or glfwSwapBuffers is called.
406 The OpenGL™ context is still valid when this function is called.
407 Note that the window close callback function is not called when glfwCloseWindow is called, but only
408 when the close request comes from the window manager.
409 Do not call glfwCloseWindow from a window close callback function. Close the window by returning
410 GL_TRUE from the function.
414 "Parameters
415 title
416 Pointer to a null terminated ISO 8859-1 (8-bit Latin 1) string that holds the title of the window.
418 Description
419 The function changes the title of the opened window.
421 Notes
422 The title property of a window is often used in situations other than for the window title, such as the title
426 "Parameters
427 width
428 Width of the window.
429 height
430 Height of the window.
431 Return values
432 none
433 Description
434 The function changes the size of an opened window. The width and height parameters denote the size of
435 the client area of the window (i.e. excluding any window borders and decorations).
436 If the window is in fullscreen mode, the video mode will be changed to a resolution that closest matches
437 the width and height parameters (the number of color bits will not be changed).
438 Notes
439 The OpenGL™ context is guaranteed to be preserved after calling glfwSetWindowSize, even if the
440 video mode is changed.
444 "Parameters
445 x
446 Horizontal position of the window, relative to the upper left corner of the desktop.
447 y
448 Vertical position of the window, relative to the upper left corner of the desktop.
449 Return values
450 none
451 Description
452 The function changes the position of an opened window. It does not have any effect on a fullscreen
453 window.
458 "The function is used for determining the size of an opened window. The returned values are dimensions
459 of the client area of the window (i.e. excluding any window borders and decorations).
460 (list width height)"
468 "Parameters
469 cbfun
470 Pointer to a callback function that will be called every time the window size changes. The
471 function should have the following C language prototype:
472 void GLFWCALL functionname( int width, int height );
473 Where functionname is the name of the callback function, and width and height are the
474 dimensions of the window client area.
475 If cbfun is NULL, any previously selected callback function will be deselected.
476 Return values
477 none
478 Description
479 The function selects which function to be called upon a window size change event.
480 A window has to be opened for this function to have any effect.
481 Notes
482 Window size changes are recorded continuously, but only reported when glfwPollEvents,
486 "Iconify a window. If the window is in fullscreen mode, then the desktop video mode will be restored.")
489 "Restore an iconified window. If the window that is restored is in fullscreen mode, then the fullscreen
493 "Parameters
494 param
495 A token selecting which parameter the function should return (see table 3.2).
497 Return values
498 The function returns different parameters depending on the value of param. Table 3.2 lists valid param
499 values, and their corresponding return values.
501 Description
502 The function is used for acquiring various properties of an opened window.
504 Notes
505 GLFW_ACCELERATED is only supported under Windows. Other systems will always return
506 GL_TRUE. Under Windows, GLFW_ACCELERATED means that the OpenGL™ renderer is a 3rd
507 party renderer, rather than the fallback Microsoft software OpenGL™ renderer. In other words, it is
508 not a real guarantee that the OpenGL™ renderer is actually hardware accelerated.
512 "The function swaps the back and front color buffers of the window. If GLFW_AUTO-POLL-EVENTS
513 is enabled (which is the default), glfwPollEvents is called before swapping the front and back buffers.")
517 "Parameters
518 interval
519 Minimum number of monitor vertical retraces between each buffer swap performed by
520 glfwSwapBuffers. If interval is zero, buffer swaps will not be synchronized to the vertical
521 refresh of the monitor (also known as ’VSync off’).
523 Description
524 The function selects the minimum number of monitor vertical retraces that should occur between two
525 buffer swaps. If the selected swap interval is one, the rate of buffer swaps will never be higher than the
526 vertical refresh rate of the monitor. If the selected swap interval is zero, the rate of buffer swaps is only
527 limited by the speed of the software and the hardware.
529 Notes
530 This function will only have an effect on hardware and drivers that support user selection of the swap
534 (defcfun+doc ("glfwSetWindowRefreshCallback" set-window-refresh-callback) :void ((cbfun :pointer))
535 "Parameters
536 cbfun
537 Pointer to a callback function that will be called when the window client area needs to be
538 refreshed. The function should have the following C language prototype:
539 void GLFWCALL functionname( void );
540 Where functionname is the name of the callback function.
541 If cbfun is NULL, any previously selected callback function will be deselected.
543 Description
544 The function selects which function to be called upon a window refresh event, which occurs when any
545 part of the window client area has been damaged, and needs to be repainted (for instance, if a part of the
546 window that was previously occluded by another window has become visible).
547 A window has to be opened for this function to have any effect.
549 Notes
550 Window refresh events are recorded continuously, but only reported when glfwPollEvents,
551 glfwWaitEvents or glfwSwapBuffers is called.
564 "Parameters
565 maxcount
566 Maximum number of video modes that list vector can hold.
568 Return values
569 The function returns the number of detected video modes (this number will never exceed maxcount).
570 The list vector is filled out with the video modes that are supported by the system.
572 Description
573 The function returns a list of supported video modes. Each video mode is represented by a
574 list of the form:
575 (width height redbits greenbits bluebits)
577 Notes
578 The returned list is sorted, first by color depth (RedBits + GreenBits + BlueBits), and then by
579 resolution (Width × Height), with the lowest resolution, fewest bits per pixel mode first. "
584 collecting
594 "Parameters
595 mode
596 Pointer to a GLFWvidmode structure, which will be filled out by the function.
597 Return values
598 The GLFWvidmode structure pointed to by mode is filled out with the desktop video mode.
599 Description
600 The function returns the desktop video mode in a GLFWvidmode structure. See glfwGetVideoModes
601 for a definition of the GLFWvidmode structure.
602 Notes
603 The color depth of the desktop display is always reported as the number of bits for each individual color
604 component (red, green and blue), even if the desktop is not using an RGB or RGBA color format. For
605 instance, an indexed 256 color display may report RedBits = 3, GreenBits = 3 and BlueBits = 2, which
606 adds up to 8 bits in total.
607 The desktop video mode is the video mode used by the desktop, not the current video mode (which may
608 differ from the desktop video mode if the GLFW window is a fullscreen window).
609 "
619 "Description
620 The function is used for polling for events, such as user input and window resize events. Upon calling
621 this function, all window states, keyboard states and mouse states are updated. If any related callback
622 functions are registered, these are called during the call to glfwPollEvents.
624 Notes
625 glfwPollEvents is called implicitly from glfwSwapBuffers if GLFW_AUTO_POLL_EVENTS is
626 enabled (default). Thus, if glfwSwapBuffers is called frequently, which is normally the case, there is
627 no need to call glfwPollEvents.
631 "Description
632 The function is used for waiting for events, such as user input and window resize events. Upon calling
633 this function, the calling thread will be put to sleep until any event appears in the event queue. When
634 events are ready, the events will be processed just as they are processed by glfwPollEvents.
635 If there are any events in the queue when the function is called, the function will behave exactly like
636 glfwPollEvents (i.e. process all messages and then return, without blocking the calling thread).
638 Notes
639 It is guaranteed that glfwWaitEvents will wake up on any event that can be processed by
640 glfwPollEvents. However, glfwWaitEvents may wake up on events that are not processed or reported
641 by glfwPollEvents too, and the function may behave differently on different systems. Do no make any
642 assumptions about when or why glfwWaitEvents will return.
646 "Parameters
647 key
648 A keyboard key identifier, which can be either an uppercase printable ISO 8859-1 (Latin 1)
649 character (e.g. 'A', '3' or '.'), or a special key identifier. Table 3.3 lists valid special key
650 identifiers.
651 Return values
652 The function returns GLFW_PRESS if the key is held down, or GLFW_RELEASE if the key is not
653 held down.
655 Description
656 The function queries the current state of a specific keyboard key. The physical location of each key
657 depends on the system keyboard layout setting.
659 Notes
660 The constant GLFW_KEY_SPACE is equal to 32, which is the ISO 8859-1 code for space.
661 Not all key codes are supported on all systems. Also, while some keys are available on some keyboard
662 layouts, they may not be available on other keyboard layouts.
663 For systems that do not distinguish between left and right versions of modifier keys (shift, alt and
664 control), the left version is used (e.g. GLFW_KEY_LSHIFT).
665 A window must be opened for the function to have any effect, and glfwPollEvents, glfwWaitEvents or
666 glfwSwapBuffers must be called before any keyboard events are recorded and reported by
667 glfwGetKey.
671 "Parameters
672 button
673 A mouse button identifier, which can be one of the mouse button identifiers listed in table 3.4.
674 Return values
675 The function returns GLFW_PRESS if the mouse button is held down, or GLFW_RELEASE if the
676 mouse button is not held down.
677 Description
678 The function queries the current state of a specific mouse button.
679 Notes
680 A window must be opened for the function to have any effect, and glfwPollEvents, glfwWaitEvents or
681 glfwSwapBuffers must be called before any mouse button events are recorded and reported by
682 glfwGetMouseButton.
683 GLFW_MOUSE_BUTTON_LEFT is equal to GLFW_MOUSE_BUTTON_1.
684 GLFW_MOUSE_BUTTON_RIGHT is equal to GLFW_MOUSE_BUTTON_2.
685 GLFW_MOUSE_BUTTON_MIDDLE is equal to GLFW_MOUSE_BUTTON_3.
690 "Return values
691 The function returns the current mouse position in xpos and ypos.
693 Description
694 The function returns the current mouse position. If the cursor is not hidden, the mouse position is the
695 cursor position, relative to the upper left corner of the window and limited to the client area of the
696 window. If the cursor is hidden, the mouse position is a virtual absolute position, not limited to any
697 boundaries except to those implied by the maximum number that can be represented by a signed integer
698 (normally -2147483648 to +2147483647).
700 Notes
701 A window must be opened for the function to have any effect, and glfwPollEvents, glfwWaitEvents or
702 glfwSwapBuffers must be called before any mouse movements are recorded and reported by
703 glfwGetMousePos.
708 "Parameters
709 xpos
710 Horizontal position of the mouse.
711 ypos
712 Vertical position of the mouse.
714 Description
715 The function changes the position of the mouse. If the cursor is visible (not disabled), the cursor will be
716 moved to the specified position, relative to the upper left corner of the window client area. If the cursor
717 is hidden (disabled), only the mouse position that is reported by GLFW is changed.
721 "Return values
722 The function returns the current mouse wheel position.
723 Description
724 The function returns the current mouse wheel position. The mouse wheel can be thought of as a third
725 mouse axis, which is available as a separate wheel or up/down stick on some mice.
726 Notes
727 A window must be opened for the function to have any effect, and glfwPollEvents, glfwWaitEvents or
728 glfwSwapBuffers must be called before any mouse wheel movements are recorded and reported by
729 glfwGetMouseWheel.
733 "Parameters
734 pos
735 Position of the mouse wheel.
736 Description
737 The function changes the position of the mouse wheel.
742 "Parameters
743 cbfun
744 Pointer to a callback function that will be called every time a key is pressed or released. The
745 function should have the following C language prototype:
746 void GLFWCALL functionname( int key, int action );
747 Where functionname is the name of the callback function, key is a key identifier, which is an
748 uppercase printable ISO 8859-1 character or a special key identifier (see table 3.3), and action is
749 either GLFW_PRESS or GLFW_RELEASE.
750 If cbfun is NULL, any previously selected callback function will be deselected.
751 Return values
752 none
753 Description
754 The function selects which function to be called upon a keyboard key event. The callback function is
755 called every time the state of a single key is changed (from released to pressed or vice versa). The
756 reported keys are unaffected by any modifiers (such as shift or alt).
757 A window has to be opened for this function to have any effect.
758 Notes
759 Keyboard events are recorded continuously, but only reported when glfwPollEvents, glfwWaitEvents
760 or glfwSwapBuffers is called.
763 "Parameters
764 cbfun
765 Pointer to a callback function that will be called every time a printable character is generated by
766 the keyboard. The function should have the following C language prototype:
767 void GLFWCALL functionname( int character, int action );
768 Where functionname is the name of the callback function, character is a Unicode (ISO 10646)
769 character, and action is either GLFW_PRESS or GLFW_RELEASE.
770 If cbfun is NULL, any previously selected callback function will be deselected.
771 Return values
772 none
773 Description
774 The function selects which function to be called upon a keyboard character event. The callback function
775 is called every time a key that results in a printable Unicode character is pressed or released. Characters
776 are affected by modifiers (such as shift or alt).
777 A window has to be opened for this function to have any effect.
778 Notes
779 Character events are recorded continuously, but only reported when glfwPollEvents, glfwWaitEvents
780 or glfwSwapBuffers is called.
781 Control characters, such as tab and carriage return, are not reported to the character callback function,
782 since they are not part of the Unicode character set. Use the key callback function for such events (see
783 glfwSetKeyCallback).
784 The Unicode character set supports character codes above 255, so never cast a Unicode character to an
785 eight bit data type (e.g. the C language ’char’ type) without first checking that the character code is less
786 than 256. Also note that Unicode character codes 0 to 255 are equal to ISO 8859-1 (Latin 1).
789 "Parameters
790 cbfun
791 Pointer to a callback function that will be called every time a mouse button is pressed or released.
792 The function should have the following C language prototype:
793 void GLFWCALL functionname( int button, int action );
794 Where functionname is the name of the callback function, button is a mouse button identifier (see
795 table 3.4 on page 56), and action is either GLFW_PRESS or GLFW_RELEASE.
796 If cbfun is NULL, any previously selected callback function will be deselected.
797 Return values
798 none
799 Description
800 The function selects which function to be called upon a mouse button event.
801 A window has to be opened for this function to have any effect.
802 Notes
803 Mouse button events are recorded continuously, but only reported when glfwPollEvents,
804 glfwWaitEvents or glfwSwapBuffers is called.
805 GLFW_MOUSE_BUTTON_LEFT is equal to GLFW_MOUSE_BUTTON_1.
806 GLFW_MOUSE_BUTTON_RIGHT is equal to GLFW_MOUSE_BUTTON_2.
807 GLFW_MOUSE_BUTTON_MIDDLE is equal to GLFW_MOUSE_BUTTON_3.
810 "Parameters
811 cbfun
812 Pointer to a callback function that will be called every time the mouse is moved. The function
813 should have the following C language prototype:
814 void GLFWCALL functionname( int x, int y );
815 Where functionname is the name of the callback function, and x and y are the mouse coordinates
816 (see glfwGetMousePos for more information on mouse coordinates).
817 If cbfun is NULL, any previously selected callback function will be deselected.
818 Return values
819 none
820 Description
821 The function selects which function to be called upon a mouse motion event.
822 A window has to be opened for this function to have any effect.
823 Notes
824 Mouse motion events are recorded continuously, but only reported when glfwPollEvents,
825 glfwWaitEvents or glfwSwapBuffers is called.
828 "Parameters
829 cbfun
830 Pointer to a callback function that will be called every time the mouse wheel is moved. The
831 function should have the following C language prototype:
832 void GLFWCALL functionname( int pos );
833 Where functionname is the name of the callback function, and pos is the mouse wheel position.
834 If cbfun is NULL, any previously selected callback function will be deselected.
835 Return values
836 none
837 Description
838 The function selects which function to be called upon a mouse wheel event.
839 A window has to be opened for this function to have any effect.
840 Notes
841 Mouse wheel events are recorded continuously, but only reported when glfwPollEvents,
842 glfwWaitEvents or glfwSwapBuffers is called.
846 "Parameters
847 joy
848 A joystick identifier, which should be GLFW_JOYSTICK_n, where n is in the range 1 to 16.
849 param
850 A token selecting which parameter the function should return (see table 3.5).
851 Return values
852 The function returns different parameters depending on the value of param. Table 3.5 lists valid param
853 values, and their corresponding return values.
854 Description
855 The function is used for acquiring various properties of a joystick.
856 Notes
857 The joystick information is updated every time the function is called.
858 No window has to be opened for joystick information to be valid.
861 (defcfun ("glfwGetJoystickPos" %get-joystick-pos) :int (joy :int) (pos :pointer) (numaxes :int))
864 "Parameters
865 joy
866 A joystick identifier, which should be GLFW_JOYSTICK_n, where n is in the range 1 to 16.
867 numaxes
868 Specifies how many axes should be returned.
869 Return values
870 An list that will hold the positional values for all requested axes.
871 If the joystick is not supported or connected, the function will
872 return nil.
874 Description
875 The function queries the current position of one or more axes of a joystick. The positional values are
876 returned in an array, where the first element represents the first axis of the joystick (normally the X
877 axis). Each position is in the range -1.0 to 1.0. Where applicable, the positive direction of an axis is
878 right, forward or up, and the negative direction is left, back or down.
879 If numaxes exceeds the number of axes supported by the joystick, or if the joystick is not available, the
880 unused elements in the pos array will be set to 0.0 (zero).
882 Notes
883 The joystick state is updated every time the function is called, so there is no need to call glfwPollEvents
884 or glfwWaitEvents for joystick state to be updated.
885 Use glfwGetJoystickParam to retrieve joystick capabilities, such as joystick availability and number of
886 supported axes.
887 No window has to be opened for joystick input to be valid.
888 "
894 (defcfun ("glfwGetJoystickButtons" %get-joystick-buttons) :int (joy :int) (buttons :pointer) (numbuttons :int))
896 "Parameters
897 joy
898 A joystick identifier, which should be GLFW_JOYSTICK_n, where n is in the range 1 to 16.
899 numbuttons
900 Specifies how many buttons should be returned.
901 Return values
902 A list that will hold the button states for all requested buttons.
903 The function returns the number of actually returned buttons. This is the minimum of numbuttons and
904 the number of buttons supported by the joystick. If the joystick is not supported or connected, the
905 function will return 0 (zero).
907 Description
908 The function queries the current state of one or more buttons of a joystick. The button states are
909 returned in an array, where the first element represents the first button of the joystick. Each state can be
910 either GLFW_PRESS or GLFW_RELEASE.
911 If numbuttons exceeds the number of buttons supported by the joystick, or if the joystick is not
912 available, the unused elements in the buttons array will be set to GLFW_RELEASE.
914 Notes
915 The joystick state is updated every time the function is called, so there is no need to call glfwPollEvents
916 or glfwWaitEvents for joystick state to be updated.
917 Use glfwGetJoystickParam to retrieve joystick capabilities, such as joystick availability and number of
918 supported buttons.
919 No window has to be opened for joystick input to be valid.
920 "
927 "Return values
928 The function returns the value of the high precision timer. The time is measured in seconds, and is
929 returned as a double precision floating point value.
931 Description
932 The function returns the state of a high precision timer. Unless the timer has been set by the
933 glfwSetTime function, the time is measured as the number of seconds that have passed since glfwInit
934 was called.
936 Notes
937 The resolution of the timer depends on which system the program is running on. The worst case
938 resolution is somewhere in the order of 10 ms, while for most systems the resolution should be better
939 than 1 μs.
943 "Parameters
944 time
945 Time (in seconds) that the timer should be set to.
947 Description
948 The function sets the current time of the high precision timer to the specified time. Subsequent calls to
949 glfwGetTime will be relative to this time. The time is given in seconds.
953 "Parameters
954 time
955 Time, in seconds, to sleep.
957 Description
958 The function puts the calling thread to sleep for the requested period of time. Only the calling thread is
959 put to sleep. Other threads within the same process can still execute.
961 Notes
962 There is usually a system dependent minimum time for which it is possible to sleep. This time is
963 generally in the range 1 ms to 20 ms, depending on thread sheduling time slot intervals etc. Using a
964 shorter time as a parameter to glfwSleep can give one of two results: either the thread will sleep for the
965 minimum possible sleep time, or the thread will not sleep at all (glfwSleep returns immediately). The
977 "Parameters
978 name
979 A null terminated ISO 8859-1 string holding the name of the file that should be read.
980 img
981 Pointer to a GLFWimage struct, which will hold the information about the loaded image (if the
982 read was successful).
983 flags
984 Flags for controlling the image reading process. Valid flags are listed in table 3.6
985 Return values
986 The function returns t if the image was loaded successfully. Otherwise nil is
987 returned.
988 Description
989 The function reads an image from the file specified by the parameter name and returns the image
990 information and data in a GLFWimage structure, which has the following definition:
991 § ¤
992 typedef struct {
993 int Width, Height; // Image dimensions
994 int Format; // OpenGL pixel format
995 int BytesPerPixel; // Number of bytes per pixel
996 unsigned char *Data; // Pointer to pixel data
997 } GLFWimage;
998 ¦ ¥
999 Width and Height give the dimensions of the image. Format specifies an OpenGL™ pixel format,
1000 which can be GL_LUMINANCE or GL_ALPHA (for gray scale images), GL_RGB or GL_RGBA.
1001 BytesPerPixel specifies the number of bytes per pixel. Data is a pointer to the actual pixel data.
1002 By default the read image is rescaled to the nearest larger 2m × 2n resolution using bilinear
1003 interpolation, if necessary, which is useful if the image is to be used as an OpenGL™ texture. This
1004 behavior can be disabled by setting the GLFW_NO_RESCALE_BIT flag.
1005 Unless the flag GLFW_ORIGIN_UL_BIT is set, the first pixel in img->Data is the lower left corner of
1006 the image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left corner.
1007 For single component images (i.e. gray scale), Format is set to GL_ALPHA if the flag
1008 GLFW_ALPHA_MAP_BIT flag is set, otherwise Format is set to GL_LUMINANCE.
1009 Notes
1010 glfwReadImage supports the Truevision Targa version 1 file format (.TGA). Supported pixel formats
1011 are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color + alpha.
1012 Paletted images are translated into true color or true color + alpha pixel formats.
1013 Please note that OpenGL™ 1.0 does not support single component alpha maps, so do not use images
1014 with Format = GL_ALPHA directly as textures under OpenGL™ 1.0.
1019 "Parameters
1020 data
1021 The memory buffer holding the contents of the file that should be read.
1022 size
1023 The size, in bytes, of the memory buffer.
1024 img
1025 Pointer to a GLFWimage struct, which will hold the information about the loaded image (if the
1026 read was successful).
1027 flags
1028 Flags for controlling the image reading process. Valid flags are listed in table 3.6
1029 Return values
1030 The function returns t if the image was loaded successfully. Otherwise nil is
1031 returned.
1032 Description
1033 The function reads an image from the memory buffer specified by the parameter data and returns the
1034 image information and data in a GLFWimage structure, which has the following definition:
1035 § ¤
1036 typedef struct {
1037 int Width, Height; // Image dimensions
1038 int Format; // OpenGL pixel format
1039 int BytesPerPixel; // Number of bytes per pixel
1040 unsigned char *Data; // Pointer to pixel data
1041 } GLFWimage;
1042 ¦ ¥
1043 Width and Height give the dimensions of the image. Format specifies an OpenGL™ pixel format,
1044 which can be GL_LUMINANCE or GL_ALPHA (for gray scale images), GL_RGB or GL_RGBA.
1045 BytesPerPixel specifies the number of bytes per pixel. Data is a pointer to the actual pixel data.
1046 By default the read image is rescaled to the nearest larger 2m × 2n resolution using bilinear
1047 interpolation, if necessary, which is useful if the image is to be used as an OpenGL™ texture. This
1048 behavior can be disabled by setting the GLFW_NO_RESCALE_BIT flag.
1049 Unless the flag GLFW_ORIGIN_UL_BIT is set, the first pixel in img->Data is the lower left corner of
1050 the image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left corner.
1051 For single component images (i.e. gray scale), Format is set to GL_ALPHA if the flag
1052 GLFW_ALPHA_MAP_BIT flag is set, otherwise Format is set to GL_LUMINANCE.
1053 Notes
1054 glfwReadMemoryImage supports the Truevision Targa version 1 file format (.TGA). Supported pixel
1055 formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color +
1056 alpha.
1057 Paletted images are translated into true color or true color + alpha pixel formats.
1058 Please note that OpenGL™ 1.0 does not support single component alpha maps, so do not use images
1059 with Format = GL_ALPHA directly as textures under OpenGL™ 1.0.
1063 "Parameters
1064 img
1065 Pointer to a GLFWimage struct.
1066 Description
1067 The function frees any memory occupied by a loaded image, and clears all the fields of the GLFWimage
1068 struct. Any image that has been loaded by the glfwReadImage function should be deallocated using
1072 "Parameters
1073 name
1074 An ISO 8859-1 string holding the name of the file that should be loaded.
1075 flags
1076 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1077 Return values
1078 The function returns t if the texture was loaded successfully. Otherwise nil is
1079 returned.
1081 Description
1082 The function reads an image from the file specified by the parameter name and uploads the image to
1083 OpenGL™ texture memory (using the glTexImage2D function).
1084 If the GLFW_BUILD_MIPMAPS_BIT flag is set, all mipmap levels for the loaded texture are
1085 generated and uploaded to texture memory.
1086 Unless the flag GLFW_ORIGIN_UL_BIT is set, the origin of the texture is the lower left corner of the
1087 loaded image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left
1088 corner.
1089 For single component images (i.e. gray scale), the texture is uploaded as an alpha mask if the flag
1090 GLFW_ALPHA_MAP_BIT flag is set, otherwise it is uploaded as a luminance texture.
1092 Notes
1093 glfwLoadTexture2D supports the Truevision Targa version 1 file format (.TGA). Supported pixel
1094 formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color +
1095 alpha.
1096 Paletted images are translated into true color or true color + alpha pixel formats.
1097 The read texture is always rescaled to the nearest larger 2m × 2n resolution using bilinear interpolation,
1098 if necessary, since OpenGL™ requires textures to have a 2m × 2n resolution.
1099 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1100 the OpenGL™ implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1101 generated by GLFW in software.
1102 Since OpenGL™ 1.0 does not support single component alpha maps, alpha map textures are converted
1103 to RGBA format under OpenGL™ 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1104 texture is a single component texture. The red, green and blue components are set to 1.0.
1109 "Parameters
1110 data
1111 The memory buffer holding the contents of the file that should be loaded.
1112 size
1113 The size, in bytes, of the memory buffer.
1114 flags
1115 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1116 Return values
1117 The function returns t if the texture was loaded successfully. Otherwise nil is
1118 returned.
1120 Description
1121 The function reads an image from the memory buffer specified by the parameter data and uploads the
1122 image to OpenGL™ texture memory (using the glTexImage2D function).
1123 If the GLFW_BUILD_MIPMAPS_BIT flag is set, all mipmap levels for the loaded texture are
1124 generated and uploaded to texture memory.
1125 Unless the flag GLFW_ORIGIN_UL_BIT is set, the origin of the texture is the lower left corner of the
1126 loaded image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left
1127 corner.
1128 For single component images (i.e. gray scale), the texture is uploaded as an alpha mask if the flag
1129 GLFW_ALPHA_MAP_BIT flag is set, otherwise it is uploaded as a luminance texture.
1131 Notes
1132 glfwLoadMemoryTexture2D supports the Truevision Targa version 1 file format (.TGA). Supported
1133 pixel formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color
1134 + alpha.
1135 Paletted images are translated into true color or true color + alpha pixel formats.
1136 The read texture is always rescaled to the nearest larger 2m × 2n resolution using bilinear interpolation,
1137 if necessary, since OpenGL™ requires textures to have a 2m × 2n resolution.
1138 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1139 the OpenGL™ implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1140 generated by GLFW in software.
1141 Since OpenGL™ 1.0 does not support single component alpha maps, alpha map textures are converted
1142 to RGBA format under OpenGL™ 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1143 texture is a single component texture. The red, green and blue components are set to 1.0.
1149 "Parameters
1150 img
1151 Pointer to a GLFWimage struct holding the information about the image to be loaded.
1152 flags
1153 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1154 Return values
1155 The function returns t if the texture was loaded successfully. Otherwise nil is
1156 returned.
1158 Description
1159 The function uploads the image specified by the parameter img to OpenGL™ texture memory (using
1160 the glTexImage2D function).
1161 If the GLFW_BUILD_MIPMAPS_BIT flag is set, all mipmap levels for the loaded texture are
1162 generated and uploaded to texture memory.
1163 Unless the flag GLFW_ORIGIN_UL_BIT is set, the origin of the texture is the lower left corner of the
1164 loaded image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left
1165 corner.
1166 For single component images (i.e. gray scale), the texture is uploaded as an alpha mask if the flag
1167 GLFW_ALPHA_MAP_BIT flag is set, otherwise it is uploaded as a luminance texture.
1169 Notes
1170 glfwLoadTextureImage2D supports the Truevision Targa version 1 file format (.TGA). Supported
1171 pixel formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color
1172 + alpha.
1173 Paletted images are translated into true color or true color + alpha pixel formats.
1174 The read texture is always rescaled to the nearest larger 2m × 2n resolution using bilinear interpolation,
1175 if necessary, since OpenGL™ requires textures to have a 2m × 2n resolution.
1176 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1177 the OpenGL™ implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1178 generated by GLFW in software.
1179 Since OpenGL™ 1.0 does not support single component alpha maps, alpha map textures are converted
1180 to RGBA format under OpenGL™ 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1185 "Parameters
1186 extension
1187 A null terminated ISO 8859-1 string containing the name of an OpenGL™ extension.
1188 Return values
1189 The function returns t if the extension is supported. Otherwise it returns nil.
1190 Description
1191 The function does a string search in the list of supported OpenGL™ extensions to find if the specified
1192 extension is listed.
1193 Notes
1194 An OpenGL™ context must be created before this function can be called (i.e. an OpenGL™ window
1195 must have been opened with glfwOpenWindow).
1196 In addition to checking for OpenGL™ extensions, GLFW also checks for extensions in the operating
1197 system “glue API”, such as WGL extensions under Windows and glX extensions under the X Window
1198 System.
1202 "Parameters
1203 procname
1204 A null terminated ISO 8859-1 string containing the name of an OpenGL™ extension function.
1205 Return values
1206 The function returns the pointer to the specified OpenGL™ function if it is supported, otherwise
1207 NULL is returned.
1208 Description
1209 The function acquires the pointer to an OpenGL™ extension function. Some (but not all) OpenGL™
1210 extensions define new API functions, which are usually not available through normal linking. It is
1211 therefore necessary to get access to those API functions at runtime.
1212 Notes
1213 An OpenGL™ context must be created before this function can be called (i.e. an OpenGL™ window
1214 must have been opened with glfwOpenWindow).
1215 Some systems do not support dynamic function pointer retrieval, in which case glfwGetProcAddress
1216 will always return NULL.
1222 "Return values
1223 The function returns the major and minor version numbers and the revision for the currently used
1224 OpenGL™ implementation as a list (major minor rev).
1226 Description
1227 The function returns the OpenGL™ implementation version. This is a convenient function that parses
1228 the version number information from the string returned by calling
1229 glGetString( GL_VERSION ). The OpenGL™ version information can be used to determine
1230 what functionality is supported by the used OpenGL™ implementation.
1232 Notes
1233 An OpenGL™ context must be created before this function can be called (i.e. an OpenGL™ window
1242 "Parameters
1243 fun
1244 A pointer to a function that acts as the entry point for the new thread. The function should have
1245 the following C language prototype:
1246 void GLFWCALL functionname( void *arg );
1247 Where functionname is the name of the thread function, and arg is the user supplied argument
1248 (see below).
1249 arg
1250 An arbitrary argument for the thread. arg will be passed as the argument to the thread function
1251 pointed to by fun. For instance, arg can point to data that is to be processed by the thread.
1252 Return values
1253 The function returns a thread identification number if the thread was created successfully. This number
1254 is always positive. If the function fails, a negative number is returned.
1255 Description
1256 The function creates a new thread, which executes within the same address space as the calling process.
1257 The thread entry point is specified with the fun argument.
1258 Once the thread function fun returns, the thread dies.
1259 Notes
1260 Even if the function returns a positive thread ID, indicating that the thread was created successfully, the
1261 thread may be unable to execute, for instance if the thread start address is not a valid thread entry point.
1264 "Parameters
1265 ID
1266 A thread identification handle, which is returned by glfwCreateThread or glfwGetThreadID.
1267 Description
1268 The function kills a running thread and removes it from the thread list.
1269 Notes
1270 This function is a very dangerous operation, which may interrupt a thread in the middle of an important
1271 operation, and its use is discouraged. You should always try to end a thread in a graceful way using
1272 thread communication, and use glfwWaitThread in order to wait for the thread to die.
1275 "Parameters
1276 ID
1277 A thread identification handle, which is returned by glfwCreateThread or glfwGetThreadID.
1278 waitmode
1279 Can be either GLFW_WAIT or GLFW_NOWAIT.
1280 Return values
1281 The function returns t if the specified thread died after the function was called, or the thread
1282 did not exist, in which case glfwWaitThread will return immediately regardless of waitmode. The
1283 function returns nil if waitmode is GLFW_NOWAIT, and the specified thread exists and is still
1284 running.
1287 "Return values
1288 The function returns a thread identification handle for the calling thread.
1289 Description
1290 The function determines the thread ID for the calling thread. The ID is the same value as was returned
1291 by glfwCreateThread when the thread was created.
1295 "Return values
1296 The function returns a mutex handle, or NULL if the mutex could not be created.
1297 Description
1298 The function creates a mutex object, which can be used to control access to data that is shared between
1299 threads.
1302 "Parameters
1303 mutex
1304 A mutex object handle.
1305 Description
1306 The function destroys a mutex object. After a mutex object has been destroyed, it may no longer be
1307 used by any thread.
1310 "Parameters
1311 mutex
1312 A mutex object handle.
1313 Description
1314 The function will acquire a lock on the selected mutex object. If the mutex is already locked by another
1315 thread, the function will block the calling thread until it is released by the locking thread. Once the
1316 function returns, the calling thread has an exclusive lock on the mutex. To release the mutex, call
1317 glfwUnlockMutex.
1320 "Parameters
1321 mutex
1322 A mutex object handle.
1323 Description
1324 The function releases the lock of a locked mutex object.
1328 "Parameters
1329 mutex
1330 A mutex object handle.
1331 forms
1332 Body of code to execute
1333 Description
1334 This macro will acquire a lock on the selected mutex object using glfwLockMutex and release it afterwards
1335 using glfwUnlockMutex.
1336 So, forms will not execute until an exclusive lock is held.
1337 The lock is then released when the stack is unwound."
1345 "Return values
1346 The function returns a condition variable handle, or NULL if the condition variable could not be
1347 created.
1348 Description
1349 The function creates a condition variable object, which can be used to synchronize threads.
1352 "Parameters
1353 cond
1354 A condition variable object handle.
1355 Description
1356 The function destroys a condition variable object. After a condition variable object has been destroyed,
1357 it may no longer be used by any thread.
1360 " arameters
1361 cond
1362 A condition variable object handle.
1363 mutex
1364 A mutex object handle.
1365 timeout
1366 Maximum time to wait for the condition variable. The parameter can either be a positive time (in
1367 seconds), or GLFW_INFINITY.
1368 Description
1369 The function atomically unlocks the mutex specified by mutex, and waits for the condition variable cond
1370 to be signaled. The thread execution is suspended and does not consume any CPU time until the
1371 condition variable is signaled or the amount of time specified by timeout has passed. If timeout is
1372 GLFW_INFINITY, glfwWaitCond will wait forever for cond to be signaled. Before returning to the
1373 calling thread, glfwWaitCond automatically re-acquires the mutex.
1374 Notes
1375 The mutex specified by mutex must be locked by the calling thread before entrance to glfwWaitCond.
1376 A condition variable must always be associated with a mutex, to avoid the race condition where a thread
1377 prepares to wait on a condition variable and another thread signals the condition just before the first
1378 thread actually waits on it.
1381 "Parameters
1382 cond
1383 A condition variable object handle.
1384 Description
1385 The function restarts one of the threads that are waiting on the condition variable cond. If no threads are
1386 waiting on cond, nothing happens. If several threads are waiting on cond, exactly one is restarted, but it
1387 is not specified which.
1388 Notes
1389 When several threads are waiting for the condition variable, which thread is started depends on
1390 operating system scheduling rules, and may vary from system to system and from time to time.
1393 "Parameters
1394 cond
1395 A condition variable object handle.
1396 Description
1397 The function restarts all the threads that are waiting on the condition variable cond. If no threads are
1398 waiting on cond, nothing happens.
1399 Notes
1400 When several threads are waiting for the condition variable, the order in which threads are started
1401 depends on operating system scheduling rules, and may vary from system to system and from time to
1402 time.
1406 "Return values
1407 The function returns the number of active processors in the system.
1408 Description
1409 The function determines the number of active processors in the system.
1410 Notes
1411 Systems with several logical processors per physical processor, also known as SMT (Symmetric Multi
1412 Threading) processors, will report the number of logical processors.
1415 "Parameters
1416 token
1417 A value specifying a feature to enable or disable. Valid tokens are listed in table 3.8.
1418 Return values
1419 none
1420 Description
1421 glfwEnable is used to enable a certain feature, while glfwDisable is used to disable it. Below follows a
1422 description of each feature.
1423 GLFW_AUTO_POLL_EVENTS
1424 When GLFW_AUTO_POLL_EVENTS is enabled, glfwPollEvents is automatically called each time
1425 that glfwSwapBuffers is called.
1426 When GLFW_AUTO_POLL_EVENTS is disabled, calling glfwSwapBuffers will not result in a call to
1427 glfwPollEvents. This can be useful if glfwSwapBuffers needs to be called from within a callback
1428 function, since calling glfwPollEvents from a callback function is not allowed.
1429 GLFW_KEY_REPEAT
1430 When GLFW_KEY_REPEAT is enabled, the key and character callback functions are called repeatedly
1431 when a key is held down long enough (according to the system key repeat configuration).
1432 When GLFW_KEY_REPEAT is disabled, the key and character callback functions are only called once
1433 when a key is pressed (and once when it is released).
1434 GLFW_MOUSE_CURSOR
1435 When GLFW_MOUSE_CURSOR is enabled, the mouse cursor is visible, and mouse coordinates are
1436 relative to the upper left corner of the client area of the GLFW window. The coordinates are limited to
1437 the client area of the window.
1438 When GLFW_MOUSE_CURSOR is disabled, the mouse cursor is invisible, and mouse coordinates are
1439 not limited to the drawing area of the window. It is as if the mouse coordinates are recieved directly
1440 from the mouse, without being restricted or manipulated by the windowing system.
1441 GLFW_STICKY_KEYS
1442 When GLFW_STICKY_KEYS is enabled, keys which are pressed will not be released until they are
1443 physically released and checked with glfwGetKey. This behavior makes it possible to catch keys that
1444 were pressed and then released again between two calls to glfwPollEvents, glfwWaitEvents or
1445 glfwSwapBuffers, which would otherwise have been reported as released. Care should be taken when
1446 using this mode, since keys that are not checked with glfwGetKey will never be released. Note also that
1447 enabling GLFW_STICKY_KEYS does not affect the behavior of the keyboard callback functionality.
1448 When GLFW_STICKY_KEYS is disabled, the status of a key that is reported by glfwGetKey is always
1449 the physical state of the key. Disabling GLFW_STICKY_KEYS also clears the sticky information for
1450 all keys.
1451 GLFW_STICKY_MOUSE_BUTTONS
1452 When GLFW_STICKY_MOUSE_BUTTONS is enabled, mouse buttons that are pressed will not be
1453 released until they are physically released and checked with glfwGetMouseButton. This behavior
1454 makes it possible to catch mouse buttons which were pressed and then released again between two calls
1455 to glfwPollEvents, glfwWaitEvents or glfwSwapBuffers, which would otherwise have been reported
1456 as released. Care should be taken when using this mode, since mouse buttons that are not checked with
1457 glfwGetMouseButton will never be released. Note also that enabling
1458 GLFW_STICKY_MOUSE_BUTTONS does not affect the behavior of the mouse button callback
1459 functionality.
1460 When GLFW_STICKY_MOUSE_BUTTONS is disabled, the status of a mouse button that is reported
1461 by glfwGetMouseButton is always the physical state of the mouse button. Disabling
1462 GLFW_STICKY_MOUSE_BUTTONS also clears the sticky information for all mouse buttons.
1463 GLFW_SYSTEM_KEYS
1464 When GLFW_SYSTEM_KEYS is enabled, pressing standard system key combinations, such as
1465 ALT+TAB under Windows, will give the normal behavior. Note that when ALT+TAB is issued under
1466 Windows in this mode so that the GLFW application is deselected when GLFW is operating in
1467 fullscreen mode, the GLFW application window will be minimized and the video mode will be set to
1468 the original desktop mode. When the GLFW application is re-selected, the video mode will be set to
1469 the GLFW video mode again.
1470 When GLFW_SYSTEM_KEYS is disabled, pressing standard system key combinations will have no
1471 effect, since those key combinations are blocked by GLFW. This mode can be useful in situations when
1472 the GLFW program must not be interrupted (normally for games in fullscreen mode).
1475 "Parameters
1476 token
1477 A value specifying a feature to enable or disable. Valid tokens are listed in table 3.8.
1478 Return values
1479 none
1480 Description
1481 glfwEnable is used to enable a certain feature, while glfwDisable is used to disable it. Below follows a
1482 description of each feature.
1483 GLFW_AUTO_POLL_EVENTS
1484 When GLFW_AUTO_POLL_EVENTS is enabled, glfwPollEvents is automatically called each time
1485 that glfwSwapBuffers is called.
1486 When GLFW_AUTO_POLL_EVENTS is disabled, calling glfwSwapBuffers will not result in a call to
1487 glfwPollEvents. This can be useful if glfwSwapBuffers needs to be called from within a callback
1488 function, since calling glfwPollEvents from a callback function is not allowed.
1489 GLFW_KEY_REPEAT
1490 When GLFW_KEY_REPEAT is enabled, the key and character callback functions are called repeatedly
1491 when a key is held down long enough (according to the system key repeat configuration).
1492 When GLFW_KEY_REPEAT is disabled, the key and character callback functions are only called once
1493 when a key is pressed (and once when it is released).
1494 GLFW_MOUSE_CURSOR
1495 When GLFW_MOUSE_CURSOR is enabled, the mouse cursor is visible, and mouse coordinates are
1496 relative to the upper left corner of the client area of the GLFW window. The coordinates are limited to
1497 the client area of the window.
1498 When GLFW_MOUSE_CURSOR is disabled, the mouse cursor is invisible, and mouse coordinates are
1499 not limited to the drawing area of the window. It is as if the mouse coordinates are recieved directly
1500 from the mouse, without being restricted or manipulated by the windowing system.
1501 GLFW_STICKY_KEYS
1502 When GLFW_STICKY_KEYS is enabled, keys which are pressed will not be released until they are
1503 physically released and checked with glfwGetKey. This behavior makes it possible to catch keys that
1504 were pressed and then released again between two calls to glfwPollEvents, glfwWaitEvents or
1505 glfwSwapBuffers, which would otherwise have been reported as released. Care should be taken when
1506 using this mode, since keys that are not checked with glfwGetKey will never be released. Note also that
1507 enabling GLFW_STICKY_KEYS does not affect the behavior of the keyboard callback functionality.
1508 When GLFW_STICKY_KEYS is disabled, the status of a key that is reported by glfwGetKey is always
1509 the physical state of the key. Disabling GLFW_STICKY_KEYS also clears the sticky information for
1510 all keys.
1511 GLFW_STICKY_MOUSE_BUTTONS
1512 When GLFW_STICKY_MOUSE_BUTTONS is enabled, mouse buttons that are pressed will not be
1513 released until they are physically released and checked with glfwGetMouseButton. This behavior
1514 makes it possible to catch mouse buttons which were pressed and then released again between two calls
1515 to glfwPollEvents, glfwWaitEvents or glfwSwapBuffers, which would otherwise have been reported
1516 as released. Care should be taken when using this mode, since mouse buttons that are not checked with
1517 glfwGetMouseButton will never be released. Note also that enabling
1518 GLFW_STICKY_MOUSE_BUTTONS does not affect the behavior of the mouse button callback
1519 functionality.
1520 When GLFW_STICKY_MOUSE_BUTTONS is disabled, the status of a mouse button that is reported
1521 by glfwGetMouseButton is always the physical state of the mouse button. Disabling
1522 GLFW_STICKY_MOUSE_BUTTONS also clears the sticky information for all mouse buttons.
1523 GLFW_SYSTEM_KEYS
1524 When GLFW_SYSTEM_KEYS is enabled, pressing standard system key combinations, such as
1525 ALT+TAB under Windows, will give the normal behavior. Note that when ALT+TAB is issued under
1526 Windows in this mode so that the GLFW application is deselected when GLFW is operating in
1527 fullscreen mode, the GLFW application window will be minimized and the video mode will be set to
1528 the original desktop mode. When the GLFW application is re-selected, the video mode will be set to
1529 the GLFW video mode again.
1530 When GLFW_SYSTEM_KEYS is disabled, pressing standard system key combinations will have no
1531 effect, since those key combinations are blocked by GLFW. This mode can be useful in situations when
1532 the GLFW program must not be interrupted (normally for games in fullscreen mode).