it's working on web and in window, waow

build_file.c

@@ -13,6 +13,7 @@
 
 #include "src/app/app.meta.c"
 #include "src/ui/ui.meta.c"
+#include "src/render/render.meta.c"
 #include "src/wasm_app/wasm_app.meta.c"
 
 int main(int argc, char **argv) {
@@ -32,6 +33,7 @@ int main(int argc, char **argv) {
     mt_ui(arena);
     mt_app(arena);
     mt_wasm_app(arena);
+    mt_render(arena);
 
     b32 run_server = false;
     b32 core_test_target = true;

package/index.html

@@ -189,7 +189,7 @@ const ctx2d = canvas.getContext('2d');
     const instance = program['instance'];
     const wasm_exports = instance['exports'];
     mem.exports = wasm_exports;
-    wasm_exports['wasm_init']();
+    wasm_exports['wasm_init'](window.devicePixelRatio);
 
     let awake = true;
 

src/app/app.gen.c

@@ -1,3 +1,4 @@
+// automatically generated using: C:\dev\wasm\src/app/app.meta.c
 
 type_t type__app_key_t = { type_kind_enum, s8_const_lit("app_key_t"), sizeof(app_key_t),
     .members = (type_member_t[]){

src/app/app.gen.h

@@ -1,3 +1,4 @@
+// automatically generated using: C:\dev\wasm\src/app/app.meta.c
 typedef enum {
 app_key_null,
 app_key_1,

src/app/app.meta.c

@@ -2,6 +2,11 @@ void mt_app(ma_arena_t *arena) {
     sb8_t *h = sb8_serial_begin(arena);
     sb8_t *c = sb8_serial_begin(arena);
 
+    sb8_printf(h, "// automatically generated using: " __FILE__ "\n");
+    sb8_printf(c, "// automatically generated using: " __FILE__ "\n");
+
+
+
     ast_t *keys = mtt_parse(arena, __FILE__, S8_CODE(
         //                                    javascript filter out
         { name       js1         js2       jf  windows1    windows2 }

src/app/app_wasm.c

@@ -9,6 +9,7 @@ gb f32         wasm_time;
 gb f32         wasm_last_time;
 gb app_frame_t wasm_frame;
 gb u64         wasm_frame_counter;
+gb u64         wasm_event_ids;
 
 typedef struct wasm_cached_t wasm_cached_t;
 struct wasm_cached_t {
@@ -23,6 +24,7 @@ fn void app_init(f32 dpr);
 fn void wasm_add_event(app_event_t event) {
     app_event_t *ev = ma_push_type(tcx.temp, app_event_t);
     *ev = event;
+    ev->id = ++wasm_event_ids;
     ev->alt = wasm_cached.alt;
     ev->ctrl = wasm_cached.ctrl;
     ev->shift = wasm_cached.shift;
@@ -75,7 +77,7 @@ fn_wasm_export void wasm_mouse_wheel(f32 x, f32 y, f32 delta_x, f32 delta_y, f32
     wasm_set_cached_buttons(ctrl, shift, alt);
     wasm_add_event((app_event_t){
         .kind = app_event_kind_mouse_wheel,
-        .mouse_wheel_delta = {delta_x, delta_y, delta_z},
+        .mouse_wheel_delta = {delta_x, -delta_y, delta_z},
     });
 }
 
@@ -140,15 +142,7 @@ fn_wasm_export b32 wasm_update(f64 time, f32 width, f32 height, f32 dpr) {
     return animating;
 }
 
-fn_wasm_export void wasm_init(void) {
+fn_wasm_export void wasm_init(f32 dpr) {
     core_init();
-    app_init(1.0); //@todo: dpr
-}
-
-fn f32 app_get_anim_time(void) {
-    return wasm_time / 1000.0;
-}
-
-fn f32 app_get_anim_delta_time(void) {
-    return wasm_delta_time / 1000.0;
+    app_init(dpr);
 }

src/app/app_wasm.html

@@ -189,7 +189,7 @@ const ctx2d = canvas.getContext('2d');
     const instance = program['instance'];
     const wasm_exports = instance['exports'];
     mem.exports = wasm_exports;
-    wasm_exports['wasm_init']();
+    wasm_exports['wasm_init'](window.devicePixelRatio);
 
     let awake = true;
 

src/core/core_intrin.c

@@ -10,8 +10,17 @@ fn void memory_set(void *dst, i32 c, usize size) {
     IF_PLATFORM_CLANG_ELSE(__builtin_memset(dst, c, size), memset(dst, c, size));
 }
 
+fn int bad_memory__compare(void *left, void *right, usize size) {
+    u8 *l = left;
+    u8 *r = right;
+    for (usize i = 0; i < size; i += 1) {
+        if (l[i] != r[i]) return 1;
+    }
+    return 0;
+}
+
 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));
+    int cmp = IF_PLATFORM_CLANG_ELSE(bad_memory__compare(left, right, size), memcmp(left, right, size));
     return cmp == 0;
 }
 

src/render/render.c

@@ -0,0 +1,126 @@
+fn rn_cmd_t *rn_get_cmd(rn_cmd_kind_t kind) {
+    b32 alloc_new = false;
+    if (rn_state.last_cmd == NULL) {
+        alloc_new = true;
+    } else if (rn_state.last_cmd->kind != kind) {
+        alloc_new = true;
+    }
+
+    rn_cmd_t *result = rn_state.last_cmd;
+    if (alloc_new) {
+        result = ma_push_type(tcx.temp, rn_cmd_t);
+        result->kind = kind;
+        SLLQ_APPEND(rn_state.first_cmd, rn_state.last_cmd, result);
+
+        if (rn_cmd_kind_quad) {
+            result->vertex = rn_state.vertices + rn_state.len;
+        }
+    }
+
+    return result;
+}
+
+fn rn_vertex_t *rn_push_vertex(rn_cmd_t *cmd, u32 count) {
+    rn_vertex_t *result = cmd->vertex + cmd->len;
+    rn_state.len += count;
+    cmd->len += count;
+    return result;
+}
+
+fn void rn_push_quad(r2f32_t rect, r2f32_t tex, v4f32_t color) {
+    rn_cmd_t *cmd = rn_get_cmd(rn_cmd_kind_quad);
+    rn_vertex_t *v = rn_push_vertex(cmd, 6);
+    v[0] = (rn_vertex_t){
+        {rect.min.x, rect.max.y},
+        { tex.min.x,  tex.max.y},
+        color
+    };
+    v[1] = (rn_vertex_t){
+        {rect.max.x, rect.max.y},
+        { tex.max.x,  tex.max.y},
+        color
+    };
+    v[2] = (rn_vertex_t){
+        {rect.min.x, rect.min.y},
+        { tex.min.x,  tex.min.y},
+        color
+    };
+    v[3] = (rn_vertex_t){
+        {rect.min.x, rect.min.y},
+        { tex.min.x,  tex.min.y},
+        color
+    };
+    v[4] = (rn_vertex_t){
+        {rect.max.x, rect.max.y},
+        { tex.max.x,  tex.max.y},
+        color
+    };
+    v[5] = (rn_vertex_t){
+        {rect.max.x, rect.min.y},
+        { tex.max.x,  tex.min.y},
+        color
+    };
+}
+
+fn void rn_draw_rect(r2f32_t rect, v4f32_t color) {
+    rn_push_quad(rect, rn_state.main_font->white_texture_bounding_box, color);
+}
+
+fn void rn_draw_rect_border(r2f32_t rect, v4f32_t color, f32 border_thickness) {
+    r2f32_t left = r2f32_cut_left(&rect, border_thickness);
+    r2f32_t right = r2f32_cut_right(&rect, border_thickness);
+    r2f32_t top = r2f32_cut_top(&rect, border_thickness);
+    r2f32_t bottom = r2f32_cut_bottom(&rect, border_thickness);
+    rn_push_quad(left, rn_state.main_font->white_texture_bounding_box, color);
+    rn_push_quad(right, rn_state.main_font->white_texture_bounding_box, color);
+    rn_push_quad(top, rn_state.main_font->white_texture_bounding_box, color);
+    rn_push_quad(bottom, rn_state.main_font->white_texture_bounding_box, color);
+}
+
+fn i64 rn_get_char_spacing(rn_font_t *font, u32 codepoint) {
+    rn_glyph_t *g = rn_get_glyph(font, codepoint);
+    if (g->xadvance) return (i64)g->xadvance;
+    return (i64)g->size.x;
+}
+
+fn i64 rn_get_line_spacing(rn_font_t *font) {
+    i64 result = (i64)(font->ascent - font->descent + font->line_gap);
+    return result;
+}
+
+fn v2f32_t rn_base_draw_string(rn_font_t *font, s8_t string, v2f32_t pos, v4f32_t color, b32 draw) {
+    pos.y += rn_get_line_spacing(font) + font->descent;
+    v2f32_t original_pos = pos;
+
+    for (utf8_iter_t iter = utf8_iterate_ex(string.str, (int)string.len); iter.item; utf8_advance(&iter)) {
+        u32 codepoint = iter.item;
+        rn_glyph_t *g    = rn_get_glyph(font, codepoint);
+        r2f32_t rect = r2f32_mindim(v2f32_add(pos, g->offset), g->size);
+        if (draw && codepoint != '\n' && codepoint != ' ' && codepoint != '\t') {
+            rn_push_quad(rect, g->atlas_bounding_box, color);
+        }
+        pos.x += g->xadvance;
+    }
+
+
+    v2f32_t result = {pos.x - original_pos.x, font->size};
+    return result;
+}
+
+fn v2f32_t rn_draw_string(rn_font_t *font, v2f32_t pos, v4f32_t color, s8_t string) {
+    return rn_base_draw_string(font, string, pos, color, true);
+}
+
+fn v2f32_t rn_draw_stringf(rn_font_t *font, v2f32_t pos, v4f32_t color, char *str, ...) {
+    S8_FMT(tcx.temp, str, result);
+    return rn_draw_string(font, pos, color, result);
+}
+
+fn v2f32_t rn_measure_string(rn_font_t *font, s8_t string) {
+    return rn_base_draw_string(font, string, v2f32(0,0), v4f32(0,0,0,0), false);
+}
+
+fn void rn_set_clip(r2f32_t rect) {
+    rn_cmd_t *cmd = rn_get_cmd(rn_cmd_kind_set_clip);
+    cmd->rect = rect;
+}

src/render/render.h

@@ -0,0 +1,85 @@
+typedef struct rn_glyph_t rn_glyph_t;
+struct rn_glyph_t {
+    v2f32_t size;
+    v2f32_t offset;
+    f32     xadvance;
+    f32     left_side_bearing;
+    r2f32_t atlas_bounding_box;
+};
+
+typedef struct rn_font_t rn_font_t;
+struct rn_font_t {
+    rn_glyph_t *glyphs;
+    i32         glyph_count;
+
+    u32 first_char, last_char;
+    u32 texture_id;
+
+    f32 size;
+    f32 descent;
+    f32 ascent;
+    f32 line_gap;
+
+    r2f32_t white_texture_bounding_box;
+};
+
+typedef struct rn_atlas_t rn_atlas_t;
+struct rn_atlas_t {
+    u8 *bitmap;
+    v2i32_t  size;
+    v2f32_t  inverse_size;
+    i32      xcursor;
+    i32      ycursor;
+
+    i32 biggest_height;
+    r2f32_t white_texture_bounding_box;
+    u32     texture_id;
+};
+
+typedef struct rn_shader_t rn_shader_t;
+struct rn_shader_t {
+    u32 pipeline;
+    u32 fshader;
+    u32 vshader;
+};
+
+typedef struct rn_vertex_t rn_vertex_t;
+struct rn_vertex_t {
+    v2f32_t pos;
+    v2f32_t tex;
+    v4f32_t color;
+};
+
+typedef enum {
+    rn_cmd_kind_null,
+    rn_cmd_kind_quad,
+    rn_cmd_kind_set_clip,
+} rn_cmd_kind_t;
+
+typedef struct rn_cmd_t rn_cmd_t;
+struct rn_cmd_t {
+    rn_cmd_t *next;
+    rn_cmd_kind_t kind;
+    union {
+        v4f32_t color;
+        r2f32_t rect;
+        struct { rn_vertex_t *vertex; u32 len; };
+    };
+};
+
+typedef struct rn_state_t rn_state_t;
+struct rn_state_t {
+    rn_font_t *main_font;
+    rn_shader_t shader2d;
+    app_frame_t *frame;
+
+    rn_cmd_t *first_cmd;
+    rn_cmd_t *last_cmd;
+    rn_vertex_t *vertices;
+    u32 len;
+    u32 cap;
+
+    u32 vao;
+    u32 vbo;
+};
+gb rn_state_t rn_state;

src/render/render.meta.c

@@ -0,0 +1,10 @@
+void mt_render(ma_arena_t *arena) {
+    sb8_t *sb = sb8_serial_begin(arena);
+    sb8_printf(sb, "// automatically generated using: " __FILE__ "\n");
+
+    sb8_printf(sb, "gb_read_only ");
+    s8_t content = OS_ReadFile(&Perm, s8_lit("../package/FiraCode-Regular.ttf"));
+    mt_serial_to_cbyte_array_ex(sb, content, s8_printf(arena, "main_font_data"));
+    sb8_printf(sb, "gb_read_only s8_t main_font = s8_array_lit(main_font_data);\n");
+    os_write_file(mt_cpath(arena), sb8_serial_end(arena, sb));
+}

src/render/render_font.c

@@ -1,41 +1,3 @@
-typedef struct rn_glyph_t rn_glyph_t;
-struct rn_glyph_t {
-    v2f32_t size;
-    v2f32_t offset;
-    f32     xadvance;
-    f32     left_side_bearing;
-    r2f32_t atlas_bounding_box;
-};
-
-typedef struct rn_font_t rn_font_t;
-struct rn_font_t {
-    rn_glyph_t *glyphs;
-    i32         glyph_count;
-
-    u32 first_char, last_char;
-    u32 texture_id;
-
-    f32 size;
-    f32 descent;
-    f32 ascent;
-    f32 line_gap;
-
-    r2f32_t white_texture_bounding_box;
-};
-
-typedef struct rn_atlas_t rn_atlas_t;
-struct rn_atlas_t {
-    u8 *bitmap;
-    v2i32_t  size;
-    v2f32_t  inverse_size;
-    i32      xcursor;
-    i32      ycursor;
-
-    i32 biggest_height;
-    r2f32_t white_texture_bounding_box;
-    u32     texture_id;
-};
-
 rn_atlas_t *rn_create_atlas(ma_arena_t *arena, v2i32_t size) {
     rn_atlas_t *result     = ma_push_type(arena, rn_atlas_t);
     result->size           = size;

src/render/render_inc.c

@@ -1,3 +1,6 @@
+
+#if PLATFORM_WINDOWS
+#include "render.h"
 #define STB_TRUETYPE_IMPLEMENTATION
 #define STBTT_ifloor(x) ((int)f64_floor(x))
 #define STBTT_iceil(x) ((int)f64_ceil(x))
@@ -13,6 +16,11 @@
 #define STBTT_strlen(x) (str_len(x))
 #define STBTT_memcpy memory_copy
 #define STBTT_memset memory_set
-#include "render/stb_truetype.h"
-#include "render/render_font.c"
-#include "render/render_opengl.c"
+#include "stb_truetype.h"
+#include "render_font.c"
+#include "render.c"
+#include "render.gen.c"
+#include "render_opengl.c"
+#else
+#include "render_wasm_canvas.c"
+#endif

src/render/render_opengl.c

@@ -1,50 +1,3 @@
-typedef struct rn_shader_t rn_shader_t;
-struct rn_shader_t {
-    u32 pipeline;
-    u32 fshader;
-    u32 vshader;
-};
-
-typedef struct rn_vertex_t rn_vertex_t;
-struct rn_vertex_t {
-    v2f32_t pos;
-    v2f32_t tex;
-    v4f32_t color;
-};
-
-typedef enum {
-    rn_cmd_kind_null,
-    rn_cmd_kind_quad,
-    rn_cmd_kind_set_clip,
-} rn_cmd_kind_t;
-
-typedef struct rn_cmd_t rn_cmd_t;
-struct rn_cmd_t {
-    rn_cmd_t *next;
-    rn_cmd_kind_t kind;
-    union {
-        v4f32_t color;
-        r2f32_t rect;
-        struct { rn_vertex_t *vertex; u32 len; };
-    };
-};
-
-typedef struct rn_state_t rn_state_t;
-struct rn_state_t {
-    rn_font_t *main_font;
-    rn_shader_t shader2d;
-
-    rn_cmd_t *first_cmd;
-    rn_cmd_t *last_cmd;
-    rn_vertex_t *vertices;
-    u32 len;
-    u32 cap;
-
-    u32 vao;
-    u32 vbo;
-};
-gb rn_state_t rn_state;
-
 fn rn_shader_t rn_create_shader(char *glsl_vshader, char *glsl_fshader) {
     rn_shader_t result  = {};
     result.vshader = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &glsl_vshader);
@@ -79,133 +32,6 @@ fn void gl_debug_callback(GLenum source, GLenum type, GLuint id, GLenum severity
     }
 }
 
-fn rn_cmd_t *rn_get_cmd(rn_cmd_kind_t kind) {
-    b32 alloc_new = false;
-    if (rn_state.last_cmd == NULL) {
-        alloc_new = true;
-    } else if (rn_state.last_cmd->kind != kind) {
-        alloc_new = true;
-    }
-
-    rn_cmd_t *result = rn_state.last_cmd;
-    if (alloc_new) {
-        result = ma_push_type(tcx.temp, rn_cmd_t);
-        result->kind = kind;
-        SLLQ_APPEND(rn_state.first_cmd, rn_state.last_cmd, result);
-
-        if (rn_cmd_kind_quad) {
-            result->vertex = rn_state.vertices + rn_state.len;
-        }
-    }
-
-    return result;
-}
-
-fn rn_vertex_t *rn_push_vertex(rn_cmd_t *cmd, u32 count) {
-    rn_vertex_t *result = cmd->vertex + cmd->len;
-    rn_state.len += count;
-    cmd->len += count;
-    return result;
-}
-
-fn void rn_push_quad(r2f32_t rect, r2f32_t tex, v4f32_t color) {
-    rn_cmd_t *cmd = rn_get_cmd(rn_cmd_kind_quad);
-    rn_vertex_t *v = rn_push_vertex(cmd, 6);
-    v[0] = (rn_vertex_t){
-        {rect.min.x, rect.max.y},
-        { tex.min.x,  tex.max.y},
-        color
-    };
-    v[1] = (rn_vertex_t){
-        {rect.max.x, rect.max.y},
-        { tex.max.x,  tex.max.y},
-        color
-    };
-    v[2] = (rn_vertex_t){
-        {rect.min.x, rect.min.y},
-        { tex.min.x,  tex.min.y},
-        color
-    };
-    v[3] = (rn_vertex_t){
-        {rect.min.x, rect.min.y},
-        { tex.min.x,  tex.min.y},
-        color
-    };
-    v[4] = (rn_vertex_t){
-        {rect.max.x, rect.max.y},
-        { tex.max.x,  tex.max.y},
-        color
-    };
-    v[5] = (rn_vertex_t){
-        {rect.max.x, rect.min.y},
-        { tex.max.x,  tex.min.y},
-        color
-    };
-}
-
-fn void rn_draw_rect(r2f32_t rect, v4f32_t color) {
-    rn_push_quad(rect, rn_state.main_font->white_texture_bounding_box, color);
-}
-
-fn void rn_draw_rect_border(r2f32_t rect, v4f32_t color, f32 border_thickness) {
-    r2f32_t left = r2f32_cut_left(&rect, border_thickness);
-    r2f32_t right = r2f32_cut_right(&rect, border_thickness);
-    r2f32_t top = r2f32_cut_top(&rect, border_thickness);
-    r2f32_t bottom = r2f32_cut_bottom(&rect, border_thickness);
-    rn_push_quad(left, rn_state.main_font->white_texture_bounding_box, color);
-    rn_push_quad(right, rn_state.main_font->white_texture_bounding_box, color);
-    rn_push_quad(top, rn_state.main_font->white_texture_bounding_box, color);
-    rn_push_quad(bottom, rn_state.main_font->white_texture_bounding_box, color);
-}
-
-fn i64 rn_get_char_spacing(rn_font_t *font, u32 codepoint) {
-    rn_glyph_t *g = rn_get_glyph(font, codepoint);
-    if (g->xadvance) return (i64)g->xadvance;
-    return (i64)g->size.x;
-}
-
-fn i64 rn_get_line_spacing(rn_font_t *font) {
-    i64 result = (i64)(font->ascent - font->descent + font->line_gap);
-    return result;
-}
-
-fn v2f32_t rn_base_draw_string(rn_font_t *font, s8_t string, v2f32_t pos, v4f32_t color, b32 draw) {
-    pos.y += rn_get_line_spacing(font) + font->descent;
-    v2f32_t original_pos = pos;
-
-    for (utf8_iter_t iter = utf8_iterate_ex(string.str, (int)string.len); iter.item; utf8_advance(&iter)) {
-        u32 codepoint = iter.item;
-        rn_glyph_t *g    = rn_get_glyph(font, codepoint);
-        r2f32_t rect = r2f32_mindim(v2f32_add(pos, g->offset), g->size);
-        if (draw && codepoint != '\n' && codepoint != ' ' && codepoint != '\t') {
-            rn_push_quad(rect, g->atlas_bounding_box, color);
-        }
-        pos.x += g->xadvance;
-    }
-
-
-    v2f32_t result = {pos.x - original_pos.x, font->size};
-    return result;
-}
-
-fn v2f32_t rn_draw_string(rn_font_t *font, v2f32_t pos, v4f32_t color, s8_t string) {
-    return rn_base_draw_string(font, string, pos, color, true);
-}
-
-fn v2f32_t rn_draw_stringf(rn_font_t *font, v2f32_t pos, v4f32_t color, char *str, ...) {
-    S8_FMT(tcx.temp, str, result);
-    return rn_draw_string(font, pos, color, result);
-}
-
-fn v2f32_t rn_measure_string(rn_font_t *font, s8_t string) {
-    return rn_base_draw_string(font, string, v2f32(0,0), v4f32(0,0,0,0), false);
-}
-
-fn void rn_set_clip(r2f32_t rect) {
-    rn_cmd_t *cmd = rn_get_cmd(rn_cmd_kind_set_clip);
-    cmd->rect = rect;
-}
-
 fn void rn_reload_font(s8_t font_data, f32 font_size) {
     if (rn_state.main_font->texture_id) {
         glDeleteTextures(1, &rn_state.main_font->texture_id);
@@ -227,13 +53,12 @@ fn void rn_reload_font(s8_t font_data, f32 font_size) {
     ma_end_scratch(scratch);
 }
 
-fn void rn_init(ma_arena_t *perm, s8_t font_data, f32 font_size) {
+fn void rn_init(ma_arena_t *perm, f32 font_size) {
     rn_state.cap = 1024*256;
     rn_state.vertices = ma_push_array(perm, rn_vertex_t, rn_state.cap);
 
     rn_state.main_font = rn_create_font(perm);
-    rn_reload_font(font_data, font_size);
-
+    rn_reload_font(main_font, font_size);
 
     glDebugMessageCallback(&gl_debug_callback, NULL);
     glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
@@ -301,12 +126,13 @@ fn void rn_init(ma_arena_t *perm, s8_t font_data, f32 font_size) {
     rn_state.shader2d = rn_create_shader(glsl_vshader, glsl_fshader);
 }
 
-void rn_begin(void) {
+void rn_begin(app_frame_t *frame) {
+    rn_state.frame = frame;
 }
 
-void rn_end(v2f32_t window_size, v4f32_t color) {
-    f32 wx = window_size.x;
-    f32 wy = window_size.y;
+void rn_end(void) {
+    f32 wx = rn_state.frame->window_size.x;
+    f32 wy = rn_state.frame->window_size.y;
     glEnable(GL_BLEND);
     glEnable(GL_SCISSOR_TEST);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
@@ -315,7 +141,7 @@ void rn_end(v2f32_t window_size, v4f32_t color) {
 
     glViewport(0, 0, (GLsizei)wx, (GLsizei)wy);
     glScissor(0, 0, (GLsizei)wx, (GLsizei)wy);
-    glClearColor(color.r, color.g, color.b, color.a);
+    glClearColor(1,1,1,1);
     glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 
     // Default draw using the font texture
@@ -338,7 +164,7 @@ void rn_end(v2f32_t window_size, v4f32_t color) {
             GLsizei h    = (GLsizei)(it->rect.max.y - y);
             if (w <= 0) w = 0;
             if (h <= 0) h = 0;
-            glScissor(x, (GLint)window_size.y - (GLint)it->rect.max.y, w, h);
+            glScissor(x, (GLint)wy - (GLint)it->rect.max.y, w, h);
         } else_is_invalid;
     }
 

src/render/render_wasm_canvas.c

@@ -0,0 +1,66 @@
+fn_wasm_import void wasm_clear(void);
+fn_wasm_import void wasm_draw_text(isize str, i32 len, f32 x, f32 y, isize font_str, i32 font_len, i32 font_size, f32 r, f32 g, f32 b, f32 a);
+fn_wasm_import void wasm_draw_rect(f32 x, f32 y, f32 w, f32 h, f32 r, f32 g, f32 b, f32 a);
+fn_wasm_import f32  wasm_measure_text(isize str, i32 len, isize font_str, i32 font_len, i32 font_size);
+fn_wasm_import f32  wasm_get_font_height(isize font_str, i32 font_len, i32 font_size);
+fn_wasm_import void wasm_set_clip(f32 x, f32 y, f32 w, f32 h);
+
+gb_read_only s8_t font_face = s8_const_lit("consolas");
+
+typedef struct rn_font_t rn_font_t;
+struct rn_font_t {
+    f32 size;
+};
+
+typedef struct rn_state_t rn_state_t;
+struct rn_state_t {
+    rn_font_t *main_font;
+    app_frame_t *frame;
+};
+rn_state_t rn_state;
+
+// fn f64 get_font_height(void) {
+//     return wasm_get_font_height((isize) font_face.str, font_face.len, m*wasm_dpr) / wasm_dpr;
+// }
+
+fn void rn_init(ma_arena_t *perm, f32 font_size) {
+    rn_state.main_font = ma_push_type(perm, rn_font_t);
+    rn_state.main_font->size = font_size;
+}
+
+fn void rn_draw_rect(r2f32_t rect, v4f32_t color) {
+    wasm_draw_rect(wasm_dpr * rect.min.x, wasm_dpr * rect.min.y, wasm_dpr * (rect.max.x - rect.min.x), wasm_dpr * (rect.max.y - rect.min.y), color.r * 255.f, color.g * 255.f, color.b * 255.f, color.a);
+}
+
+fn void rn_draw_rect_border(r2f32_t rect, v4f32_t color, f32 border_thickness) {
+}
+
+fn v2f32_t rn_measure_string(rn_font_t *font, s8_t string) {
+    f32 x = wasm_measure_text((isize)string.str, string.len, (isize) font_face.str, font_face.len, rn_state.main_font->size) / wasm_dpr;
+    return (v2f32_t){x, rn_state.main_font->size};
+}
+
+fn v2f32_t rn_draw_string(rn_font_t *font, v2f32_t pos, v4f32_t color, s8_t string) {
+    wasm_draw_text((isize)string.str, string.len, wasm_dpr * pos.x, wasm_dpr * pos.y, (isize) font_face.str, font_face.len, rn_state.main_font->size, color.r * 255.f, color.g * 255.f, color.b * 255.f, color.a);
+    v2f32_t size = rn_measure_string(font, string);
+    return size;
+}
+
+fn v2f32_t rn_draw_stringf(rn_font_t *font, v2f32_t pos, v4f32_t color, char *str, ...) {
+    S8_FMT(tcx.temp, str, string);
+    return rn_draw_string(font, pos, color, string);
+}
+
+fn void rn_set_clip(r2f32_t rect) {
+    wasm_set_clip(wasm_dpr * rect.min.x, wasm_dpr * rect.min.y, wasm_dpr * (rect.max.x - rect.min.x), wasm_dpr * (rect.max.y - rect.min.y));
+}
+
+fn void rn_begin(app_frame_t *frame) {
+    rn_state.frame = frame;
+    r2f32_t window_rect = r2f32(0, 0, rn_state.frame->window_size.x, rn_state.frame->window_size.y);
+    wasm_clear();
+    rn_draw_rect(window_rect, white_color_global);
+}
+
+fn void rn_end() {
+}

src/ui/ui.c

@@ -165,7 +165,7 @@ fn ui_signal_t ui_signal_from_box(ui_box_t *box) {
     ui_signal_t result = {box};
     app_event_t *ev = ui->event;
 
-    b32 move = ev->kind == app_event_kind_mouse_move;
+    // b32 move = ev->kind == app_event_kind_mouse_move;
     b32 inside = r2f32_contains(box->final_rect, ev->mouse_pos);
 
     if (ui_is_active_box(box)) {
@@ -624,7 +624,7 @@ fn void ui_demo_update(app_frame_t *frame) {
                 f32 scrollable_space = (1 - scroller_size);
                 f32 scroller_norm = scroller_value / (all_items_size);
                 f32 scroller_percent = scroller_norm * scrollable_space;
-                f32 scroller_second = scrollable_space - scroller_percent;
+                // f32 scroller_second = scrollable_space - scroller_percent;
 
                 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_idf("slider"));
@@ -648,10 +648,10 @@ fn void ui_demo_update(app_frame_t *frame) {
         ui_end_build();
     }
 
-    rn_begin();
+    rn_begin(frame);
     ui_draw();
     rn_draw_stringf(rn_state.main_font, v2f32(0, frame->window_size.y - rn_state.main_font->size), black_color_global, "boxes: %d", ui->allocated_boxes);
-    rn_end(frame->window_size, white_color_global);
+    rn_end();
 
     ui_end_frame();
 }

src/ui/ui.gen.c

@@ -1,3 +1,4 @@
+// automatically generated using: C:\dev\wasm\src/ui/ui.meta.c
 fn void ui_push_id(ui_id_t v) { ui_id_node_t *n = ma_push_type(tcx.temp, ui_id_node_t); n->value = v; SLLS_PUSH(ui->id_stack, n); }
 fn void ui_pop_id(void) { SLLS_POP(ui->id_stack); }
 #define ui_set_id(x) defer_block(ui_push_id(x), ui_pop_id())

src/ui/ui.gen.h

@@ -1,3 +1,4 @@
+// automatically generated using: C:\dev\wasm\src/ui/ui.meta.c
 
 typedef struct ui_id_node_t ui_id_node_t; struct ui_id_node_t { ui_id_t value; ui_id_node_t *next; };
 typedef struct ui_lop_node_t ui_lop_node_t; struct ui_lop_node_t { ui_lop_t value; ui_lop_node_t *next; };

src/ui/ui.meta.c

@@ -34,6 +34,9 @@ void mt_ui(ma_arena_t *arena) {
     sb8_t *h = sb8_serial_begin(arena);
     sb8_t *c = sb8_serial_begin(arena);
 
+    sb8_printf(h, "// automatically generated using: " __FILE__ "\n");
+    sb8_printf(c, "// automatically generated using: " __FILE__ "\n");
+
     ///////////////////////////////
     // generate types
     for (ast_t *it = table->first; it; it = it->next) {

src/wasm_app/main.c

@@ -4,29 +4,33 @@
 
 #include "core/core_inc.c"
 #include "app/app.c"
-// #include "render/render_inc.c"
+#include "render/render_inc.c"
 
 #include "wasm_app.gen.c"
-// #include "ui/ui_iter.c"
-// #include "ui/ui.gen.c"
-// #include "ui/ui.c"
+#include "ui/ui_iter.c"
+#include "ui/ui.gen.c"
+#include "ui/ui.c"
 
 fn void app_init(f32 dpr) {
     ma_arena_t *perm = &tcx._perm;
     unused(perm);
-    mt_embed_file(font_data, "package/liberation-mono.ttf");
+    // mt_embed_file(font_data, "package/FiraCode-Regular.ttf");
     mt_tweak_f32(font_size, 50, 4, 200);
-    mt_tweak_f32(_font_size, 50, 50, 50);
+    // mt_tweak_f32(_font_size, 50, 50, 50);
 
-    // rn_init(perm, font_data, font_size * dpr);
-    // ui_demo_init(perm);
+    rn_init(perm, font_size * dpr);
+    ui_demo_init(perm);
 }
 
 fn b32 app_update(app_frame_t *frame) {
-    if (!f32_are_equal(font_size, _font_size)) {
-        _font_size = font_size;
+    // if (!f32_are_equal(font_size, _font_size)) {
+    //     _font_size = font_size;
         // rn_reload_font(font_data, font_size);
-    }
-    // ui_demo_update(frame);
+    // }
+    // @todo
+    ui_demo_update(frame);
+    v2f32_t size = rn_measure_string(rn_state.main_font, s8_lit("Memes and other things"));
+    debugf("font size = %f %f", size.x, size.y);
+
     return true;
 }

src/wasm_app/wasm_app.meta.c

@@ -16,6 +16,7 @@ void mt_wasm_app(ma_arena_t *arena) {
     cg_tweak_t *last_tweak  = NULL;
 
     sb8_t *sb_embeds = sb8_serial_begin(arena);
+    sb8_printf(sb_embeds, "// automatically generated using: " __FILE__ "\n");
     for (mt_file_t *it = files.first; it; it = it->next) {
         parser_t *par = parser_make(arena, it->tokens.data);
         for (;par->at->kind != lex_kind_eof;) {
@@ -87,6 +88,7 @@ void mt_wasm_app(ma_arena_t *arena) {
         }
     }
 
+    if (first_tweak != NULL) {
         for (cg_tweak_t *it = first_tweak; it; it = it->next) {
             sb8_printf(sb_embeds, "gb %S %S = %S;\n", it->type->name, it->name, it->value);
         }
@@ -95,6 +97,7 @@ void mt_wasm_app(ma_arena_t *arena) {
             sb8_printf(sb_embeds, "{type(%S), s8_const_lit(\"%S\"), &%S, %S, %S},\n", it->type->name, it->name, it->name, it->min, it->max);
         }
         sb8_printf(sb_embeds, "\n};\n");
+    }
 
 
     s8_t embeds = sb8_serial_end(arena, sb_embeds);

todo.txt

@@ -17,6 +17,7 @@
 [ ] render
     [ ] fix opengl warnings on win32
     [ ] wasm (maybe try first without opengl and then opengl) <<<<<<<<<<<
+        [ ] maybe copy package stuff to build?
 
 [ ] ui
     [ ] text input