package core:sys/orca

Source

arena :: struct {
	// An allocator providing memory pages from the system
	base:         ^base_allocator,
	// A list of `oc_arena_chunk` chunks.
	chunks:       list,
	// The chunk new memory allocations are pulled from.
	currentChunk: ^arena_chunk,
}

arena_chunk :: struct {
	listElt:   list_elt,
	ptr:       cstring,
	offset:    u64,
	committed: u64,
	cap:       u64,
}

arena_options :: struct {
	// The base allocator to use with this arena
	base:    ^base_allocator,
	// The amount of memory to reserve up-front when creating the arena.
	reserve: u64,
}

arena_scope :: struct {
	// The arena which offset is stored.
	arena:  ^arena,
	// The arena chunk to which the offset belongs.
	chunk:  ^arena_chunk,
	// The offset to rewind the arena to.
	offset: u64,
}

base_allocator :: struct {
	// A procedure to reserve memory from the system.
	reserve:  mem_reserve_proc,
	// A procedure to commit memory from the system.
	commit:   mem_modify_proc,
	// A procedure to decommit memory from the system.
	decommit: mem_modify_proc,
	// A procedure to release memory previously reserved from the system.
	release:  mem_modify_proc,
}

canvas_context :: distinct u64

canvas_renderer :: distinct u64

cap_type :: enum u32 {
	NONE   = 0, 
	SQUARE = 1, 
}

char :: u8

char_event :: struct {
	// The unicode codepoint of the character.
	codepoint: rune,
	// The utf8 sequence of the character.
	sequence:  [8]u8,
	// The utf8 sequence length.
	seqLen:    u8,
}

clipboard_state :: struct {
	lastUpdate: u64,
	pastedText: string,
}

clock_kind :: enum i32 {
	MONOTONIC, 
	UPTIME, 
	DATE, 
}

color :: struct {
	using c:    [4]f32,
	colorSpace: color_space,
}

color_space :: enum u32 {
	RGB  = 0, 
	SRGB = 1, 
}

datestamp :: struct {
	seconds:  i64,
	fraction: u64,
}

event :: struct {
	// The window in which this event happened.
	window: window,
	// The type of the event. This determines which member of the event union is active.
	type:   event_type,
	using _: struct #raw_union {
		key:       key_event,
		character: char_event,
		mouse:     mouse_event,
		move:      move_event,
		paths:     str8_list,
	},
}

event_type :: enum u32 {
	// No event. That could be used simply to wake up the application.
	NONE            = 0, 
	// A modifier key event. This event is sent when a key such as <kbd>Alt</kbd>, <kbd>Control</kbd>, <kbd>Command</kbd> or <kbd>Shift</kbd> are pressed, released, or repeated. The `key` field contains the event's details.
	KEYBOARD_MODS   = 1, 
	// A key event. This event is sent when a normal key is pressed, released, or repeated. The `key` field contains the event's details.
	KEYBOARD_KEY    = 2, 
	// A character input event. This event is sent when an input character is produced by the keyboard. The `character` field contains the event's details.
	KEYBOARD_CHAR   = 3, 
	// A mouse button event. This is event sent when one of the mouse buttons is pressed, released, or clicked. The `key` field contains the event's details.
	MOUSE_BUTTON    = 4, 
	// A mouse move event. This is event sent when the mouse is moved. The `mouse` field contains the event's details.
	MOUSE_MOVE      = 5, 
	// A mouse wheel event. This is event sent when the mouse wheel is moved (or when a trackpad is scrolled). The `mouse` field contains the event's details.
	MOUSE_WHEEL     = 6, 
	// A mouse enter event. This event is sent when the mouse enters the application's window. The `mouse` field contains the event's details.
	MOUSE_ENTER     = 7, 
	// A mouse leave event. This event is sent when the mouse leaves the application's window.
	MOUSE_LEAVE     = 8, 
	// A clipboard paste event. This event is sent when the user uses the paste shortcut while the application window has focus.
	CLIPBOARD_PASTE = 9, 
	// A resize event. This event is sent when the application's window is resized. The `move` field contains the event's details.
	WINDOW_RESIZE   = 10, 
	// A move event. This event is sent when the window is moved. The `move` field contains the event's details.
	WINDOW_MOVE     = 11, 
	// A focus event. This event is sent when the application gains focus.
	WINDOW_FOCUS    = 12, 
	// An unfocus event. This event is sent when the application looses focus.
	WINDOW_UNFOCUS  = 13, 
	// A hide event. This event is sent when the application's window is hidden or minimized.
	WINDOW_HIDE     = 14, 
	// A show event. This event is sent when the application's window is shown or de-minimized.
	WINDOW_SHOW     = 15, 
	// A close event. This event is sent when the window is about to be closed.
	WINDOW_CLOSE    = 16, 
	// A path drop event. This event is sent when the user drops files onto the application's window. The `paths` field contains the event's details.
	PATHDROP        = 17, 
	// A frame event. This event is sent when the application should render a frame.
	FRAME           = 18, 
	// A quit event. This event is sent when the application has been requested to quit.
	QUIT            = 19, 
}

file :: distinct u64

file_access :: bit_set[file_access_flag; u16]

file_access_flag :: enum u16 {
	// The file handle can be used for reading from the file.
	READ  = 1, 
	// The file handle can be used for writing to the file.
	WRITE, 
}

file_dialog_button :: enum u32 {
	// The user clicked the "Cancel" button, or closed the dialog box.
	CANCEL = 0, 
	// The user clicked the "OK" button.
	OK     = 1, 
}

file_dialog_desc :: struct {
	// The kind of file dialog, see `oc_file_dialog_kind`.
	kind:      file_dialog_kind,
	// A combination of file dialog flags used to enable file dialog options.
	flags:     bit_set[file_dialog_flag; u32],
	// The title of the dialog, displayed in the dialog title bar.
	title:     string,
	// Optional. The label of the OK button, e.g. "Save" or "Open".
	okLabel:   string,
	// Optional. A file handle to the root directory for the dialog. If set to zero, the root directory is the application's default data directory.
	startAt:   file,
	// Optional. The path of the starting directory of the dialog, relative to its root directory. If set to nil, the dialog starts at its root directory.
	startPath: string,
	// A list of file extensions used to restrict which files can be selected in this dialog. An empty list allows all files to be selected. Extensions should be provided without a leading dot.
	filters:   str8_list,
}

file_dialog_flag :: enum u32 {
	// This dialog allows selecting files.
	FILES              = 1, 
	// This dialog allows selecting directories.
	DIRECTORIES, 
	// This dialog allows selecting multiple items.
	MULTIPLE, 
	// This dialog allows creating directories.
	CREATE_DIRECTORIES, 
}

file_dialog_flags :: bit_set[file_dialog_flag; u32]

file_dialog_kind :: enum u32 {
	// The file dialog is a save dialog.
	SAVE = 0, 
	// The file dialog is an open dialog.
	OPEN = 1, 
}

file_dialog_result :: struct {
	// The button clicked by the user.
	button:    file_dialog_button,
	// The path that was selected when the user clicked the OK button. If the dialog box had the `OC_FILE_DIALOG_MULTIPLE` flag set, this is the first file of the list of selected paths.
	path:      string,
	// If the dialog box had the `OC_FILE_DIALOG_MULTIPLE` flag set and the user clicked the OK button, this list contains the selected paths.
	selection: str8_list,
}

