Creates and returns a custom cursor object.

The resulting cursor object should be cleaned up with destroy-cursor.

The hotspot is the location in pixels of the point on the cursor which will be reported as its location, starting from the top left.

See set-cursor, set-window-icon.

Create a cursor object with a standard shape.

See standard-cursors, create-cursor.

Constructs a brand new window of the given size and with the given title.

If the window should be created as a fullscreen window, then pass a monitor object. The share parameter is another window object which the context will share resources with.

Returns an opaque window object.

See destroy-window.

Resets all the window creation init-hints to their default values.

Destroy a cursor object and release its related resources.

All remaining cursors are also destroyed on terminate.

See create-cursor.

Destroys the given window.

See create-window.

Checks if a given api extension is supported for the given context.

This can search both for context creation extensions and client extensions.

This function does not apply to Vulkan. If you are using Vulkan see get-required-instance-extensions, and use vkEnumerateInstanceExtensionProperties and vkEnumerateDeviceExtensionProperties instead.

Requests focus on the window, bringing it to the front.

The window should already be visible and not iconified.

Do not use this function to steal focus from other applications unless you are absolutely sure that is what the user wants. Prefer using attention requests.

See request-window-attention.

Gets the content of the system clipboard as a UTF-8 encoded string.

If the clipboard is empty or is not encoded as a valid UTF-8 string then nil is returned and a :glfw-clj.core/format-unavailable error is generated.

Gets the window whose context is bound to the current thread.

Gets the current cursor position as a vector of the x and y.

The coordinates are screen coordinates starting from the top left corner of the content area of the window.

If the cursor is disabled then the value is not connected to the window directly and is unbounded.

Gets the most recent error which has occurred on this thread.

If there is an error to fetch, it is returned as an ex-info with the message as the error description and the key :type in the ex-data with the error code’s human-readable name.

This function may be called before init.

Gets the size in pixels of the framebuffer for rendering to the window, as a vector.

Returns the human-readable name of the gamepad from the gamepad mapping assigned to the joystick jid.

If the joystick does not exist or does not have a gamepad mapping, returns nil.

Gets the state of the joystick jid remapped to an Xbox-like gamepad.

If the joystick does not exist, returns nil.

Returns a map with the keys :buttons and :axes.

:buttons is a set of currently pressed button names. The buttons are :a, :b :x, :y, :left-bumper, :right-bumper, :back, :start, :guide, :left-thumb, :right-thumb, :dpad-up, :dpad-right, :dpad-down, and :dpad-left.

The :guide button may not be available as it is often hooked by the system or by Steam.

:axes is a map from :left-stick and :right-stick to vectors of the x and y values of the axis, as doubles from -1.0 to 1.0, and from :left-trigger and :right-trigger to a number from 0 to 1.0.

Unavailable buttons and axes will report as not pressed and 0.0 respectively.

Gets the gamma ramp for the monitor.

The gamma ramp is a sequence of maps with the keys :red, :green, and :blue, all of which map to unsigned shorts.

Gets the value of the given input-mode for the window.

Values for :glfw-clj.core/cursor are :glfw-clj.core/normal, as well as hidden, and disabled keywords in the same ns.

Other modes are either true or false.

See input-modes.

Gets a vector of all the joystick axis values for the joystick jid.

All the returned values are floats from -1.0 to 1.0.

Gets a vector of all the buttons for the joystick jid.

All the returned values are :glfw-clj.core/press or :glfw-clj.core/release.

By default all hats are also included as sets of four buttons in the order up, right, down, left, and they are returned in the same order as get-joystick-hats.

These can be elided from this list if the init-hint :glfw-clj.core/joystick-hat-buttons is set to false.

Get the SDL-compatible GUID as a hex string of the joystick jid.

This GUID is what’s used to identify a joystick as a gamepad. Each GUID identifies a model of joystick, but not is not unique to a particular connected joystick (e.g. all wired Xbox 360 controllers will have the same GUID). These GUIDs may also be different between platforms.

Gets a vector of the state of all hats on the joystick jid.

The hats are sets of keywords representing the directions pressed.

See hats.

Get the name of the joystick jid.

If the joystick is not present, returns nil.

Gets the user appointer attached to the joystick jid.

This is used to fetch data attached to the joystick from inside the joystick callback without relying on global state.

See set-joystick-user-pointer.

Gets the most recent key event for the key in window.

Returns either :glfw-clj.core/press or :glfw-clj.core/release. To get the higher-level input :glfw-clj.core/repeat you must use the callback via set-key-callback.

Get the printable name of a key as a string.

This is generally the character the key will produce without any modifier keys, intended for displaying keybindings to a user.

