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