file_open_flag :: enum u16 {
	// Open the file in 'append' mode. All writes append data at the end of the file.
	APPEND    = 1, 
	// Truncate the file to 0 bytes when opening.
	TRUNCATE, 
	// Create the file if it does not exist.
	CREATE, 
	// If the file is a symlink, open the symlink itself instead of following it.
	SYMLINK, 
	// If the file is a symlink, the call to open will fail.
	NO_FOLLOW, 
	// Reserved.
	RESTRICT, 
}

file_open_flags :: bit_set[file_open_flag; u16]

file_open_with_dialog_elt :: struct {
	listElt: list_elt,
	file:    file,
}

file_open_with_dialog_result :: struct {
	// The button of the file dialog clicked by the user.
	button:    file_dialog_button,
	// The file that was opened through the dialog. If the dialog had the `OC_FILE_DIALOG_MULTIPLE` flag set, this is equal to the first handle in the `selection` list.
	file:      file,
	// If the dialog had the `OC_FILE_DIALOG_MULTIPLE` flag set, this list of `oc_file_open_with_dialog_elt` contains the handles of the opened files.
	selection: list,
}

file_perm :: bit_set[file_perm_flag; u16]

file_perm_flag :: enum u16 {
	OTHER_EXEC  = 1, 
	OTHER_WRITE, 
	OTHER_READ, 
	GROUP_EXEC, 
	GROUP_WRITE, 
	GROUP_READ, 
	OWNER_EXEC, 
	OWNER_WRITE, 
	OWNER_READ, 
	STICKY_BIT, 
	SET_GID, 
	SET_UID, 
}

file_status :: struct {
	uid:              u64,
	type:             file_type,
	perm:             bit_set[file_perm_flag; u16],
	size:             u64,
	creationDate:     datestamp,
	accessDate:       datestamp,
	modificationDate: datestamp,
}

file_type :: enum u32 {
	// The file is of unknown type.
	UNKNOWN   = 0, 
	// The file is a regular file.
	REGULAR   = 1, 
	// The file is a directory.
	DIRECTORY = 2, 
	// The file is a symbolic link.
	SYMLINK   = 3, 
	// The file is a block device.
	BLOCK     = 4, 
	// The file is a character device.
	CHARACTER = 5, 
	// The file is a FIFO pipe.
	FIFO      = 6, 
	// The file is a socket.
	SOCKET    = 7, 
}

file_whence :: enum u32 {
	// Set the file position relative to the beginning of the file.
	SET     = 0, 
	// Set the file position relative to the end of the file.
	END     = 1, 
	// Set the file position relative to the current position.
	CURRENT = 2, 
}

font :: distinct u64

font_metrics :: struct {
	ascent:    f32,
	descent:   f32,
	lineGap:   f32,
	xHeight:   f32,
	capHeight: f32,
	width:     f32,
}

glyph_metrics :: struct {
	ink:     rect,
	advance: [2]f32,
}

gradient_blend_space :: enum u32 {
	LINEAR = 0, 
	SRGB   = 1, 
}

image :: distinct u64

image_region :: struct {
	image: image,
	rect:  rect,
}

input_state :: struct {
	frameCounter: u64,
	keyboard:     keyboard_state,
	mouse:        mouse_state,
	text:         text_state,
	clipboard:    clipboard_state,
}

io_cmp :: struct {
	// The request ID as passed in the `oc_io_req` request that generated this completion.
	id:    u64,
	// The error value for the operation.
	error: io_error,
	using _: struct #raw_union {
		result: i64,
		size:   u64,
		offset: i64,
		handle: file,
	},
}

io_error :: enum u32 {
	// No error.
	OK          = 0, 
	// An unexpected error happened.
	UNKNOWN     = 1, 
	// The request had an invalid operation.
	OP          = 2, 
	// The request had an invalid handle.
	HANDLE      = 3, 
	// The operation was not carried out because the file handle has previous errors.
	PREV        = 4, 
	// The request contained wrong arguments.
	ARG         = 5, 
	// The operation requires permissions that the file handle doesn't have.
	PERM        = 6, 
	// The operation couldn't complete due to a lack of space in the result buffer.
	SPACE       = 7, 
	// One of the directory in the path does not exist or couldn't be traversed.
	NO_ENTRY    = 8, 
	// The file already exists.
	EXISTS      = 9, 
	// The file is not a directory.
	NOT_DIR     = 10, 
	// The file is a directory.
	DIR         = 11, 
	// There are too many opened files.
	MAX_FILES   = 12, 
	// The path contains too many symbolic links (this may be indicative of a symlink loop).
	MAX_LINKS   = 13, 
	// The path is too long.
	PATH_LENGTH = 14, 
	// The file is too large.
	FILE_SIZE   = 15, 
	// The file is too large to be opened.
	OVERFLOW    = 16, 
	// The file is locked or the device on which it is stored is not ready.
	NOT_READY   = 17, 
	// The system is out of memory.
	MEM         = 18, 
	// The operation was interrupted by a signal.
	INTERRUPT   = 19, 
	// A physical error happened.
	PHYSICAL    = 20, 
	// The device on which the file is stored was not found.
	NO_DEVICE   = 21, 
	// One element along the path is outside the root directory subtree.
	WALKOUT     = 22, 
}

io_op :: enum u32 {
	// ['Open a file at a path relative to a given root directory.', '', "    - `handle` is the handle to the root directory. If it is nil, the application's default directory is used.", '    - `size` is the size of the path, in bytes.', '    - `buffer` points to an array containing the path of the file to open, relative to the directory identified by `handle`.', '    - `open` contains the permissions and flags for the open operation.']
	OPEN_AT        = 0, 
	// ['Close a file handle.', '', '    - `handle` is the handle to close.']
	CLOSE          = 1, 
	// ['Get status information for a file handle.', '', '    - `handle` is the handle to stat.', '    - `size` is the size of the result buffer. It should be at least `sizeof(oc_file_status)`.', '    - `buffer` is the result buffer.']
	FSTAT          = 2, 
	// ['Move the file position in a file.', '', '    - `handle` is the handle of the file.', '    - `offset` specifies the offset of the new position, relative to the base position specified by `whence`.', '    - `whence` determines the base position for the seek operation.']
	SEEK           = 3, 
	// ['Read data from a file.', '', '    - `handle` is the handle of the file.', '    - `size` is the number of bytes to read.', '    - `buffer` is the result buffer. It should be big enough to hold `size` bytes.']
	READ           = 4, 
	// ['Write data to a file.', '', '    - `handle` is the handle of the file.', '    - `size` is the number of bytes to write.', '    - `buffer` contains the data to write to the file.']
	WRITE          = 5, 
	// ['Get the error attached to a file handle.', '', '    - `handle` is the handle of the file.']
	OC_OC_IO_ERROR = 6, 
}

io_req :: struct {
	// An identifier for the request. You can set this to any value you want. It is passed back in the `oc_io_cmp` completion and can be used to match requests and completions.
	id:     u64,
	// The requested operation.
	op:     io_op,
	// A file handle used by some operations.
	handle: file,
	// An offset used by some operations.
	offset: i64,
	// A size indicating the capacity of the buffer pointed to by `buffer`, in bytes.
	size:   u64,
	using _: struct #raw_union {
		buffer: [^]u8,
		unused: u64,
	},
	using _: struct #raw_union {
		open:   struct {
			// The access permissions requested on the file to open.
			rights: bit_set[file_access_flag; u16],
			// The options to use when opening the file.
			flags:  bit_set[file_open_flag; u16],
		},
		whence: file_whence,
	},
}

io_req_id :: u64

joint_type :: enum u32 {
	MITER = 0, 
	BEVEL = 1, 
	NONE  = 2, 
}