If the key is nil or :glfw-clj.core/key-unknown, it is ignored and scancode is used, otherwise scancode is ignored.

For non-printable keys, returns nil.

Gets the scancode of the key.

If the key is unknown or nil, or the key doesn’t exist on the keyboard, returns nil.

Gets the x and y scale of the content in the monitor.

The content scale is the ratio between the current DPI and the platform default DPI.

Gets a human-readable, non-unique name for the monitor.

Gets the size of the monitor in millimeters.

Returns a vector of the width and height.

Gets the virtual screen coordinate of the upper left corner of the monitor.

Gets the user-defined pointer for the monitor.

Gets the upper left point and extents of the monitor’s work area.

This is returned as a vector of the x and y position of the upper left corner of the monitor, and the width and height of the work area.

The work area excludes things like a menubar or hotbar.

If there is no OS hotbar, the width and height are the resolution of the monitor in screen coordinates.

Gets a sequence of opaque monitor objects.

Gets the most recent button event for the mouse-button in window.

Returns either :glfw-clj.core/press or :glfw-clj.core/release

Gets an opaque handle to the current primary monitor.

Returns a pointer to the specified procedure.

The returned address is not guaranteed to be the same between contexts.

This function may return a non-nil value even for unsupported functions. Always check the version and extensions supported first.

This function does not apply if you are using Vulkan. If you are using Vulkan, see get-instance-proc-address, and use vkGetInstanceProcAddr and vkGetDeviceProcAddr instead.

The pointer is valid until the context is destroyed.

Gets the current time in seconds.

The returned time counts from the call to init by default, but can be altered with set-time.

This uses the highest-resolution monotonic time available on the current platform.

This function may be called from any thread.

Gets the frequency in Hz of the raw system timer.

Returns 0 if there was an error.

This function may be called from any thread.

See get-timer-value.

Gets the current raw timer value.

The raw timer value is an integral value which does not have a consistent mapping to a particular length of time. To convert this to a consistent time, divide it by the timer frequency.

This function may be called from any thread.

See get-timer-frequency.

Gets a vector of the major, minor, and revision version of GLFW.

This can be called on any thread, and before init.

Gets a string of the version of GLFW.

Don’t parse the string to get the version. Instead use get-version.

This can be called on any thread, and before init.

Get the current video mode set on the monitor.

See get-video-modes.

Get all video modes supported by the monitor.

Each video mode is a map with the keys :width, :height, :red-bits, :green-bits, :blue-bits, and :refresh-rate, all of which are integer values.

Gets the current value of attrib from the window.

Framebuffer related hints are not attributes.

Gets the current content scale for the given window.

The content scale is the ratio between the current DPI and the platform default DPI.

Gets the size of the window (including decorations).

Returns a vector of the pixel lengths of the left, top, right, and bottom edges of the window.

Gets an opaque representation of the monitor for the window.

Returns null if the window is not a fullscreen window.

Gets the opacity of the window, including any decorations.

Gets the current x and y position of the given window as a vector.

Gets the width and height of the content area of the given window as a vector.

Gets a user-defined pointer value associated with the window.

Hides the window if it was previously shown.

Minimizes the window if it was previously restored.

On a fullscreen window, returns the monitor to its original resolution until the window is restored.

Initializes GLFW.

Returns true if it initializes successfully. Automatically terminates GLFW if it fails. If it succeeds, then you should call terminate before application exit.

Sets the given hint with the boolean value.

The hint must be one of the values from init-hints.

Hints starting with :cocoa are MacOS-specific.

This must be called before init.

Returns if the joystick jid is present and has a gamepad mapping.

Returns if a joystick with the given jid is present.

All other functions that take a jid first check if it is present, so this need not be called before them.

Binds the context for the given window to the current thread.

Only one context can be bound on the thread at once. If nil is passed, any context already bound to this thread will be released.

Maximizes the window.

If the window was fullscreen, this function does nothing.

Process all events on all the windows.

This may call the callbacks which are set, however the callbacks may be called at other times depending on the platform.

On some platforms certain window events will block. The window-refresh callback should perform any rendering during these events.

Joystick input does not depend on event processing.

Post an empty event to the event queue, causing wait-events and wait-events-timeout to return.

Returns if raw mouse motion is supported by the current system.

This value will not change after init is called, so it needs only be called once.

Raw mouse motion is useful in situations where mouse input is used for something besides moving a cursor, and as such raw mouse motion is only provided when the cursor input mode is disabled.

Requests the attention of the user on the window.

Once the user has given the application attention, usually by focusing the window, the attention request ends.

