birth-software/bloat-buster
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Clumsy UI prototype

Browse Source
This commit is contained in:
David Gonzalez Martin 2024-12-04 18:47:47 -06:00 committed by David
parent b30a2d0c52
commit a9e0c8bfcb
16 changed files with 2537 additions and 1595 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -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)

288
bootstrap/bloat-buster/bb_core.c
View File

@ -7,18 +7,8 @@
#include <std/shader_compilation.h>
#include <std/image_loader.h>
#include <std/font_provider.h>
STRUCT(Vertex)
{
f32 x;
f32 y;
f32 uv_x;
f32 uv_y;
Vec4 color;
u32 texture_index;
u32 reserved[3];
};
decl_vb(Vertex);
#include <std/ui_core.h>
#include <std/ui_builder.h>
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;
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;
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;
}
}
BBPanel* first;
BBPanel* last;
BBPanel* next;
BBPanel* previous;
BBPanel* parent;
f32 parent_percentage;
Axis2 split_axis;
};
STRUCT(BBWindow)
{
OSWindow os;
RenderWindow* render;
BBWindow* previous;
BBWindow* next;
BBPanel* root_panel;
UI_State* ui;
};
STRUCT(BBGUIState)
{
Arena* arena;
BBWindow* first;
BBWindow* last;
Timestamp last_frame_timestamp;
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(use_x11);
OSWindow os_window = os_window_create((OSWindowCreate) {
os_graphics_init((OSGraphicsInitializationOptions) {
.should_use_x11 = 1,
});
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);
RenderWindow* render_window = renderer_window_initialize(renderer, os_window);
state.first_window->render = renderer_window_initialize(state.renderer, state.first_window->os);
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 monospace_font = font_texture_atlas_create(state.arena, renderer, (TextureAtlasCreate) {
auto white_texture = white_texture_create(state.arena, state.renderer);
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();
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);
app_update();
}
// TODO: deinitialization

87
bootstrap/include/std/base.h
View File

@ -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);
u64 align_backward(u64 value, u64 alignment);
u8 log2_alignment(u64 alignment);
u8 is_power_of_two(u64 value);
u8 first_bit_set_32(u32 value);
u64 first_bit_set_64(u64 value);
EXPORT u64 align_forward(u64 value, u64 alignment);
EXPORT u64 align_backward(u64 value, u64 alignment);
EXPORT u8 log2_alignment(u64 alignment);
EXPORT u8 is_power_of_two(u64 value);
EXPORT u8 first_bit_set_32(u32 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);
u16 cast_u32_to_u16(u32 source, const char* name, int line);
s16 cast_u32_to_s16(u32 source, const char* name, int line);
s32 cast_u32_to_s32(u32 source, const char* name, int line);
u8 cast_u64_to_u8(u64 source, const char* name, int line);
u16 cast_u64_to_u16(u64 source, const char* name, int line);
u32 cast_u64_to_u32(u64 source, const char* name, int line);
s32 cast_u64_to_s32(u64 source, const char* name, int line);
s64 cast_u64_to_s64(u64 source, const char* name, int line);
u8 cast_s32_to_u8(s32 source, const char* name, int line);
u16 cast_s32_to_u16(s32 source, const char* name, int line);
u32 cast_s32_to_u32(s32 source, const char* name, int line);
u64 cast_s32_to_u64(s32 source, const char* name, int line);
s16 cast_s32_to_s16(s32 source, const char* name, int line);
u16 cast_s64_to_u16(s64 source, const char* name, int line);
u32 cast_s64_to_u32(s64 source, const char* name, int line);
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 u8 cast_u32_to_u8(u32 source, const char* name, int line);
EXPORT u16 cast_u32_to_u16(u32 source, const char* name, int line);
EXPORT s16 cast_u32_to_s16(u32 source, const char* name, int line);
EXPORT s32 cast_u32_to_s32(u32 source, const char* name, int line);
EXPORT u8 cast_u64_to_u8(u64 source, const char* name, int line);
EXPORT u16 cast_u64_to_u16(u64 source, const char* name, int line);
EXPORT u32 cast_u64_to_u32(u64 source, const char* name, int line);
EXPORT s32 cast_u64_to_s32(u64 source, const char* name, int line);
EXPORT s64 cast_u64_to_s64(u64 source, const char* name, int line);
EXPORT u8 cast_s32_to_u8(s32 source, const char* name, int line);
EXPORT u16 cast_s32_to_u16(s32 source, const char* name, int line);
EXPORT u32 cast_s32_to_u32(s32 source, const char* name, int line);
EXPORT u64 cast_s32_to_u64(s32 source, const char* name, int line);
EXPORT s16 cast_s32_to_s16(s32 source, const char* name, int line);
EXPORT u16 cast_s64_to_u16(s64 source, const char* name, int line);
EXPORT u32 cast_s64_to_u32(s64 source, const char* name, int line);
EXPORT u64 cast_s64_to_u64(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);
u32 format_hexadecimal(String buffer, u64 hexadecimal);
u64 format_float(String buffer, f64 value_double);
EXPORT u32 format_decimal(String buffer, u64 decimal);
EXPORT u32 format_hexadecimal(String buffer, u64 hexadecimal);
EXPORT u64 format_float(String buffer, f64 value_double);
u64 is_decimal_digit(u8 ch);
u32 is_space(u8 ch, u8 next_ch);
u8 get_next_ch_safe(String string, u64 index);
u64 is_identifier_start(u8 ch);
u64 is_identifier_ch(u8 ch);
u64 is_alphabetic(u8 ch);
EXPORT u64 is_decimal_digit(u8 ch);
EXPORT u32 is_space(u8 ch, u8 next_ch);
EXPORT u8 get_next_ch_safe(String string, u64 index);
EXPORT u64 is_identifier_start(u8 ch);
EXPORT u64 is_identifier_ch(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);
Hash32 hash64_fib_end(Hash64 hash);
EXPORT Hash32 hash32_fib_end(Hash32 hash);
EXPORT Hash32 hash64_fib_end(Hash64 hash);
Hash64 hash_byte(Hash64 source, u8 ch);
Hash64 hash_bytes(String bytes);
Hash32 hash64_to_hash32(Hash64 hash64);
EXPORT Hash64 hash_byte(Hash64 source, u8 ch);
EXPORT Hash64 hash_bytes(String bytes);
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)
{

6
bootstrap/include/std/format.h Normal file
View File

@ -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);