key_action :: enum u32 {
	// No action happened on that key.
	NO_ACTION = 0, 
	// The key was pressed.
	PRESS     = 1, 
	// The key was released.
	RELEASE   = 2, 
	// The key was maintained pressed at least for the system's key repeat period.
	REPEAT    = 3, 
}

key_code :: enum u32 {
	UNKNOWN       = 0, 
	SPACE         = 32, 
	APOSTROPHE    = 39, 
	COMMA         = 44, 
	MINUS         = 45, 
	PERIOD        = 46, 
	SLASH         = 47, 
	_0            = 48, 
	_1            = 49, 
	_2            = 50, 
	_3            = 51, 
	_4            = 52, 
	_5            = 53, 
	_6            = 54, 
	_7            = 55, 
	_8            = 56, 
	_9            = 57, 
	SEMICOLON     = 59, 
	EQUAL         = 61, 
	LEFT_BRACKET  = 91, 
	BACKSLASH     = 92, 
	RIGHT_BRACKET = 93, 
	GRAVE_ACCENT  = 96, 
	A             = 97, 
	B             = 98, 
	C             = 99, 
	D             = 100, 
	E             = 101, 
	F             = 102, 
	G             = 103, 
	H             = 104, 
	I             = 105, 
	J             = 106, 
	K             = 107, 
	L             = 108, 
	M             = 109, 
	N             = 110, 
	O             = 111, 
	P             = 112, 
	Q             = 113, 
	R             = 114, 
	S             = 115, 
	T             = 116, 
	U             = 117, 
	V             = 118, 
	W             = 119, 
	X             = 120, 
	Y             = 121, 
	Z             = 122, 
	WORLD_1       = 161, 
	WORLD_2       = 162, 
	ESCAPE        = 256, 
	ENTER         = 257, 
	TAB           = 258, 
	BACKSPACE     = 259, 
	INSERT        = 260, 
	DELETE        = 261, 
	RIGHT         = 262, 
	LEFT          = 263, 
	DOWN          = 264, 
	UP            = 265, 
	PAGE_UP       = 266, 
	PAGE_DOWN     = 267, 
	HOME          = 268, 
	END           = 269, 
	CAPS_LOCK     = 280, 
	SCROLL_LOCK   = 281, 
	NUM_LOCK      = 282, 
	PRINT_SCREEN  = 283, 
	PAUSE         = 284, 
	F1            = 290, 
	F2            = 291, 
	F3            = 292, 
	F4            = 293, 
	F5            = 294, 
	F6            = 295, 
	F7            = 296, 
	F8            = 297, 
	F9            = 298, 
	F10           = 299, 
	F11           = 300, 
	F12           = 301, 
	F13           = 302, 
	F14           = 303, 
	F15           = 304, 
	F16           = 305, 
	F17           = 306, 
	F18           = 307, 
	F19           = 308, 
	F20           = 309, 
	F21           = 310, 
	F22           = 311, 
	F23           = 312, 
	F24           = 313, 
	F25           = 314, 
	KP_0          = 320, 
	KP_1          = 321, 
	KP_2          = 322, 
	KP_3          = 323, 
	KP_4          = 324, 
	KP_5          = 325, 
	KP_6          = 326, 
	KP_7          = 327, 
	KP_8          = 328, 
	KP_9          = 329, 
	KP_DECIMAL    = 330, 
	KP_DIVIDE     = 331, 
	KP_MULTIPLY   = 332, 
	KP_SUBTRACT   = 333, 
	KP_ADD        = 334, 
	KP_ENTER      = 335, 
	KP_EQUAL      = 336, 
	LEFT_SHIFT    = 340, 
	LEFT_CONTROL  = 341, 
	LEFT_ALT      = 342, 
	LEFT_SUPER    = 343, 
	RIGHT_SHIFT   = 344, 
	RIGHT_CONTROL = 345, 
	RIGHT_ALT     = 346, 
	RIGHT_SUPER   = 347, 
	MENU          = 348, 
	COUNT         = 349, 
}

key_event :: struct {
	// The action that was done on the key.
	action:     key_action,
	// The scan code of the key. Only valid for key events.
	scanCode:   scan_code,
	// The key code of the key. Only valid for key events.
	keyCode:    key_code,
	// The button of the mouse. Only valid for mouse button events.
	button:     mouse_button,
	// Modifier flags indicating which modifier keys where pressed at the time of the event.
	mods:       bit_set[keymod_flag; u32],
	// The number of clicks that where detected for the button. Only valid for mouse button events.
	clickCount: u8,
}

key_state :: struct {
	lastUpdate:       u64,
	transitionCount:  u32,
	repeatCount:      u32,
	down:             bool,
	sysClicked:       bool,
	sysDoubleClicked: bool,
	sysTripleClicked: bool,
}

keyboard_state :: struct {
	keys: [349]key_state,
	mods: bit_set[keymod_flag; u32],
}

keymod_flag :: enum u32 {
	ALT           = 0, 
	SHIFT, 
	CTRL, 
	CMD, 
	MAIN_MODIFIER, 
}

keymod_flags :: bit_set[keymod_flag; u32]

list :: struct {
	// Points to the first element in the list.
	first: ^list_elt,
	// Points to the last element in the list.
	last:  ^list_elt,
}

list_elt :: struct {
	// Points to the previous element in the list.
	prev: ^list_elt,
	// Points to the next element in the list.
	next: ^list_elt,
}

log_level :: enum u32 {
	// Only errors are logged.
	ERROR   = 0, 
	// Only warnings and errors are logged.
	WARNING = 1, 
	// All messages are logged.
	INFO    = 2, 
	COUNT   = 3, 
}

mat2x3 :: [6]f32

mem_modify_proc :: proc "c" (_context: ^base_allocator, ptr: rawptr, size: u64)

mem_reserve_proc :: proc "c" (_context: ^base_allocator, size: u64) -> rawptr

mouse_button :: enum u32 {
	LEFT         = 0, 
	RIGHT        = 1, 
	MIDDLE       = 2, 
	EXT1         = 3, 
	EXT2         = 4, 
	BUTTON_COUNT = 5, 
}

mouse_event :: struct {
	// The x coordinate of the mouse.
	x:      f32,
	// The y coordinate of the mouse.
	y:      f32,
	// The delta from the last x coordinate of the mouse, or the scroll value along the x coordinate.
	deltaX: f32,
	// The delta from the last y coordinate of the mouse, or the scoll value along the y  coordinate.
	deltaY: f32,
	// Modifier flags indicating which modifier keys where pressed at the time of the event.
	mods:   bit_set[keymod_flag; u32],
}

mouse_state :: struct {
	lastUpdate: u64,
	posValid:   bool,
	pos:        [2]f32,
	delta:      [2]f32,
	wheel:      [2]f32,
	using _:    struct #raw_union {
		buttons: [5]key_state,
		using _: struct {
			left:   key_state,
			right:  key_state,
			middle: key_state,
			ext1:   key_state,
			ext2:   key_state,
		},
	},
}

move_event :: struct {
	// The position and dimension of the frame rectangle, i.e. including the window title bar and border.
	frame:   rect,
	// The position and dimension of the content rectangle, relative to the frame rectangle.
	content: rect,
}

pool :: struct {
	arena:     arena,
	freeList:  list,
	blockSize: u64,
}

rect :: struct {
	x: f32,
	y: f32,
	w: f32,
	h: f32,
}

rect_atlas :: struct {}

