Clumsy UI prototype

CMakeLists.txt

@@ -57,6 +57,7 @@ include_directories("bootstrap/include")
 add_library("${LIBRARY_NAME}"
     "bootstrap/std/base.c"
     "bootstrap/std/string.c"
+    "bootstrap/std/format.c"
     "bootstrap/std/os.c"
     "bootstrap/std/entry_point.c"
     "bootstrap/std/virtual_buffer.c"
@@ -236,6 +237,7 @@ if (NOT BB_IS_CI)
         "bootstrap/std/graphics.c"
         "bootstrap/std/render.c"
         "bootstrap/std/ui_core.c"
+        "bootstrap/std/ui_builder.c"
     )
 
     target_include_directories(${COMPILER_NAME} PRIVATE dependencies/stb)

bootstrap/bloat-buster/bb_core.c

@@ -7,18 +7,8 @@
 #include <std/shader_compilation.h>
 #include <std/image_loader.h>
 #include <std/font_provider.h>
-
+#include <std/ui_core.h>
-STRUCT(Vertex)
+#include <std/ui_builder.h>
-{
-    f32 x;
-    f32 y;
-    f32 uv_x;
-    f32 uv_y;
-    Vec4 color;
-    u32 texture_index;
-    u32 reserved[3];
-};
-decl_vb(Vertex);
 
 fn TextureIndex white_texture_create(Arena* arena, Renderer* renderer)
 {
@@ -38,108 +28,155 @@ fn TextureIndex white_texture_create(Arena* arena, Renderer* renderer)
     return white_texture;
 }
 
-fn void draw_string(RenderWindow* window, Vec4 color, String string, TextureAtlas texture_atlas, u32 texture_index, u32 x_offset, u32 y_offset)
+STRUCT(BBPanel)
 {
-    auto height = texture_atlas.ascent - texture_atlas.descent;
+    BBPanel* first;
-    for (u64 i = 0; i < string.length; i += 1)
+    BBPanel* last;
-    {
+    BBPanel* next;
-        auto ch = string.pointer[i];
+    BBPanel* previous;
-        auto* character = &texture_atlas.characters[ch];
+    BBPanel* parent;
-        auto pos_x = x_offset;
+    f32 parent_percentage;
-        auto pos_y = y_offset + character->y_offset + height; // Offset of the height to render the character from the bottom (y + height) up (y)
+    Axis2 split_axis;
-        auto uv_x = character->x;
+};
-        auto uv_y = character->y;
-        auto uv_width = character->width;
-        auto uv_height = character->height;
-
-        Vertex vertices[] = {
-            (Vertex) {
-                .x = pos_x,
-                .y = pos_y,
-                .uv_x = (f32)uv_x,
-                .uv_y = (f32)uv_y,
-                .color = color,
-                .texture_index = texture_index,
-            },
-            (Vertex) {
-                .x = pos_x + character->width,
-                .y = pos_y,
-                .uv_x = (f32)(uv_x + uv_width),
-                .uv_y = (f32)uv_y,
-                .color = color,
-                .texture_index = texture_index,
-            },
-            (Vertex) {
-                .x = pos_x,
-                .y = pos_y + character->height,
-                .uv_x = (f32)uv_x,
-                .uv_y = (f32)(uv_y + uv_height),
-                .color = color,
-                .texture_index = texture_index,
-            },
-            (Vertex) {
-                .x = pos_x + character->width,
-                .y = pos_y + character->height,
-                .uv_x = (f32)(uv_x + uv_width),
-                .uv_y = (f32)(uv_y + uv_height),
-                .color = color,
-                .texture_index = texture_index,
-            },
-        };
-
-        auto vertex_offset = window_pipeline_add_vertices(window, BB_PIPELINE_RECT, (String)array_to_bytes(vertices), array_length(vertices));
-
-        u32 indices[] = {
-            vertex_offset + 0,
-            vertex_offset + 1,
-            vertex_offset + 2,
-            vertex_offset + 1,
-            vertex_offset + 3,
-            vertex_offset + 2,
-        };
-
-        window_pipeline_add_indices(window, BB_PIPELINE_RECT, (Slice(u32))array_to_slice(indices));
-
-        auto kerning = (texture_atlas.kerning_tables + ch * 256)[string.pointer[i + 1]];
-        x_offset += character->advance + kerning;
-    }
-}
 
 STRUCT(BBWindow)
 {
     OSWindow os;
     RenderWindow* render;
+    BBWindow* previous;
+    BBWindow* next;
+    BBPanel* root_panel;
+    UI_State* ui;
 };
 
 STRUCT(BBGUIState)
 {
     Arena* arena;
-    BBWindow* first;
+    Timestamp last_frame_timestamp;
-    BBWindow* last;
+    BBWindow* first_window;
+    BBWindow* last_window;
+    Renderer* renderer;
+    // TODO: should this not be thread local?
+    OSEventQueue event_queue;
 };
 global_variable BBGUIState state;
 
