#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>

Include dependency graph for MLX42.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	mlx_texture

struct	xpm

struct	mlx_instance

struct	mlx_key_data

struct	mlx_image

struct	mlx

Typedefs
typedef enum action	action_t

typedef enum modifier_key	modifier_key_t

typedef enum mouse_key	mouse_key_t

typedef enum mouse_mode	mouse_mode_t

typedef enum cursor	cursor_t

typedef enum keys	keys_t

typedef struct mlx_texture	mlx_texture_t

typedef struct xpm	xpm_t

typedef struct mlx_instance	mlx_instance_t

typedef struct mlx_key_data	mlx_key_data_t

typedef struct mlx_image	mlx_image_t

typedef struct mlx	mlx_t

typedef enum mlx_errno	mlx_errno_t

typedef enum mlx_settings	mlx_settings_t

typedef void(*	mlx_scrollfunc) (double xdelta, double ydelta, void *param)

typedef void(*	mlx_mousefunc) (mouse_key_t button, action_t action, modifier_key_t mods, void *param)

typedef void(*	mlx_cursorfunc) (double xpos, double ypos, void *param)

typedef void(*	mlx_keyfunc) (mlx_key_data_t keydata, void *param)

typedef void(*	mlx_resizefunc) (int32_t width, int32_t height, void *param)

typedef void(*	mlx_closefunc) (void *param)

typedef void	mlx_win_cursor_t

Enumerations
enum	action { MLX_RELEASE = 0 , MLX_PRESS = 1 , MLX_REPEAT = 2 }

enum	modifier_key { MLX_SHIFT = 0x0001 , MLX_CONTROL = 0x0002 , MLX_ALT = 0x0004 , MLX_SUPERKEY = 0x0008 , MLX_CAPSLOCK = 0x0010 , MLX_NUMLOCK = 0x0020 }

enum	mouse_key { MLX_MOUSE_BUTTON_LEFT = 0 , MLX_MOUSE_BUTTON_RIGHT = 1 , MLX_MOUSE_BUTTON_MIDDLE = 2 }

enum	mouse_mode { MLX_MOUSE_NORMAL = 0x00034001 , MLX_MOUSE_HIDDEN = 0x00034002 , MLX_MOUSE_DISABLED = 0x00034003 }

enum	cursor { MLX_CURSOR_ARROW = 0x00036001 , MLX_CURSOR_IBEAM = 0x00036002 , MLX_CURSOR_CROSSHAIR = 0x00036003 , MLX_CURSOR_HAND = 0x00036004 , MLX_CURSOR_HRESIZE = 0x00036005 , MLX_CURSOR_VRESIZE = 0x00036006 }

enum	keys { MLX_KEY_SPACE = 32 , MLX_KEY_APOSTROPHE = 39 , MLX_KEY_COMMA = 44 , MLX_KEY_MINUS = 45 , MLX_KEY_PERIOD = 46 , MLX_KEY_SLASH = 47 , MLX_KEY_0 = 48 , MLX_KEY_1 = 49 , MLX_KEY_2 = 50 , MLX_KEY_3 = 51 , MLX_KEY_4 = 52 , MLX_KEY_5 = 53 , MLX_KEY_6 = 54 , MLX_KEY_7 = 55 , MLX_KEY_8 = 56 , MLX_KEY_9 = 57 , MLX_KEY_SEMICOLON = 59 , MLX_KEY_EQUAL = 61 , MLX_KEY_A = 65 , MLX_KEY_B = 66 , MLX_KEY_C = 67 , MLX_KEY_D = 68 , MLX_KEY_E = 69 , MLX_KEY_F = 70 , MLX_KEY_G = 71 , MLX_KEY_H = 72 , MLX_KEY_I = 73 , MLX_KEY_J = 74 , MLX_KEY_K = 75 , MLX_KEY_L = 76 , MLX_KEY_M = 77 , MLX_KEY_N = 78 , MLX_KEY_O = 79 , MLX_KEY_P = 80 , MLX_KEY_Q = 81 , MLX_KEY_R = 82 , MLX_KEY_S = 83 , MLX_KEY_T = 84 , MLX_KEY_U = 85 , MLX_KEY_V = 86 , MLX_KEY_W = 87 , MLX_KEY_X = 88 , MLX_KEY_Y = 89 , MLX_KEY_Z = 90 , MLX_KEY_LEFT_BRACKET = 91 , MLX_KEY_BACKSLASH = 92 , MLX_KEY_RIGHT_BRACKET = 93 , MLX_KEY_GRAVE_ACCENT = 96 , MLX_KEY_ESCAPE = 256 , MLX_KEY_ENTER = 257 , MLX_KEY_TAB = 258 , MLX_KEY_BACKSPACE = 259 , MLX_KEY_INSERT = 260 , MLX_KEY_DELETE = 261 , MLX_KEY_RIGHT = 262 , MLX_KEY_LEFT = 263 , MLX_KEY_DOWN = 264 , MLX_KEY_UP = 265 , MLX_KEY_PAGE_UP = 266 , MLX_KEY_PAGE_DOWN = 267 , MLX_KEY_HOME = 268 , MLX_KEY_END = 269 , MLX_KEY_CAPS_LOCK = 280 , MLX_KEY_SCROLL_LOCK = 281 , MLX_KEY_NUM_LOCK = 282 , MLX_KEY_PRINT_SCREEN = 283 , MLX_KEY_PAUSE = 284 , MLX_KEY_F1 = 290 , MLX_KEY_F2 = 291 , MLX_KEY_F3 = 292 , MLX_KEY_F4 = 293 , MLX_KEY_F5 = 294 , MLX_KEY_F6 = 295 , MLX_KEY_F7 = 296 , MLX_KEY_F8 = 297 , MLX_KEY_F9 = 298 , MLX_KEY_F10 = 299 , MLX_KEY_F11 = 300 , MLX_KEY_F12 = 301 , MLX_KEY_F13 = 302 , MLX_KEY_F14 = 303 , MLX_KEY_F15 = 304 , MLX_KEY_F16 = 305 , MLX_KEY_F17 = 306 , MLX_KEY_F18 = 307 , MLX_KEY_F19 = 308 , MLX_KEY_F20 = 309 , MLX_KEY_F21 = 310 , MLX_KEY_F22 = 311 , MLX_KEY_F23 = 312 , MLX_KEY_F24 = 313 , MLX_KEY_F25 = 314 , MLX_KEY_KP_0 = 320 , MLX_KEY_KP_1 = 321 , MLX_KEY_KP_2 = 322 , MLX_KEY_KP_3 = 323 , MLX_KEY_KP_4 = 324 , MLX_KEY_KP_5 = 325 , MLX_KEY_KP_6 = 326 , MLX_KEY_KP_7 = 327 , MLX_KEY_KP_8 = 328 , MLX_KEY_KP_9 = 329 , MLX_KEY_KP_DECIMAL = 330 , MLX_KEY_KP_DIVIDE = 331 , MLX_KEY_KP_MULTIPLY = 332 , MLX_KEY_KP_SUBTRACT = 333 , MLX_KEY_KP_ADD = 334 , MLX_KEY_KP_ENTER = 335 , MLX_KEY_KP_EQUAL = 336 , MLX_KEY_LEFT_SHIFT = 340 , MLX_KEY_LEFT_CONTROL = 341 , MLX_KEY_LEFT_ALT = 342 , MLX_KEY_LEFT_SUPER = 343 , MLX_KEY_RIGHT_SHIFT = 344 , MLX_KEY_RIGHT_CONTROL = 345 , MLX_KEY_RIGHT_ALT = 346 , MLX_KEY_RIGHT_SUPER = 347 , MLX_KEY_MENU = 348 }

enum	mlx_errno { MLX_SUCCESS = 0 , MLX_INVEXT , MLX_INVFILE , MLX_INVPNG , MLX_INVXPM , MLX_INVPOS , MLX_INVDIM , MLX_INVIMG , MLX_VERTFAIL , MLX_FRAGFAIL , MLX_SHDRFAIL , MLX_MEMFAIL , MLX_GLADFAIL , MLX_GLFWFAIL , MLX_WINFAIL , MLX_STRTOOBIG , MLX_ERRMAX }

enum	mlx_settings { MLX_STRETCH_IMAGE = 0 , MLX_FULLSCREEN , MLX_MAXIMIZED , MLX_DECORATED , MLX_HEADLESS , MLX_SETTINGS_MAX }

Functions
const char *	mlx_strerror (mlx_errno_t val)

mlx_t *	mlx_init (int32_t width, int32_t height, const char *title, bool resize)

void	mlx_set_setting (mlx_settings_t setting, int32_t value)

void	mlx_close_window (mlx_t *mlx)

void	mlx_loop (mlx_t *mlx)

void	mlx_set_icon (mlx_t mlx, mlx_texture_t image)

void	mlx_terminate (mlx_t *mlx)

double	mlx_get_time (void)

void	mlx_focus (mlx_t *mlx)

void	mlx_get_monitor_size (int32_t index, int32_t width, int32_t height)

void	mlx_set_window_pos (mlx_t *mlx, int32_t xpos, int32_t ypos)

void	mlx_get_window_pos (mlx_t mlx, int32_t xpos, int32_t *ypos)

void	mlx_set_window_size (mlx_t *mlx, int32_t new_width, int32_t new_height)