scan_code :: enum u32 {
	UNKNOWN       = 0, 
	SPACE         = 32, 
	APOSTROPHE    = 39, 
	COMMA         = 44, 
	MINUS         = 45, 
	PERIOD        = 46, 
	SLASH         = 47, 
	_0            = 48, 
	_1            = 49, 
	_2            = 50, 
	_3            = 51, 
	_4            = 52, 
	_5            = 53, 
	_6            = 54, 
	_7            = 55, 
	_8            = 56, 
	_9            = 57, 
	SEMICOLON     = 59, 
	EQUAL         = 61, 
	LEFT_BRACKET  = 91, 
	BACKSLASH     = 92, 
	RIGHT_BRACKET = 93, 
	GRAVE_ACCENT  = 96, 
	A             = 97, 
	B             = 98, 
	C             = 99, 
	D             = 100, 
	E             = 101, 
	F             = 102, 
	G             = 103, 
	H             = 104, 
	I             = 105, 
	J             = 106, 
	K             = 107, 
	L             = 108, 
	M             = 109, 
	N             = 110, 
	O             = 111, 
	P             = 112, 
	Q             = 113, 
	R             = 114, 
	S             = 115, 
	T             = 116, 
	U             = 117, 
	V             = 118, 
	W             = 119, 
	X             = 120, 
	Y             = 121, 
	Z             = 122, 
	WORLD_1       = 161, 
	WORLD_2       = 162, 
	ESCAPE        = 256, 
	ENTER         = 257, 
	TAB           = 258, 
	BACKSPACE     = 259, 
	INSERT        = 260, 
	DELETE        = 261, 
	RIGHT         = 262, 
	LEFT          = 263, 
	DOWN          = 264, 
	UP            = 265, 
	PAGE_UP       = 266, 
	PAGE_DOWN     = 267, 
	HOME          = 268, 
	END           = 269, 
	CAPS_LOCK     = 280, 
	SCROLL_LOCK   = 281, 
	NUM_LOCK      = 282, 
	PRINT_SCREEN  = 283, 
	PAUSE         = 284, 
	F1            = 290, 
	F2            = 291, 
	F3            = 292, 
	F4            = 293, 
	F5            = 294, 
	F6            = 295, 
	F7            = 296, 
	F8            = 297, 
	F9            = 298, 
	F10           = 299, 
	F11           = 300, 
	F12           = 301, 
	F13           = 302, 
	F14           = 303, 
	F15           = 304, 
	F16           = 305, 
	F17           = 306, 
	F18           = 307, 
	F19           = 308, 
	F20           = 309, 
	F21           = 310, 
	F22           = 311, 
	F23           = 312, 
	F24           = 313, 
	F25           = 314, 
	KP_0          = 320, 
	KP_1          = 321, 
	KP_2          = 322, 
	KP_3          = 323, 
	KP_4          = 324, 
	KP_5          = 325, 
	KP_6          = 326, 
	KP_7          = 327, 
	KP_8          = 328, 
	KP_9          = 329, 
	KP_DECIMAL    = 330, 
	KP_DIVIDE     = 331, 
	KP_MULTIPLY   = 332, 
	KP_SUBTRACT   = 333, 
	KP_ADD        = 334, 
	KP_ENTER      = 335, 
	KP_EQUAL      = 336, 
	LEFT_SHIFT    = 340, 
	LEFT_CONTROL  = 341, 
	LEFT_ALT      = 342, 
	LEFT_SUPER    = 343, 
	RIGHT_SHIFT   = 344, 
	RIGHT_CONTROL = 345, 
	RIGHT_ALT     = 346, 
	RIGHT_SUPER   = 347, 
	MENU          = 348, 
	COUNT         = 349, 
}

str16 :: distinct []u16

str16_elt :: struct {
	// The string element is linked into its parent string list through this field.
	listElt: list_elt,
	// The string for this element.
	string:  str16,
}

str16_list :: struct {
	// A linked-list of `oc_str8_elt`.
	list:     list,
	// The number of elements in `list`.
	eltCount: u64,
	// The total length of the string list, which is the sum of the lengths over all elements.
	len:      u64,
}

str32 :: distinct []rune

str32_elt :: struct {
	// The string element is linked into its parent string list through this field.
	listElt: list_elt,
	// The string for this element.
	string:  str32,
}

str32_list :: struct {
	// A linked-list of `oc_str8_elt`.
	list:     list,
	// The number of elements in `list`.
	eltCount: u64,
	// The total length of the string list, which is the sum of the lengths over all elements.
	len:      u64,
}

str8 :: string

str8_elt :: struct {
	// The string element is linked into its parent string list through this field.
	listElt: list_elt,
	// The string for this element.
	string:  string,
}

str8_list :: struct {
	// A linked-list of `oc_str8_elt`.
	list:     list,
	// The number of elements in `list`.
	eltCount: u64,
	// The total length of the string list, which is the sum of the lengths over all elements.
	len:      u64,
}

style_enum :: enum int {
	SIZE_WIDTH      = 1, 
	SIZE_HEIGHT, 
	LAYOUT_AXIS, 
	LAYOUT_ALIGN_X, 
	LAYOUT_ALIGN_Y, 
	LAYOUT_SPACING, 
	LAYOUT_MARGIN_X, 
	LAYOUT_MARGIN_Y, 
	FLOAT_X, 
	FLOAT_Y, 
	COLOR, 
	BG_COLOR, 
	BORDER_COLOR, 
	BORDER_SIZE, 
	ROUNDNESS, 
	FONT, 
	FONT_SIZE, 
	ANIMATION_TIME, 
	ANIMATION_MASK, 
}

surface :: distinct u64

sys_err_def :: struct {
	msg:  [1024]u8 `fmt:"s,0"`,
	code: i32,
}

text_metrics :: struct {
	ink:     rect,
	logical: rect,
	advance: [2]f32,
}

text_state :: struct {
	lastUpdate: u64,
	backing:    [64]rune,
	codePoints: str32,
}

ui_align :: enum u32 {
	START  = 0, 
	END    = 1, 
	CENTER = 2, 
}

ui_axis :: enum u32 {
	X     = 0, 
	Y     = 1, 
	COUNT = 2, 
}

ui_box :: struct {
	listElt:          list_elt,
	children:         list,
	parent:           ^ui_box,
	overlayElt:       list_elt,
	bucketElt:        list_elt,
	key:              ui_key,
	frameCounter:     u64,
	flags:            bit_set[ui_flag; u32],
	string:           string,
	tags:             list,
	drawProc:         ui_box_draw_proc,
	drawData:         rawptr,
	beforeRules:      list,
	afterRules:       list,
	targetStyle:      ^ui_style,
	style:            ui_style,
	z:                u32,
	floatPos:         [2]f32,
	childrenSum:      [2]f32,
	spacing:          [2]f32,
	minSize:          [2]f32,
	rect:             rect,
	sig:              ^ui_sig,
	fresh:            bool,
	closed:           bool,
	parentClosed:     bool,
	dragging:         bool,
	hot:              bool,
	active:           bool,
	scroll:           [2]f32,
	pressedMouse:     [2]f32,
	hotTransition:    f32,
	activeTransition: f32,
}

ui_box_draw_proc :: proc "c" (arg0: ^ui_box, arg1: rawptr)

ui_box_floating :: [2]bool

ui_box_size :: [2]ui_size