148
bootstrap/include/std/graphics.h
View File

@ -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 OSWindowSize os_window_size_get(OSWindow window);
EXPORT void os_poll_events(OSEventQueue* event_queue);
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

31
bootstrap/include/std/render.h
View File

@ -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);

6
bootstrap/include/std/ui_builder.h Normal file
View File

@ -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);

80
bootstrap/include/std/ui_core.h
View File

@ -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);

2
bootstrap/include/std/virtual_buffer.h
View File

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

1065
bootstrap/std/base.c
View File

File diff suppressed because it is too large Load Diff

1372
bootstrap/std/format.c Normal file
View File

File diff suppressed because it is too large Load Diff

363
bootstrap/std/graphics.c
View File

@ -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 = use_x11 ? GLFW_PLATFORM_X11 : GLFW_PLATFORM_WAYLAND;
int platform_hint = options.should_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;
global_variable OSWindowRefresh* refresh_callback;
fn void os_framebuffer_size_callback(GLFWwindow* w, int width, int height)
fn void glfw_window_drop_callback(GLFWwindow* window, int path_count, const char* paths[])
{
void* context = glfwGetWindowUserPointer(w);
if (resize_callback)
void* context = glfwGetWindowUserPointer(window);
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);
GLFWwindow* window = glfwCreateWindow(create.size.width, create.size.height, string_to_c(create.name), 0, 0);
GLFWmonitor* monitor = 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);
resize_callback = create.resize_callback;
refresh_callback = create.refresh_callback;
glfwSetWindowPosCallback(window, &glfw_window_position_callback);
glfwSetWindowSizeCallback(window, &glfw_window_size_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;
glfwGetWindowSize(window, (int*)&result.width, (int*)&result.height);
return result;
int width;
int height;
glfwGetFramebufferSize(window, &width, &height);
return (OSWindowSize)
{
.width = width,
.height = height,
};
}
OSCursorPosition os_window_cursor_position_get(OSWindow window)

298
bootstrap/std/os.c
View File

@ -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) };
u8* it = (u8*)format;
u64 buffer_i = 0;
String final_string = format_string_va(buffer, format, args);
va_end(args);
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
}

162
bootstrap/std/render.c
View File

@ -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;
}
}

13
bootstrap/std/ui_builder.c Normal file
View File

@ -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;
}

209
bootstrap/std/ui_core.c
View File

@ -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;
}