void	mlx_set_window_limit (mlx_t *mlx, int32_t min_w, int32_t min_h, int32_t max_w, int32_t max_h)

void	mlx_set_window_title (mlx_t mlx, const char title)

bool	mlx_is_key_down (mlx_t *mlx, keys_t key)

bool	mlx_is_mouse_down (mlx_t *mlx, mouse_key_t key)

void	mlx_get_mouse_pos (mlx_t mlx, int32_t x, int32_t *y)

void	mlx_set_mouse_pos (mlx_t *mlx, int32_t x, int32_t y)

void	mlx_set_cursor_mode (mlx_t *mlx, mouse_mode_t mode)

mlx_win_cursor_t *	mlx_create_std_cursor (cursor_t type)

mlx_win_cursor_t *	mlx_create_cursor (mlx_texture_t *texture)

void	mlx_destroy_cursor (mlx_win_cursor_t *cursor)

void	mlx_set_cursor (mlx_t mlx, mlx_win_cursor_t cursor)

void	mlx_scroll_hook (mlx_t mlx, mlx_scrollfunc func, void param)

void	mlx_mouse_hook (mlx_t mlx, mlx_mousefunc func, void param)

void	mlx_cursor_hook (mlx_t mlx, mlx_cursorfunc func, void param)

void	mlx_key_hook (mlx_t mlx, mlx_keyfunc func, void param)

void	mlx_close_hook (mlx_t mlx, mlx_closefunc func, void param)

void	mlx_resize_hook (mlx_t mlx, mlx_resizefunc func, void param)

bool	mlx_loop_hook (mlx_t mlx, void(f)(void ), void param)

mlx_texture_t *	mlx_load_png (const char *path)

xpm_t *	mlx_load_xpm42 (const char *path)

void	mlx_delete_texture (mlx_texture_t *texture)

void	mlx_delete_xpm42 (xpm_t *xpm)

mlx_image_t *	mlx_texture_to_image (mlx_t mlx, mlx_texture_t texture)

void	mlx_put_pixel (mlx_image_t *image, uint32_t x, uint32_t y, uint32_t color)

mlx_image_t *	mlx_new_image (mlx_t *mlx, uint32_t width, uint32_t height)

int32_t	mlx_image_to_window (mlx_t mlx, mlx_image_t img, int32_t x, int32_t y)

void	mlx_delete_image (mlx_t mlx, mlx_image_t image)

bool	mlx_resize_image (mlx_image_t *img, uint32_t nwidth, uint32_t nheight)

void	mlx_set_instance_depth (mlx_instance_t *instance, int32_t zdepth)

mlx_image_t *	mlx_put_string (mlx_t mlx, const char str, int32_t x, int32_t y)

const mlx_texture_t *	mlx_get_font (void)

int32_t	mlx_get_texoffset (char c)

Variables
mlx_errno_t	mlx_errno

Typedef Documentation

◆ action_t

typedef enum action action_t

MLX42 is a cross-platform low level and simple graphics library written in C and uses OpenGL and GLFW for it's underlying windowing and rendering system.

It's a much more up-to-date alternative to the miniLibX which has been extensively proven to be fragile, unmaintained, deprecated and just plain painfully bad to work with. Also its code quality is dubious.

Some structs contain potential void* which are to be ignored as they simply represent points of abstraction to the hidden internal header. This abstraction is crucial as the whole point of this lib so to hide all the bells and whistles in the "engine". Most user's have no need for the inner workings eitherway (shaders, vertex buffer, ...).
The input key codes are copied straight from GLFW. Any new entries should have the exact same values as defined in the glfw3.h. A key action such as pressing or releasing a key.

Parameters

RELEASE	Execute when the key is being released.
PRESS	Execute when the key is being pressed.
REPEAT	Execute when the key is being held down.

◆ cursor_t

typedef enum cursor cursor_t

Various cursors that are standard.

Parameters

ARROW	The regular arrow cursor.
IBEAM	The text input I-beam cursor shape.
CROSSHAIR	The crosshair shape cursor.
HAND	The hand shape cursor.
HRESIZE	The horizontal resize arrow shape.
VRESIZE	The vertical resize arrow shape.

◆ keys_t

typedef enum keys keys_t

All sorts of keyboard keycodes.

KP = Keypad.

◆ mlx_closefunc

typedef void(* mlx_closefunc) (void *param)

Callback function used to handle window closing which is called when the user attempts to close the window, for example by clicking the close widget in the title bar.

Parameters

[in] param Additional parameter to pass on to the function.

Definition at line 462 of file MLX42.h.

◆ mlx_cursorfunc

typedef void(* mlx_cursorfunc) (double xpos, double ypos, void *param)

Callback function used to handle raw mouse movement.

Parameters

[in]	xpos	The mouse x position.
[in]	ypos	The mouse y position.
[in]	param	Additional parameter to pass on to the function.

Definition at line 433 of file MLX42.h.

◆ mlx_errno_t

typedef enum mlx_errno mlx_errno_t

◆ mlx_image_t

typedef struct mlx_image mlx_image_t

An image with an individual buffer that can be rendered. Any value can be modified except the width/height and context.

Parameters

width	The width of the image.
height	The height of the image.
pixels	The literal pixel data.
instances	An instance carrying the X, Y and Z location data.
count	The element count of the instances array.
enabled	If true the image is drawn onto the screen, else it's not.
context	Abstracted OpenGL data.

◆ mlx_instance_t

typedef struct mlx_instance mlx_instance_t

An image instance can be summarized as just a simple x, y & z coordinate.

Coordinates start from the top left of the screen at 0,0 and increase towards the bottom right.

NOTE: To change the z value, use mlx_set_instance_depth!

Parameters

x	The x location.
y	The y location.
z	The z depth, controls if the image is on the fore or background.
enabled	If true, the instance is drawn, else it's not.

◆ mlx_key_data_t

typedef struct mlx_key_data mlx_key_data_t

Key function callback data. Data related to the mlx_key_hook function

Parameters

key	The key that was pressed.
action	The action that was done with the key.
os_key	The os_key is unique for every key, and will have a different value/keycode depending on the platform. They may be consistent on different platforms.
modifier	The modifier key that was pressed, 0 if no key was pressed.

◆ mlx_keyfunc

typedef void(* mlx_keyfunc) (mlx_key_data_t keydata, void *param)

Callback function used to handle key presses.

Parameters

[in]	keydata	The callback data, contains info on key, action, ...
[in]	param	Additional parameter to pass on to the function.

Definition at line 441 of file MLX42.h.

◆ mlx_mousefunc

typedef void(* mlx_mousefunc) (mouse_key_t button, action_t action, modifier_key_t mods, void *param)

Callback function used to handle mouse actions.

Parameters

[in]	button	The mouse button/key pressed.
[in]	action	The mouse action that took place.
[in]	mods	The modifier keys pressed together with the mouse key.
[in]	param	Additional parameter to pass on to the function.

Definition at line 424 of file MLX42.h.

◆ mlx_resizefunc

typedef void(* mlx_resizefunc) (int32_t width, int32_t height, void *param)

Callback function used to handle window resizing.

WARNING: The function is called every frame during which the window is being resized, be aware!

Parameters

[in]	width	The new width of the window.
[in]	height	The new height of the window.
[in]	param	Additional parameter to pass on to the function.

Definition at line 453 of file MLX42.h.

◆ mlx_scrollfunc

typedef void(* mlx_scrollfunc) (double xdelta, double ydelta, void *param)

Callback function used to handle scrolling.

Parameters

[in]	xdelta	The mouse x delta.
[in]	ydelta	The mouse y delta.
[in]	param	Additional parameter to pass on to the function.

Definition at line 414 of file MLX42.h.

◆ mlx_settings_t

typedef enum mlx_settings mlx_settings_t

◆ mlx_t

typedef struct mlx mlx_t

Main MLX handle, carries important data in regards to the program.

Parameters

window	The window itself.
context	Abstracted opengl data.
width	The width of the window.
height	The height of the window.
delta_time	The time difference between the previous frame and the current frame.

◆ mlx_texture_t

typedef struct mlx_texture mlx_texture_t

Base object for disk loaded textures. It contains rudementary information about the texture.

Parameters

width	The width of the texture.
height	The height of the texture.
pixels	The literal pixel data.
bytes_per_pixel	The amount of bytes in a pixel, always 4.

◆ mlx_win_cursor_t

typedef void mlx_win_cursor_t

Typedef for a window cursor object, these eventually expand to the native cursor object, but are hidden from the user.

Under GLFW they are named GLFWcursor and have a wrapper for each implementation. You can find the ACTUAL cursor in the following files at GLFW named under *_platform.h

Definition at line 471 of file MLX42.h.

◆ modifier_key_t

typedef enum modifier_key modifier_key_t

Key modifiers, such as shift, control or alt. These keys are flags meaning you can combine them to detect key combinations such as CTRL + ALT so CTRL | ALT.

Parameters

SHIFT	The shift key.
CONTROL	The control key.
ALT	The alt key.
SUPERKEY	The Superkey such as the Windows Key or Command.
CAPSLOCK	The capslock key.
NUMLOCK	The numlock key.

◆ mouse_key_t

typedef enum mouse_key mouse_key_t

The mouse button keycodes.