ui_context :: struct {
	init:                           bool,
	input:                          input_state,
	frameCounter:                   u64,
	frameTime:                      f64,
	lastFrameDuration:              f64,
	frameArena:                     arena,
	boxPool:                        pool,
	boxMap:                         [1024]list,
	root:                           ^ui_box,
	overlay:                        ^ui_box,
	overlayList:                    list,
	boxStack:                       ^ui_stack_elt,
	clipStack:                      ^ui_stack_elt,
	nextBoxBeforeRules:             list,
	nextBoxAfterRules:              list,
	nextBoxTags:                    list,
	z:                              u32,
	hovered:                        ^ui_box,
	focus:                          ^ui_box,
	editCursor:                     i32,
	editMark:                       i32,
	editFirstDisplayedChar:         i32,
	editCursorBlinkStart:           f64,
	editSelectionMode:              ui_edit_move,
	editWordSelectionInitialCursor: i32,
	editWordSelectionInitialMark:   i32,
	theme:                          ^ui_theme,
}

ui_edit_move :: enum u32 {
	NONE = 0, 
	CHAR = 1, 
	WORD = 2, 
	LINE = 3, 
}

ui_flag :: enum u32 {
	CLICKABLE        = 0, 
	SCROLL_WHEEL_X, 
	SCROLL_WHEEL_Y, 
	BLOCK_MOUSE, 
	HOT_ANIMATION, 
	ACTIVE_ANIMATION, 
	OVERFLOW_ALLOW_X, 
	OVERFLOW_ALLOW_Y, 
	CLIP, 
	DRAW_BACKGROUND, 
	DRAW_FOREGROUND, 
	DRAW_BORDER, 
	DRAW_TEXT, 
	DRAW_PROC, 
	OVERLAY, 
}

ui_flags :: bit_set[ui_flag; u32]

ui_input_text :: struct {
	count:      u8 `fmt:"-"`,
	codePoints: [64]rune `fmt:"s,count"`,
}

ui_key :: struct {
	hash: u64,
}

ui_layout :: struct {
	axis:    ui_axis,
	spacing: f32,
	margin:  [2]f32,
	align:   [2]ui_align,
}

ui_layout_align :: [2]ui_align

ui_palette :: struct {
	red0:        color,
	red1:        color,
	red2:        color,
	red3:        color,
	red4:        color,
	red5:        color,
	red6:        color,
	red7:        color,
	red8:        color,
	red9:        color,
	orange0:     color,
	orange1:     color,
	orange2:     color,
	orange3:     color,
	orange4:     color,
	orange5:     color,
	orange6:     color,
	orange7:     color,
	orange8:     color,
	orange9:     color,
	amber0:      color,
	amber1:      color,
	amber2:      color,
	amber3:      color,
	amber4:      color,
	amber5:      color,
	amber6:      color,
	amber7:      color,
	amber8:      color,
	amber9:      color,
	yellow0:     color,
	yellow1:     color,
	yellow2:     color,
	yellow3:     color,
	yellow4:     color,
	yellow5:     color,
	yellow6:     color,
	yellow7:     color,
	yellow8:     color,
	yellow9:     color,
	lime0:       color,
	lime1:       color,
	lime2:       color,
	lime3:       color,
	lime4:       color,
	lime5:       color,
	lime6:       color,
	lime7:       color,
	lime8:       color,
	lime9:       color,
	lightGreen0: color,
	lightGreen1: color,
	lightGreen2: color,
	lightGreen3: color,
	lightGreen4: color,
	lightGreen5: color,
	lightGreen6: color,
	lightGreen7: color,
	lightGreen8: color,
	lightGreen9: color,
	green0:      color,
	green1:      color,
	green2:      color,
	green3:      color,
	green4:      color,
	green5:      color,
	green6:      color,
	green7:      color,
	green8:      color,
	green9:      color,
	teal0:       color,
	teal1:       color,
	teal2:       color,
	teal3:       color,
	teal4:       color,
	teal5:       color,
	teal6:       color,
	teal7:       color,
	teal8:       color,
	teal9:       color,
	cyan0:       color,
	cyan1:       color,
	cyan2:       color,
	cyan3:       color,
	cyan4:       color,
	cyan5:       color,
	cyan6:       color,
	cyan7:       color,
	cyan8:       color,
	cyan9:       color,
	lightBlue0:  color,
	lightBlue1:  color,
	lightBlue2:  color,
	lightBlue3:  color,
	lightBlue4:  color,
	lightBlue5:  color,
	lightBlue6:  color,
	lightBlue7:  color,
	lightBlue8:  color,
	lightBlue9:  color,
	blue0:       color,
	blue1:       color,
	blue2:       color,
	blue3:       color,
	blue4:       color,
	blue5:       color,
	blue6:       color,
	blue7:       color,
	blue8:       color,
	blue9:       color,
	indigo0:     color,
	indigo1:     color,
	indigo2:     color,
	indigo3:     color,
	indigo4:     color,
	indigo5:     color,
	indigo6:     color,
	indigo7:     color,
	indigo8:     color,
	indigo9:     color,
	violet0:     color,
	violet1:     color,
	violet2:     color,
	violet3:     color,
	violet4:     color,
	violet5:     color,
	violet6:     color,
	violet7:     color,
	violet8:     color,
	violet9:     color,
	purple0:     color,
	purple1:     color,
	purple2:     color,
	purple3:     color,
	purple4:     color,
	purple5:     color,
	purple6:     color,
	purple7:     color,
	purple8:     color,
	purple9:     color,
	pink0:       color,
	pink1:       color,
	pink2:       color,
	pink3:       color,
	pink4:       color,
	pink5:       color,
	pink6:       color,
	pink7:       color,
	pink8:       color,
	pink9:       color,
	grey0:       color,
	grey1:       color,
	grey2:       color,
	grey3:       color,
	grey4:       color,
	grey5:       color,
	grey6:       color,
	grey7:       color,
	grey8:       color,
	grey9:       color,
	black:       color,
	white:       color,
}

ui_pattern :: struct {
	l: list,
}

ui_radio_group_info :: struct {
	changed:       bool,
	selectedIndex: i32,
	optionCount:   i32 `fmt:"-"`,
	options:       [^]string `fmt:"s,optionCount"`,
}

ui_select_popup_info :: struct {
	changed:       bool,
	selectedIndex: i32,
	optionCount:   i32 `fmt:"-"`,
	options:       [^]string `fmt:"s,optionCount"`,
	placeholder:   string,
}

ui_selector :: struct {
	listElt: list_elt,
	kind:    ui_selector_kind,
	op:      ui_selector_op,
	using _: struct #raw_union {
		text:   string,
		key:    ui_key,
		tag:    ui_tag,
		status: bit_set[ui_status_flag; u8],
	},
}

ui_selector_kind :: enum u32 {
	ANY    = 0, 
	OWNER  = 1, 
	TEXT   = 2, 
	TAG    = 3, 
	STATUS = 4, 
	KEY    = 5, 
}

ui_selector_op :: enum u32 {
	DESCENDANT = 0, 
	AND        = 1, 
}

ui_sig :: struct {
	box:           ^ui_box,
	mouse:         [2]f32,
	delta:         [2]f32,
	wheel:         [2]f32,
	pressed:       bool,
	released:      bool,
	clicked:       bool,
	doubleClicked: bool,
	tripleClicked: bool,
	rightPressed:  bool,
	dragging:      bool,
	hovering:      bool,
	pasted:        bool,
}

ui_size :: struct {
	kind:    ui_size_kind,
	value:   f32,
	relax:   f32,
	minSize: f32,
}

ui_size_kind :: enum u32 {
	TEXT                = 0, 
	PIXELS              = 1, 
	CHILDREN            = 2, 
	PARENT              = 3, 
	PARENT_MINUS_PIXELS = 4, 
}

ui_stack_elt :: struct {
	parent: ^ui_stack_elt,
	using _: struct #raw_union {
		box:  ^ui_box,
		size: ui_size,
		clip: rect,
	},
}

ui_status :: bit_set[ui_status_flag; u8]