Restores the window to its chosen resolution if it was previously maximized or iconified.

If the window was fullscreen, returns the monitor to its original resolution.

Sets the callback to be called when a character is input.

This is used for Unicode character input.

The callback is a function of the window and a string representing a single unicode character. It may or may not be representable in a char. The return value is ignored.

Returns the old callback if any was set.

Sets the callback to be called when a character is input, including key mods.

This is used for Unicode character input.

The callback is a function of the window and a string representing a single unicode character, plus a key mod set. The unicode character may or may not be representable in a char. The return value is ignored.

Returns the old callback if any was set.

Deprecated and will be removed in GLFW 4.0.

Sets the system clipboard to the specified, UTF-8 encoded string.

Sets the cursor image for the given window to the passed cursor object.

The cursor image will only be visible when the cursor mode is :glfw-clj.core/cursor-normal.

See create-cursor, create-standard-cursor.

Sets the callback to be called when the mouse enters the content area of the window.

The callback is a function of the window and a boolean, which will be true if the cursor is now in the window, and false if it is no longer in the window. The return value is ignored.

Returns the old callback if any was set.

Sets the position of the cursor relative to the window.

Do not use this function to implement things like camera controls. Instead set the cursor mode to disabled.

Sets the callback to be called when the mouse moves.

The callback is a function of the window and the new x and y position of the cursor. The return value is ignored.

The position is provided in screen coordinates relative to the upper left of the window.

Returns the old callback if any was set.

Sets the callback to be called when a file is dropped into the window.

The callback is a function of the window and a vector of file paths. The return value is ignored.

Returns the old callback if any was set.

Sets the global error callback for GLFW.

The callback is a function of an integer error code and a string description.

Returns the previous callback, or nil if there was none.

If scope is passed, the callback will be kept valid for the duration of that scope. If it is not, a mem/global-scope is used. If the callback is called by GLFW after the scope has been released, it will cause a JVM crash.

This function may be called before init.

Sets the window framebuffer size callback for the window.

The callback is a function of the window the event is from and two ints for the size of the framebuffer.

Returns the previous callback, or nil if there was none.

If scope is passed, the callback will be kept valid for the duration of that scope. If it is not, a mem/global-scope is used.

Generates an appropriately sized gamma ramp for the exponent and calls set-gamma-ramp with it.

Sets the gamma ramp for the monitor.

See get-gamma-ramp.

Sets the input-mode for the given window.

Mode values for :glfw-clj.core/cursor are :glfw-clj.core/normal, as well as hidden, and disabled keywords in the same ns.

Other modes take true or false.

See input-modes.

Sets the callback to be called when a joystick connection event occurs.

The callback is a function of the jid of the joystick and a keyword representing a connection event. The return value is ignored.

For joystick connection events to be processed, one of the event processing functions like poll-events must be called.

Returns the old callback if any was set.

See connection-events.

Set a user pointer attached to the joystick jid.

This is used to enable not depending on global state inside the joystick callback.

See get-joystick-user-pointer.

Sets the callback to be called when a key event occurs.

This should not be used for text input. Instead use set-char-callback.

The callback is a function of the window, a key name, scancode, key event, and active key mods at the time of the event. The return value is ignored.

When the window loses focus, artificial key release events are generated for all currently pressed keys. You can distinguish the difference between real events and these generated ones by the fact that the focus loss event will be processed before these release events.

Some keys will register with a key name of :glfw-clj.core/key-unknown. These are keys that GLFW has no name for and are identified by the scancode passed. They are platform and keyboard-specific, so should not be used across devices, and cannot be queried with get-key.

In some cases additional events will be generated by GLFW, which may have a scancode of 0.

Returns the old callback, if any was set.

Set a callback to be called whenever the monitor configuration changes.

The callback is a function of a monitor and one of :connected or :disconnected.

Sets a user-defined pointer for the monitor.

Useful when code needs to rely on the monitor but not on global state.

Sets the callback to be called when a mouse button is pressed.

The callback is a function of the window, the mouse button the event is connected with, and the event. The return value is ignored.

When focus is lost on the window, synthetic mouse button release events are sent for all currently-pressed buttons. These events will be handled after the focus event.

Returns the old callback if any was set.

Sets the callback to be called when the scroll wheel is rotated.

The callback is a function of the window and the x and y offsets that were scrolled since the last time events were processed. The return value is ignored.

Returns the old callback if any was set.

Set the current time to be counted from.

The number must be a positive, finite number less than 18446744073.0, which is approximately 584.5 years.

This limit is based on the largest number of nanoseconds that can be stored in a 64-bit integer, and may be increased in the future.