Parameters

LEFT	The left mouse button.
RIGHT	The right mouse button.
MIDDLE	The middle mouse button, aka the Scrollwheel.

◆ mouse_mode_t

typedef enum mouse_mode mouse_mode_t

Various mouse/cursor states.

Parameters

NORMAL	Simple visible default cursor.
HIDDEN	The cursor is not rendered but still functions.
DISABLED	The cursor is not rendered, nor is it functional.

◆ xpm_t

typedef struct xpm xpm_t

Struct containing data regarding an XPM image.

Parameters

texture	The texture data of the XPM.
color_count	The amount of colors available.
cpp	The amount of characters per pixel.
mode	The color mode, either (c)olor or (m)onochrome.

Enumeration Type Documentation

◆ action

enum action

MLX42 is a cross-platform low level and simple graphics library written in C and uses OpenGL and GLFW for it's underlying windowing and rendering system.

It's a much more up-to-date alternative to the miniLibX which has been extensively proven to be fragile, unmaintained, deprecated and just plain painfully bad to work with. Also its code quality is dubious.

Some structs contain potential void* which are to be ignored as they simply represent points of abstraction to the hidden internal header. This abstraction is crucial as the whole point of this lib so to hide all the bells and whistles in the "engine". Most user's have no need for the inner workings eitherway (shaders, vertex buffer, ...).
The input key codes are copied straight from GLFW. Any new entries should have the exact same values as defined in the glfw3.h. A key action such as pressing or releasing a key.

Parameters

RELEASE	Execute when the key is being released.
PRESS	Execute when the key is being pressed.
REPEAT	Execute when the key is being held down.

Enumerator
MLX_RELEASE
MLX_PRESS
MLX_REPEAT

Definition at line 53 of file MLX42.h.

{
    MLX_RELEASE = 0,
    MLX_PRESS   = 1,
    MLX_REPEAT  = 2,
}   action_t;

◆ cursor

enum cursor

Various cursors that are standard.

Parameters

ARROW	The regular arrow cursor.
IBEAM	The text input I-beam cursor shape.
CROSSHAIR	The crosshair shape cursor.
HAND	The hand shape cursor.
HRESIZE	The horizontal resize arrow shape.
VRESIZE	The vertical resize arrow shape.

Enumerator
MLX_CURSOR_ARROW
MLX_CURSOR_IBEAM
MLX_CURSOR_CROSSHAIR
MLX_CURSOR_HAND
MLX_CURSOR_HRESIZE
MLX_CURSOR_VRESIZE

Definition at line 117 of file MLX42.h.

{
    MLX_CURSOR_ARROW        = 0x00036001,
    MLX_CURSOR_IBEAM        = 0x00036002,
    MLX_CURSOR_CROSSHAIR    = 0x00036003,
    MLX_CURSOR_HAND         = 0x00036004,
    MLX_CURSOR_HRESIZE      = 0x00036005,
    MLX_CURSOR_VRESIZE      = 0x00036006,
}   cursor_t;

◆ keys

enum keys

All sorts of keyboard keycodes.

KP = Keypad.

Enumerator
MLX_KEY_SPACE
MLX_KEY_APOSTROPHE
MLX_KEY_COMMA
MLX_KEY_MINUS
MLX_KEY_PERIOD
MLX_KEY_SLASH
MLX_KEY_0
MLX_KEY_1
MLX_KEY_2
MLX_KEY_3
MLX_KEY_4
MLX_KEY_5
MLX_KEY_6
MLX_KEY_7
MLX_KEY_8
MLX_KEY_9
MLX_KEY_SEMICOLON
MLX_KEY_EQUAL
MLX_KEY_A
MLX_KEY_B
MLX_KEY_C
MLX_KEY_D
MLX_KEY_E
MLX_KEY_F
MLX_KEY_G
MLX_KEY_H
MLX_KEY_I
MLX_KEY_J
MLX_KEY_K
MLX_KEY_L
MLX_KEY_M
MLX_KEY_N
MLX_KEY_O
MLX_KEY_P
MLX_KEY_Q
MLX_KEY_R
MLX_KEY_S
MLX_KEY_T
MLX_KEY_U
MLX_KEY_V
MLX_KEY_W
MLX_KEY_X
MLX_KEY_Y
MLX_KEY_Z
MLX_KEY_LEFT_BRACKET
MLX_KEY_BACKSLASH
MLX_KEY_RIGHT_BRACKET
MLX_KEY_GRAVE_ACCENT
MLX_KEY_ESCAPE
MLX_KEY_ENTER
MLX_KEY_TAB
MLX_KEY_BACKSPACE
MLX_KEY_INSERT
MLX_KEY_DELETE
MLX_KEY_RIGHT
MLX_KEY_LEFT
MLX_KEY_DOWN
MLX_KEY_UP
MLX_KEY_PAGE_UP
MLX_KEY_PAGE_DOWN
MLX_KEY_HOME
MLX_KEY_END
MLX_KEY_CAPS_LOCK
MLX_KEY_SCROLL_LOCK
MLX_KEY_NUM_LOCK
MLX_KEY_PRINT_SCREEN
MLX_KEY_PAUSE
MLX_KEY_F1
MLX_KEY_F2
MLX_KEY_F3
MLX_KEY_F4
MLX_KEY_F5
MLX_KEY_F6
MLX_KEY_F7
MLX_KEY_F8
MLX_KEY_F9
MLX_KEY_F10
MLX_KEY_F11
MLX_KEY_F12
MLX_KEY_F13
MLX_KEY_F14
MLX_KEY_F15
MLX_KEY_F16
MLX_KEY_F17
MLX_KEY_F18
MLX_KEY_F19
MLX_KEY_F20
MLX_KEY_F21
MLX_KEY_F22
MLX_KEY_F23
MLX_KEY_F24
MLX_KEY_F25
MLX_KEY_KP_0
MLX_KEY_KP_1
MLX_KEY_KP_2
MLX_KEY_KP_3
MLX_KEY_KP_4
MLX_KEY_KP_5
MLX_KEY_KP_6
MLX_KEY_KP_7
MLX_KEY_KP_8
MLX_KEY_KP_9
MLX_KEY_KP_DECIMAL
MLX_KEY_KP_DIVIDE
MLX_KEY_KP_MULTIPLY
MLX_KEY_KP_SUBTRACT
MLX_KEY_KP_ADD
MLX_KEY_KP_ENTER
MLX_KEY_KP_EQUAL
MLX_KEY_LEFT_SHIFT
MLX_KEY_LEFT_CONTROL
MLX_KEY_LEFT_ALT
MLX_KEY_LEFT_SUPER
MLX_KEY_RIGHT_SHIFT
MLX_KEY_RIGHT_CONTROL
MLX_KEY_RIGHT_ALT
MLX_KEY_RIGHT_SUPER
MLX_KEY_MENU

Definition at line 132 of file MLX42.h.