ui_status_flag :: enum u8 {
	HOVER    = 1, 
	HOT, 
	ACTIVE, 
	DRAGGING, 
}

ui_style :: struct {
	size:          [2]ui_size,
	layout:        ui_layout,
	floating:      [2]bool,
	floatTarget:   [2]f32,
	_color:        color,
	bgColor:       color,
	borderColor:   color,
	font:          font,
	fontSize:      f32,
	borderSize:    f32,
	roundness:     f32,
	animationTime: f32,
	animationMask: bit_set[style_enum; u64],
}

ui_style_mask :: bit_set[style_enum; u64]

ui_style_rule :: struct {
	boxElt:   list_elt,
	buildElt: list_elt,
	tmpElt:   list_elt,
	owner:    ^ui_box,
	pattern:  ui_pattern,
	mask:     bit_set[style_enum; u64],
	style:    ^ui_style,
}

ui_tag :: struct {
	hash: u64,
}

ui_tag_elt :: struct {
	listElt: list_elt,
	tag:     ui_tag,
}

ui_text_box_result :: struct {
	changed:  bool,
	accepted: bool,
	text:     string,
}

ui_theme :: struct {
	white:             color,
	primary:           color,
	primaryHover:      color,
	primaryActive:     color,
	border:            color,
	fill0:             color,
	fill1:             color,
	fill2:             color,
	bg0:               color,
	bg1:               color,
	bg2:               color,
	bg3:               color,
	bg4:               color,
	text0:             color,
	text1:             color,
	text2:             color,
	text3:             color,
	sliderThumbBorder: color,
	elevatedBorder:    color,
	roundnessSmall:    f32,
	roundnessMedium:   f32,
	roundnessLarge:    f32,
	palette:           ^ui_palette,
}

unicode_range :: struct {
	// The first codepoint of the range.
	firstCodePoint: rune,
	// The number of codepoints in the range.
	count:          u32,
}

utf32 :: rune

utf8_dec :: struct {
	// The decoded codepoint.
	codepoint: rune,
	// The size of the utf8 sequence encoding that codepoint.
	size:      u32,
}

vec2 :: [2]f32

vec2i :: [2]i32

vec3 :: [3]f32

vec4 :: [4]f32

window :: distinct u64

BACKING_SIZE :: 64

BOX_MAP_BUCKET_COUNT :: 1024

FLOAT: bit_set[style_enum; u64] : ui_style_mask{.FLOAT_X, .FLOAT_Y}

LAYOUT: bit_set[style_enum; u64] : ui_style_mask{.LAYOUT_AXIS, .LAYOUT_ALIGN_X, .LAYOUT_ALIGN_Y, .LAYOUT_SPACING, .LAYOUT_MARGIN_X, .LAYOUT_MARGIN_Y}

LAYOUT_MARGINS: bit_set[style_enum; u64] : ui_style_mask{.LAYOUT_MARGIN_X, .LAYOUT_MARGIN_Y}

MASK_INHERITED: bit_set[style_enum; u64] : ui_style_mask{.COLOR, .FONT, .FONT_SIZE, .ANIMATION_TIME, .ANIMATION_MASK}

MAX_INPUT_CHAR_PER_FRAME :: 64

SIZE: bit_set[style_enum; u64] : ui_style_mask{.SIZE_WIDTH, .SIZE_HEIGHT}

SYS_MAX_ERROR :: 1024

UNICODE_AEGEAN_NUMBERS :: unicode_range{0x10100, 63}

UNICODE_ALPHABETIC_PRESENTATION_FORMS :: unicode_range{0xfb00, 79}

UNICODE_ARABIC :: unicode_range{0x0600, 255}

UNICODE_ARABIC_PRESENTATION_FORMS_A :: unicode_range{0xfb50, 687}

UNICODE_ARABIC_PRESENTATION_FORMS_B :: unicode_range{0xfe70, 143}

UNICODE_ARMENIAN :: unicode_range{0x0530, 95}

UNICODE_ARROWS :: unicode_range{0x2190, 111}

UNICODE_BASIC_LATIN :: unicode_range{0x0000, 127}

UNICODE_BENGALI_ASSAMESE :: unicode_range{0x0980, 127}

UNICODE_BLOCK_ELEMENTS :: unicode_range{0x2580, 31}

UNICODE_BOPOMOFO :: unicode_range{0x3100, 47}

UNICODE_BOPOMOFO_EXTENDED :: unicode_range{0x31a0, 31}

UNICODE_BOX_DRAWING :: unicode_range{0x2500, 127}

UNICODE_BRAILLE_PATTERNS :: unicode_range{0x2800, 255}

UNICODE_BUHID :: unicode_range{0x1740, 31}

UNICODE_BYZANTINE_MUSICAL_SYMBOLS :: unicode_range{0x1d000, 255}

UNICODE_C1_CONTROLS_AND_LATIN_1_SUPPLEMENT :: unicode_range{0x0080, 127}

UNICODE_CHEROKEE :: unicode_range{0x13a0, 95}

UNICODE_CJK_COMPATIBILITY :: unicode_range{0x3300, 255}

UNICODE_CJK_COMPATIBILITY_FORMS :: unicode_range{0xfe30, 31}

UNICODE_CJK_COMPATIBILITY_IDEOGRAPHS :: unicode_range{0xf900, 511}

UNICODE_CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT :: unicode_range{0x2f800, 543}

UNICODE_CJK_RADICALS_SUPPLEMENT :: unicode_range{0x2e80, 127}

UNICODE_CJK_SYMBOLS_AND_PUNCTUATION :: unicode_range{0x3000, 63}

UNICODE_CJK_UNIFIED_IDEOGRAPHS :: unicode_range{0x4e00, 20911}

UNICODE_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A :: unicode_range{0x3400, 6591}

UNICODE_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B :: unicode_range{0x20000, 42719}

UNICODE_COMBINING_DIACRITICAL_MARKS :: unicode_range{0x0300, 111}

UNICODE_COMBINING_DIACRITICAL_MARKS_FOR_SYMBOLS :: unicode_range{0x20d0, 47}

UNICODE_COMBINING_HALF_MARKS :: unicode_range{0xfe20, 15}

UNICODE_CONTROL_PICTURES :: unicode_range{0x2400, 63}

UNICODE_CURRENCY_SYMBOLS :: unicode_range{0x20a0, 47}

UNICODE_CYPRIOT_SYLLABARY :: unicode_range{0x10800, 63}

UNICODE_CYRILLIC :: unicode_range{0x0400, 255}

UNICODE_CYRILLIC_SUPPLEMENT :: unicode_range{0x0500, 47}

UNICODE_DESERET :: unicode_range{0x10400, 79}

UNICODE_DEVANAGARI :: unicode_range{0x0900, 127}

UNICODE_DINGBATS :: unicode_range{0x2700, 191}

UNICODE_ENCLOSED_ALPHANUMERICS :: unicode_range{0x2460, 159}

UNICODE_ENCLOSED_CJK_LETTERS_AND_MONTHS :: unicode_range{0x3200, 255}

UNICODE_ETHIOPIC :: unicode_range{0x1200, 383}

UNICODE_GENERAL_PUNCTUATION :: unicode_range{0x2000, 111}

UNICODE_GEOMETRIC_SHAPES :: unicode_range{0x25a0, 95}

UNICODE_GEORGIAN :: unicode_range{0x10a0, 95}

UNICODE_GOTHIC :: unicode_range{0x10330, 31}

UNICODE_GREEK_COPTIC :: unicode_range{0x0370, 143}