This function may be called from any thread, but is not atomic or synchronized in any way with calls to get-time, and so must be externally synchronized.

Sets a required aspect ratio of the content area of the window.

This has no effect on fullscreen windows.

The ratio must be rational?, with the numerator and denominator extracted before being passed to the 3-arity version of this function.

Sets the value of attrib for the window.

Can only set :decorated, :resizable, :floating, :auto-iconify, and :focus-on-show.

Sets the window close callback for the window.

The callback is a function of the window the event is from.

Returns the previous callback, or nil if there was none.

If scope is passed, the callback will be kept valid for the duration of that scope. If it is not, a mem/global-scope is used.

Sets the window content scale callback for the window.

The callback is a function of the window the event is from and two floats for the size of the framebuffer.

Returns the previous callback, or nil if there was none.

If scope is passed, the callback will be kept valid for the duration of that scope. If it is not, a mem/global-scope is used.

Sets the window focus callback for the window.

The callback is a function of the window the event is from and a boolean of if the window is focused.

Returns the previous callback, or nil if there was none.

If scope is passed, the callback will be kept valid for the duration of that scope. If it is not, a mem/global-scope is used.

Sets the icon of the window to one of the images.

The image with the closest resolution to the one desired by the OS will be used, rescaling if needed.

Each image is a map with the keys :width, :height, and :pixels. The :width and :height are integers, while :pixels is a pointer to the memory which will be copied for the icon. The image data will be finished copying before this function returns.

The image data is 8 bits color per channel, RGBA, little-endian, and non-premultiplied. Pixels are arranged in rows starting from the top left.

Sets the window iconify callback for the window.

The callback is a function of the window the event is from and a boolean of if the window is iconified.

Returns the previous callback, or nil if there was none.

If scope is passed, the callback will be kept valid for the duration of that scope. If it is not, a mem/global-scope is used.

Sets the window maximize callback for the window.

The callback is a function of the window the event is from and a boolean of if the window is maximized.

Returns the previous callback, or nil if there was none.

If scope is passed, the callback will be kept valid for the duration of that scope. If it is not, a mem/global-scope is used.

Sets the window to be fullscreen on monitor, or to windowed mode if nil.

If monitor is nil, the refresh-rate is ignored. If monitor is non-nil, then x-pos and y-pos are ignored. Alternate-arity versions of the function are provided to match those uses.

Sets the opacity of the window, including any decorations.

Sets the x and y positions of the given window.

Sets the position callback for the given window.

The callback is a function of the window the event is from and the two ints describing the new position of the window.

Returns the previous callback, or nil if there was none.

If scope is passed, the callback will be kept valid for the duration of that scope. If it is not, a mem/global-scope is used.

Sets the window refresh callback for the window.

The callback is a function of the window the event is from.

Returns the previous callback, or nil if there was none.

If scope is passed, the callback will be kept valid for the duration of that scope. If it is not, a mem/global-scope is used.

Sets the given window’s close flag.

Sets the width and height of the content area of window.

Sets the window resize callback for the window.

The callback is a function of the window the event is from and the two ints describing the new size of the content area of the window.

Returns the previous callback, or nil if there was none.

If scope is passed, the callback will be kept valid for the duration of that scope. If it is not, a mem/global-scope is used.

Sets the size limits of the content area of the window

Sets the title of the given window.

Sets a user-defined pointer value associated with the window.

The current value is retained until the window is destroyed.

Shows the window if it was previously hidden.

Swap the front and back buffers of a GL or GLES context for window.

If the swap interval is greater than zero, the GPU driver will wait that many screen updates before swapping the buffers.

When rendering with Vulkan, use vkQueuePresentKHR instead.

Sets the number of vblanks to wait for before showing the buffer.

A context must be current on this thread to call this function.

This function does not apply to Vulkan. If you are rendering using Vulkan, set the present mode of your swapchain instead.

See make-context-current.

Shuts down GLFW.

The contexts of any windows must not be current on any other thread when this is called.

Parse the passed mappings string and update internal list.

The mappings string can contain either a single gamepad mapping, or many mappings separated by newlines. The parser supports the full format of gamecontrollerdb.txt source file including empty lines and comments.

See the Gamepad Mappings Guide for a full description of the format.

If there is already a mapping for a passed GUID, it will be overriden with the new mapping. If terminate is called, followed by a second init, the internal mappings will be reset to their defaults.

Blocks the thread until at least one event is available, and processes it.

See poll-events.

Process events as wait-events, but returns after timeout seconds.

See poll-events.

Sets a window hint for the next window to be created.

Sets a string-valued window hint for the next window to be created.

Checks if the given window’s close flag is set.