{
    MLX_KEY_SPACE           = 32,
    MLX_KEY_APOSTROPHE      = 39,
    MLX_KEY_COMMA           = 44,
    MLX_KEY_MINUS           = 45,
    MLX_KEY_PERIOD          = 46,
    MLX_KEY_SLASH           = 47,
    MLX_KEY_0               = 48,
    MLX_KEY_1               = 49,
    MLX_KEY_2               = 50,
    MLX_KEY_3               = 51,
    MLX_KEY_4               = 52,
    MLX_KEY_5               = 53,
    MLX_KEY_6               = 54,
    MLX_KEY_7               = 55,
    MLX_KEY_8               = 56,
    MLX_KEY_9               = 57,
    MLX_KEY_SEMICOLON       = 59,
    MLX_KEY_EQUAL           = 61,
    MLX_KEY_A               = 65,
    MLX_KEY_B               = 66,
    MLX_KEY_C               = 67,
    MLX_KEY_D               = 68,
    MLX_KEY_E               = 69,
    MLX_KEY_F               = 70,
    MLX_KEY_G               = 71,
    MLX_KEY_H               = 72,
    MLX_KEY_I               = 73,
    MLX_KEY_J               = 74,
    MLX_KEY_K               = 75,
    MLX_KEY_L               = 76,
    MLX_KEY_M               = 77,
    MLX_KEY_N               = 78,
    MLX_KEY_O               = 79,
    MLX_KEY_P               = 80,
    MLX_KEY_Q               = 81,
    MLX_KEY_R               = 82,
    MLX_KEY_S               = 83,
    MLX_KEY_T               = 84,
    MLX_KEY_U               = 85,
    MLX_KEY_V               = 86,
    MLX_KEY_W               = 87,
    MLX_KEY_X               = 88,
    MLX_KEY_Y               = 89,
    MLX_KEY_Z               = 90,
    MLX_KEY_LEFT_BRACKET    = 91,
    MLX_KEY_BACKSLASH       = 92,
    MLX_KEY_RIGHT_BRACKET   = 93,
    MLX_KEY_GRAVE_ACCENT    = 96,
    MLX_KEY_ESCAPE          = 256,
    MLX_KEY_ENTER           = 257,
    MLX_KEY_TAB             = 258,
    MLX_KEY_BACKSPACE       = 259,
    MLX_KEY_INSERT          = 260,
    MLX_KEY_DELETE          = 261,
    MLX_KEY_RIGHT           = 262,
    MLX_KEY_LEFT            = 263,
    MLX_KEY_DOWN            = 264,
    MLX_KEY_UP              = 265,
    MLX_KEY_PAGE_UP         = 266,
    MLX_KEY_PAGE_DOWN       = 267,
    MLX_KEY_HOME            = 268,
    MLX_KEY_END             = 269,
    MLX_KEY_CAPS_LOCK       = 280,
    MLX_KEY_SCROLL_LOCK     = 281,
    MLX_KEY_NUM_LOCK        = 282,
    MLX_KEY_PRINT_SCREEN    = 283,
    MLX_KEY_PAUSE           = 284,
    MLX_KEY_F1              = 290,
    MLX_KEY_F2              = 291,
    MLX_KEY_F3              = 292,
    MLX_KEY_F4              = 293,
    MLX_KEY_F5              = 294,
    MLX_KEY_F6              = 295,
    MLX_KEY_F7              = 296,
    MLX_KEY_F8              = 297,
    MLX_KEY_F9              = 298,
    MLX_KEY_F10             = 299,
    MLX_KEY_F11             = 300,
    MLX_KEY_F12             = 301,
    MLX_KEY_F13             = 302,
    MLX_KEY_F14             = 303,
    MLX_KEY_F15             = 304,
    MLX_KEY_F16             = 305,
    MLX_KEY_F17             = 306,
    MLX_KEY_F18             = 307,
    MLX_KEY_F19             = 308,
    MLX_KEY_F20             = 309,
    MLX_KEY_F21             = 310,
    MLX_KEY_F22             = 311,
    MLX_KEY_F23             = 312,
    MLX_KEY_F24             = 313,
    MLX_KEY_F25             = 314,
    MLX_KEY_KP_0            = 320,
    MLX_KEY_KP_1            = 321,
    MLX_KEY_KP_2            = 322,
    MLX_KEY_KP_3            = 323,
    MLX_KEY_KP_4            = 324,
    MLX_KEY_KP_5            = 325,
    MLX_KEY_KP_6            = 326,
    MLX_KEY_KP_7            = 327,
    MLX_KEY_KP_8            = 328,
    MLX_KEY_KP_9            = 329,
    MLX_KEY_KP_DECIMAL      = 330,
    MLX_KEY_KP_DIVIDE       = 331,
    MLX_KEY_KP_MULTIPLY     = 332,
    MLX_KEY_KP_SUBTRACT     = 333,
    MLX_KEY_KP_ADD          = 334,
    MLX_KEY_KP_ENTER        = 335,
    MLX_KEY_KP_EQUAL        = 336,
    MLX_KEY_LEFT_SHIFT      = 340,
    MLX_KEY_LEFT_CONTROL    = 341,
    MLX_KEY_LEFT_ALT        = 342,
    MLX_KEY_LEFT_SUPER      = 343,
    MLX_KEY_RIGHT_SHIFT     = 344,
    MLX_KEY_RIGHT_CONTROL   = 345,
    MLX_KEY_RIGHT_ALT       = 346,
    MLX_KEY_RIGHT_SUPER     = 347,
    MLX_KEY_MENU            = 348,
}   keys_t;

◆ mlx_errno

enum mlx_errno

Enumerator
MLX_SUCCESS
MLX_INVEXT
MLX_INVFILE
MLX_INVPNG
MLX_INVXPM
MLX_INVPOS
MLX_INVDIM
MLX_INVIMG
MLX_VERTFAIL
MLX_FRAGFAIL
MLX_SHDRFAIL
MLX_MEMFAIL
MLX_GLADFAIL
MLX_GLFWFAIL
MLX_WINFAIL
MLX_STRTOOBIG
MLX_ERRMAX

Definition at line 370 of file MLX42.h.

{
    MLX_SUCCESS = 0,    // No Errors
    MLX_INVEXT,         // File has an invalid extension
    MLX_INVFILE,        // File was invalid / does not exist.
    MLX_INVPNG,         // Something is wrong with the given PNG file.
    MLX_INVXPM,         // Something is wrong with the given XPM file.
    MLX_INVPOS,         // The specified X/Y positions are out of bounds.
    MLX_INVDIM,         // The specified W/H dimensions are out of bounds.
    MLX_INVIMG,         // The provided image is invalid, might indicate mismanagement of images.
    MLX_VERTFAIL,       // Failed to compile the vertex shader.
    MLX_FRAGFAIL,       // Failed to compile the fragment shader.
    MLX_SHDRFAIL,       // Failed to compile the shaders.
    MLX_MEMFAIL,        // Dynamic memory allocation has failed.
    MLX_GLADFAIL,       // OpenGL loader has failed.
    MLX_GLFWFAIL,       // GLFW failed to initialize.
    MLX_WINFAIL,        // Failed to create a window.
    MLX_STRTOOBIG,      // The string is too big to be drawn.
    MLX_ERRMAX,         // Error count
}   mlx_errno_t;

◆ mlx_settings

enum mlx_settings

Enumerator
MLX_STRETCH_IMAGE
MLX_FULLSCREEN
MLX_MAXIMIZED
MLX_DECORATED
MLX_HEADLESS
MLX_SETTINGS_MAX

Definition at line 397 of file MLX42.h.

{
    MLX_STRETCH_IMAGE = 0,  // Should images resize with the window as it's being resized or not. Default: false
    MLX_FULLSCREEN,         // Should the window be in Fullscreen, note it will fullscreen at the given resolution. Default: false
    MLX_MAXIMIZED,          // Start the window in a maximized state, overwrites the fullscreen state if this is true. Default: false
    MLX_DECORATED,          // Have the window be decorated with a window bar. Default: true
    MLX_HEADLESS,           // Run in headless mode, no window is created. (NOTE: Still requires some form of window manager such as xvfb)
    MLX_SETTINGS_MAX,       // Setting count.
}   mlx_settings_t;

◆ modifier_key

enum modifier_key

Key modifiers, such as shift, control or alt. These keys are flags meaning you can combine them to detect key combinations such as CTRL + ALT so CTRL | ALT.

Parameters

SHIFT	The shift key.
CONTROL	The control key.
ALT	The alt key.
SUPERKEY	The Superkey such as the Windows Key or Command.
CAPSLOCK	The capslock key.
NUMLOCK	The numlock key.

Enumerator
MLX_SHIFT
MLX_CONTROL
MLX_ALT
MLX_SUPERKEY
MLX_CAPSLOCK
MLX_NUMLOCK

Definition at line 72 of file MLX42.h.

{
    MLX_SHIFT       = 0x0001,
    MLX_CONTROL     = 0x0002,
    MLX_ALT         = 0x0004,
    MLX_SUPERKEY    = 0x0008,
    MLX_CAPSLOCK    = 0x0010,
    MLX_NUMLOCK     = 0x0020,
}   modifier_key_t;

◆ mouse_key

enum mouse_key

The mouse button keycodes.

Parameters

LEFT	The left mouse button.
RIGHT	The right mouse button.
MIDDLE	The middle mouse button, aka the Scrollwheel.

Enumerator
MLX_MOUSE_BUTTON_LEFT
MLX_MOUSE_BUTTON_RIGHT
MLX_MOUSE_BUTTON_MIDDLE

Definition at line 88 of file MLX42.h.

{
    MLX_MOUSE_BUTTON_LEFT   = 0,
    MLX_MOUSE_BUTTON_RIGHT  = 1,
    MLX_MOUSE_BUTTON_MIDDLE = 2,
}   mouse_key_t;

◆ mouse_mode

enum mouse_mode

Various mouse/cursor states.

Parameters

NORMAL	Simple visible default cursor.
HIDDEN	The cursor is not rendered but still functions.
DISABLED	The cursor is not rendered, nor is it functional.

Enumerator
MLX_MOUSE_NORMAL
MLX_MOUSE_HIDDEN
MLX_MOUSE_DISABLED

Definition at line 101 of file MLX42.h.

{
    MLX_MOUSE_NORMAL    = 0x00034001,
    MLX_MOUSE_HIDDEN    = 0x00034002,
    MLX_MOUSE_DISABLED  = 0x00034003,
}   mouse_mode_t;

Function Documentation

◆ mlx_close_hook()

void mlx_close_hook	(	mlx_t *	mlx,
		mlx_closefunc	func,
		void *	param
	)

This function sets the close callback, which is called in attempt to close the window device such as a close window widget used in the window bar.

Parameters

[in]	mlx	The MLX instance handle.
[in]	func	The close callback function.
[in]	param	An additional optional parameter.

Definition at line 63 of file mlx_window.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(func);
 
    mlx_ctx_t* mlxctx = mlx->context;
    mlxctx->close_hook.func = func;
    mlxctx->close_hook.param = param;
    glfwSetWindowCloseCallback(mlx->window, mlx_close_callback);
}

Here is the call graph for this function:

◆ mlx_close_window()

void mlx_close_window ( mlx_t * mlx )

Notifies MLX that it should stop rendering and exit the main loop. This is not the same as terminate, this simply tells MLX to close the window.

Parameters

[in] mlx The MLX instance handle.

Definition at line 26 of file mlx_exit.c.

{
    MLX_NONNULL(mlx);
    glfwSetWindowShouldClose(mlx->window, true);
}

Here is the caller graph for this function:

◆ mlx_create_cursor()

mlx_win_cursor_t * mlx_create_cursor ( mlx_texture_t * texture )

Allows for the creation of custom cursors with a given texture.

Use mlx_set_cursor to select the specific cursor. Cursors are destroyed at mlx_terminate().

Parameters

[in] texture The texture to use as cursor.

Returns: The cursor object or null on failure.

Definition at line 27 of file mlx_cursor.c.

{
    MLX_NONNULL(texture);
 
    GLFWcursor* cursor;
    GLFWimage image = (GLFWimage) {
        .width = texture->width,
        .height = texture->height,
        .pixels = texture->pixels
    };
 
    if ((cursor = glfwCreateCursor(&image, 0, 0)))
        return (cursor);
    return ((void *)mlx_error(MLX_MEMFAIL));
}

Here is the call graph for this function:

◆ mlx_create_std_cursor()

mlx_win_cursor_t * mlx_create_std_cursor ( cursor_t type )

Retrieves the system standard cursor.

Parameters

[in] type The standard cursor type to create.

Returns: The cursor object or null on failure.

Definition at line 17 of file mlx_cursor.c.

{
    MLX_ASSERT(type >= MLX_CURSOR_ARROW && type < MLX_CURSOR_VRESIZE, "Invalid standard cursor type");
 
    GLFWcursor* cursor;
    if ((cursor = glfwCreateStandardCursor(type)))
        return (cursor);
    return ((void *)mlx_error(MLX_MEMFAIL));
}

Here is the call graph for this function:

◆ mlx_cursor_hook()

void mlx_cursor_hook	(	mlx_t *	mlx,
		mlx_cursorfunc	func,
		void *	param
	)

This function sets the cursor callback, which is called when the mouse position changes. Position is relative to the window.

Parameters

[in]	mlx	The MLX instance handle.
[in]	func	The cursor callback function.
[in]	param	An additional optional parameter.

Definition at line 65 of file mlx_mouse.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(func);
 
    mlx_ctx_t* const mlxctx = mlx->context;
    mlxctx->cursor_hook.func = func;
    mlxctx->cursor_hook.param = param;
    glfwSetCursorPosCallback(mlx->window, mlx_cursor_cb);
}

Here is the call graph for this function:

◆ mlx_delete_image()

void mlx_delete_image	(	mlx_t *	mlx,
		mlx_image_t *	image
	)

Deleting an image will remove it from the render queue as well as any and all instances it might have. Additionally, just as extra measures sets all the data to NULL.

If you simply wish to stop rendering an image without de-allocation set the 'enabled' boolean in the image struct.

Parameters

[in]	mlx	The MLX instance handle.
[in]	image	The image to delete.

Definition at line 204 of file mlx_images.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(image);
 
    mlx_ctx_t* mlxctx = mlx->context;
 
    // Delete all instances in the render queue
    mlx_list_t* quelst;
    while ((quelst = mlx_lstremove(&mlxctx->render_queue, image, &mlx_equal_inst)))
        mlx_freen(2, quelst->content, quelst);
 
    mlx_list_t* imglst;
    if ((imglst = mlx_lstremove(&mlxctx->images, image, &mlx_equal_image)))
    {
        glDeleteTextures(1, &((mlx_image_ctx_t*)image->context)->texture);
        mlx_freen(5, image->pixels, image->instances, image->context, imglst, image);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mlx_delete_texture()

void mlx_delete_texture ( mlx_texture_t * texture )

Deletes a texture by freeing its allocated data.

Parameters

[in] texture The texture to free.

Definition at line 37 of file mlx_texture.c.

{
    MLX_NONNULL(texture);
 
    mlx_freen(2, texture->pixels, texture);
}

Here is the call graph for this function:

◆ mlx_delete_xpm42()

void mlx_delete_xpm42 ( xpm_t * xpm )

Deletes an XPM42 texture by freeing its allocated data.

This will not remove any already drawn XPMs, it simply deletes the XPM buffer.

Parameters

[in] xpm The xpm texture to delete.

Definition at line 203 of file mlx_xpm42.c.

{
    MLX_NONNULL(xpm);
    free(xpm->texture.pixels);
    free(xpm);
}

◆ mlx_destroy_cursor()

void mlx_destroy_cursor ( mlx_win_cursor_t * cursor )

Destroys the given cursor object.

Parameters

[in] cursor The cursor object to destroy.

Definition at line 43 of file mlx_cursor.c.

{
    MLX_NONNULL(cursor);
 
    glfwDestroyCursor(cursor);
}

◆ mlx_focus()

void mlx_focus ( mlx_t * mlx )

This function brings the specified window to front and sets input focus.

Do not use this function to steal focus from other applications unless you are certain that is what the user wants. Focus stealing can be extremely disruptive.

Parameters

[in] mlx The MLX instance handle.

Definition at line 126 of file mlx_utils.c.

{
    MLX_NONNULL(mlx);
 
    glfwFocusWindow(mlx->window);
}

◆ mlx_get_font()

const mlx_texture_t * mlx_get_font ( void )

Retrieve the texture data for the built-in font.

Returns: Pointer to the built-in font texture.

Definition at line 46 of file mlx_font.c.

{
    return ((const mlx_texture_t*)&font_atlas);
}

◆ mlx_get_monitor_size()

void mlx_get_monitor_size	(	int32_t	index,
		int32_t *	width,
		int32_t *	height
	)

Gets the size of the specified monitor.

Parameters

[in]	index	Normally 0, in case of multiple windows, can be specified
[in]	width	The width of the window.
[in]	height	The height of the window.

Definition at line 17 of file mlx_monitor.c.

{
    MLX_ASSERT(index >= 0, "Index out of bounds");
    MLX_NONNULL(width);
    MLX_NONNULL(height);
 
    *width = 0;
    *height = 0;
    
    int32_t monitor_count;
    GLFWmonitor** monitors = glfwGetMonitors(&monitor_count);
    if (index > monitor_count || !monitors)
        return;
 
    const GLFWvidmode* vidmode;
    if ((vidmode = glfwGetVideoMode(monitors[index])))
    {
        *width = vidmode->width;
        *height = vidmode->height;
    }
}

◆ mlx_get_mouse_pos()

void mlx_get_mouse_pos	(	mlx_t *	mlx,
		int32_t *	x,
		int32_t *	y
	)

Returns the current, relative, mouse cursor position on the window, starting from the top left corner.

Negative values or values greater than window width or height indicate that it is outside the window.

Parameters

[in]	mlx	The MLX instance handle.
[out]	x	The position.
[out]	y	The position.

Definition at line 90 of file mlx_mouse.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(x);
    MLX_NONNULL(y);
 
    double xd, yd;
    glfwGetCursorPos(mlx->window, &xd, &yd);
    *x = (int32_t)xd;
    *y = (int32_t)yd;
}

◆ mlx_get_texoffset()

int32_t mlx_get_texoffset ( char c )

This function lets you retrieve the X offset of the given char in the font texture.

NOTE: A single character is 10 * 20 in pixels!

Parameters

[in] c The character to get the offset from.

Returns: Non-negative if found or -1 if not found.

Definition at line 51 of file mlx_font.c.

{
    const bool _isprint = isprint(c);
 
    // NOTE: Cheesy branchless operation :D
    // +2 To skip line separator in texture
    return (-1 * !_isprint + ((FONT_WIDTH + 2) * (c - 32)) * _isprint);
}

Here is the caller graph for this function:

◆ mlx_get_time()

double mlx_get_time ( void )

Gets the elapsed time since MLX was initialized.

Returns: The amount of time elapsed in seconds.

Definition at line 121 of file mlx_utils.c.

{
    return (glfwGetTime());
}

◆ mlx_get_window_pos()

void mlx_get_window_pos	(	mlx_t *	mlx,
		int32_t *	xpos,
		int32_t *	ypos
	)

Gets the window's position.

Parameters

[in]	mlx	The MLX instance handle.
[out]	xpos	The x position.
[out]	ypos	The y position.

Definition at line 106 of file mlx_window.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(xpos);
    MLX_NONNULL(ypos);
 
    glfwGetWindowPos(mlx->window, xpos, ypos);
}

◆ mlx_image_to_window()

int32_t mlx_image_to_window	(	mlx_t *	mlx,
		mlx_image_t *	img,
		int32_t	x,
		int32_t	y
	)

Draws a new instance of an image, it will then share the same pixel buffer as the image.

NOTE: Keep in mind that the instance array gets reallocated, try to store the return value to the instance! NOT the pointer! It will become invalid!

WARNING: Try to display as few images on the window as possible, drawing too many images will cause a loss in performance!

Parameters

[in]	mlx	The MLX instance handle.
[in]	img	The image to draw on the screen.
[in]	x	The X position.
[in]	y	The Y position.

Returns: Index to the instance, or -1 on failure.

