aboutsummaryrefslogtreecommitdiff
path: root/core/sys/orca
diff options
context:
space:
mode:
Diffstat (limited to 'core/sys/orca')
-rw-r--r--core/sys/orca/algebra.odin58
-rw-r--r--core/sys/orca/app.odin366
-rw-r--r--core/sys/orca/graphics.odin247
-rw-r--r--core/sys/orca/input_state.odin59
-rw-r--r--core/sys/orca/io.odin159
-rw-r--r--core/sys/orca/lists.odin117
-rw-r--r--core/sys/orca/orca_graphics.odin332
-rw-r--r--core/sys/orca/orca_strings.odin40
-rw-r--r--core/sys/orca/orca_threads.odin75
-rw-r--r--core/sys/orca/orca_types.odin807
-rw-r--r--core/sys/orca/typedefs.odin (renamed from core/sys/orca/orca.odin)0
-rw-r--r--core/sys/orca/ui.odin685
-rw-r--r--core/sys/orca/utf8.odin131
-rw-r--r--core/sys/orca/util.odin266
14 files changed, 1254 insertions, 2088 deletions
diff --git a/core/sys/orca/algebra.odin b/core/sys/orca/algebra.odin
deleted file mode 100644
index 29aa65e9e..000000000
--- a/core/sys/orca/algebra.odin
+++ /dev/null
@@ -1,58 +0,0 @@
-package orca
-
-import "core:math"
-
-// TODO use orcas or native?
-
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- mat2x3_mul_m :: proc(lhs, rhs: mat2x3) -> mat2x3 ---
- mat2x3_inv :: proc(x: mat2x3) -> mat2x3 ---
- mat2x3_mul :: proc(m: mat2x3, p: vec2) -> vec2 ---
- mat2x3_rotate :: proc(radians: f32) -> mat2x3 ---
- mat2x3_translate :: proc(x, y: f32) -> mat2x3 ---
-}
-
-// mat2x3_mul_m :: proc "contextless" (lhs, rhs: mat2x3) -> (res: mat2x3) {
-// res[0] = lhs[0] * rhs[0] + lhs[1] * rhs[3]
-// res[1] = lhs[0] * rhs[1] + lhs[1] * rhs[4]
-// res[2] = lhs[0] * rhs[2] + lhs[1] * rhs[5] + lhs[2]
-// res[3] = lhs[3] * rhs[0] + lhs[4] * rhs[3]
-// res[4] = lhs[3] * rhs[1] + lhs[4] * rhs[4]
-// res[5] = lhs[3] * rhs[2] + lhs[4] * rhs[5] + lhs[5]
-// return
-// }
-
-// mat2x3_inv :: proc "contextless" (x: mat2x3) -> (res: mat2x3) {
-// res[0] = x[4] / (x[0] * x[4] - x[1] * x[3])
-// res[1] = x[1] / (x[1] * x[3] - x[0] * x[4])
-// res[3] = x[3] / (x[1] * x[3] - x[0] * x[4])
-// res[4] = x[0] / (x[0] * x[4] - x[1] * x[3])
-// res[2] = -(x[2] * res[0] + x[5] * res[1])
-// res[5] = -(x[2] * res[3] + x[5] * res[4])
-// return
-// }
-
-// mat2x3_mul :: proc "contextless" (m: mat2x3, p: vec2) -> vec2 {
-// return {
-// p.x * m[0] + p.y * m[1] + m[2],
-// p.x * m[3] + p.y * m[4] + m[5],
-// }
-// }
-
-// mat2x3_rotate :: proc "contextless" (radians: f32) -> mat2x3 {
-// sinRot := math.sin(radians)
-// cosRot := math.cos(radians)
-// rot := mat2x3 {
-// cosRot, -sinRot, 0,
-// sinRot, cosRot, 0,
-// }
-// return rot
-// }
-
-// mat2x3_translate :: proc "contextless" (x, y: f32) -> mat2x3 {
-// return {
-// 1, 0, x,
-// 0, 1, y,
-// }
-// }
diff --git a/core/sys/orca/app.odin b/core/sys/orca/app.odin
deleted file mode 100644
index 0cf42b80b..000000000
--- a/core/sys/orca/app.odin
+++ /dev/null
@@ -1,366 +0,0 @@
-package orca
-
-import "core:c"
-
-window :: distinct u64
-
-mouse_cursor :: enum c.int {
- ARROW,
- RESIZE_0,
- RESIZE_90,
- RESIZE_45,
- RESIZE_135,
- TEXT,
-}
-
-window_style :: enum u32 {
- NO_TITLE = 0x01 << 0,
- FIXED_SIZE = 0x01 << 1,
- NO_CLOSE = 0x01 << 2,
- NO_MINIFY = 0x01 << 3,
- NO_FOCUS = 0x01 << 4,
- FLOAT = 0x01 << 5,
- POPUPMENU = 0x01 << 6,
- NO_BUTTONS = 0x01 << 7
-}
-
-event_type :: enum c.int {
- NONE,
- KEYBOARD_MODS, //TODO: remove, keep only key?
- KEYBOARD_KEY,
- KEYBOARD_CHAR,
- MOUSE_BUTTON,
- MOUSE_MOVE,
- MOUSE_WHEEL,
- MOUSE_ENTER,
- MOUSE_LEAVE,
- CLIPBOARD_PASTE,
- WINDOW_RESIZE,
- WINDOW_MOVE,
- WINDOW_FOCUS,
- WINDOW_UNFOCUS,
- WINDOW_HIDE, // rename to minimize?
- WINDOW_SHOW, // rename to restore?
- WINDOW_CLOSE,
- PATHDROP,
- FRAME,
- QUIT
-}
-
-key_action :: enum c.int {
- NO_ACTION,
- PRESS,
- RELEASE,
- REPEAT
-}
-
-key_code :: enum c.int {
- KEY_UNKNOWN = '\x00',
- KEY_SPACE = ' ',
- KEY_APOSTROPHE = '\'',
- KEY_COMMA = ',',
- KEY_MINUS = '-',
- KEY_PERIOD = '.',
- KEY_SLASH = '/',
- KEY_0 = '0',
- KEY_1 = '1',
- KEY_2 = '2',
- KEY_3 = '3',
- KEY_4 = '4',
- KEY_5 = '5',
- KEY_6 = '6',
- KEY_7 = '7',
- KEY_8 = '8',
- KEY_9 = '9',
- KEY_SEMICOLON = ';',
- KEY_EQUAL = '=',
- KEY_LEFT_BRACKET = '[',
- KEY_BACKSLASH = '\\',
- KEY_RIGHT_BRACKET = ']',
- KEY_GRAVE_ACCENT = '`',
- KEY_A = 'a',
- KEY_B = 'b',
- KEY_C = 'c',
- KEY_D = 'd',
- KEY_E = 'e',
- KEY_F = 'f',
- KEY_G = 'g',
- KEY_H = 'h',
- KEY_I = 'i',
- KEY_J = 'j',
- KEY_K = 'k',
- KEY_L = 'l',
- KEY_M = 'm',
- KEY_N = 'n',
- KEY_O = 'o',
- KEY_P = 'p',
- KEY_Q = 'q',
- KEY_R = 'r',
- KEY_S = 's',
- KEY_T = 't',
- KEY_U = 'u',
- KEY_V = 'v',
- KEY_W = 'w',
- KEY_X = 'x',
- KEY_Y = 'y',
- KEY_Z = 'z',
- KEY_WORLD_1 = 161,
- KEY_WORLD_2 = 162,
- KEY_ESCAPE = 256,
- KEY_ENTER = 257,
- KEY_TAB = 258,
- KEY_BACKSPACE = 259,
- KEY_INSERT = 260,
- KEY_DELETE = 261,
- KEY_RIGHT = 262,
- KEY_LEFT = 263,
- KEY_DOWN = 264,
- KEY_UP = 265,
- KEY_PAGE_UP = 266,
- KEY_PAGE_DOWN = 267,
- KEY_HOME = 268,
- KEY_END = 269,
- KEY_CAPS_LOCK = 280,
- KEY_SCROLL_LOCK = 281,
- KEY_NUM_LOCK = 282,
- KEY_PRINT_SCREEN = 283,
- KEY_PAUSE = 284,
- KEY_F1 = 290,
- KEY_F2 = 291,
- KEY_F3 = 292,
- KEY_F4 = 293,
- KEY_F5 = 294,
- KEY_F6 = 295,
- KEY_F7 = 296,
- KEY_F8 = 297,
- KEY_F9 = 298,
- KEY_F10 = 299,
- KEY_F11 = 300,
- KEY_F12 = 301,
- KEY_F13 = 302,
- KEY_F14 = 303,
- KEY_F15 = 304,
- KEY_F16 = 305,
- KEY_F17 = 306,
- KEY_F18 = 307,
- KEY_F19 = 308,
- KEY_F20 = 309,
- KEY_F21 = 310,
- KEY_F22 = 311,
- KEY_F23 = 312,
- KEY_F24 = 313,
- KEY_F25 = 314,
- KEY_KP_0 = 320,
- KEY_KP_1 = 321,
- KEY_KP_2 = 322,
- KEY_KP_3 = 323,
- KEY_KP_4 = 324,
- KEY_KP_5 = 325,
- KEY_KP_6 = 326,
- KEY_KP_7 = 327,
- KEY_KP_8 = 328,
- KEY_KP_9 = 329,
- KEY_KP_DECIMAL = 330,
- KEY_KP_DIVIDE = 331,
- KEY_KP_MULTIPLY = 332,
- KEY_KP_SUBTRACT = 333,
- KEY_KP_ADD = 334,
- KEY_KP_ENTER = 335,
- KEY_KP_EQUAL = 336,
- KEY_LEFT_SHIFT = 340,
- KEY_LEFT_CONTROL = 341,
- KEY_LEFT_ALT = 342,
- KEY_LEFT_SUPER = 343,
- KEY_RIGHT_SHIFT = 344,
- KEY_RIGHT_CONTROL = 345,
- KEY_RIGHT_ALT = 346,
- KEY_RIGHT_SUPER = 347,
- KEY_MENU = 348,
-}
-
-scan_code :: enum c.int {
- SCANCODE_UNKNOWN = 0,
- SCANCODE_SPACE = 32,
- SCANCODE_APOSTROPHE = 39,
- SCANCODE_COMMA = 44,
- SCANCODE_MINUS = 45,
- SCANCODE_PERIOD = 46,
- SCANCODE_SLASH = 47,
- SCANCODE_0 = 48,
- SCANCODE_1 = 49,
- SCANCODE_2 = 50,
- SCANCODE_3 = 51,
- SCANCODE_4 = 52,
- SCANCODE_5 = 53,
- SCANCODE_6 = 54,
- SCANCODE_7 = 55,
- SCANCODE_8 = 56,
- SCANCODE_9 = 57,
- SCANCODE_SEMICOLON = 59,
- SCANCODE_EQUAL = 61,
- SCANCODE_LEFT_BRACKET = 91,
- SCANCODE_BACKSLASH = 92,
- SCANCODE_RIGHT_BRACKET = 93,
- SCANCODE_GRAVE_ACCENT = 96,
- SCANCODE_A = 97,
- SCANCODE_B = 98,
- SCANCODE_C = 99,
- SCANCODE_D = 100,
- SCANCODE_E = 101,
- SCANCODE_F = 102,
- SCANCODE_G = 103,
- SCANCODE_H = 104,
- SCANCODE_I = 105,
- SCANCODE_J = 106,
- SCANCODE_K = 107,
- SCANCODE_L = 108,
- SCANCODE_M = 109,
- SCANCODE_N = 110,
- SCANCODE_O = 111,
- SCANCODE_P = 112,
- SCANCODE_Q = 113,
- SCANCODE_R = 114,
- SCANCODE_S = 115,
- SCANCODE_T = 116,
- SCANCODE_U = 117,
- SCANCODE_V = 118,
- SCANCODE_W = 119,
- SCANCODE_X = 120,
- SCANCODE_Y = 121,
- SCANCODE_Z = 122,
- SCANCODE_WORLD_1 = 161,
- SCANCODE_WORLD_2 = 162,
- SCANCODE_ESCAPE = 256,
- SCANCODE_ENTER = 257,
- SCANCODE_TAB = 258,
- SCANCODE_BACKSPACE = 259,
- SCANCODE_INSERT = 260,
- SCANCODE_DELETE = 261,
- SCANCODE_RIGHT = 262,
- SCANCODE_LEFT = 263,
- SCANCODE_DOWN = 264,
- SCANCODE_UP = 265,
- SCANCODE_PAGE_UP = 266,
- SCANCODE_PAGE_DOWN = 267,
- SCANCODE_HOME = 268,
- SCANCODE_END = 269,
- SCANCODE_CAPS_LOCK = 280,
- SCANCODE_SCROLL_LOCK = 281,
- SCANCODE_NUM_LOCK = 282,
- SCANCODE_PRINT_SCREEN = 283,
- SCANCODE_PAUSE = 284,
- SCANCODE_F1 = 290,
- SCANCODE_F2 = 291,
- SCANCODE_F3 = 292,
- SCANCODE_F4 = 293,
- SCANCODE_F5 = 294,
- SCANCODE_F6 = 295,
- SCANCODE_F7 = 296,
- SCANCODE_F8 = 297,
- SCANCODE_F9 = 298,
- SCANCODE_F10 = 299,
- SCANCODE_F11 = 300,
- SCANCODE_F12 = 301,
- SCANCODE_F13 = 302,
- SCANCODE_F14 = 303,
- SCANCODE_F15 = 304,
- SCANCODE_F16 = 305,
- SCANCODE_F17 = 306,
- SCANCODE_F18 = 307,
- SCANCODE_F19 = 308,
- SCANCODE_F20 = 309,
- SCANCODE_F21 = 310,
- SCANCODE_F22 = 311,
- SCANCODE_F23 = 312,
- SCANCODE_F24 = 313,
- SCANCODE_F25 = 314,
- SCANCODE_KP_0 = 320,
- SCANCODE_KP_1 = 321,
- SCANCODE_KP_2 = 322,
- SCANCODE_KP_3 = 323,
- SCANCODE_KP_4 = 324,
- SCANCODE_KP_5 = 325,
- SCANCODE_KP_6 = 326,
- SCANCODE_KP_7 = 327,
- SCANCODE_KP_8 = 328,
- SCANCODE_KP_9 = 329,
- SCANCODE_KP_DECIMAL = 330,
- SCANCODE_KP_DIVIDE = 331,
- SCANCODE_KP_MULTIPLY = 332,
- SCANCODE_KP_SUBTRACT = 333,
- SCANCODE_KP_ADD = 334,
- SCANCODE_KP_ENTER = 335,
- SCANCODE_KP_EQUAL = 336,
- SCANCODE_LEFT_SHIFT = 340,
- SCANCODE_LEFT_CONTROL = 341,
- SCANCODE_LEFT_ALT = 342,
- SCANCODE_LEFT_SUPER = 343,
- SCANCODE_RIGHT_SHIFT = 344,
- SCANCODE_RIGHT_CONTROL = 345,
- SCANCODE_RIGHT_ALT = 346,
- SCANCODE_RIGHT_SUPER = 347,
- SCANCODE_MENU = 348,
-}
-
-keymod_flags :: enum c.int {
- NONE = 0x00,
- ALT = 0x01,
- SHIFT = 0x02,
- CTRL = 0x04,
- CMD = 0x08,
- MAIN_MODIFIER = 0x10 /* CMD on Mac, CTRL on Win32 */
-}
-
-mouse_button :: enum c.int {
- LEFT = 0x00,
- RIGHT = 0x01,
- MIDDLE = 0x02,
- EXT1 = 0x03,
- EXT2 = 0x04,
-}
-
-// keyboard and mouse buttons input
-key_event :: struct {
- action: key_action,
- scanCode: scan_code,
- keyCode: key_code,
- button: mouse_button,
- mods: keymod_flags,
- clickCount: u8,
-}
-
-// character input
-char_event :: struct {
- codepoint: utf32,
- sequence: [8]c.char,
- seqLen: u8,
-}
-
-// mouse move/scroll
-mouse_event :: struct {
- x: f32,
- y: f32,
- deltaX: f32,
- deltaY: f32,
- mods: keymod_flags,
-}
-
-// window resize / move
-move_event :: struct {
- frame: rect,
- content: rect,
-}
-
-event :: struct {
- //TODO clipboard and path drop
- window: window,
- type: event_type,
-
- _: struct #raw_union {
- key: key_event,
- character: char_event,
- mouse: mouse_event,
- move: move_event,
- paths: str8_list,
- }
-}
diff --git a/core/sys/orca/graphics.odin b/core/sys/orca/graphics.odin
deleted file mode 100644
index 8ef478b2f..000000000
--- a/core/sys/orca/graphics.odin
+++ /dev/null
@@ -1,247 +0,0 @@
-package orca
-
-import "core:c"
-
-// types
-color :: distinct [4]f32
-utf32 :: rune
-
-// handles
-surface :: distinct u32
-font :: distinct u64
-image :: distinct u64
-canvas :: distinct u64
-
-joint_type :: enum c.int {
- MITER,
- BEVEL,
- NONE,
-}
-
-cap_type :: enum c.int {
- NONE,
- SQUARE,
-}
-
-font_metrics :: struct {
- ascent: f32, // the extent above the baseline (by convention a positive value extends above the baseline)
- descent: f32, // the extent below the baseline (by convention, positive value extends below the baseline)
- lineGap: f32, // spacing between one row's descent and the next row's ascent
- xHeight: f32, // height of the lower case letter 'x'
- capHeight: f32, // height of the upper case letter 'M'
- width: f32, // maximum width of the font
-}
-
-glyph_metrics :: struct {
- ink: rect,
- advance: vec2,
-}
-
-text_metrics :: struct {
- ink: rect,
- logical: rect,
- advance: vec2,
-}
-
-rect_atlas :: struct {
- arena: ^arena,
- size: vec2i,
- pos: vec2i,
- lineHeight: u32,
-}
-
-image_region :: struct {
- image: image,
- rect: rect,
-}
-
-//------------------------------------------------------------------------------------------
-// graphics surface
-//------------------------------------------------------------------------------------------
-@(default_calling_convention="c", link_prefix="oc_", link_suffix="_argptr_stub")
-foreign {
- surface_nil :: proc() -> surface ---
- surface_is_nil :: proc() -> c.bool ---
- surface_canvas :: proc(s: ^surface) ---
- surface_destroy :: proc(surface: surface) ---
-
- surface_get_size :: proc(surface: surface) -> vec2 ---
- surface_contents_scaling :: proc(surface: surface) -> vec2 ---
- surface_bring_to_front :: proc(surface: surface) ---
- surface_send_to_back :: proc(surface: surface) ---
-
- surface_gles :: proc(surface: ^surface) ---
- surface_select :: proc(surface: surface) ---
-
- surface_deselect :: proc() ---
- surface_present :: proc(surface: surface) ---
-}
-
-//------------------------------------------------------------------------------------------
-// 2D canvas command buffer
-//------------------------------------------------------------------------------------------
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- canvas_nil :: proc() -> canvas ---
- canvas_is_nil :: proc(canvas: canvas) -> c.bool ---
- canvas_create :: proc() -> canvas ---
- canvas_destroy :: proc(canvas: canvas) ---
- canvas_set_current :: proc(_canvas: canvas) -> canvas ---
- canvas_select :: proc(_canvas: canvas) -> canvas ---
- render :: proc(canvas: canvas) ---
-}
-
-//------------------------------------------------------------------------------------------
-// transform and clipping
-//------------------------------------------------------------------------------------------
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- matrix_push :: proc(mat: mat2x3) ---
- matrix_multiply_push :: proc(mat: mat2x3) ---
- matrix_pop :: proc() ---
- matrix_top :: proc() -> mat2x3 ---
-
- clip_push :: proc(x, y, w, h: f32) ---
- clip_pop :: proc() ---
- clip_top :: proc() -> rect ---
-}
-
-//------------------------------------------------------------------------------------------
-// graphics attributes setting/getting
-//------------------------------------------------------------------------------------------
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- set_color :: proc(color: color) ---
- set_color_rgba :: proc(r, g, b, a: f32) ---
- set_width :: proc(width: f32) ---
- set_tolerance :: proc(tolerance: f32) ---
- set_joint :: proc(joint: joint_type) ---
- set_max_joint_excursion :: proc(maxJointExcursion: f32) ---
- set_cap :: proc(cap: cap_type) ---
- set_font :: proc(font: font) ---
- set_font_size :: proc(size: f32) ---
- set_text_flip :: proc(flip: c.bool) ---
- set_image :: proc(image: image) ---
- set_image_source_region :: proc(region: rect) ---
-
- get_color :: proc() -> color ---
- get_width :: proc() -> f32 ---
- get_tolerance :: proc() -> f32 ---
- get_joint :: proc() -> joint_type ---
- get_max_joint_excursion :: proc() -> f32 ---
- get_cap :: proc() -> cap_type ---
- get_font :: proc() -> font ---
- get_font_size :: proc() -> f32 ---
- get_text_flip :: proc() -> bool ---
- get_image :: proc() -> image ---
-}
-
-//------------------------------------------------------------------------------------------
-// path construction
-//------------------------------------------------------------------------------------------
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- get_position :: proc() -> vec2 ---
- move_to :: proc(x, y: f32) ---
- line_to :: proc(x, y: f32) ---
- quadratic_to :: proc(x1, y1, x2, y2: f32) ---
- cubic_to :: proc(x1, y1, x2, y2, x3, y3: f32) ---
- close_path :: proc() ---
-
- glyph_outlines :: proc(glyphIndices: str32) -> rect ---
- codepoints_outlines :: proc(str: str32) ---
- text_outlines :: proc(str: str8) ---
-}
-
-//------------------------------------------------------------------------------------------
-// clear/fill/stroke
-//------------------------------------------------------------------------------------------
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- clear :: proc() ---
- fill :: proc() ---
- stroke :: proc() ---
-}
-
-//------------------------------------------------------------------------------------------
-// shapes helpers
-//------------------------------------------------------------------------------------------
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- rectangle_fill :: proc(x, y, w, h: f32) ---
- rectangle_stroke :: proc(x, y, w, h: f32) ---
- rounded_rectangle_fill :: proc(x, y, w, h, r: f32) ---
- rounded_rectangle_stroke :: proc(x, y, w, h, r: f32) ---
- ellipse_fill :: proc(x, y, rx, ry: f32) ---
- ellipse_stroke :: proc(x, y, rx, ry: f32) ---
- circle_fill :: proc(x, y, r: f32) ---
- circle_stroke :: proc(x, y, r: f32) ---
- arc :: proc(x, y, r, arcAngle, startAngle: f32) ---
- image_draw :: proc(image: image, rect: rect) ---
- image_draw_region :: proc(image: image, srcRegion, dstRegion: rect) ---
-
- text_fill :: proc(x, y: f32, text: str8) ---
-}
-
-//------------------------------------------------------------------------------------------
-// fonts
-//------------------------------------------------------------------------------------------
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- font_nil :: proc() -> font ---
- font_is_nil :: proc(font: font) -> c.bool ---
-
- font_create_from_memory :: proc(mem: str8, rangeCount: u32, ranges: [^]unicode_range) -> font ---
- font_create_from_file :: proc(file: file, rangeCount: u32, ranges: [^]unicode_range) -> font ---
- font_create_from_path :: proc(path: str8, rangeCount: u32, ranges: [^]unicode_range) -> font ---
-
- font_destroy :: proc(font: font) ---
-
- font_get_glyph_indices :: proc(font: font, codePoints: str32, backing: str32) -> str32 ---
- font_push_glyph_indices :: proc(arena: ^arena, font: font, codePoints: str32) -> str32 ---
- font_get_glyph_index :: proc(font: font, codePoint: utf32) -> u32 ---
-
- font_get_metrics :: proc(font: font, emSize: f32) -> font_metrics ---
- font_get_metrics_unscaled :: proc(font: font) -> font_metrics ---
- font_get_scale_for_em_pixels :: proc(font: font, emSize: f32) -> f32 ---
-
- font_text_metrics_utf32 :: proc(font: font, fontSize: f32, codepoints: str32) -> text_metrics ---
- font_text_metrics :: proc(font: font, fontSize: f32, text: str8) -> text_metrics ---
-}
-
-//------------------------------------------------------------------------------------------
-// images
-//------------------------------------------------------------------------------------------
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- image_nil :: proc() -> image ---
- image_is_nil :: proc(a: image) -> c.bool ---
-
- image_create :: proc(surface: surface, width, height: u32) -> image ---
- image_create_from_rgba8 :: proc(surface: surface, width, height: u32, pixels: [^]u8) -> image ---
- image_create_from_memory :: proc(surface: surface, mem: str8, flip: c.bool) -> image ---
- image_create_from_file :: proc(surface: surface, file: file, flip: c.bool) -> image ---
- image_create_from_path :: proc(surface: surface, path: str8, flip: c.bool) -> image ---
-
- image_destroy :: proc(image: image) ---
-
- image_upload_region_rgba8 :: proc(image: image, region: rect, pixels: [^]u8) ---
- image_size :: proc(image: image) -> vec2 ---
-}
-
-//------------------------------------------------------------------------------------------
-// image atlas
-//------------------------------------------------------------------------------------------
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- rect_atlas_create :: proc(arena: ^arena, width, height: i32) -> ^rect_atlas ---
- rect_atlas_alloc :: proc(atlas: ^rect_atlas, width, height: i32) -> rect ---
- rect_atlas_recycle :: proc(atlas: ^rect_atlas, rect: rect) ---
-
- image_atlas_allfrom_rgba8 :: proc(atlas: ^rect_atlas, backingImage: image, width, height: u32, pixels: [^]u8) -> image_region ---
- image_atlas_allfrom_memory :: proc(atlas: ^rect_atlas, backingImage: image, mem: str8, flip: c.bool) -> image_region ---
- image_atlas_allfrom_file :: proc(atlas: ^rect_atlas, backingImage: image, file: file, flip: c.bool) -> image_region ---
- image_atlas_allfrom_path :: proc(atlas: ^rect_atlas, backingImage: image, path: str8, flip: c.bool) -> image_region ---
-
- image_atlas_recycle :: proc(atlas: ^rect_atlas, imageRgn: image_region) ---
-}
diff --git a/core/sys/orca/input_state.odin b/core/sys/orca/input_state.odin
deleted file mode 100644
index d8779f453..000000000
--- a/core/sys/orca/input_state.odin
+++ /dev/null
@@ -1,59 +0,0 @@
-package orca
-
-import "core:c"
-
-key_state :: struct {
- lastUpdate: u64,
- transitionCount: u32,
- repeatCount: u32,
- down: c.bool,
- sysClicked: c.bool,
- sysDoubleClicked: c.bool,
- sysTripleClicked: c.bool,
-}
-
-keyboard_state :: struct {
- keys: [len(key_code)]key_state,
- mods: keymod_flags,
-}
-
-mouse_state :: struct {
- lastUpdate: u64,
- posValid: c.bool,
- pos: vec2,
- delta: vec2,
- wheel: vec2,
-
- _: struct #raw_union {
- buttons: [len(mouse_button)]key_state,
-
- _: struct {
- left: key_state,
- right: key_state,
- middle: key_state,
- ext1: key_state,
- ext2: key_state,
- }
- }
-}
-
-INPUT_TEXT_BACKING_SIZE :: 64
-
-text_state :: struct {
- lastUpdate: u64,
- backing: [INPUT_TEXT_BACKING_SIZE]utf32,
- codePoints: str32,
-}
-
-clipboard_state :: struct {
- lastUpdate: u64,
- pastedText: str8,
-}
-
-input_state :: struct {
- frameCounter: u64,
- keyboard: keyboard_state,
- mouse: mouse_state,
- text: text_state,
- clipboard: clipboard_state,
-}
diff --git a/core/sys/orca/io.odin b/core/sys/orca/io.odin
deleted file mode 100644
index 501a45623..000000000
--- a/core/sys/orca/io.odin
+++ /dev/null
@@ -1,159 +0,0 @@
-package orca
-
-import "core:c"
-
-file :: distinct u64 // handle
-
-file_access :: enum u16 {
- NONE = 0,
- READ = 1 << 1,
- WRITE = 1 << 2,
-}
-
-file_open_flags :: enum u16 {
- NONE = 0,
- APPEND = 1 << 1,
- TRUNCATE = 1 << 2,
- CREATE = 1 << 3,
-
- SYMLINK = 1 << 4,
- NO_FOLLOW = 1 << 5,
- RESTRICT = 1 << 6,
-}
-
-file_whence :: enum c.int {
- SEEK_SET,
- SEEK_END,
- SEEK_CURRENT,
-}
-
-io_error :: enum i32 {
- OK = 0,
- ERR_UNKNOWN,
- ERR_OP, // unsupported operation
- ERR_HANDLE, // invalid handle
- ERR_PREV, // previously had a fatal error (last error stored on handle)
- ERR_ARG, // invalid argument or argument combination
- ERR_PERM, // access denied
- ERR_SPACE, // no space left
- ERR_NO_ENTRY, // file or directory does not exist
- ERR_EXISTS, // file already exists
- ERR_NOT_DIR, // path element is not a directory
- ERR_DIR, // attempted to write directory
- ERR_MAX_FILES, // max open files reached
- ERR_MAX_LINKS, // too many symbolic links in path
- ERR_PATH_LENGTH, // path too long
- ERR_FILE_SIZE, // file too big
- ERR_OVERFLOW, // offset too big
- ERR_NOT_READY, // no data ready to be read/written
- ERR_MEM, // failed to allocate memory
- ERR_INTERRUPT, // operation interrupted by a signal
- ERR_PHYSICAL, // physical IO error
- ERR_NO_DEVICE, // device not found
- ERR_WALKOUT, // attempted to walk out of root directory
-}
-
-//----------------------------------------------------------------
-// File System wrapper API
-//----------------------------------------------------------------
-file_type :: enum c.int {
- UNKNOWN,
- REGULAR,
- DIRECTORY,
- SYMLINK,
- BLOCK,
- CHARACTER,
- FIFO,
- SOCKET,
-}
-
-file_perm :: enum u16 {
- OTHER_EXEC = 1 << 0,
- OTHER_WRITE = 1 << 1,
- OTHER_READ = 1 << 2,
-
- GROUP_EXEC = 1 << 3,
- GROUP_WRITE = 1 << 4,
- GROUP_READ = 1 << 5,
-
- OWNER_EXEC = 1 << 6,
- OWNER_WRITE = 1 << 7,
- OWNER_READ = 1 << 8,
-
- STICKY_BIT = 1 << 9,
- SET_GID = 1 << 10,
- SET_UID = 1 << 11,
-}
-
-datestamp :: struct {
- seconds: i64, // seconds relative to NTP epoch.
- fraction: u64, // fraction of seconds elapsed since the time specified by seconds.
-}
-
-file_status :: struct {
- uid: u64,
- type: file_type,
- perm: file_perm,
- size: u64,
-
- creationDate: datestamp,
- accessDate: datestamp,
- modificationDate: datestamp,
-}
-
-// TODO file dialogs
-
-// typedef struct oc_file_open_with_dialog_elt
-// {
-// oc_list_elt listElt;
-// oc_file file;
-// } oc_file_open_with_dialog_elt;
-
-// typedef struct oc_file_open_with_dialog_result
-// {
-// oc_file_dialog_button button;
-// oc_file file;
-// oc_list selection;
-// } oc_file_open_with_dialog_result;
-
-// file_open_with_dialog_result :: u64 // TODO
-// file_dialog_desc :: u64 // TODO
-
-//----------------------------------------------------------------
-// Low-level File IO API
-//----------------------------------------------------------------
-// @(default_calling_convention="c", link_prefix="oc_")
-// foreign {
-// oc_io_cmp oc_io_wait_single_req(oc_io_req* req);
-// }
-
-//----------------------------------------------------------------
-// High-level File IO API
-//----------------------------------------------------------------
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- file_nil :: proc() -> file ---
- file_is_nil :: proc(handle: file) -> c.bool ---
-
- file_open :: proc(path: str8, rights: file_access, flags: file_open_flags) -> file ---
- file_open_at :: proc(dir: file, path: str8, rights: file_access, flags: file_open_flags) -> file ---
- file_close :: proc(file: file) ---
- file_last_error :: proc(handle: file) -> io_error ---
-
- file_pos :: proc(file: file) -> i64 ---
- file_seek :: proc(file: file, offset: i64, whence: file_whence) -> i64 ---
- file_write :: proc(file: file, size: u64, buffer: [^]byte) -> u64 ---
- file_read :: proc(file: file, size: u64, buffer: [^]byte) -> u64 ---
-
- file_get_status :: proc(file: file) -> file_status ---
- file_size :: proc(file: file) -> u64 ---
-}
-
-//----------------------------------------------------------------
-// Asking users for file capabilities
-//----------------------------------------------------------------
-// @(default_calling_convention="c", link_prefix="oc_")
-// foreign {
-// file_open_with_request :: proc(path: str8, rights: file_access, flags: file_open_flags) -> file ---
-// file_open_with_dialog :: proc(arena: ^arena, rights: file_access, flags: file_open_flags, desc: ^file_dialog_desc) -> file_open_with_dialog_result ---
-// } \ No newline at end of file
diff --git a/core/sys/orca/lists.odin b/core/sys/orca/lists.odin
deleted file mode 100644
index fda0f5718..000000000
--- a/core/sys/orca/lists.odin
+++ /dev/null
@@ -1,117 +0,0 @@
-package orca
-
-// TODO could check if container/intrusive/list/intrusive_list.odin can be used
-
-//----------------------------------------------------------------
-// Lists
-//----------------------------------------------------------------
-list_elt :: struct {
- prev: ^list_elt,
- next: ^list_elt,
-}
-
-list :: struct {
- first: ^list_elt,
- last: ^list_elt,
-}
-
-list_init :: proc "c" (list: ^list) {
- list.first = nil
- list.last = nil
-}
-
-list_insert :: proc "c" (list: ^list, afterElt, elt: ^list_elt) {
- elt.prev = afterElt
- elt.next = afterElt.next
- if afterElt.next != nil {
- afterElt.next.prev = elt
- } else {
- list.last = elt
- }
- afterElt.next = elt
-
- // OC_DEBUG_ASSERT(elt.next != elt, "list_insert(): can't insert an element into itself")
-}
-
-list_insert_before :: proc "c" (list: ^list, beforeElt, elt: ^list_elt) {
- elt.next = beforeElt
- elt.prev = beforeElt.prev
-
- if beforeElt.prev != nil {
- beforeElt.prev.next = elt
- } else {
- list.first = elt
- }
- beforeElt.prev = elt
-
- // OC_DEBUG_ASSERT(elt.next != elt, "list_insert_before(): can't insert an element into itself")
-}
-
-list_remove :: proc "c" (list: ^list, elt: ^list_elt) {
- if elt.prev != nil {
- elt.prev.next = elt.next
- } else {
- // OC_DEBUG_ASSERT(list.first == elt)
- list.first = elt.next
- }
-
- if elt.next != nil {
- elt.next.prev = elt.prev
- } else {
- // OC_DEBUG_ASSERT(list.last == elt)
- list.last = elt.prev
- }
-
- elt.prev = nil
- elt.next = nil
-}
-
-list_push :: proc "c" (list: ^list, elt: ^list_elt) {
- elt.next = list.first
- elt.prev = nil
- if list.first != nil {
- list.first.prev = elt
- } else {
- list.last = elt
- }
- list.first = elt
-}
-
-list_pop :: proc "c" (list: ^list) -> ^list_elt {
- elt := list.first
- if elt != list.last {
- list_remove(list, elt)
- return elt
- } else {
- return nil
- }
-}
-
-list_push_back :: proc "c" (list: ^list, elt: ^list_elt) {
- elt.prev = list.last
- elt.next = nil
-
- if list.last != nil {
- list.last.next = elt
- } else {
- list.first = elt
- }
-
- list.last = elt
-}
-
-list_append :: list_push_back
-
-list_pop_back :: proc "c" (list: ^list) -> ^list_elt {
- elt := list.last
- if elt != nil {
- list_remove(list, elt)
- return elt
- } else {
- return nil
- }
-}
-
-list_empty :: proc "c" (list: ^list) -> bool {
- return list.first == nil || list.last == nil
-}
diff --git a/core/sys/orca/orca_graphics.odin b/core/sys/orca/orca_graphics.odin
new file mode 100644
index 000000000..740618f58
--- /dev/null
+++ b/core/sys/orca/orca_graphics.odin
@@ -0,0 +1,332 @@
+package orca
+
+import "core:c"
+
+
+surface_data :: struct {}
+canvas_backend :: struct {}
+
+
+surface_destroy_proc :: proc "c" (surface: ^surface_data)
+surface_select_proc :: proc "c" (surface: ^surface_data)
+surface_deselect_proc :: proc "c" (surface: ^surface_data)
+surface_present_proc :: proc "c" (surface: ^surface_data)
+surface_swap_interval_proc :: proc "c" (surface: ^surface_data, swap: c.int)
+
+surface_get_size_proc :: proc "c" (surface: ^surface_data) -> vec2
+surface_contents_scaling_proc :: proc "c" (surface: ^surface_data) -> vec2
+surface_get_hidden_proc :: proc "c" (surface: ^surface_data) -> bool
+surface_set_hidden_proc :: proc "c" (surface: ^surface_data, hidden: bool);
+surface_native_layer_proc :: proc "c" (surface: ^surface_data) -> rawptr
+
+surface_bring_to_front_proc :: proc "c" (surface: ^surface_data)
+surface_send_to_back_proc :: proc "c" (surface: ^surface_data)
+
+
+//------------------------------------------------------------------------
+// canvas structs
+//------------------------------------------------------------------------
+path_elt_type :: enum c.int {
+ MOVE,
+ LINE,
+ QUADRATIC,
+ CUBIC,
+}
+
+path_elt :: struct {
+ type: path_elt_type,
+ p: [3]vec2,
+}
+
+path_descriptor :: struct {
+ startIndex: u32,
+ count: u32,
+ startPoint: vec2,
+}
+
+attributes :: struct {
+ width: f32,
+ tolerance: f32,
+ color: color,
+ joint: joint_type,
+ maxJointExcursion: f32,
+ cap: cap_type,
+
+ font: font,
+ fontSize: f32,
+
+ image: image,
+ srcRegion: rect,
+
+ transform: mat2x3,
+ clip: rect,
+}
+
+primitive_cmd :: enum {
+ FILL,
+ STROKE,
+ JUMP,
+}
+
+primitive :: struct {
+ cmd: primitive_cmd,
+ attributes: attributes,
+
+ using _: struct #raw_union {
+ path: path_descriptor,
+ rect: rect,
+ jump: u32,
+ },
+}
+
+
+
+surface_api :: enum c.int {
+ NONE,
+ METAL,
+ GL,
+ GLES,
+ CANVAS,
+ HOST,
+}
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ is_surface_api_available :: proc(api: surface_api) -> bool ---
+}
+
+//------------------------------------------------------------------------------------------
+//SECTION: graphics surface
+//------------------------------------------------------------------------------------------
+surface :: struct {
+ h: u64,
+}
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ oc_surface_nil :: proc() -> surface --- //DOC: returns a nil surface
+ oc_surface_is_nil :: proc(surface: surface) -> bool --- //DOC: true if surface is nil
+
+ oc_surface_canvas :: proc() -> surface --- //DOC: creates a surface for use with the canvas API
+ oc_surface_gles :: proc() -> surface --- //DOC: create a surface for use with GLES API
+
+
+ oc_surface_destroy :: proc(surface: surface) --- //DOC: destroys the surface
+
+ oc_surface_select :: proc(surface: surface) --- //DOC: selects the surface in the current thread before drawing
+ oc_surface_deselect :: proc() --- //DOC: deselects the current thread's previously selected surface
+ oc_surface_get_selected :: proc() -> surface ---
+
+ oc_surface_present :: proc(surface: surface) --- //DOC: presents the surface to its window
+
+ oc_surface_get_size :: proc(surface: surface) -> vec2 ---
+ oc_surface_contents_scaling:: proc(surface: surface) -> vec2 --- //DOC: returns the scaling of the surface (pixels = points * scale)
+
+ oc_surface_bring_to_front :: proc(surface: surface) --- //DOC: puts surface on top of the surface stack
+ oc_surface_send_to_back :: proc(surface: surface) --- //DOC: puts surface at the bottom of the surface stack
+}
+
+//------------------------------------------------------------------------------------------
+//SECTION: graphics canvas structs
+//------------------------------------------------------------------------------------------
+canvas :: struct {h: u64}
+font :: struct {h: u64}
+image :: struct {h: u64}
+
+joint_type :: enum c.int {
+ MITER = 0,
+ BEVEL,
+ NONE,
+}
+
+cap_type :: enum c.int {
+ NONE = 0,
+ SQUARE,
+}
+
+font_metrics :: struct {
+ ascent: f32, // the extent above the baseline (by convention a positive value extends above the baseline)
+ descent: f32, // the extent below the baseline (by convention, positive value extends below the baseline)
+ lineGap: f32, // spacing between one row's descent and the next row's ascent
+ xHeight: f32, // height of the lower case letter 'x'
+ capHeight: f32, // height of the upper case letter 'M'
+ width: f32, // maximum width of the font
+}
+
+glyph_metrics :: struct {
+ ink: rect,
+ advance: vec2,
+}
+
+text_metrics :: struct {
+ ink: rect,
+ logical: rect,
+ advance: vec2,
+}
+
+//NOTE: image atlas helpers
+image_region :: struct {
+ image: image,
+ rect: rect,
+}
+
+/*
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ //------------------------------------------------------------------------------------------
+ //SECTION: graphics canvas
+ //------------------------------------------------------------------------------------------
+ ORCA_API oc_canvas oc_canvas_nil(); //DOC: returns a nil canvas
+ ORCA_API bool oc_canvas_is_nil(oc_canvas canvas); //DOC: true if canvas is nil
+
+ ORCA_API oc_canvas oc_canvas_create(); //DOC: create a new canvas
+ ORCA_API void oc_canvas_destroy(oc_canvas canvas); //DOC: destroys canvas
+ ORCA_API oc_canvas oc_canvas_select(oc_canvas canvas); //DOC: selects canvas in the current thread
+ ORCA_API void oc_render(oc_canvas canvas); //DOC: renders all canvas commands onto surface
+
+ //------------------------------------------------------------------------------------------
+ //SECTION: fonts
+ //------------------------------------------------------------------------------------------
+ ORCA_API oc_font oc_font_nil();
+ ORCA_API bool oc_font_is_nil(oc_font font);
+
+ ORCA_API oc_font oc_font_create_from_memory(oc_str8 mem, u32 rangeCount, oc_unicode_range* ranges);
+ ORCA_API oc_font oc_font_create_from_file(oc_file file, u32 rangeCount, oc_unicode_range* ranges);
+ ORCA_API oc_font oc_font_create_from_path(oc_str8 path, u32 rangeCount, oc_unicode_range* ranges);
+
+ ORCA_API void oc_font_destroy(oc_font font);
+
+ ORCA_API oc_str32 oc_font_get_glyph_indices(oc_font font, oc_str32 codePoints, oc_str32 backing);
+ ORCA_API oc_str32 oc_font_push_glyph_indices(oc_arena* arena, oc_font font, oc_str32 codePoints);
+ ORCA_API u32 oc_font_get_glyph_index(oc_font font, oc_utf32 codePoint);
+
+ // metrics
+ ORCA_API oc_font_metrics oc_font_get_metrics(oc_font font, f32 emSize);
+ ORCA_API oc_font_metrics oc_font_get_metrics_unscaled(oc_font font);
+ ORCA_API f32 oc_font_get_scale_for_em_pixels(oc_font font, f32 emSize);
+
+ ORCA_API oc_text_metrics oc_font_text_metrics_utf32(oc_font font, f32 fontSize, oc_str32 codepoints);
+ ORCA_API oc_text_metrics oc_font_text_metrics(oc_font font, f32 fontSize, oc_str8 text);
+
+ //------------------------------------------------------------------------------------------
+ //SECTION: images
+ //------------------------------------------------------------------------------------------
+ ORCA_API oc_image oc_image_nil();
+ ORCA_API bool oc_image_is_nil(oc_image a);
+
+ ORCA_API oc_image oc_image_create(oc_surface surface, u32 width, u32 height);
+ ORCA_API oc_image oc_image_create_from_rgba8(oc_surface surface, u32 width, u32 height, u8* pixels);
+ ORCA_API oc_image oc_image_create_from_memory(oc_surface surface, oc_str8 mem, bool flip);
+ ORCA_API oc_image oc_image_create_from_file(oc_surface surface, oc_file file, bool flip);
+ ORCA_API oc_image oc_image_create_from_path(oc_surface surface, oc_str8 path, bool flip);
+
+ ORCA_API void oc_image_destroy(oc_image image);
+
+ ORCA_API void oc_image_upload_region_rgba8(oc_image image, oc_rect region, u8* pixels);
+ ORCA_API oc_vec2 oc_image_size(oc_image image);
+
+ //------------------------------------------------------------------------------------------
+ //SECTION: atlasing
+ //------------------------------------------------------------------------------------------
+
+ //NOTE: rectangle allocator
+ typedef struct oc_rect_atlas oc_rect_atlas;
+
+ ORCA_API oc_rect_atlas* oc_rect_atlas_create(oc_arena* arena, i32 width, i32 height);
+ ORCA_API oc_rect oc_rect_atlas_alloc(oc_rect_atlas* atlas, i32 width, i32 height);
+ ORCA_API void oc_rect_atlas_recycle(oc_rect_atlas* atlas, oc_rect rect);
+
+ ORCA_API oc_image_region oc_image_atlas_alloc_from_rgba8(oc_rect_atlas* atlas, oc_image backingImage, u32 width, u32 height, u8* pixels);
+ ORCA_API oc_image_region oc_image_atlas_alloc_from_memory(oc_rect_atlas* atlas, oc_image backingImage, oc_str8 mem, bool flip);
+ ORCA_API oc_image_region oc_image_atlas_alloc_from_file(oc_rect_atlas* atlas, oc_image backingImage, oc_file file, bool flip);
+ ORCA_API oc_image_region oc_image_atlas_alloc_from_path(oc_rect_atlas* atlas, oc_image backingImage, oc_str8 path, bool flip);
+ ORCA_API void oc_image_atlas_recycle(oc_rect_atlas* atlas, oc_image_region imageRgn);
+
+ //------------------------------------------------------------------------------------------
+ //SECTION: transform, viewport and clipping
+ //------------------------------------------------------------------------------------------
+ ORCA_API void oc_matrix_push(oc_mat2x3 matrix);
+ ORCA_API void oc_matrix_multiply_push(oc_mat2x3 matrix);
+ ORCA_API void oc_matrix_pop();
+ ORCA_API oc_mat2x3 oc_matrix_top();
+
+ ORCA_API void oc_clip_push(f32 x, f32 y, f32 w, f32 h);
+ ORCA_API void oc_clip_pop();
+ ORCA_API oc_rect oc_clip_top();
+
+ //------------------------------------------------------------------------------------------
+ //SECTION: graphics attributes setting/getting
+ //------------------------------------------------------------------------------------------
+ ORCA_API void oc_set_color(oc_color color);
+ ORCA_API void oc_set_color_rgba(f32 r, f32 g, f32 b, f32 a);
+ ORCA_API void oc_set_width(f32 width);
+ ORCA_API void oc_set_tolerance(f32 tolerance);
+ ORCA_API void oc_set_joint(oc_joint_type joint);
+ ORCA_API void oc_set_max_joint_excursion(f32 maxJointExcursion);
+ ORCA_API void oc_set_cap(oc_cap_type cap);
+ ORCA_API void oc_set_font(oc_font font);
+ ORCA_API void oc_set_font_size(f32 size);
+ ORCA_API void oc_set_text_flip(bool flip);
+ ORCA_API void oc_set_image(oc_image image);
+ ORCA_API void oc_set_image_source_region(oc_rect region);
+
+ ORCA_API oc_color oc_get_color();
+ ORCA_API f32 oc_get_width();
+ ORCA_API f32 oc_get_tolerance();
+ ORCA_API oc_joint_type oc_get_joint();
+ ORCA_API f32 oc_get_max_joint_excursion();
+ ORCA_API oc_cap_type oc_get_cap();
+ ORCA_API oc_font oc_get_font();
+ ORCA_API f32 oc_get_font_size();
+ ORCA_API bool oc_get_text_flip();
+ ORCA_API oc_image oc_get_image();
+ ORCA_API oc_rect oc_get_image_source_region();
+
+ //------------------------------------------------------------------------------------------
+ //SECTION: path construction
+ //------------------------------------------------------------------------------------------
+ ORCA_API oc_vec2 oc_get_position();
+ ORCA_API void oc_move_to(f32 x, f32 y);
+ ORCA_API void oc_line_to(f32 x, f32 y);
+ ORCA_API void oc_quadratic_to(f32 x1, f32 y1, f32 x2, f32 y2);
+ ORCA_API void oc_cubic_to(f32 x1, f32 y1, f32 x2, f32 y2, f32 x3, f32 y3);
+ ORCA_API void oc_close_path();
+
+ ORCA_API oc_rect oc_glyph_outlines(oc_str32 glyphIndices);
+ ORCA_API void oc_codepoints_outlines(oc_str32 string);
+ ORCA_API void oc_text_outlines(oc_str8 string);
+
+ //------------------------------------------------------------------------------------------
+ //SECTION: clear/fill/stroke
+ //------------------------------------------------------------------------------------------
+ ORCA_API void oc_clear();
+ ORCA_API void oc_fill();
+ ORCA_API void oc_stroke();
+
+ //------------------------------------------------------------------------------------------
+ //SECTION: shapes helpers
+ //------------------------------------------------------------------------------------------
+ ORCA_API void oc_rectangle_fill(f32 x, f32 y, f32 w, f32 h);
+ ORCA_API void oc_rectangle_stroke(f32 x, f32 y, f32 w, f32 h);
+ ORCA_API void oc_rounded_rectangle_fill(f32 x, f32 y, f32 w, f32 h, f32 r);
+ ORCA_API void oc_rounded_rectangle_stroke(f32 x, f32 y, f32 w, f32 h, f32 r);
+ ORCA_API void oc_ellipse_fill(f32 x, f32 y, f32 rx, f32 ry);
+ ORCA_API void oc_ellipse_stroke(f32 x, f32 y, f32 rx, f32 ry);
+ ORCA_API void oc_circle_fill(f32 x, f32 y, f32 r);
+ ORCA_API void oc_circle_stroke(f32 x, f32 y, f32 r);
+ ORCA_API void oc_arc(f32 x, f32 y, f32 r, f32 arcAngle, f32 startAngle);
+
+ ORCA_API void oc_text_fill(f32 x, f32 y, oc_str8 text);
+
+ //NOTE: image helpers
+ ORCA_API void oc_image_draw(oc_image image, oc_rect rect);
+ ORCA_API void oc_image_draw_region(oc_image image, oc_rect srcRegion, oc_rect dstRegion);
+}
+
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ egl_surface_create_for_window :: proc(window: window) -> ^surface_data ---
+ egl_surface_create_remote :: proc(width, height: u32) -> ^surface_data ---
+}
+*/ \ No newline at end of file
diff --git a/core/sys/orca/orca_strings.odin b/core/sys/orca/orca_strings.odin
new file mode 100644
index 000000000..67fa6a639
--- /dev/null
+++ b/core/sys/orca/orca_strings.odin
@@ -0,0 +1,40 @@
+package orca
+
+import "core:c"
+import ilist "core:container/intrusive/list"
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ str8_push_buffer :: proc(arena: ^arena, len: u64, buffer: rawptr) -> str8 ---
+ str8_push_cstring :: proc(arena: ^arena, str: cstring) -> str8 ---
+ str8_push_copy :: proc(arena: ^arena, s: string) -> str8 ---
+ str8_to_cstring :: proc(arena: ^arena, s: str8) -> cstring ---
+}
+
+
+// string lists
+//----------------------------------------------------------------------------------
+str8_elt :: struct {
+ listElt: list_elt,
+ string: str8,
+}
+
+str8_list :: struct {
+ list: list,
+ eltCount: u64,
+ len: u64,
+}
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ str8_list_push :: proc(arena: ^arena, list: ^str8_list, str: string) ---
+
+ str8_list_collate :: proc(arena: ^arena, list: str8_list, prefix, separator, postfix: string) -> str8 ---
+ str8_list_join :: proc(arena: ^arena, list: str8_list) -> str8 ---
+ str8_split :: proc(arena: ^arena, str: string, separators: str8_list) -> str8_list ---
+
+ win32_utf8_to_wide :: proc(arena: ^arena, s: str8) -> str16 ---
+ win32_wide_to_utf8 :: proc(arena: ^arena, s: str16) -> str8 ---
+ win32_path_normalize_slash_in_place :: proc(path: []byte) ---
+}
+
diff --git a/core/sys/orca/orca_threads.odin b/core/sys/orca/orca_threads.odin
new file mode 100644
index 000000000..29f6b1a3c
--- /dev/null
+++ b/core/sys/orca/orca_threads.odin
@@ -0,0 +1,75 @@
+package orca
+
+import "core:c"
+
+THREAD_NAME_MAX_SIZE :: 64 // including null terminator
+
+
+thread :: struct {}
+
+thread_start_proc :: proc "c" (userPointer: rawptr) -> i32
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ thread_create :: proc(start: thread_start_proc, userPointer: rawptr) -> ^thread ---
+ thread_create_with_name :: proc(start: thread_start_proc, userPointer: rawptr, name: string) -> ^thread ---
+ thread_get_name :: proc(thread: ^thread) -> string ---
+ thread_unique_id :: proc(thread: ^thread) -> u64 ---
+ thread_self_id :: proc() -> u64 ---
+ thread_signal :: proc(thread: ^thread, sig: c.int) -> c.int ---
+ thread_join :: proc(thread: ^thread, exitCode: ^i64) -> c.int ---
+ thread_detach :: proc(thread: ^thread) -> c.int ---
+}
+
+//---------------------------------------------------------------
+// Platform Mutex API
+//---------------------------------------------------------------
+
+mutex :: struct {}
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ mutex_create :: proc() -> ^mutex ---
+ mutex_destroy :: proc(mutex: ^mutex) -> c.int ---
+ mutex_lock :: proc(mutex: ^mutex) -> c.int ---
+ mutex_unlock :: proc(mutex: ^mutex) -> c.int ---
+}
+
+//---------------------------------------------------------------
+// Lightweight ticket mutex API
+//---------------------------------------------------------------
+
+ticket :: struct {
+ nextTicket: u64, // volatile and atomic
+ serving: u64, // volatile and atomic
+}
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ ticket_init :: proc(mutex: ^ticket) ---
+ ticket_lock :: proc(mutex: ^ticket) ---
+ ticket_unlock :: proc(mutex: ^ticket) ---
+}
+
+//---------------------------------------------------------------
+// Platform condition variable API
+//---------------------------------------------------------------
+
+condition :: struct {}
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ condition_create :: proc() -> ^condition ---
+ condition_destroy :: proc(cond: ^condition) -> c.int ---
+ condition_wait :: proc(cond: ^condition, mutex: ^mutex) -> c.int ---
+ condition_timedwait :: proc(cond: ^condition, mutex: ^mutex, seconds: f64) -> c.int ---
+ condition_signal :: proc(cond: ^condition) -> c.int ---
+ condition_broadcast :: proc(cond: ^condition) -> c.int ---
+}
+//---------------------------------------------------------------
+// Putting threads to sleep
+//---------------------------------------------------------------
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ sleep_nano :: proc(nanoseconds: u64) --- // sleep for a given number of nanoseconds
+} \ No newline at end of file
diff --git a/core/sys/orca/orca_types.odin b/core/sys/orca/orca_types.odin
new file mode 100644
index 000000000..45d476ad6
--- /dev/null
+++ b/core/sys/orca/orca_types.odin
@@ -0,0 +1,807 @@
+package orca
+
+import "core:c"
+import ilist "core:container/intrusive/list"
+
+list_elt :: ilist.Node
+list :: ilist.List
+
+vec2 :: [2]f32
+vec3 :: [3]f32
+vec4 :: [4]f32
+vec2i :: [2]i32
+mat2x3 :: #row_major matrix[2, 3]f32
+rect :: struct {
+ x, y: f32,
+ w, h: f32,
+}
+
+color :: distinct [4]f32
+
+str8 :: string
+str16 :: []u16
+str32 :: []rune
+
+
+
+clock_kind :: enum c.int {
+ MONOTONIC, // clock that increment monotonically
+ UPTIME, // clock that increment monotonically during uptime
+ DATE // clock that is driven by the platform time
+}
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ clock_time :: proc(clock: clock_kind) -> f64 ---
+}
+
+
+//----------------------------------------------------------------
+// Assert / Abort
+//----------------------------------------------------------------
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ abort_ext :: proc(file: cstring, function: cstring, line: c.int, fmt: cstring, #c_vararg args: ..any) -> ! ---
+ assert_fail :: proc(file: cstring, function: cstring, line: c.int, src: cstring, fmt: cstring, #c_vararg args: ..any) -> ! ---
+}
+
+//----------------------------------------------------------------
+// Logging
+//----------------------------------------------------------------
+log_level :: enum c.int {
+ ERROR,
+ WARNING,
+ INFO,
+}
+
+log_output :: struct {}
+
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ @(link_name="OC_LOG_DEFAULT_OUTPUT")
+ LOG_DEFAULT_OUTPUT: ^log_output
+
+ log_set_level :: proc(level: log_level) ---
+ log_set_output :: proc(output: ^log_output) ---
+ log_ext :: proc(level: log_level,
+ function: cstring,
+ file: cstring,
+ line: c.int,
+ fmt: cstring,
+ #c_vararg args: ..any) ---
+}
+
+//--------------------------------------------------------------------------------
+//NOTE(martin): base allocator
+//--------------------------------------------------------------------------------
+mem_reserve_proc :: proc "c" (ctx: ^base_allocator, size: u64) -> rawptr
+mem_modify_proc :: proc "c" (ctx: ^base_allocator, ptr: rawptr, size: u64)
+
+base_allocator :: struct {
+ reserve: mem_reserve_proc,
+ commit: mem_modify_proc,
+ decommit: mem_modify_proc,
+ release: mem_modify_proc,
+
+}
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ base_allocator_default :: proc() -> ^base_allocator ---
+}
+
+
+//--------------------------------------------------------------------------------
+//NOTE(martin): memory arena
+//--------------------------------------------------------------------------------
+
+arena_chunk :: struct {
+ listElt: list_elt,
+ ptr: [^]byte,
+ offset: u64,
+ committed: u64,
+ cap: u64,
+}
+
+arena :: struct {
+ base: ^base_allocator,
+ chunks: list,
+ currentChunk: ^arena_chunk,
+}
+
+arena_scope :: struct {
+ arena: ^arena,
+ chunk: ^arena_chunk,
+ offset: u64,
+}
+
+arena_options :: struct {
+ base: ^base_allocator,
+ reserve: u64,
+}
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ arena_init :: proc(arena: ^arena) ---
+ arena_init_with_options :: proc(arena: ^arena, #by_ptr options: arena_options) ---
+ arena_cleanup :: proc(arena: ^arena) ---
+
+ arena_push :: proc(arena: ^arena, size: u64) -> rawptr ---
+ arena_push_aligned :: proc(arena: ^arena, size: u64, alignment: u32) -> rawptr ---
+
+ arena_clear :: proc(arena: ^arena) ---
+
+ arena_scope_begin :: proc(arena: ^arena) -> arena_scope ---
+ arena_scope_end :: proc(scope: arena_scope) ---
+}
+
+
+
+arena_push_type :: proc "c" (arena: ^arena, $T: typeid) -> ^T {
+ return (^T)(arena_push_aligned(arena, size_of(type), align_of(type)))
+}
+arena_push_array :: proc "c" (arena: ^arena, $T: typeid, #any_int count: int) -> []T {
+ return ([^]T)(arena_push_aligned(arena, size_of(type)*u64(count), align_of(type)))[:count]
+}
+
+
+
+
+
+//----------------------------------------------------------------
+// IO API
+//----------------------------------------------------------------
+
+file :: struct {
+ h: u64,
+}
+
+file_open_flags :: distinct bit_set[file_open_flags_enum; u16]
+file_open_flags_enum :: enum u16 {
+ APPEND = 1,
+ TRUNCATE = 2,
+ CREATE = 3,
+
+ SYMLINK = 4,
+ NO_FOLLOW = 5,
+ RESTRICT = 6,
+}
+
+file_access :: distinct bit_set[file_access_enum; u16]
+
+file_access_enum :: enum u16 {
+ READ = 1,
+ WRITE = 2,
+}
+
+file_whence :: enum c.int {
+ SET,
+ END,
+ CURRENT,
+}
+
+io_req_id :: distinct u64
+
+io_op :: enum u32 {
+ OPEN_AT = 0,
+ CLOSE,
+
+ FSTAT,
+
+ SEEK,
+ READ,
+ WRITE,
+
+ ERROR,
+};
+
+io_req :: struct {
+ id: io_req_id,
+ op: io_op,
+ handle: file,
+
+ offset: i64,
+ size: u64,
+
+ using _: struct #raw_union {
+ buffer: [^]byte,
+ _: u64,
+ },
+ using _: struct #raw_union {
+ open: struct {
+ rights: file_access,
+ flags: file_open_flags,
+ },
+ whence: file_whence,
+ },
+}
+
+
+io_error :: enum u32 {
+ NONE = 0,
+ UNKNOWN,
+ OP, // unsupported operation
+ HANDLE, // invalid handle
+ PREV, // previously had a fatal error (last error stored on handle)
+ ARG, // invalid argument or argument combination
+ PERM, // access denied
+ SPACE, // no space left
+ NO_ENTRY, // file or directory does not exist
+ EXISTS, // file already exists
+ NOT_DIR, // path element is not a directory
+ DIR, // attempted to write directory
+ MAX_FILES, // max open files reached
+ MAX_LINKS, // too many symbolic links in path
+ PATH_LENGTH, // path too long
+ FILE_SIZE, // file too big
+ OVERFLOW, // offset too big
+ NOT_READY, // no data ready to be read/written
+ MEM, // failed to allocate memory
+ INTERRUPT, // operation interrupted by a signal
+ PHYSICAL, // physical IO error
+ NO_DEVICE, // device not found
+ WALKOUT, // attempted to walk out of root directory
+}
+
+io_cmp :: struct {
+ id: io_req_id,
+ error: io_error,
+
+ using _: struct #raw_union {
+ result: i64,
+ size: u64,
+ offset: i64,
+ handle: file,
+ }
+}
+
+
+@(default_calling_convention="c", link_prefix="oc_", link_suffix="_argptr_stub")
+foreign {
+ //----------------------------------------------------------------
+ //TODO: complete io queue api
+ //----------------------------------------------------------------
+ io_wait_single_req :: proc(req: ^io_req) -> io_cmp ---
+}
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ //----------------------------------------------------------------
+ // File IO wrapper API
+ //----------------------------------------------------------------
+
+ file_nil :: proc() -> file ---
+ file_is_nil :: proc(handle: file) -> bool ---
+
+ file_open :: proc(path: string, rights: file_access, flags: file_open_flags) -> file ---
+ file_open_at :: proc(dir: file, path: string, rights: file_access, flags: file_open_flags) -> file ---
+ file_close :: proc(file: file) ---
+
+ file_pos :: proc(file: file) -> i64 ---
+ file_seek :: proc(file: file, offset: i64, whence: file_whence) -> i64 ---
+
+ file_write :: proc(file: file, size: u64, buffer: rawptr) -> u64 ---
+ file_read :: proc(file: file, size: u64, buffer: rawptr) -> u64 ---
+
+ file_last_error :: proc(handle: file) -> io_error ---
+}
+
+
+//----------------------------------------------------------------
+// File System wrapper API
+//----------------------------------------------------------------
+
+file_type :: enum c.int {
+ UNKNOWN,
+ REGULAR,
+ DIRECTORY,
+ SYMLINK,
+ BLOCK,
+ CHARACTER,
+ FIFO,
+ SOCKET,
+}
+
+file_perm :: distinct bit_set[file_perm_enum; u16]
+
+file_perm_enum :: enum u16 {
+ OTHER_EXEC = 0,
+ OTHER_WRITE = 1,
+ OTHER_READ = 2,
+
+ GROUP_EXEC = 3,
+ GROUP_WRITE = 4,
+ GROUP_READ = 5,
+
+ OWNER_EXEC = 6,
+ OWNER_WRITE = 7,
+ OWNER_READ = 8,
+
+ STICKY_BIT = 9,
+ SET_GID = 10,
+ SET_UID = 11,
+}
+
+datestamp :: struct {
+ seconds: i64, // seconds relative to NTP epoch.
+ fraction: u64, // fraction of seconds elapsed since the time specified by seconds.
+}
+
+file_status :: struct {
+ uid: u64,
+ type: file_type,
+ perm: file_perm,
+ size: u64,
+
+ creationDate: datestamp,
+ accessDate: datestamp,
+ modificationDate: datestamp,
+}
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ file_get_status :: proc(file: file) -> file_status ---
+ file_size :: proc(file: file) -> u64 ---
+}
+
+
+
+file_open_with_dialog_elt :: struct {
+ listElt: list_elt,
+ file: file,
+}
+
+file_open_with_dialog_result :: struct {
+ button: file_dialog_button,
+ file: file,
+ selection: list,
+}
+
+
+@(default_calling_convention="c", link_prefix="oc_", link_suffix="_argptr_stub")
+foreign {
+ file_open_with_request :: proc(path: string, rights: file_access, flags: file_open_flags) -> file ---
+ file_open_with_dialog :: proc(arena: ^arena, rights: file_access, flags: file_open_flags, #by_ptr desc: file_dialog_desc) -> file_open_with_dialog_result ---
+}
+
+
+//--------------------------------------------------------------------
+// App typedefs, enums and constants
+//--------------------------------------------------------------------
+
+
+window :: struct {
+ h: u64,
+}
+
+mouse_cursor :: enum c.int {
+ ARROW,
+ RESIZE_0,
+ RESIZE_90,
+ RESIZE_45,
+ RESIZE_135,
+ TEXT,
+}
+
+window_style :: distinct bit_set[window_style_enum; u32]
+
+window_style_enum :: enum u32 {
+ NO_TITLE = 0,
+ FIXED_SIZE = 1,
+ NO_CLOSE = 2,
+ NO_MINIFY = 3,
+ NO_FOCUS = 4,
+ FLOAT = 5,
+ POPUPMENU = 6,
+ NO_BUTTONS = 7,
+}
+
+event_type :: enum c.int {
+ NONE,
+ KEYBOARD_MODS, //TODO: remove, keep only key?
+ KEYBOARD_KEY,
+ KEYBOARD_CHAR,
+ MOUSE_BUTTON,
+ MOUSE_MOVE,
+ MOUSE_WHEEL,
+ MOUSE_ENTER,
+ MOUSE_LEAVE,
+ CLIPBOARD_PASTE,
+ WINDOW_RESIZE,
+ WINDOW_MOVE,
+ WINDOW_FOCUS,
+ WINDOW_UNFOCUS,
+ WINDOW_HIDE, // rename to minimize?
+ WINDOW_SHOW, // rename to restore?
+ WINDOW_CLOSE,
+ PATHDROP,
+ FRAME,
+ QUIT,
+}
+
+key_action :: enum c.int {
+ NO_ACTION,
+ PRESS,
+ RELEASE,
+ REPEAT,
+}
+
+scan_code :: enum c.int {
+ 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,
+}
+
+key_code :: enum c.int {
+ UNKNOWN = 0,
+ SPACE = ' ',
+ APOSTROPHE = '\'',
+ COMMA = ',',
+ MINUS = '-',
+ PERIOD = '.',
+ SLASH = '/',
+ _0 = '0',
+ _1 = '1',
+ _2 = '2',
+ _3 = '3',
+ _4 = '4',
+ _5 = '5',
+ _6 = '6',
+ _7 = '7',
+ _8 = '8',
+ _9 = '9',
+ SEMICOLON = ';',
+ EQUAL = '=',
+ LEFT_BRACKET = '[',
+ BACKSLASH = '\\',
+ RIGHT_BRACKET = ']',
+ GRAVE_ACCENT = '`',
+ A = 'a',
+ B = 'b',
+ C = 'c',
+ D = 'd',
+ E = 'e',
+ F = 'f',
+ G = 'g',
+ H = 'h',
+ I = 'i',
+ J = 'j',
+ K = 'k',
+ L = 'l',
+ M = 'm',
+ N = 'n',
+ O = 'o',
+ P = 'p',
+ Q = 'q',
+ R = 'r',
+ S = 's',
+ T = 't',
+ U = 'u',
+ V = 'v',
+ W = 'w',
+ X = 'x',
+ Y = 'y',
+ Z = 'z',
+ WORLD_1,
+ WORLD_2,
+ ESCAPE,
+ ENTER,
+ TAB,
+ BACKSPACE,
+ INSERT,
+ DELETE,
+ RIGHT,
+ LEFT,
+ DOWN,
+ UP,
+ PAGE_UP,
+ PAGE_DOWN,
+ HOME,
+ END,
+ CAPS_LOCK,
+ SCROLL_LOCK,
+ NUM_LOCK,
+ PRINT_SCREEN,
+ PAUSE,
+ F1,
+ F2,
+ F3,
+ F4,
+ F5,
+ F6,
+ F7,
+ F8,
+ F9,
+ F10,
+ F11,
+ F12,
+ F13,
+ F14,
+ F15,
+ F16,
+ F17,
+ F18,
+ F19,
+ F20,
+ F21,
+ F22,
+ F23,
+ F24,
+ F25,
+ KP_0,
+ KP_1,
+ KP_2,
+ KP_3,
+ KP_4,
+ KP_5,
+ KP_6,
+ KP_7,
+ KP_8,
+ KP_9,
+ KP_DECIMAL,
+ KP_DIVIDE,
+ KP_MULTIPLY,
+ KP_SUBTRACT,
+ KP_ADD,
+ KP_ENTER,
+ KP_EQUAL,
+ LEFT_SHIFT,
+ LEFT_CONTROL,
+ LEFT_ALT,
+ LEFT_SUPER,
+ RIGHT_SHIFT,
+ RIGHT_CONTROL,
+ RIGHT_ALT,
+ RIGHT_SUPER,
+ MENU,
+}
+
+keymod_flags :: distinct bit_set[keymod_flags_enum; c.int]
+keymod_flags_enum :: enum c.int {
+ ALT = 0,
+ SHIFT = 1,
+ CTRL = 2,
+ CMD = 3,
+ MAIN_MODIFIER = 4, // CMD on Mac, CTRL on Win32
+}
+
+
+mouse_button :: enum {
+ LEFT = 0x00,
+ RIGHT = 0x01,
+ MIDDLE = 0x02,
+ EXT1 = 0x03,
+ EXT2 = 0x04,
+}
+
+key_event :: struct { // keyboard and mouse buttons input
+ action: key_action,
+ scanCode: scan_code,
+ keyCode: key_code,
+ button: mouse_button,
+ mods: keymod_flags,
+ clickCount: u8,
+}
+
+char_event :: struct { // character input
+ codepoint: rune,
+ sequence: [8]u8 `fmt:"s,seqLen"`,
+ seqLen: u8,
+}
+
+mouse_event :: struct { // mouse move/scroll
+ x: f32,
+ y: f32,
+ deltaX: f32,
+ deltaY: f32,
+ mods: keymod_flags,
+}
+
+move_event :: struct { // window resize / move
+ frame: rect,
+ content: rect,
+}
+
+event :: struct {
+ //TODO clipboard and path drop
+ window: window,
+ type: event_type,
+
+ using _: struct #raw_union {
+ key: key_event,
+ character: char_event,
+ mouse: mouse_event,
+ move: move_event,
+ paths: str8_list,
+ },
+}
+
+file_dialog_kind :: enum c.int {
+ SAVE,
+ OPEN,
+}
+
+file_dialog_flags :: distinct bit_set[file_dialog_flags_enum; u32]
+file_dialog_flags_enum :: enum u32 {
+ FILES = 0,
+ DIRECTORIES = 1,
+ MULTIPLE = 2,
+ CREATE_DIRECTORIES = 3,
+}
+
+file_dialog_desc :: struct {
+ kind: file_dialog_kind,
+ flags: file_dialog_flags,
+ title: str8,
+ okLabel: str8,
+ startAt: file,
+ startPath: str8,
+ filters: str8_list,
+ //... later customization options with checkboxes / radiobuttons
+}
+
+file_dialog_button :: enum c.int {
+ CANCEL = 0,
+ OK,
+}
+
+file_dialog_result :: struct {
+ button: file_dialog_button,
+ path: str8,
+ selection: str8_list,
+}
+
+
+
+@(default_calling_convention="c", link_prefix="oc_", link_suffix="_argptr_stub")
+foreign {
+ window_set_title :: proc(title: str8) ---
+ window_set_size :: proc(size: vec2) ---
+
+ clipboard_set_string :: proc(string: str8) ---
+}
+
+@(default_calling_convention="c", link_prefix="oc_", link_suffix="_argptr_stub")
+foreign {
+ request_quit :: proc() ---
+ scancode_to_keycode :: proc(scanCode: scan_code) -> key_code ---
+}
+
+
+/*NOTE:
+ by convention, functions that take an arena and return a path
+ allocated on that arena allocate 1 more character and null-terminate
+ the string.
+*/
+
+@(default_calling_convention="c", link_prefix="oc_")
+foreign {
+ path_slice_directory :: proc(path: string) -> string ---
+ path_slice_filename :: proc(path: string) -> string ---
+
+ path_split :: proc(arena: ^arena, path: string) -> str8_list ---
+ path_join :: proc(arena: ^arena, elements: str8_list) -> string ---
+ path_append :: proc(arena: ^arena, parent, relPath: string) -> string ---
+
+ path_is_absolute :: proc(path: string) -> bool ---
+} \ No newline at end of file
diff --git a/core/sys/orca/orca.odin b/core/sys/orca/typedefs.odin
index 4c5d886dc..4c5d886dc 100644
--- a/core/sys/orca/orca.odin
+++ b/core/sys/orca/typedefs.odin
diff --git a/core/sys/orca/ui.odin b/core/sys/orca/ui.odin
deleted file mode 100644
index 6b2d93750..000000000
--- a/core/sys/orca/ui.odin
+++ /dev/null
@@ -1,685 +0,0 @@
-package orca
-
-import "core:c"
-
-ui_key :: struct {
- hash: u64
-}
-
-ui_axis :: enum c.int {
- X,
- Y,
-}
-
-ui_align :: enum c.int {
- START,
- END,
- CENTER,
-}
-
-ui_layout_align :: [2]ui_align
-
-ui_layout :: struct {
- axis: ui_axis,
- spacing: f32,
- margin: [2]f32,
- align: ui_layout_align,
-}
-
-ui_size_kind :: enum c.int {
- TEXT,
- PIXELS,
- CHILDREN,
- PARENT,
- PARENT_MINUS_PIXELS,
-}
-
-ui_size :: struct {
- kind: ui_size_kind,
- value: f32,
- relax: f32,
- minSize: f32,
-}
-
-ui_box_size :: [2]ui_size
-ui_box_floating :: [2]c.bool
-
-//NOTE: flags for axis-dependent properties (e.g. UI_STYLE_FLOAT_X/Y) need to be consecutive bits
-// in order to play well with axis agnostic functions
-ui_style_mask :: enum u64 {
- NONE = 0,
- SIZE_WIDTH = 1 << 1,
- SIZE_HEIGHT = 1 << 2,
- LAYOUT_AXIS = 1 << 3,
- LAYOUT_ALIGN_X = 1 << 4,
- LAYOUT_ALIGN_Y = 1 << 5,
- LAYOUT_SPACING = 1 << 6,
- LAYOUT_MARGIN_X = 1 << 7,
- LAYOUT_MARGIN_Y = 1 << 8,
- FLOAT_X = 1 << 9,
- FLOAT_Y = 1 << 10,
- COLOR = 1 << 11,
- BG_COLOR = 1 << 12,
- BORDER_COLOR = 1 << 13,
- BORDER_SIZE = 1 << 14,
- ROUNDNESS = 1 << 15,
- FONT = 1 << 16,
- FONT_SIZE = 1 << 17,
- ANIMATION_TIME = 1 << 18,
- ANIMATION_MASK = 1 << 19,
-
- //masks
- SIZE = SIZE_WIDTH | SIZE_HEIGHT,
-
- LAYOUT_MARGINS = LAYOUT_MARGIN_X | LAYOUT_MARGIN_Y,
-
- LAYOUT = LAYOUT_AXIS | LAYOUT_ALIGN_X | LAYOUT_ALIGN_Y | LAYOUT_SPACING | LAYOUT_MARGIN_X | LAYOUT_MARGIN_Y,
-
- FLOAT = FLOAT_X | FLOAT_Y,
-
- MASK_INHERITED = COLOR | FONT | FONT_SIZE | ANIMATION_TIME | ANIMATION_MASK,
-}
-
-ui_style :: struct {
- size: ui_box_size,
- layout: ui_layout,
- floating: ui_box_floating,
- floatTarget: vec2,
- _color: color,
- bgColor: color,
- borderColor: color,
- font: font,
- fontSize: f32,
- borderSize: f32,
- roundness: f32,
- animationTime: f32,
- animationMask: ui_style_mask,
-}
-
-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,
-}
-
-// TODO exteern
-// ui_palette: UI_DARK_PALETTE
-// ui_palette: UI_LIGHT_PALETTE
-
-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,
-}
-
-@export UI_DARK_THEME: ui_theme
-@export UI_LIGHT_THEME: ui_theme
-
-ui_tag :: struct {
- hash: u64,
-}
-
-ui_selector_kind :: enum c.int {
- ANY,
- OWNER,
- TEXT,
- TAG,
- STATUS,
- KEY,
-}
-
-ui_status :: enum u8 {
- NONE = 0,
- HOVER = 1 << 1,
- HOT = 1 << 2,
- ACTIVE = 1 << 3,
- DRAGGING = 1 << 4,
-}
-
-ui_selector_op :: enum c.int {
- DESCENDANT = 0,
- AND = 1,
-}
-
-ui_selector :: struct {
- listElt: list_elt,
- kind: ui_selector_kind,
- op: ui_selector_op,
-
- type: struct #raw_union {
- text: str8,
- key: ui_key,
- tag: ui_tag,
- status: ui_status,
- }
-}
-
-ui_pattern :: struct {
- l: list,
-}
-
-ui_style_rule :: struct {
- boxElt: list_elt,
- buildElt: list_elt,
- tmpElt: list_elt,
-
- owner: ^ui_box,
- pattern: ui_pattern,
- mask: ui_style_mask,
- style: ^ui_style,
-}
-
-ui_sig :: struct {
- box: ^ui_box,
-
- mouse: vec2,
- delta: vec2,
- wheel: vec2,
-
- pressed: c.bool,
- released: c.bool,
- clicked: c.bool,
- doubleClicked: c.bool,
- tripleClicked: c.bool,
- rightPressed: c.bool,
-
- dragging: c.bool,
- hovering: c.bool,
-
- pasted: c.bool,
-
-}
-
-ui_box_draw_proc :: proc "c" (box: ^ui_box, data: rawptr)
-
-ui_flags :: enum c.int {
- NONE = 0,
- CLICKABLE = (1 << 0),
- SCROLL_WHEEL_X = (1 << 1),
- SCROLL_WHEEL_Y = (1 << 2),
- BLOCK_MOUSE = (1 << 3),
- HOT_ANIMATION = (1 << 4),
- ACTIVE_ANIMATION = (1 << 5),
- //WARN: these two following flags need to be kept as consecutive bits to
- // play well with axis-agnostic functions
- OVERFLOW_ALLOW_X = (1 << 6),
- OVERFLOW_ALLOW_Y = (1 << 7),
- CLIP = (1 << 8),
- DRAW_BACKGROUND = (1 << 9),
- DRAW_FOREGROUND = (1 << 10),
- DRAW_BORDER = (1 << 11),
- DRAW_TEXT = (1 << 12),
- DRAW_PROC = (1 << 13),
-
- OVERLAY = (1 << 16),
-}
-
-ui_box :: struct {
- // hierarchy
- listElt: list_elt,
- children: list,
- parent: ^ui_box,
-
- overlayElt: list_elt,
-
- // keying and caching
- bucketElt: list_elt,
- key: ui_key,
- frameCounter: u64,
-
- // builder-provided info
- flags: ui_flags,
- string: str8,
- tags: list,
-
- drawProc: ui_box_draw_proc,
- drawData: rawptr,
-
- // styling
- beforeRules: list,
- afterRules: list,
-
- //ui_style_tag tag
- targetStyle: ^ui_style,
- style: ui_style,
- z: u32,
-
- floatPos: vec2,
- childrenSum: [2]f32,
- spacing: [2]f32,
- minSize: [2]f32,
- rect: rect,
-
- // signals
- sig: ^ui_sig,
-
- // stateful behaviour
- fresh: c.bool,
- closed: c.bool,
- parentClosed: c.bool,
- dragging: c.bool,
- hot: c.bool,
- active: c.bool,
- scroll: vec2,
- pressedMouse: vec2,
-
- // animation data
- hotTransition: f32,
- activeTransition: f32,
-}
-
-UI_MAX_INPUT_CHAR_PER_FRAME :: 64
-
-ui_input_text :: struct {
- count: u8,
- codePoints: [UI_MAX_INPUT_CHAR_PER_FRAME]utf32,
-}
-
-ui_stack_elt :: struct {
- parent: ^ui_stack_elt,
-
- _: struct #raw_union {
- box: ^ui_box,
- size: ui_size,
- clip: rect,
- }
-}
-
-ui_tag_elt :: struct {
- listElt: list_elt,
- tag: ui_tag,
-}
-
-UI_BOX_MAP_BUCKET_COUNT :: 1024
-
-ui_edit_move :: enum c.int {
- NONE,
- CHAR,
- WORD,
- LINE,
-}
-
-ui_context :: struct {
- init: c.bool,
-
- input: input_state,
-
- frameCounter: u64,
- frameTime: f64,
- lastFrameDuration: f64,
-
- frameArena: arena,
- boxPool: pool,
- boxMap: [UI_BOX_MAP_BUCKET_COUNT]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,
-
- clipboardRegistered: c.bool,
-
- theme: ^ui_theme,
-}
-
-ui_text_box_result :: struct {
- changed: c.bool,
- accepted: c.bool,
- text: str8,
-}
-
-ui_select_popup_info :: struct {
- changed: bool,
- selectedIndex: int, // -1 if nothing is selected
- optionCount: int,
- options: [^]str8,
- placeholder: str8,
-}
-
-ui_radio_group_info :: struct {
- changed: bool,
- selectedIndex: int, // -1 if nothing is selected
- optionCount: int,
- options: [^]str8,
-}
-
-//----------------------------------------------------------------
-// Context and frame lifecycle
-//----------------------------------------------------------------
-
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- ui_init :: proc(ctx: ^ui_context) ---
- ui_get_context :: proc() -> ^ui_context ---
- ui_set_context :: proc(ctx: ^ui_context) ---
-
- ui_process_event :: proc(event: ^event) ---
- ui_begin_frame :: proc(size: vec2, defaultStyle: ^ui_style, mask: ui_style_mask) ---
- ui_end_frame :: proc() ---
- ui_draw :: proc() ---
-}
-
-@(deferred_none=ui_end_frame)
-ui_frame :: proc "c" (size: vec2, defaultStyle: ^ui_style, mask: ui_style_mask) {
- ui_begin_frame(size, defaultStyle, mask)
-}
-ui_frame_scoped :: ui_frame
-
-//----------------------------------------------------------------
-// Common widget helpers
-//----------------------------------------------------------------
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- ui_label :: proc(label: cstring) -> ui_sig ---
- ui_label_str8 :: proc(label: str8) -> ui_sig ---
- ui_button :: proc(label: cstring) -> ui_sig ---
- ui_checkbox :: proc(name: cstring, checked: ^c.bool) -> ui_sig ---
- ui_slider :: proc(label: cstring, value: ^f32) -> ^ui_box ---
- ui_scrollbar :: proc(label: cstring, thumbRatio: f32, scrollValue: ^f32) -> ^ui_box ---
- ui_text_box :: proc(name: cstring, arena: ^arena, text: str8) -> ui_text_box_result ---
- ui_select_popup :: proc(name: cstring, info: ^ui_select_popup_info) -> ui_select_popup_info ---
- ui_radio_group :: proc(name: cstring, info: ^ui_radio_group_info) -> ui_radio_group_info ---
-
- ui_panel_begin :: proc(name: cstring, flags: ui_flags) ---
- ui_panel_end :: proc() ---
-
- ui_menu_bar_begin :: proc(label: cstring) ---
- ui_menu_bar_end :: proc() ---
-
- ui_menu_begin :: proc(label: cstring) ---
- ui_menu_end :: proc() ---
-
- ui_menu_button :: proc(name: cstring) -> ui_sig ---
-
- ui_tooltip_begin :: proc(name: cstring) -> ui_sig ---
- ui_tooltip_end :: proc() ---
-}
-
-@(deferred_none=ui_panel_end)
-ui_panel :: proc "c" (name: cstring, flags: ui_flags) {
- ui_panel_begin(name, flags)
-}
-ui_panel_scoped :: ui_panel
-
-@(deferred_none=ui_menu_bar_end)
-ui_menu_bar :: proc "c" (label: cstring) {
- ui_menu_bar_begin(label)
-}
-ui_menu_bar_scoped :: ui_menu_bar
-
-@(deferred_none=ui_menu_end)
-ui_menu :: proc "c" (label: cstring) {
- ui_menu_begin(label)
-}
-ui_menu_scoped :: ui_menu
-
-@(deferred_none=ui_tooltip_end)
-ui_tooltip :: proc "c" (label: cstring) -> ui_sig {
- return ui_tooltip_begin(label)
-}
-ui_tooltip_scoped :: ui_menu
-
-//-------------------------------------------------------------------------------------
-// Styling
-//-------------------------------------------------------------------------------------
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- ui_style_next :: proc(style: ^ui_style, mask: ui_style_mask) ---
-
- ui_pattern_push :: proc(arena: ^arena, pattern: ^ui_pattern, selector: ui_selector) ---
- ui_pattern_all :: proc() -> ui_pattern ---
- ui_pattern_owner :: proc() -> ui_pattern ---
-
- ui_style_match_before :: proc(pattern: ui_pattern, style: ^ui_style, mask: ui_style_mask) ---
- ui_style_match_after :: proc(pattern: ui_pattern, style: ^ui_style, mask: ui_style_mask) ---
-}
-
-//-------------------------------------------------------------------------------------
-// BOX
-//-------------------------------------------------------------------------------------
-
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- ui_box_make_str8 :: proc(str: str8, flags: ui_flags) -> ^ui_box ---
- ui_box_begin_str8 :: proc(str: str8, flags: ui_flags) -> ^ui_box ---
- ui_box_end :: proc() -> ^ui_box ---
-}
-
-@(deferred_none=ui_box_end)
-ui_container :: proc "c" (str: string, flags: ui_flags) -> ^ui_box {
- return ui_box_begin_str8(str, flags)
-}
-
-@(deferred_none=ui_box_end)
-ui_container_str8 :: proc "c" (str: str8, flags: ui_flags) -> ^ui_box {
- return ui_box_begin_str8(str, flags)
-}
-
-ui_box_make :: proc "c" (str: string, flags: ui_flags) -> ^ui_box {
- return ui_box_make_str8(str, flags)
-}
-
-ui_box_begin :: proc "c" (str: string, flags: ui_flags) -> ^ui_box {
- return ui_box_begin_str8(str, flags)
-}
-
-//-------------------------------------------------------------------------------------
-// BOX
-//-------------------------------------------------------------------------------------
-
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- ui_tag_make_str8 :: proc(str: str8) -> ui_tag ---
- ui_tag_box_str8 :: proc(box: ^ui_box, str: str8) ---
- ui_tag_next_str8 :: proc(str: str8) ---
-}
-
-ui_tag_make :: proc "c" (s: string) -> ui_tag {
- return ui_tag_make_str8(s)
-}
-
-ui_tag_box :: proc "c" (b: ^ui_box, s: string) {
- ui_tag_box_str8(b, s)
-}
-
-ui_tag_next :: proc "c" (s: string) {
- ui_tag_next_str8(s)
-}
diff --git a/core/sys/orca/utf8.odin b/core/sys/orca/utf8.odin
deleted file mode 100644
index 4800fb3fa..000000000
--- a/core/sys/orca/utf8.odin
+++ /dev/null
@@ -1,131 +0,0 @@
-package orca
-
-unicode_range :: struct {
- firstCodePoint: utf32,
- count: u32,
-}
-
-UNICODE_BASIC_LATIN :: unicode_range { 0x0000, 127 }
-UNICODE_C1_CONTROLS_AND_LATIN_1_SUPPLEMENT :: unicode_range { 0x0080, 127 }
-UNICODE_LATIN_EXTENDED_A :: unicode_range { 0x0100, 127 }
-UNICODE_LATIN_EXTENDED_B :: unicode_range { 0x0180, 207 }
-UNICODE_IPA_EXTENSIONS :: unicode_range { 0x0250, 95 }
-UNICODE_SPACING_MODIFIER_LETTERS :: unicode_range { 0x02b0, 79 }
-UNICODE_COMBINING_DIACRITICAL_MARKS :: unicode_range { 0x0300, 111 }
-UNICODE_GREEK_COPTIC :: unicode_range { 0x0370, 143 }
-UNICODE_CYRILLIC :: unicode_range { 0x0400, 255 }
-UNICODE_CYRILLIC_SUPPLEMENT :: unicode_range { 0x0500, 47 }
-UNICODE_ARMENIAN :: unicode_range { 0x0530, 95 }
-UNICODE_HEBREW :: unicode_range { 0x0590, 111 }
-UNICODE_ARABIC :: unicode_range { 0x0600, 255 }
-UNICODE_SYRIAC :: unicode_range { 0x0700, 79 }
-UNICODE_THAANA :: unicode_range { 0x0780, 63 }
-UNICODE_DEVANAGARI :: unicode_range { 0x0900, 127 }
-UNICODE_BENGALI_ASSAMESE :: unicode_range { 0x0980, 127 }
-UNICODE_GURMUKHI :: unicode_range { 0x0a00, 127 }
-UNICODE_GUJARATI :: unicode_range { 0x0a80, 127 }
-UNICODE_ORIYA :: unicode_range { 0x0b00, 127 }
-UNICODE_TAMIL :: unicode_range { 0x0b80, 127 }
-UNICODE_TELUGU :: unicode_range { 0x0c00, 127 }
-UNICODE_KANNADA :: unicode_range { 0x0c80, 127 }
-UNICODE_MALAYALAM :: unicode_range { 0x0d00, 255 }
-UNICODE_SINHALA :: unicode_range { 0x0d80, 127 }
-UNICODE_THAI :: unicode_range { 0x0e00, 127 }
-UNICODE_LAO :: unicode_range { 0x0e80, 127 }
-UNICODE_TIBETAN :: unicode_range { 0x0f00, 255 }
-UNICODE_MYANMAR :: unicode_range { 0x1000, 159 }
-UNICODE_GEORGIAN :: unicode_range { 0x10a0, 95 }
-UNICODE_HANGUL_JAMO :: unicode_range { 0x1100, 255 }
-UNICODE_ETHIOPIC :: unicode_range { 0x1200, 383 }
-UNICODE_CHEROKEE :: unicode_range { 0x13a0, 95 }
-UNICODE_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS :: unicode_range { 0x1400, 639 }
-UNICODE_OGHAM :: unicode_range { 0x1680, 31 }
-UNICODE_RUNIC :: unicode_range { 0x16a0, 95 }
-UNICODE_TAGALOG :: unicode_range { 0x1700, 31 }
-UNICODE_HANUNOO :: unicode_range { 0x1720, 31 }
-UNICODE_BUHID :: unicode_range { 0x1740, 31 }
-UNICODE_TAGBANWA :: unicode_range { 0x1760, 31 }
-UNICODE_KHMER :: unicode_range { 0x1780, 127 }
-UNICODE_MONGOLIAN :: unicode_range { 0x1800, 175 }
-UNICODE_LIMBU :: unicode_range { 0x1900, 79 }
-UNICODE_TAI_LE :: unicode_range { 0x1950, 47 }
-UNICODE_KHMER_SYMBOLS :: unicode_range { 0x19e0, 31 }
-UNICODE_PHONETIC_EXTENSIONS :: unicode_range { 0x1d00, 127 }
-UNICODE_LATIN_EXTENDED_ADDITIONAL :: unicode_range { 0x1e00, 255 }
-UNICODE_GREEK_EXTENDED :: unicode_range { 0x1f00, 255 }
-UNICODE_GENERAL_PUNCTUATION :: unicode_range { 0x2000, 111 }
-UNICODE_SUPERSCRIPTS_AND_SUBSCRIPTS :: unicode_range { 0x2070, 47 }
-UNICODE_CURRENCY_SYMBOLS :: unicode_range { 0x20a0, 47 }
-UNICODE_COMBINING_DIACRITICAL_MARKS_FOR_SYMBOLS :: unicode_range { 0x20d0, 47 }
-UNICODE_LETTERLIKE_SYMBOLS :: unicode_range { 0x2100, 79 }
-UNICODE_NUMBER_FORMS :: unicode_range { 0x2150, 63 }
-UNICODE_ARROWS :: unicode_range { 0x2190, 111 }
-UNICODE_MATHEMATICAL_OPERATORS :: unicode_range { 0x2200, 255 }
-UNICODE_MISCELLANEOUS_TECHNICAL :: unicode_range { 0x2300, 255 }
-UNICODE_CONTROL_PICTURES :: unicode_range { 0x2400, 63 }
-UNICODE_OPTICAL_CHARACTER_RECOGNITION :: unicode_range { 0x2440, 31 }
-UNICODE_ENCLOSED_ALPHANUMERICS :: unicode_range { 0x2460, 159 }
-UNICODE_BOX_DRAWING :: unicode_range { 0x2500, 127 }
-UNICODE_BLOCK_ELEMENTS :: unicode_range { 0x2580, 31 }
-UNICODE_GEOMETRIC_SHAPES :: unicode_range { 0x25a0, 95 }
-UNICODE_MISCELLANEOUS_SYMBOLS :: unicode_range { 0x2600, 255 }
-UNICODE_DINGBATS :: unicode_range { 0x2700, 191 }
-UNICODE_MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A :: unicode_range { 0x27c0, 47 }
-UNICODE_SUPPLEMENTAL_ARROWS_A :: unicode_range { 0x27f0, 15 }
-UNICODE_BRAILLE_PATTERNS :: unicode_range { 0x2800, 255 }
-UNICODE_SUPPLEMENTAL_ARROWS_B :: unicode_range { 0x2900, 127 }
-UNICODE_MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B :: unicode_range { 0x2980, 127 }
-UNICODE_SUPPLEMENTAL_MATHEMATICAL_OPERATORS :: unicode_range { 0x2a00, 255 }
-UNICODE_MISCELLANEOUS_SYMBOLS_AND_ARROWS :: unicode_range { 0x2b00, 255 }
-UNICODE_CJK_RADICALS_SUPPLEMENT :: unicode_range { 0x2e80, 127 }
-UNICODE_KANGXI_RADICALS :: unicode_range { 0x2f00, 223 }
-UNICODE_IDEOGRAPHIC_DESCRIPTION_CHARACTERS :: unicode_range { 0x2ff0, 15 }
-UNICODE_CJK_SYMBOLS_AND_PUNCTUATION :: unicode_range { 0x3000, 63 }
-UNICODE_HIRAGANA :: unicode_range { 0x3040, 95 }
-UNICODE_KATAKANA :: unicode_range { 0x30a0, 95 }
-UNICODE_BOPOMOFO :: unicode_range { 0x3100, 47 }
-UNICODE_HANGUL_COMPATIBILITY_JAMO :: unicode_range { 0x3130, 95 }
-UNICODE_KANBUN_KUNTEN :: unicode_range { 0x3190, 15 }
-UNICODE_BOPOMOFO_EXTENDED :: unicode_range { 0x31a0, 31 }
-UNICODE_KATAKANA_PHONETIC_EXTENSIONS :: unicode_range { 0x31f0, 15 }
-UNICODE_ENCLOSED_CJK_LETTERS_AND_MONTHS :: unicode_range { 0x3200, 255 }
-UNICODE_CJK_COMPATIBILITY :: unicode_range { 0x3300, 255 }
-UNICODE_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A :: unicode_range { 0x3400, 6591 }
-UNICODE_YIJING_HEXAGRAM_SYMBOLS :: unicode_range { 0x4dc0, 63 }
-UNICODE_CJK_UNIFIED_IDEOGRAPHS :: unicode_range { 0x4e00, 20911 }
-UNICODE_YI_SYLLABLES :: unicode_range { 0xa000, 1167 }
-UNICODE_YI_RADICALS :: unicode_range { 0xa490, 63 }
-UNICODE_HANGUL_SYLLABLES :: unicode_range { 0xac00, 11183 }
-UNICODE_HIGH_SURROGATE_AREA :: unicode_range { 0xd800, 1023 }
-UNICODE_LOW_SURROGATE_AREA :: unicode_range { 0xdc00, 1023 }
-UNICODE_PRIVATE_USE_AREA :: unicode_range { 0xe000, 6399 }
-UNICODE_CJK_COMPATIBILITY_IDEOGRAPHS :: unicode_range { 0xf900, 511 }
-UNICODE_ALPHABETIC_PRESENTATION_FORMS :: unicode_range { 0xfb00, 79 }
-UNICODE_ARABIC_PRESENTATION_FORMS_A :: unicode_range { 0xfb50, 687 }
-UNICODE_VARIATION_SELECTORS :: unicode_range { 0xfe00, 15 }
-UNICODE_COMBINING_HALF_MARKS :: unicode_range { 0xfe20, 15 }
-UNICODE_CJK_COMPATIBILITY_FORMS :: unicode_range { 0xfe30, 31 }
-UNICODE_SMALL_FORM_VARIANTS :: unicode_range { 0xfe50, 31 }
-UNICODE_ARABIC_PRESENTATION_FORMS_B :: unicode_range { 0xfe70, 143 }
-UNICODE_HALFWIDTH_AND_FULLWIDTH_FORMS :: unicode_range { 0xff00, 239 }
-UNICODE_SPECIALS :: unicode_range { 0xfff0, 15 }
-UNICODE_LINEAR_B_SYLLABARY :: unicode_range { 0x10000, 127 }
-UNICODE_LINEAR_B_IDEOGRAMS :: unicode_range { 0x10080, 127 }
-UNICODE_AEGEAN_NUMBERS :: unicode_range { 0x10100, 63 }
-UNICODE_OLD_ITALIC :: unicode_range { 0x10300, 47 }
-UNICODE_GOTHIC :: unicode_range { 0x10330, 31 }
-UNICODE_UGARITIC :: unicode_range { 0x10380, 31 }
-UNICODE_DESERET :: unicode_range { 0x10400, 79 }
-UNICODE_SHAVIAN :: unicode_range { 0x10450, 47 }
-UNICODE_OSMANYA :: unicode_range { 0x10480, 47 }
-UNICODE_CYPRIOT_SYLLABARY :: unicode_range { 0x10800, 63 }
-UNICODE_BYZANTINE_MUSICAL_SYMBOLS :: unicode_range { 0x1d000, 255 }
-UNICODE_MUSICAL_SYMBOLS :: unicode_range { 0x1d100, 255 }
-UNICODE_TAI_XUAN_JING_SYMBOLS :: unicode_range { 0x1d300, 95 }
-UNICODE_MATHEMATICAL_ALPHANUMERIC_SYMBOLS :: unicode_range { 0x1d400, 1023 }
-UNICODE_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B :: unicode_range { 0x20000, 42719 }
-UNICODE_CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT :: unicode_range { 0x2f800, 543 }
-UNICODE_TAGS :: unicode_range { 0xe0000, 127 }
-UNICODE_VARIATION_SELECTORS_SUPPLEMENT :: unicode_range { 0xe0100, 239 }
-UNICODE_SUPPLEMENTARY_PRIVATE_USE_AREA_A :: unicode_range { 0xf0000, 65533 }
-UNICODE_SUPPLEMENTARY_PRIVATE_USE_AREA_B :: unicode_range { 0x100000, 65533 }
diff --git a/core/sys/orca/util.odin b/core/sys/orca/util.odin
deleted file mode 100644
index c1ec9a765..000000000
--- a/core/sys/orca/util.odin
+++ /dev/null
@@ -1,266 +0,0 @@
-package orca
-
-import "core:c"
-import "core:fmt"
-import "core:runtime"
-import "core:intrinsics"
-
-//----------------------------------------------------------------
-// Arenas
-//----------------------------------------------------------------
-
-mem_reserve_proc :: proc "c" (ctx: ^base_allocator, size: u64)
-mem_modify_proc :: proc "c" (ctx: ^base_allocator, ptr: rawptr, size: u64)
-
-base_allocator :: struct {
- reserve: mem_reserve_proc,
- commit: mem_modify_proc,
- decommit: mem_modify_proc,
- release: mem_modify_proc,
-}
-
-arena_chunk :: struct {
- listElt: list_elt,
- ptr: [^]byte,
- offset: u64,
- committed: u64,
- cap: u64,
-}
-
-arena :: struct {
- base: ^base_allocator,
- chunks: list,
- currentChunk: ^arena_chunk,
-}
-
-arena_scope :: struct {
- arena: ^arena,
- chunk: ^arena_chunk,
- offset: u64,
-}
-
-arena_options :: struct {
- base: ^base_allocator,
- reserve: u64,
-}
-
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- arena_init :: proc(arena: ^arena) ---
- arena_init_with_options :: proc(arena: ^arena, options: ^arena_options) ---
- arena_cleanup :: proc(arena: ^arena) ---
-
- arena_push :: proc(arena: ^arena, size: u64) -> rawptr ---
- arena_clear :: proc(arena: ^arena) ---
-
- arena_scope_begin :: proc(arena: ^arena) -> arena_scope ---
- arena_scope_end :: proc(scope: arena_scope) ---
-
- scratch_begin :: proc() -> arena_scope ---
- scratch_begin_next :: proc(used: ^arena) -> arena_scope ---
-}
-
-arena_push_type :: proc "c" (arena: ^arena, $T: typeid) -> ^T {
- return cast(^T) arena_push(arena, size_of(T))
-}
-
-arena_push_array :: proc "c" (arena: ^arena, $T: typeid, count: int) -> []T {
- return ([^]T)(arena_push(arena, size_of(T)))[:count]
-}
-
-scratch_end :: arena_scope_end
-
-//----------------------------------------------------------------
-// Pool
-//----------------------------------------------------------------
-
-pool :: struct {
- arena: arena,
- freeList: list,
- blockSize: u64,
-}
-
-pool_options :: struct {
- base: ^base_allocator,
- reserve: u64,
-}
-
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- pool_init :: proc(pool: ^pool, blockSize: u64) ---
- pool_init_with_options :: proc(pool: ^pool, blockSize: u64, options: ^pool_options) ---
- pool_cleanup :: proc(pool: ^pool) ---
-
- pool_alloc :: proc(pool: ^pool) -> rawptr ---
- pool_recycle :: proc(pool: ^pool, ptr: rawptr) ---
- pool_clear :: proc(pool: ^pool) ---
-}
-
-pool_alloc_type :: proc "c" (arena: ^arena, $T: typeid) -> ^T {
- return cast(^T) pool_alloc(arena)
-}
-
-// TODO support list macros?
-// #define list_entry :: proc(ptr, type, member)
-// #define list_next_entry :: proc(list, elt, type, member)
-// #define list_prev_entry :: proc(list, elt, type, member)
-// #define list_first_entry :: proc(list, type, member)
-// #define list_last_entry :: proc(list, type, member)
-// #define list_pop_entry :: proc(list, type, member)
-
-// @(default_calling_convention="c", link_prefix="oc_")
-// foreign {
-// list_init :: proc(list: ^list) ---
-// list_empty :: proc(list: ^list) -> c.bool ---
-
-// list_begin :: proc(list: ^list) -> ^list_elt ---
-// list_end :: proc(list: ^list) -> ^list_elt ---
-// list_last :: proc(list: ^list) -> ^list_elt ---
-
-// list_insert :: proc(list: ^list, afterElt: ^list_elt, elt: ^list_elt) ---
-// list_insert_before :: proc(list: ^list, beforeElt: ^list_elt, elt: ^list_elt) ---
-// list_remove :: proc(list: ^list, elt: ^list_elt) ---
-// list_push :: proc(list: ^list, elt: ^list_elt) ---
-// list_pop :: proc(list: ^list) -> ^list_elt ---
-// list_push_back :: proc(list: ^list, elt: ^list_elt) ---
-// list_pop_back :: proc(list: ^list) -> ^list_elt ---
-// }
-
-//------------------------------------------------------------------------------------------
-// for iterators
-//------------------------------------------------------------------------------------------
-
-List_Iterator :: struct($T: typeid) {
- iterate: ^list,
- curr: ^list_elt,
- index: int,
- offset: uintptr,
-}
-
-// NOTE(Skytrias): intrusive list iterator
-list_iter_init :: proc "c" (iterate: ^list, $T: typeid, $field_name: string) -> (res: List_Iterator(T))
- where intrinsics.type_has_field(T, field_name),
- intrinsics.type_field_type(T, field_name) == list_elt {
- res.iterate = iterate
- res.curr = list_begin(iterate)
- res.offset = offset_of_by_string(T, field_name)
- return
-}
-
-list_iterate :: proc "c" (iter: ^List_Iterator($T)) -> (ptr: ^T, ok: bool) {
- node := iter.curr
- if node == nil {
- return nil, false
- }
- iter.index += 1
- iter.curr = node.next
- return (^T)(uintptr(node) - iter.offset), true
-}
-
-//----------------------------------------------------------------
-// Strings / string lists / path strings
-//----------------------------------------------------------------
-
-str8 :: string
-str32 :: []rune
-
-str8_list :: struct {
- list: list,
- eltCount: u64,
- len: u64,
-}
-
-str8_elt :: struct {
- str: str8,
- listElt: list_elt,
-}
-
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- str8_push_buffer :: proc(arena: ^arena, len: u64, buffer: [^]c.char) -> str8 ---
- str8_push_cstring :: proc(arena: ^arena, str: cstring) -> str8 ---
- str8_push_copy :: proc(arena: ^arena, s: str8) -> str8 ---
- str8_push_slice :: proc(arena: ^arena, s: str8, start: u64, end: u64) -> str8 ---
-
- // TODO get rid of these or wrap them
- str8_pushfv :: proc(arena: ^arena, format: cstring, args: c.va_list) -> str8 ---
- str8_pushf :: proc(arena: ^arena, format: cstring, #c_vararg args: ..any) -> str8 ---
-
- str8_to_cstring :: proc(arena: ^arena, string: str8) -> cstring ---
-
- str8_list_push :: proc(arena: ^arena, list: ^str8_list, str: str8) ---
- str8_list_pushf :: proc(arena: ^arena, list: ^str8_list, format: cstring, #c_vararg args: ..any) ---
-
- str8_list_collate :: proc(arena: ^arena, list: str8_list, prefix: str8, separator: str8, postfix: str8) -> str8 ---
- str8_list_join :: proc(arena: ^arena, list: str8_list) -> str8 ---
- str8_split :: proc(arena: ^arena, str: str8, separators: str8_list) -> str8_list ---
-
- path_slice_directory :: proc(path: str8) -> str8 ---
- path_slice_filename :: proc(path: str8) -> str8 ---
- path_split :: proc(arena: ^arena, path: str8) -> str8_list ---
- path_join :: proc(arena: ^arena, elements: str8_list) -> str8 ---
- path_append :: proc(arena: ^arena, parent: str8, relPath: str8) -> str8 ---
- path_is_absolute :: proc(path: str8) -> bool ---
-}
-
-//----------------------------------------------------------------
-// Logging
-//----------------------------------------------------------------
-
-// TODO proper odin formatted strings
-
-log_level :: enum c.int {
- ERROR,
- WARNING,
- INFO,
-}
-
-@(default_calling_convention="c", link_prefix="oc_")
-foreign {
- bridge_log :: proc(
- level: log_level,
- functionLen: c.int,
- function: [^]byte,
- fileLen: c.int,
- file: [^]byte,
- line: c.int,
- msgLen: c.int,
- msg: [^]byte,
- ) ---
-}
-
-@(private)
-log_position :: proc "contextless" (loc: runtime.Source_Code_Location) -> (functionLen: c.int, function: [^]byte,
- fileLen: c.int, file: [^]byte,
- line: c.int) {
- functionLen = c.int(len(loc.procedure))
- function = raw_data(loc.procedure)
-
- fileLen = c.int(len(loc.file_path))
- file = raw_data(loc.file_path)
-
- line = c.int(loc.line)
- return
-}
-
-log_ext :: proc "contextless" (level: log_level, format: string, args: ..any, loc := #caller_location) {
- @(thread_local) buffer: [256]byte
-
- context = runtime.default_context()
-
- s := fmt.bprintf(buffer[:], format, ..args)
-
- bridge_log(level, log_position(loc), c.int(len(s)), raw_data(s))
-}
-
-log_info :: proc "contextless" (format: string, args: ..any, loc := #caller_location) {
- log_ext(.INFO, format, ..args, loc=loc)
-}
-
-log_warning :: proc "contextless" (format: string, args: ..any, loc := #caller_location) {
- log_ext(.WARNING, format, ..args, loc=loc)
-}
-
-log_error :: proc "contextless" (format: string, args: ..any, loc := #caller_location) {
- log_ext(.ERROR, format, ..args, loc=loc)
-}
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-15 06:20:26 +0000