+fn void app_update()
+{
+    auto frame_end = os_timestamp();
+    os_poll_events(&state.event_queue);
+    auto frame_ms = os_resolve_timestamps(state.last_frame_timestamp, frame_end, TIME_UNIT_MILLISECONDS);
+    state.last_frame_timestamp = frame_end;
+
+    Renderer* renderer = state.renderer;
+
+    BBWindow* window = state.first_window;
+    while (likely(window))
+    {
+        auto* previous = window->previous;
+        auto* next = window->next;
+
+        auto* render_window = window->render;
+        renderer_window_frame_begin(renderer, render_window);
+
+        ui_state_select(window->ui);
+
+        if (likely(ui_build_begin(window->os, frame_ms, &state.event_queue)))
+        {
+            {
+                if (unlikely(ui_button(strlit("Hello world\n"), (UI_Rect) {
+                        .x0 = 200,
+                        .y0 = 200,
+                        .x1 = 300,
+                        .y1 = 300,
+                    }).clicked_left))
+                {
+                    print("Clicked on hello world\n");
+                }
+
+                if (unlikely(ui_button(strlit("Bye world\n"), (UI_Rect) {
+                        .x0 = 600,
+                        .y0 = 500,
+                        .x1 = 700,
+                        .y1 = 600,
+                    }).clicked_left))
+                {
+                    print("Clicked on bye world\n");
+                }
+            }
+
+            ui_build_end();
+
+            ui_draw();
+
+            renderer_window_frame_end(renderer, render_window);
+        }
+        else
+        {
+            if (previous)
+            {
+                previous->next = next;
+            }
+
+            if (next)
+            {
+                next->previous = previous;
+            }
+
+            if (state.first_window == window)
+            {
+                state.first_window = next;
+            }
+
+            if (state.last_window == window)
+            {
+                state.last_window = previous;
+            }
+        }
+
+        window = next;
+    }
+}
+
+fn void window_refresh_callback(OSWindow window, void* context)
+{
+    unused(window);
+    unused(context);
+    app_update();
+}
+
 void run_app()
 {
     state.arena = arena_init(MB(512), MB(2), MB(2));
 
-    u8 use_x11 = 1;
+    os_graphics_init((OSGraphicsInitializationOptions) {
-    os_graphics_init(use_x11);
+        .should_use_x11 = 1,
-    OSWindow os_window = os_window_create((OSWindowCreate) {
+    });
+    state.renderer = renderer_initialize(state.arena);
+
+    state.first_window = state.last_window = arena_allocate(state.arena, BBWindow, 1);
+    state.first_window->os = os_window_create((OSWindowCreate) {
         .name = strlit("Bloat Buster"),
         .size = {
             .width = 1024,
             .height= 768,
         },
+        .refresh_callback = &window_refresh_callback,
     });
 
-    if (!os_window)
+    if (!state.first_window->os)
     {
         failed_execution();
     }
 
-    Renderer* renderer = renderer_initialize(state.arena);
+    state.first_window->render = renderer_window_initialize(state.renderer, state.first_window->os);
-    RenderWindow* render_window = renderer_window_initialize(renderer, os_window);
+    state.first_window->ui = arena_allocate(state.arena, UI_State, 1);
+    state.first_window->ui->arena = arena_init(GB(4), MB(2), MB(2));
+    state.first_window->ui->render = state.first_window->render;
+    state.first_window->ui->renderer = state.renderer;
+    state.first_window->root_panel = arena_allocate(state.arena, BBPanel, 1);
+    state.first_window->root_panel->parent_percentage = 1.0f;
+    state.first_window->root_panel->split_axis = AXIS2_X;
 
     auto font_path = 
 #ifdef _WIN32
@@ -152,85 +189,26 @@ strlit("/Users/david/Library/Fonts/FiraSans-Regular.ttf");
         strlit("WRONG_PATH");
 #endif
 
-    window_rect_texture_update_begin(render_window);
+    window_rect_texture_update_begin(state.first_window->render);
 
-    auto white_texture = white_texture_create(state.arena, renderer);
+    auto white_texture = white_texture_create(state.arena, state.renderer);
-    auto monospace_font = font_texture_atlas_create(state.arena, renderer, (TextureAtlasCreate) {
+    auto monospace_font = font_texture_atlas_create(state.arena, state.renderer, (TextureAtlasCreate) {
         .font_path = font_path,
         .text_height = 50,
     });
     auto proportional_font = monospace_font;
-    // auto proportional_font = font_texture_atlas_create(state.arena, renderer, (TextureAtlasCreate) {
-    //     .font_path = font_path,
-    //     .text_height = 36,
-    // });
-    window_queue_rect_texture_update(render_window, RECT_TEXTURE_SLOT_WHITE, white_texture);
-    renderer_queue_font_update(renderer, render_window, RENDER_FONT_TYPE_MONOSPACE, monospace_font);
-    renderer_queue_font_update(renderer, render_window, RENDER_FONT_TYPE_PROPORTIONAL, proportional_font);
 
-    window_rect_texture_update_end(renderer, render_window);
+    window_queue_rect_texture_update(state.first_window->render, RECT_TEXTURE_SLOT_WHITE, white_texture);
+    renderer_queue_font_update(state.renderer, state.first_window->render, RENDER_FONT_TYPE_MONOSPACE, monospace_font);
+    renderer_queue_font_update(state.renderer, state.first_window->render, RENDER_FONT_TYPE_PROPORTIONAL, proportional_font);
 
-    auto frame_start = os_timestamp();
+    window_rect_texture_update_end(state.renderer, state.first_window->render);
 
-    while (!os_window_should_close(os_window))
+    state.last_frame_timestamp = os_timestamp();
+
+    while (state.first_window)
     {
-        auto frame_end = os_timestamp();
+        app_update();
-        auto frame_ms = os_resolve_timestamps(frame_start, frame_end, TIME_UNIT_MILLISECONDS);
-        frame_start = frame_end;
-
-        os_poll_events();
-
-        auto mouse_position = os_window_cursor_position_get(os_window);
-        // print("Mouse position: ({f64}, {f64})\n", mouse_position.x, mouse_position.y);
-
-        renderer_window_frame_begin(renderer, render_window);
-
-        u8 format_buffer[256];
-        auto buffer_len = format_float((String)array_to_slice(format_buffer), frame_ms);
-        format_buffer[buffer_len + 0] = ' ';
-        format_buffer[buffer_len + 1] = 'm';
-        format_buffer[buffer_len + 2] = 's';
-        auto ms = (String) { .pointer = format_buffer, .length = buffer_len + 3 };
-        draw_string(render_window, Color4(0, 1, 1, 1), ms, monospace_font, RECT_TEXTURE_SLOT_MONOSPACE_FONT, 500, 500);
-
-        u32 box_width = 100;
-        u32 box_height = 100;
-        auto box_color = Color4(1, 1, 1, 1);
-
-        Vertex box_vertices[] = {
-            {
-                .x = mouse_position.x,
-                .y = mouse_position.y,
-                .color = box_color,
-            },
-            {
-                .x = mouse_position.x + box_width,
-                .y = mouse_position.y,
-                .color = box_color,
-            },
-            {
-                .x = mouse_position.x,
-                .y = mouse_position.y + box_height,
-                .color = box_color,
-            },
-            {
-                .x = mouse_position.x + box_width,
-                .y = mouse_position.y + box_height,
-                .color = box_color,
-            },
-        };
-
-        auto vertex_offset = window_pipeline_add_vertices(render_window, BB_PIPELINE_RECT, (String)array_to_bytes(box_vertices), array_length(box_vertices));
-
-        u32 box_indices[] = {
-            vertex_offset + 0, vertex_offset + 1, vertex_offset + 2,
-            vertex_offset + 1, vertex_offset + 3, vertex_offset + 2,
-        };
-
-        window_pipeline_add_indices(render_window, BB_PIPELINE_RECT, (Slice(u32))array_to_slice(box_indices));
-        draw_string(render_window, Color4(0, 0, 0, 1), strlit("abcdefghijklmnopqrstuvwxyz!"), monospace_font, RECT_TEXTURE_SLOT_MONOSPACE_FONT, 100, 100);
-
-        renderer_window_frame_end(renderer, render_window);
     }
 
     // TODO: deinitialization

bootstrap/include/std/base.h

@@ -39,6 +39,13 @@ typedef double f64;
 typedef u32 Hash32;
 typedef u64 Hash64;
 
+typedef enum Axis2
+{
+    AXIS2_X,
+    AXIS2_Y,
+    AXIS2_COUNT,
+} Axis2;
+
 #ifdef __cplusplus
 #define EXPORT extern "C"
 #else
@@ -194,12 +201,12 @@ const may_be_unused global_variable u8 bracket_close = ']';
 
 #define todo() do { print("TODO at {cstr}:{u32}\n", __FILE__, __LINE__); __builtin_trap(); } while(0)
 
-u64 align_forward(u64 value, u64 alignment);
+EXPORT u64 align_forward(u64 value, u64 alignment);
-u64 align_backward(u64 value, u64 alignment);
+EXPORT u64 align_backward(u64 value, u64 alignment);
-u8 log2_alignment(u64 alignment);
+EXPORT u8 log2_alignment(u64 alignment);
-u8 is_power_of_two(u64 value);
+EXPORT u8 is_power_of_two(u64 value);
-u8 first_bit_set_32(u32 value);
+EXPORT u8 first_bit_set_32(u32 value);
-u64 first_bit_set_64(u64 value);
+EXPORT u64 first_bit_set_64(u64 value);
 
 EXPORT void* memcpy(void* const restrict dst, const void* const restrict src, usize size) NO_EXCEPT;
 EXPORT void* memmove(void* const dst, const void* const src, usize n) NO_EXCEPT;
@@ -209,49 +216,49 @@ EXPORT usize strlen (const char* c_string) NO_EXCEPT;
 EXPORT int strcmp(const char* s1, const char* s2) NO_EXCEPT;
 EXPORT int strncmp(const char* s1, const char* s2, usize length) NO_EXCEPT;
 
-u8 cast_u32_to_u8(u32 source, const char* name, int line);
+EXPORT u8 cast_u32_to_u8(u32 source, const char* name, int line);
-u16 cast_u32_to_u16(u32 source, const char* name, int line);
+EXPORT u16 cast_u32_to_u16(u32 source, const char* name, int line);
-s16 cast_u32_to_s16(u32 source, const char* name, int line);
+EXPORT s16 cast_u32_to_s16(u32 source, const char* name, int line);
-s32 cast_u32_to_s32(u32 source, const char* name, int line);
+EXPORT s32 cast_u32_to_s32(u32 source, const char* name, int line);
-u8 cast_u64_to_u8(u64 source, const char* name, int line);
+EXPORT u8 cast_u64_to_u8(u64 source, const char* name, int line);
-u16 cast_u64_to_u16(u64 source, const char* name, int line);
+EXPORT u16 cast_u64_to_u16(u64 source, const char* name, int line);
-u32 cast_u64_to_u32(u64 source, const char* name, int line);
+EXPORT u32 cast_u64_to_u32(u64 source, const char* name, int line);
-s32 cast_u64_to_s32(u64 source, const char* name, int line);
+EXPORT s32 cast_u64_to_s32(u64 source, const char* name, int line);
-s64 cast_u64_to_s64(u64 source, const char* name, int line);
+EXPORT s64 cast_u64_to_s64(u64 source, const char* name, int line);
-u8 cast_s32_to_u8(s32 source, const char* name, int line);
+EXPORT u8 cast_s32_to_u8(s32 source, const char* name, int line);
-u16 cast_s32_to_u16(s32 source, const char* name, int line);
+EXPORT u16 cast_s32_to_u16(s32 source, const char* name, int line);
-u32 cast_s32_to_u32(s32 source, const char* name, int line);
+EXPORT u32 cast_s32_to_u32(s32 source, const char* name, int line);
-u64 cast_s32_to_u64(s32 source, const char* name, int line);
+EXPORT u64 cast_s32_to_u64(s32 source, const char* name, int line);
-s16 cast_s32_to_s16(s32 source, const char* name, int line);
+EXPORT s16 cast_s32_to_s16(s32 source, const char* name, int line);
-u16 cast_s64_to_u16(s64 source, const char* name, int line);
+EXPORT u16 cast_s64_to_u16(s64 source, const char* name, int line);
-u32 cast_s64_to_u32(s64 source, const char* name, int line);
+EXPORT u32 cast_s64_to_u32(s64 source, const char* name, int line);
-u64 cast_s64_to_u64(s64 source, const char* name, int line);
+EXPORT u64 cast_s64_to_u64(s64 source, const char* name, int line);
-s32 cast_s64_to_s32(s64 source, const char* name, int line);
+EXPORT s32 cast_s64_to_s32(s64 source, const char* name, int line);
 
-u32 format_decimal(String buffer, u64 decimal);
+EXPORT u32 format_decimal(String buffer, u64 decimal);
-u32 format_hexadecimal(String buffer, u64 hexadecimal);
+EXPORT u32 format_hexadecimal(String buffer, u64 hexadecimal);
-u64 format_float(String buffer, f64 value_double);
+EXPORT u64 format_float(String buffer, f64 value_double);
 
-u64 is_decimal_digit(u8 ch);
+EXPORT u64 is_decimal_digit(u8 ch);
-u32 is_space(u8 ch, u8 next_ch);
+EXPORT u32 is_space(u8 ch, u8 next_ch);
-u8 get_next_ch_safe(String string, u64 index);
+EXPORT u8 get_next_ch_safe(String string, u64 index);
-u64 is_identifier_start(u8 ch);
+EXPORT u64 is_identifier_start(u8 ch);
-u64 is_identifier_ch(u8 ch);
+EXPORT u64 is_identifier_ch(u8 ch);
-u64 is_alphabetic(u8 ch);
+EXPORT u64 is_alphabetic(u8 ch);
 
-u64 parse_decimal(String string);
+EXPORT u64 parse_decimal(String string);
 
 global_variable const Hash64 fnv_offset = 14695981039346656037ull;
 global_variable const u64 fnv_prime = 1099511628211ull;
 
-Hash32 hash32_fib_end(Hash32 hash);
+EXPORT Hash32 hash32_fib_end(Hash32 hash);
-Hash32 hash64_fib_end(Hash64 hash);
+EXPORT Hash32 hash64_fib_end(Hash64 hash);
 
-Hash64 hash_byte(Hash64 source, u8 ch);
+EXPORT Hash64 hash_byte(Hash64 source, u8 ch);
-Hash64 hash_bytes(String bytes);
+EXPORT Hash64 hash_bytes(String bytes);
-Hash32 hash64_to_hash32(Hash64 hash64);
+EXPORT Hash32 hash64_to_hash32(Hash64 hash64);
 
-u64 round_up_to_next_power_of_2(u64 n);
+EXPORT u64 round_up_to_next_power_of_2(u64 n);
 
 STRUCT(TextureIndex)
 {

bootstrap/include/std/format.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <std/base.h>
+
+EXPORT String format_string(String buffer, const char* format, ...);
+EXPORT String format_string_va(String buffer, const char* format, va_list args);

bootstrap/include/std/graphics.h

@@ -2,11 +2,149 @@
 
 #include <std/base.h>
 #include <std/os.h>
+#include <std/virtual_buffer.h>
+
+typedef enum OSEventType
+{
+    OS_EVENT_TYPE_MOUSE_BUTTON,
+    OS_EVENT_TYPE_CURSOR_POSITION,
+    OS_EVENT_TYPE_CURSOR_ENTER,
+    OS_EVENT_TYPE_WINDOW_FOCUS,
+    OS_EVENT_TYPE_WINDOW_POSITION,
+    OS_EVENT_TYPE_WINDOW_CLOSE,
+} OSEventType;
+
+STRUCT(OSEventDescriptor)
+{
+    u32 index:24;
+    OSEventType type:8;
+};
+static_assert(sizeof(OSEventDescriptor) == 4);
+decl_vb(OSEventDescriptor);
+
+typedef enum OSEventMouseButtonKind : u8
+{
+    OS_EVENT_MOUSE_BUTTON_1 = 0,
+    OS_EVENT_MOUSE_BUTTON_2 = 1,
+    OS_EVENT_MOUSE_BUTTON_3 = 2,
+    OS_EVENT_MOUSE_BUTTON_4 = 3,
+    OS_EVENT_MOUSE_BUTTON_5 = 4,
+    OS_EVENT_MOUSE_BUTTON_6 = 5,
+    OS_EVENT_MOUSE_BUTTON_7 = 6,
+    OS_EVENT_MOUSE_BUTTON_8 = 7,
+    OS_EVENT_MOUSE_BUTTON_COUNT = 8,
+    OS_EVENT_MOUSE_LEFT = OS_EVENT_MOUSE_BUTTON_1,
+    OS_EVENT_MOUSE_RIGHT = OS_EVENT_MOUSE_BUTTON_2,
+    OS_EVENT_MOUSE_MIDDLE = OS_EVENT_MOUSE_BUTTON_3,
+} OSEventMouseButtonKind;
+
+typedef enum OSEventMouseButtonAction : u8
+{
+    OS_EVENT_MOUSE_RELAX = 0,
+    OS_EVENT_MOUSE_RELEASE = 1,
+    OS_EVENT_MOUSE_PRESS = 2,
+    OS_EVENT_MOUSE_REPEAT = 3,
+} OSEventMouseButtonAction;
+
+STRUCT(OSEventMouseButtonEvent)
+{
+    OSEventMouseButtonAction action:2;
+    u8 mod_shift:1;
+    u8 mod_control:1;
+    u8 mod_alt:1;
+    u8 mod_super:1;
+    u8 mod_caps_lock:1;
+    u8 mod_num_lock:1;
+};
+
+STRUCT(OSEventMouseButton)
+{
+    OSEventMouseButtonKind button:3;
+    u8 reserved:5;
+    OSEventMouseButtonEvent event;
+};
+static_assert(sizeof(OSEventMouseButton) == sizeof(u16));
+decl_vb(OSEventMouseButton);
+
+#define OS_EVENT_BITSET_SIZE (64)
+STRUCT(OSEventBitset)
+{
+    u64 value;
+};
+decl_vb(OSEventBitset);
+
+STRUCT(OSEventCursorPosition)
+{
+    f64 x;
+    f64 y;
+};
+decl_vb(OSEventCursorPosition);
+
+STRUCT(OSEventWindowPosition)
+{
+    u32 x;
+    u32 y;
+};
+decl_vb(OSEventWindowPosition);
+
+STRUCT(OSEventQueue)
+{
+    VirtualBuffer(OSEventDescriptor) descriptors;
+    VirtualBuffer(OSEventMouseButton) mouse_buttons;
+    VirtualBuffer(OSEventBitset) window_focuses;
+    u32 window_focuses_count;
+    u32 cursor_enter_count;
+    VirtualBuffer(OSEventBitset) cursor_enters;
+    VirtualBuffer(OSEventCursorPosition) cursor_positions;
+    VirtualBuffer(OSEventWindowPosition) window_positions;
+};
 
 typedef void* OSWindow;
 
+typedef void OSFramebufferResize(OSWindow window, void* context, u32 width, u32 height);
 typedef void OSWindowResize(OSWindow window, void* context, u32 width, u32 height);
 typedef void OSWindowRefresh(OSWindow window, void* context);
+typedef void OSWindowPosition(OSWindow window, void* context, u32 x, u32 y);
+typedef void OSWindowClose(OSWindow window, void* context);
+typedef void OSWindowFocus(OSWindow window, void* context, u8 focused);
+typedef void OSWindowIconify(OSWindow window, void* context, u8 iconified);
+typedef void OSWindowMaximize(OSWindow window, void* context, u8 maximized);
+typedef void OSWindowContentScale(OSWindow window, void* context, f32 x, f32 y);
+typedef void OSWindowKey(OSWindow window, void* context, s32 key, s32 scancode, s32 action, s32 mods);
+typedef void OSWindowCharacter(OSWindow window, void* context, u32 codepoint);
+typedef void OSWindowCharacterModifier(OSWindow window, void* context, u32 codepoint, s32 mods);
+typedef void OSWindowMouseButton(OSWindow window, void* context, s32 button, s32 action, s32 mods);
+typedef void OSWindowCursorPosition(OSWindow window, void* context, f64 x, f64 y);
+typedef void OSWindowCursorEnter(OSWindow window, void* context, u8 entered);
+typedef void OSWindowScroll(OSWindow window, void* context, f64 x, f64 y);
+typedef void OSWindowDrop(OSWindow window, void* context, CStringSlice paths);
+
+STRUCT(OSGraphicCallbacks)
+{
+    OSFramebufferResize* framebuffer_resize;
+    OSWindowResize* window_resize;
+    OSWindowRefresh* window_refresh;
+    OSWindowPosition* window_position;
+    OSWindowClose* window_close;
+    OSWindowFocus* window_focus;
+    OSWindowIconify* window_iconify;
+    OSWindowMaximize* window_maximize;
+    OSWindowContentScale* window_content_scale;
+    OSWindowKey* window_key;
+    OSWindowCharacter* window_character;
+    OSWindowCharacterModifier* window_character_modifier;
+    OSWindowMouseButton* window_mouse_button;
+    OSWindowCursorPosition* window_cursor_position;
+    OSWindowCursorEnter* window_cursor_enter;
+    OSWindowScroll* window_scroll;
+    OSWindowDrop* window_drop;
+};
+
+STRUCT(OSGraphicsInitializationOptions)
+{
+    OSGraphicCallbacks callback;
+    u8 should_use_x11;
+};
 
 STRUCT(OSWindowSize)
 {
@@ -29,12 +167,14 @@ STRUCT(OSCursorPosition)
     f64 y;
 };
 
-EXPORT void os_graphics_init(u8 should_use_x11);
+EXPORT void os_graphics_init(OSGraphicsInitializationOptions options);
 EXPORT OSWindow os_window_create(OSWindowCreate create);
 EXPORT u8 os_window_should_close(OSWindow window);
-EXPORT void os_poll_events();
+EXPORT void os_poll_events(OSEventQueue* event_queue);
-EXPORT OSWindowSize os_window_size_get(OSWindow window);
 EXPORT OSCursorPosition os_window_cursor_position_get(OSWindow window);
+EXPORT OSWindowSize os_window_framebuffer_size_get(OSWindow window);
+
+EXPORT u8 os_event_queue_get_window_focus(OSEventQueue* queue, u32 index);
 
 #ifdef __linux__
 typedef unsigned long XID;
@@ -46,5 +186,5 @@ EXPORT Window x11_window_get(OSWindow window);
 #endif
 
 #ifdef _WIN32
-EXPORT HANDLE win32_window_get(GraphicsWindow* window);
+EXPORT HANDLE win32_window_get(OSWindow window);
 #endif

bootstrap/include/std/render.h

@@ -15,6 +15,35 @@ STRUCT(Vec4)
 {
     f32 v[4];
 }__attribute__((aligned(16)));
+typedef Vec4 Color;
+
+STRUCT(RenderRect)
+{
+    u32 x0;
+    u32 y0;
+    u32 x1;
+    u32 y1;
+};
+
+STRUCT(RectDraw)
+{
+    RenderRect vertex;
+    RenderRect texture;
+    Color color;
+    u32 texture_index;
+};
+
+STRUCT(RectVertex)
+{
+    f32 x;
+    f32 y;
+    f32 uv_x;
+    f32 uv_y;
+    Vec4 color;
+    u32 texture_index;
+    u32 reserved[3];
+};
+decl_vb(RectVertex);
 
 #define Color4(r, g, b, a) ((Vec4){ .v = { r, g, b, a } })
 
@@ -173,3 +202,5 @@ EXPORT void window_rect_texture_update_end(Renderer* renderer, RenderWindow* win
 
 EXPORT u32 window_pipeline_add_vertices(RenderWindow* window, BBPipeline pipeline_index, String vertex_memory, u32 vertex_count);
 EXPORT void window_pipeline_add_indices(RenderWindow* window, BBPipeline pipeline_index, Slice(u32) indices);
+EXPORT void window_render_rect(RenderWindow* window, RectDraw draw);
+EXPORT void window_render_text(Renderer* renderer, RenderWindow* window, String string, Color color, RenderFontType font_type, u32 x_offset, u32 y_offset);

bootstrap/include/std/ui_builder.h

@@ -0,0 +1,6 @@
+#pragma once 
+
+#include <std/base.h>
+#include <std/ui_core.h>
+
+EXPORT UI_Signal ui_button(String string, UI_Rect rect);

bootstrap/include/std/ui_core.h

@@ -1,5 +1,85 @@
+#pragma once
+
 #include <std/base.h>
+#include <std/graphics.h>
+#include <std/os.h>
+#include <std/render.h>
+
+STRUCT(UI_MousePosition)
+{
+    f64 x;
+    f64 y;
+};
+
+STRUCT(UI_WidgetFlags)
+{
+    u32 draw_text:1;
+    u32 draw_background:1;
+    u32 clickable:1;
+    u32 reserved:30;
+};
+
+UNION(UI_Rect)
+{
+    struct
+    {
+        u32 x0;
+        u32 y0;
+        u32 x1;
+        u32 y1;
+    };
+};
+
+STRUCT(UI_Widget)
+{
+    UI_WidgetFlags flags;
+    String string;
+    UI_Widget* first;
+    UI_Widget* last;
+    UI_Widget* next;
+    UI_Widget* previous;
+    UI_Widget* parent;
+    UI_Rect rect;
+    Color background_color;
+};
 
 STRUCT(UI_State)
 {
+    Arena* arena;
+    Renderer* renderer;
+    RenderWindow* render;
+
+    UI_Widget* root;
+    UI_MousePosition mouse_position;
+    OSEventMouseButtonEvent mouse_button_events[OS_EVENT_MOUSE_BUTTON_COUNT];
+    u8 focused:1;
 };
+
+enum
+{
+    UI_SignalFlag_ClickedLeft = (1 << 0),
+};
+
+typedef u32 UI_SignalFlags;
+
+STRUCT(UI_Signal)
+{
+    UI_Widget* widget;
+    union
+    {
+        UI_SignalFlags flags;
+        struct
+        {
+            u32 clicked_left:1;
+            u32 reserved:31;
+        };
+    };
+};
+
+EXPORT void ui_state_select(UI_State* state);
+EXPORT u8 ui_build_begin(OSWindow window, f64 frame_time, OSEventQueue* event_queue);
+EXPORT void ui_build_end();
+EXPORT void ui_draw();
+EXPORT UI_Signal ui_signal_from_widget(UI_Widget* widget);
+
+EXPORT UI_Widget* ui_widget_make(UI_WidgetFlags flags, String string, UI_Rect rect);

bootstrap/include/std/virtual_buffer.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <std/base.h>
 
 #define VirtualBuffer(T) VirtualBuffer_ ## T

bootstrap/std/graphics.c

@@ -4,13 +4,44 @@
 #include <GLFW/glfw3.h>
 #include <GLFW/glfw3native.h>
 
-global_variable u8 use_x11 = 0;
+global_variable OSGraphicCallbacks callbacks;
 
-void os_graphics_init(u8 should_use_x11)
+// TODO: thread local
+global_variable OSEventQueue* event_queue = 0;
+
+fn void monitor_callback(GLFWmonitor* monitor, int event)
+{
+    unused(monitor);
+    unused(event);
+    trap();
+}
+
+fn void joystick_callback(int joystick_id, int event)
+{
+    unused(joystick_id);
+    unused(event);
+    trap();
+}
+
+fn void bitset_list_add(VirtualBuffer(OSEventBitset)* list, u32* counter, u64 value)
+{
+    auto event_index = *counter;
+    if (unlikely(event_index % OS_EVENT_BITSET_SIZE == 0))
+    {
+        *vb_add(list, 1) = (OSEventBitset) {
+            .value = 0,
+        };
+    }
+
+    auto bitset_index = event_index / OS_EVENT_BITSET_SIZE;
+    u64 bit_index = event_index % OS_EVENT_BITSET_SIZE;
+    list->pointer[bitset_index].value |= (value << bit_index);
+}
+
+void os_graphics_init(OSGraphicsInitializationOptions options)
 {
 #ifdef __linux__
-    use_x11 = should_use_x11;
+    int platform_hint = options.should_use_x11 ? GLFW_PLATFORM_X11 : GLFW_PLATFORM_WAYLAND;
-    int platform_hint = use_x11 ? GLFW_PLATFORM_X11 : GLFW_PLATFORM_WAYLAND;
     glfwInitHint(GLFW_PLATFORM, platform_hint);
 #endif
 
@@ -18,23 +49,263 @@ void os_graphics_init(u8 should_use_x11)
     {
         failed_execution();
     }
+
+    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+    // From GLFW documentation:
+    // This is called when a monitor is connected to or disconnected from the system.
+    glfwSetMonitorCallback(&monitor_callback);
+    glfwSetJoystickCallback(&joystick_callback);
+
+    callbacks = options.callback;
 }
 
-global_variable OSWindowResize* resize_callback;
+fn void glfw_window_drop_callback(GLFWwindow* window, int path_count, const char* paths[])
-global_variable OSWindowRefresh* refresh_callback;
-
-fn void os_framebuffer_size_callback(GLFWwindow* w, int width, int height)
 {
-    void* context = glfwGetWindowUserPointer(w);
+    void* context = glfwGetWindowUserPointer(window);
-    if (resize_callback)
+    auto* drop_callback = callbacks.window_drop;
+    print("DROP\n");
+    if (drop_callback)
     {
-        resize_callback(w, context, width, height);
+        drop_callback(window, context, (CStringSlice) { .pointer = (char**)paths, .length = path_count });
     }
 }
 
-fn void os_window_refresh_callback(GLFWwindow* w)
+fn void glfw_window_scroll_callback(GLFWwindow* window, double x, double y)
+{
+    void* context = glfwGetWindowUserPointer(window);
+    auto* scroll_callback = callbacks.window_scroll;
+    print("SCROLL\n");
+    if (scroll_callback)
+    {
+        scroll_callback(window, context, x, y);
+    }
+}
+
+fn void glfw_window_cursor_enter_callback(GLFWwindow* window, int entered)
+{
+    void* context = glfwGetWindowUserPointer(window);
+    auto* cursor_enter_callback = callbacks.window_cursor_enter;
+    print("CURSOR_ENTER: {u32}\n", entered);
+
+    auto event_index = event_queue->cursor_enter_count;
+    *vb_add(&event_queue->descriptors, 1) = (OSEventDescriptor) {
+        .type = OS_EVENT_TYPE_WINDOW_FOCUS,
+        .index = event_index,
+    };
+
+    bitset_list_add(&event_queue->cursor_enters, &event_queue->cursor_enter_count, entered);
+
+    if (cursor_enter_callback)
+    {
+        cursor_enter_callback(window, context, entered);
+    }
+}
+
+fn void glfw_window_cursor_position_callback(GLFWwindow* window, double x, double y)
+{
+    void* context = glfwGetWindowUserPointer(window);
+    auto* cursor_position_callback = callbacks.window_cursor_position;
+    *vb_add(&event_queue->descriptors, 1) = (OSEventDescriptor) {
+        .index = event_queue->cursor_positions.length,
+        .type = OS_EVENT_TYPE_CURSOR_POSITION,
+    };
+    *vb_add(&event_queue->cursor_positions, 1) = (OSEventCursorPosition) {
+        .x = x,
+        .y = y,
+    };
+
+    if (cursor_position_callback)
+    {
+        cursor_position_callback(window, context, x, y);
+    }
+}
+
+fn void glfw_window_mouse_button_callback(GLFWwindow* window, int button, int action, int mods)
+{
+    void* context = glfwGetWindowUserPointer(window);
+    auto* mouse_button_callback = callbacks.window_mouse_button;
+    *vb_add(&event_queue->descriptors, 1) = (OSEventDescriptor) {
+        .index = event_queue->mouse_buttons.length,
+        .type = OS_EVENT_TYPE_MOUSE_BUTTON,
+    };
+    print("Button: {u32:x}. Action: {u32:x}. Mods: {u32:x}\n", button, action, mods);
+
+    OSEventMouseButtonAction os_action;
+    switch (action)
+    {
+        case GLFW_RELEASE: os_action = OS_EVENT_MOUSE_RELEASE; break;
+        case GLFW_PRESS: os_action = OS_EVENT_MOUSE_PRESS; break;
+        case GLFW_REPEAT: os_action = OS_EVENT_MOUSE_REPEAT; break;
+        default: unreachable();
+    }
+
+    *vb_add(&event_queue->mouse_buttons, 1) = (OSEventMouseButton) {
+        .button = button,
+        .event = (OSEventMouseButtonEvent){
+            .action = os_action,
+            .mod_shift = mods & GLFW_MOD_SHIFT,
+            .mod_control = mods & GLFW_MOD_CONTROL,
+            .mod_alt = mods & GLFW_MOD_ALT,
+            .mod_super = mods & GLFW_MOD_SUPER,
+            .mod_caps_lock = mods & GLFW_MOD_CAPS_LOCK,
+            .mod_num_lock = mods & GLFW_MOD_NUM_LOCK,
+        },
+    };
+
+    if (mouse_button_callback)
+    {
+        mouse_button_callback(window, context, button, action, mods);
+    }
+}
+
+fn void glfw_window_character_modifier_callback(GLFWwindow* window, unsigned int codepoint, int mods)
+{
+    void* context = glfwGetWindowUserPointer(window);
+    auto* character_modifier_callback = callbacks.window_character_modifier;
+    // print("CHAR_MODIFIER. Codepoint: {u32}. Mods: {u32}\n", codepoint, mods);
+    if (character_modifier_callback)
+    {
+        character_modifier_callback(window, context, codepoint, mods);
+    }
+}
+
+fn void glfw_window_character_callback(GLFWwindow* window, unsigned int codepoint)
+{
+    void* context = glfwGetWindowUserPointer(window);
+    auto* character_callback = callbacks.window_character;
+    // print("CHAR. Codepoint: {u32}\n", codepoint);
+    if (character_callback)
+    {
+        character_callback(window, context, codepoint);
+    }
+}
+
+fn void glfw_window_key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    void* context = glfwGetWindowUserPointer(window);
+    auto* key_callback = callbacks.window_key;
+    print("Key: {u32}. Scancode: {u32}. Action: {u32}. Mods: {u32}\n", key, scancode, action, mods);
+    if (key_callback)
+    {
+        key_callback(window, context, key, scancode, action, mods);
+    }
+}
+
+fn void glfw_window_content_scale_callback(GLFWwindow* window, float x, float y)
+{
+    void* context = glfwGetWindowUserPointer(window);
+    print("CONTENT_SCALE\n");
+    auto* content_scale_callback = callbacks.window_content_scale;
+    if (content_scale_callback)
+    {
+        content_scale_callback(window, context, x, y);
+    }
+}
+
+fn void glfw_window_maximize_callback(GLFWwindow* window, int maximized)
+{
+    void* context = glfwGetWindowUserPointer(window);
+    print("MAXIMIZE\n");
+    auto* maximize_callback = callbacks.window_maximize;
+    if (maximize_callback)
+    {
+        maximize_callback(window, context, maximized);
+    }
+}
+
+fn void glfw_window_iconify_callback(GLFWwindow* window, int iconified)
+{
+    void* context = glfwGetWindowUserPointer(window);
+    print("ICONIFY\n");
+    auto* iconify_callback = callbacks.window_iconify;
+    if (iconify_callback)
+    {
+        iconify_callback(window, context, iconified);
+    }
+}
+
+fn void glfw_window_focus_callback(GLFWwindow* window, int focused)
+{
+    void* context = glfwGetWindowUserPointer(window);
+    print("FOCUS\n");
+    auto* focus_callback = callbacks.window_focus;
+    auto event_index = event_queue->window_focuses_count;
+    *vb_add(&event_queue->descriptors, 1) = (OSEventDescriptor) {
+        .type = OS_EVENT_TYPE_WINDOW_FOCUS,
+        .index = event_index,
+    };
+
+    bitset_list_add(&event_queue->window_focuses, &event_queue->window_focuses_count, focused);
+
+    if (focus_callback)
+    {
+        focus_callback(window, context, focused);
+    }
+}
+
+fn void glfw_window_close_callback(GLFWwindow* window)
+{
+    void* context = glfwGetWindowUserPointer(window);
+    *vb_add(&event_queue->descriptors, 1) = (OSEventDescriptor) {
+        .type = OS_EVENT_TYPE_WINDOW_CLOSE,
+    };
+
+    auto* close_callback = callbacks.window_close;
+    if (close_callback)
+    {
+        close_callback(window, context);
+    }
+}
+
+fn void glfw_window_position_callback(GLFWwindow* window, int x, int y)
+{
+    void* context = glfwGetWindowUserPointer(window);
+    print("WINDOW_POSITION: {u32}x{u32}\n", x, y);
+    auto* position_callback = callbacks.window_position;
+
+    *vb_add(&event_queue->descriptors, 1) = (OSEventDescriptor) {
+        .index = event_queue->window_positions.length,
+        .type = OS_EVENT_TYPE_WINDOW_POSITION,
+    };
+
+    *vb_add(&event_queue->window_positions, 1) = (OSEventWindowPosition) {
+        .x = x,
+        .y = y,
+    };
+
+    if (position_callback)
+    {
+        position_callback(window, context, x, y);
+    }
+}
+
+fn void glfw_window_size_callback(GLFWwindow* window, int width, int height)
+{
+    void* context = glfwGetWindowUserPointer(window);
+    print("WINDOW_SIZE\n");
+    auto* window_resize_callback = callbacks.window_resize;
+    if (window_resize_callback)
+    {
+        window_resize_callback(window, context, width, height);
+    }
+}
+
+fn void glfw_framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    void* context = glfwGetWindowUserPointer(window);
+    print("FRAMEBUFFER_SIZE\n");
+    auto* framebuffer_resize_callback = callbacks.framebuffer_resize;
+    if (framebuffer_resize_callback)
+    {
+        framebuffer_resize_callback(window, context, width, height);
+    }
+}
+
+fn void glfw_window_refresh_callback(GLFWwindow* w)
 {
     void* context = glfwGetWindowUserPointer(w);
+    print("REFRESH\n");
+    auto refresh_callback = callbacks.window_refresh;
     if (refresh_callback)
     {
         refresh_callback(w, context);
@@ -43,13 +314,29 @@ fn void os_window_refresh_callback(GLFWwindow* w)
 
 OSWindow os_window_create(OSWindowCreate create)
 {
-    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+    GLFWmonitor* monitor = 0;
-    GLFWwindow* window = glfwCreateWindow(create.size.width, create.size.height, string_to_c(create.name), 0, 0);
+    GLFWwindow* share = 0;
+    GLFWwindow* window = glfwCreateWindow(create.size.width, create.size.height, string_to_c(create.name), monitor, share);
+
     glfwSetWindowUserPointer(window, create.context);
-    glfwSetFramebufferSizeCallback(window, &os_framebuffer_size_callback);
+
-    glfwSetWindowRefreshCallback(window, &os_window_refresh_callback);
+    glfwSetWindowPosCallback(window, &glfw_window_position_callback);
-    resize_callback = create.resize_callback;
+    glfwSetWindowSizeCallback(window, &glfw_window_size_callback);
-    refresh_callback = create.refresh_callback;
+    glfwSetWindowCloseCallback(window, &glfw_window_close_callback);
+    glfwSetWindowFocusCallback(window, &glfw_window_focus_callback);
+    glfwSetWindowIconifyCallback(window, &glfw_window_iconify_callback); // Minimize callback
+    glfwSetWindowMaximizeCallback(window, &glfw_window_maximize_callback);
+    glfwSetFramebufferSizeCallback(window, &glfw_framebuffer_size_callback);
+    glfwSetWindowRefreshCallback(window, &glfw_window_refresh_callback);
+    glfwSetWindowContentScaleCallback(window, &glfw_window_content_scale_callback);
+    glfwSetKeyCallback(window, &glfw_window_key_callback);
+    glfwSetCharCallback(window, &glfw_window_character_callback);
+    glfwSetCharModsCallback(window, &glfw_window_character_modifier_callback);
+    glfwSetMouseButtonCallback(window, &glfw_window_mouse_button_callback);
+    glfwSetCursorPosCallback(window, &glfw_window_cursor_position_callback);
+    glfwSetCursorEnterCallback(window, &glfw_window_cursor_enter_callback);
+    glfwSetScrollCallback(window, &glfw_window_scroll_callback);
+    glfwSetDropCallback(window, &glfw_window_drop_callback);
 
     return window;
 }
@@ -59,17 +346,45 @@ u8 os_window_should_close(OSWindow window)
     return glfwWindowShouldClose(window);
 }
 
-void os_poll_events()
+fn void os_event_queue_reset(OSEventQueue* queue)
 {
+    queue->descriptors.length = 0;
+    queue->mouse_buttons.length = 0;
+    queue->cursor_positions.length = 0;
+}
+
+fn u8 os_event_bitset_list(VirtualBuffer(OSEventBitset) bitset, u32 index)
+{
+    auto bitset_index = index / bitset.length;
+    auto bit_index = index % bitset.length;
+    return !!(bitset.pointer[bitset_index].value & bit_index);
+}
+
+u8 os_event_queue_get_window_focus(OSEventQueue* queue, u32 index)
+{
+    assert(index < queue->window_focuses.length);
+    auto result = os_event_bitset_list(queue->window_focuses, index);
+    return result;
+}
+
+void os_poll_events(OSEventQueue* queue)
+{
+    os_event_queue_reset(queue);
+    event_queue = queue;
+    assert(queue->descriptors.length == 0);
     glfwPollEvents();
 }
 
-OSWindowSize os_window_size_get(OSWindow window)
+OSWindowSize os_window_framebuffer_size_get(OSWindow window)
 {
-    OSWindowSize result;
+    int width;
-    glfwGetWindowSize(window, (int*)&result.width, (int*)&result.height);
+    int height;
-
+    glfwGetFramebufferSize(window, &width, &height);
-    return result;
+    return (OSWindowSize)
+    {
+        .width = width,
+        .height = height,
+    };
 }
 
 OSCursorPosition os_window_cursor_position_get(OSWindow window)

bootstrap/std/os.c

@@ -1,5 +1,6 @@
 #include <std/os.h>
 #include <std/string.h>
+#include <std/format.h>
 
 #ifdef _WIN32
 #define WIN32_LEAN_AND_MEAN 1
@@ -977,302 +978,13 @@ void os_directory_make(String path)
 void print(const char* format, ...)
 {
 #ifndef SILENT
-        u8 stack_buffer[4096];
+        u8 stack_buffer[16*1024];
+        String buffer = { .pointer = stack_buffer, .length = array_length(stack_buffer) };
         va_list args;
         va_start(args, format);
-        String buffer = { .pointer = stack_buffer, .length = array_length(stack_buffer) };
+        String final_string = format_string_va(buffer, format, args);
-        u8* it = (u8*)format;
+        va_end(args);
-        u64 buffer_i = 0;
 
-        while (*it)
-        {
-            while (*it && *it != brace_open)
-            {
-                s_get(buffer, buffer_i) = *it;
-                buffer_i += 1;
-                it += 1;
-            }
-
-            if (*it == brace_open)
-            {
-                it += 1;
-                auto next_ch = *it;
-
-                if (next_ch == brace_open)
-                {
-                    trap();
-                }
-                else
-                {
-                    switch (next_ch)
-                    {
-                        case 'c':
-                            {
-                                int done = 0;
-                                it += 1;
-                                if (*it == 's')
-                                {
-                                    it += 1;
-                                    if (*it == 't')
-                                    {
-                                        it += 1;
-                                        if (*it == 'r')
-                                        {
-                                            it += 1;
-                                            done = 1;
-                                            auto* cstring = va_arg(args, const u8*);
-                                            while (*cstring)
-                                            {
-                                                buffer.pointer[buffer_i] = *cstring;
-                                                buffer_i += 1;
-                                                cstring += 1;
-                                            }
-                                        }
-                                    }
-                                }
-                                else
-                                {
-                                    auto character = cast_to(u8, u32, va_arg(args, u32));
-                                    buffer.pointer[buffer_i] = character;
-                                    buffer_i += 1;
-                                    done = 1;
-                                }
-
-                                assert(done);
-                            } break;
-                        case 'f':
-                            {
-                                it += 1;
-                                f64 value_double;
-                                switch (*it)
-                                {
-                                    case '3':
-                                        it += 1;
-                                        if (*it != '2')
-                                        {
-                                            failed_execution();
-                                        }
-                                        it += 1;
-                                        failed_execution();
-                                        break;
-                                    case '6':
-                                        it += 1;
-                                        if (*it != '4')
-                                        {
-                                            failed_execution();
-                                        }
-                                        it += 1;
-                                        value_double = va_arg(args, f64);
-                                        break;
-                                    default:
-                                        failed_execution();
-                                }
-
-                                buffer_i += format_float(s_get_slice(u8, buffer, buffer_i, buffer.length), value_double);
-                            } break;
-                        case 's':
-                            {
-                                it += 1;
-
-                                if (is_decimal_digit(*it))
-                                {
-                                    u8* bit_count_start = it;
-                                    while (is_decimal_digit(*it))
-                                    {
-                                        it += 1;
-                                    }
-
-                                    u8* bit_count_end = it;
-                                    u64 bit_count = parse_decimal(slice_from_pointer_range(u8, (u8*)bit_count_start, (u8*)bit_count_end));
-
-                                    typedef enum IntegerFormat : u8
-                                    {
-                                        INTEGER_FORMAT_HEXADECIMAL,
-                                        INTEGER_FORMAT_DECIMAL,
-                                        INTEGER_FORMAT_OCTAL,
-                                        INTEGER_FORMAT_BINARY,
-                                    } IntegerFormat;
-
-                                    IntegerFormat format = INTEGER_FORMAT_DECIMAL;
-
-                                    if (*it == ':')
-                                    {
-                                        it += 1;
-                                        switch (*it)
-                                        {
-                                            case 'x':
-                                                format = INTEGER_FORMAT_HEXADECIMAL;
-                                                break;
-                                            case 'd':
-                                                format = INTEGER_FORMAT_DECIMAL;
-                                                break;
-                                            case 'o':
-                                                format = INTEGER_FORMAT_OCTAL;
-                                                break;
-                                            case 'b':
-                                                format = INTEGER_FORMAT_BINARY;
-                                                break;
-                                            default:
-                                                trap();
-                                        }
-
-                                        it += 1;
-                                    }
-
-                                    s64 original_value;
-                                    switch (bit_count)
-                                    {
-                                        case 8:
-                                        case 16:
-                                        case 32:
-                                            original_value = va_arg(args, s32);
-                                            break;
-                                        case 64:
-                                            original_value = va_arg(args, s64);
-                                            break;
-                                        default:
-                                            trap();
-                                    }
-
-                                    auto buffer_slice = s_get_slice(u8, buffer, buffer_i, buffer.length);
-
-                                    switch (format)
-                                    {
-                                        case INTEGER_FORMAT_HEXADECIMAL:
-                                            {
-                                                auto written_characters = format_hexadecimal(buffer_slice, original_value);
-                                                buffer_i += written_characters;
-                                            } break;
-                                        case INTEGER_FORMAT_DECIMAL:
-                                            {
-                                                u64 value;
-                                                if (original_value < 0)
-                                                {
-                                                    buffer_slice.pointer[0] = '-';
-                                                    buffer_slice.pointer += 1;
-                                                    buffer_slice.length -= 1;
-                                                    buffer_i += 1;
-                                                    value = (u64)(-(original_value - (original_value == INT64_MIN))) + (original_value == INT64_MIN);
-                                                }
-                                                else
-                                                {
-                                                    value = (u64)original_value;
-                                                }
-
-                                                auto written_characters = format_decimal(buffer_slice, value);
-                                                buffer_i += written_characters;
-                                            } break;
-                                        case INTEGER_FORMAT_OCTAL:
-                                        case INTEGER_FORMAT_BINARY:
-                                            trap();
-                                    }
-                                }
-                                else
-                                {
-                                    String string = va_arg(args, String);
-                                    memcpy(buffer.pointer + buffer_i, string.pointer, string.length);
-                                    buffer_i += string.length;
-                                }
-
-                            } break;
-                        case 'u':
-                            {
-                                it += 1;
-
-                                u8* bit_count_start = it;
-                                while (is_decimal_digit(*it))
-                                {
-                                    it += 1;
-                                }
-
-                                u8* bit_count_end = it;
-                                u64 bit_count = parse_decimal(slice_from_pointer_range(u8, (u8*)bit_count_start, (u8*)bit_count_end));
-
-                                typedef enum IntegerFormat : u8
-                                {
-                                    INTEGER_FORMAT_HEXADECIMAL,
-                                    INTEGER_FORMAT_DECIMAL,
-                                    INTEGER_FORMAT_OCTAL,
-                                    INTEGER_FORMAT_BINARY,
-                                } IntegerFormat;
-
-                                IntegerFormat format = INTEGER_FORMAT_DECIMAL;
-
-                                if (*it == ':')
-                                {
-                                    it += 1;
-                                    switch (*it)
-                                    {
-                                        case 'x':
-                                            format = INTEGER_FORMAT_HEXADECIMAL;
-                                            break;
-                                        case 'd':
-                                            format = INTEGER_FORMAT_DECIMAL;
-                                            break;
-                                        case 'o':
-                                            format = INTEGER_FORMAT_OCTAL;
-                                            break;
-                                        case 'b':
-                                            format = INTEGER_FORMAT_BINARY;
-                                            break;
-                                        default:
-                                            trap();
-                                    }
-
-                                    it += 1;
-                                }
-
-                                u64 original_value;
-                                switch (bit_count)
-                                {
-                                    case 8:
-                                    case 16:
-                                    case 32:
-                                        original_value = va_arg(args, u32);
-                                        break;
-                                    case 64:
-                                        original_value = va_arg(args, u64);
-                                        break;
-                                    default:
-                                        trap();
-                                }
-
-                                auto buffer_slice = s_get_slice(u8, buffer, buffer_i, buffer.length);
-
-                                switch (format)
-                                {
-                                    case INTEGER_FORMAT_HEXADECIMAL:
-                                        {
-                                            auto written_characters = format_hexadecimal(buffer_slice, original_value);
-                                            buffer_i += written_characters;
-                                        } break;
-                                    case INTEGER_FORMAT_DECIMAL:
-                                        {
-                                            auto written_characters = format_decimal(buffer_slice, original_value);
-                                            buffer_i += written_characters;
-                                        } break;
-                                    case INTEGER_FORMAT_OCTAL:
-                                    case INTEGER_FORMAT_BINARY:
-                                        trap();
-                                }
-                            } break;
-                        default:
-                            buffer.pointer[buffer_i] = '{';
-                            buffer_i += 1;
-                            continue;
-                    }
-
-                    if (*it != brace_close)
-                    {
-                        failed_execution();
-                    }
-
-                    it += 1;
-                }
-            }
-        }
-
-        String final_string = s_get_slice(u8, buffer, 0, buffer_i);
         os_file_write(os_stdout_get(), final_string);
 #endif
 }

bootstrap/std/render.c

@@ -6,16 +6,6 @@
 
 #include <volk.h>
 
-#define vkok(call) do {\
-    VkResult _r_e_s_u_l_t_ = call; \
-    if (unlikely(_r_e_s_u_l_t_ != VK_SUCCESS)) wrong_vulkan_result(_r_e_s_u_l_t_, strlit(#call), strlit(__FILE__), __LINE__); \
-} while(0)
-
-#define vkok_swapchain(call) do {\
-    VkResult result = call; \
-    if (unlikely(result != VK_SUCCESS)) wrong_vulkan_result(result, strlit(#call), strlit(__FILE__), __LINE__); \
-} while(0)
-
 #define MAX_SWAPCHAIN_IMAGE_COUNT (16)
 #define MAX_FRAME_COUNT (2)
 #define MAX_DESCRIPTOR_SET_COUNT (16)
@@ -28,6 +18,11 @@
 #define MAX_DESCRIPTOR_SET_UPDATE_COUNT (16)
 #define MAX_LOCAL_BUFFER_COPY_COUNT (16)
 
+#define vkok(call) do {\
+    VkResult _r_e_s_u_l_t_ = call; \
+    if (unlikely(_r_e_s_u_l_t_ != VK_SUCCESS)) wrong_vulkan_result(_r_e_s_u_l_t_, strlit(#call), strlit(__FILE__), __LINE__); \
+} while(0)
+
 STRUCT(VulkanImageCreate)
 {
     u32 width;
@@ -959,6 +954,7 @@ Renderer* renderer_initialize(Arena* arena)
         }
 
         present_queue_family_index = 0;
+
         // for (present_queue_family_index = 0; present_queue_family_index < queue_count; present_queue_family_index += 1)
         // {
         //     VkBool32 support;
@@ -1435,6 +1431,20 @@ fn void swapchain_recreate(Renderer* renderer, RenderWindow* window, VkSurfaceCa
     window->width = surface_capabilities.currentExtent.width;
     window->height = surface_capabilities.currentExtent.height;
 
+    VkPresentModeKHR preferred_present_mode = VK_PRESENT_MODE_IMMEDIATE_KHR;
+    VkPresentModeKHR present_modes[16];
+    u32 present_mode_count = array_length(present_modes);
+    vkok(vkGetPhysicalDeviceSurfacePresentModesKHR(renderer->physical_device, window->surface, &present_mode_count, present_modes));
+
+    for (u32 i = 0; i < present_mode_count; i += 1)
+    {
+        if (present_modes[i] == VK_PRESENT_MODE_MAILBOX_KHR)
+        {
+            preferred_present_mode = VK_PRESENT_MODE_MAILBOX_KHR;
+            break;
+        }
+    }
+
     VkSwapchainCreateInfoKHR swapchain_create_info = {
         .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
         .pNext = 0,
@@ -1451,7 +1461,7 @@ fn void swapchain_recreate(Renderer* renderer, RenderWindow* window, VkSurfaceCa
         .pQueueFamilyIndices = queue_family_indices,
         .preTransform = surface_capabilities.currentTransform,
         .compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
-        .presentMode = VK_PRESENT_MODE_MAILBOX_KHR,
+        .presentMode = preferred_present_mode,
         .clipped = 0,
         .oldSwapchain = window->swapchain,
     };
@@ -1540,7 +1550,7 @@ RenderWindow* renderer_window_initialize(Renderer* renderer, OSWindow window)
             .pNext = 0,
             .flags = 0,
             .hinstance = os_windows_get_module_handle(),
-            .hwnd = graphics_win32_window_get(window),
+            .hwnd = win32_window_get(window),
         };
         vkok(vkCreateWin32SurfaceKHR(renderer->instance, &create_info, renderer->allocator, &result->surface));
 #endif
@@ -1564,6 +1574,7 @@ RenderWindow* renderer_window_initialize(Renderer* renderer, OSWindow window)
 
     VkSurfaceCapabilitiesKHR surface_capabilities;
     vkok(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(renderer->physical_device, result->surface, &surface_capabilities));
+
     swapchain_recreate(renderer, result, surface_capabilities);
 
     for (u64 frame_index = 0; frame_index < MAX_FRAME_COUNT; frame_index += 1)
@@ -2007,7 +2018,7 @@ void renderer_window_frame_end(Renderer* renderer, RenderWindow* window)
     {
         for (u32 i = 0; i < array_length(results); i += 1)
         {
-            vkok_swapchain(results[i]);
+            vkok(results[i]);
         }
     }
     else if (present_result == VK_ERROR_OUT_OF_DATE_KHR || present_result == VK_SUBOPTIMAL_KHR)
@@ -2170,7 +2181,10 @@ fn void window_texture_update_end(Renderer* renderer, RenderWindow* window, BBPi
     auto* pipeline_instantiation = &window->pipeline_instantiations[pipeline_index];
     u32 descriptor_copy_count = 0;
     VkCopyDescriptorSet* descriptor_copies = 0;
-    vkUpdateDescriptorSets(renderer->device, 1, &pipeline_instantiation->descriptor_set_update, descriptor_copy_count, descriptor_copies);
+    VkWriteDescriptorSet descriptor_set_writes[] = {
+        pipeline_instantiation->descriptor_set_update,
+    };
+    vkUpdateDescriptorSets(renderer->device, array_length(descriptor_set_writes), descriptor_set_writes, descriptor_copy_count, descriptor_copies);
 }
 
 void window_rect_texture_update_end(Renderer* renderer, RenderWindow* window)
@@ -2194,3 +2208,123 @@ void window_pipeline_add_indices(RenderWindow* window, BBPipeline pipeline_index
     auto* index_pointer = vb_add(&frame->pipeline_instantiations[pipeline_index].index_buffer.cpu, indices.length);
     memcpy(index_pointer, indices.pointer, indices.length * sizeof(*indices.pointer));
 }
+
+void window_render_rect(RenderWindow* window, RectDraw draw)
+{
+    RectVertex vertices[] = {
+        (RectVertex) {
+            .x = draw.vertex.x0,
+            .y = draw.vertex.y0,
+            .uv_x = draw.texture.x0,
+            .uv_y = draw.texture.y0,
+            .color = draw.color,
+            .texture_index = draw.texture_index,
+        },
+        (RectVertex) {
+            .x = draw.vertex.x1,
+            .y = draw.vertex.y0,
+            .uv_x = draw.texture.x1,
+            .uv_y = draw.texture.y0,
+            .color = draw.color,
+            .texture_index = draw.texture_index,
+        },
+        (RectVertex) {
+            .x = draw.vertex.x0,
+            .y = draw.vertex.y1,
+            .uv_x = draw.texture.x0,
+            .uv_y = draw.texture.y1,
+            .color = draw.color,
+            .texture_index = draw.texture_index,
+        },
+        (RectVertex) {
+            .x = draw.vertex.x1,
+            .y = draw.vertex.y1,
+            .uv_x = draw.texture.x1,
+            .uv_y = draw.texture.y1,
+            .color = draw.color,
+            .texture_index = draw.texture_index,
+        },
+    };
+
+    auto vertex_offset = window_pipeline_add_vertices(window, BB_PIPELINE_RECT, (String)array_to_bytes(vertices), array_length(vertices));
+
+    u32 indices[] = {
+        vertex_offset + 0,
+        vertex_offset + 1,
+        vertex_offset + 2,
+        vertex_offset + 1,
+        vertex_offset + 3,
+        vertex_offset + 2,
+    };
+
+    window_pipeline_add_indices(window, BB_PIPELINE_RECT, (Slice(u32))array_to_slice(indices));
+}
+
+void window_render_text(Renderer* renderer, RenderWindow* window, String string, Color color, RenderFontType font_type, u32 x_offset, u32 y_offset)
+{
+    auto* texture_atlas = &renderer->fonts[font_type];
+    auto height = texture_atlas->ascent - texture_atlas->descent;
+    auto texture_index = texture_atlas->texture.value;
+    for (u64 i = 0; i < string.length; i += 1)
+    {
+        auto ch = string.pointer[i];
+        auto* character = &texture_atlas->characters[ch];
+        auto pos_x = x_offset;
+        auto pos_y = y_offset + character->y_offset + height; // Offset of the height to render the character from the bottom (y + height) up (y)
+        auto uv_x = character->x;
+        auto uv_y = character->y;
+        auto uv_width = character->width;
+        auto uv_height = character->height;
+
+        RectVertex vertices[] = {
+            (RectVertex) {
+                .x = pos_x,
+                .y = pos_y,
+                .uv_x = (f32)uv_x,
+                .uv_y = (f32)uv_y,
+                .color = color,
+                .texture_index = texture_index,
+            },
+            (RectVertex) {
+                .x = pos_x + character->width,
+                .y = pos_y,
+                .uv_x = (f32)(uv_x + uv_width),
+                .uv_y = (f32)uv_y,
+                .color = color,
+                .texture_index = texture_index,
+            },
+            (RectVertex) {
+                .x = pos_x,
+                .y = pos_y + character->height,
+                .uv_x = (f32)uv_x,
+                .uv_y = (f32)(uv_y + uv_height),
+                .color = color,
+                .texture_index = texture_index,
+            },
+            (RectVertex) {
+                .x = pos_x + character->width,
+                .y = pos_y + character->height,
+                .uv_x = (f32)(uv_x + uv_width),
+                .uv_y = (f32)(uv_y + uv_height),
+                .color = color,
+                .texture_index = texture_index,
+            },
+        };
+
+        auto vertex_offset = window_pipeline_add_vertices(window, BB_PIPELINE_RECT, (String)array_to_bytes(vertices), array_length(vertices));
+
+        u32 indices[] = {
+            vertex_offset + 0,
+            vertex_offset + 1,
+            vertex_offset + 2,
+            vertex_offset + 1,
+            vertex_offset + 3,
+            vertex_offset + 2,
+        };
+
+        window_pipeline_add_indices(window, BB_PIPELINE_RECT, (Slice(u32))array_to_slice(indices));
+
+        auto kerning = (texture_atlas->kerning_tables + ch * 256)[string.pointer[i + 1]];
+        x_offset += character->advance + kerning;
+    }
+}

bootstrap/std/ui_builder.c

@@ -0,0 +1,13 @@
+#include <std/ui_builder.h>
+
+UI_Signal ui_button(String string, UI_Rect rect)
+{
+    auto* widget = ui_widget_make((UI_WidgetFlags) {
+        .draw_text = 1,
+        .draw_background = 1,
+        .clickable = 1,
+    }, string, rect);
+
+    UI_Signal signal = ui_signal_from_widget(widget);
+    return signal;
+}

bootstrap/std/ui_core.c

@@ -1,3 +1,212 @@
 #include <std/ui_core.h>
+#include <std/format.h>
 
+global_variable UI_State* ui_state = 0;
 
+void ui_state_select(UI_State* state)
+{
+    ui_state = state;
+}
+
+u8 ui_build_begin(OSWindow window, f64 frame_time, OSEventQueue* event_queue)
+{
+    u8 open = 1;
+    for (u32 generic_event_index = 0; generic_event_index < event_queue->descriptors.length; generic_event_index += 1)
+    {
+        auto event_descriptor = event_queue->descriptors.pointer[generic_event_index];
+        u32 event_index = event_descriptor.index;
+
+        switch (event_descriptor.type)
+        {
+        case OS_EVENT_TYPE_MOUSE_BUTTON:
+            {
+                auto button = event_queue->mouse_buttons.pointer[event_index];
+                auto previous_button_event = ui_state->mouse_button_events[button.button];
+                switch (button.event.action)
+                {
+                    case OS_EVENT_MOUSE_RELAX:
+                        unreachable();
+                    case OS_EVENT_MOUSE_RELEASE:
+                        {
+                            assert(previous_button_event.action == OS_EVENT_MOUSE_PRESS);
+                        } break;
+                    case OS_EVENT_MOUSE_PRESS:
+                        {
+                            assert(previous_button_event.action == OS_EVENT_MOUSE_RELAX);
+                        } break;
+                    case OS_EVENT_MOUSE_REPEAT:
+                        {
+                            unreachable();
+                        } break;
+                }
+
+                ui_state->mouse_button_events[button.button] = button.event;
+            } break;
+        case OS_EVENT_TYPE_WINDOW_FOCUS:
+            {
+            } break;
+        case OS_EVENT_TYPE_CURSOR_POSITION:
+            {
+                auto mouse_position = event_queue->cursor_positions.pointer[event_index];
+                ui_state->mouse_position = (UI_MousePosition) {
+                    .x = mouse_position.x,
+                    .y = mouse_position.y,
+                };
+            } break;
+        case OS_EVENT_TYPE_CURSOR_ENTER:
+            {
+                todo();
+            } break;
+        case OS_EVENT_TYPE_WINDOW_POSITION:
+            {
+                // event_queue->window_positions.pointer[event_index];
+                // todo();
+            } break;
+        case OS_EVENT_TYPE_WINDOW_CLOSE:
+            {
+                open = 0;
+            } break;
+        }
+    }
+
+    auto framebuffer_size = os_window_framebuffer_size_get(window);
+
+    ui_state->root = ui_widget_make(
+        (UI_WidgetFlags) {},
+        strlit(""),
+        (UI_Rect) {
+            .x0 = 0,
+            .y0 = 0,
+            .x1 = framebuffer_size.width,
+            .y1 = framebuffer_size.height,
+        }
+    );
+
+    return open;
+}
+
+void ui_build_end()
+{
+    // Clear release button presses
+    for (u32 i = 0; i < array_length(ui_state->mouse_button_events); i += 1)
+    {
+        auto* event = &ui_state->mouse_button_events[i];
+        if (event->action == OS_EVENT_MOUSE_RELEASE)
+        {
+            event->action = OS_EVENT_MOUSE_RELAX;
+        }
+    }
+}
+
+fn RenderRect render_rect(UI_Rect rect)
+{
+    return (RenderRect) {
+        .x0 = rect.x0,
+        .y0 = rect.y0,
+        .x1 = rect.x1,
+        .y1 = rect.y1,
+    };
+}
+
+void ui_draw()
+{
+    UI_Widget* root = ui_state->root;
+
+    UI_Widget* widget = root;
+    RenderWindow* window = ui_state->render;
+    Renderer* renderer = ui_state->renderer;
+
+    while (1)
+    {
+        if (widget->flags.draw_background)
+        {
+            window_render_rect(window, (RectDraw) {
+                .color = widget->background_color,
+                .vertex = render_rect(widget->rect),
+            });
+        }
+
+        if (widget->flags.draw_text)
+        {
+            window_render_text(renderer, window, widget->string, Color4(1, 1, 1, 1), RENDER_FONT_TYPE_PROPORTIONAL, widget->rect.x0, widget->rect.y0);
+        }
+
+        if (widget->first)
+        {
+            widget = widget->first;
+        }
+        else if (widget->next)
+        {
+            widget = widget->next;
+        }
+        else if (widget->parent == ui_state->root)
+        {
+            break;
+        }
+        else if (widget->parent)
+        {
+            widget = widget->parent;
+        }
+        else
+        {
+            unreachable();
+        }
+    }
+}
+
+UI_Widget* ui_widget_make(UI_WidgetFlags flags, String string, UI_Rect rect)
+{
+    auto* widget = arena_allocate(ui_state->arena, UI_Widget, 1);
+    *widget = (UI_Widget)
+    {
+        .string = string,
+        .flags = flags,
+        .rect = rect,
+        .background_color = Color4(0, 0, 0, 1),
+        // TODO: modify
+        .parent = ui_state->root,
+    };
+
+    auto* parent = widget->parent;
+    if (parent)
+    {
+        auto* ptr = &parent->last;
+        auto* previous_last = *ptr;
+        if (previous_last)
+        {
+            previous_last->next = widget;
+        }
+        *ptr = widget;
+
+        if (!parent->first)
+        {
+            parent->first = widget;
+        }
+        parent->last = widget;
+    }
+    
+    return widget;
+}
+
+UI_Widget* ui_widget_make_format(UI_WidgetFlags flags, UI_Rect rect, const char* format, ...)
+{
+    va_list args;
+    u8 buffer[4096];
+    va_start(args, format);
+    auto string = format_string_va((String)array_to_slice(buffer), format, args);
+    va_end(args);
+
+    auto* result = ui_widget_make(flags, string, rect);
+    return result;
+}
+
+UI_Signal ui_signal_from_widget(UI_Widget* widget)
+{
+    UI_Rect rect = widget->rect;
+    UI_Signal signal = {
+        .clicked_left = (widget->flags.clickable & (ui_state->mouse_button_events[OS_EVENT_MOUSE_LEFT].action == OS_EVENT_MOUSE_RELEASE)) &
+        (ui_state->mouse_position.x >= rect.x0 & ui_state->mouse_position.x <= rect.x1) &
+        (ui_state->mouse_position.y >= rect.y0 & ui_state->mouse_position.y <= rect.y1),
+    };
+    return signal;
+}