Definition at line 121 of file mlx_images.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(img);
 
    // Allocate buffers...
    img->count++;
    bool did_realloc;
    mlx_instance_t* instances = mlx_grow_instances(img, &did_realloc);
    draw_queue_t* queue = calloc(1, sizeof(draw_queue_t));
    if (!instances || !queue)
    {
        if (did_realloc)
            free(instances);
        return (free(queue), mlx_error(MLX_MEMFAIL), -1);
    }
 
    // Set data...
    queue->image = img;
    int32_t index = queue->instanceid = img->count - 1;
    img->instances = instances;
    img->instances[index].x = x;
    img->instances[index].y = y;
 
    // NOTE: We keep updating the Z for the convenience of the user.
    // Always update Z depth to prevent overlapping images by default.
    img->instances[index].z = ((mlx_ctx_t*)mlx->context)->zdepth++;
    img->instances[index].enabled = true;
 
    // Add draw call...
    sort_queue = true;
    mlx_list_t* templst;
    if ((templst = mlx_lstnew(queue)))
    {
        mlx_lstadd_front(&((mlx_ctx_t*)mlx->context)->render_queue, templst);
        return (index);
    }
    return (mlx_freen(2, instances, queue), mlx_error(MLX_MEMFAIL), -1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mlx_init()

mlx_t * mlx_init	(	int32_t	width,
		int32_t	height,
		const char *	title,
		bool	resize
	)

Initializes a new MLX42 Instance.

Parameters

[in]	width	The width of the window.
[in]	height	The height of the window.
[in]	title	The title of the window.
[in]	resize	Enable window resizing.

Returns: Ptr to the MLX handle or null on failure.

Definition at line 164 of file mlx_init.c.

{
    MLX_NONNULL(title);
    MLX_ASSERT(width > 0, "Window width must be positive");
    MLX_ASSERT(height > 0, "Window height must be positive");
 
    bool init;
    mlx_t* mlx;
    if (!(init = glfwInit()))
        return ((void*)mlx_error(MLX_GLFWFAIL));
    if (!(mlx = calloc(1, sizeof(mlx_t))))
        return ((void*)mlx_error(MLX_MEMFAIL));
    if (!(mlx->context = calloc(1, sizeof(mlx_ctx_t))))
        return (free(mlx), (void*)mlx_error(MLX_MEMFAIL));
 
    mlx_ctx_t* const mlxctx = mlx->context;
    mlx->window = NULL;
    mlx->width = width;
    mlx->height = height;
    mlxctx->initialWidth = width;
    mlxctx->initialHeight = height;
 
    // NOTE(W2): For emscripten, this value will be ignored anyway.
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#ifdef EMSCRIPTEN
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
    glfwWindowHint(GLFW_DECORATED, GLFW_TRUE);
    glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE);
    glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
#else
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_MAXIMIZED, mlx_settings[MLX_MAXIMIZED]);
    glfwWindowHint(GLFW_DECORATED, mlx_settings[MLX_DECORATED]);
    glfwWindowHint(GLFW_VISIBLE, !mlx_settings[MLX_HEADLESS]);
#endif
#ifdef __APPLE__
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif
    glfwWindowHint(GLFW_RESIZABLE, resize ? GLFW_TRUE : GLFW_FALSE);
    if (!(mlx->window = glfwCreateWindow(width, height, title, mlx_settings[MLX_FULLSCREEN] ? glfwGetPrimaryMonitor() : NULL, NULL)))
        return (glfwTerminate(), (void*)mlx_error(MLX_WINFAIL));
    if (!mlx_init_render(mlx) || !mlx_create_buffers(mlx))
        return (mlx_terminate(mlx), NULL);
    glfwMakeContextCurrent(mlx->window);
    return (mlx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mlx_is_key_down()

bool mlx_is_key_down	(	mlx_t *	mlx,
		keys_t	key
	)

Returns true or false if the key is down or not.

Parameters

[in]	mlx	The MLX instance handle.
[in]	key	The keycode to check, use MLX_KEY_... to specify!

Returns: True or false if the key is down or not.

Definition at line 44 of file mlx_keys.c.

{
    MLX_NONNULL(mlx);
 
    return (glfwGetKey(mlx->window, key) == GLFW_PRESS);
}

◆ mlx_is_mouse_down()

bool mlx_is_mouse_down	(	mlx_t *	mlx,
		mouse_key_t	key
	)

Checks whether a mouse button is pressed or not.

Parameters

[in]	mlx	The MLX instance handle.
[in]	key	A specific mouse key. e.g MLX_MOUSE_BUTTON_0

Returns: True or false if the mouse key is down or not.

Definition at line 76 of file mlx_mouse.c.

{
    MLX_NONNULL(mlx);
 
    return (glfwGetMouseButton(mlx->window, key) == GLFW_PRESS);
}

◆ mlx_key_hook()

void mlx_key_hook	(	mlx_t *	mlx,
		mlx_keyfunc	func,
		void *	param
	)

This function sets the key callback, which is called when a key is pressed on the keyboard. Useful for single keypress detection.

Parameters

[in]	mlx	The MLX instance handle.
[in]	func	The keypress callback function.
[in]	param	An additional optional parameter.

Definition at line 33 of file mlx_keys.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(func);
 
    mlx_ctx_t* mlxctx = mlx->context;
    mlxctx->key_hook.func = func;
    mlxctx->key_hook.param = param;
    glfwSetKeyCallback(mlx->window, mlx_key_callback);
}

Here is the call graph for this function:

◆ mlx_load_png()

mlx_texture_t * mlx_load_png ( const char * path )

Decode/load a PNG file into a buffer.

Parameters

[in] path Path to the PNG file.

Returns: If successful the texture data is returned, else NULL.

Definition at line 17 of file mlx_png.c.

{
    MLX_NONNULL(path);
 
    mlx_texture_t* image;
    if (!(image = malloc(sizeof(mlx_texture_t))))
        return ((void*)mlx_error(MLX_MEMFAIL));
 
    uint32_t error;
    image->bytes_per_pixel = BPP;
    if ((error = lodepng_decode32_file(&image->pixels, &image->width, &image->height, path)))
    {
        free(image);
        // Explicitly print error on purpose
        fprintf(stderr, "MLX42: LodePNG: %s\n", lodepng_error_text(error));
        return ((void*)mlx_error(MLX_INVPNG));
    }
    return (image);
}

Here is the call graph for this function:

◆ mlx_load_xpm42()

xpm_t * mlx_load_xpm42 ( const char * path )

Loads an XPM42 texture from the given file path.

Parameters

[in] path The file path to the XPM texture.

Returns: The XPM texture struct containing its information.

Definition at line 181 of file mlx_xpm42.c.

{
    FILE* file;
    xpm_t* xpm = NULL;
 
    MLX_NONNULL(path);
    if (!strstr(path, ".xpm42"))
        return ((void*)mlx_error(MLX_INVEXT));
    if (!(file = fopen(path, "r")))
        return ((void*)mlx_error(MLX_INVFILE));
    if (!(xpm = calloc(1, sizeof(xpm_t))))
        return ((void*)mlx_error(MLX_MEMFAIL));
    if (!mlx_read_xpm_header(xpm, file))
    {
        mlx_freen(2, xpm->texture.pixels, xpm);
        mlx_error(MLX_INVXPM);
        xpm = NULL;
    }
    fclose(file);
    return (xpm);
}

Here is the call graph for this function:

◆ mlx_loop()

void mlx_loop ( mlx_t * mlx )

Initializes the rendering of MLX, this function won't return until mlx_close_window is called, meaning it will loop until the user requests that the window should close.

Parameters

[in] mlx The MLX instance handle.

In Emscripten the lood is defined differently, there the this function is passed to the while loop instead

Definition at line 97 of file mlx_loop.c.

