| blob | d7c0a9b58c498a8c9cebbd1e586f52ea3fd8434b |
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 |#
23 ;; copy the boolean from OpenGL
46 args)))
49 args))))
56 args))
58 ,docstring
63 out-args)))))))
65 ;; ECL's DFFI seems to have issues if you don't put the full path in
75 ;; Key and button state/action definitions
79 ;; Keyboard key definitions: 8-bit ISO-8859-1 (Latin 1) encoding is used
80 ;; for printable keys (such as A-Z, 0-9 etc), and values above 256
81 ;; represent special (non-printable) keys (e.g. F1, Page Up etc).
149 ;; Mouse button definitions
160 ;; Mouse button aliases
165 ;; Joystick identifiers
185 ;;========================================================================
186 ;; Other definitions
187 ;;========================================================================
189 ;; glfwOpenWindow modes
193 ;; glfwGetWindowParam tokens
205 ;; The following constants are used for both glfwGetWindowParam
206 ;; and glfwOpenWindowHint
217 ;; glfwEnable/glfwDisable tokens
225 ;; glfwWaitThread wait modes
229 ;; glfwGetJoystickParam tokens
234 ;; glfwReadImage/glfwLoadTexture2D flags
240 ;; Time spans longer than this (seconds) are considered to be infinity
244 "Return values
245 If the function succeeds, t is returned.
246 If the function fails, nil is returned.
248 The glfwInit function initializes GLFW. No other GLFW functions may be used before this function
249 has been called.
251 Notes
252 This function may take several seconds to complete on some systems, while on other systems it may
256 "The function terminates GLFW. Among other things it closes the window, if it is opened, and kills any
262 "Return values
263 The function returns the major and minor version numbers and the revision for the currently linked
267 "Call glfw:init, execute forms and clean-up with glfw:terminate once finished.
268 This makes a nice wrapper to an application higher-level form.
269 Signals an error on failure to initialize. Wrapped in a block named glfw:with-init."
285 "width
286 The width of the window. If width is zero, it will be calculated as width = 4/3 height, if height is
287 not zero. If both width and height are zero, then width will be set to 640.
288 height
289 The height of the window. If height is zero, it will be calculated as height = 3/4 width, if width is
290 not zero. If both width and height are zero, then height will be set to 480.
291 redbits, greenbits, bluebits
292 The number of bits to use for each color component of the color buffer (0 means default color
293 depth). For instance, setting redbits=5, greenbits=6, and bluebits=5 will generate a 16-bit color
294 buffer, if possible.
295 alphabits
296 The number of bits to use for the alpha buffer (0 means no alpha buffer).
297 depthbits
298 The number of bits to use for the depth buffer (0 means no depth buffer).
299 stencilbits
300 The number of bits to use for the stencil buffer (0 means no stencil buffer).
301 mode
302 Selects which type of OpenGL™ window to use. mode can be either GLFW_WINDOW, which
303 will generate a normal desktop window, or GLFW_FULLSCREEN, which will generate a
304 window which covers the entire screen. When GLFW_FULLSCREEN is selected, the video
305 mode will be changed to the resolution that closest matches the width and height parameters.
307 Return values
308 If the function succeeds, t is returned.
309 If the function fails, nil is returned.
311 Description
312 The function opens a window that best matches the parameters given to the function. How well the
313 resulting window matches the desired window depends mostly on the available hardware and
314 OpenGL™ drivers. In general, selecting a fullscreen mode has better chances of generating a close
315 match than does a normal desktop window, since GLFW can freely select from all the available video
316 modes. A desktop window is normally restricted to the video mode of the desktop.
318 Notes
319 For additional control of window properties, see glfwOpenWindowHint.
320 In fullscreen mode the mouse cursor is hidden by default, and any system screensavers are prohibited
321 from starting. In windowed mode the mouse cursor is visible, and screensavers are allowed to start. To
322 change the visibility of the mouse cursor, use glfwEnable or glfwDisable with the argument
323 GLFW_MOUSE-CURSOR.
324 In order to determine the actual properties of an opened window, use glfwGetWindowParam and
325 glfwGetWindowSize (or glfwSetWindowSizeCallback).
326 "
331 "target
332 Can be any of the constants in the table 3.1.
333 hint
334 An integer giving the value of the corresponding target (see table 3.1).
336 Description
337 The function sets additional properties for a window that is to be opened. For a hint to be registered, the
338 function must be called before calling glfwOpenWindow. When the glfwOpenWindow function is
339 called, any hints that were registered with the glfwOpenWindowHint function are used for setting the
340 corresponding window properties, and then all hints are reset to their default values.
342 Notes
343 In order to determine the actual properties of an opened window, use glfwGetWindowParam (after the
344 window has been opened).
345 GLFW_STEREO is a hard constraint. If stereo rendering is requested, but no stereo rendering capable
346 pixel formats / visuals are available, glfwOpenWindow will fail.
347 The GLFW_REFRESH-RATE property should be used with caution. Most systems have default values
348 for monitor refresh rates that are optimal for the specific system. Specifying the refresh rate can
349 override these settings, which can result in suboptimal operation. The monitor may be unable to display
350 the resulting video signal, or in the worst case it may even be damaged!
360 "Wraps forms such that there is an open window for them to execute in and cleans up the
361 window afterwards. An error is signalled if there was an error opening the window.
362 Takes the same parameters as open-window, with the addition of 'title' which will
363 set the window title after opening.
364 Wrapped in a block named glfw:with-open-window."
365 `(if (%open-window ,width ,height ,redbits ,greenbits ,bluebits ,alphabits ,depthbits ,stencilbits ,mode)
378 "Wraps forms in with-init, with-open-window. Passes through the other arguments to open-window."
380 (with-open-window (,title ,width ,height ,redbits ,greenbits ,bluebits ,alphabits ,depthbits ,stencilbits ,mode)
388 "High-level convenience macro for initializing glfw, opening a window (given the optional window parameters),
389 setting the title given,
390 running setup-forms and then running forms in a loop, with calls to swap-buffers after each loop iteration.
391 The loop is in a block named do-window [so can be exited by a call to (return-from glfw:do-window)].
392 If the window is closed, the loop is also exited."
393 `(with-init-window (,title ,width ,height ,redbits ,greenbits ,bluebits ,alphabits ,depthbits ,stencilbits ,mode)
394 ,@setup-forms
396 ,@forms
402 "Parameters
403 cbfun
404 Pointer to a callback function that will be called when a user requests that the window should be
405 closed, typically by clicking the window close icon (e.g. the cross in the upper right corner of a
406 window under Microsoft Windows). The function should have the following C language
407 prototype:
408 int GLFWCALL functionname( void );
409 Where functionname is the name of the callback function. The return value of the callback
410 function indicates wether or not the window close action should continue. If the function returns
411 GL_TRUE, the window will be closed. If the function returns GL_FALSE, the window will not
412 be closed.
413 If cbfun is NULL, any previously selected callback function will be deselected.
415 If you declare your callback as returning glfw:boolean, you can use t and nil as return types.
417 Description
418 The function selects which function to be called upon a window close event.
419 A window has to be opened for this function to have any effect.
421 Notes
422 Window close events are recorded continuously, but only reported when glfwPollEvents,
423 glfwWaitEvents or glfwSwapBuffers is called.
424 The OpenGL™ context is still valid when this function is called.
425 Note that the window close callback function is not called when glfwCloseWindow is called, but only
426 when the close request comes from the window manager.
427 Do not call glfwCloseWindow from a window close callback function. Close the window by returning
428 GL_TRUE from the function.
432 "Parameters
433 title
434 Pointer to a null terminated ISO 8859-1 (8-bit Latin 1) string that holds the title of the window.
436 Description
437 The function changes the title of the opened window.
439 Notes
440 The title property of a window is often used in situations other than for the window title, such as the title
444 "Parameters
445 width
446 Width of the window.
447 height
448 Height of the window.
449 Return values
450 none
451 Description
452 The function changes the size of an opened window. The width and height parameters denote the size of
453 the client area of the window (i.e. excluding any window borders and decorations).
454 If the window is in fullscreen mode, the video mode will be changed to a resolution that closest matches
455 the width and height parameters (the number of color bits will not be changed).
456 Notes
457 The OpenGL™ context is guaranteed to be preserved after calling glfwSetWindowSize, even if the
458 video mode is changed.
462 "Parameters
463 x
464 Horizontal position of the window, relative to the upper left corner of the desktop.
465 y
466 Vertical position of the window, relative to the upper left corner of the desktop.
467 Return values
468 none
469 Description
470 The function changes the position of an opened window. It does not have any effect on a fullscreen
471 window.
476 "The function is used for determining the size of an opened window. The returned values are dimensions
477 of the client area of the window (i.e. excluding any window borders and decorations).
478 (list width height)"
486 "Parameters
487 cbfun
488 Pointer to a callback function that will be called every time the window size changes. The
489 function should have the following C language prototype:
490 void GLFWCALL functionname( int width, int height );
491 Where functionname is the name of the callback function, and width and height are the
492 dimensions of the window client area.
493 If cbfun is NULL, any previously selected callback function will be deselected.
494 Return values
495 none
496 Description
497 The function selects which function to be called upon a window size change event.
498 A window has to be opened for this function to have any effect.
499 Notes
500 Window size changes are recorded continuously, but only reported when glfwPollEvents,
504 "Iconify a window. If the window is in fullscreen mode, then the desktop video mode will be restored.")
507 "Restore an iconified window. If the window that is restored is in fullscreen mode, then the fullscreen
511 "Parameters
512 param
513 A token selecting which parameter the function should return (see table 3.2).
515 Return values
516 The function returns different parameters depending on the value of param. Table 3.2 lists valid param
517 values, and their corresponding return values.
519 Description
520 The function is used for acquiring various properties of an opened window.
522 Notes
523 GLFW_ACCELERATED is only supported under Windows. Other systems will always return
524 GL_TRUE. Under Windows, GLFW_ACCELERATED means that the OpenGL™ renderer is a 3rd
525 party renderer, rather than the fallback Microsoft software OpenGL™ renderer. In other words, it is
526 not a real guarantee that the OpenGL™ renderer is actually hardware accelerated.
530 "The function swaps the back and front color buffers of the window. If GLFW_AUTO-POLL-EVENTS
531 is enabled (which is the default), glfwPollEvents is called before swapping the front and back buffers.")
535 "Parameters
536 interval
537 Minimum number of monitor vertical retraces between each buffer swap performed by
538 glfwSwapBuffers. If interval is zero, buffer swaps will not be synchronized to the vertical
539 refresh of the monitor (also known as ’VSync off’).
541 Description
542 The function selects the minimum number of monitor vertical retraces that should occur between two
543 buffer swaps. If the selected swap interval is one, the rate of buffer swaps will never be higher than the
544 vertical refresh rate of the monitor. If the selected swap interval is zero, the rate of buffer swaps is only
545 limited by the speed of the software and the hardware.
547 Notes
548 This function will only have an effect on hardware and drivers that support user selection of the swap
552 (defcfun+doc ("glfwSetWindowRefreshCallback" set-window-refresh-callback) :void ((cbfun :pointer))
553 "Parameters
554 cbfun
555 Pointer to a callback function that will be called when the window client area needs to be
556 refreshed. The function should have the following C language prototype:
557 void GLFWCALL functionname( void );
558 Where functionname is the name of the callback function.
559 If cbfun is NULL, any previously selected callback function will be deselected.
561 Description
562 The function selects which function to be called upon a window refresh event, which occurs when any
563 part of the window client area has been damaged, and needs to be repainted (for instance, if a part of the
564 window that was previously occluded by another window has become visible).
565 A window has to be opened for this function to have any effect.
567 Notes
568 Window refresh events are recorded continuously, but only reported when glfwPollEvents,
569 glfwWaitEvents or glfwSwapBuffers is called.
582 "Parameters
583 maxcount
584 Maximum number of video modes that list vector can hold.
586 Return values
587 The function returns the number of detected video modes (this number will never exceed maxcount).
588 The list vector is filled out with the video modes that are supported by the system.
590 Description
591 The function returns a list of supported video modes. Each video mode is represented by a
592 list of the form:
593 (width height redbits greenbits bluebits)
595 Notes
596 The returned list is sorted, first by color depth (RedBits + GreenBits + BlueBits), and then by
597 resolution (Width × Height), with the lowest resolution, fewest bits per pixel mode first. "
602 collecting
612 "Parameters
613 mode
614 Pointer to a GLFWvidmode structure, which will be filled out by the function.
615 Return values
616 The GLFWvidmode structure pointed to by mode is filled out with the desktop video mode.
617 Description
618 The function returns the desktop video mode in a GLFWvidmode structure. See glfwGetVideoModes
619 for a definition of the GLFWvidmode structure.
620 Notes
621 The color depth of the desktop display is always reported as the number of bits for each individual color
622 component (red, green and blue), even if the desktop is not using an RGB or RGBA color format. For
623 instance, an indexed 256 color display may report RedBits = 3, GreenBits = 3 and BlueBits = 2, which
624 adds up to 8 bits in total.
625 The desktop video mode is the video mode used by the desktop, not the current video mode (which may
626 differ from the desktop video mode if the GLFW window is a fullscreen window).
627 "
637 "Description
638 The function is used for polling for events, such as user input and window resize events. Upon calling
639 this function, all window states, keyboard states and mouse states are updated. If any related callback
640 functions are registered, these are called during the call to glfwPollEvents.
642 Notes
643 glfwPollEvents is called implicitly from glfwSwapBuffers if GLFW_AUTO_POLL_EVENTS is
644 enabled (default). Thus, if glfwSwapBuffers is called frequently, which is normally the case, there is
645 no need to call glfwPollEvents.
649 "Description
650 The function is used for waiting for events, such as user input and window resize events. Upon calling
651 this function, the calling thread will be put to sleep until any event appears in the event queue. When
652 events are ready, the events will be processed just as they are processed by glfwPollEvents.
653 If there are any events in the queue when the function is called, the function will behave exactly like
654 glfwPollEvents (i.e. process all messages and then return, without blocking the calling thread).
656 Notes
657 It is guaranteed that glfwWaitEvents will wake up on any event that can be processed by
658 glfwPollEvents. However, glfwWaitEvents may wake up on events that are not processed or reported
659 by glfwPollEvents too, and the function may behave differently on different systems. Do no make any
660 assumptions about when or why glfwWaitEvents will return.
664 "Parameters
665 key
666 A keyboard key identifier, which can be either an uppercase printable ISO 8859-1 (Latin 1)
667 character (e.g. 'A', '3' or '.'), or a special key identifier. Table 3.3 lists valid special key
668 identifiers.
669 Return values
670 The function returns GLFW_PRESS if the key is held down, or GLFW_RELEASE if the key is not
671 held down.
673 Description
674 The function queries the current state of a specific keyboard key. The physical location of each key
675 depends on the system keyboard layout setting.
677 Notes
678 The constant GLFW_KEY_SPACE is equal to 32, which is the ISO 8859-1 code for space.
679 Not all key codes are supported on all systems. Also, while some keys are available on some keyboard
680 layouts, they may not be available on other keyboard layouts.
681 For systems that do not distinguish between left and right versions of modifier keys (shift, alt and
682 control), the left version is used (e.g. GLFW_KEY_LSHIFT).
683 A window must be opened for the function to have any effect, and glfwPollEvents, glfwWaitEvents or
684 glfwSwapBuffers must be called before any keyboard events are recorded and reported by
685 glfwGetKey.
689 "Parameters
690 button
691 A mouse button identifier, which can be one of the mouse button identifiers listed in table 3.4.
692 Return values
693 The function returns GLFW_PRESS if the mouse button is held down, or GLFW_RELEASE if the
694 mouse button is not held down.
695 Description
696 The function queries the current state of a specific mouse button.
697 Notes
698 A window must be opened for the function to have any effect, and glfwPollEvents, glfwWaitEvents or
699 glfwSwapBuffers must be called before any mouse button events are recorded and reported by
700 glfwGetMouseButton.
701 GLFW_MOUSE_BUTTON_LEFT is equal to GLFW_MOUSE_BUTTON_1.
702 GLFW_MOUSE_BUTTON_RIGHT is equal to GLFW_MOUSE_BUTTON_2.
703 GLFW_MOUSE_BUTTON_MIDDLE is equal to GLFW_MOUSE_BUTTON_3.
708 "Return values
709 The function returns the current mouse position in xpos and ypos.
711 Description
712 The function returns the current mouse position. If the cursor is not hidden, the mouse position is the
713 cursor position, relative to the upper left corner of the window and limited to the client area of the
714 window. If the cursor is hidden, the mouse position is a virtual absolute position, not limited to any
715 boundaries except to those implied by the maximum number that can be represented by a signed integer
716 (normally -2147483648 to +2147483647).
718 Notes
719 A window must be opened for the function to have any effect, and glfwPollEvents, glfwWaitEvents or
720 glfwSwapBuffers must be called before any mouse movements are recorded and reported by
721 glfwGetMousePos.
726 "Parameters
727 xpos
728 Horizontal position of the mouse.
729 ypos
730 Vertical position of the mouse.
732 Description
733 The function changes the position of the mouse. If the cursor is visible (not disabled), the cursor will be
734 moved to the specified position, relative to the upper left corner of the window client area. If the cursor
735 is hidden (disabled), only the mouse position that is reported by GLFW is changed.
739 "Return values
740 The function returns the current mouse wheel position.
741 Description
742 The function returns the current mouse wheel position. The mouse wheel can be thought of as a third
743 mouse axis, which is available as a separate wheel or up/down stick on some mice.
744 Notes
745 A window must be opened for the function to have any effect, and glfwPollEvents, glfwWaitEvents or
746 glfwSwapBuffers must be called before any mouse wheel movements are recorded and reported by
747 glfwGetMouseWheel.
751 "Parameters
752 pos
753 Position of the mouse wheel.
754 Description
755 The function changes the position of the mouse wheel.
760 "Parameters
761 cbfun
762 Pointer to a callback function that will be called every time a key is pressed or released. The
763 function should have the following C language prototype:
764 void GLFWCALL functionname( int key, int action );
765 Where functionname is the name of the callback function, key is a key identifier, which is an
766 uppercase printable ISO 8859-1 character or a special key identifier (see table 3.3), and action is
767 either GLFW_PRESS or GLFW_RELEASE.
768 If cbfun is NULL, any previously selected callback function will be deselected.
769 Return values
770 none
771 Description
772 The function selects which function to be called upon a keyboard key event. The callback function is
773 called every time the state of a single key is changed (from released to pressed or vice versa). The
774 reported keys are unaffected by any modifiers (such as shift or alt).
775 A window has to be opened for this function to have any effect.
776 Notes
777 Keyboard events are recorded continuously, but only reported when glfwPollEvents, glfwWaitEvents
778 or glfwSwapBuffers is called.
781 "Parameters
782 cbfun
783 Pointer to a callback function that will be called every time a printable character is generated by
784 the keyboard. The function should have the following C language prototype:
785 void GLFWCALL functionname( int character, int action );
786 Where functionname is the name of the callback function, character is a Unicode (ISO 10646)
787 character, and action is either GLFW_PRESS or GLFW_RELEASE.
788 If cbfun is NULL, any previously selected callback function will be deselected.
789 Return values
790 none
791 Description
792 The function selects which function to be called upon a keyboard character event. The callback function
793 is called every time a key that results in a printable Unicode character is pressed or released. Characters
794 are affected by modifiers (such as shift or alt).
795 A window has to be opened for this function to have any effect.
796 Notes
797 Character events are recorded continuously, but only reported when glfwPollEvents, glfwWaitEvents
798 or glfwSwapBuffers is called.
799 Control characters, such as tab and carriage return, are not reported to the character callback function,
800 since they are not part of the Unicode character set. Use the key callback function for such events (see
801 glfwSetKeyCallback).
802 The Unicode character set supports character codes above 255, so never cast a Unicode character to an
803 eight bit data type (e.g. the C language ’char’ type) without first checking that the character code is less
804 than 256. Also note that Unicode character codes 0 to 255 are equal to ISO 8859-1 (Latin 1).
807 "Parameters
808 cbfun
809 Pointer to a callback function that will be called every time a mouse button is pressed or released.
810 The function should have the following C language prototype:
811 void GLFWCALL functionname( int button, int action );
812 Where functionname is the name of the callback function, button is a mouse button identifier (see
813 table 3.4 on page 56), and action is either GLFW_PRESS or GLFW_RELEASE.
814 If cbfun is NULL, any previously selected callback function will be deselected.
815 Return values
816 none
817 Description
818 The function selects which function to be called upon a mouse button event.
819 A window has to be opened for this function to have any effect.
820 Notes
821 Mouse button events are recorded continuously, but only reported when glfwPollEvents,
822 glfwWaitEvents or glfwSwapBuffers is called.
823 GLFW_MOUSE_BUTTON_LEFT is equal to GLFW_MOUSE_BUTTON_1.
824 GLFW_MOUSE_BUTTON_RIGHT is equal to GLFW_MOUSE_BUTTON_2.
825 GLFW_MOUSE_BUTTON_MIDDLE is equal to GLFW_MOUSE_BUTTON_3.
828 "Parameters
829 cbfun
830 Pointer to a callback function that will be called every time the mouse is moved. The function
831 should have the following C language prototype:
832 void GLFWCALL functionname( int x, int y );
833 Where functionname is the name of the callback function, and x and y are the mouse coordinates
834 (see glfwGetMousePos for more information on mouse coordinates).
835 If cbfun is NULL, any previously selected callback function will be deselected.
836 Return values
837 none
838 Description
839 The function selects which function to be called upon a mouse motion event.
840 A window has to be opened for this function to have any effect.
841 Notes
842 Mouse motion events are recorded continuously, but only reported when glfwPollEvents,
843 glfwWaitEvents or glfwSwapBuffers is called.
846 "Parameters
847 cbfun
848 Pointer to a callback function that will be called every time the mouse wheel is moved. The
849 function should have the following C language prototype:
850 void GLFWCALL functionname( int pos );
851 Where functionname is the name of the callback function, and pos is the mouse wheel position.
852 If cbfun is NULL, any previously selected callback function will be deselected.
853 Return values
854 none
855 Description
856 The function selects which function to be called upon a mouse wheel event.
857 A window has to be opened for this function to have any effect.
858 Notes
859 Mouse wheel events are recorded continuously, but only reported when glfwPollEvents,
860 glfwWaitEvents or glfwSwapBuffers is called.
864 "Parameters
865 joy
866 A joystick identifier, which should be GLFW_JOYSTICK_n, where n is in the range 1 to 16.
867 param
868 A token selecting which parameter the function should return (see table 3.5).
869 Return values
870 The function returns different parameters depending on the value of param. Table 3.5 lists valid param
871 values, and their corresponding return values.
872 Description
873 The function is used for acquiring various properties of a joystick.
874 Notes
875 The joystick information is updated every time the function is called.
876 No window has to be opened for joystick information to be valid.
879 (defcfun ("glfwGetJoystickPos" %get-joystick-pos) :int (joy :int) (pos :pointer) (numaxes :int))
882 "Parameters
883 joy
884 A joystick identifier, which should be GLFW_JOYSTICK_n, where n is in the range 1 to 16.
885 numaxes
886 Specifies how many axes should be returned.
887 Return values
888 An list that will hold the positional values for all requested axes.
889 If the joystick is not supported or connected, the function will
890 return nil.
892 Description
893 The function queries the current position of one or more axes of a joystick. The positional values are
894 returned in an array, where the first element represents the first axis of the joystick (normally the X
895 axis). Each position is in the range -1.0 to 1.0. Where applicable, the positive direction of an axis is
896 right, forward or up, and the negative direction is left, back or down.
897 If numaxes exceeds the number of axes supported by the joystick, or if the joystick is not available, the
898 unused elements in the pos array will be set to 0.0 (zero).
900 Notes
901 The joystick state is updated every time the function is called, so there is no need to call glfwPollEvents
902 or glfwWaitEvents for joystick state to be updated.
903 Use glfwGetJoystickParam to retrieve joystick capabilities, such as joystick availability and number of
904 supported axes.
905 No window has to be opened for joystick input to be valid.
906 "
912 (defcfun ("glfwGetJoystickButtons" %get-joystick-buttons) :int (joy :int) (buttons :pointer) (numbuttons :int))
914 "Parameters
915 joy
916 A joystick identifier, which should be GLFW_JOYSTICK_n, where n is in the range 1 to 16.
917 numbuttons
918 Specifies how many buttons should be returned.
919 Return values
920 A list that will hold the button states for all requested buttons.
921 The function returns the number of actually returned buttons. This is the minimum of numbuttons and
922 the number of buttons supported by the joystick. If the joystick is not supported or connected, the
923 function will return 0 (zero).
925 Description
926 The function queries the current state of one or more buttons of a joystick. The button states are
927 returned in an array, where the first element represents the first button of the joystick. Each state can be
928 either GLFW_PRESS or GLFW_RELEASE.
929 If numbuttons exceeds the number of buttons supported by the joystick, or if the joystick is not
930 available, the unused elements in the buttons array will be set to GLFW_RELEASE.
932 Notes
933 The joystick state is updated every time the function is called, so there is no need to call glfwPollEvents
934 or glfwWaitEvents for joystick state to be updated.
935 Use glfwGetJoystickParam to retrieve joystick capabilities, such as joystick availability and number of
936 supported buttons.
937 No window has to be opened for joystick input to be valid.
938 "
945 "Return values
946 The function returns the value of the high precision timer. The time is measured in seconds, and is
947 returned as a double precision floating point value.
949 Description
950 The function returns the state of a high precision timer. Unless the timer has been set by the
951 glfwSetTime function, the time is measured as the number of seconds that have passed since glfwInit
952 was called.
954 Notes
955 The resolution of the timer depends on which system the program is running on. The worst case
956 resolution is somewhere in the order of 10 ms, while for most systems the resolution should be better
957 than 1 μs.
961 "Parameters
962 time
963 Time (in seconds) that the timer should be set to.
965 Description
966 The function sets the current time of the high precision timer to the specified time. Subsequent calls to
967 glfwGetTime will be relative to this time. The time is given in seconds.
971 "Parameters
972 time
973 Time, in seconds, to sleep.
975 Description
976 The function puts the calling thread to sleep for the requested period of time. Only the calling thread is
977 put to sleep. Other threads within the same process can still execute.
979 Notes
980 There is usually a system dependent minimum time for which it is possible to sleep. This time is
981 generally in the range 1 ms to 20 ms, depending on thread sheduling time slot intervals etc. Using a
982 shorter time as a parameter to glfwSleep can give one of two results: either the thread will sleep for the
983 minimum possible sleep time, or the thread will not sleep at all (glfwSleep returns immediately). The
995 "Parameters
996 name
997 A null terminated ISO 8859-1 string holding the name of the file that should be read.
998 img
999 Pointer to a GLFWimage struct, which will hold the information about the loaded image (if the
1000 read was successful).
1001 flags
1002 Flags for controlling the image reading process. Valid flags are listed in table 3.6
1003 Return values
1004 The function returns t if the image was loaded successfully. Otherwise nil is
1005 returned.
1006 Description
1007 The function reads an image from the file specified by the parameter name and returns the image
1008 information and data in a GLFWimage structure, which has the following definition:
1009 § ¤
1010 typedef struct {
1011 int Width, Height; // Image dimensions
1012 int Format; // OpenGL pixel format
1013 int BytesPerPixel; // Number of bytes per pixel
1014 unsigned char *Data; // Pointer to pixel data
1015 } GLFWimage;
1016 ¦ ¥
1017 Width and Height give the dimensions of the image. Format specifies an OpenGL™ pixel format,
1018 which can be GL_LUMINANCE or GL_ALPHA (for gray scale images), GL_RGB or GL_RGBA.
1019 BytesPerPixel specifies the number of bytes per pixel. Data is a pointer to the actual pixel data.
1020 By default the read image is rescaled to the nearest larger 2m × 2n resolution using bilinear
1021 interpolation, if necessary, which is useful if the image is to be used as an OpenGL™ texture. This
1022 behavior can be disabled by setting the GLFW_NO_RESCALE_BIT flag.
1023 Unless the flag GLFW_ORIGIN_UL_BIT is set, the first pixel in img->Data is the lower left corner of
1024 the image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left corner.
1025 For single component images (i.e. gray scale), Format is set to GL_ALPHA if the flag
1026 GLFW_ALPHA_MAP_BIT flag is set, otherwise Format is set to GL_LUMINANCE.
1027 Notes
1028 glfwReadImage supports the Truevision Targa version 1 file format (.TGA). Supported pixel formats
1029 are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color + alpha.
1030 Paletted images are translated into true color or true color + alpha pixel formats.
1031 Please note that OpenGL™ 1.0 does not support single component alpha maps, so do not use images
1032 with Format = GL_ALPHA directly as textures under OpenGL™ 1.0.
1037 "Parameters
1038 data
1039 The memory buffer holding the contents of the file that should be read.
1040 size
1041 The size, in bytes, of the memory buffer.
1042 img
1043 Pointer to a GLFWimage struct, which will hold the information about the loaded image (if the
1044 read was successful).
1045 flags
1046 Flags for controlling the image reading process. Valid flags are listed in table 3.6
1047 Return values
1048 The function returns t if the image was loaded successfully. Otherwise nil is
1049 returned.
1050 Description
1051 The function reads an image from the memory buffer specified by the parameter data and returns the
1052 image information and data in a GLFWimage structure, which has the following definition:
1053 § ¤
1054 typedef struct {
1055 int Width, Height; // Image dimensions
1056 int Format; // OpenGL pixel format
1057 int BytesPerPixel; // Number of bytes per pixel
1058 unsigned char *Data; // Pointer to pixel data
1059 } GLFWimage;
1060 ¦ ¥
1061 Width and Height give the dimensions of the image. Format specifies an OpenGL™ pixel format,
1062 which can be GL_LUMINANCE or GL_ALPHA (for gray scale images), GL_RGB or GL_RGBA.
1063 BytesPerPixel specifies the number of bytes per pixel. Data is a pointer to the actual pixel data.
1064 By default the read image is rescaled to the nearest larger 2m × 2n resolution using bilinear
1065 interpolation, if necessary, which is useful if the image is to be used as an OpenGL™ texture. This
1066 behavior can be disabled by setting the GLFW_NO_RESCALE_BIT flag.
1067 Unless the flag GLFW_ORIGIN_UL_BIT is set, the first pixel in img->Data is the lower left corner of
1068 the image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left corner.
1069 For single component images (i.e. gray scale), Format is set to GL_ALPHA if the flag
1070 GLFW_ALPHA_MAP_BIT flag is set, otherwise Format is set to GL_LUMINANCE.
1071 Notes
1072 glfwReadMemoryImage supports the Truevision Targa version 1 file format (.TGA). Supported pixel
1073 formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color +
1074 alpha.
1075 Paletted images are translated into true color or true color + alpha pixel formats.
1076 Please note that OpenGL™ 1.0 does not support single component alpha maps, so do not use images
1077 with Format = GL_ALPHA directly as textures under OpenGL™ 1.0.
1081 "Parameters
1082 img
1083 Pointer to a GLFWimage struct.
1084 Description
1085 The function frees any memory occupied by a loaded image, and clears all the fields of the GLFWimage
1086 struct. Any image that has been loaded by the glfwReadImage function should be deallocated using
1090 "Parameters
1091 name
1092 An ISO 8859-1 string holding the name of the file that should be loaded.
1093 flags
1094 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1095 Return values
1096 The function returns t if the texture was loaded successfully. Otherwise nil is
1097 returned.
1099 Description
1100 The function reads an image from the file specified by the parameter name and uploads the image to
1101 OpenGL™ texture memory (using the glTexImage2D function).
1102 If the GLFW_BUILD_MIPMAPS_BIT flag is set, all mipmap levels for the loaded texture are
1103 generated and uploaded to texture memory.
1104 Unless the flag GLFW_ORIGIN_UL_BIT is set, the origin of the texture is the lower left corner of the
1105 loaded image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left
1106 corner.
1107 For single component images (i.e. gray scale), the texture is uploaded as an alpha mask if the flag
1108 GLFW_ALPHA_MAP_BIT flag is set, otherwise it is uploaded as a luminance texture.
1110 Notes
1111 glfwLoadTexture2D supports the Truevision Targa version 1 file format (.TGA). Supported pixel
1112 formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color +
1113 alpha.
1114 Paletted images are translated into true color or true color + alpha pixel formats.
1115 The read texture is always rescaled to the nearest larger 2m × 2n resolution using bilinear interpolation,
1116 if necessary, since OpenGL™ requires textures to have a 2m × 2n resolution.
1117 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1118 the OpenGL™ implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1119 generated by GLFW in software.
1120 Since OpenGL™ 1.0 does not support single component alpha maps, alpha map textures are converted
1121 to RGBA format under OpenGL™ 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1122 texture is a single component texture. The red, green and blue components are set to 1.0.
1127 "Parameters
1128 data
1129 The memory buffer holding the contents of the file that should be loaded.
1130 size
1131 The size, in bytes, of the memory buffer.
1132 flags
1133 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1134 Return values
1135 The function returns t if the texture was loaded successfully. Otherwise nil is
1136 returned.
1138 Description
1139 The function reads an image from the memory buffer specified by the parameter data and uploads the
1140 image to OpenGL™ texture memory (using the glTexImage2D function).
1141 If the GLFW_BUILD_MIPMAPS_BIT flag is set, all mipmap levels for the loaded texture are
1142 generated and uploaded to texture memory.
1143 Unless the flag GLFW_ORIGIN_UL_BIT is set, the origin of the texture is the lower left corner of the
1144 loaded image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left
1145 corner.
1146 For single component images (i.e. gray scale), the texture is uploaded as an alpha mask if the flag
1147 GLFW_ALPHA_MAP_BIT flag is set, otherwise it is uploaded as a luminance texture.
1149 Notes
1150 glfwLoadMemoryTexture2D supports the Truevision Targa version 1 file format (.TGA). Supported
1151 pixel formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color
1152 + alpha.
1153 Paletted images are translated into true color or true color + alpha pixel formats.
1154 The read texture is always rescaled to the nearest larger 2m × 2n resolution using bilinear interpolation,
1155 if necessary, since OpenGL™ requires textures to have a 2m × 2n resolution.
1156 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1157 the OpenGL™ implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1158 generated by GLFW in software.
1159 Since OpenGL™ 1.0 does not support single component alpha maps, alpha map textures are converted
1160 to RGBA format under OpenGL™ 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1161 texture is a single component texture. The red, green and blue components are set to 1.0.
1167 "Parameters
1168 img
1169 Pointer to a GLFWimage struct holding the information about the image to be loaded.
1170 flags
1171 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1172 Return values
1173 The function returns t if the texture was loaded successfully. Otherwise nil is
1174 returned.
1176 Description
1177 The function uploads the image specified by the parameter img to OpenGL™ texture memory (using
1178 the glTexImage2D function).
1179 If the GLFW_BUILD_MIPMAPS_BIT flag is set, all mipmap levels for the loaded texture are
1180 generated and uploaded to texture memory.
1181 Unless the flag GLFW_ORIGIN_UL_BIT is set, the origin of the texture is the lower left corner of the
1182 loaded image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left
1183 corner.
1184 For single component images (i.e. gray scale), the texture is uploaded as an alpha mask if the flag
1185 GLFW_ALPHA_MAP_BIT flag is set, otherwise it is uploaded as a luminance texture.
1187 Notes
1188 glfwLoadTextureImage2D supports the Truevision Targa version 1 file format (.TGA). Supported
1189 pixel formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color
1190 + alpha.
1191 Paletted images are translated into true color or true color + alpha pixel formats.
1192 The read texture is always rescaled to the nearest larger 2m × 2n resolution using bilinear interpolation,
1193 if necessary, since OpenGL™ requires textures to have a 2m × 2n resolution.
1194 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1195 the OpenGL™ implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1196 generated by GLFW in software.
1197 Since OpenGL™ 1.0 does not support single component alpha maps, alpha map textures are converted
1198 to RGBA format under OpenGL™ 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1203 "Parameters
1204 extension
1205 A null terminated ISO 8859-1 string containing the name of an OpenGL™ extension.
1206 Return values
1207 The function returns t if the extension is supported. Otherwise it returns nil.
1208 Description
1209 The function does a string search in the list of supported OpenGL™ extensions to find if the specified
1210 extension is listed.
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 In addition to checking for OpenGL™ extensions, GLFW also checks for extensions in the operating
1215 system “glue API”, such as WGL extensions under Windows and glX extensions under the X Window
1216 System.
1220 "Parameters
1221 procname
1222 A null terminated ISO 8859-1 string containing the name of an OpenGL™ extension function.
1223 Return values
1224 The function returns the pointer to the specified OpenGL™ function if it is supported, otherwise
1225 NULL is returned.
1226 Description
1227 The function acquires the pointer to an OpenGL™ extension function. Some (but not all) OpenGL™
1228 extensions define new API functions, which are usually not available through normal linking. It is
1229 therefore necessary to get access to those API functions at runtime.
1230 Notes
1231 An OpenGL™ context must be created before this function can be called (i.e. an OpenGL™ window
1232 must have been opened with glfwOpenWindow).
1233 Some systems do not support dynamic function pointer retrieval, in which case glfwGetProcAddress
1234 will always return NULL.
1240 "Return values
1241 The function returns the major and minor version numbers and the revision for the currently used
1242 OpenGL™ implementation as a list (major minor rev).
1244 Description
1245 The function returns the OpenGL™ implementation version. This is a convenient function that parses
1246 the version number information from the string returned by calling
1247 glGetString( GL_VERSION ). The OpenGL™ version information can be used to determine
1248 what functionality is supported by the used OpenGL™ implementation.
1250 Notes
1251 An OpenGL™ context must be created before this function can be called (i.e. an OpenGL™ window
1260 "Parameters
1261 fun
1262 A pointer to a function that acts as the entry point for the new thread. The function should have
1263 the following C language prototype:
1264 void GLFWCALL functionname( void *arg );
1265 Where functionname is the name of the thread function, and arg is the user supplied argument
1266 (see below).
1267 arg
1268 An arbitrary argument for the thread. arg will be passed as the argument to the thread function
1269 pointed to by fun. For instance, arg can point to data that is to be processed by the thread.
1270 Return values
1271 The function returns a thread identification number if the thread was created successfully. This number
1272 is always positive. If the function fails, a negative number is returned.
1273 Description
1274 The function creates a new thread, which executes within the same address space as the calling process.
1275 The thread entry point is specified with the fun argument.
1276 Once the thread function fun returns, the thread dies.
1277 Notes
1278 Even if the function returns a positive thread ID, indicating that the thread was created successfully, the
1279 thread may be unable to execute, for instance if the thread start address is not a valid thread entry point.
1282 "Parameters
1283 ID
1284 A thread identification handle, which is returned by glfwCreateThread or glfwGetThreadID.
1285 Description
1286 The function kills a running thread and removes it from the thread list.
1287 Notes
1288 This function is a very dangerous operation, which may interrupt a thread in the middle of an important
1289 operation, and its use is discouraged. You should always try to end a thread in a graceful way using
1290 thread communication, and use glfwWaitThread in order to wait for the thread to die.
1293 "Parameters
1294 ID
1295 A thread identification handle, which is returned by glfwCreateThread or glfwGetThreadID.
1296 waitmode
1297 Can be either GLFW_WAIT or GLFW_NOWAIT.
1298 Return values
1299 The function returns t if the specified thread died after the function was called, or the thread
1300 did not exist, in which case glfwWaitThread will return immediately regardless of waitmode. The
1301 function returns nil if waitmode is GLFW_NOWAIT, and the specified thread exists and is still
1302 running.
1305 "Return values
1306 The function returns a thread identification handle for the calling thread.
1307 Description
1308 The function determines the thread ID for the calling thread. The ID is the same value as was returned
1309 by glfwCreateThread when the thread was created.
1313 "Return values
1314 The function returns a mutex handle, or NULL if the mutex could not be created.
1315 Description
1316 The function creates a mutex object, which can be used to control access to data that is shared between
1317 threads.
1320 "Parameters
1321 mutex
1322 A mutex object handle.
1323 Description
1324 The function destroys a mutex object. After a mutex object has been destroyed, it may no longer be
1325 used by any thread.
1328 "Parameters
1329 mutex
1330 A mutex object handle.
1331 Description
1332 The function will acquire a lock on the selected mutex object. If the mutex is already locked by another
1333 thread, the function will block the calling thread until it is released by the locking thread. Once the
1334 function returns, the calling thread has an exclusive lock on the mutex. To release the mutex, call
1335 glfwUnlockMutex.
1338 "Parameters
1339 mutex
1340 A mutex object handle.
1341 Description
1342 The function releases the lock of a locked mutex object.
1346 "Parameters
1347 mutex
1348 A mutex object handle.
1349 forms
1350 Body of code to execute
1351 Description
1352 This macro will acquire a lock on the selected mutex object using glfwLockMutex and release it afterwards
1353 using glfwUnlockMutex.
1354 So, forms will not execute until an exclusive lock is held.
1355 The lock is then released when the stack is unwound."
1363 "Return values
1364 The function returns a condition variable handle, or NULL if the condition variable could not be
1365 created.
1366 Description
1367 The function creates a condition variable object, which can be used to synchronize threads.
1370 "Parameters
1371 cond
1372 A condition variable object handle.
1373 Description
1374 The function destroys a condition variable object. After a condition variable object has been destroyed,
1375 it may no longer be used by any thread.
1378 " arameters
1379 cond
1380 A condition variable object handle.
1381 mutex
1382 A mutex object handle.
1383 timeout
1384 Maximum time to wait for the condition variable. The parameter can either be a positive time (in
1385 seconds), or GLFW_INFINITY.
1386 Description
1387 The function atomically unlocks the mutex specified by mutex, and waits for the condition variable cond
1388 to be signaled. The thread execution is suspended and does not consume any CPU time until the
1389 condition variable is signaled or the amount of time specified by timeout has passed. If timeout is
1390 GLFW_INFINITY, glfwWaitCond will wait forever for cond to be signaled. Before returning to the
1391 calling thread, glfwWaitCond automatically re-acquires the mutex.
1392 Notes
1393 The mutex specified by mutex must be locked by the calling thread before entrance to glfwWaitCond.
1394 A condition variable must always be associated with a mutex, to avoid the race condition where a thread
1395 prepares to wait on a condition variable and another thread signals the condition just before the first
1396 thread actually waits on it.
1399 "Parameters
1400 cond
1401 A condition variable object handle.
1402 Description
1403 The function restarts one of the threads that are waiting on the condition variable cond. If no threads are
1404 waiting on cond, nothing happens. If several threads are waiting on cond, exactly one is restarted, but it
1405 is not specified which.
1406 Notes
1407 When several threads are waiting for the condition variable, which thread is started depends on
1408 operating system scheduling rules, and may vary from system to system and from time to time.
1411 "Parameters
1412 cond
1413 A condition variable object handle.
1414 Description
1415 The function restarts all the threads that are waiting on the condition variable cond. If no threads are
1416 waiting on cond, nothing happens.
1417 Notes
1418 When several threads are waiting for the condition variable, the order in which threads are started
1419 depends on operating system scheduling rules, and may vary from system to system and from time to
1420 time.
1424 "Return values
1425 The function returns the number of active processors in the system.
1426 Description
1427 The function determines the number of active processors in the system.
1428 Notes
1429 Systems with several logical processors per physical processor, also known as SMT (Symmetric Multi
1430 Threading) processors, will report the number of logical processors.
1433 "Parameters
1434 token
1435 A value specifying a feature to enable or disable. Valid tokens are listed in table 3.8.
1436 Return values
1437 none
1438 Description
1439 glfwEnable is used to enable a certain feature, while glfwDisable is used to disable it. Below follows a
1440 description of each feature.
1441 GLFW_AUTO_POLL_EVENTS
1442 When GLFW_AUTO_POLL_EVENTS is enabled, glfwPollEvents is automatically called each time
1443 that glfwSwapBuffers is called.
1444 When GLFW_AUTO_POLL_EVENTS is disabled, calling glfwSwapBuffers will not result in a call to
1445 glfwPollEvents. This can be useful if glfwSwapBuffers needs to be called from within a callback
1446 function, since calling glfwPollEvents from a callback function is not allowed.
1447 GLFW_KEY_REPEAT
1448 When GLFW_KEY_REPEAT is enabled, the key and character callback functions are called repeatedly
1449 when a key is held down long enough (according to the system key repeat configuration).
1450 When GLFW_KEY_REPEAT is disabled, the key and character callback functions are only called once
1451 when a key is pressed (and once when it is released).
1452 GLFW_MOUSE_CURSOR
1453 When GLFW_MOUSE_CURSOR is enabled, the mouse cursor is visible, and mouse coordinates are
1454 relative to the upper left corner of the client area of the GLFW window. The coordinates are limited to
1455 the client area of the window.
1456 When GLFW_MOUSE_CURSOR is disabled, the mouse cursor is invisible, and mouse coordinates are
1457 not limited to the drawing area of the window. It is as if the mouse coordinates are recieved directly
1458 from the mouse, without being restricted or manipulated by the windowing system.
1459 GLFW_STICKY_KEYS
1460 When GLFW_STICKY_KEYS is enabled, keys which are pressed will not be released until they are
1461 physically released and checked with glfwGetKey. This behavior makes it possible to catch keys that
1462 were pressed and then released again between two calls to glfwPollEvents, glfwWaitEvents or
1463 glfwSwapBuffers, which would otherwise have been reported as released. Care should be taken when
1464 using this mode, since keys that are not checked with glfwGetKey will never be released. Note also that
1465 enabling GLFW_STICKY_KEYS does not affect the behavior of the keyboard callback functionality.
1466 When GLFW_STICKY_KEYS is disabled, the status of a key that is reported by glfwGetKey is always
1467 the physical state of the key. Disabling GLFW_STICKY_KEYS also clears the sticky information for
1468 all keys.
1469 GLFW_STICKY_MOUSE_BUTTONS
1470 When GLFW_STICKY_MOUSE_BUTTONS is enabled, mouse buttons that are pressed will not be
1471 released until they are physically released and checked with glfwGetMouseButton. This behavior
1472 makes it possible to catch mouse buttons which were pressed and then released again between two calls
1473 to glfwPollEvents, glfwWaitEvents or glfwSwapBuffers, which would otherwise have been reported
1474 as released. Care should be taken when using this mode, since mouse buttons that are not checked with
1475 glfwGetMouseButton will never be released. Note also that enabling
1476 GLFW_STICKY_MOUSE_BUTTONS does not affect the behavior of the mouse button callback
1477 functionality.
1478 When GLFW_STICKY_MOUSE_BUTTONS is disabled, the status of a mouse button that is reported
1479 by glfwGetMouseButton is always the physical state of the mouse button. Disabling
1480 GLFW_STICKY_MOUSE_BUTTONS also clears the sticky information for all mouse buttons.
1481 GLFW_SYSTEM_KEYS
1482 When GLFW_SYSTEM_KEYS is enabled, pressing standard system key combinations, such as
1483 ALT+TAB under Windows, will give the normal behavior. Note that when ALT+TAB is issued under
1484 Windows in this mode so that the GLFW application is deselected when GLFW is operating in
1485 fullscreen mode, the GLFW application window will be minimized and the video mode will be set to
1486 the original desktop mode. When the GLFW application is re-selected, the video mode will be set to
1487 the GLFW video mode again.
1488 When GLFW_SYSTEM_KEYS is disabled, pressing standard system key combinations will have no
1489 effect, since those key combinations are blocked by GLFW. This mode can be useful in situations when
1490 the GLFW program must not be interrupted (normally for games in fullscreen mode).
1493 "Parameters
1494 token
1495 A value specifying a feature to enable or disable. Valid tokens are listed in table 3.8.
1496 Return values
1497 none
1498 Description
1499 glfwEnable is used to enable a certain feature, while glfwDisable is used to disable it. Below follows a
1500 description of each feature.
1501 GLFW_AUTO_POLL_EVENTS
1502 When GLFW_AUTO_POLL_EVENTS is enabled, glfwPollEvents is automatically called each time
1503 that glfwSwapBuffers is called.
1504 When GLFW_AUTO_POLL_EVENTS is disabled, calling glfwSwapBuffers will not result in a call to
1505 glfwPollEvents. This can be useful if glfwSwapBuffers needs to be called from within a callback
1506 function, since calling glfwPollEvents from a callback function is not allowed.
1507 GLFW_KEY_REPEAT
1508 When GLFW_KEY_REPEAT is enabled, the key and character callback functions are called repeatedly
1509 when a key is held down long enough (according to the system key repeat configuration).
1510 When GLFW_KEY_REPEAT is disabled, the key and character callback functions are only called once
1511 when a key is pressed (and once when it is released).
1512 GLFW_MOUSE_CURSOR
1513 When GLFW_MOUSE_CURSOR is enabled, the mouse cursor is visible, and mouse coordinates are
1514 relative to the upper left corner of the client area of the GLFW window. The coordinates are limited to
1515 the client area of the window.
1516 When GLFW_MOUSE_CURSOR is disabled, the mouse cursor is invisible, and mouse coordinates are
1517 not limited to the drawing area of the window. It is as if the mouse coordinates are recieved directly
1518 from the mouse, without being restricted or manipulated by the windowing system.
1519 GLFW_STICKY_KEYS
1520 When GLFW_STICKY_KEYS is enabled, keys which are pressed will not be released until they are
1521 physically released and checked with glfwGetKey. This behavior makes it possible to catch keys that
1522 were pressed and then released again between two calls to glfwPollEvents, glfwWaitEvents or
1523 glfwSwapBuffers, which would otherwise have been reported as released. Care should be taken when
1524 using this mode, since keys that are not checked with glfwGetKey will never be released. Note also that
1525 enabling GLFW_STICKY_KEYS does not affect the behavior of the keyboard callback functionality.
1526 When GLFW_STICKY_KEYS is disabled, the status of a key that is reported by glfwGetKey is always
1527 the physical state of the key. Disabling GLFW_STICKY_KEYS also clears the sticky information for
1528 all keys.
1529 GLFW_STICKY_MOUSE_BUTTONS
1530 When GLFW_STICKY_MOUSE_BUTTONS is enabled, mouse buttons that are pressed will not be
1531 released until they are physically released and checked with glfwGetMouseButton. This behavior
1532 makes it possible to catch mouse buttons which were pressed and then released again between two calls
1533 to glfwPollEvents, glfwWaitEvents or glfwSwapBuffers, which would otherwise have been reported
1534 as released. Care should be taken when using this mode, since mouse buttons that are not checked with
1535 glfwGetMouseButton will never be released. Note also that enabling
1536 GLFW_STICKY_MOUSE_BUTTONS does not affect the behavior of the mouse button callback
1537 functionality.
1538 When GLFW_STICKY_MOUSE_BUTTONS is disabled, the status of a mouse button that is reported
1539 by glfwGetMouseButton is always the physical state of the mouse button. Disabling
1540 GLFW_STICKY_MOUSE_BUTTONS also clears the sticky information for all mouse buttons.
1541 GLFW_SYSTEM_KEYS
1542 When GLFW_SYSTEM_KEYS is enabled, pressing standard system key combinations, such as
1543 ALT+TAB under Windows, will give the normal behavior. Note that when ALT+TAB is issued under
1544 Windows in this mode so that the GLFW application is deselected when GLFW is operating in
1545 fullscreen mode, the GLFW application window will be minimized and the video mode will be set to
1546 the original desktop mode. When the GLFW application is re-selected, the video mode will be set to
1547 the GLFW video mode again.
1548 When GLFW_SYSTEM_KEYS is disabled, pressing standard system key combinations will have no
1549 effect, since those key combinations are blocked by GLFW. This mode can be useful in situations when
1550 the GLFW program must not be interrupted (normally for games in fullscreen mode).