| blob | 1306453ce14418913b1d9ec30896ca14bb3d841a |
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)))))))
71 ;; Key and button state/action definitions
75 ;; Keyboard key definitions: 8-bit ISO-8859-1 (Latin 1) encoding is used
76 ;; for printable keys (such as A-Z, 0-9 etc), and values above 256
77 ;; represent special (non-printable) keys (e.g. F1, Page Up etc).
145 ;; Mouse button definitions
156 ;; Mouse button aliases
161 ;; Joystick identifiers
181 ;;========================================================================
182 ;; Other definitions
183 ;;========================================================================
185 ;; glfwOpenWindow modes
189 ;; glfwGetWindowParam tokens
201 ;; The following constants are used for both glfwGetWindowParam
202 ;; and glfwOpenWindowHint
213 ;; glfwEnable/glfwDisable tokens
221 ;; glfwWaitThread wait modes
225 ;; glfwGetJoystickParam tokens
230 ;; glfwReadImage/glfwLoadTexture2D flags
236 ;; Time spans longer than this (seconds) are considered to be infinity
240 "Return values
241 If the function succeeds, t is returned.
242 If the function fails, nil is returned.
244 The glfwInit function initializes GLFW. No other GLFW functions may be used before this function
245 has been called.
247 Notes
248 This function may take several seconds to complete on some systems, while on other systems it may
252 "The function terminates GLFW. Among other things it closes the window, if it is opened, and kills any
258 "Return values
259 The function returns the major and minor version numbers and the revision for the currently linked
263 "Call glfw:init, execute forms and clean-up with glfw:terminate once finished.
264 This makes a nice wrapper to an application higher-level form.
265 Signals an error on failure to initialize. Wrapped in a block named glfw:with-init."
281 "width
282 The width of the window. If width is zero, it will be calculated as width = 4/3 height, if height is
283 not zero. If both width and height are zero, then width will be set to 640.
284 height
285 The height of the window. If height is zero, it will be calculated as height = 3/4 width, if width is
286 not zero. If both width and height are zero, then height will be set to 480.
287 redbits, greenbits, bluebits
288 The number of bits to use for each color component of the color buffer (0 means default color
289 depth). For instance, setting redbits=5, greenbits=6, and bluebits=5 will generate a 16-bit color
290 buffer, if possible.
291 alphabits
292 The number of bits to use for the alpha buffer (0 means no alpha buffer).
293 depthbits
294 The number of bits to use for the depth buffer (0 means no depth buffer).
295 stencilbits
296 The number of bits to use for the stencil buffer (0 means no stencil buffer).
297 mode
298 Selects which type of OpenGL™ window to use. mode can be either GLFW_WINDOW, which
299 will generate a normal desktop window, or GLFW_FULLSCREEN, which will generate a
300 window which covers the entire screen. When GLFW_FULLSCREEN is selected, the video
301 mode will be changed to the resolution that closest matches the width and height parameters.
303 Return values
304 If the function succeeds, t is returned.
305 If the function fails, nil is returned.
307 Description
308 The function opens a window that best matches the parameters given to the function. How well the
309 resulting window matches the desired window depends mostly on the available hardware and
310 OpenGL™ drivers. In general, selecting a fullscreen mode has better chances of generating a close
311 match than does a normal desktop window, since GLFW can freely select from all the available video
312 modes. A desktop window is normally restricted to the video mode of the desktop.
314 Notes
315 For additional control of window properties, see glfwOpenWindowHint.
316 In fullscreen mode the mouse cursor is hidden by default, and any system screensavers are prohibited
317 from starting. In windowed mode the mouse cursor is visible, and screensavers are allowed to start. To
318 change the visibility of the mouse cursor, use glfwEnable or glfwDisable with the argument
319 GLFW_MOUSE-CURSOR.
320 In order to determine the actual properties of an opened window, use glfwGetWindowParam and
321 glfwGetWindowSize (or glfwSetWindowSizeCallback).
322 "
327 "target
328 Can be any of the constants in the table 3.1.
329 hint
330 An integer giving the value of the corresponding target (see table 3.1).
332 Description
333 The function sets additional properties for a window that is to be opened. For a hint to be registered, the
334 function must be called before calling glfwOpenWindow. When the glfwOpenWindow function is
335 called, any hints that were registered with the glfwOpenWindowHint function are used for setting the
336 corresponding window properties, and then all hints are reset to their default values.
338 Notes
339 In order to determine the actual properties of an opened window, use glfwGetWindowParam (after the
340 window has been opened).
341 GLFW_STEREO is a hard constraint. If stereo rendering is requested, but no stereo rendering capable
342 pixel formats / visuals are available, glfwOpenWindow will fail.
343 The GLFW_REFRESH-RATE property should be used with caution. Most systems have default values
344 for monitor refresh rates that are optimal for the specific system. Specifying the refresh rate can
345 override these settings, which can result in suboptimal operation. The monitor may be unable to display
346 the resulting video signal, or in the worst case it may even be damaged!
356 "Wraps forms such that there is an open window for them to execute in and cleans up the
357 window afterwards. An error is signalled if there was an error opening the window.
358 Takes the same parameters as open-window, with the addition of 'title' which will
359 set the window title after opening.
360 Wrapped in a block named glfw:with-open-window."
361 `(if (%open-window ,width ,height ,redbits ,greenbits ,bluebits ,alphabits ,depthbits ,stencilbits ,mode)
374 "Wraps forms in with-init, with-open-window. Passes through the other arguments to open-window."
376 (with-open-window (,title ,width ,height ,redbits ,greenbits ,bluebits ,alphabits ,depthbits ,stencilbits ,mode)
384 "High-level convenience macro for initializing glfw, opening a window (given the optional window parameters),
385 setting the title given,
386 running setup-forms and then running forms in a loop, with calls to swap-buffers after each loop iteration.
387 The loop is in a block named do-window [so can be exited by a call to (return-from glfw:do-window)].
388 If the window is closed, the loop is also exited."
389 `(with-init-window (,title ,width ,height ,redbits ,greenbits ,bluebits ,alphabits ,depthbits ,stencilbits ,mode)
390 ,@setup-forms
392 ,@forms
398 "Parameters
399 cbfun
400 Pointer to a callback function that will be called when a user requests that the window should be
401 closed, typically by clicking the window close icon (e.g. the cross in the upper right corner of a
402 window under Microsoft Windows). The function should have the following C language
403 prototype:
404 int GLFWCALL functionname( void );
405 Where functionname is the name of the callback function. The return value of the callback
406 function indicates wether or not the window close action should continue. If the function returns
407 GL_TRUE, the window will be closed. If the function returns GL_FALSE, the window will not
408 be closed.
409 If cbfun is NULL, any previously selected callback function will be deselected.
411 If you declare your callback as returning glfw:boolean, you can use t and nil as return types.
413 Description
414 The function selects which function to be called upon a window close event.
415 A window has to be opened for this function to have any effect.
417 Notes
418 Window close events are recorded continuously, but only reported when glfwPollEvents,
419 glfwWaitEvents or glfwSwapBuffers is called.
420 The OpenGL™ context is still valid when this function is called.
421 Note that the window close callback function is not called when glfwCloseWindow is called, but only
422 when the close request comes from the window manager.
423 Do not call glfwCloseWindow from a window close callback function. Close the window by returning
424 GL_TRUE from the function.
428 "Parameters
429 title
430 Pointer to a null terminated ISO 8859-1 (8-bit Latin 1) string that holds the title of the window.
432 Description
433 The function changes the title of the opened window.
435 Notes
436 The title property of a window is often used in situations other than for the window title, such as the title
440 "Parameters
441 width
442 Width of the window.
443 height
444 Height of the window.
445 Return values
446 none
447 Description
448 The function changes the size of an opened window. The width and height parameters denote the size of
449 the client area of the window (i.e. excluding any window borders and decorations).
450 If the window is in fullscreen mode, the video mode will be changed to a resolution that closest matches
451 the width and height parameters (the number of color bits will not be changed).
452 Notes
453 The OpenGL™ context is guaranteed to be preserved after calling glfwSetWindowSize, even if the
454 video mode is changed.
458 "Parameters
459 x
460 Horizontal position of the window, relative to the upper left corner of the desktop.
461 y
462 Vertical position of the window, relative to the upper left corner of the desktop.
463 Return values
464 none
465 Description
466 The function changes the position of an opened window. It does not have any effect on a fullscreen
467 window.
472 "The function is used for determining the size of an opened window. The returned values are dimensions
473 of the client area of the window (i.e. excluding any window borders and decorations).
474 (list width height)"
482 "Parameters
483 cbfun
484 Pointer to a callback function that will be called every time the window size changes. The
485 function should have the following C language prototype:
486 void GLFWCALL functionname( int width, int height );
487 Where functionname is the name of the callback function, and width and height are the
488 dimensions of the window client area.
489 If cbfun is NULL, any previously selected callback function will be deselected.
490 Return values
491 none
492 Description
493 The function selects which function to be called upon a window size change event.
494 A window has to be opened for this function to have any effect.
495 Notes
496 Window size changes are recorded continuously, but only reported when glfwPollEvents,
500 "Iconify a window. If the window is in fullscreen mode, then the desktop video mode will be restored.")
503 "Restore an iconified window. If the window that is restored is in fullscreen mode, then the fullscreen
507 "Parameters
508 param
509 A token selecting which parameter the function should return (see table 3.2).
511 Return values
512 The function returns different parameters depending on the value of param. Table 3.2 lists valid param
513 values, and their corresponding return values.
515 Description
516 The function is used for acquiring various properties of an opened window.
518 Notes
519 GLFW_ACCELERATED is only supported under Windows. Other systems will always return
520 GL_TRUE. Under Windows, GLFW_ACCELERATED means that the OpenGL™ renderer is a 3rd
521 party renderer, rather than the fallback Microsoft software OpenGL™ renderer. In other words, it is
522 not a real guarantee that the OpenGL™ renderer is actually hardware accelerated.
526 "The function swaps the back and front color buffers of the window. If GLFW_AUTO-POLL-EVENTS
527 is enabled (which is the default), glfwPollEvents is called before swapping the front and back buffers.")
531 "Parameters
532 interval
533 Minimum number of monitor vertical retraces between each buffer swap performed by
534 glfwSwapBuffers. If interval is zero, buffer swaps will not be synchronized to the vertical
535 refresh of the monitor (also known as ’VSync off’).
537 Description
538 The function selects the minimum number of monitor vertical retraces that should occur between two
539 buffer swaps. If the selected swap interval is one, the rate of buffer swaps will never be higher than the
540 vertical refresh rate of the monitor. If the selected swap interval is zero, the rate of buffer swaps is only
541 limited by the speed of the software and the hardware.
543 Notes
544 This function will only have an effect on hardware and drivers that support user selection of the swap
548 (defcfun+doc ("glfwSetWindowRefreshCallback" set-window-refresh-callback) :void ((cbfun :pointer))
549 "Parameters
550 cbfun
551 Pointer to a callback function that will be called when the window client area needs to be
552 refreshed. The function should have the following C language prototype:
553 void GLFWCALL functionname( void );
554 Where functionname is the name of the callback function.
555 If cbfun is NULL, any previously selected callback function will be deselected.
557 Description
558 The function selects which function to be called upon a window refresh event, which occurs when any
559 part of the window client area has been damaged, and needs to be repainted (for instance, if a part of the
560 window that was previously occluded by another window has become visible).
561 A window has to be opened for this function to have any effect.
563 Notes
564 Window refresh events are recorded continuously, but only reported when glfwPollEvents,
565 glfwWaitEvents or glfwSwapBuffers is called.
578 "Parameters
579 maxcount
580 Maximum number of video modes that list vector can hold.
582 Return values
583 The function returns the number of detected video modes (this number will never exceed maxcount).
584 The list vector is filled out with the video modes that are supported by the system.
586 Description
587 The function returns a list of supported video modes. Each video mode is represented by a
588 list of the form:
589 (width height redbits greenbits bluebits)
591 Notes
592 The returned list is sorted, first by color depth (RedBits + GreenBits + BlueBits), and then by
593 resolution (Width × Height), with the lowest resolution, fewest bits per pixel mode first. "
598 collecting
608 "Parameters
609 mode
610 Pointer to a GLFWvidmode structure, which will be filled out by the function.
611 Return values
612 The GLFWvidmode structure pointed to by mode is filled out with the desktop video mode.
613 Description
614 The function returns the desktop video mode in a GLFWvidmode structure. See glfwGetVideoModes
615 for a definition of the GLFWvidmode structure.
616 Notes
617 The color depth of the desktop display is always reported as the number of bits for each individual color
618 component (red, green and blue), even if the desktop is not using an RGB or RGBA color format. For
619 instance, an indexed 256 color display may report RedBits = 3, GreenBits = 3 and BlueBits = 2, which
620 adds up to 8 bits in total.
621 The desktop video mode is the video mode used by the desktop, not the current video mode (which may
622 differ from the desktop video mode if the GLFW window is a fullscreen window).
623 "
633 "Description
634 The function is used for polling for events, such as user input and window resize events. Upon calling
635 this function, all window states, keyboard states and mouse states are updated. If any related callback
636 functions are registered, these are called during the call to glfwPollEvents.
638 Notes
639 glfwPollEvents is called implicitly from glfwSwapBuffers if GLFW_AUTO_POLL_EVENTS is
640 enabled (default). Thus, if glfwSwapBuffers is called frequently, which is normally the case, there is
641 no need to call glfwPollEvents.
645 "Description
646 The function is used for waiting for events, such as user input and window resize events. Upon calling
647 this function, the calling thread will be put to sleep until any event appears in the event queue. When
648 events are ready, the events will be processed just as they are processed by glfwPollEvents.
649 If there are any events in the queue when the function is called, the function will behave exactly like
650 glfwPollEvents (i.e. process all messages and then return, without blocking the calling thread).
652 Notes
653 It is guaranteed that glfwWaitEvents will wake up on any event that can be processed by
654 glfwPollEvents. However, glfwWaitEvents may wake up on events that are not processed or reported
655 by glfwPollEvents too, and the function may behave differently on different systems. Do no make any
656 assumptions about when or why glfwWaitEvents will return.
660 "Parameters
661 key
662 A keyboard key identifier, which can be either an uppercase printable ISO 8859-1 (Latin 1)
663 character (e.g. 'A', '3' or '.'), or a special key identifier. Table 3.3 lists valid special key
664 identifiers.
665 Return values
666 The function returns GLFW_PRESS if the key is held down, or GLFW_RELEASE if the key is not
667 held down.
669 Description
670 The function queries the current state of a specific keyboard key. The physical location of each key
671 depends on the system keyboard layout setting.
673 Notes
674 The constant GLFW_KEY_SPACE is equal to 32, which is the ISO 8859-1 code for space.
675 Not all key codes are supported on all systems. Also, while some keys are available on some keyboard
676 layouts, they may not be available on other keyboard layouts.
677 For systems that do not distinguish between left and right versions of modifier keys (shift, alt and
678 control), the left version is used (e.g. GLFW_KEY_LSHIFT).
679 A window must be opened for the function to have any effect, and glfwPollEvents, glfwWaitEvents or
680 glfwSwapBuffers must be called before any keyboard events are recorded and reported by
681 glfwGetKey.
685 "Parameters
686 button
687 A mouse button identifier, which can be one of the mouse button identifiers listed in table 3.4.
688 Return values
689 The function returns GLFW_PRESS if the mouse button is held down, or GLFW_RELEASE if the
690 mouse button is not held down.
691 Description
692 The function queries the current state of a specific mouse button.
693 Notes
694 A window must be opened for the function to have any effect, and glfwPollEvents, glfwWaitEvents or
695 glfwSwapBuffers must be called before any mouse button events are recorded and reported by
696 glfwGetMouseButton.
697 GLFW_MOUSE_BUTTON_LEFT is equal to GLFW_MOUSE_BUTTON_1.
698 GLFW_MOUSE_BUTTON_RIGHT is equal to GLFW_MOUSE_BUTTON_2.
699 GLFW_MOUSE_BUTTON_MIDDLE is equal to GLFW_MOUSE_BUTTON_3.
704 "Return values
705 The function returns the current mouse position in xpos and ypos.
707 Description
708 The function returns the current mouse position. If the cursor is not hidden, the mouse position is the
709 cursor position, relative to the upper left corner of the window and limited to the client area of the
710 window. If the cursor is hidden, the mouse position is a virtual absolute position, not limited to any
711 boundaries except to those implied by the maximum number that can be represented by a signed integer
712 (normally -2147483648 to +2147483647).
714 Notes
715 A window must be opened for the function to have any effect, and glfwPollEvents, glfwWaitEvents or
716 glfwSwapBuffers must be called before any mouse movements are recorded and reported by
717 glfwGetMousePos.
722 "Parameters
723 xpos
724 Horizontal position of the mouse.
725 ypos
726 Vertical position of the mouse.
728 Description
729 The function changes the position of the mouse. If the cursor is visible (not disabled), the cursor will be
730 moved to the specified position, relative to the upper left corner of the window client area. If the cursor
731 is hidden (disabled), only the mouse position that is reported by GLFW is changed.
735 "Return values
736 The function returns the current mouse wheel position.
737 Description
738 The function returns the current mouse wheel position. The mouse wheel can be thought of as a third
739 mouse axis, which is available as a separate wheel or up/down stick on some mice.
740 Notes
741 A window must be opened for the function to have any effect, and glfwPollEvents, glfwWaitEvents or
742 glfwSwapBuffers must be called before any mouse wheel movements are recorded and reported by
743 glfwGetMouseWheel.
747 "Parameters
748 pos
749 Position of the mouse wheel.
750 Description
751 The function changes the position of the mouse wheel.
756 "Parameters
757 cbfun
758 Pointer to a callback function that will be called every time a key is pressed or released. The
759 function should have the following C language prototype:
760 void GLFWCALL functionname( int key, int action );
761 Where functionname is the name of the callback function, key is a key identifier, which is an
762 uppercase printable ISO 8859-1 character or a special key identifier (see table 3.3), and action is
763 either GLFW_PRESS or GLFW_RELEASE.
764 If cbfun is NULL, any previously selected callback function will be deselected.
765 Return values
766 none
767 Description
768 The function selects which function to be called upon a keyboard key event. The callback function is
769 called every time the state of a single key is changed (from released to pressed or vice versa). The
770 reported keys are unaffected by any modifiers (such as shift or alt).
771 A window has to be opened for this function to have any effect.
772 Notes
773 Keyboard events are recorded continuously, but only reported when glfwPollEvents, glfwWaitEvents
774 or glfwSwapBuffers is called.
777 "Parameters
778 cbfun
779 Pointer to a callback function that will be called every time a printable character is generated by
780 the keyboard. The function should have the following C language prototype:
781 void GLFWCALL functionname( int character, int action );
782 Where functionname is the name of the callback function, character is a Unicode (ISO 10646)
783 character, and action is either GLFW_PRESS or GLFW_RELEASE.
784 If cbfun is NULL, any previously selected callback function will be deselected.
785 Return values
786 none
787 Description
788 The function selects which function to be called upon a keyboard character event. The callback function
789 is called every time a key that results in a printable Unicode character is pressed or released. Characters
790 are affected by modifiers (such as shift or alt).
791 A window has to be opened for this function to have any effect.
792 Notes
793 Character events are recorded continuously, but only reported when glfwPollEvents, glfwWaitEvents
794 or glfwSwapBuffers is called.
795 Control characters, such as tab and carriage return, are not reported to the character callback function,
796 since they are not part of the Unicode character set. Use the key callback function for such events (see
797 glfwSetKeyCallback).
798 The Unicode character set supports character codes above 255, so never cast a Unicode character to an
799 eight bit data type (e.g. the C language ’char’ type) without first checking that the character code is less
800 than 256. Also note that Unicode character codes 0 to 255 are equal to ISO 8859-1 (Latin 1).
803 "Parameters
804 cbfun
805 Pointer to a callback function that will be called every time a mouse button is pressed or released.
806 The function should have the following C language prototype:
807 void GLFWCALL functionname( int button, int action );
808 Where functionname is the name of the callback function, button is a mouse button identifier (see
809 table 3.4 on page 56), and action is either GLFW_PRESS or GLFW_RELEASE.
810 If cbfun is NULL, any previously selected callback function will be deselected.
811 Return values
812 none
813 Description
814 The function selects which function to be called upon a mouse button event.
815 A window has to be opened for this function to have any effect.
816 Notes
817 Mouse button events are recorded continuously, but only reported when glfwPollEvents,
818 glfwWaitEvents or glfwSwapBuffers is called.
819 GLFW_MOUSE_BUTTON_LEFT is equal to GLFW_MOUSE_BUTTON_1.
820 GLFW_MOUSE_BUTTON_RIGHT is equal to GLFW_MOUSE_BUTTON_2.
821 GLFW_MOUSE_BUTTON_MIDDLE is equal to GLFW_MOUSE_BUTTON_3.
824 "Parameters
825 cbfun
826 Pointer to a callback function that will be called every time the mouse is moved. The function
827 should have the following C language prototype:
828 void GLFWCALL functionname( int x, int y );
829 Where functionname is the name of the callback function, and x and y are the mouse coordinates
830 (see glfwGetMousePos for more information on mouse coordinates).
831 If cbfun is NULL, any previously selected callback function will be deselected.
832 Return values
833 none
834 Description
835 The function selects which function to be called upon a mouse motion event.
836 A window has to be opened for this function to have any effect.
837 Notes
838 Mouse motion events are recorded continuously, but only reported when glfwPollEvents,
839 glfwWaitEvents or glfwSwapBuffers is called.
842 "Parameters
843 cbfun
844 Pointer to a callback function that will be called every time the mouse wheel is moved. The
845 function should have the following C language prototype:
846 void GLFWCALL functionname( int pos );
847 Where functionname is the name of the callback function, and pos is the mouse wheel position.
848 If cbfun is NULL, any previously selected callback function will be deselected.
849 Return values
850 none
851 Description
852 The function selects which function to be called upon a mouse wheel event.
853 A window has to be opened for this function to have any effect.
854 Notes
855 Mouse wheel events are recorded continuously, but only reported when glfwPollEvents,
856 glfwWaitEvents or glfwSwapBuffers is called.
860 "Parameters
861 joy
862 A joystick identifier, which should be GLFW_JOYSTICK_n, where n is in the range 1 to 16.
863 param
864 A token selecting which parameter the function should return (see table 3.5).
865 Return values
866 The function returns different parameters depending on the value of param. Table 3.5 lists valid param
867 values, and their corresponding return values.
868 Description
869 The function is used for acquiring various properties of a joystick.
870 Notes
871 The joystick information is updated every time the function is called.
872 No window has to be opened for joystick information to be valid.
875 (defcfun ("glfwGetJoystickPos" %get-joystick-pos) :int (joy :int) (pos :pointer) (numaxes :int))
878 "Parameters
879 joy
880 A joystick identifier, which should be GLFW_JOYSTICK_n, where n is in the range 1 to 16.
881 numaxes
882 Specifies how many axes should be returned.
883 Return values
884 An list that will hold the positional values for all requested axes.
885 If the joystick is not supported or connected, the function will
886 return nil.
888 Description
889 The function queries the current position of one or more axes of a joystick. The positional values are
890 returned in an array, where the first element represents the first axis of the joystick (normally the X
891 axis). Each position is in the range -1.0 to 1.0. Where applicable, the positive direction of an axis is
892 right, forward or up, and the negative direction is left, back or down.
893 If numaxes exceeds the number of axes supported by the joystick, or if the joystick is not available, the
894 unused elements in the pos array will be set to 0.0 (zero).
896 Notes
897 The joystick state is updated every time the function is called, so there is no need to call glfwPollEvents
898 or glfwWaitEvents for joystick state to be updated.
899 Use glfwGetJoystickParam to retrieve joystick capabilities, such as joystick availability and number of
900 supported axes.
901 No window has to be opened for joystick input to be valid.
902 "
908 (defcfun ("glfwGetJoystickButtons" %get-joystick-buttons) :int (joy :int) (buttons :pointer) (numbuttons :int))
910 "Parameters
911 joy
912 A joystick identifier, which should be GLFW_JOYSTICK_n, where n is in the range 1 to 16.
913 numbuttons
914 Specifies how many buttons should be returned.
915 Return values
916 A list that will hold the button states for all requested buttons.
917 The function returns the number of actually returned buttons. This is the minimum of numbuttons and
918 the number of buttons supported by the joystick. If the joystick is not supported or connected, the
919 function will return 0 (zero).
921 Description
922 The function queries the current state of one or more buttons of a joystick. The button states are
923 returned in an array, where the first element represents the first button of the joystick. Each state can be
924 either GLFW_PRESS or GLFW_RELEASE.
925 If numbuttons exceeds the number of buttons supported by the joystick, or if the joystick is not
926 available, the unused elements in the buttons array will be set to GLFW_RELEASE.
928 Notes
929 The joystick state is updated every time the function is called, so there is no need to call glfwPollEvents
930 or glfwWaitEvents for joystick state to be updated.
931 Use glfwGetJoystickParam to retrieve joystick capabilities, such as joystick availability and number of
932 supported buttons.
933 No window has to be opened for joystick input to be valid.
934 "
941 "Return values
942 The function returns the value of the high precision timer. The time is measured in seconds, and is
943 returned as a double precision floating point value.
945 Description
946 The function returns the state of a high precision timer. Unless the timer has been set by the
947 glfwSetTime function, the time is measured as the number of seconds that have passed since glfwInit
948 was called.
950 Notes
951 The resolution of the timer depends on which system the program is running on. The worst case
952 resolution is somewhere in the order of 10 ms, while for most systems the resolution should be better
953 than 1 μs.
957 "Parameters
958 time
959 Time (in seconds) that the timer should be set to.
961 Description
962 The function sets the current time of the high precision timer to the specified time. Subsequent calls to
963 glfwGetTime will be relative to this time. The time is given in seconds.
967 "Parameters
968 time
969 Time, in seconds, to sleep.
971 Description
972 The function puts the calling thread to sleep for the requested period of time. Only the calling thread is
973 put to sleep. Other threads within the same process can still execute.
975 Notes
976 There is usually a system dependent minimum time for which it is possible to sleep. This time is
977 generally in the range 1 ms to 20 ms, depending on thread sheduling time slot intervals etc. Using a
978 shorter time as a parameter to glfwSleep can give one of two results: either the thread will sleep for the
979 minimum possible sleep time, or the thread will not sleep at all (glfwSleep returns immediately). The
991 "Parameters
992 name
993 A null terminated ISO 8859-1 string holding the name of the file that should be read.
994 img
995 Pointer to a GLFWimage struct, which will hold the information about the loaded image (if the
996 read was successful).
997 flags
998 Flags for controlling the image reading process. Valid flags are listed in table 3.6
999 Return values
1000 The function returns t if the image was loaded successfully. Otherwise nil is
1001 returned.
1002 Description
1003 The function reads an image from the file specified by the parameter name and returns the image
1004 information and data in a GLFWimage structure, which has the following definition:
1005 § ¤
1006 typedef struct {
1007 int Width, Height; // Image dimensions
1008 int Format; // OpenGL pixel format
1009 int BytesPerPixel; // Number of bytes per pixel
1010 unsigned char *Data; // Pointer to pixel data
1011 } GLFWimage;
1012 ¦ ¥
1013 Width and Height give the dimensions of the image. Format specifies an OpenGL™ pixel format,
1014 which can be GL_LUMINANCE or GL_ALPHA (for gray scale images), GL_RGB or GL_RGBA.
1015 BytesPerPixel specifies the number of bytes per pixel. Data is a pointer to the actual pixel data.
1016 By default the read image is rescaled to the nearest larger 2m × 2n resolution using bilinear
1017 interpolation, if necessary, which is useful if the image is to be used as an OpenGL™ texture. This
1018 behavior can be disabled by setting the GLFW_NO_RESCALE_BIT flag.
1019 Unless the flag GLFW_ORIGIN_UL_BIT is set, the first pixel in img->Data is the lower left corner of
1020 the image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left corner.
1021 For single component images (i.e. gray scale), Format is set to GL_ALPHA if the flag
1022 GLFW_ALPHA_MAP_BIT flag is set, otherwise Format is set to GL_LUMINANCE.
1023 Notes
1024 glfwReadImage supports the Truevision Targa version 1 file format (.TGA). Supported pixel formats
1025 are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color + alpha.
1026 Paletted images are translated into true color or true color + alpha pixel formats.
1027 Please note that OpenGL™ 1.0 does not support single component alpha maps, so do not use images
1028 with Format = GL_ALPHA directly as textures under OpenGL™ 1.0.
1033 "Parameters
1034 data
1035 The memory buffer holding the contents of the file that should be read.
1036 size
1037 The size, in bytes, of the memory buffer.
1038 img
1039 Pointer to a GLFWimage struct, which will hold the information about the loaded image (if the
1040 read was successful).
1041 flags
1042 Flags for controlling the image reading process. Valid flags are listed in table 3.6
1043 Return values
1044 The function returns t if the image was loaded successfully. Otherwise nil is
1045 returned.
1046 Description
1047 The function reads an image from the memory buffer specified by the parameter data and returns the
1048 image information and data in a GLFWimage structure, which has the following definition:
1049 § ¤
1050 typedef struct {
1051 int Width, Height; // Image dimensions
1052 int Format; // OpenGL pixel format
1053 int BytesPerPixel; // Number of bytes per pixel
1054 unsigned char *Data; // Pointer to pixel data
1055 } GLFWimage;
1056 ¦ ¥
1057 Width and Height give the dimensions of the image. Format specifies an OpenGL™ pixel format,
1058 which can be GL_LUMINANCE or GL_ALPHA (for gray scale images), GL_RGB or GL_RGBA.
1059 BytesPerPixel specifies the number of bytes per pixel. Data is a pointer to the actual pixel data.
1060 By default the read image is rescaled to the nearest larger 2m × 2n resolution using bilinear
1061 interpolation, if necessary, which is useful if the image is to be used as an OpenGL™ texture. This
1062 behavior can be disabled by setting the GLFW_NO_RESCALE_BIT flag.
1063 Unless the flag GLFW_ORIGIN_UL_BIT is set, the first pixel in img->Data is the lower left corner of
1064 the image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left corner.
1065 For single component images (i.e. gray scale), Format is set to GL_ALPHA if the flag
1066 GLFW_ALPHA_MAP_BIT flag is set, otherwise Format is set to GL_LUMINANCE.
1067 Notes
1068 glfwReadMemoryImage supports the Truevision Targa version 1 file format (.TGA). Supported pixel
1069 formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color +
1070 alpha.
1071 Paletted images are translated into true color or true color + alpha pixel formats.
1072 Please note that OpenGL™ 1.0 does not support single component alpha maps, so do not use images
1073 with Format = GL_ALPHA directly as textures under OpenGL™ 1.0.
1077 "Parameters
1078 img
1079 Pointer to a GLFWimage struct.
1080 Description
1081 The function frees any memory occupied by a loaded image, and clears all the fields of the GLFWimage
1082 struct. Any image that has been loaded by the glfwReadImage function should be deallocated using
1086 "Parameters
1087 name
1088 An ISO 8859-1 string holding the name of the file that should be loaded.
1089 flags
1090 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1091 Return values
1092 The function returns t if the texture was loaded successfully. Otherwise nil is
1093 returned.
1095 Description
1096 The function reads an image from the file specified by the parameter name and uploads the image to
1097 OpenGL™ texture memory (using the glTexImage2D function).
1098 If the GLFW_BUILD_MIPMAPS_BIT flag is set, all mipmap levels for the loaded texture are
1099 generated and uploaded to texture memory.
1100 Unless the flag GLFW_ORIGIN_UL_BIT is set, the origin of the texture is the lower left corner of the
1101 loaded image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left
1102 corner.
1103 For single component images (i.e. gray scale), the texture is uploaded as an alpha mask if the flag
1104 GLFW_ALPHA_MAP_BIT flag is set, otherwise it is uploaded as a luminance texture.
1106 Notes
1107 glfwLoadTexture2D supports the Truevision Targa version 1 file format (.TGA). Supported pixel
1108 formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color +
1109 alpha.
1110 Paletted images are translated into true color or true color + alpha pixel formats.
1111 The read texture is always rescaled to the nearest larger 2m × 2n resolution using bilinear interpolation,
1112 if necessary, since OpenGL™ requires textures to have a 2m × 2n resolution.
1113 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1114 the OpenGL™ implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1115 generated by GLFW in software.
1116 Since OpenGL™ 1.0 does not support single component alpha maps, alpha map textures are converted
1117 to RGBA format under OpenGL™ 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1118 texture is a single component texture. The red, green and blue components are set to 1.0.
1123 "Parameters
1124 data
1125 The memory buffer holding the contents of the file that should be loaded.
1126 size
1127 The size, in bytes, of the memory buffer.
1128 flags
1129 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1130 Return values
1131 The function returns t if the texture was loaded successfully. Otherwise nil is
1132 returned.
1134 Description
1135 The function reads an image from the memory buffer specified by the parameter data and uploads the
1136 image to OpenGL™ texture memory (using the glTexImage2D function).
1137 If the GLFW_BUILD_MIPMAPS_BIT flag is set, all mipmap levels for the loaded texture are
1138 generated and uploaded to texture memory.
1139 Unless the flag GLFW_ORIGIN_UL_BIT is set, the origin of the texture is the lower left corner of the
1140 loaded image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left
1141 corner.
1142 For single component images (i.e. gray scale), the texture is uploaded as an alpha mask if the flag
1143 GLFW_ALPHA_MAP_BIT flag is set, otherwise it is uploaded as a luminance texture.
1145 Notes
1146 glfwLoadMemoryTexture2D supports the Truevision Targa version 1 file format (.TGA). Supported
1147 pixel formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color
1148 + alpha.
1149 Paletted images are translated into true color or true color + alpha pixel formats.
1150 The read texture is always rescaled to the nearest larger 2m × 2n resolution using bilinear interpolation,
1151 if necessary, since OpenGL™ requires textures to have a 2m × 2n resolution.
1152 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1153 the OpenGL™ implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1154 generated by GLFW in software.
1155 Since OpenGL™ 1.0 does not support single component alpha maps, alpha map textures are converted
1156 to RGBA format under OpenGL™ 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1157 texture is a single component texture. The red, green and blue components are set to 1.0.
1163 "Parameters
1164 img
1165 Pointer to a GLFWimage struct holding the information about the image to be loaded.
1166 flags
1167 Flags for controlling the texture loading process. Valid flags are listed in table 3.7.
1168 Return values
1169 The function returns t if the texture was loaded successfully. Otherwise nil is
1170 returned.
1172 Description
1173 The function uploads the image specified by the parameter img to OpenGL™ texture memory (using
1174 the glTexImage2D function).
1175 If the GLFW_BUILD_MIPMAPS_BIT flag is set, all mipmap levels for the loaded texture are
1176 generated and uploaded to texture memory.
1177 Unless the flag GLFW_ORIGIN_UL_BIT is set, the origin of the texture is the lower left corner of the
1178 loaded image. If the flag GLFW_ORIGIN_UL_BIT is set, however, the first pixel is the upper left
1179 corner.
1180 For single component images (i.e. gray scale), the texture is uploaded as an alpha mask if the flag
1181 GLFW_ALPHA_MAP_BIT flag is set, otherwise it is uploaded as a luminance texture.
1183 Notes
1184 glfwLoadTextureImage2D supports the Truevision Targa version 1 file format (.TGA). Supported
1185 pixel formats are: 8-bit gray scale, 8-bit paletted (24/32-bit color), 24-bit true color and 32-bit true color
1186 + alpha.
1187 Paletted images are translated into true color or true color + alpha pixel formats.
1188 The read texture is always rescaled to the nearest larger 2m × 2n resolution using bilinear interpolation,
1189 if necessary, since OpenGL™ requires textures to have a 2m × 2n resolution.
1190 If the GL_SGIS_generate_mipmap extension, which is usually hardware accelerated, is supported by
1191 the OpenGL™ implementation it will be used for mipmap generation. Otherwise the mipmaps will be
1192 generated by GLFW in software.
1193 Since OpenGL™ 1.0 does not support single component alpha maps, alpha map textures are converted
1194 to RGBA format under OpenGL™ 1.0 when the GLFW_ALPHA_MAP_BIT flag is set and the loaded
1199 "Parameters
1200 extension
1201 A null terminated ISO 8859-1 string containing the name of an OpenGL™ extension.
1202 Return values
1203 The function returns t if the extension is supported. Otherwise it returns nil.
1204 Description
1205 The function does a string search in the list of supported OpenGL™ extensions to find if the specified
1206 extension is listed.
1207 Notes
1208 An OpenGL™ context must be created before this function can be called (i.e. an OpenGL™ window
1209 must have been opened with glfwOpenWindow).
1210 In addition to checking for OpenGL™ extensions, GLFW also checks for extensions in the operating
1211 system “glue API”, such as WGL extensions under Windows and glX extensions under the X Window
1212 System.
1216 "Parameters
1217 procname
1218 A null terminated ISO 8859-1 string containing the name of an OpenGL™ extension function.
1219 Return values
1220 The function returns the pointer to the specified OpenGL™ function if it is supported, otherwise
1221 NULL is returned.
1222 Description
1223 The function acquires the pointer to an OpenGL™ extension function. Some (but not all) OpenGL™
1224 extensions define new API functions, which are usually not available through normal linking. It is
1225 therefore necessary to get access to those API functions at runtime.
1226 Notes
1227 An OpenGL™ context must be created before this function can be called (i.e. an OpenGL™ window
1228 must have been opened with glfwOpenWindow).
1229 Some systems do not support dynamic function pointer retrieval, in which case glfwGetProcAddress
1230 will always return NULL.
1236 "Return values
1237 The function returns the major and minor version numbers and the revision for the currently used
1238 OpenGL™ implementation as a list (major minor rev).
1240 Description
1241 The function returns the OpenGL™ implementation version. This is a convenient function that parses
1242 the version number information from the string returned by calling
1243 glGetString( GL_VERSION ). The OpenGL™ version information can be used to determine
1244 what functionality is supported by the used OpenGL™ implementation.
1246 Notes
1247 An OpenGL™ context must be created before this function can be called (i.e. an OpenGL™ window
1256 "Parameters
1257 fun
1258 A pointer to a function that acts as the entry point for the new thread. The function should have
1259 the following C language prototype:
1260 void GLFWCALL functionname( void *arg );
1261 Where functionname is the name of the thread function, and arg is the user supplied argument
1262 (see below).
1263 arg
1264 An arbitrary argument for the thread. arg will be passed as the argument to the thread function
1265 pointed to by fun. For instance, arg can point to data that is to be processed by the thread.
1266 Return values
1267 The function returns a thread identification number if the thread was created successfully. This number
1268 is always positive. If the function fails, a negative number is returned.
1269 Description
1270 The function creates a new thread, which executes within the same address space as the calling process.
1271 The thread entry point is specified with the fun argument.
1272 Once the thread function fun returns, the thread dies.
1273 Notes
1274 Even if the function returns a positive thread ID, indicating that the thread was created successfully, the
1275 thread may be unable to execute, for instance if the thread start address is not a valid thread entry point.
1278 "Parameters
1279 ID
1280 A thread identification handle, which is returned by glfwCreateThread or glfwGetThreadID.
1281 Description
1282 The function kills a running thread and removes it from the thread list.
1283 Notes
1284 This function is a very dangerous operation, which may interrupt a thread in the middle of an important
1285 operation, and its use is discouraged. You should always try to end a thread in a graceful way using
1286 thread communication, and use glfwWaitThread in order to wait for the thread to die.
1289 "Parameters
1290 ID
1291 A thread identification handle, which is returned by glfwCreateThread or glfwGetThreadID.
1292 waitmode
1293 Can be either GLFW_WAIT or GLFW_NOWAIT.
1294 Return values
1295 The function returns t if the specified thread died after the function was called, or the thread
1296 did not exist, in which case glfwWaitThread will return immediately regardless of waitmode. The
1297 function returns nil if waitmode is GLFW_NOWAIT, and the specified thread exists and is still
1298 running.
1301 "Return values
1302 The function returns a thread identification handle for the calling thread.
1303 Description
1304 The function determines the thread ID for the calling thread. The ID is the same value as was returned
1305 by glfwCreateThread when the thread was created.
1309 "Return values
1310 The function returns a mutex handle, or NULL if the mutex could not be created.
1311 Description
1312 The function creates a mutex object, which can be used to control access to data that is shared between
1313 threads.
1316 "Parameters
1317 mutex
1318 A mutex object handle.
1319 Description
1320 The function destroys a mutex object. After a mutex object has been destroyed, it may no longer be
1321 used by any thread.
1324 "Parameters
1325 mutex
1326 A mutex object handle.
1327 Description
1328 The function will acquire a lock on the selected mutex object. If the mutex is already locked by another
1329 thread, the function will block the calling thread until it is released by the locking thread. Once the
1330 function returns, the calling thread has an exclusive lock on the mutex. To release the mutex, call
1331 glfwUnlockMutex.
1334 "Parameters
1335 mutex
1336 A mutex object handle.
1337 Description
1338 The function releases the lock of a locked mutex object.
1342 "Parameters
1343 mutex
1344 A mutex object handle.
1345 forms
1346 Body of code to execute
1347 Description
1348 This macro will acquire a lock on the selected mutex object using glfwLockMutex and release it afterwards
1349 using glfwUnlockMutex.
1350 So, forms will not execute until an exclusive lock is held.
1351 The lock is then released when the stack is unwound."
1359 "Return values
1360 The function returns a condition variable handle, or NULL if the condition variable could not be
1361 created.
1362 Description
1363 The function creates a condition variable object, which can be used to synchronize threads.
1366 "Parameters
1367 cond
1368 A condition variable object handle.
1369 Description
1370 The function destroys a condition variable object. After a condition variable object has been destroyed,
1371 it may no longer be used by any thread.
1374 " arameters
1375 cond
1376 A condition variable object handle.
1377 mutex
1378 A mutex object handle.
1379 timeout
1380 Maximum time to wait for the condition variable. The parameter can either be a positive time (in
1381 seconds), or GLFW_INFINITY.
1382 Description
1383 The function atomically unlocks the mutex specified by mutex, and waits for the condition variable cond
1384 to be signaled. The thread execution is suspended and does not consume any CPU time until the
1385 condition variable is signaled or the amount of time specified by timeout has passed. If timeout is
1386 GLFW_INFINITY, glfwWaitCond will wait forever for cond to be signaled. Before returning to the
1387 calling thread, glfwWaitCond automatically re-acquires the mutex.
1388 Notes
1389 The mutex specified by mutex must be locked by the calling thread before entrance to glfwWaitCond.
1390 A condition variable must always be associated with a mutex, to avoid the race condition where a thread
1391 prepares to wait on a condition variable and another thread signals the condition just before the first
1392 thread actually waits on it.
1395 "Parameters
1396 cond
1397 A condition variable object handle.
1398 Description
1399 The function restarts one of the threads that are waiting on the condition variable cond. If no threads are
1400 waiting on cond, nothing happens. If several threads are waiting on cond, exactly one is restarted, but it
1401 is not specified which.
1402 Notes
1403 When several threads are waiting for the condition variable, which thread is started depends on
1404 operating system scheduling rules, and may vary from system to system and from time to time.
1407 "Parameters
1408 cond
1409 A condition variable object handle.
1410 Description
1411 The function restarts all the threads that are waiting on the condition variable cond. If no threads are
1412 waiting on cond, nothing happens.
1413 Notes
1414 When several threads are waiting for the condition variable, the order in which threads are started
1415 depends on operating system scheduling rules, and may vary from system to system and from time to
1416 time.
1420 "Return values
1421 The function returns the number of active processors in the system.
1422 Description
1423 The function determines the number of active processors in the system.
1424 Notes
1425 Systems with several logical processors per physical processor, also known as SMT (Symmetric Multi
1426 Threading) processors, will report the number of logical processors.
1429 "Parameters
1430 token
1431 A value specifying a feature to enable or disable. Valid tokens are listed in table 3.8.
1432 Return values
1433 none
1434 Description
1435 glfwEnable is used to enable a certain feature, while glfwDisable is used to disable it. Below follows a
1436 description of each feature.
1437 GLFW_AUTO_POLL_EVENTS
1438 When GLFW_AUTO_POLL_EVENTS is enabled, glfwPollEvents is automatically called each time
1439 that glfwSwapBuffers is called.
1440 When GLFW_AUTO_POLL_EVENTS is disabled, calling glfwSwapBuffers will not result in a call to
1441 glfwPollEvents. This can be useful if glfwSwapBuffers needs to be called from within a callback
1442 function, since calling glfwPollEvents from a callback function is not allowed.
1443 GLFW_KEY_REPEAT
1444 When GLFW_KEY_REPEAT is enabled, the key and character callback functions are called repeatedly
1445 when a key is held down long enough (according to the system key repeat configuration).
1446 When GLFW_KEY_REPEAT is disabled, the key and character callback functions are only called once
1447 when a key is pressed (and once when it is released).
1448 GLFW_MOUSE_CURSOR
1449 When GLFW_MOUSE_CURSOR is enabled, the mouse cursor is visible, and mouse coordinates are
1450 relative to the upper left corner of the client area of the GLFW window. The coordinates are limited to
1451 the client area of the window.
1452 When GLFW_MOUSE_CURSOR is disabled, the mouse cursor is invisible, and mouse coordinates are
1453 not limited to the drawing area of the window. It is as if the mouse coordinates are recieved directly
1454 from the mouse, without being restricted or manipulated by the windowing system.
1455 GLFW_STICKY_KEYS
1456 When GLFW_STICKY_KEYS is enabled, keys which are pressed will not be released until they are
1457 physically released and checked with glfwGetKey. This behavior makes it possible to catch keys that
1458 were pressed and then released again between two calls to glfwPollEvents, glfwWaitEvents or
1459 glfwSwapBuffers, which would otherwise have been reported as released. Care should be taken when
1460 using this mode, since keys that are not checked with glfwGetKey will never be released. Note also that
1461 enabling GLFW_STICKY_KEYS does not affect the behavior of the keyboard callback functionality.
1462 When GLFW_STICKY_KEYS is disabled, the status of a key that is reported by glfwGetKey is always
1463 the physical state of the key. Disabling GLFW_STICKY_KEYS also clears the sticky information for
1464 all keys.
1465 GLFW_STICKY_MOUSE_BUTTONS
1466 When GLFW_STICKY_MOUSE_BUTTONS is enabled, mouse buttons that are pressed will not be
1467 released until they are physically released and checked with glfwGetMouseButton. This behavior
1468 makes it possible to catch mouse buttons which were pressed and then released again between two calls
1469 to glfwPollEvents, glfwWaitEvents or glfwSwapBuffers, which would otherwise have been reported
1470 as released. Care should be taken when using this mode, since mouse buttons that are not checked with
1471 glfwGetMouseButton will never be released. Note also that enabling
1472 GLFW_STICKY_MOUSE_BUTTONS does not affect the behavior of the mouse button callback
1473 functionality.
1474 When GLFW_STICKY_MOUSE_BUTTONS is disabled, the status of a mouse button that is reported
1475 by glfwGetMouseButton is always the physical state of the mouse button. Disabling
1476 GLFW_STICKY_MOUSE_BUTTONS also clears the sticky information for all mouse buttons.
1477 GLFW_SYSTEM_KEYS
1478 When GLFW_SYSTEM_KEYS is enabled, pressing standard system key combinations, such as
1479 ALT+TAB under Windows, will give the normal behavior. Note that when ALT+TAB is issued under
1480 Windows in this mode so that the GLFW application is deselected when GLFW is operating in
1481 fullscreen mode, the GLFW application window will be minimized and the video mode will be set to
1482 the original desktop mode. When the GLFW application is re-selected, the video mode will be set to
1483 the GLFW video mode again.
1484 When GLFW_SYSTEM_KEYS is disabled, pressing standard system key combinations will have no
1485 effect, since those key combinations are blocked by GLFW. This mode can be useful in situations when
1486 the GLFW program must not be interrupted (normally for games in fullscreen mode).
1489 "Parameters
1490 token
1491 A value specifying a feature to enable or disable. Valid tokens are listed in table 3.8.
1492 Return values
1493 none
1494 Description
1495 glfwEnable is used to enable a certain feature, while glfwDisable is used to disable it. Below follows a
1496 description of each feature.
1497 GLFW_AUTO_POLL_EVENTS
1498 When GLFW_AUTO_POLL_EVENTS is enabled, glfwPollEvents is automatically called each time
1499 that glfwSwapBuffers is called.
1500 When GLFW_AUTO_POLL_EVENTS is disabled, calling glfwSwapBuffers will not result in a call to
1501 glfwPollEvents. This can be useful if glfwSwapBuffers needs to be called from within a callback
1502 function, since calling glfwPollEvents from a callback function is not allowed.
1503 GLFW_KEY_REPEAT
1504 When GLFW_KEY_REPEAT is enabled, the key and character callback functions are called repeatedly
1505 when a key is held down long enough (according to the system key repeat configuration).
1506 When GLFW_KEY_REPEAT is disabled, the key and character callback functions are only called once
1507 when a key is pressed (and once when it is released).
1508 GLFW_MOUSE_CURSOR
1509 When GLFW_MOUSE_CURSOR is enabled, the mouse cursor is visible, and mouse coordinates are
1510 relative to the upper left corner of the client area of the GLFW window. The coordinates are limited to
1511 the client area of the window.
1512 When GLFW_MOUSE_CURSOR is disabled, the mouse cursor is invisible, and mouse coordinates are
1513 not limited to the drawing area of the window. It is as if the mouse coordinates are recieved directly
1514 from the mouse, without being restricted or manipulated by the windowing system.
1515 GLFW_STICKY_KEYS
1516 When GLFW_STICKY_KEYS is enabled, keys which are pressed will not be released until they are
1517 physically released and checked with glfwGetKey. This behavior makes it possible to catch keys that
1518 were pressed and then released again between two calls to glfwPollEvents, glfwWaitEvents or
1519 glfwSwapBuffers, which would otherwise have been reported as released. Care should be taken when
1520 using this mode, since keys that are not checked with glfwGetKey will never be released. Note also that
1521 enabling GLFW_STICKY_KEYS does not affect the behavior of the keyboard callback functionality.
1522 When GLFW_STICKY_KEYS is disabled, the status of a key that is reported by glfwGetKey is always
1523 the physical state of the key. Disabling GLFW_STICKY_KEYS also clears the sticky information for
1524 all keys.
1525 GLFW_STICKY_MOUSE_BUTTONS
1526 When GLFW_STICKY_MOUSE_BUTTONS is enabled, mouse buttons that are pressed will not be
1527 released until they are physically released and checked with glfwGetMouseButton. This behavior
1528 makes it possible to catch mouse buttons which were pressed and then released again between two calls
1529 to glfwPollEvents, glfwWaitEvents or glfwSwapBuffers, which would otherwise have been reported
1530 as released. Care should be taken when using this mode, since mouse buttons that are not checked with
1531 glfwGetMouseButton will never be released. Note also that enabling
1532 GLFW_STICKY_MOUSE_BUTTONS does not affect the behavior of the mouse button callback
1533 functionality.
1534 When GLFW_STICKY_MOUSE_BUTTONS is disabled, the status of a mouse button that is reported
1535 by glfwGetMouseButton is always the physical state of the mouse button. Disabling
1536 GLFW_STICKY_MOUSE_BUTTONS also clears the sticky information for all mouse buttons.
1537 GLFW_SYSTEM_KEYS
1538 When GLFW_SYSTEM_KEYS is enabled, pressing standard system key combinations, such as
1539 ALT+TAB under Windows, will give the normal behavior. Note that when ALT+TAB is issued under
1540 Windows in this mode so that the GLFW application is deselected when GLFW is operating in
1541 fullscreen mode, the GLFW application window will be minimized and the video mode will be set to
1542 the original desktop mode. When the GLFW application is re-selected, the video mode will be set to
1543 the GLFW video mode again.
1544 When GLFW_SYSTEM_KEYS is disabled, pressing standard system key combinations will have no
1545 effect, since those key combinations are blocked by GLFW. This mode can be useful in situations when
1546 the GLFW program must not be interrupted (normally for games in fullscreen mode).