{
    MLX_NONNULL(mlx);
 
#ifdef EMSCRIPTEN
    static double start, oldstart = 0;
#else
    double start, oldstart = 0;
    while (!glfwWindowShouldClose(mlx->window))
    {
#endif
        start = glfwGetTime();
        mlx->delta_time = start - oldstart;
        oldstart = start;
 
        glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glfwGetWindowSize(mlx->window, &(mlx->width), &(mlx->height));
 
        if ((mlx->width > 1 || mlx->height > 1))
            mlx_update_matrix(mlx);
 
        mlx_exec_loop_hooks(mlx);
        mlx_render_images(mlx);
        mlx_flush_batch(mlx->context);
 
        glfwSwapBuffers(mlx->window);
        glfwPollEvents();
#ifndef EMSCRIPTEN
    }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mlx_loop_hook()

bool mlx_loop_hook	(	mlx_t *	mlx,
		void()(void )	f,
		void *	param
	)

Generic loop hook for any custom hooks to add to the main loop. Executes a function per frame, so be careful.

Parameters

[in]	mlx	The MLX instance handle.
[in]	f	The function.
[in]	param	The parameter to pass on to the function.

Returns: Whether or not the hook was added successfully.

Definition at line 70 of file mlx_loop.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(f);
 
    mlx_hook_t* hook;
    if (!(hook = malloc(sizeof(mlx_hook_t))))
        return (mlx_error(MLX_MEMFAIL));
 
    mlx_list_t* lst;
    if (!(lst = mlx_lstnew(hook)))
    {
        free(hook);
        return (mlx_error(MLX_MEMFAIL));
    }
    hook->func = f;
    hook->param = param;
    const mlx_ctx_t *mlxctx = mlx->context;
    mlx_lstadd_back((mlx_list_t**)(&mlxctx->hooks), lst);
    return (true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mlx_mouse_hook()

void mlx_mouse_hook	(	mlx_t *	mlx,
		mlx_mousefunc	func,
		void *	param
	)

This function sets the mouse callback, which is called when a mouse does any sort of action such as pressing a key.

Parameters

[in]	mlx	The MLX instance handle.
[in]	func	The mouse callback function.
[in]	param	An additional optional parameter.

Definition at line 54 of file mlx_mouse.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(func);
 
    mlx_ctx_t* const mlxctx = mlx->context;
    mlxctx->mouse_hook.func = func;
    mlxctx->mouse_hook.param = param;
    glfwSetMouseButtonCallback(mlx->window, mlx_mouse_cb);
}

Here is the call graph for this function:

◆ mlx_new_image()

mlx_image_t * mlx_new_image	(	mlx_t *	mlx,
		uint32_t	width,
		uint32_t	height
	)

Creates and allocates a new image buffer.

Parameters

[in]	mlx	The MLX instance handle.
[in]	width	The desired width of the image.
[in]	height	The desired height of the image.

Returns: Pointer to the image buffer, if it failed to allocate then NULL.

Definition at line 161 of file mlx_images.c.

{
    MLX_NONNULL(mlx);
 
    if (!width || !height || width > INT16_MAX || height > INT16_MAX)
        return ((void*)mlx_error(MLX_INVDIM));
 
    const mlx_ctx_t* mlxctx = mlx->context;
    mlx_image_t* newimg = calloc(1, sizeof(mlx_image_t));
    mlx_image_ctx_t* newctx = calloc(1, sizeof(mlx_image_ctx_t));
    if (!newimg || !newctx)
    {
        mlx_freen(2, newimg, newctx);
        return ((void *)mlx_error(MLX_MEMFAIL));
    }
    newimg->enabled = true;
    newimg->context = newctx;
    (*(uint32_t*)&newimg->width) = width;
    (*(uint32_t*)&newimg->height) = height;
    if (!(newimg->pixels = calloc(width * height, sizeof(int32_t))))
    {
        mlx_freen(2, newimg, newctx);
        return ((void *)mlx_error(MLX_MEMFAIL));
    }
 
    mlx_list_t* newentry;
    if (!(newentry = mlx_lstnew(newimg)))
    {
        mlx_freen(3, newimg->pixels, newimg->context, newimg);
        return ((void *)mlx_error(MLX_MEMFAIL));
    }
 
    // Generate OpenGL texture
    glGenTextures(1, &newctx->texture);
    glBindTexture(GL_TEXTURE_2D, newctx->texture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    mlx_lstadd_front((mlx_list_t**)(&mlxctx->images), newentry);
    return (newimg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mlx_put_pixel()

void mlx_put_pixel	(	mlx_image_t *	image,
		uint32_t	x,
		uint32_t	y,
		uint32_t	color
	)

Sets / puts a pixel onto an image.

NOTE: It is considered undefined behaviour when putting a pixel beyond the bounds of an image.

Parameters

[in]	image	The MLX instance handle.
[in]	x	The X coordinate position.
[in]	y	The Y coordinate position.
[in]	color	The color value to put.

Definition at line 26 of file mlx_put_pixel.c.

{
    MLX_NONNULL(image);
    MLX_ASSERT(x < image->width, "Pixel is out of bounds");
    MLX_ASSERT(y < image->height, "Pixel is out of bounds");
 
    uint8_t* pixelstart = &image->pixels[(y * image->width + x) * BPP];
    mlx_draw_pixel(pixelstart, color);
}

Here is the call graph for this function:

◆ mlx_put_string()

mlx_image_t * mlx_put_string	(	mlx_t *	mlx,
		const char *	str,
		int32_t	x,
		int32_t	y
	)

Draws a string on an image and then outputs it to the window.

Parameters

[in]	mlx	The MLX instance handle.
[in]	str	The string to draw.
[in]	x	The X location.
[in]	y	The Y location.

Returns: Image ptr to the string.

Definition at line 60 of file mlx_font.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(str);
 
    mlx_image_t* strimage;
    const size_t len = strlen(str);
    if (len > MLX_MAX_STRING)
        return ((void*)mlx_error(MLX_STRTOOBIG));   
    if (!(strimage = mlx_new_image(mlx, len * FONT_WIDTH, FONT_HEIGHT)))
        return (NULL);
 
    // Draw the text itself
    int32_t imgoffset = 0;
    for (size_t i = 0; i < len; i++, imgoffset += FONT_WIDTH)
        mlx_draw_char(strimage, mlx_get_texoffset(str[i]), imgoffset);
 
    if (mlx_image_to_window(mlx, strimage, x, y) == -1)
        return (mlx_delete_image(mlx, strimage), NULL);
    return (strimage);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mlx_resize_hook()

void mlx_resize_hook	(	mlx_t *	mlx,
		mlx_resizefunc	func,
		void *	param
	)

This function sets the resize callback, which is called when the window is resized

Parameters

[in]	mlx	The MLX instance handle.
[in]	func	The resize callback function.
[in]	param	An additional optional parameter.

Definition at line 74 of file mlx_window.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(func);
 
    mlx_ctx_t* mlxctx = mlx->context;
    mlxctx->resize_hook.func = func;
    mlxctx->resize_hook.param = param;
    glfwSetWindowSizeCallback(mlx->window, mlx_resize_callback);
}

Here is the call graph for this function:

◆ mlx_resize_image()

bool mlx_resize_image	(	mlx_image_t *	img,
		uint32_t	nwidth,
		uint32_t	nheight
	)

Allows you to resize an image, a new pixel buffer is allocated to fit & the previous data is scaled to fit the new size.

Parameters

[in]	img	The image to resize.
[in]	nwidth	The new width.
[in]	nheight	The new height.

Returns: True if image was resized or false on error.

Definition at line 224 of file mlx_images.c.

{
    MLX_NONNULL(img);
 
    if (!nwidth || !nheight || nwidth > INT16_MAX || nheight > INT16_MAX)
        return (mlx_error(MLX_INVDIM));
    if (nwidth != img->width || nheight != img->height)
    {
        uint32_t* origin = (uint32_t*)img->pixels;
        float wstep = (float)img->width / nwidth;
        float hstep = (float)img->height / nheight;
 
        uint8_t* tempbuff = calloc(nwidth * nheight, BPP);
        if (!tempbuff)
            return (mlx_error(MLX_MEMFAIL));
        img->pixels = tempbuff;
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, nwidth, nheight, 0, GL_RGBA, GL_UNSIGNED_BYTE, img->pixels);
 
        uint32_t* destin = (uint32_t*)img->pixels;
        for (uint32_t j = 0; j < nheight; j++)
            for (uint32_t i = 0; i < nwidth; i++)
                destin[j * nwidth + i] = origin[(uint32_t)(j * hstep) * img->width + (uint32_t)(i * wstep)];
        (*(uint32_t*)&img->width) = nwidth;
        (*(uint32_t*)&img->height) = nheight;
        free(origin);
    }
    return (true);
}

Here is the call graph for this function:

◆ mlx_scroll_hook()

void mlx_scroll_hook	(	mlx_t *	mlx,
		mlx_scrollfunc	func,
		void *	param
	)

This function sets the scroll callback, which is called when a scrolling device is used, such as a mouse wheel.

Parameters

[in]	mlx	The MLX instance handle.
[in]	func	The scroll wheel callback function.
[in]	param	An additional optional parameter.

Definition at line 43 of file mlx_mouse.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(func);
 
    mlx_ctx_t* const mlxctx = mlx->context;
    mlxctx->scroll_hook.func = func;
    mlxctx->scroll_hook.param = param;
    glfwSetScrollCallback(mlx->window, mlx_scroll_cb);
}

Here is the call graph for this function:

◆ mlx_set_cursor()

void mlx_set_cursor	(	mlx_t *	mlx,
		mlx_win_cursor_t *	cursor
	)

Sets the current cursor to the given custom cursor.

Parameters

[in]	mlx	The MLX instance handle.
[in]	cursor	The cursor object to display, if null default cursor is selected.

Definition at line 50 of file mlx_cursor.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(cursor);
 
    glfwSetCursor(mlx->window, cursor);
}

◆ mlx_set_cursor_mode()

void mlx_set_cursor_mode	(	mlx_t *	mlx,
		mouse_mode_t	mode
	)

Defines the state for the cursor.

Parameters

[in]	mlx	The MLX instance handle.
[in]	mode	A specified mouse mode.

Definition at line 58 of file mlx_cursor.c.

{
    MLX_NONNULL(mlx);
 
    glfwSetInputMode(mlx->window, GLFW_CURSOR, mode);
}

◆ mlx_set_icon()

void mlx_set_icon	(	mlx_t *	mlx,
		mlx_texture_t *	image
	)

Lets you set a custom image as the program icon.

NOTE: In MacOS this function does nothing, you should use the bundles icon to set the dock bar icon.

See also: : https://9to5mac.com/2021/11/08/change-mac-icons/; : https://github.com/glfw/glfw/issues/2041

Parameters

[in]	mlx	The MLX instance handle.
[in]	image	The image to use as icon.

Definition at line 85 of file mlx_window.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(image);
 
    const GLFWimage icon = {
        .width = image->width,
        .height = image->height,
        .pixels = image->pixels
    };
 
    glfwSetWindowIcon(mlx->window, 1, &icon);
}

◆ mlx_set_instance_depth()