UNICODE_GREEK_EXTENDED :: unicode_range{0x1f00, 255}

UNICODE_GUJARATI :: unicode_range{0x0a80, 127}

UNICODE_GURMUKHI :: unicode_range{0x0a00, 127}

UNICODE_HALFWIDTH_AND_FULLWIDTH_FORMS :: unicode_range{0xff00, 239}

UNICODE_HANGUL_COMPATIBILITY_JAMO :: unicode_range{0x3130, 95}

UNICODE_HANGUL_JAMO :: unicode_range{0x1100, 255}

UNICODE_HANGUL_SYLLABLES :: unicode_range{0xac00, 11183}

UNICODE_HANUNOO :: unicode_range{0x1720, 31}

UNICODE_HEBREW :: unicode_range{0x0590, 111}

UNICODE_HIGH_SURROGATE_AREA :: unicode_range{0xd800, 1023}

UNICODE_HIRAGANA :: unicode_range{0x3040, 95}

UNICODE_IDEOGRAPHIC_DESCRIPTION_CHARACTERS :: unicode_range{0x2ff0, 15}

UNICODE_IPA_EXTENSIONS :: unicode_range{0x0250, 95}

UNICODE_KANBUN_KUNTEN :: unicode_range{0x3190, 15}

UNICODE_KANGXI_RADICALS :: unicode_range{0x2f00, 223}

UNICODE_KANNADA :: unicode_range{0x0c80, 127}

UNICODE_KATAKANA :: unicode_range{0x30a0, 95}

UNICODE_KATAKANA_PHONETIC_EXTENSIONS :: unicode_range{0x31f0, 15}

UNICODE_KHMER :: unicode_range{0x1780, 127}

UNICODE_KHMER_SYMBOLS :: unicode_range{0x19e0, 31}

UNICODE_LAO :: unicode_range{0x0e80, 127}

UNICODE_LATIN_EXTENDED_A :: unicode_range{0x0100, 127}

UNICODE_LATIN_EXTENDED_ADDITIONAL :: unicode_range{0x1e00, 255}

UNICODE_LATIN_EXTENDED_B :: unicode_range{0x0180, 207}

UNICODE_LETTERLIKE_SYMBOLS :: unicode_range{0x2100, 79}

UNICODE_LIMBU :: unicode_range{0x1900, 79}

UNICODE_LINEAR_B_IDEOGRAMS :: unicode_range{0x10080, 127}

UNICODE_LINEAR_B_SYLLABARY :: unicode_range{0x10000, 127}

UNICODE_LOW_SURROGATE_AREA :: unicode_range{0xdc00, 1023}

UNICODE_MALAYALAM :: unicode_range{0x0d00, 255}

UNICODE_MATHEMATICAL_ALPHANUMERIC_SYMBOLS :: unicode_range{0x1d400, 1023}

UNICODE_MATHEMATICAL_OPERATORS :: unicode_range{0x2200, 255}

UNICODE_MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A :: unicode_range{0x27c0, 47}

UNICODE_MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B :: unicode_range{0x2980, 127}

UNICODE_MISCELLANEOUS_SYMBOLS :: unicode_range{0x2600, 255}

UNICODE_MISCELLANEOUS_SYMBOLS_AND_ARROWS :: unicode_range{0x2b00, 255}

UNICODE_MISCELLANEOUS_TECHNICAL :: unicode_range{0x2300, 255}

UNICODE_MONGOLIAN :: unicode_range{0x1800, 175}

UNICODE_MUSICAL_SYMBOLS :: unicode_range{0x1d100, 255}

UNICODE_MYANMAR :: unicode_range{0x1000, 159}

UNICODE_NUMBER_FORMS :: unicode_range{0x2150, 63}

UNICODE_OGHAM :: unicode_range{0x1680, 31}

UNICODE_OLD_ITALIC :: unicode_range{0x10300, 47}

UNICODE_OPTICAL_CHARACTER_RECOGNITION :: unicode_range{0x2440, 31}

UNICODE_ORIYA :: unicode_range{0x0b00, 127}

UNICODE_OSMANYA :: unicode_range{0x10480, 47}

UNICODE_PHONETIC_EXTENSIONS :: unicode_range{0x1d00, 127}

UNICODE_PRIVATE_USE_AREA :: unicode_range{0xe000, 6399}

UNICODE_RUNIC :: unicode_range{0x16a0, 95}

UNICODE_SHAVIAN :: unicode_range{0x10450, 47}

UNICODE_SINHALA :: unicode_range{0x0d80, 127}

UNICODE_SMALL_FORM_VARIANTS :: unicode_range{0xfe50, 31}

UNICODE_SPACING_MODIFIER_LETTERS :: unicode_range{0x02b0, 79}

UNICODE_SPECIALS :: unicode_range{0xfff0, 15}

UNICODE_SUPERSCRIPTS_AND_SUBSCRIPTS :: unicode_range{0x2070, 47}

UNICODE_SUPPLEMENTAL_ARROWS_A :: unicode_range{0x27f0, 15}

UNICODE_SUPPLEMENTAL_ARROWS_B :: unicode_range{0x2900, 127}

UNICODE_SUPPLEMENTAL_MATHEMATICAL_OPERATORS :: unicode_range{0x2a00, 255}

UNICODE_SUPPLEMENTARY_PRIVATE_USE_AREA_A :: unicode_range{0xf0000, 65533}

UNICODE_SUPPLEMENTARY_PRIVATE_USE_AREA_B :: unicode_range{0x100000, 65533}

UNICODE_SYRIAC :: unicode_range{0x0700, 79}

UNICODE_TAGALOG :: unicode_range{0x1700, 31}

UNICODE_TAGBANWA :: unicode_range{0x1760, 31}

UNICODE_TAGS :: unicode_range{0xe0000, 127}

UNICODE_TAI_LE :: unicode_range{0x1950, 47}

UNICODE_TAI_XUAN_JING_SYMBOLS :: unicode_range{0x1d300, 95}

UNICODE_TAMIL :: unicode_range{0x0b80, 127}

UNICODE_TELUGU :: unicode_range{0x0c00, 127}

UNICODE_THAANA :: unicode_range{0x0780, 63}

UNICODE_THAI :: unicode_range{0x0e00, 127}

UNICODE_TIBETAN :: unicode_range{0x0f00, 255}

UNICODE_UGARITIC :: unicode_range{0x10380, 31}

UNICODE_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS :: unicode_range{0x1400, 639}

UNICODE_VARIATION_SELECTORS :: unicode_range{0xfe00, 15}

UNICODE_VARIATION_SELECTORS_SUPPLEMENT :: unicode_range{0xe0100, 239}

UNICODE_YIJING_HEXAGRAM_SYMBOLS :: unicode_range{0x4dc0, 63}

UNICODE_YI_RADICALS :: unicode_range{0xa490, 63}

UNICODE_YI_SYLLABLES :: unicode_range{0xa000, 1167}

UI_DARK_PALETTE: ui_palette

UI_DARK_THEME: ui_theme

UI_LIGHT_PALETTE: ui_palette

UI_LIGHT_THEME: ui_theme

sys_error: sys_err_def

