krzosa/wasm_transcript_browser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

don't include generated math into build_file, use cache, ui

Browse Source
This commit is contained in:
Krzosa Karol
2025-01-17 13:35:35 +01:00
parent 0ad84c9fc7
commit d3c84fd666
18 changed files with 255 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
build_file.c
View File

@@ -1,4 +1,5 @@
// don't ever include stuff that build_file will generate code for!
#define DONT_INCLUDE_GENERATED_MATH
#include "src/core/core_inc.h"
#include "src/core/core_inc.c"
@@ -22,13 +23,13 @@ void list_files_recursive(sb8_t *sb, s8_t path) {
}
int main(int argc, char **argv) {
cache_init(&Perm, s8_lit("cache_build_file"));
int ok = 0;
ma_arena_t *arena = ma_create(ma_default_reserve_size);
meta_app(arena);
meta_ui(arena);
b32 generate_math_library = false; // WARNING: be wary of this, cause it might break build file
b32 execute_python_snippets = false; // make sure to not abuse just for quick maths
b32 run_server = false;
@@ -36,7 +37,7 @@ int main(int argc, char **argv) {
b32 win32_target = true;
b32 wasm_target = false;
if (generate_math_library) {
if (cache_code_modified(s8_lit("../src/core/core_math_gen.py"), s8_null)) {
os_set_working_dir("../src/core");
os_systemf("py core_math_gen.py");
os_set_working_dir("../../build");
@@ -110,5 +111,7 @@ int main(int argc, char **argv) {
os_copy("main.wasm", "../package/main.wasm", os_copy_overwrite);
if (ok != 0) return ok;
}
cache_save();
return ok;
}

138
src/app/app.gen.c
View File

@@ -78,75 +78,75 @@ type_t type__app_key_t = { type_kind_enum, s8_const_lit("app_key_t"), sizeof(app
typedef struct { app_key_t key; b32 filter_out; } wasm_key_map_t;
wasm_key_map_t wasm_map_key_string_to_app_key(s8_t key) {
if (0) {}
else if (s8_equal_ex(key, s8_lit("1"), s8_ignore_case)) return (wasm_key_map_t){app_key_1, 0};
else if (s8_equal_ex(key, s8_lit("2"), s8_ignore_case)) return (wasm_key_map_t){app_key_2, 0};
else if (s8_equal_ex(key, s8_lit("3"), s8_ignore_case)) return (wasm_key_map_t){app_key_3, 0};
else if (s8_equal_ex(key, s8_lit("4"), s8_ignore_case)) return (wasm_key_map_t){app_key_4, 0};
else if (s8_equal_ex(key, s8_lit("5"), s8_ignore_case)) return (wasm_key_map_t){app_key_5, 0};
else if (s8_equal_ex(key, s8_lit("6"), s8_ignore_case)) return (wasm_key_map_t){app_key_6, 0};
else if (s8_equal_ex(key, s8_lit("7"), s8_ignore_case)) return (wasm_key_map_t){app_key_7, 0};
else if (s8_equal_ex(key, s8_lit("8"), s8_ignore_case)) return (wasm_key_map_t){app_key_8, 0};
else if (s8_equal_ex(key, s8_lit("9"), s8_ignore_case)) return (wasm_key_map_t){app_key_9, 0};
else if (s8_equal_ex(key, s8_lit("0"), s8_ignore_case)) return (wasm_key_map_t){app_key_0, 0};
else if (s8_equal_ex(key, s8_lit("F1"), s8_ignore_case)) return (wasm_key_map_t){app_key_f1, 1};
else if (s8_equal_ex(key, s8_lit("F2"), s8_ignore_case)) return (wasm_key_map_t){app_key_f2, 1};
else if (s8_equal_ex(key, s8_lit("F3"), s8_ignore_case)) return (wasm_key_map_t){app_key_f3, 1};
else if (s8_equal_ex(key, s8_lit("F4"), s8_ignore_case)) return (wasm_key_map_t){app_key_f4, 1};
else if (s8_equal_ex(key, s8_lit("F5"), s8_ignore_case)) return (wasm_key_map_t){app_key_f5, 1};
else if (s8_equal_ex(key, s8_lit("F6"), s8_ignore_case)) return (wasm_key_map_t){app_key_f6, 1};
else if (s8_equal_ex(key, s8_lit("F7"), s8_ignore_case)) return (wasm_key_map_t){app_key_f7, 1};
else if (s8_equal_ex(key, s8_lit("F8"), s8_ignore_case)) return (wasm_key_map_t){app_key_f8, 1};
else if (s8_equal_ex(key, s8_lit("F9"), s8_ignore_case)) return (wasm_key_map_t){app_key_f9, 1};
else if (s8_equal_ex(key, s8_lit("F10"), s8_ignore_case)) return (wasm_key_map_t){app_key_f10, 1};
else if (s8_equal_ex(key, s8_lit("F11"), s8_ignore_case)) return (wasm_key_map_t){app_key_f11, 1};
else if (s8_equal_ex(key, s8_lit("F12"), s8_ignore_case)) return (wasm_key_map_t){app_key_f12, 1};
else if (s8_equal_ex(key, s8_lit("a"), s8_ignore_case)) return (wasm_key_map_t){app_key_a, 0};
else if (s8_equal_ex(key, s8_lit("b"), s8_ignore_case)) return (wasm_key_map_t){app_key_b, 0};
else if (s8_equal_ex(key, s8_lit("c"), s8_ignore_case)) return (wasm_key_map_t){app_key_c, 0};
else if (s8_equal_ex(key, s8_lit("d"), s8_ignore_case)) return (wasm_key_map_t){app_key_d, 0};
else if (s8_equal_ex(key, s8_lit("e"), s8_ignore_case)) return (wasm_key_map_t){app_key_e, 0};
else if (s8_equal_ex(key, s8_lit("f"), s8_ignore_case)) return (wasm_key_map_t){app_key_f, 0};
else if (s8_equal_ex(key, s8_lit("g"), s8_ignore_case)) return (wasm_key_map_t){app_key_g, 0};
else if (s8_equal_ex(key, s8_lit("h"), s8_ignore_case)) return (wasm_key_map_t){app_key_h, 0};
else if (s8_equal_ex(key, s8_lit("i"), s8_ignore_case)) return (wasm_key_map_t){app_key_i, 0};
else if (s8_equal_ex(key, s8_lit("j"), s8_ignore_case)) return (wasm_key_map_t){app_key_j, 0};
else if (s8_equal_ex(key, s8_lit("k"), s8_ignore_case)) return (wasm_key_map_t){app_key_k, 0};
else if (s8_equal_ex(key, s8_lit("l"), s8_ignore_case)) return (wasm_key_map_t){app_key_l, 0};
else if (s8_equal_ex(key, s8_lit("m"), s8_ignore_case)) return (wasm_key_map_t){app_key_m, 0};
else if (s8_equal_ex(key, s8_lit("n"), s8_ignore_case)) return (wasm_key_map_t){app_key_n, 0};
else if (s8_equal_ex(key, s8_lit("o"), s8_ignore_case)) return (wasm_key_map_t){app_key_o, 0};
else if (s8_equal_ex(key, s8_lit("p"), s8_ignore_case)) return (wasm_key_map_t){app_key_p, 0};
else if (s8_equal_ex(key, s8_lit("q"), s8_ignore_case)) return (wasm_key_map_t){app_key_q, 0};
else if (s8_equal_ex(key, s8_lit("r"), s8_ignore_case)) return (wasm_key_map_t){app_key_r, 0};
else if (s8_equal_ex(key, s8_lit("s"), s8_ignore_case)) return (wasm_key_map_t){app_key_s, 0};
else if (s8_equal_ex(key, s8_lit("t"), s8_ignore_case)) return (wasm_key_map_t){app_key__t, 0};
else if (s8_equal_ex(key, s8_lit("u"), s8_ignore_case)) return (wasm_key_map_t){app_key_u, 0};
else if (s8_equal_ex(key, s8_lit("v"), s8_ignore_case)) return (wasm_key_map_t){app_key_v, 0};
else if (s8_equal_ex(key, s8_lit("w"), s8_ignore_case)) return (wasm_key_map_t){app_key_w, 0};
else if (s8_equal_ex(key, s8_lit("x"), s8_ignore_case)) return (wasm_key_map_t){app_key_x, 0};
else if (s8_equal_ex(key, s8_lit("y"), s8_ignore_case)) return (wasm_key_map_t){app_key_y, 0};
else if (s8_equal_ex(key, s8_lit("z"), s8_ignore_case)) return (wasm_key_map_t){app_key_z, 0};
else if (s8_equal_ex(key, s8_lit(" "), s8_ignore_case)) return (wasm_key_map_t){app_key_space, 0};
else if (s8_equal_ex(key, s8_lit("Enter"), s8_ignore_case)) return (wasm_key_map_t){app_key_enter, 1};
else if (s8_equal_ex(key, s8_lit("Escape"), s8_ignore_case)) return (wasm_key_map_t){app_key_escape, 1};
else if (s8_equal_ex(key, s8_lit("ArrowLeft"), s8_ignore_case)) return (wasm_key_map_t){app_key_left, 1};
else if (s8_equal_ex(key, s8_lit("ArrowUp"), s8_ignore_case)) return (wasm_key_map_t){app_key_up, 1};
else if (s8_equal_ex(key, s8_lit("ArrowRight"), s8_ignore_case)) return (wasm_key_map_t){app_key_right, 1};
else if (s8_equal_ex(key, s8_lit("ArrowDown"), s8_ignore_case)) return (wasm_key_map_t){app_key_down, 1};
else if (s8_equal_ex(key, s8_lit("Tab"), s8_ignore_case)) return (wasm_key_map_t){app_key_tab, 1};
else if (s8_equal_ex(key, s8_lit("Backspace"), s8_ignore_case)) return (wasm_key_map_t){app_key_backspace, 1};
else if (s8_equal_ex(key, s8_lit("Control"), s8_ignore_case)) return (wasm_key_map_t){app_key_control, 1};
else if (s8_equal_ex(key, s8_lit("Shift"), s8_ignore_case)) return (wasm_key_map_t){app_key_shift, 1};
else if (s8_equal_ex(key, s8_lit("Alt"), s8_ignore_case)) return (wasm_key_map_t){app_key_alt, 1};
else if (s8_equal_ex(key, s8_lit("AltGraph"), s8_ignore_case)) return (wasm_key_map_t){app_key_alt, 1};
else if (s8_equal_ex(key, s8_lit("Meta"), s8_ignore_case)) return (wasm_key_map_t){app_key_meta, 1};
else if (s8_equal_ex(key, s8_lit("CapsLock"), s8_ignore_case)) return (wasm_key_map_t){app_key_caps_lock, 1};
else if (s8_equal_ex(key, s8_lit("Delete"), s8_ignore_case)) return (wasm_key_map_t){app_key_delete, 1};
else if (s8_equal_ex(key, s8_lit("Home"), s8_ignore_case)) return (wasm_key_map_t){app_key_home, 1};
else if (s8_equal_ex(key, s8_lit("End"), s8_ignore_case)) return (wasm_key_map_t){app_key_end, 1};
else if (s8_equal_ex(key, s8_lit("Insert"), s8_ignore_case)) return (wasm_key_map_t){app_key_insert, 1};
else if (s8_equal_ex(key, s8_lit("PageUp"), s8_ignore_case)) return (wasm_key_map_t){app_key_page_up, 1};
else if (s8_equal_ex(key, s8_lit("PageDown"), s8_ignore_case)) return (wasm_key_map_t){app_key_page_down, 1};
else if (s8_are_equal_ex(key, s8_lit("1"), s8_ignore_case)) return (wasm_key_map_t){app_key_1, 0};
else if (s8_are_equal_ex(key, s8_lit("2"), s8_ignore_case)) return (wasm_key_map_t){app_key_2, 0};
else if (s8_are_equal_ex(key, s8_lit("3"), s8_ignore_case)) return (wasm_key_map_t){app_key_3, 0};
else if (s8_are_equal_ex(key, s8_lit("4"), s8_ignore_case)) return (wasm_key_map_t){app_key_4, 0};
else if (s8_are_equal_ex(key, s8_lit("5"), s8_ignore_case)) return (wasm_key_map_t){app_key_5, 0};
else if (s8_are_equal_ex(key, s8_lit("6"), s8_ignore_case)) return (wasm_key_map_t){app_key_6, 0};
else if (s8_are_equal_ex(key, s8_lit("7"), s8_ignore_case)) return (wasm_key_map_t){app_key_7, 0};
else if (s8_are_equal_ex(key, s8_lit("8"), s8_ignore_case)) return (wasm_key_map_t){app_key_8, 0};
else if (s8_are_equal_ex(key, s8_lit("9"), s8_ignore_case)) return (wasm_key_map_t){app_key_9, 0};
else if (s8_are_equal_ex(key, s8_lit("0"), s8_ignore_case)) return (wasm_key_map_t){app_key_0, 0};
else if (s8_are_equal_ex(key, s8_lit("F1"), s8_ignore_case)) return (wasm_key_map_t){app_key_f1, 1};
else if (s8_are_equal_ex(key, s8_lit("F2"), s8_ignore_case)) return (wasm_key_map_t){app_key_f2, 1};
else if (s8_are_equal_ex(key, s8_lit("F3"), s8_ignore_case)) return (wasm_key_map_t){app_key_f3, 1};
else if (s8_are_equal_ex(key, s8_lit("F4"), s8_ignore_case)) return (wasm_key_map_t){app_key_f4, 1};
else if (s8_are_equal_ex(key, s8_lit("F5"), s8_ignore_case)) return (wasm_key_map_t){app_key_f5, 1};
else if (s8_are_equal_ex(key, s8_lit("F6"), s8_ignore_case)) return (wasm_key_map_t){app_key_f6, 1};
else if (s8_are_equal_ex(key, s8_lit("F7"), s8_ignore_case)) return (wasm_key_map_t){app_key_f7, 1};
else if (s8_are_equal_ex(key, s8_lit("F8"), s8_ignore_case)) return (wasm_key_map_t){app_key_f8, 1};
else if (s8_are_equal_ex(key, s8_lit("F9"), s8_ignore_case)) return (wasm_key_map_t){app_key_f9, 1};
else if (s8_are_equal_ex(key, s8_lit("F10"), s8_ignore_case)) return (wasm_key_map_t){app_key_f10, 1};
else if (s8_are_equal_ex(key, s8_lit("F11"), s8_ignore_case)) return (wasm_key_map_t){app_key_f11, 1};
else if (s8_are_equal_ex(key, s8_lit("F12"), s8_ignore_case)) return (wasm_key_map_t){app_key_f12, 1};
else if (s8_are_equal_ex(key, s8_lit("a"), s8_ignore_case)) return (wasm_key_map_t){app_key_a, 0};
else if (s8_are_equal_ex(key, s8_lit("b"), s8_ignore_case)) return (wasm_key_map_t){app_key_b, 0};
else if (s8_are_equal_ex(key, s8_lit("c"), s8_ignore_case)) return (wasm_key_map_t){app_key_c, 0};
else if (s8_are_equal_ex(key, s8_lit("d"), s8_ignore_case)) return (wasm_key_map_t){app_key_d, 0};
else if (s8_are_equal_ex(key, s8_lit("e"), s8_ignore_case)) return (wasm_key_map_t){app_key_e, 0};
else if (s8_are_equal_ex(key, s8_lit("f"), s8_ignore_case)) return (wasm_key_map_t){app_key_f, 0};
else if (s8_are_equal_ex(key, s8_lit("g"), s8_ignore_case)) return (wasm_key_map_t){app_key_g, 0};
else if (s8_are_equal_ex(key, s8_lit("h"), s8_ignore_case)) return (wasm_key_map_t){app_key_h, 0};
else if (s8_are_equal_ex(key, s8_lit("i"), s8_ignore_case)) return (wasm_key_map_t){app_key_i, 0};
else if (s8_are_equal_ex(key, s8_lit("j"), s8_ignore_case)) return (wasm_key_map_t){app_key_j, 0};
else if (s8_are_equal_ex(key, s8_lit("k"), s8_ignore_case)) return (wasm_key_map_t){app_key_k, 0};
else if (s8_are_equal_ex(key, s8_lit("l"), s8_ignore_case)) return (wasm_key_map_t){app_key_l, 0};
else if (s8_are_equal_ex(key, s8_lit("m"), s8_ignore_case)) return (wasm_key_map_t){app_key_m, 0};
else if (s8_are_equal_ex(key, s8_lit("n"), s8_ignore_case)) return (wasm_key_map_t){app_key_n, 0};
else if (s8_are_equal_ex(key, s8_lit("o"), s8_ignore_case)) return (wasm_key_map_t){app_key_o, 0};
else if (s8_are_equal_ex(key, s8_lit("p"), s8_ignore_case)) return (wasm_key_map_t){app_key_p, 0};
else if (s8_are_equal_ex(key, s8_lit("q"), s8_ignore_case)) return (wasm_key_map_t){app_key_q, 0};
else if (s8_are_equal_ex(key, s8_lit("r"), s8_ignore_case)) return (wasm_key_map_t){app_key_r, 0};
else if (s8_are_equal_ex(key, s8_lit("s"), s8_ignore_case)) return (wasm_key_map_t){app_key_s, 0};
else if (s8_are_equal_ex(key, s8_lit("t"), s8_ignore_case)) return (wasm_key_map_t){app_key__t, 0};
else if (s8_are_equal_ex(key, s8_lit("u"), s8_ignore_case)) return (wasm_key_map_t){app_key_u, 0};
else if (s8_are_equal_ex(key, s8_lit("v"), s8_ignore_case)) return (wasm_key_map_t){app_key_v, 0};
else if (s8_are_equal_ex(key, s8_lit("w"), s8_ignore_case)) return (wasm_key_map_t){app_key_w, 0};
else if (s8_are_equal_ex(key, s8_lit("x"), s8_ignore_case)) return (wasm_key_map_t){app_key_x, 0};
else if (s8_are_equal_ex(key, s8_lit("y"), s8_ignore_case)) return (wasm_key_map_t){app_key_y, 0};
else if (s8_are_equal_ex(key, s8_lit("z"), s8_ignore_case)) return (wasm_key_map_t){app_key_z, 0};
else if (s8_are_equal_ex(key, s8_lit(" "), s8_ignore_case)) return (wasm_key_map_t){app_key_space, 0};
else if (s8_are_equal_ex(key, s8_lit("Enter"), s8_ignore_case)) return (wasm_key_map_t){app_key_enter, 1};
else if (s8_are_equal_ex(key, s8_lit("Escape"), s8_ignore_case)) return (wasm_key_map_t){app_key_escape, 1};
else if (s8_are_equal_ex(key, s8_lit("ArrowLeft"), s8_ignore_case)) return (wasm_key_map_t){app_key_left, 1};
else if (s8_are_equal_ex(key, s8_lit("ArrowUp"), s8_ignore_case)) return (wasm_key_map_t){app_key_up, 1};
else if (s8_are_equal_ex(key, s8_lit("ArrowRight"), s8_ignore_case)) return (wasm_key_map_t){app_key_right, 1};
else if (s8_are_equal_ex(key, s8_lit("ArrowDown"), s8_ignore_case)) return (wasm_key_map_t){app_key_down, 1};
else if (s8_are_equal_ex(key, s8_lit("Tab"), s8_ignore_case)) return (wasm_key_map_t){app_key_tab, 1};
else if (s8_are_equal_ex(key, s8_lit("Backspace"), s8_ignore_case)) return (wasm_key_map_t){app_key_backspace, 1};
else if (s8_are_equal_ex(key, s8_lit("Control"), s8_ignore_case)) return (wasm_key_map_t){app_key_control, 1};
else if (s8_are_equal_ex(key, s8_lit("Shift"), s8_ignore_case)) return (wasm_key_map_t){app_key_shift, 1};
else if (s8_are_equal_ex(key, s8_lit("Alt"), s8_ignore_case)) return (wasm_key_map_t){app_key_alt, 1};
else if (s8_are_equal_ex(key, s8_lit("AltGraph"), s8_ignore_case)) return (wasm_key_map_t){app_key_alt, 1};
else if (s8_are_equal_ex(key, s8_lit("Meta"), s8_ignore_case)) return (wasm_key_map_t){app_key_meta, 1};
else if (s8_are_equal_ex(key, s8_lit("CapsLock"), s8_ignore_case)) return (wasm_key_map_t){app_key_caps_lock, 1};
else if (s8_are_equal_ex(key, s8_lit("Delete"), s8_ignore_case)) return (wasm_key_map_t){app_key_delete, 1};
else if (s8_are_equal_ex(key, s8_lit("Home"), s8_ignore_case)) return (wasm_key_map_t){app_key_home, 1};
else if (s8_are_equal_ex(key, s8_lit("End"), s8_ignore_case)) return (wasm_key_map_t){app_key_end, 1};
else if (s8_are_equal_ex(key, s8_lit("Insert"), s8_ignore_case)) return (wasm_key_map_t){app_key_insert, 1};
else if (s8_are_equal_ex(key, s8_lit("PageUp"), s8_ignore_case)) return (wasm_key_map_t){app_key_page_up, 1};
else if (s8_are_equal_ex(key, s8_lit("PageDown"), s8_ignore_case)) return (wasm_key_map_t){app_key_page_down, 1};
return (wasm_key_map_t){0};
}
#endif

6
src/app/app.meta.c
View File

@@ -98,8 +98,8 @@ void meta_app(ma_arena_t *arena) {
s8_t js[] = {row_geti(row, js1_idx)->string, row_geti(row, js2_idx)->string};
for (i32 i = 0; i < lengthof(js); i += 1) {
if (s8_equal(js[i], s8_lit("XXX"))) continue;
sb8_stmtf(c, "else if (s8_equal_ex(key, s8_lit(\"%S\"), s8_ignore_case)) return (wasm_key_map_t){app_key_%S, %d};", js[i], name, (i32)filter_out);
if (s8_are_equal(js[i], s8_lit("XXX"))) continue;
sb8_stmtf(c, "else if (s8_are_equal_ex(key, s8_lit(\"%S\"), s8_ignore_case)) return (wasm_key_map_t){app_key_%S, %d};", js[i], name, (i32)filter_out);
}
}
sb8_stmtf(c, "return (wasm_key_map_t){0};");
@@ -123,7 +123,7 @@ void meta_app(ma_arena_t *arena) {
s8_t name = row_geti(row, name_idx)->string;
s8_t w[] = {row_geti(row, w1i)->string, row_geti(row, w2i)->string};
for (i32 i = 0; i < lengthof(w); i += 1) {
if (s8_equal(w[i], s8_lit("XXX"))) continue;
if (s8_are_equal(w[i], s8_lit("XXX"))) continue;
sb8_stmtf(c, "case %S: return app_key_%S; break;", w[i], name);
}
}

2
src/core/core_hash_table.c
View File

@@ -85,7 +85,7 @@ ht_node_t *ht_search_string(ht_dict_t *ht, s8_t key) {
i64 idx = hash % ht->bucket_count;
ht_bucket_t *bucket = ht->buckets + idx;
for (ht_node_t *it = bucket->first; it; it = it->next) {
if (s8_equal(it->kv.key_string, key)) {
if (s8_are_equal(it->kv.key_string, key)) {
return it;
}
}

4
src/core/core_inc.c
View File

@@ -35,7 +35,6 @@
#include "core_intrin.c"
#include "core_unicode.c"
#include "core_math.c"
#include "core_math.gen.c"
#include "core_arena.c"
#define STB_SPRINTF_IMPLEMENTATION
@@ -46,3 +45,6 @@
#include "core_type_info.c"
#include "core_hash.c"
#include "core_hash_table.c"
#ifndef DONT_INCLUDE_GENERATED_MATH
#include "core_math.gen.c"
#endif

5
src/core/core_intrin.c
View File

@@ -10,6 +10,11 @@ fn void memory_set(void *dst, i32 c, usize size) {
IF_PLATFORM_CLANG_ELSE(__builtin_memset(dst, c, size), memset(dst, c, size));
}
fn b32 memory_equal(void *left, void *right, usize size) {
int cmp = IF_PLATFORM_CLANG_ELSE(__builtin_memcmp(left, right, size), memcmp(left, right, size));
return cmp == 0;
}
fn void memory_zero(void *dst, usize size) {
memory_set(dst, 0, size);
}

2
src/core/core_lexer.c
View File

@@ -299,7 +299,7 @@ fn lex_t *parser_match(parser_t *par, lex_kind_t kind) {
}
fn lex_t *parser_matchi(parser_t *par, s8_t str) {
if (par->at->kind == lex_kind_ident && s8_equal(par->at->string, str)) {
if (par->at->kind == lex_kind_ident && s8_are_equal(par->at->string, str)) {
return parser_next(par);
} else {
return NULL;

60
src/core/core_math.gen.c
View File

@@ -1,5 +1,8 @@
// auto generated using: C:\dev\wasm\src\core\core_math_gen.py
v2f32_t v2f32(f32 x, f32 y) { return (v2f32_t){ x, y }; }
gb_read_only v2f32_t v2f32_null = {0};
b32 v2f32_is_null(v2f32_t a) { return memory_equal(&a, &v2f32_null, sizeof(a)); }
b32 v2f32_are_equal(v2f32_t a, v2f32_t b) { return memory_equal(&a, &b, sizeof(a)); }
v2f32_t v2f32_add(v2f32_t a, v2f32_t b) { return (v2f32_t){ a.x + b.x, a.y + b.y }; }
v2f32_t v2f32_adds(v2f32_t a, f32 b) { return (v2f32_t){ a.x + b, a.y + b }; }
v2f32_t v2f32_sub(v2f32_t a, v2f32_t b) { return (v2f32_t){ a.x - b.x, a.y - b.y }; }
@@ -9,6 +12,9 @@ v2f32_t v2f32_muls(v2f32_t a, f32 b) { return (v2f32_t){ a.x * b, a.y * b }; }
v2f32_t v2f32_div(v2f32_t a, v2f32_t b) { return (v2f32_t){ a.x / b.x, a.y / b.y }; }
v2f32_t v2f32_divs(v2f32_t a, f32 b) { return (v2f32_t){ a.x / b, a.y / b }; }
v3f32_t v3f32(f32 x, f32 y, f32 z) { return (v3f32_t){ x, y, z }; }
gb_read_only v3f32_t v3f32_null = {0};
b32 v3f32_is_null(v3f32_t a) { return memory_equal(&a, &v3f32_null, sizeof(a)); }
b32 v3f32_are_equal(v3f32_t a, v3f32_t b) { return memory_equal(&a, &b, sizeof(a)); }
v3f32_t v3f32_add(v3f32_t a, v3f32_t b) { return (v3f32_t){ a.x + b.x, a.y + b.y, a.z + b.z }; }
v3f32_t v3f32_adds(v3f32_t a, f32 b) { return (v3f32_t){ a.x + b, a.y + b, a.z + b }; }
v3f32_t v3f32_sub(v3f32_t a, v3f32_t b) { return (v3f32_t){ a.x - b.x, a.y - b.y, a.z - b.z }; }
@@ -18,6 +24,9 @@ v3f32_t v3f32_muls(v3f32_t a, f32 b) { return (v3f32_t){ a.x * b, a.y * b, a.z *
v3f32_t v3f32_div(v3f32_t a, v3f32_t b) { return (v3f32_t){ a.x / b.x, a.y / b.y, a.z / b.z }; }
v3f32_t v3f32_divs(v3f32_t a, f32 b) { return (v3f32_t){ a.x / b, a.y / b, a.z / b }; }
v4f32_t v4f32(f32 x, f32 y, f32 z, f32 w) { return (v4f32_t){ x, y, z, w }; }
gb_read_only v4f32_t v4f32_null = {0};
b32 v4f32_is_null(v4f32_t a) { return memory_equal(&a, &v4f32_null, sizeof(a)); }
b32 v4f32_are_equal(v4f32_t a, v4f32_t b) { return memory_equal(&a, &b, sizeof(a)); }
v4f32_t v4f32_add(v4f32_t a, v4f32_t b) { return (v4f32_t){ a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w }; }
v4f32_t v4f32_adds(v4f32_t a, f32 b) { return (v4f32_t){ a.x + b, a.y + b, a.z + b, a.w + b }; }
v4f32_t v4f32_sub(v4f32_t a, v4f32_t b) { return (v4f32_t){ a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w }; }
@@ -27,6 +36,9 @@ v4f32_t v4f32_muls(v4f32_t a, f32 b) { return (v4f32_t){ a.x * b, a.y * b, a.z *
v4f32_t v4f32_div(v4f32_t a, v4f32_t b) { return (v4f32_t){ a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w }; }
v4f32_t v4f32_divs(v4f32_t a, f32 b) { return (v4f32_t){ a.x / b, a.y / b, a.z / b, a.w / b }; }
r2f32_t r2f32(f32 x0, f32 y0, f32 x1, f32 y1) { return (r2f32_t){ x0, y0, x1, y1 }; }
gb_read_only r2f32_t r2f32_null = {0};
b32 r2f32_is_null(r2f32_t a) { return memory_equal(&a, &r2f32_null, sizeof(a)); }
b32 r2f32_are_equal(r2f32_t a, r2f32_t b) { return memory_equal(&a, &b, sizeof(a)); }
r2f32_t r2f32_add(r2f32_t a, r2f32_t b) { return (r2f32_t){ a.x0 + b.x0, a.y0 + b.y0, a.x1 + b.x1, a.y1 + b.y1 }; }
r2f32_t r2f32_adds(r2f32_t a, f32 b) { return (r2f32_t){ a.x0 + b, a.y0 + b, a.x1 + b, a.y1 + b }; }
r2f32_t r2f32_sub(r2f32_t a, r2f32_t b) { return (r2f32_t){ a.x0 - b.x0, a.y0 - b.y0, a.x1 - b.x1, a.y1 - b.y1 }; }
@@ -36,6 +48,9 @@ r2f32_t r2f32_muls(r2f32_t a, f32 b) { return (r2f32_t){ a.x0 * b, a.y0 * b, a.x
r2f32_t r2f32_div(r2f32_t a, r2f32_t b) { return (r2f32_t){ a.x0 / b.x0, a.y0 / b.y0, a.x1 / b.x1, a.y1 / b.y1 }; }
r2f32_t r2f32_divs(r2f32_t a, f32 b) { return (r2f32_t){ a.x0 / b, a.y0 / b, a.x1 / b, a.y1 / b }; }
r3f32_t r3f32(f32 x0, f32 y0, f32 z0, f32 x1, f32 y1, f32 z1) { return (r3f32_t){ x0, y0, z0, x1, y1, z1 }; }
gb_read_only r3f32_t r3f32_null = {0};
b32 r3f32_is_null(r3f32_t a) { return memory_equal(&a, &r3f32_null, sizeof(a)); }
b32 r3f32_are_equal(r3f32_t a, r3f32_t b) { return memory_equal(&a, &b, sizeof(a)); }
r3f32_t r3f32_add(r3f32_t a, r3f32_t b) { return (r3f32_t){ a.x0 + b.x0, a.y0 + b.y0, a.z0 + b.z0, a.x1 + b.x1, a.y1 + b.y1, a.z1 + b.z1 }; }
r3f32_t r3f32_adds(r3f32_t a, f32 b) { return (r3f32_t){ a.x0 + b, a.y0 + b, a.z0 + b, a.x1 + b, a.y1 + b, a.z1 + b }; }
r3f32_t r3f32_sub(r3f32_t a, r3f32_t b) { return (r3f32_t){ a.x0 - b.x0, a.y0 - b.y0, a.z0 - b.z0, a.x1 - b.x1, a.y1 - b.y1, a.z1 - b.z1 }; }
@@ -45,6 +60,9 @@ r3f32_t r3f32_muls(r3f32_t a, f32 b) { return (r3f32_t){ a.x0 * b, a.y0 * b, a.z
r3f32_t r3f32_div(r3f32_t a, r3f32_t b) { return (r3f32_t){ a.x0 / b.x0, a.y0 / b.y0, a.z0 / b.z0, a.x1 / b.x1, a.y1 / b.y1, a.z1 / b.z1 }; }
r3f32_t r3f32_divs(r3f32_t a, f32 b) { return (r3f32_t){ a.x0 / b, a.y0 / b, a.z0 / b, a.x1 / b, a.y1 / b, a.z1 / b }; }
v2f64_t v2f64(f64 x, f64 y) { return (v2f64_t){ x, y }; }
gb_read_only v2f64_t v2f64_null = {0};
b32 v2f64_is_null(v2f64_t a) { return memory_equal(&a, &v2f64_null, sizeof(a)); }
b32 v2f64_are_equal(v2f64_t a, v2f64_t b) { return memory_equal(&a, &b, sizeof(a)); }
v2f64_t v2f64_add(v2f64_t a, v2f64_t b) { return (v2f64_t){ a.x + b.x, a.y + b.y }; }
v2f64_t v2f64_adds(v2f64_t a, f64 b) { return (v2f64_t){ a.x + b, a.y + b }; }
v2f64_t v2f64_sub(v2f64_t a, v2f64_t b) { return (v2f64_t){ a.x - b.x, a.y - b.y }; }
@@ -54,6 +72,9 @@ v2f64_t v2f64_muls(v2f64_t a, f64 b) { return (v2f64_t){ a.x * b, a.y * b }; }
v2f64_t v2f64_div(v2f64_t a, v2f64_t b) { return (v2f64_t){ a.x / b.x, a.y / b.y }; }
v2f64_t v2f64_divs(v2f64_t a, f64 b) { return (v2f64_t){ a.x / b, a.y / b }; }
v3f64_t v3f64(f64 x, f64 y, f64 z) { return (v3f64_t){ x, y, z }; }
gb_read_only v3f64_t v3f64_null = {0};
b32 v3f64_is_null(v3f64_t a) { return memory_equal(&a, &v3f64_null, sizeof(a)); }
b32 v3f64_are_equal(v3f64_t a, v3f64_t b) { return memory_equal(&a, &b, sizeof(a)); }
v3f64_t v3f64_add(v3f64_t a, v3f64_t b) { return (v3f64_t){ a.x + b.x, a.y + b.y, a.z + b.z }; }
v3f64_t v3f64_adds(v3f64_t a, f64 b) { return (v3f64_t){ a.x + b, a.y + b, a.z + b }; }
v3f64_t v3f64_sub(v3f64_t a, v3f64_t b) { return (v3f64_t){ a.x - b.x, a.y - b.y, a.z - b.z }; }
@@ -63,6 +84,9 @@ v3f64_t v3f64_muls(v3f64_t a, f64 b) { return (v3f64_t){ a.x * b, a.y * b, a.z *
v3f64_t v3f64_div(v3f64_t a, v3f64_t b) { return (v3f64_t){ a.x / b.x, a.y / b.y, a.z / b.z }; }
v3f64_t v3f64_divs(v3f64_t a, f64 b) { return (v3f64_t){ a.x / b, a.y / b, a.z / b }; }
v4f64_t v4f64(f64 x, f64 y, f64 z, f64 w) { return (v4f64_t){ x, y, z, w }; }
gb_read_only v4f64_t v4f64_null = {0};
b32 v4f64_is_null(v4f64_t a) { return memory_equal(&a, &v4f64_null, sizeof(a)); }
b32 v4f64_are_equal(v4f64_t a, v4f64_t b) { return memory_equal(&a, &b, sizeof(a)); }
v4f64_t v4f64_add(v4f64_t a, v4f64_t b) { return (v4f64_t){ a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w }; }
v4f64_t v4f64_adds(v4f64_t a, f64 b) { return (v4f64_t){ a.x + b, a.y + b, a.z + b, a.w + b }; }
v4f64_t v4f64_sub(v4f64_t a, v4f64_t b) { return (v4f64_t){ a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w }; }
@@ -72,6 +96,9 @@ v4f64_t v4f64_muls(v4f64_t a, f64 b) { return (v4f64_t){ a.x * b, a.y * b, a.z *
v4f64_t v4f64_div(v4f64_t a, v4f64_t b) { return (v4f64_t){ a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w }; }
v4f64_t v4f64_divs(v4f64_t a, f64 b) { return (v4f64_t){ a.x / b, a.y / b, a.z / b, a.w / b }; }
r2f64_t r2f64(f64 x0, f64 y0, f64 x1, f64 y1) { return (r2f64_t){ x0, y0, x1, y1 }; }
gb_read_only r2f64_t r2f64_null = {0};
b32 r2f64_is_null(r2f64_t a) { return memory_equal(&a, &r2f64_null, sizeof(a)); }
b32 r2f64_are_equal(r2f64_t a, r2f64_t b) { return memory_equal(&a, &b, sizeof(a)); }
r2f64_t r2f64_add(r2f64_t a, r2f64_t b) { return (r2f64_t){ a.x0 + b.x0, a.y0 + b.y0, a.x1 + b.x1, a.y1 + b.y1 }; }
r2f64_t r2f64_adds(r2f64_t a, f64 b) { return (r2f64_t){ a.x0 + b, a.y0 + b, a.x1 + b, a.y1 + b }; }
r2f64_t r2f64_sub(r2f64_t a, r2f64_t b) { return (r2f64_t){ a.x0 - b.x0, a.y0 - b.y0, a.x1 - b.x1, a.y1 - b.y1 }; }
@@ -81,6 +108,9 @@ r2f64_t r2f64_muls(r2f64_t a, f64 b) { return (r2f64_t){ a.x0 * b, a.y0 * b, a.x
r2f64_t r2f64_div(r2f64_t a, r2f64_t b) { return (r2f64_t){ a.x0 / b.x0, a.y0 / b.y0, a.x1 / b.x1, a.y1 / b.y1 }; }
r2f64_t r2f64_divs(r2f64_t a, f64 b) { return (r2f64_t){ a.x0 / b, a.y0 / b, a.x1 / b, a.y1 / b }; }
r3f64_t r3f64(f64 x0, f64 y0, f64 z0, f64 x1, f64 y1, f64 z1) { return (r3f64_t){ x0, y0, z0, x1, y1, z1 }; }
gb_read_only r3f64_t r3f64_null = {0};
b32 r3f64_is_null(r3f64_t a) { return memory_equal(&a, &r3f64_null, sizeof(a)); }
b32 r3f64_are_equal(r3f64_t a, r3f64_t b) { return memory_equal(&a, &b, sizeof(a)); }
r3f64_t r3f64_add(r3f64_t a, r3f64_t b) { return (r3f64_t){ a.x0 + b.x0, a.y0 + b.y0, a.z0 + b.z0, a.x1 + b.x1, a.y1 + b.y1, a.z1 + b.z1 }; }
r3f64_t r3f64_adds(r3f64_t a, f64 b) { return (r3f64_t){ a.x0 + b, a.y0 + b, a.z0 + b, a.x1 + b, a.y1 + b, a.z1 + b }; }
r3f64_t r3f64_sub(r3f64_t a, r3f64_t b) { return (r3f64_t){ a.x0 - b.x0, a.y0 - b.y0, a.z0 - b.z0, a.x1 - b.x1, a.y1 - b.y1, a.z1 - b.z1 }; }
@@ -90,6 +120,9 @@ r3f64_t r3f64_muls(r3f64_t a, f64 b) { return (r3f64_t){ a.x0 * b, a.y0 * b, a.z
r3f64_t r3f64_div(r3f64_t a, r3f64_t b) { return (r3f64_t){ a.x0 / b.x0, a.y0 / b.y0, a.z0 / b.z0, a.x1 / b.x1, a.y1 / b.y1, a.z1 / b.z1 }; }
r3f64_t r3f64_divs(r3f64_t a, f64 b) { return (r3f64_t){ a.x0 / b, a.y0 / b, a.z0 / b, a.x1 / b, a.y1 / b, a.z1 / b }; }
v2i32_t v2i32(i32 x, i32 y) { return (v2i32_t){ x, y }; }
gb_read_only v2i32_t v2i32_null = {0};
b32 v2i32_is_null(v2i32_t a) { return memory_equal(&a, &v2i32_null, sizeof(a)); }
b32 v2i32_are_equal(v2i32_t a, v2i32_t b) { return memory_equal(&a, &b, sizeof(a)); }
v2i32_t v2i32_add(v2i32_t a, v2i32_t b) { return (v2i32_t){ a.x + b.x, a.y + b.y }; }
v2i32_t v2i32_adds(v2i32_t a, i32 b) { return (v2i32_t){ a.x + b, a.y + b }; }
v2i32_t v2i32_sub(v2i32_t a, v2i32_t b) { return (v2i32_t){ a.x - b.x, a.y - b.y }; }
@@ -99,6 +132,9 @@ v2i32_t v2i32_muls(v2i32_t a, i32 b) { return (v2i32_t){ a.x * b, a.y * b }; }
v2i32_t v2i32_div(v2i32_t a, v2i32_t b) { return (v2i32_t){ a.x / b.x, a.y / b.y }; }
v2i32_t v2i32_divs(v2i32_t a, i32 b) { return (v2i32_t){ a.x / b, a.y / b }; }
v3i32_t v3i32(i32 x, i32 y, i32 z) { return (v3i32_t){ x, y, z }; }
gb_read_only v3i32_t v3i32_null = {0};
b32 v3i32_is_null(v3i32_t a) { return memory_equal(&a, &v3i32_null, sizeof(a)); }
b32 v3i32_are_equal(v3i32_t a, v3i32_t b) { return memory_equal(&a, &b, sizeof(a)); }
v3i32_t v3i32_add(v3i32_t a, v3i32_t b) { return (v3i32_t){ a.x + b.x, a.y + b.y, a.z + b.z }; }
v3i32_t v3i32_adds(v3i32_t a, i32 b) { return (v3i32_t){ a.x + b, a.y + b, a.z + b }; }
v3i32_t v3i32_sub(v3i32_t a, v3i32_t b) { return (v3i32_t){ a.x - b.x, a.y - b.y, a.z - b.z }; }
@@ -108,6 +144,9 @@ v3i32_t v3i32_muls(v3i32_t a, i32 b) { return (v3i32_t){ a.x * b, a.y * b, a.z *
v3i32_t v3i32_div(v3i32_t a, v3i32_t b) { return (v3i32_t){ a.x / b.x, a.y / b.y, a.z / b.z }; }
v3i32_t v3i32_divs(v3i32_t a, i32 b) { return (v3i32_t){ a.x / b, a.y / b, a.z / b }; }
v4i32_t v4i32(i32 x, i32 y, i32 z, i32 w) { return (v4i32_t){ x, y, z, w }; }
gb_read_only v4i32_t v4i32_null = {0};
b32 v4i32_is_null(v4i32_t a) { return memory_equal(&a, &v4i32_null, sizeof(a)); }
b32 v4i32_are_equal(v4i32_t a, v4i32_t b) { return memory_equal(&a, &b, sizeof(a)); }
v4i32_t v4i32_add(v4i32_t a, v4i32_t b) { return (v4i32_t){ a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w }; }
v4i32_t v4i32_adds(v4i32_t a, i32 b) { return (v4i32_t){ a.x + b, a.y + b, a.z + b, a.w + b }; }
v4i32_t v4i32_sub(v4i32_t a, v4i32_t b) { return (v4i32_t){ a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w }; }
@@ -117,6 +156,9 @@ v4i32_t v4i32_muls(v4i32_t a, i32 b) { return (v4i32_t){ a.x * b, a.y * b, a.z *
v4i32_t v4i32_div(v4i32_t a, v4i32_t b) { return (v4i32_t){ a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w }; }
v4i32_t v4i32_divs(v4i32_t a, i32 b) { return (v4i32_t){ a.x / b, a.y / b, a.z / b, a.w / b }; }
r2i32_t r2i32(i32 x0, i32 y0, i32 x1, i32 y1) { return (r2i32_t){ x0, y0, x1, y1 }; }
gb_read_only r2i32_t r2i32_null = {0};
b32 r2i32_is_null(r2i32_t a) { return memory_equal(&a, &r2i32_null, sizeof(a)); }
b32 r2i32_are_equal(r2i32_t a, r2i32_t b) { return memory_equal(&a, &b, sizeof(a)); }
r2i32_t r2i32_add(r2i32_t a, r2i32_t b) { return (r2i32_t){ a.x0 + b.x0, a.y0 + b.y0, a.x1 + b.x1, a.y1 + b.y1 }; }
r2i32_t r2i32_adds(r2i32_t a, i32 b) { return (r2i32_t){ a.x0 + b, a.y0 + b, a.x1 + b, a.y1 + b }; }
r2i32_t r2i32_sub(r2i32_t a, r2i32_t b) { return (r2i32_t){ a.x0 - b.x0, a.y0 - b.y0, a.x1 - b.x1, a.y1 - b.y1 }; }
@@ -126,6 +168,9 @@ r2i32_t r2i32_muls(r2i32_t a, i32 b) { return (r2i32_t){ a.x0 * b, a.y0 * b, a.x
r2i32_t r2i32_div(r2i32_t a, r2i32_t b) { return (r2i32_t){ a.x0 / b.x0, a.y0 / b.y0, a.x1 / b.x1, a.y1 / b.y1 }; }
r2i32_t r2i32_divs(r2i32_t a, i32 b) { return (r2i32_t){ a.x0 / b, a.y0 / b, a.x1 / b, a.y1 / b }; }
r3i32_t r3i32(i32 x0, i32 y0, i32 z0, i32 x1, i32 y1, i32 z1) { return (r3i32_t){ x0, y0, z0, x1, y1, z1 }; }
gb_read_only r3i32_t r3i32_null = {0};
b32 r3i32_is_null(r3i32_t a) { return memory_equal(&a, &r3i32_null, sizeof(a)); }
b32 r3i32_are_equal(r3i32_t a, r3i32_t b) { return memory_equal(&a, &b, sizeof(a)); }
r3i32_t r3i32_add(r3i32_t a, r3i32_t b) { return (r3i32_t){ a.x0 + b.x0, a.y0 + b.y0, a.z0 + b.z0, a.x1 + b.x1, a.y1 + b.y1, a.z1 + b.z1 }; }
r3i32_t r3i32_adds(r3i32_t a, i32 b) { return (r3i32_t){ a.x0 + b, a.y0 + b, a.z0 + b, a.x1 + b, a.y1 + b, a.z1 + b }; }
r3i32_t r3i32_sub(r3i32_t a, r3i32_t b) { return (r3i32_t){ a.x0 - b.x0, a.y0 - b.y0, a.z0 - b.z0, a.x1 - b.x1, a.y1 - b.y1, a.z1 - b.z1 }; }
@@ -135,6 +180,9 @@ r3i32_t r3i32_muls(r3i32_t a, i32 b) { return (r3i32_t){ a.x0 * b, a.y0 * b, a.z
r3i32_t r3i32_div(r3i32_t a, r3i32_t b) { return (r3i32_t){ a.x0 / b.x0, a.y0 / b.y0, a.z0 / b.z0, a.x1 / b.x1, a.y1 / b.y1, a.z1 / b.z1 }; }
r3i32_t r3i32_divs(r3i32_t a, i32 b) { return (r3i32_t){ a.x0 / b, a.y0 / b, a.z0 / b, a.x1 / b, a.y1 / b, a.z1 / b }; }
v2i64_t v2i64(i64 x, i64 y) { return (v2i64_t){ x, y }; }
gb_read_only v2i64_t v2i64_null = {0};
b32 v2i64_is_null(v2i64_t a) { return memory_equal(&a, &v2i64_null, sizeof(a)); }
b32 v2i64_are_equal(v2i64_t a, v2i64_t b) { return memory_equal(&a, &b, sizeof(a)); }
v2i64_t v2i64_add(v2i64_t a, v2i64_t b) { return (v2i64_t){ a.x + b.x, a.y + b.y }; }
v2i64_t v2i64_adds(v2i64_t a, i64 b) { return (v2i64_t){ a.x + b, a.y + b }; }
v2i64_t v2i64_sub(v2i64_t a, v2i64_t b) { return (v2i64_t){ a.x - b.x, a.y - b.y }; }
@@ -144,6 +192,9 @@ v2i64_t v2i64_muls(v2i64_t a, i64 b) { return (v2i64_t){ a.x * b, a.y * b }; }
v2i64_t v2i64_div(v2i64_t a, v2i64_t b) { return (v2i64_t){ a.x / b.x, a.y / b.y }; }
v2i64_t v2i64_divs(v2i64_t a, i64 b) { return (v2i64_t){ a.x / b, a.y / b }; }
v3i64_t v3i64(i64 x, i64 y, i64 z) { return (v3i64_t){ x, y, z }; }
gb_read_only v3i64_t v3i64_null = {0};
b32 v3i64_is_null(v3i64_t a) { return memory_equal(&a, &v3i64_null, sizeof(a)); }
b32 v3i64_are_equal(v3i64_t a, v3i64_t b) { return memory_equal(&a, &b, sizeof(a)); }
v3i64_t v3i64_add(v3i64_t a, v3i64_t b) { return (v3i64_t){ a.x + b.x, a.y + b.y, a.z + b.z }; }
v3i64_t v3i64_adds(v3i64_t a, i64 b) { return (v3i64_t){ a.x + b, a.y + b, a.z + b }; }
v3i64_t v3i64_sub(v3i64_t a, v3i64_t b) { return (v3i64_t){ a.x - b.x, a.y - b.y, a.z - b.z }; }
@@ -153,6 +204,9 @@ v3i64_t v3i64_muls(v3i64_t a, i64 b) { return (v3i64_t){ a.x * b, a.y * b, a.z *
v3i64_t v3i64_div(v3i64_t a, v3i64_t b) { return (v3i64_t){ a.x / b.x, a.y / b.y, a.z / b.z }; }
v3i64_t v3i64_divs(v3i64_t a, i64 b) { return (v3i64_t){ a.x / b, a.y / b, a.z / b }; }
v4i64_t v4i64(i64 x, i64 y, i64 z, i64 w) { return (v4i64_t){ x, y, z, w }; }
gb_read_only v4i64_t v4i64_null = {0};
b32 v4i64_is_null(v4i64_t a) { return memory_equal(&a, &v4i64_null, sizeof(a)); }
b32 v4i64_are_equal(v4i64_t a, v4i64_t b) { return memory_equal(&a, &b, sizeof(a)); }
v4i64_t v4i64_add(v4i64_t a, v4i64_t b) { return (v4i64_t){ a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w }; }
v4i64_t v4i64_adds(v4i64_t a, i64 b) { return (v4i64_t){ a.x + b, a.y + b, a.z + b, a.w + b }; }
v4i64_t v4i64_sub(v4i64_t a, v4i64_t b) { return (v4i64_t){ a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w }; }
@@ -162,6 +216,9 @@ v4i64_t v4i64_muls(v4i64_t a, i64 b) { return (v4i64_t){ a.x * b, a.y * b, a.z *
v4i64_t v4i64_div(v4i64_t a, v4i64_t b) { return (v4i64_t){ a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w }; }
v4i64_t v4i64_divs(v4i64_t a, i64 b) { return (v4i64_t){ a.x / b, a.y / b, a.z / b, a.w / b }; }
r2i64_t r2i64(i64 x0, i64 y0, i64 x1, i64 y1) { return (r2i64_t){ x0, y0, x1, y1 }; }
gb_read_only r2i64_t r2i64_null = {0};
b32 r2i64_is_null(r2i64_t a) { return memory_equal(&a, &r2i64_null, sizeof(a)); }
b32 r2i64_are_equal(r2i64_t a, r2i64_t b) { return memory_equal(&a, &b, sizeof(a)); }
r2i64_t r2i64_add(r2i64_t a, r2i64_t b) { return (r2i64_t){ a.x0 + b.x0, a.y0 + b.y0, a.x1 + b.x1, a.y1 + b.y1 }; }
r2i64_t r2i64_adds(r2i64_t a, i64 b) { return (r2i64_t){ a.x0 + b, a.y0 + b, a.x1 + b, a.y1 + b }; }
r2i64_t r2i64_sub(r2i64_t a, r2i64_t b) { return (r2i64_t){ a.x0 - b.x0, a.y0 - b.y0, a.x1 - b.x1, a.y1 - b.y1 }; }
@@ -171,6 +228,9 @@ r2i64_t r2i64_muls(r2i64_t a, i64 b) { return (r2i64_t){ a.x0 * b, a.y0 * b, a.x
r2i64_t r2i64_div(r2i64_t a, r2i64_t b) { return (r2i64_t){ a.x0 / b.x0, a.y0 / b.y0, a.x1 / b.x1, a.y1 / b.y1 }; }
r2i64_t r2i64_divs(r2i64_t a, i64 b) { return (r2i64_t){ a.x0 / b, a.y0 / b, a.x1 / b, a.y1 / b }; }
r3i64_t r3i64(i64 x0, i64 y0, i64 z0, i64 x1, i64 y1, i64 z1) { return (r3i64_t){ x0, y0, z0, x1, y1, z1 }; }
gb_read_only r3i64_t r3i64_null = {0};
b32 r3i64_is_null(r3i64_t a) { return memory_equal(&a, &r3i64_null, sizeof(a)); }
b32 r3i64_are_equal(r3i64_t a, r3i64_t b) { return memory_equal(&a, &b, sizeof(a)); }
r3i64_t r3i64_add(r3i64_t a, r3i64_t b) { return (r3i64_t){ a.x0 + b.x0, a.y0 + b.y0, a.z0 + b.z0, a.x1 + b.x1, a.y1 + b.y1, a.z1 + b.z1 }; }
r3i64_t r3i64_adds(r3i64_t a, i64 b) { return (r3i64_t){ a.x0 + b, a.y0 + b, a.z0 + b, a.x1 + b, a.y1 + b, a.z1 + b }; }
r3i64_t r3i64_sub(r3i64_t a, r3i64_t b) { return (r3i64_t){ a.x0 - b.x0, a.y0 - b.y0, a.z0 - b.z0, a.x1 - b.x1, a.y1 - b.y1, a.z1 - b.z1 }; }

4
src/core/core_math_gen.py
View File

@@ -163,6 +163,9 @@ for basic_type in basic_types:
return result
print(f"""{type}_t {type}({members_as_func_params(members, basic_type)}) {{ return ({type}_t){{ {members_as_func_params(members, "")} }}; }}""")
print(f"""gb_read_only {type}_t {type}_null = {{0}};""")
print(f"""b32 {type}_is_null({type}_t a) {{ return memory_equal(&a, &{type}_null, sizeof(a)); }}""")
print(f"""b32 {type}_are_equal({type}_t a, {type}_t b) {{ return memory_equal(&a, &b, sizeof(a)); }}""")
for sym in symbols:
op = sym[op_idx]
@@ -183,7 +186,6 @@ for basic_type in basic_types:
return result
print(f"{type}_t {type}_{opname}({type}_t a, {type}_t b) {{ return ({type}_t){{ {op_str(members, op)} }}; }}")
print(f"{type}_t {type}_{opname}s({type}_t a, {basic_type} b) {{ return ({type}_t){{ {op_str(members, op, skip_right = True)} }}; }}")

16
src/core/core_string.c
View File

@@ -7,7 +7,7 @@ fn i32 str_len(char *str) {
}
fn b32 str_eq(char *a, char *b) {
return s8_equal(s8_from_char(a), s8_from_char(b));
return s8_are_equal(s8_from_char(a), s8_from_char(b));
}
fn char char_to_lower_case(char a) {
@@ -98,7 +98,7 @@ s8_t s8_copy_char(ma_arena_t *ma, char *s) {
return result;
}
fn b32 s8_equal_ex(s8_t a, s8_t b, b32 ignore_case) {
fn b32 s8_are_equal_ex(s8_t a, s8_t b, b32 ignore_case) {
if (a.len != b.len) return false;
for (int64_t i = 0; i < a.len; i++) {
char A = a.str[i];
@@ -113,8 +113,8 @@ fn b32 s8_equal_ex(s8_t a, s8_t b, b32 ignore_case) {
return true;
}
fn b32 s8_equal(s8_t a, s8_t b) {
return s8_equal_ex(a, b, false);
fn b32 s8_are_equal(s8_t a, s8_t b) {
return s8_are_equal_ex(a, b, false);
}
fn s8_t s8_get_postfix(s8_t string, int64_t len) {
@@ -145,13 +145,13 @@ fn s8_t s8_skip(s8_t string, int64_t len) {
fn b32 s8_ends_with(s8_t a, s8_t end, b32 ignore_case) {
s8_t a_end = s8_get_postfix(a, end.len);
b32 result = s8_equal_ex(end, a_end, ignore_case);
b32 result = s8_are_equal_ex(end, a_end, ignore_case);
return result;
}
fn b32 s8_starts_with(s8_t a, s8_t start, b32 ignore_case) {
s8_t a_start = s8_get_prefix(a, start.len);
b32 result = s8_equal_ex(start, a_start, ignore_case);
b32 result = s8_are_equal_ex(start, a_start, ignore_case);
return result;
}
@@ -268,7 +268,7 @@ fn b32 s8_seek(s8_t string, s8_t find, s8_seek_t flags, int64_t *index_out) {
for (int64_t i = string.len; i != 0; i--) {
int64_t index = i - 1;
s8_t substring = s8_slice(string, index, index + find.len);
if (s8_equal_ex(substring, find, ignore_case)) {
if (s8_are_equal_ex(substring, find, ignore_case)) {
if (index_out)
*index_out = index;
result = true;
@@ -279,7 +279,7 @@ fn b32 s8_seek(s8_t string, s8_t find, s8_seek_t flags, int64_t *index_out) {
else {
for (int64_t i = 0; i < string.len; i++) {
s8_t substring = s8_slice(string, i, i + find.len);
if (s8_equal_ex(substring, find, ignore_case)) {
if (s8_are_equal_ex(substring, find, ignore_case)) {
if (index_out)
*index_out = i;
result = true;

4
src/core/core_string.h
View File

@@ -83,8 +83,8 @@ fn s8_t s8_from_s16(ma_arena_t *ma, s16_t string);
//
// conditional
fn b32 s8_equal_ex(s8_t a, s8_t b, b32 ignore_case);
fn b32 s8_equal(s8_t a, s8_t b);
fn b32 s8_are_equal_ex(s8_t a, s8_t b, b32 ignore_case);
fn b32 s8_are_equal(s8_t a, s8_t b);
fn b32 s8_ends_with(s8_t a, s8_t end, b32 ignore_case);
fn b32 s8_starts_with(s8_t a, s8_t start, b32 ignore_case);
fn b32 s8_is_pointer_inside(s8_t string, char *p);// @todo: maybe more general?

54
src/core/core_test_entry.c
View File

@@ -12,11 +12,11 @@ void test_s8(void) {
sb8_printf(sb, "%S", memes);
assert(sb->first == sb->last);
assert(sb->first->len == 5);
assert(s8_equal(sb->first->string, memes));
assert(s8_are_equal(sb->first->string, memes));
sb8_printf(sb, "%S", s8_lit("things are going fine"));
s8_t string = sb8_merge(sb);
assert(s8_equal(string, s8_lit("memesthings are going fine")));
assert(s8_are_equal(string, s8_lit("memesthings are going fine")));
ma_end_temp(temp);
}
@@ -25,8 +25,8 @@ void test_s8(void) {
s8_t str = s8_lit("thing|another|");
sb8_t sb = s8_split(arena, str, s8_lit("|"), s8_split_none);
assert(s8_equal(sb.first->string, s8_lit("thing")));
assert(s8_equal(sb.first->next->string, s8_lit("another")));
assert(s8_are_equal(sb.first->string, s8_lit("thing")));
assert(s8_are_equal(sb.first->next->string, s8_lit("another")));
assert(sb.first->next->next == NULL);
}
@@ -34,10 +34,10 @@ void test_s8(void) {
s8_t str = s8_lit("thing|another|");
sb8_t sb = s8_split(arena, str, s8_lit("|"), s8_split_inclusive);
assert(s8_equal(sb.first->string, s8_lit("thing")));
assert(s8_equal(sb.first->next->string, s8_lit("|")));
assert(s8_equal(sb.first->next->next->string, s8_lit("another")));
assert(s8_equal(sb.first->next->next->next->string, s8_lit("|")));
assert(s8_are_equal(sb.first->string, s8_lit("thing")));
assert(s8_are_equal(sb.first->next->string, s8_lit("|")));
assert(s8_are_equal(sb.first->next->next->string, s8_lit("another")));
assert(s8_are_equal(sb.first->next->next->next->string, s8_lit("|")));
assert(sb.first->next->next->next->next == NULL);
}
@@ -45,11 +45,11 @@ void test_s8(void) {
s8_t str = s8_lit("aabaaBaa");
sb8_t sb = s8_split(arena, str, s8_lit("b"), s8_split_inclusive | s8_split_ignore_case);
assert(s8_equal(sb.first->string, s8_lit("aa")));
assert(s8_equal(sb.first->next->string, s8_lit("b")));
assert(s8_equal(sb.first->next->next->string, s8_lit("aa")));
assert(s8_equal(sb.first->next->next->next->string, s8_lit("B")));
assert(s8_equal(sb.first->next->next->next->next->string, s8_lit("aa")));
assert(s8_are_equal(sb.first->string, s8_lit("aa")));
assert(s8_are_equal(sb.first->next->string, s8_lit("b")));
assert(s8_are_equal(sb.first->next->next->string, s8_lit("aa")));
assert(s8_are_equal(sb.first->next->next->next->string, s8_lit("B")));
assert(s8_are_equal(sb.first->next->next->next->next->string, s8_lit("aa")));
assert(sb.first->next->next->next->next->next == NULL);
}
@@ -57,41 +57,41 @@ void test_s8(void) {
s8_t str = s8_lit("aabaaBaa");
sb8_t sb = s8_split(arena, str, s8_lit("b"), s8_split_inclusive);
assert(s8_equal(sb.first->string, s8_lit("aa")));
assert(s8_equal(sb.first->next->string, s8_lit("b")));
assert(s8_equal(sb.first->next->next->string, s8_lit("aaBaa")));
assert(s8_are_equal(sb.first->string, s8_lit("aa")));
assert(s8_are_equal(sb.first->next->string, s8_lit("b")));
assert(s8_are_equal(sb.first->next->next->string, s8_lit("aaBaa")));
}
{
s8_t s = s8_lit("0123456789");
assert(s8_equal(s8_slice(s, 0, 4), s8_lit("0123")));
assert(s8_equal(s8_slice(s, -2, -1), s8_lit("89")));
assert(s8_equal(s8_slice(s, -2, 10), s8_lit("89")));
assert(s8_equal(s8_slice(s, 8, 10), s8_lit("89")));
assert(s8_are_equal(s8_slice(s, 0, 4), s8_lit("0123")));
assert(s8_are_equal(s8_slice(s, -2, -1), s8_lit("89")));
assert(s8_are_equal(s8_slice(s, -2, 10), s8_lit("89")));
assert(s8_are_equal(s8_slice(s, 8, 10), s8_lit("89")));
}
{
s8_t s = s8_lit(" a \n");
s = s8_trim(s);
assert(s8_equal(s, s8_lit("a")));
assert(s8_are_equal(s, s8_lit("a")));
}
{
s8_t s = s8_lit("C:/memes/the_thing.c");
s8_t ss = s8_get_name_no_ext(s);
assert(s8_equal(ss, s8_lit("the_thing")));
assert(s8_are_equal(ss, s8_lit("the_thing")));
}
{
s8_t s = s8_printf(arena, "%d%Sv%s", 32, s8_lit("|"), ">");
assert(s8_equal(s, s8_lit("32|v>")));
assert(s8_are_equal(s, s8_lit("32|v>")));
}
{
s8_t s0 = s8_lit("0123456789");
s8_t s1 = s8_cut_start(&s0, 2);
assert(s8_equal(s0, s8_lit("23456789")));
assert(s8_equal(s1, s8_lit("01")));
assert(s8_are_equal(s0, s8_lit("23456789")));
assert(s8_are_equal(s1, s8_lit("01")));
}
ma_destroy(arena);
}
@@ -123,8 +123,8 @@ void test_hash_table(void) {
s8_t s = s8_printf(scratch.arena, "%d", i);
ht_insert_string(ht, s, s);
ht_node_t *node = ht_search_string(ht, s);
assert(s8_equal(node->kv.value_string, s));
assert(s8_equal(node->kv.key_string, s));
assert(s8_are_equal(node->kv.value_string, s));
assert(s8_are_equal(node->kv.key_string, s));
}
ht_node_t *node = ht_search_string(ht, s8_lit("memes"));

6
src/core/core_type_info.c
View File

@@ -13,7 +13,7 @@ fn i64 ti_enum_name_to_value(s8_t name, type_t *type) {
assert(type->kind == type_kind_enum);
for (i32 i = 0; i < type->count; i += 1) {
type_member_t *it = type->members + i;
if (s8_equal(it->name, name)) {
if (s8_are_equal(it->name, name)) {
return it->value;
}
}
@@ -55,7 +55,7 @@ fn void ti_enum_write_value(void *p, i64 value, type_t *type) {
fn type_member_t *ti_get_member(s8_t name, type_t *type) {
for (i32 i = 0; i < type->count; i += 1) {
type_member_t *it = type->members + i;
if (s8_equal(it->name, name)) {
if (s8_are_equal(it->name, name)) {
return it;
}
}
@@ -390,7 +390,7 @@ fn void ti__deserial_data_ex(ma_arena_t *arena, parser_t *par, void *p, type_t *
lex_t *ident = parser_expect(par, lex_kind_ident);
parser_expect(par, lex_kind_colon);
expect (s8_equal(ident->string, mem->name)) fatalf("expected identifier: %S, got instead %S", mem->name, ident->string);
expect (s8_are_equal(ident->string, mem->name)) fatalf("expected identifier: %S, got instead %S", mem->name, ident->string);
ti__deserial_data_ex(arena, par, memp, mem->type);
parser_expect(par, lex_kind_comma);

43
src/meta/build_tool.c
View File

@@ -2296,7 +2296,7 @@ OS_API S8_String OS_GetAbsolutePath(MA_Arena *arena, S8_String relative) {
return path;
}
OS_API bool OS_FileExists(S8_String path) {
OS_API bool os_file_exists(S8_String path) {
wchar_t wbuff[1024];
UTF_CreateWidecharFromChar(wbuff, MA_Lengthof(wbuff), path.str, path.len);
DWORD attribs = GetFileAttributesW(wbuff);
@@ -2664,7 +2664,7 @@ OS_API S8_String OS_GetAbsolutePath(MA_Arena *arena, S8_String relative) {
return result;
}
OS_API bool OS_FileExists(S8_String path) {
OS_API bool os_file_exists(S8_String path) {
MA_Temp scratch = MA_GetScratch();
S8_String copy = S8_Copy(scratch.arena, path);
@@ -4969,7 +4969,7 @@ SRC_Cache *SRC_FromFileCache;
S8_String SRC_CacheFilename;
CL_SearchPaths SRC_SearchPaths = {0}; // @todo;
void SRC_InitCache(MA_Arena *arena, S8_String cachefilename) {
void cache_init(MA_Arena *arena, S8_String cachefilename) {
SRC_CacheFilename = cachefilename;
SRC_InMemoryCache = MA_PushStruct(arena, SRC_Cache);
@@ -4982,12 +4982,12 @@ void SRC_InitCache(MA_Arena *arena, S8_String cachefilename) {
if (cache.len) MA_MemoryCopy(SRC_FromFileCache, cache.str, cache.len);
}
void SRC_SaveCache() {
void cache_save() {
S8_String dump = S8_Make((char *)SRC_InMemoryCache, sizeof(SRC_Cache));
os_write_file(SRC_CacheFilename, dump);
}
SRC_CacheEntry *SRC_AddHash(uint64_t filepath, uint64_t file, uint64_t includes) {
SRC_CacheEntry *cache_add_hash(uint64_t filepath, uint64_t file, uint64_t includes) {
IO_Assert(SRC_InMemoryCache->entry_len + 1 < SRC_InMemoryCache->entry_cap);
SRC_CacheEntry *result = SRC_InMemoryCache->entries + SRC_InMemoryCache->entry_len++;
result->filepath_hash = filepath;
@@ -4997,7 +4997,7 @@ SRC_CacheEntry *SRC_AddHash(uint64_t filepath, uint64_t file, uint64_t includes)
return result;
}
SRC_CacheEntry *SRC_FindCache(SRC_Cache *cache, uint64_t filepath_hash) {
SRC_CacheEntry *cache_find(SRC_Cache *cache, uint64_t filepath_hash) {
for (int cache_i = 0; cache_i < cache->entry_len; cache_i += 1) {
SRC_CacheEntry *it = cache->entries + cache_i;
if (it->filepath_hash == filepath_hash) {
@@ -5007,7 +5007,7 @@ SRC_CacheEntry *SRC_FindCache(SRC_Cache *cache, uint64_t filepath_hash) {
return 0;
}
SRC_CacheEntry *SRC_HashFile(S8_String file, char *parent_file) {
SRC_CacheEntry *cache_hash_file(S8_String file, char *parent_file) {
char *resolved_file = CL_ResolveFilepath(&Perm, &SRC_SearchPaths, file.str, parent_file, false);
if (!resolved_file) {
IO_Printf("Failed to resolve file: %.*s\n", S8_Expand(file));
@@ -5015,7 +5015,7 @@ SRC_CacheEntry *SRC_HashFile(S8_String file, char *parent_file) {
}
uint64_t filepath_hash = HashBytes(resolved_file, S8_Length(resolved_file));
SRC_CacheEntry *entry = SRC_FindCache(SRC_InMemoryCache, filepath_hash);
SRC_CacheEntry *entry = cache_find(SRC_InMemoryCache, filepath_hash);
if (entry) return entry;
S8_String filecontent = OS_ReadFile(&Perm, S8_MakeFromChar(resolved_file));
@@ -5031,7 +5031,7 @@ SRC_CacheEntry *SRC_HashFile(S8_String file, char *parent_file) {
if (token.is_system_include) continue;
S8_String file_it = S8_MakeFromChar(token.string_literal);
SRC_CacheEntry *cache = SRC_HashFile(file_it, resolved_file);
SRC_CacheEntry *cache = cache_hash_file(file_it, resolved_file);
if (!cache) {
// error was reported already IO_Printf("Missing cache for: %.*s\n", S8_Expand(file_it));
continue;
@@ -5040,14 +5040,14 @@ SRC_CacheEntry *SRC_HashFile(S8_String file, char *parent_file) {
includes_hash = HashMix(includes_hash, cache->total_hash);
}
SRC_CacheEntry *result = SRC_AddHash(filepath_hash, file_hash, includes_hash);
SRC_CacheEntry *result = cache_add_hash(filepath_hash, file_hash, includes_hash);
return result;
}
bool SRC_WasModified(S8_String file, S8_String artifact_path) {
bool cache_code_modified(S8_String file, S8_String artifact_path) {
double time_start = OS_GetTime();
if (OS_FileExists(file) == false) {
if (os_file_exists(file) == false) {
IO_Printf("FAILED File doesnt exist: %.*s\n", S8_Expand(file));
exit(0);
}
@@ -5055,17 +5055,16 @@ bool SRC_WasModified(S8_String file, S8_String artifact_path) {
file = OS_GetAbsolutePath(&Perm, file);
}
S8_String without_ext = S8_ChopLastPeriod(file);
S8_String name_only = S8_SkipToLastSlash(without_ext);
bool modified = false;
if (artifact_path.len) {
modified = os_file_exists(artifact_path) == false;
}
if (artifact_path.len == 0) artifact_path = S8_Format(&Perm, "%.*s.%s", S8_Expand(name_only), IF_WINDOWS_ELSE("obj", "o"));
bool modified = OS_FileExists(artifact_path) == false;
SRC_CacheEntry *in_memory = SRC_HashFile(file, 0);
SRC_CacheEntry *in_memory = cache_hash_file(file, 0);
IO_Assert(in_memory);
if (modified == false) {
SRC_CacheEntry *from_file = SRC_FindCache(SRC_FromFileCache, in_memory->filepath_hash);
SRC_CacheEntry *from_file = cache_find(SRC_FromFileCache, in_memory->filepath_hash);
if (from_file == 0 || (in_memory->total_hash != from_file->total_hash)) {
modified = true;
}
@@ -5142,13 +5141,13 @@ int main(int argument_count, char **arguments) {
}
}
SRC_InitCache(&Perm, S8_Lit("build_tool.cache"));
cache_init(&Perm, S8_Lit("build_tool.cache"));
S8_String name_no_ext = S8_GetNameNoExt(build_file);
S8_String exe_name = S8_Format(&Perm, "%.*s.exe", S8_Expand(name_no_ext));
// Compile the build file only if code changed
double time_build_file_compiled = 0;
if (SRC_WasModified(build_file, exe_name)) {
if (cache_code_modified(build_file, exe_name)) {
time_build_file_compiled = OS_GetTime();
int result = 0;
if (S8_AreEqual(cc, S8_Lit("cl"), false)) {
@@ -5180,7 +5179,7 @@ int main(int argument_count, char **arguments) {
}
}
SRC_SaveCache();
cache_save();
if (time_build_file_compiled) IO_Printf("build file compiled in: %f\n", time_build_file_compiled);
IO_Printf("executed in : %f\n", OS_GetTime() - time);
}

2
src/meta/serialize.c
View File

@@ -178,7 +178,7 @@ int row_findi(ast_t *row, char *name) {
s8_t s = s8_from_char(name);
int i = 0;
for (ast_t *col = row->first; col; col = col->next) {
if (s8_equal(col->string, s)) {
if (s8_are_equal(col->string, s)) {
return i;
}
i += 1;

39
src/wasm_app/ui.c
View File

@@ -66,8 +66,8 @@ fn void ui_push_box(ui_box_t *parent, ui_box_t *box) {
parent->node_count += 1;
}
fn r2f32_t ui_next_rect(ui_op_t layout_op, r2f32_t *rect, v2f32_t required_size) {
switch (layout_op) {
fn r2f32_t ui_next_rect(ui_op_t op, r2f32_t *rect, v2f32_t required_size) {
switch (op) {
case ui_op_cut_top: return r2f32_cut_top_no_squash(rect, required_size.y); break;
case ui_op_cut_bottom: return r2f32_cut_bottom_no_squash(rect, required_size.y); break;
case ui_op_cut_left: return r2f32_cut_left_no_squash(rect, required_size.x); break;
@@ -95,8 +95,6 @@ fn ui_box_t *ui_build_box_from_id(ui_code_loc_t loc, ui_box_flags_t flags, ui_id
box->id = id;
box->flags = flags;
ui_push_box(ui->top, box);
r2f32_t rect = ui_next_rect(ui->top->layout_op, &ui->top->rect, rn_measure_string(&rn_state.main_font, box->string));
ui_set_rect(box, rect);
return box;
}
@@ -104,6 +102,10 @@ fn ui_box_t *ui_build_box_from_string(ui_code_loc_t loc, ui_box_flags_t flags, s
ui_id_t id = ui_id_from_string(ui_get_hash_string(string));
ui_box_t *box = ui_build_box_from_id(loc, flags, id);
box->string = ui_get_display_string(string);
v2f32_t string_size = rn_measure_string(&rn_state.main_font, box->string);
string_size.x += 50;
r2f32_t rect = ui_next_rect(ui->top->op, &ui->top->rect, string_size);
ui_set_rect(box, rect);
return box;
}
@@ -146,7 +148,7 @@ fn ui_signal_t ui_signal_from_box(ui_box_t *box) {
#define ui_button(...) ui__button(UILOC, __VA_ARGS__)
fn ui_signal_t ui__button(ui_code_loc_t loc, char *str, ...) {
S8_FMT(tcx.temp, str, string);
ui_box_t *box = ui_build_box_from_string(loc, (ui_box_flags_t){ .draw_rect = true, .draw_text = true }, string);
ui_box_t *box = ui_build_box_from_string(loc, (ui_box_flags_t){ .draw_rect = true, .draw_text = true, .fully_center_text = true }, string);
ui_signal_t signal = ui_signal_from_box(box);
return signal;
}
@@ -217,6 +219,7 @@ fn void ui_draw(app_frame_t *frame) {
for (ui_preorder_iter_t it = ui_iterate_preorder(&ui->root); ui_preorder_iter_is_valid(it); ui_iter_advance_preorder(&it)) {
ui_box_t *box = it.box;
box->final_rect = box->full_rect;
r2f32_t rect = box->final_rect;
v4f32_t rect_color = primary_color_global;
v4f32_t text_color = black_color_global;
@@ -230,18 +233,21 @@ fn void ui_draw(app_frame_t *frame) {
}
if (box->flags.draw_rect) {
rn_draw_rect(box->full_rect, rect_color);
rn_draw_rect(rect, rect_color);
}
if (box->flags.draw_border) {
rn_draw_rect_border(box->full_rect, accent2_color_global);
rn_draw_rect_border(rect, accent2_color_global);
}
if (box->flags.draw_text) {
v2f32_t string_size = rn_measure_string(&rn_state.main_font, box->string);
v2f32_t rect_size = r2f32_get_size(box->full_rect);
v2f32_t rect_size = r2f32_get_size(rect);
v2f32_t rect_string_diff = v2f32_sub(rect_size, string_size);
v2f32_t center_pos = v2f32_divs(rect_string_diff, 2);
v2f32_t pos_in_rect = v2f32(box->full_rect.min.x, center_pos.y);
v2f32_t pos = v2f32_add(pos_in_rect, box->full_rect.min);
v2f32_t pos_in_rect = v2f32(0, center_pos.y);
if (box->flags.fully_center_text) {
pos_in_rect = center_pos;
}
v2f32_t pos = v2f32_add(pos_in_rect, rect.min);
rn_draw_string(&rn_state.main_font, pos, text_color, box->string);
}
}
@@ -256,13 +262,22 @@ fn void ui_demo_update(app_frame_t *frame) {
for (app_event_t *ev = frame->first_event; ev; ev = ev->next) {
ui_begin_build(UILOC, ev, window_rect_from_frame(frame));
ui->top->layout_op = ui_op_idle;
ui->top->op = ui_op_idle;
ui_box_t *top_box = ui_boxf((ui_box_flags_t){.draw_rect = true, .draw_border = true}, "top_box");
ui_set_rect(top_box, r2f32_cut_top(&ui->top->rect, ui_em(1)));
defer_block(ui_push_top(top_box), ui_pop_top()) {
top_box->op = ui_op_cut_left;
ui_button("file");
ui_button("edit");
}
ui_box_t *scroller_box = ui_boxf((ui_box_flags_t){.draw_rect = true}, "scroller");
ui_set_rect(scroller_box, r2f32_cut_right(&ui->top->rect, ui_em(1)));
ui_box_t *item_box = ui_boxf((ui_box_flags_t){.draw_rect = true}, "item_box");
ui_set_rect(item_box, r2f32_cut_left(&ui->top->rect, ui_max));
// @todo: now actually fill this out with struct data using type info
static f32 scroller_value;
defer_block(ui_push_top(item_box), ui_pop_top()) {
defer_if (ui_begin_expander("app_event_t").clicked, ui_end_expander()) {
@@ -295,7 +310,7 @@ fn void ui_demo_update(app_frame_t *frame) {
f32 scroller_percent = scroller_norm * scrollable_space;
f32 scroller_second = scrollable_space - scroller_percent;
scroller_box->layout_op = ui_op_idle;
scroller_box->op = ui_op_idle;
r2f32_cut_top(&ui->top->rect, scroller_percent * scroller_box_size);
ui_box_t *box = ui_build_box_from_id(UILOC, (ui_box_flags_t){.draw_border = true, .draw_rect = true}, ui_id_from_string(s8_lit("slider")));
ui_set_rect(box, r2f32_cut_top(&ui->top->rect, scroller_size * scroller_box_size));

11
src/wasm_app/ui.h
View File

@@ -15,6 +15,8 @@ struct ui_box_flags_t {
b8 draw_rect: 1;
b8 draw_border: 1;
b8 draw_text: 1;
b8 fully_center_text : 1;
};
typedef enum {
@@ -36,12 +38,15 @@ struct ui_box_t {
ui_code_loc_t loc;
s8_t string;
r2f32_t full_rect;
r2f32_t rect;
ui_op_t layout_op;
ui_box_flags_t flags;
b8 created_new;
ui_op_t op;
r2f32_t full_rect;
r2f32_t rect;
// state
ui_id_t id;
ui_box_t *hash_next;
ui_box_t *hash_prev;

4
src/wasm_app/ui_iter.c
View File

@@ -85,7 +85,7 @@ fn void ui_test_iterator(void) {
}
s8_t iter_string = sb8_serial_end(scratch.arena, sb);
assert(s8_equal(recursive_string, iter_string));
assert(s8_are_equal(recursive_string, iter_string));
ma_end_scratch(scratch);
}
@@ -102,7 +102,7 @@ fn void ui_test_iterator(void) {
}
s8_t iter_string = sb8_serial_end(scratch.arena, sb);
assert(s8_equal(recursive_string, iter_string));
assert(s8_are_equal(recursive_string, iter_string));
ma_end_scratch(scratch);
}