void mlx_set_instance_depth	(	mlx_instance_t *	instance,
		int32_t	zdepth
	)

Sets the depth / Z axis value of an instance.

NOTE: Keep in mind that images that are on the same Z layer cut each other off. so if you don't see your image anymore make sure it's not conflicting by being on the same layer as another image.

Parameters

[in]	instance	The instance on which to change the depth.
[in]	zdepth	The new depth value.

NOTE: The reason why we don't sort directly is that the user might call this function multiple times in a row and we don't want to sort for every change. Pre-loop wise that is.

Definition at line 105 of file mlx_images.c.

{
    MLX_NONNULL(instance);
 
    if (instance->z == zdepth)
        return;
    instance->z = zdepth;
 
    /**
     * NOTE: The reason why we don't sort directly is that
     * the user might call this function multiple times in a row and we don't
     * want to sort for every change. Pre-loop wise that is.
     */
    sort_queue = true;
}

◆ mlx_set_mouse_pos()

void mlx_set_mouse_pos	(	mlx_t *	mlx,
		int32_t	x,
		int32_t	y
	)

Sets the mouse position.

Parameters

[in]	mlx	The MLX instance handle.
[in]	pos	The position.

Definition at line 83 of file mlx_mouse.c.

{
    MLX_NONNULL(mlx);
 
    glfwSetCursorPos(mlx->window, (double)x, (double)y);
}

◆ mlx_set_setting()

void mlx_set_setting	(	mlx_settings_t	setting,
		int32_t	value
	)

Set a setting for MLX42. Settings can manipulate the core behaviour of the engine.

Parameters

[in]	setting	The settings value, See mlx_settings_t type.
[in]	value	Settings value to determine the state of the setting. Can be a boolean or an enum / macro.

Definition at line 213 of file mlx_init.c.

{
    MLX_ASSERT(setting >= 0 && setting < MLX_SETTINGS_MAX, "Invalid settings value");
    mlx_settings[setting] = value;
}

Here is the caller graph for this function:

◆ mlx_set_window_limit()

void mlx_set_window_limit	(	mlx_t *	mlx,
		int32_t	min_w,
		int32_t	min_h,
		int32_t	max_w,
		int32_t	max_h
	)

Sets the size limits of the specified window. Will force the window to not be resizable past or below the given values.

Pass -1 for no limit to any of the min/max parameters to ignore that boundary. For instance if you want a min window size but the max window size can be whatever.

Parameters

[in]	mlx	The MLX instance handle.
[in]	min_w	The min width of the window.
[in]	max_w	The max width of the window.
[in]	min_h	The min height of the window.
[in]	max_h	The max height of the window.

Definition at line 124 of file mlx_window.c.

{
    MLX_NONNULL(mlx);
 
    glfwSetWindowSizeLimits(mlx->window, min_w, min_h, max_w, max_h);
}

◆ mlx_set_window_pos()

void mlx_set_window_pos	(	mlx_t *	mlx,
		int32_t	xpos,
		int32_t	ypos
	)

Sets the window's position.

Do not use this function to move an already visible window unless you have very good reasons for doing so, as it will confuse and annoy the user.

Parameters

[in]	mlx	The MLX instance handle.
[in]	xpos	The x position.
[in]	ypos	The y position.

Definition at line 99 of file mlx_window.c.

{
    MLX_NONNULL(mlx);
 
    glfwSetWindowPos(mlx->window, xpos, ypos);
}

◆ mlx_set_window_size()

void mlx_set_window_size	(	mlx_t *	mlx,
		int32_t	new_width,
		int32_t	new_height
	)

Changes the window size to the newly specified values. Use this to update the window width and height values in the mlx handle.

Parameters

[in]	mlx	The MLX instance handle.
[in]	new_width	The new desired width.
[in]	new_height	The new desired height.

Definition at line 115 of file mlx_window.c.

{
    MLX_NONNULL(mlx);
 
    mlx->width = new_width;
    mlx->height = new_height;
    glfwSetWindowSize(mlx->window, new_width, new_height);
}

◆ mlx_set_window_title()

void mlx_set_window_title	(	mlx_t *	mlx,
		const char *	title
	)

Sets the title of the window.

Parameters

[in]	mlx	The MLX instance handle.
[in]	title	The window title.

Definition at line 131 of file mlx_window.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(title);
 
    glfwSetWindowTitle(mlx->window, title);
}

◆ mlx_strerror()

const char * mlx_strerror ( mlx_errno_t val )

Gets the english description of the error code.

Parameters

[in] val The error code.

Returns: The error string that describes the error code.

Definition at line 54 of file mlx_error.c.

{
    MLX_ASSERT(val >= 0, "Index must be positive");
    MLX_ASSERT(val < MLX_ERRMAX, "Index out of bounds");
 
    return (mlx_errors[val]);
}

Here is the caller graph for this function:

◆ mlx_terminate()

void mlx_terminate ( mlx_t * mlx )

Terminates MLX and cleans up any of its used resources. Using any functions that require mlx afterwards will be considered undefined behaviour, beware of segfaults.

Parameters

[in] mlx The MLX instance handle.

All of glfw & glads resources are cleaned up by the terminate function. Now it's time to clean up our own mess.

Definition at line 36 of file mlx_exit.c.

{
    MLX_NONNULL(mlx);
 
    mlx_ctx_t *const mlxctx = mlx->context;
 
    glUseProgram(0);
    glLinkProgram(mlxctx->shaderprogram);
    glDeleteProgram(mlxctx->shaderprogram);
    glfwTerminate();
    mlx_lstclear((mlx_list_t**)(&mlxctx->hooks), &free);
    mlx_lstclear((mlx_list_t**)(&mlxctx->render_queue), &free);
    mlx_lstclear((mlx_list_t**)(&mlxctx->images), &mlx_free_image);
    mlx_freen(2, mlxctx, mlx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mlx_texture_to_image()

mlx_image_t * mlx_texture_to_image	(	mlx_t *	mlx,
		mlx_texture_t *	texture
	)

Converts a given texture to an image.

Parameters

[in]	mlx	The MLX instance handle.
[in]	texture	The texture to use to create the image from.

Returns: mlx_image_t* The image created from the texture.

Definition at line 17 of file mlx_texture.c.

{
    MLX_NONNULL(mlx);
    MLX_NONNULL(texture);
 
    mlx_image_t* image = mlx_new_image(mlx, texture->width, texture->height);
    if (image == NULL)
        return (NULL);
 
    uint8_t* pixelx;
    uint8_t* pixeli;
    for (uint32_t i = 0; i < texture->height; i++)
    {
        pixelx = &texture->pixels[(i * texture->width) * texture->bytes_per_pixel];
        pixeli = &image->pixels[(i * image->width) * texture->bytes_per_pixel];
        memmove(pixeli, pixelx, texture->width * texture->bytes_per_pixel);
    }
    return (image);
}

Here is the call graph for this function:

Variable Documentation

◆ mlx_errno

mlx_errno_t mlx_errno

extern

Definition at line 161 of file mlx_init.c.

Data Structures

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ action_t

◆ cursor_t

◆ keys_t

◆ mlx_closefunc

◆ mlx_cursorfunc

◆ mlx_errno_t

◆ mlx_image_t

◆ mlx_instance_t

◆ mlx_key_data_t

◆ mlx_keyfunc

◆ mlx_mousefunc

◆ mlx_resizefunc

◆ mlx_scrollfunc

◆ mlx_settings_t

◆ mlx_t

◆ mlx_texture_t

◆ mlx_win_cursor_t

◆ modifier_key_t

◆ mouse_key_t

◆ mouse_mode_t

◆ xpm_t

Enumeration Type Documentation

◆ action

◆ cursor

◆ keys

◆ mlx_errno

◆ mlx_settings

◆ modifier_key

◆ mouse_key

◆ mouse_mode

Function Documentation

◆ mlx_close_hook()

◆ mlx_close_window()

◆ mlx_create_cursor()

◆ mlx_create_std_cursor()

◆ mlx_cursor_hook()

◆ mlx_delete_image()

◆ mlx_delete_texture()

◆ mlx_delete_xpm42()

◆ mlx_destroy_cursor()

◆ mlx_focus()

◆ mlx_get_font()

◆ mlx_get_monitor_size()

◆ mlx_get_mouse_pos()

◆ mlx_get_texoffset()

◆ mlx_get_time()

◆ mlx_get_window_pos()

◆ mlx_image_to_window()

◆ mlx_init()

◆ mlx_is_key_down()

◆ mlx_is_mouse_down()

◆ mlx_key_hook()

◆ mlx_load_png()

◆ mlx_load_xpm42()

◆ mlx_loop()

◆ mlx_loop_hook()

◆ mlx_mouse_hook()

◆ mlx_new_image()

◆ mlx_put_pixel()

◆ mlx_put_string()

◆ mlx_resize_hook()

◆ mlx_resize_image()

◆ mlx_scroll_hook()

◆ mlx_set_cursor()

◆ mlx_set_cursor_mode()

◆ mlx_set_icon()

◆ mlx_set_instance_depth()

◆ mlx_set_mouse_pos()

◆ mlx_set_setting()

◆ mlx_set_window_limit()

◆ mlx_set_window_pos()

◆ mlx_set_window_size()

◆ mlx_set_window_title()

◆ mlx_strerror()