abort :: proc "contextless" (msg: cstring, loc := #caller_location) {…}

abort_ext :: proc "c" (file: cstring, function: cstring, line: i32, fmt: cstring, .. args: ..any) -> ! ---

arc :: proc "c" (x: f32, y: f32, r: f32, arcAngle: f32, startAngle: f32) ---

arena_cleanup :: proc "c" (arena: ^arena) ---

arena_clear :: proc "c" (arena: ^arena) ---

arena_init :: proc "c" (arena: ^arena) ---

arena_init_with_options :: proc "c" (arena: ^arena, options: ^arena_options) ---

arena_push :: proc "c" (arena: ^arena, size: u64) -> rawptr ---

arena_push_aligned :: proc "c" (arena: ^arena, size: u64, alignment: u32) -> rawptr ---

arena_push_array :: proc "contextless" (arena: ^arena, $T: typeid, count: u64) -> []typeid {…}

arena_push_type :: proc "contextless" (arena: ^arena, $T: typeid) -> ^typeid {…}

arena_scope_begin :: proc "c" (arena: ^arena) -> arena_scope ---

arena_scope_end :: proc "c" (scope: arena_scope) ---

assert_fail :: proc "c" (
	file:     cstring, 
	function: cstring, 
	line:     i32, 
	src:      cstring, 
	fmt:      cstring, 
	.. args:  ..any, 
) -> ! ---

canvas_context_create :: proc "c" () -> canvas_context ---

canvas_context_destroy :: proc "c" (_context: canvas_context) ---

canvas_context_is_nil :: proc "c" (_context: canvas_context) -> bool ---

canvas_context_nil :: proc "c" () -> canvas_context ---

canvas_context_select :: proc "c" (_context: canvas_context) -> canvas_context ---

canvas_context_set_msaa_sample_count :: proc "c" (_context: canvas_context, sampleCount: u32) ---

canvas_present :: proc "c" (renderer: canvas_renderer, surface: surface) ---

canvas_render :: proc "c" (renderer: canvas_renderer, _context: canvas_context, surface: surface) ---

canvas_renderer_create :: proc "c" () -> canvas_renderer ---

canvas_renderer_destroy :: proc "c" (renderer: canvas_renderer) ---

canvas_renderer_is_nil :: proc "c" (renderer: canvas_renderer) -> bool ---

canvas_renderer_nil :: proc "c" () -> canvas_renderer ---

canvas_surface_create :: proc "c" (renderer: canvas_renderer) -> surface ---

canvas_surface_swap_interval :: proc "c" (surface: surface, swap: i32) ---

circle_fill :: proc "c" (x: f32, y: f32, r: f32) ---

circle_stroke :: proc "c" (x: f32, y: f32, r: f32) ---

clear :: proc "c" () ---

clip_pop :: proc "c" () ---

clip_push :: proc "c" (x: f32, y: f32, w: f32, h: f32) ---

clip_top :: proc "c" () -> rect ---

clipboard_pasted :: proc "c" (state: ^input_state) -> bool ---

clipboard_pasted_text :: proc "c" (state: ^input_state) -> string ---

clipboard_set_string :: proc "c" (string: string) ---

clock_time :: proc "c" (clock: clock_kind) -> f64 ---

close_path :: proc "c" () ---

codepoints_outlines :: proc "c" (string: str32) ---

color_convert :: proc "c" (_color: color, colorSpace: color_space) -> color ---

color_rgba :: proc "c" (r: f32, g: f32, b: f32, a: f32) -> color ---

color_srgba :: proc "c" (r: f32, g: f32, b: f32, a: f32) -> color ---

create_odin_logger :: proc(lowest: runtime.Logger_Level = runtime.Logger_Level.Debug, ident: string = "") -> runtime.Logger {…}

cubic_to :: proc "c" (
	x1: f32, 
	y1: f32, 
	x2: f32, 
	y2: f32, 
	x3: f32, 
	y3: f32, 
) ---

ellipse_fill :: proc "c" (x: f32, y: f32, rx: f32, ry: f32) ---

ellipse_stroke :: proc "c" (x: f32, y: f32, rx: f32, ry: f32) ---

file_close :: proc "c" (file: file) ---

file_get_status :: proc "c" (file: file) -> file_status ---

file_is_nil :: proc "c" (handle: file) -> bool ---

file_last_error :: proc "c" (handle: file) -> io_error ---

file_nil :: proc "c" () -> file ---

file_open :: proc "c" (path: string, rights: bit_set[file_access_flag; u16], flags: bit_set[file_open_flag; u16]) -> file ---

file_open_at :: proc "c" (dir: file, path: string, rights: bit_set[file_access_flag; u16], flags: bit_set[file_open_flag; u16]) -> file ---

file_open_with_dialog :: proc "c" (arena: ^arena, rights: bit_set[file_access_flag; u16], flags: bit_set[file_open_flag; u16], desc: ^file_dialog_desc) -> file_open_with_dialog_result ---

file_open_with_request :: proc "c" (path: string, rights: bit_set[file_access_flag; u16], flags: bit_set[file_open_flag; u16]) -> file ---

file_pos :: proc "c" (file: file) -> i64 ---

file_read :: proc "c" (file: file, size: u64, buffer: [^]u8) -> u64 ---

file_read_slice :: proc(file: file, slice: []u8) -> u64 {…}

file_seek :: proc "c" (file: file, offset: i64, whence: file_whence) -> i64 ---

file_size :: proc "c" (file: file) -> u64 ---

file_write :: proc "c" (file: file, size: u64, buffer: [^]u8) -> u64 ---

file_write_slice :: proc(file: file, slice: []u8) -> u64 {…}

fill :: proc "c" () ---

font_create_from_file :: proc "c" (file: file, rangeCount: u32, ranges: ^unicode_range) -> font ---

font_create_from_memory :: proc "c" (mem: string, rangeCount: u32, ranges: ^unicode_range) -> font ---

font_create_from_path :: proc "c" (path: string, rangeCount: u32, ranges: ^unicode_range) -> font ---

font_destroy :: proc "c" (font: font) ---

font_get_glyph_index :: proc "c" (font: font, codePoint: rune) -> u32 ---

font_get_glyph_indices :: proc "c" (font: font, codePoints: str32, backing: str32) -> str32 ---

font_get_metrics :: proc "c" (font: font, emSize: f32) -> font_metrics ---

font_get_metrics_unscaled :: proc "c" (font: font) -> font_metrics ---

font_get_scale_for_em_pixels :: proc "c" (font: font, emSize: f32) -> f32 ---

font_is_nil :: proc "c" (font: font) -> bool ---

font_nil :: proc "c" () -> font ---

font_push_glyph_indices :: proc "c" (arena: ^arena, font: font, codePoints: str32) -> str32 ---

font_text_metrics :: proc "c" (font: font, fontSize: f32, text: string) -> text_metrics ---

font_text_metrics_utf32 :: proc "c" (font: font, fontSize: f32, codepoints: str32) -> text_metrics ---

get_cap :: proc "c" () -> cap_type ---

get_color :: proc "c" () -> color ---

get_font :: proc "c" () -> font ---

get_font_size :: proc "c" () -> f32 ---

get_image :: proc "c" () -> image ---

get_image_source_region :: proc "c" () -> rect ---

get_joint :: proc "c" () -> joint_type ---

get_max_joint_excursion :: proc "c" () -> f32 ---

get_position :: proc "c" () -> [2]f32 ---

get_text_flip :: proc "c" () -> bool ---

get_tolerance :: proc "c" () -> f32 ---

get_width :: proc "c" () -> f32 ---

gles_surface_create :: proc "c" () -> surface ---

gles_surface_make_current :: proc "c" (surface: surface) ---

gles_surface_swap_buffers :: proc "c" (surface: surface) ---

gles_surface_swap_interval :: proc "c" (surface: surface, interval: i32) ---

glyph_outlines :: proc "c" (glyphIndices: str32) -> rect ---

image_atlas_alloc_from_file :: proc "c" (atlas: ^rect_atlas, backingImage: image, file: file, flip: bool) -> image_region ---