diff --git a/data/batcher.glsl b/data/batcher.glsl
new file mode 100644
index 0000000..e5e69bd
--- /dev/null
+++ b/data/batcher.glsl
@@ -0,0 +1,67 @@
+@ctype vec2 vec2
+@ctype vec4 vec4
+
+@vs vs
+layout(binding=0) uniform render_data {
+    vec2 one_over_window_size;
+    float zoom;
+};
+
+in vec4 quad;
+in vec4 tex_quad;
+in vec4 colour;
+
+out vec2 uv;
+out vec4 fs_colour;
+
+const int indices[6] = {
+    0, 1, 2, 2, 3, 0,
+};
+
+const vec3 positions[4] = {
+    vec3(0, 0, 0),
+    vec3(0, 1, 0),
+    vec3(1, 1, 0),
+    vec3(1, 0, 0),
+};
+
+const vec2 uvs[4] = {
+    vec2(0.0f, 0.0f), 
+    vec2(0.0f, 1.0f),
+    vec2(1.0f, 1.0f), 
+    vec2(1.0f, 0.0f), 
+};
+
+void main() {
+    int vtx = indices[gl_VertexIndex];
+    vec3 pos = positions[vtx];
+    uv = uvs[vtx];
+
+    pos.xy = ((pos.xy * quad.zw) + quad.xy) * zoom;
+    pos.xy = (pos.xy * one_over_window_size) * 2.0 - 1.0;
+    pos.y = -pos.y;
+
+    uv *= tex_quad.zw;
+    uv += tex_quad.xy;
+
+    gl_Position = vec4(pos, 1);
+    fs_colour = colour;
+}
+@end
+
+@fs fs
+layout(binding=0) uniform texture2D tex;
+layout(binding=0) uniform sampler smp;
+in vec2 uv;
+in vec4 fs_colour;
+
+out vec4 frag_colour;
+
+void main() {
+    vec4 c = texture(sampler2D(tex, smp), uv) * fs_colour;
+    if (c.a < 1) discard;
+    frag_colour = c;
+}
+@end
+
+@program batcher vs fs
diff --git a/data/berkeley-mono.otf b/data/berkeley-mono.otf
deleted file mode 100644
index 8d4d622..0000000
Binary files a/data/berkeley-mono.otf and /dev/null differ
diff --git a/data/font.png b/data/font.png
new file mode 100644
index 0000000..34aa4fa
Binary files /dev/null and b/data/font.png differ
diff --git a/data/metro.glb b/data/metro.glb
deleted file mode 100644
index fb23de7..0000000
Binary files a/data/metro.glb and /dev/null differ
diff --git a/data/obj.glsl b/data/obj.glsl
index ae15087..70afbc9 100644
--- a/data/obj.glsl
+++ b/data/obj.glsl
@@ -1,5 +1,5 @@
-@ctype mat4 HMM_Mat4
-@ctype vec3 HMM_Vec3
+@ctype mat4 mat4
+@ctype vec3 vec3
 
 @vs vs
 layout(binding=0) uniform vs_params {
diff --git a/data/testino.glb b/data/testino.glb
deleted file mode 100644
index 45e5b84..0000000
Binary files a/data/testino.glb and /dev/null differ
diff --git a/data/textures/Chair.png b/data/textures/Chair.png
deleted file mode 100644
index 6b63500..0000000
Binary files a/data/textures/Chair.png and /dev/null differ
diff --git a/data/textures/ConcreteBare.png b/data/textures/ConcreteBare.png
deleted file mode 100644
index da3d182..0000000
Binary files a/data/textures/ConcreteBare.png and /dev/null differ
diff --git a/data/textures/Door.png b/data/textures/Door.png
deleted file mode 100644
index 0b8419e..0000000
Binary files a/data/textures/Door.png and /dev/null differ
diff --git a/data/textures/Door_01.jpg b/data/textures/Door_01.jpg
deleted file mode 100644
index eca7bab..0000000
Binary files a/data/textures/Door_01.jpg and /dev/null differ
diff --git a/data/textures/Floor.png b/data/textures/Floor.png
deleted file mode 100644
index 32e6b1b..0000000
Binary files a/data/textures/Floor.png and /dev/null differ
diff --git a/data/textures/TactilePaving.png b/data/textures/TactilePaving.png
deleted file mode 100644
index d0f3cdb..0000000
Binary files a/data/textures/TactilePaving.png and /dev/null differ
diff --git a/data/textures/Tiles.png b/data/textures/Tiles.png
deleted file mode 100644
index 2b9e9cb..0000000
Binary files a/data/textures/Tiles.png and /dev/null differ
diff --git a/data/textures/Trains.png b/data/textures/Trains.png
deleted file mode 100644
index a01061a..0000000
Binary files a/data/textures/Trains.png and /dev/null differ
diff --git a/data/textures/Trains_01.jpg b/data/textures/Trains_01.jpg
deleted file mode 100644
index 5c4b851..0000000
Binary files a/data/textures/Trains_01.jpg and /dev/null differ
diff --git a/data/textures/Vending_machine.png b/data/textures/Vending_machine.png
deleted file mode 100644
index 37ffb19..0000000
Binary files a/data/textures/Vending_machine.png and /dev/null differ
diff --git a/data/textures/metal.jpg b/data/textures/metal.jpg
deleted file mode 100644
index 9b4cc56..0000000
Binary files a/data/textures/metal.jpg and /dev/null differ
diff --git a/data/textures/metal_01.jpg b/data/textures/metal_01.jpg
deleted file mode 100644
index e9616c6..0000000
Binary files a/data/textures/metal_01.jpg and /dev/null differ
diff --git a/data/textures/metal_02.png b/data/textures/metal_02.png
deleted file mode 100644
index 35ead45..0000000
Binary files a/data/textures/metal_02.png and /dev/null differ
diff --git a/data/textures/metal_03.jpg b/data/textures/metal_03.jpg
deleted file mode 100644
index c51de10..0000000
Binary files a/data/textures/metal_03.jpg and /dev/null differ
diff --git a/data/textures/metal_04.png b/data/textures/metal_04.png
deleted file mode 100644
index 37e61e0..0000000
Binary files a/data/textures/metal_04.png and /dev/null differ
diff --git a/data/textures/metal_05.jpg b/data/textures/metal_05.jpg
deleted file mode 100644
index c86ac64..0000000
Binary files a/data/textures/metal_05.jpg and /dev/null differ
diff --git a/data/textures/road_rails.jpg b/data/textures/road_rails.jpg
deleted file mode 100644
index a410f1b..0000000
Binary files a/data/textures/road_rails.jpg and /dev/null differ
diff --git a/data/textures/seats.png b/data/textures/seats.png
deleted file mode 100644
index 2f14231..0000000
Binary files a/data/textures/seats.png and /dev/null differ
diff --git a/data/textures/tile_tile.jpg b/data/textures/tile_tile.jpg
deleted file mode 100644
index 1509153..0000000
Binary files a/data/textures/tile_tile.jpg and /dev/null differ
diff --git a/data/textures/trash_can.png b/data/textures/trash_can.png
deleted file mode 100644
index b3621f2..0000000
Binary files a/data/textures/trash_can.png and /dev/null differ
diff --git a/data/triangle.glsl b/data/triangle.glsl
deleted file mode 100644
index 0c31a1e..0000000
--- a/data/triangle.glsl
+++ /dev/null
@@ -1,22 +0,0 @@
-@vs vs
-in vec4 position;
-in vec4 color0;
-
-out vec4 color;
-
-void main() {
-    gl_Position = position;
-    color = color0;
-}
-@end
-
-@fs fs
-in vec4 color;
-out vec4 frag_color;
-
-void main() {
-    frag_color = color;
-}
-@end
-
-@program triangle vs fs
diff --git a/gen.nu b/gen.nu
index a86bea0..c001322 100644
--- a/gen.nu
+++ b/gen.nu
@@ -5,7 +5,13 @@ mkdir src/gen
 ls data/*.glsl
 | get name
 | each { |s|
-    let outname = $s | path parse | $'src/gen/($in.stem).h'
+    let name = $s | path parse | get stem
+    let outname = $'src/gen/($name).h'
     bin/sokol-shdc -i $s -o $outname -l hlsl5:spirv_vk -f sokol
+    open $outname 
+    | str replace -ar '(vs_[a-z])' $'($name)_$1' 
+    | str replace -ar '(fs_[a-z])' $'($name)_$1' 
+    | save -f $outname
+    $outname
 }
 
diff --git a/src/camera.c b/src/camera.c
index 02b5a4f..f3631ef 100644
--- a/src/camera.c
+++ b/src/camera.c
@@ -1,28 +1,14 @@
 #include "colla/colla.h"
+#include "camera.h"
 
-#include "libs/handmademath.h"
 #include "libs/sokol_gfx.h"
 
 #include "utils.h"
 
-#define WORLD_UP HMM_V3(0, 1, 0)
+#define WORLD_UP v3(0, 1, 0)
 #define NEAR_Z (0.1f)
 #define FAR_Z (1000.f)
 
-typedef struct camera_t camera_t;
-struct camera_t {
-    HMM_Vec3 pos;
-    HMM_Vec3 fwd;
-    HMM_Vec3 up;
-
-    float yaw, pitch;
-
-    HMM_Mat4 lookat;
-    float speed, mov_speed, look_speed;
-
-    float fov;
-};
-
 camera_t cam_init(void) {
     camera_t cam = {
         .fwd = { 0, 0, -1 },
@@ -30,7 +16,7 @@ camera_t cam_init(void) {
         .pos = { 0, 0, 0 },
         .look_speed = 0.3f,
         .mov_speed = 15.f,
-        .fov = HMM_DegToRad * 60.f,
+        .fov = hmm_degtorad * 60.f,
     };
     return cam;
 }
@@ -43,35 +29,35 @@ void cam_update(camera_t *cam, float dt) {
     float move_speed = cam->mov_speed * dt;
     float look_speed = cam->look_speed * dt;
 
-    HMM_Vec2 delta = mouse_delta();
-    cam->yaw   += delta.X * look_speed;
-    cam->pitch -= delta.Y * look_speed;
-    float max_angle = HMM_DegToRad * 89.f;
-    cam->pitch = HMM_Clamp(-max_angle, cam->pitch, max_angle);
+    vec2 delta = mouse_delta();
+    cam->yaw   += delta.x * look_speed;
+    cam->pitch -= delta.y * look_speed;
+    float max_angle = hmm_degtorad * 89.f;
+    cam->pitch = clamp(-max_angle, cam->pitch, max_angle);
 
     float yc = cosf(cam->yaw);
     float ys = sinf(cam->yaw);
     float pc = cosf(cam->pitch);
     float ps = sinf(cam->pitch);
 
-    cam->fwd = HMM_Norm(HMM_V3(
+    cam->fwd = norm(v3(
         pc * ys,
         ps,
         -pc * yc
     ));
 
-    HMM_Vec3 right = HMM_Norm(HMM_Cross(cam->fwd, WORLD_UP));
-    cam->up        = HMM_Cross(right, cam->fwd);
+    vec3 right = norm(cross(cam->fwd, WORLD_UP));
+    cam->up    = cross(right, cam->fwd);
 
-    cam->pos = HMM_Add(
+    cam->pos = hmm_add(
         cam->pos,
-        HMM_Mul(
-            HMM_Add(
-                HMM_Add(
-                    HMM_Mul(cam->fwd, forward), 
-                    HMM_Mul(right, strafe)
+        hmm_mul(
+            hmm_add(
+                hmm_add(
+                    hmm_mul(cam->fwd, forward), 
+                    hmm_mul(right, strafe)
                 ),
-                HMM_Mul(cam->up, movup)
+                hmm_mul(cam->up, movup)
             ), 
             move_speed
         )
@@ -79,15 +65,15 @@ void cam_update(camera_t *cam, float dt) {
     
 }
 
-HMM_Mat4 cam_view(camera_t *cam) {
-    HMM_Mat4 view = HMM_LookAt_RH(cam->pos, HMM_Add(cam->pos, cam->fwd), cam->up);
+mat4 cam_view(camera_t *cam) {
+    mat4 view = HMM_LookAt_RH(cam->pos, hmm_add(cam->pos, cam->fwd), cam->up);
     
     return view;
 }
 
-HMM_Mat4 cam_proj(camera_t *cam) {
+mat4 cam_proj(camera_t *cam) {
     float aspect = sapp_widthf() / sapp_heightf();
-    HMM_Mat4 proj = HMM_Perspective_RH_ZO(cam->fov, aspect, NEAR_Z, FAR_Z);
+    mat4 proj = HMM_Perspective_RH_ZO(cam->fov, aspect, NEAR_Z, FAR_Z);
     return proj;
 }
 
diff --git a/src/camera.h b/src/camera.h
new file mode 100644
index 0000000..e82df50
--- /dev/null
+++ b/src/camera.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "libs/handmademath.h"
+
+typedef struct camera_t camera_t;
+struct camera_t {
+    vec3 pos;
+    vec3 fwd;
+    vec3 up;
+
+    float yaw, pitch;
+
+    mat4 lookat;
+    float speed, mov_speed, look_speed;
+
+    float fov;
+};
+
+camera_t cam_init(void);
+void cam_update(camera_t *cam, float dt);
+mat4 cam_view(camera_t *cam);
+mat4 cam_proj(camera_t *cam);
diff --git a/src/colla b/src/colla
index c7291ea..e0dc93f 160000
--- a/src/colla
+++ b/src/colla
@@ -1 +1 @@
-Subproject commit c7291ead23083a3a38fc8831ce22418fb8b4c211
+Subproject commit e0dc93f61d1983687941293fdc1fccf90a766c0d
diff --git a/src/game.c b/src/game.c
new file mode 100644
index 0000000..4a50a9a
--- /dev/null
+++ b/src/game.c
@@ -0,0 +1,53 @@
+#include "game.h"
+
+#include <string.h>
+
+#define FRAME_X(_, name) extern void name##_frame(arena_t scratch, entity_t *entities, float dt);
+ENTITY_KIND(FRAME_X)
+#undef FRAME_X
+
+entity_update_fn game_frame_fn[ENTITY__COUNT] = {
+    NULL,
+#define FN_X(_, name) name##_frame,
+ENTITY_KIND(FN_X)
+#undef FN_X
+};
+
+game_t game = {0};
+
+void game_init() {
+    game.arena = arena_make(ARENA_VIRTUAL, GB(1));
+    game.frame_arena = arena_scratch(&game.arena, MB(5));
+}
+
+void game_cleanup(void) {
+}
+
+void game_frame(float dt) {
+    arena_rewind(&game.frame_arena, 0);
+
+#define FRAME_X(enumval, name) \
+    name##_frame(game.frame_arena, game.active_by_type[ENTITY_##enumval], dt);
+    ENTITY_KIND(FRAME_X);
+#undef FRAME_X
+}
+
+entity_t *game_new_entity(entity_kind_e kind) {
+    entity_t *e = game.freelist;
+    list_pop(game.freelist);
+    if (!e) {
+        e = alloc(&game.arena, entity_t, .flags = ALLOC_NOZERO);
+    }
+
+    memset(e, 0, sizeof(entity_t));
+
+    e->kind = kind;
+    dlist_push(game.active_by_type[kind], e);
+
+    return e;
+}
+
+void game_entity_destroy(entity_t *e) {
+    dlist_pop(game.active_by_type[e->kind], e);
+    dlist_push(game.freelist, e);
+}
diff --git a/src/game.h b/src/game.h
new file mode 100644
index 0000000..0413945
--- /dev/null
+++ b/src/game.h
@@ -0,0 +1,47 @@
+#pragma once
+
+#include "colla/colla.h"
+#include "camera.h"
+
+#define ENTITY_KIND(X) \
+    X(PLAYER, player) \
+
+typedef enum {
+    ENTITY_NONE,
+
+#define ENUM_X(name, ...) ENTITY_##name,
+    ENTITY_KIND(ENUM_X)
+#undef ENUM_X
+
+    ENTITY__COUNT,
+} entity_kind_e;
+
+typedef struct entity_t entity_t;
+
+typedef void (*entity_update_fn)(arena_t scratch, entity_t *entites, float dt);
+
+struct entity_t {
+    entity_kind_e kind;
+    entity_t *next;
+    entity_t *prev;
+
+    camera_t camera;
+    vec3 position;
+};
+
+typedef struct game_t game_t;
+struct game_t {
+    arena_t arena;
+    arena_t frame_arena;
+    entity_t *freelist;
+    entity_t *active_by_type[ENTITY__COUNT];
+};
+extern game_t game;
+
+void game_init(void);
+void game_cleanup(void);
+
+void game_frame(float dt);
+
+entity_t *game_new_entity(entity_kind_e kind);
+void game_entity_destroy(entity_t *e);
diff --git a/src/gen/batcher.h b/src/gen/batcher.h
new file mode 100644
index 0000000..d5bb8e6
--- /dev/null
+++ b/src/gen/batcher.h
@@ -0,0 +1,736 @@
+#pragma once
+/*
+    #version:1# (machine generated, don't edit!)
+
+    Generated by sokol-shdc (https://github.com/floooh/sokol-tools)
+
+    Cmdline:
+        sokol-shdc -i data\batcher.glsl -o src/gen/batcher.h -l hlsl5:spirv_vk -f sokol
+
+    Overview:
+    =========
+    Shader program: 'batcher':
+        Get shader desc: batcher_shader_desc(sg_query_backend());
+        Vertex Shader: vs
+        Fragment Shader: fs
+        Attributes:
+            ATTR_batcher_quad => 0
+            ATTR_batcher_tex_quad => 1
+            ATTR_batcher_colour => 2
+    Bindings:
+        Uniform block 'render_data':
+            C struct: render_data_t
+            Bind slot: UB_render_data => 0
+        Texture 'tex':
+            Image type: SG_IMAGETYPE_2D
+            Sample type: SG_IMAGESAMPLETYPE_FLOAT
+            Multisampled: false
+            Bind slot: VIEW_tex => 0
+        Sampler 'smp':
+            Type: SG_SAMPLERTYPE_FILTERING
+            Bind slot: SMP_smp => 0
+*/
+#if !defined(SOKOL_GFX_INCLUDED)
+#error "Please include sokol_gfx.h before batcher.h"
+#endif
+#if !defined(SOKOL_SHDC_ALIGN)
+#if defined(_MSC_VER)
+#define SOKOL_SHDC_ALIGN(a) __declspec(align(a))
+#else
+#define SOKOL_SHDC_ALIGN(a) __attribute__((aligned(a)))
+#endif
+#endif
+#define ATTR_batcher_quad (0)
+#define ATTR_batcher_tex_quad (1)
+#define ATTR_batcher_colour (2)
+#define UB_render_data (0)
+#define VIEW_tex (0)
+#define SMP_smp (0)
+#pragma pack(push,1)
+SOKOL_SHDC_ALIGN(16) typedef struct render_data_t {
+    vec2 one_over_window_size;
+    float zoom;
+    uint8_t _pad_12[4];
+} render_data_t;
+#pragma pack(pop)
+/*
+    static float3 _135;
+
+    static const int _16[6] = { 0, 1, 2, 2, 3, 0 };
+    static const float3 _36[4] = { 0.0f.xxx, float3(0.0f, 1.0f, 0.0f), float3(1.0f, 1.0f, 0.0f), float3(1.0f, 0.0f, 0.0f) };
+    static const float2 _50[4] = { 0.0f.xx, float2(0.0f, 1.0f), 1.0f.xx, float2(1.0f, 0.0f) };
+
+    cbuffer render_data : register(b0)
+    {
+        float2 _70_one_over_window_size : packoffset(c0);
+        float _70_zoom : packoffset(c0.z);
+    };
+
+
+    static float4 gl_Position;
+    static int gl_VertexIndex;
+    static float2 uv;
+    static float4 quad;
+    static float4 tex_quad;
+    static float4 batcher_fs_colour;
+    static float4 colour;
+
+    struct SPIRV_Cross_Input
+    {
+        float4 quad : TEXCOORD0;
+        float4 tex_quad : TEXCOORD1;
+        float4 colour : TEXCOORD2;
+        uint gl_VertexIndex : SV_VertexID;
+    };
+
+    struct SPIRV_Cross_Output
+    {
+        float2 uv : TEXCOORD0;
+        float4 batcher_fs_colour : TEXCOORD1;
+        float4 gl_Position : SV_Position;
+    };
+
+    void vert_main()
+    {
+        uv = _50[_16[gl_VertexIndex]];
+        float2 _74 = ((_36[_16[gl_VertexIndex]].xy * quad.zw) + quad.xy) * _70_zoom;
+        float3 _124;
+        _124.x = _74.x;
+        _124.y = _74.y;
+        float2 _91 = ((_124.xy * _70_one_over_window_size) * 2.0f) - 1.0f.xx;
+        uv *= tex_quad.zw;
+        uv += tex_quad.xy;
+        gl_Position = float4(_91.x, -_91.y, _36[_16[gl_VertexIndex]].z, 1.0f);
+        batcher_fs_colour = colour;
+    }
+
+    SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input)
+    {
+        gl_VertexIndex = int(stage_input.gl_VertexIndex);
+        quad = stage_input.quad;
+        tex_quad = stage_input.tex_quad;
+        colour = stage_input.colour;
+        vert_main();
+        SPIRV_Cross_Output stage_output;
+        stage_output.gl_Position = gl_Position;
+        stage_output.uv = uv;
+        stage_output.batcher_fs_colour = batcher_fs_colour;
+        return stage_output;
+    }
+*/
+static const uint8_t batcher_vs_source_hlsl5[1691] = {
+    0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,0x61,0x74,0x33,0x20,0x5f,0x31,
+    0x33,0x35,0x3b,0x0a,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x63,0x6f,0x6e,0x73,
+    0x74,0x20,0x69,0x6e,0x74,0x20,0x5f,0x31,0x36,0x5b,0x36,0x5d,0x20,0x3d,0x20,0x7b,
+    0x20,0x30,0x2c,0x20,0x31,0x2c,0x20,0x32,0x2c,0x20,0x32,0x2c,0x20,0x33,0x2c,0x20,
+    0x30,0x20,0x7d,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x63,0x6f,0x6e,0x73,
+    0x74,0x20,0x66,0x6c,0x6f,0x61,0x74,0x33,0x20,0x5f,0x33,0x36,0x5b,0x34,0x5d,0x20,
+    0x3d,0x20,0x7b,0x20,0x30,0x2e,0x30,0x66,0x2e,0x78,0x78,0x78,0x2c,0x20,0x66,0x6c,
+    0x6f,0x61,0x74,0x33,0x28,0x30,0x2e,0x30,0x66,0x2c,0x20,0x31,0x2e,0x30,0x66,0x2c,
+    0x20,0x30,0x2e,0x30,0x66,0x29,0x2c,0x20,0x66,0x6c,0x6f,0x61,0x74,0x33,0x28,0x31,
+    0x2e,0x30,0x66,0x2c,0x20,0x31,0x2e,0x30,0x66,0x2c,0x20,0x30,0x2e,0x30,0x66,0x29,
+    0x2c,0x20,0x66,0x6c,0x6f,0x61,0x74,0x33,0x28,0x31,0x2e,0x30,0x66,0x2c,0x20,0x30,
+    0x2e,0x30,0x66,0x2c,0x20,0x30,0x2e,0x30,0x66,0x29,0x20,0x7d,0x3b,0x0a,0x73,0x74,
+    0x61,0x74,0x69,0x63,0x20,0x63,0x6f,0x6e,0x73,0x74,0x20,0x66,0x6c,0x6f,0x61,0x74,
+    0x32,0x20,0x5f,0x35,0x30,0x5b,0x34,0x5d,0x20,0x3d,0x20,0x7b,0x20,0x30,0x2e,0x30,
+    0x66,0x2e,0x78,0x78,0x2c,0x20,0x66,0x6c,0x6f,0x61,0x74,0x32,0x28,0x30,0x2e,0x30,
+    0x66,0x2c,0x20,0x31,0x2e,0x30,0x66,0x29,0x2c,0x20,0x31,0x2e,0x30,0x66,0x2e,0x78,
+    0x78,0x2c,0x20,0x66,0x6c,0x6f,0x61,0x74,0x32,0x28,0x31,0x2e,0x30,0x66,0x2c,0x20,
+    0x30,0x2e,0x30,0x66,0x29,0x20,0x7d,0x3b,0x0a,0x0a,0x63,0x62,0x75,0x66,0x66,0x65,
+    0x72,0x20,0x72,0x65,0x6e,0x64,0x65,0x72,0x5f,0x64,0x61,0x74,0x61,0x20,0x3a,0x20,
+    0x72,0x65,0x67,0x69,0x73,0x74,0x65,0x72,0x28,0x62,0x30,0x29,0x0a,0x7b,0x0a,0x20,
+    0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x32,0x20,0x5f,0x37,0x30,0x5f,0x6f,0x6e,
+    0x65,0x5f,0x6f,0x76,0x65,0x72,0x5f,0x77,0x69,0x6e,0x64,0x6f,0x77,0x5f,0x73,0x69,
+    0x7a,0x65,0x20,0x3a,0x20,0x70,0x61,0x63,0x6b,0x6f,0x66,0x66,0x73,0x65,0x74,0x28,
+    0x63,0x30,0x29,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x20,0x5f,
+    0x37,0x30,0x5f,0x7a,0x6f,0x6f,0x6d,0x20,0x3a,0x20,0x70,0x61,0x63,0x6b,0x6f,0x66,
+    0x66,0x73,0x65,0x74,0x28,0x63,0x30,0x2e,0x7a,0x29,0x3b,0x0a,0x7d,0x3b,0x0a,0x0a,
+    0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x67,
+    0x6c,0x5f,0x50,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x3b,0x0a,0x73,0x74,0x61,0x74,
+    0x69,0x63,0x20,0x69,0x6e,0x74,0x20,0x67,0x6c,0x5f,0x56,0x65,0x72,0x74,0x65,0x78,
+    0x49,0x6e,0x64,0x65,0x78,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x66,0x6c,
+    0x6f,0x61,0x74,0x32,0x20,0x75,0x76,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,
+    0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x71,0x75,0x61,0x64,0x3b,0x0a,0x73,0x74,0x61,
+    0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x74,0x65,0x78,0x5f,0x71,
+    0x75,0x61,0x64,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,0x61,
+    0x74,0x34,0x20,0x66,0x73,0x5f,0x63,0x6f,0x6c,0x6f,0x75,0x72,0x3b,0x0a,0x73,0x74,
+    0x61,0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x63,0x6f,0x6c,0x6f,
+    0x75,0x72,0x3b,0x0a,0x0a,0x73,0x74,0x72,0x75,0x63,0x74,0x20,0x53,0x50,0x49,0x52,
+    0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,0x5f,0x49,0x6e,0x70,0x75,0x74,0x0a,0x7b,0x0a,
+    0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x71,0x75,0x61,0x64,0x20,
+    0x3a,0x20,0x54,0x45,0x58,0x43,0x4f,0x4f,0x52,0x44,0x30,0x3b,0x0a,0x20,0x20,0x20,
+    0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x74,0x65,0x78,0x5f,0x71,0x75,0x61,0x64,
+    0x20,0x3a,0x20,0x54,0x45,0x58,0x43,0x4f,0x4f,0x52,0x44,0x31,0x3b,0x0a,0x20,0x20,
+    0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x63,0x6f,0x6c,0x6f,0x75,0x72,0x20,
+    0x3a,0x20,0x54,0x45,0x58,0x43,0x4f,0x4f,0x52,0x44,0x32,0x3b,0x0a,0x20,0x20,0x20,
+    0x20,0x75,0x69,0x6e,0x74,0x20,0x67,0x6c,0x5f,0x56,0x65,0x72,0x74,0x65,0x78,0x49,
+    0x6e,0x64,0x65,0x78,0x20,0x3a,0x20,0x53,0x56,0x5f,0x56,0x65,0x72,0x74,0x65,0x78,
+    0x49,0x44,0x3b,0x0a,0x7d,0x3b,0x0a,0x0a,0x73,0x74,0x72,0x75,0x63,0x74,0x20,0x53,
+    0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,0x5f,0x4f,0x75,0x74,0x70,0x75,
+    0x74,0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x32,0x20,0x75,
+    0x76,0x20,0x3a,0x20,0x54,0x45,0x58,0x43,0x4f,0x4f,0x52,0x44,0x30,0x3b,0x0a,0x20,
+    0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x66,0x73,0x5f,0x63,0x6f,0x6c,
+    0x6f,0x75,0x72,0x20,0x3a,0x20,0x54,0x45,0x58,0x43,0x4f,0x4f,0x52,0x44,0x31,0x3b,
+    0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x67,0x6c,0x5f,0x50,
+    0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x20,0x3a,0x20,0x53,0x56,0x5f,0x50,0x6f,0x73,
+    0x69,0x74,0x69,0x6f,0x6e,0x3b,0x0a,0x7d,0x3b,0x0a,0x0a,0x76,0x6f,0x69,0x64,0x20,
+    0x76,0x65,0x72,0x74,0x5f,0x6d,0x61,0x69,0x6e,0x28,0x29,0x0a,0x7b,0x0a,0x20,0x20,
+    0x20,0x20,0x75,0x76,0x20,0x3d,0x20,0x5f,0x35,0x30,0x5b,0x5f,0x31,0x36,0x5b,0x67,
+    0x6c,0x5f,0x56,0x65,0x72,0x74,0x65,0x78,0x49,0x6e,0x64,0x65,0x78,0x5d,0x5d,0x3b,
+    0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x32,0x20,0x5f,0x37,0x34,0x20,
+    0x3d,0x20,0x28,0x28,0x5f,0x33,0x36,0x5b,0x5f,0x31,0x36,0x5b,0x67,0x6c,0x5f,0x56,
+    0x65,0x72,0x74,0x65,0x78,0x49,0x6e,0x64,0x65,0x78,0x5d,0x5d,0x2e,0x78,0x79,0x20,
+    0x2a,0x20,0x71,0x75,0x61,0x64,0x2e,0x7a,0x77,0x29,0x20,0x2b,0x20,0x71,0x75,0x61,
+    0x64,0x2e,0x78,0x79,0x29,0x20,0x2a,0x20,0x5f,0x37,0x30,0x5f,0x7a,0x6f,0x6f,0x6d,
+    0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x33,0x20,0x5f,0x31,0x32,
+    0x34,0x3b,0x0a,0x20,0x20,0x20,0x20,0x5f,0x31,0x32,0x34,0x2e,0x78,0x20,0x3d,0x20,
+    0x5f,0x37,0x34,0x2e,0x78,0x3b,0x0a,0x20,0x20,0x20,0x20,0x5f,0x31,0x32,0x34,0x2e,
+    0x79,0x20,0x3d,0x20,0x5f,0x37,0x34,0x2e,0x79,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,
+    0x6c,0x6f,0x61,0x74,0x32,0x20,0x5f,0x39,0x31,0x20,0x3d,0x20,0x28,0x28,0x5f,0x31,
+    0x32,0x34,0x2e,0x78,0x79,0x20,0x2a,0x20,0x5f,0x37,0x30,0x5f,0x6f,0x6e,0x65,0x5f,
+    0x6f,0x76,0x65,0x72,0x5f,0x77,0x69,0x6e,0x64,0x6f,0x77,0x5f,0x73,0x69,0x7a,0x65,
+    0x29,0x20,0x2a,0x20,0x32,0x2e,0x30,0x66,0x29,0x20,0x2d,0x20,0x31,0x2e,0x30,0x66,
+    0x2e,0x78,0x78,0x3b,0x0a,0x20,0x20,0x20,0x20,0x75,0x76,0x20,0x2a,0x3d,0x20,0x74,
+    0x65,0x78,0x5f,0x71,0x75,0x61,0x64,0x2e,0x7a,0x77,0x3b,0x0a,0x20,0x20,0x20,0x20,
+    0x75,0x76,0x20,0x2b,0x3d,0x20,0x74,0x65,0x78,0x5f,0x71,0x75,0x61,0x64,0x2e,0x78,
+    0x79,0x3b,0x0a,0x20,0x20,0x20,0x20,0x67,0x6c,0x5f,0x50,0x6f,0x73,0x69,0x74,0x69,
+    0x6f,0x6e,0x20,0x3d,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x28,0x5f,0x39,0x31,0x2e,
+    0x78,0x2c,0x20,0x2d,0x5f,0x39,0x31,0x2e,0x79,0x2c,0x20,0x5f,0x33,0x36,0x5b,0x5f,
+    0x31,0x36,0x5b,0x67,0x6c,0x5f,0x56,0x65,0x72,0x74,0x65,0x78,0x49,0x6e,0x64,0x65,
+    0x78,0x5d,0x5d,0x2e,0x7a,0x2c,0x20,0x31,0x2e,0x30,0x66,0x29,0x3b,0x0a,0x20,0x20,
+    0x20,0x20,0x66,0x73,0x5f,0x63,0x6f,0x6c,0x6f,0x75,0x72,0x20,0x3d,0x20,0x63,0x6f,
+    0x6c,0x6f,0x75,0x72,0x3b,0x0a,0x7d,0x0a,0x0a,0x53,0x50,0x49,0x52,0x56,0x5f,0x43,
+    0x72,0x6f,0x73,0x73,0x5f,0x4f,0x75,0x74,0x70,0x75,0x74,0x20,0x6d,0x61,0x69,0x6e,
+    0x28,0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,0x5f,0x49,0x6e,0x70,
+    0x75,0x74,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,0x70,0x75,0x74,0x29,0x0a,
+    0x7b,0x0a,0x20,0x20,0x20,0x20,0x67,0x6c,0x5f,0x56,0x65,0x72,0x74,0x65,0x78,0x49,
+    0x6e,0x64,0x65,0x78,0x20,0x3d,0x20,0x69,0x6e,0x74,0x28,0x73,0x74,0x61,0x67,0x65,
+    0x5f,0x69,0x6e,0x70,0x75,0x74,0x2e,0x67,0x6c,0x5f,0x56,0x65,0x72,0x74,0x65,0x78,
+    0x49,0x6e,0x64,0x65,0x78,0x29,0x3b,0x0a,0x20,0x20,0x20,0x20,0x71,0x75,0x61,0x64,
+    0x20,0x3d,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,0x70,0x75,0x74,0x2e,0x71,
+    0x75,0x61,0x64,0x3b,0x0a,0x20,0x20,0x20,0x20,0x74,0x65,0x78,0x5f,0x71,0x75,0x61,
+    0x64,0x20,0x3d,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,0x70,0x75,0x74,0x2e,
+    0x74,0x65,0x78,0x5f,0x71,0x75,0x61,0x64,0x3b,0x0a,0x20,0x20,0x20,0x20,0x63,0x6f,
+    0x6c,0x6f,0x75,0x72,0x20,0x3d,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,0x70,
+    0x75,0x74,0x2e,0x63,0x6f,0x6c,0x6f,0x75,0x72,0x3b,0x0a,0x20,0x20,0x20,0x20,0x76,
+    0x65,0x72,0x74,0x5f,0x6d,0x61,0x69,0x6e,0x28,0x29,0x3b,0x0a,0x20,0x20,0x20,0x20,
+    0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,0x5f,0x4f,0x75,0x74,0x70,
+    0x75,0x74,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,0x3b,
+    0x0a,0x20,0x20,0x20,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,
+    0x74,0x2e,0x67,0x6c,0x5f,0x50,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x20,0x3d,0x20,
+    0x67,0x6c,0x5f,0x50,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x3b,0x0a,0x20,0x20,0x20,
+    0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,0x2e,0x75,0x76,
+    0x20,0x3d,0x20,0x75,0x76,0x3b,0x0a,0x20,0x20,0x20,0x20,0x73,0x74,0x61,0x67,0x65,
+    0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,0x2e,0x66,0x73,0x5f,0x63,0x6f,0x6c,0x6f,0x75,
+    0x72,0x20,0x3d,0x20,0x66,0x73,0x5f,0x63,0x6f,0x6c,0x6f,0x75,0x72,0x3b,0x0a,0x20,
+    0x20,0x20,0x20,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,
+    0x6f,0x75,0x74,0x70,0x75,0x74,0x3b,0x0a,0x7d,0x0a,0x00,
+};
+/*
+    Texture2D<float4> tex : register(t0);
+    SamplerState smp : register(s0);
+
+    static float2 uv;
+    static float4 batcher_fs_colour;
+    static float4 frag_colour;
+
+    struct SPIRV_Cross_Input
+    {
+        float2 uv : TEXCOORD0;
+        float4 batcher_fs_colour : TEXCOORD1;
+    };
+
+    struct SPIRV_Cross_Output
+    {
+        float4 frag_colour : SV_Target0;
+    };
+
+    void frag_main()
+    {
+        float4 _24 = tex.Sample(smp, uv);
+        float4 _28 = _24 * batcher_fs_colour;
+        if (_28.w < 1.0f)
+        {
+            discard;
+        }
+        frag_colour = _28;
+    }
+
+    SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input)
+    {
+        uv = stage_input.uv;
+        batcher_fs_colour = stage_input.batcher_fs_colour;
+        frag_main();
+        SPIRV_Cross_Output stage_output;
+        stage_output.frag_colour = frag_colour;
+        return stage_output;
+    }
+*/
+static const uint8_t batcher_fs_source_hlsl5[719] = {
+    0x54,0x65,0x78,0x74,0x75,0x72,0x65,0x32,0x44,0x3c,0x66,0x6c,0x6f,0x61,0x74,0x34,
+    0x3e,0x20,0x74,0x65,0x78,0x20,0x3a,0x20,0x72,0x65,0x67,0x69,0x73,0x74,0x65,0x72,
+    0x28,0x74,0x30,0x29,0x3b,0x0a,0x53,0x61,0x6d,0x70,0x6c,0x65,0x72,0x53,0x74,0x61,
+    0x74,0x65,0x20,0x73,0x6d,0x70,0x20,0x3a,0x20,0x72,0x65,0x67,0x69,0x73,0x74,0x65,
+    0x72,0x28,0x73,0x30,0x29,0x3b,0x0a,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x66,
+    0x6c,0x6f,0x61,0x74,0x32,0x20,0x75,0x76,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,
+    0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x66,0x73,0x5f,0x63,0x6f,0x6c,0x6f,0x75,
+    0x72,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,
+    0x20,0x66,0x72,0x61,0x67,0x5f,0x63,0x6f,0x6c,0x6f,0x75,0x72,0x3b,0x0a,0x0a,0x73,
+    0x74,0x72,0x75,0x63,0x74,0x20,0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,
+    0x73,0x5f,0x49,0x6e,0x70,0x75,0x74,0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,
+    0x6f,0x61,0x74,0x32,0x20,0x75,0x76,0x20,0x3a,0x20,0x54,0x45,0x58,0x43,0x4f,0x4f,
+    0x52,0x44,0x30,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,
+    0x66,0x73,0x5f,0x63,0x6f,0x6c,0x6f,0x75,0x72,0x20,0x3a,0x20,0x54,0x45,0x58,0x43,
+    0x4f,0x4f,0x52,0x44,0x31,0x3b,0x0a,0x7d,0x3b,0x0a,0x0a,0x73,0x74,0x72,0x75,0x63,
+    0x74,0x20,0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,0x5f,0x4f,0x75,
+    0x74,0x70,0x75,0x74,0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,
+    0x34,0x20,0x66,0x72,0x61,0x67,0x5f,0x63,0x6f,0x6c,0x6f,0x75,0x72,0x20,0x3a,0x20,
+    0x53,0x56,0x5f,0x54,0x61,0x72,0x67,0x65,0x74,0x30,0x3b,0x0a,0x7d,0x3b,0x0a,0x0a,
+    0x76,0x6f,0x69,0x64,0x20,0x66,0x72,0x61,0x67,0x5f,0x6d,0x61,0x69,0x6e,0x28,0x29,
+    0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x5f,0x32,
+    0x34,0x20,0x3d,0x20,0x74,0x65,0x78,0x2e,0x53,0x61,0x6d,0x70,0x6c,0x65,0x28,0x73,
+    0x6d,0x70,0x2c,0x20,0x75,0x76,0x29,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,
+    0x61,0x74,0x34,0x20,0x5f,0x32,0x38,0x20,0x3d,0x20,0x5f,0x32,0x34,0x20,0x2a,0x20,
+    0x66,0x73,0x5f,0x63,0x6f,0x6c,0x6f,0x75,0x72,0x3b,0x0a,0x20,0x20,0x20,0x20,0x69,
+    0x66,0x20,0x28,0x5f,0x32,0x38,0x2e,0x77,0x20,0x3c,0x20,0x31,0x2e,0x30,0x66,0x29,
+    0x0a,0x20,0x20,0x20,0x20,0x7b,0x0a,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x64,
+    0x69,0x73,0x63,0x61,0x72,0x64,0x3b,0x0a,0x20,0x20,0x20,0x20,0x7d,0x0a,0x20,0x20,
+    0x20,0x20,0x66,0x72,0x61,0x67,0x5f,0x63,0x6f,0x6c,0x6f,0x75,0x72,0x20,0x3d,0x20,
+    0x5f,0x32,0x38,0x3b,0x0a,0x7d,0x0a,0x0a,0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,
+    0x6f,0x73,0x73,0x5f,0x4f,0x75,0x74,0x70,0x75,0x74,0x20,0x6d,0x61,0x69,0x6e,0x28,
+    0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,0x5f,0x49,0x6e,0x70,0x75,
+    0x74,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,0x70,0x75,0x74,0x29,0x0a,0x7b,
+    0x0a,0x20,0x20,0x20,0x20,0x75,0x76,0x20,0x3d,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,
+    0x69,0x6e,0x70,0x75,0x74,0x2e,0x75,0x76,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x73,
+    0x5f,0x63,0x6f,0x6c,0x6f,0x75,0x72,0x20,0x3d,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,
+    0x69,0x6e,0x70,0x75,0x74,0x2e,0x66,0x73,0x5f,0x63,0x6f,0x6c,0x6f,0x75,0x72,0x3b,
+    0x0a,0x20,0x20,0x20,0x20,0x66,0x72,0x61,0x67,0x5f,0x6d,0x61,0x69,0x6e,0x28,0x29,
+    0x3b,0x0a,0x20,0x20,0x20,0x20,0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,
+    0x73,0x5f,0x4f,0x75,0x74,0x70,0x75,0x74,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x6f,
+    0x75,0x74,0x70,0x75,0x74,0x3b,0x0a,0x20,0x20,0x20,0x20,0x73,0x74,0x61,0x67,0x65,
+    0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,0x2e,0x66,0x72,0x61,0x67,0x5f,0x63,0x6f,0x6c,
+    0x6f,0x75,0x72,0x20,0x3d,0x20,0x66,0x72,0x61,0x67,0x5f,0x63,0x6f,0x6c,0x6f,0x75,
+    0x72,0x3b,0x0a,0x20,0x20,0x20,0x20,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x73,0x74,
+    0x61,0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,0x3b,0x0a,0x7d,0x0a,0x00,
+};
+/*
+    #version 460
+
+    const int _16[6] = int[](0, 1, 2, 2, 3, 0);
+    const vec3 _36[4] = vec3[](vec3(0.0), vec3(0.0, 1.0, 0.0), vec3(1.0, 1.0, 0.0), vec3(1.0, 0.0, 0.0));
+    const vec2 _50[4] = vec2[](vec2(0.0), vec2(0.0, 1.0), vec2(1.0), vec2(1.0, 0.0));
+    vec3 _135;
+
+    layout(set = 0, binding = 0, std140) uniform render_data
+    {
+        vec2 one_over_window_size;
+        float zoom;
+    } _70;
+
+    layout(location = 0) out vec2 uv;
+    layout(location = 0) in vec4 quad;
+    layout(location = 1) in vec4 tex_quad;
+    layout(location = 1) out vec4 batcher_fs_colour;
+    layout(location = 2) in vec4 colour;
+
+    void main()
+    {
+        uv = _50[_16[gl_VertexIndex]];
+        vec2 _74 = ((_36[_16[gl_VertexIndex]].xy * quad.zw) + quad.xy) * _70.zoom;
+        vec3 _124;
+        _124.x = _74.x;
+        _124.y = _74.y;
+        vec2 _91 = ((_124.xy * _70.one_over_window_size) * 2.0) - vec2(1.0);
+        uv *= tex_quad.zw;
+        uv += tex_quad.xy;
+        gl_Position = vec4(_91.x, -_91.y, _36[_16[gl_VertexIndex]].z, 1.0);
+        batcher_fs_colour = colour;
+    }
+
+*/
+static const uint8_t batcher_vs_bytecode_spirv_vk[3440] = {
+    0x03,0x02,0x23,0x07,0x00,0x04,0x01,0x00,0x0b,0x00,0x08,0x00,0x81,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x11,0x00,0x02,0x00,0x01,0x00,0x00,0x00,0x0b,0x00,0x06,0x00,
+    0x01,0x00,0x00,0x00,0x47,0x4c,0x53,0x4c,0x2e,0x73,0x74,0x64,0x2e,0x34,0x35,0x30,
+    0x00,0x00,0x00,0x00,0x0e,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
+    0x0f,0x00,0x0e,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x6d,0x61,0x69,0x6e,
+    0x00,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x1d,0x00,0x00,0x00,0x3d,0x00,0x00,0x00,
+    0x46,0x00,0x00,0x00,0x5f,0x00,0x00,0x00,0x6b,0x00,0x00,0x00,0x7c,0x00,0x00,0x00,
+    0x7d,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x03,0x00,0x03,0x00,0x02,0x00,0x00,0x00,
+    0xcc,0x01,0x00,0x00,0x05,0x00,0x04,0x00,0x04,0x00,0x00,0x00,0x6d,0x61,0x69,0x6e,
+    0x00,0x00,0x00,0x00,0x05,0x00,0x03,0x00,0x09,0x00,0x00,0x00,0x75,0x76,0x00,0x00,
+    0x05,0x00,0x06,0x00,0x1d,0x00,0x00,0x00,0x67,0x6c,0x5f,0x56,0x65,0x72,0x74,0x65,
+    0x78,0x49,0x6e,0x64,0x65,0x78,0x00,0x00,0x05,0x00,0x05,0x00,0x20,0x00,0x00,0x00,
+    0x69,0x6e,0x64,0x65,0x78,0x61,0x62,0x6c,0x65,0x00,0x00,0x00,0x05,0x00,0x05,0x00,
+    0x25,0x00,0x00,0x00,0x69,0x6e,0x64,0x65,0x78,0x61,0x62,0x6c,0x65,0x00,0x00,0x00,
+    0x05,0x00,0x03,0x00,0x29,0x00,0x00,0x00,0x5f,0x37,0x34,0x00,0x05,0x00,0x05,0x00,
+    0x32,0x00,0x00,0x00,0x69,0x6e,0x64,0x65,0x78,0x61,0x62,0x6c,0x65,0x00,0x00,0x00,
+    0x05,0x00,0x05,0x00,0x36,0x00,0x00,0x00,0x69,0x6e,0x64,0x65,0x78,0x61,0x62,0x6c,
+    0x65,0x00,0x00,0x00,0x05,0x00,0x04,0x00,0x3d,0x00,0x00,0x00,0x71,0x75,0x61,0x64,
+    0x00,0x00,0x00,0x00,0x05,0x00,0x05,0x00,0x44,0x00,0x00,0x00,0x72,0x65,0x6e,0x64,
+    0x65,0x72,0x5f,0x64,0x61,0x74,0x61,0x00,0x06,0x00,0x09,0x00,0x44,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x6f,0x6e,0x65,0x5f,0x6f,0x76,0x65,0x72,0x5f,0x77,0x69,0x6e,
+    0x64,0x6f,0x77,0x5f,0x73,0x69,0x7a,0x65,0x00,0x00,0x00,0x00,0x06,0x00,0x05,0x00,
+    0x44,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x7a,0x6f,0x6f,0x6d,0x00,0x00,0x00,0x00,
+    0x05,0x00,0x03,0x00,0x46,0x00,0x00,0x00,0x5f,0x37,0x30,0x00,0x05,0x00,0x04,0x00,
+    0x4b,0x00,0x00,0x00,0x5f,0x31,0x32,0x34,0x00,0x00,0x00,0x00,0x05,0x00,0x03,0x00,
+    0x55,0x00,0x00,0x00,0x5f,0x39,0x31,0x00,0x05,0x00,0x05,0x00,0x5f,0x00,0x00,0x00,
+    0x74,0x65,0x78,0x5f,0x71,0x75,0x61,0x64,0x00,0x00,0x00,0x00,0x05,0x00,0x06,0x00,
+    0x69,0x00,0x00,0x00,0x67,0x6c,0x5f,0x50,0x65,0x72,0x56,0x65,0x72,0x74,0x65,0x78,
+    0x00,0x00,0x00,0x00,0x06,0x00,0x06,0x00,0x69,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x67,0x6c,0x5f,0x50,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x00,0x06,0x00,0x07,0x00,
+    0x69,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x67,0x6c,0x5f,0x50,0x6f,0x69,0x6e,0x74,
+    0x53,0x69,0x7a,0x65,0x00,0x00,0x00,0x00,0x06,0x00,0x07,0x00,0x69,0x00,0x00,0x00,
+    0x02,0x00,0x00,0x00,0x67,0x6c,0x5f,0x43,0x6c,0x69,0x70,0x44,0x69,0x73,0x74,0x61,
+    0x6e,0x63,0x65,0x00,0x06,0x00,0x07,0x00,0x69,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
+    0x67,0x6c,0x5f,0x43,0x75,0x6c,0x6c,0x44,0x69,0x73,0x74,0x61,0x6e,0x63,0x65,0x00,
+    0x05,0x00,0x03,0x00,0x6b,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x05,0x00,
+    0x72,0x00,0x00,0x00,0x69,0x6e,0x64,0x65,0x78,0x61,0x62,0x6c,0x65,0x00,0x00,0x00,
+    0x05,0x00,0x05,0x00,0x76,0x00,0x00,0x00,0x69,0x6e,0x64,0x65,0x78,0x61,0x62,0x6c,
+    0x65,0x00,0x00,0x00,0x05,0x00,0x05,0x00,0x7c,0x00,0x00,0x00,0x66,0x73,0x5f,0x63,
+    0x6f,0x6c,0x6f,0x75,0x72,0x00,0x00,0x00,0x05,0x00,0x04,0x00,0x7d,0x00,0x00,0x00,
+    0x63,0x6f,0x6c,0x6f,0x75,0x72,0x00,0x00,0x05,0x00,0x04,0x00,0x80,0x00,0x00,0x00,
+    0x5f,0x31,0x33,0x35,0x00,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x09,0x00,0x00,0x00,
+    0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x1d,0x00,0x00,0x00,
+    0x0b,0x00,0x00,0x00,0x2a,0x00,0x00,0x00,0x47,0x00,0x03,0x00,0x20,0x00,0x00,0x00,
+    0x18,0x00,0x00,0x00,0x47,0x00,0x03,0x00,0x25,0x00,0x00,0x00,0x18,0x00,0x00,0x00,
+    0x47,0x00,0x03,0x00,0x32,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x47,0x00,0x03,0x00,
+    0x36,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x3d,0x00,0x00,0x00,
+    0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x47,0x00,0x03,0x00,0x44,0x00,0x00,0x00,
+    0x02,0x00,0x00,0x00,0x48,0x00,0x05,0x00,0x44,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x23,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x48,0x00,0x05,0x00,0x44,0x00,0x00,0x00,
+    0x01,0x00,0x00,0x00,0x23,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x47,0x00,0x04,0x00,
+    0x46,0x00,0x00,0x00,0x21,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x47,0x00,0x04,0x00,
+    0x46,0x00,0x00,0x00,0x22,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x47,0x00,0x04,0x00,
+    0x5f,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x47,0x00,0x03,0x00,
+    0x69,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x48,0x00,0x05,0x00,0x69,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x48,0x00,0x05,0x00,
+    0x69,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
+    0x48,0x00,0x05,0x00,0x69,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,
+    0x03,0x00,0x00,0x00,0x48,0x00,0x05,0x00,0x69,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
+    0x0b,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x47,0x00,0x03,0x00,0x72,0x00,0x00,0x00,
+    0x18,0x00,0x00,0x00,0x47,0x00,0x03,0x00,0x76,0x00,0x00,0x00,0x18,0x00,0x00,0x00,
+    0x47,0x00,0x04,0x00,0x7c,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
+    0x47,0x00,0x04,0x00,0x7d,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,0x02,0x00,0x00,0x00,
+    0x13,0x00,0x02,0x00,0x02,0x00,0x00,0x00,0x21,0x00,0x03,0x00,0x03,0x00,0x00,0x00,
+    0x02,0x00,0x00,0x00,0x16,0x00,0x03,0x00,0x06,0x00,0x00,0x00,0x20,0x00,0x00,0x00,
+    0x17,0x00,0x04,0x00,0x07,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x02,0x00,0x00,0x00,
+    0x20,0x00,0x04,0x00,0x08,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x07,0x00,0x00,0x00,
+    0x3b,0x00,0x04,0x00,0x08,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
+    0x15,0x00,0x04,0x00,0x0a,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x2b,0x00,0x04,0x00,0x0a,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x04,0x00,0x00,0x00,
+    0x1c,0x00,0x04,0x00,0x0c,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,
+    0x2b,0x00,0x04,0x00,0x06,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x2c,0x00,0x05,0x00,0x07,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,
+    0x0d,0x00,0x00,0x00,0x2b,0x00,0x04,0x00,0x06,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,
+    0x00,0x00,0x80,0x3f,0x2c,0x00,0x05,0x00,0x07,0x00,0x00,0x00,0x10,0x00,0x00,0x00,
+    0x0d,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x2c,0x00,0x05,0x00,0x07,0x00,0x00,0x00,
+    0x11,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x2c,0x00,0x05,0x00,
+    0x07,0x00,0x00,0x00,0x12,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,
+    0x2c,0x00,0x07,0x00,0x0c,0x00,0x00,0x00,0x13,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,
+    0x10,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x12,0x00,0x00,0x00,0x15,0x00,0x04,0x00,
+    0x14,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x2b,0x00,0x04,0x00,
+    0x0a,0x00,0x00,0x00,0x15,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x1c,0x00,0x04,0x00,
+    0x16,0x00,0x00,0x00,0x14,0x00,0x00,0x00,0x15,0x00,0x00,0x00,0x2b,0x00,0x04,0x00,
+    0x14,0x00,0x00,0x00,0x17,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x2b,0x00,0x04,0x00,
+    0x14,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x2b,0x00,0x04,0x00,
+    0x14,0x00,0x00,0x00,0x19,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x2b,0x00,0x04,0x00,
+    0x14,0x00,0x00,0x00,0x1a,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x2c,0x00,0x09,0x00,
+    0x16,0x00,0x00,0x00,0x1b,0x00,0x00,0x00,0x17,0x00,0x00,0x00,0x18,0x00,0x00,0x00,
+    0x19,0x00,0x00,0x00,0x19,0x00,0x00,0x00,0x1a,0x00,0x00,0x00,0x17,0x00,0x00,0x00,
+    0x20,0x00,0x04,0x00,0x1c,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x14,0x00,0x00,0x00,
+    0x3b,0x00,0x04,0x00,0x1c,0x00,0x00,0x00,0x1d,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
+    0x20,0x00,0x04,0x00,0x1f,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x16,0x00,0x00,0x00,
+    0x20,0x00,0x04,0x00,0x21,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x14,0x00,0x00,0x00,
+    0x20,0x00,0x04,0x00,0x24,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,
+    0x20,0x00,0x04,0x00,0x26,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x07,0x00,0x00,0x00,
+    0x17,0x00,0x04,0x00,0x2a,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
+    0x1c,0x00,0x04,0x00,0x2b,0x00,0x00,0x00,0x2a,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,
+    0x2c,0x00,0x06,0x00,0x2a,0x00,0x00,0x00,0x2c,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,
+    0x0d,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x2c,0x00,0x06,0x00,0x2a,0x00,0x00,0x00,
+    0x2d,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,
+    0x2c,0x00,0x06,0x00,0x2a,0x00,0x00,0x00,0x2e,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,
+    0x0f,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x2c,0x00,0x06,0x00,0x2a,0x00,0x00,0x00,
+    0x2f,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,
+    0x2c,0x00,0x07,0x00,0x2b,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x2c,0x00,0x00,0x00,
+    0x2d,0x00,0x00,0x00,0x2e,0x00,0x00,0x00,0x2f,0x00,0x00,0x00,0x20,0x00,0x04,0x00,
+    0x35,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x2b,0x00,0x00,0x00,0x20,0x00,0x04,0x00,
+    0x37,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x2a,0x00,0x00,0x00,0x17,0x00,0x04,0x00,
+    0x3b,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x20,0x00,0x04,0x00,
+    0x3c,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x3b,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,
+    0x3c,0x00,0x00,0x00,0x3d,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x1e,0x00,0x04,0x00,
+    0x44,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x20,0x00,0x04,0x00,
+    0x45,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x44,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,
+    0x45,0x00,0x00,0x00,0x46,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x20,0x00,0x04,0x00,
+    0x47,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x2b,0x00,0x04,0x00,
+    0x0a,0x00,0x00,0x00,0x4c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x04,0x00,
+    0x4d,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x2b,0x00,0x04,0x00,
+    0x0a,0x00,0x00,0x00,0x51,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x20,0x00,0x04,0x00,
+    0x58,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x2b,0x00,0x04,0x00,
+    0x06,0x00,0x00,0x00,0x5c,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x3b,0x00,0x04,0x00,
+    0x3c,0x00,0x00,0x00,0x5f,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x1c,0x00,0x04,0x00,
+    0x68,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x51,0x00,0x00,0x00,0x1e,0x00,0x06,0x00,
+    0x69,0x00,0x00,0x00,0x3b,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x68,0x00,0x00,0x00,
+    0x68,0x00,0x00,0x00,0x20,0x00,0x04,0x00,0x6a,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
+    0x69,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,0x6a,0x00,0x00,0x00,0x6b,0x00,0x00,0x00,
+    0x03,0x00,0x00,0x00,0x2b,0x00,0x04,0x00,0x0a,0x00,0x00,0x00,0x75,0x00,0x00,0x00,
+    0x02,0x00,0x00,0x00,0x20,0x00,0x04,0x00,0x7a,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
+    0x3b,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,0x7a,0x00,0x00,0x00,0x7c,0x00,0x00,0x00,
+    0x03,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,0x3c,0x00,0x00,0x00,0x7d,0x00,0x00,0x00,
+    0x01,0x00,0x00,0x00,0x20,0x00,0x04,0x00,0x7f,0x00,0x00,0x00,0x06,0x00,0x00,0x00,
+    0x2a,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,0x7f,0x00,0x00,0x00,0x80,0x00,0x00,0x00,
+    0x06,0x00,0x00,0x00,0x36,0x00,0x05,0x00,0x02,0x00,0x00,0x00,0x04,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0xf8,0x00,0x02,0x00,0x05,0x00,0x00,0x00,
+    0x3b,0x00,0x05,0x00,0x1f,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x07,0x00,0x00,0x00,
+    0x1b,0x00,0x00,0x00,0x3b,0x00,0x05,0x00,0x24,0x00,0x00,0x00,0x25,0x00,0x00,0x00,
+    0x07,0x00,0x00,0x00,0x13,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,0x26,0x00,0x00,0x00,
+    0x29,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x3b,0x00,0x05,0x00,0x1f,0x00,0x00,0x00,
+    0x32,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x1b,0x00,0x00,0x00,0x3b,0x00,0x05,0x00,
+    0x35,0x00,0x00,0x00,0x36,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x30,0x00,0x00,0x00,
+    0x3b,0x00,0x04,0x00,0x37,0x00,0x00,0x00,0x4b,0x00,0x00,0x00,0x07,0x00,0x00,0x00,
+    0x3b,0x00,0x04,0x00,0x26,0x00,0x00,0x00,0x55,0x00,0x00,0x00,0x07,0x00,0x00,0x00,
+    0x3b,0x00,0x05,0x00,0x1f,0x00,0x00,0x00,0x72,0x00,0x00,0x00,0x07,0x00,0x00,0x00,
+    0x1b,0x00,0x00,0x00,0x3b,0x00,0x05,0x00,0x35,0x00,0x00,0x00,0x76,0x00,0x00,0x00,
+    0x07,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x14,0x00,0x00,0x00,
+    0x1e,0x00,0x00,0x00,0x1d,0x00,0x00,0x00,0x41,0x00,0x05,0x00,0x21,0x00,0x00,0x00,
+    0x22,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,
+    0x14,0x00,0x00,0x00,0x23,0x00,0x00,0x00,0x22,0x00,0x00,0x00,0x41,0x00,0x05,0x00,
+    0x26,0x00,0x00,0x00,0x27,0x00,0x00,0x00,0x25,0x00,0x00,0x00,0x23,0x00,0x00,0x00,
+    0x3d,0x00,0x04,0x00,0x07,0x00,0x00,0x00,0x28,0x00,0x00,0x00,0x27,0x00,0x00,0x00,
+    0x3e,0x00,0x03,0x00,0x09,0x00,0x00,0x00,0x28,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,
+    0x14,0x00,0x00,0x00,0x31,0x00,0x00,0x00,0x1d,0x00,0x00,0x00,0x41,0x00,0x05,0x00,
+    0x21,0x00,0x00,0x00,0x33,0x00,0x00,0x00,0x32,0x00,0x00,0x00,0x31,0x00,0x00,0x00,
+    0x3d,0x00,0x04,0x00,0x14,0x00,0x00,0x00,0x34,0x00,0x00,0x00,0x33,0x00,0x00,0x00,
+    0x41,0x00,0x05,0x00,0x37,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x36,0x00,0x00,0x00,
+    0x34,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x2a,0x00,0x00,0x00,0x39,0x00,0x00,0x00,
+    0x38,0x00,0x00,0x00,0x4f,0x00,0x07,0x00,0x07,0x00,0x00,0x00,0x3a,0x00,0x00,0x00,
+    0x39,0x00,0x00,0x00,0x39,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
+    0x3d,0x00,0x04,0x00,0x3b,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x3d,0x00,0x00,0x00,
+    0x4f,0x00,0x07,0x00,0x07,0x00,0x00,0x00,0x3f,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,
+    0x3e,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x85,0x00,0x05,0x00,
+    0x07,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x3a,0x00,0x00,0x00,0x3f,0x00,0x00,0x00,
+    0x3d,0x00,0x04,0x00,0x3b,0x00,0x00,0x00,0x41,0x00,0x00,0x00,0x3d,0x00,0x00,0x00,
+    0x4f,0x00,0x07,0x00,0x07,0x00,0x00,0x00,0x42,0x00,0x00,0x00,0x41,0x00,0x00,0x00,
+    0x41,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x81,0x00,0x05,0x00,
+    0x07,0x00,0x00,0x00,0x43,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x42,0x00,0x00,0x00,
+    0x41,0x00,0x05,0x00,0x47,0x00,0x00,0x00,0x48,0x00,0x00,0x00,0x46,0x00,0x00,0x00,
+    0x18,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x06,0x00,0x00,0x00,0x49,0x00,0x00,0x00,
+    0x48,0x00,0x00,0x00,0x8e,0x00,0x05,0x00,0x07,0x00,0x00,0x00,0x4a,0x00,0x00,0x00,
+    0x43,0x00,0x00,0x00,0x49,0x00,0x00,0x00,0x3e,0x00,0x03,0x00,0x29,0x00,0x00,0x00,
+    0x4a,0x00,0x00,0x00,0x41,0x00,0x05,0x00,0x4d,0x00,0x00,0x00,0x4e,0x00,0x00,0x00,
+    0x29,0x00,0x00,0x00,0x4c,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x06,0x00,0x00,0x00,
+    0x4f,0x00,0x00,0x00,0x4e,0x00,0x00,0x00,0x41,0x00,0x05,0x00,0x4d,0x00,0x00,0x00,
+    0x50,0x00,0x00,0x00,0x4b,0x00,0x00,0x00,0x4c,0x00,0x00,0x00,0x3e,0x00,0x03,0x00,
+    0x50,0x00,0x00,0x00,0x4f,0x00,0x00,0x00,0x41,0x00,0x05,0x00,0x4d,0x00,0x00,0x00,
+    0x52,0x00,0x00,0x00,0x29,0x00,0x00,0x00,0x51,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,
+    0x06,0x00,0x00,0x00,0x53,0x00,0x00,0x00,0x52,0x00,0x00,0x00,0x41,0x00,0x05,0x00,
+    0x4d,0x00,0x00,0x00,0x54,0x00,0x00,0x00,0x4b,0x00,0x00,0x00,0x51,0x00,0x00,0x00,
+    0x3e,0x00,0x03,0x00,0x54,0x00,0x00,0x00,0x53,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,
+    0x2a,0x00,0x00,0x00,0x56,0x00,0x00,0x00,0x4b,0x00,0x00,0x00,0x4f,0x00,0x07,0x00,
+    0x07,0x00,0x00,0x00,0x57,0x00,0x00,0x00,0x56,0x00,0x00,0x00,0x56,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x41,0x00,0x05,0x00,0x58,0x00,0x00,0x00,
+    0x59,0x00,0x00,0x00,0x46,0x00,0x00,0x00,0x17,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,
+    0x07,0x00,0x00,0x00,0x5a,0x00,0x00,0x00,0x59,0x00,0x00,0x00,0x85,0x00,0x05,0x00,
+    0x07,0x00,0x00,0x00,0x5b,0x00,0x00,0x00,0x57,0x00,0x00,0x00,0x5a,0x00,0x00,0x00,
+    0x8e,0x00,0x05,0x00,0x07,0x00,0x00,0x00,0x5d,0x00,0x00,0x00,0x5b,0x00,0x00,0x00,
+    0x5c,0x00,0x00,0x00,0x83,0x00,0x05,0x00,0x07,0x00,0x00,0x00,0x5e,0x00,0x00,0x00,
+    0x5d,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x3e,0x00,0x03,0x00,0x55,0x00,0x00,0x00,
+    0x5e,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x3b,0x00,0x00,0x00,0x60,0x00,0x00,0x00,
+    0x5f,0x00,0x00,0x00,0x4f,0x00,0x07,0x00,0x07,0x00,0x00,0x00,0x61,0x00,0x00,0x00,
+    0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
+    0x3d,0x00,0x04,0x00,0x07,0x00,0x00,0x00,0x62,0x00,0x00,0x00,0x09,0x00,0x00,0x00,
+    0x85,0x00,0x05,0x00,0x07,0x00,0x00,0x00,0x63,0x00,0x00,0x00,0x62,0x00,0x00,0x00,
+    0x61,0x00,0x00,0x00,0x3e,0x00,0x03,0x00,0x09,0x00,0x00,0x00,0x63,0x00,0x00,0x00,
+    0x3d,0x00,0x04,0x00,0x3b,0x00,0x00,0x00,0x64,0x00,0x00,0x00,0x5f,0x00,0x00,0x00,
+    0x4f,0x00,0x07,0x00,0x07,0x00,0x00,0x00,0x65,0x00,0x00,0x00,0x64,0x00,0x00,0x00,
+    0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,
+    0x07,0x00,0x00,0x00,0x66,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x81,0x00,0x05,0x00,
+    0x07,0x00,0x00,0x00,0x67,0x00,0x00,0x00,0x66,0x00,0x00,0x00,0x65,0x00,0x00,0x00,
+    0x3e,0x00,0x03,0x00,0x09,0x00,0x00,0x00,0x67,0x00,0x00,0x00,0x41,0x00,0x05,0x00,
+    0x4d,0x00,0x00,0x00,0x6c,0x00,0x00,0x00,0x55,0x00,0x00,0x00,0x4c,0x00,0x00,0x00,
+    0x3d,0x00,0x04,0x00,0x06,0x00,0x00,0x00,0x6d,0x00,0x00,0x00,0x6c,0x00,0x00,0x00,
+    0x41,0x00,0x05,0x00,0x4d,0x00,0x00,0x00,0x6e,0x00,0x00,0x00,0x55,0x00,0x00,0x00,
+    0x51,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x06,0x00,0x00,0x00,0x6f,0x00,0x00,0x00,
+    0x6e,0x00,0x00,0x00,0x7f,0x00,0x04,0x00,0x06,0x00,0x00,0x00,0x70,0x00,0x00,0x00,
+    0x6f,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x14,0x00,0x00,0x00,0x71,0x00,0x00,0x00,
+    0x1d,0x00,0x00,0x00,0x41,0x00,0x05,0x00,0x21,0x00,0x00,0x00,0x73,0x00,0x00,0x00,
+    0x72,0x00,0x00,0x00,0x71,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x14,0x00,0x00,0x00,
+    0x74,0x00,0x00,0x00,0x73,0x00,0x00,0x00,0x41,0x00,0x06,0x00,0x4d,0x00,0x00,0x00,
+    0x77,0x00,0x00,0x00,0x76,0x00,0x00,0x00,0x74,0x00,0x00,0x00,0x75,0x00,0x00,0x00,
+    0x3d,0x00,0x04,0x00,0x06,0x00,0x00,0x00,0x78,0x00,0x00,0x00,0x77,0x00,0x00,0x00,
+    0x50,0x00,0x07,0x00,0x3b,0x00,0x00,0x00,0x79,0x00,0x00,0x00,0x6d,0x00,0x00,0x00,
+    0x70,0x00,0x00,0x00,0x78,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x41,0x00,0x05,0x00,
+    0x7a,0x00,0x00,0x00,0x7b,0x00,0x00,0x00,0x6b,0x00,0x00,0x00,0x17,0x00,0x00,0x00,
+    0x3e,0x00,0x03,0x00,0x7b,0x00,0x00,0x00,0x79,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,
+    0x3b,0x00,0x00,0x00,0x7e,0x00,0x00,0x00,0x7d,0x00,0x00,0x00,0x3e,0x00,0x03,0x00,
+    0x7c,0x00,0x00,0x00,0x7e,0x00,0x00,0x00,0xfd,0x00,0x01,0x00,0x38,0x00,0x01,0x00,
+
+};
+/*
+    #version 460
+
+    layout(set = 1, binding = 0) uniform texture2D tex;
+    layout(set = 1, binding = 32) uniform sampler smp;
+
+    layout(location = 0) in vec2 uv;
+    layout(location = 1) in vec4 batcher_fs_colour;
+    layout(location = 0) out vec4 frag_colour;
+
+    void main()
+    {
+        vec4 _24 = texture(sampler2D(tex, smp), uv);
+        vec4 _28 = _24 * batcher_fs_colour;
+        if (_28.w < 1.0)
+        {
+            discard;
+        }
+        frag_colour = _28;
+    }
+
+*/
+static const uint8_t batcher_fs_bytecode_spirv_vk[1088] = {
+    0x03,0x02,0x23,0x07,0x00,0x04,0x01,0x00,0x0b,0x00,0x08,0x00,0x2d,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x11,0x00,0x02,0x00,0x01,0x00,0x00,0x00,0x0b,0x00,0x06,0x00,
+    0x01,0x00,0x00,0x00,0x47,0x4c,0x53,0x4c,0x2e,0x73,0x74,0x64,0x2e,0x34,0x35,0x30,
+    0x00,0x00,0x00,0x00,0x0e,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
+    0x0f,0x00,0x0a,0x00,0x04,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x6d,0x61,0x69,0x6e,
+    0x00,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x16,0x00,0x00,0x00,
+    0x1c,0x00,0x00,0x00,0x2b,0x00,0x00,0x00,0x10,0x00,0x03,0x00,0x04,0x00,0x00,0x00,
+    0x07,0x00,0x00,0x00,0x03,0x00,0x03,0x00,0x02,0x00,0x00,0x00,0xcc,0x01,0x00,0x00,
+    0x05,0x00,0x04,0x00,0x04,0x00,0x00,0x00,0x6d,0x61,0x69,0x6e,0x00,0x00,0x00,0x00,
+    0x05,0x00,0x03,0x00,0x09,0x00,0x00,0x00,0x5f,0x32,0x34,0x00,0x05,0x00,0x03,0x00,
+    0x0c,0x00,0x00,0x00,0x74,0x65,0x78,0x00,0x05,0x00,0x03,0x00,0x10,0x00,0x00,0x00,
+    0x73,0x6d,0x70,0x00,0x05,0x00,0x03,0x00,0x16,0x00,0x00,0x00,0x75,0x76,0x00,0x00,
+    0x05,0x00,0x03,0x00,0x19,0x00,0x00,0x00,0x5f,0x32,0x38,0x00,0x05,0x00,0x05,0x00,
+    0x1c,0x00,0x00,0x00,0x66,0x73,0x5f,0x63,0x6f,0x6c,0x6f,0x75,0x72,0x00,0x00,0x00,
+    0x05,0x00,0x05,0x00,0x2b,0x00,0x00,0x00,0x66,0x72,0x61,0x67,0x5f,0x63,0x6f,0x6c,
+    0x6f,0x75,0x72,0x00,0x47,0x00,0x04,0x00,0x0c,0x00,0x00,0x00,0x21,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x0c,0x00,0x00,0x00,0x22,0x00,0x00,0x00,
+    0x01,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x10,0x00,0x00,0x00,0x21,0x00,0x00,0x00,
+    0x20,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x10,0x00,0x00,0x00,0x22,0x00,0x00,0x00,
+    0x01,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x16,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x1c,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,
+    0x01,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x2b,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x13,0x00,0x02,0x00,0x02,0x00,0x00,0x00,0x21,0x00,0x03,0x00,
+    0x03,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x16,0x00,0x03,0x00,0x06,0x00,0x00,0x00,
+    0x20,0x00,0x00,0x00,0x17,0x00,0x04,0x00,0x07,0x00,0x00,0x00,0x06,0x00,0x00,0x00,
+    0x04,0x00,0x00,0x00,0x20,0x00,0x04,0x00,0x08,0x00,0x00,0x00,0x07,0x00,0x00,0x00,
+    0x07,0x00,0x00,0x00,0x19,0x00,0x09,0x00,0x0a,0x00,0x00,0x00,0x06,0x00,0x00,0x00,
+    0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x04,0x00,0x0b,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,0x0b,0x00,0x00,0x00,
+    0x0c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1a,0x00,0x02,0x00,0x0e,0x00,0x00,0x00,
+    0x20,0x00,0x04,0x00,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,
+    0x3b,0x00,0x04,0x00,0x0f,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x1b,0x00,0x03,0x00,0x12,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x17,0x00,0x04,0x00,
+    0x14,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x20,0x00,0x04,0x00,
+    0x15,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x14,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,
+    0x15,0x00,0x00,0x00,0x16,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x20,0x00,0x04,0x00,
+    0x1b,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,
+    0x1b,0x00,0x00,0x00,0x1c,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x15,0x00,0x04,0x00,
+    0x1f,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x2b,0x00,0x04,0x00,
+    0x1f,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x20,0x00,0x04,0x00,
+    0x21,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x2b,0x00,0x04,0x00,
+    0x06,0x00,0x00,0x00,0x24,0x00,0x00,0x00,0x00,0x00,0x80,0x3f,0x14,0x00,0x02,0x00,
+    0x25,0x00,0x00,0x00,0x20,0x00,0x04,0x00,0x2a,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
+    0x07,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,0x2a,0x00,0x00,0x00,0x2b,0x00,0x00,0x00,
+    0x03,0x00,0x00,0x00,0x36,0x00,0x05,0x00,0x02,0x00,0x00,0x00,0x04,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0xf8,0x00,0x02,0x00,0x05,0x00,0x00,0x00,
+    0x3b,0x00,0x04,0x00,0x08,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x07,0x00,0x00,0x00,
+    0x3b,0x00,0x04,0x00,0x08,0x00,0x00,0x00,0x19,0x00,0x00,0x00,0x07,0x00,0x00,0x00,
+    0x3d,0x00,0x04,0x00,0x0a,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,
+    0x3d,0x00,0x04,0x00,0x0e,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x10,0x00,0x00,0x00,
+    0x56,0x00,0x05,0x00,0x12,0x00,0x00,0x00,0x13,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,
+    0x11,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x14,0x00,0x00,0x00,0x17,0x00,0x00,0x00,
+    0x16,0x00,0x00,0x00,0x57,0x00,0x05,0x00,0x07,0x00,0x00,0x00,0x18,0x00,0x00,0x00,
+    0x13,0x00,0x00,0x00,0x17,0x00,0x00,0x00,0x3e,0x00,0x03,0x00,0x09,0x00,0x00,0x00,
+    0x18,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x07,0x00,0x00,0x00,0x1a,0x00,0x00,0x00,
+    0x09,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x07,0x00,0x00,0x00,0x1d,0x00,0x00,0x00,
+    0x1c,0x00,0x00,0x00,0x85,0x00,0x05,0x00,0x07,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,
+    0x1a,0x00,0x00,0x00,0x1d,0x00,0x00,0x00,0x3e,0x00,0x03,0x00,0x19,0x00,0x00,0x00,
+    0x1e,0x00,0x00,0x00,0x41,0x00,0x05,0x00,0x21,0x00,0x00,0x00,0x22,0x00,0x00,0x00,
+    0x19,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x06,0x00,0x00,0x00,
+    0x23,0x00,0x00,0x00,0x22,0x00,0x00,0x00,0xb8,0x00,0x05,0x00,0x25,0x00,0x00,0x00,
+    0x26,0x00,0x00,0x00,0x23,0x00,0x00,0x00,0x24,0x00,0x00,0x00,0xf7,0x00,0x03,0x00,
+    0x28,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xfa,0x00,0x04,0x00,0x26,0x00,0x00,0x00,
+    0x27,0x00,0x00,0x00,0x28,0x00,0x00,0x00,0xf8,0x00,0x02,0x00,0x27,0x00,0x00,0x00,
+    0xfc,0x00,0x01,0x00,0xf8,0x00,0x02,0x00,0x28,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,
+    0x07,0x00,0x00,0x00,0x2c,0x00,0x00,0x00,0x19,0x00,0x00,0x00,0x3e,0x00,0x03,0x00,
+    0x2b,0x00,0x00,0x00,0x2c,0x00,0x00,0x00,0xfd,0x00,0x01,0x00,0x38,0x00,0x01,0x00,
+
+};
+static inline const sg_shader_desc* batcher_shader_desc(sg_backend backend) {
+    if (backend == SG_BACKEND_D3D11) {
+        static sg_shader_desc desc;
+        static bool valid;
+        if (!valid) {
+            valid = true;
+            desc.vertex_func.source = (const char*)batcher_vs_source_hlsl5;
+            desc.vertex_func.d3d11_target = "vs_5_0";
+            desc.vertex_func.entry = "main";
+            desc.fragment_func.source = (const char*)batcher_fs_source_hlsl5;
+            desc.fragment_func.d3d11_target = "ps_5_0";
+            desc.fragment_func.entry = "main";
+            desc.attrs[0].base_type = SG_SHADERATTRBASETYPE_FLOAT;
+            desc.attrs[0].hlsl_sem_name = "TEXCOORD";
+            desc.attrs[0].hlsl_sem_index = 0;
+            desc.attrs[1].base_type = SG_SHADERATTRBASETYPE_FLOAT;
+            desc.attrs[1].hlsl_sem_name = "TEXCOORD";
+            desc.attrs[1].hlsl_sem_index = 1;
+            desc.attrs[2].base_type = SG_SHADERATTRBASETYPE_FLOAT;
+            desc.attrs[2].hlsl_sem_name = "TEXCOORD";
+            desc.attrs[2].hlsl_sem_index = 2;
+            desc.uniform_blocks[0].stage = SG_SHADERSTAGE_VERTEX;
+            desc.uniform_blocks[0].layout = SG_UNIFORMLAYOUT_STD140;
+            desc.uniform_blocks[0].size = 16;
+            desc.uniform_blocks[0].hlsl_register_b_n = 0;
+            desc.views[0].texture.stage = SG_SHADERSTAGE_FRAGMENT;
+            desc.views[0].texture.image_type = SG_IMAGETYPE_2D;
+            desc.views[0].texture.sample_type = SG_IMAGESAMPLETYPE_FLOAT;
+            desc.views[0].texture.multisampled = false;
+            desc.views[0].texture.hlsl_register_t_n = 0;
+            desc.samplers[0].stage = SG_SHADERSTAGE_FRAGMENT;
+            desc.samplers[0].sampler_type = SG_SAMPLERTYPE_FILTERING;
+            desc.samplers[0].hlsl_register_s_n = 0;
+            desc.texture_sampler_pairs[0].stage = SG_SHADERSTAGE_FRAGMENT;
+            desc.texture_sampler_pairs[0].view_slot = 0;
+            desc.texture_sampler_pairs[0].sampler_slot = 0;
+            desc.label = "batcher_shader";
+        }
+        return &desc;
+    }
+    if (backend == SG_BACKEND_VULKAN) {
+        static sg_shader_desc desc;
+        static bool valid;
+        if (!valid) {
+            valid = true;
+            desc.vertex_func.bytecode.ptr = batcher_vs_bytecode_spirv_vk;
+            desc.vertex_func.bytecode.size = 3440;
+            desc.vertex_func.entry = "main";
+            desc.fragment_func.bytecode.ptr = batcher_fs_bytecode_spirv_vk;
+            desc.fragment_func.bytecode.size = 1088;
+            desc.fragment_func.entry = "main";
+            desc.attrs[0].base_type = SG_SHADERATTRBASETYPE_FLOAT;
+            desc.attrs[1].base_type = SG_SHADERATTRBASETYPE_FLOAT;
+            desc.attrs[2].base_type = SG_SHADERATTRBASETYPE_FLOAT;
+            desc.uniform_blocks[0].stage = SG_SHADERSTAGE_VERTEX;
+            desc.uniform_blocks[0].layout = SG_UNIFORMLAYOUT_STD140;
+            desc.uniform_blocks[0].size = 16;
+            desc.uniform_blocks[0].spirv_set0_binding_n = 0;
+            desc.views[0].texture.stage = SG_SHADERSTAGE_FRAGMENT;
+            desc.views[0].texture.image_type = SG_IMAGETYPE_2D;
+            desc.views[0].texture.sample_type = SG_IMAGESAMPLETYPE_FLOAT;
+            desc.views[0].texture.multisampled = false;
+            desc.views[0].texture.spirv_set1_binding_n = 0;
+            desc.samplers[0].stage = SG_SHADERSTAGE_FRAGMENT;
+            desc.samplers[0].sampler_type = SG_SAMPLERTYPE_FILTERING;
+            desc.samplers[0].spirv_set1_binding_n = 32;
+            desc.texture_sampler_pairs[0].stage = SG_SHADERSTAGE_FRAGMENT;
+            desc.texture_sampler_pairs[0].view_slot = 0;
+            desc.texture_sampler_pairs[0].sampler_slot = 0;
+            desc.label = "batcher_shader";
+        }
+        return &desc;
+    }
+    return 0;
+}
diff --git a/src/gen/obj.h b/src/gen/obj.h
index ea2c137..88a7558 100644
--- a/src/gen/obj.h
+++ b/src/gen/obj.h
@@ -19,14 +19,22 @@
             ATTR_obj_tex_uv => 2
             ATTR_obj_lightmap_uv => 3
     Bindings:
-        Uniform block 'vs_params':
-            C struct: vs_params_t
-            Bind slot: UB_vs_params => 0
+        Uniform block 'obj_vs_params':
+            C struct: obj_vs_params_t
+            Bind slot: UB_obj_vs_params => 0
+        Texture 'tex':
+            Image type: SG_IMAGETYPE_2D
+            Sample type: SG_IMAGESAMPLETYPE_FLOAT
+            Multisampled: false
+            Bind slot: VIEW_tex => 0
         Texture 'lightmap':
             Image type: SG_IMAGETYPE_2D
             Sample type: SG_IMAGESAMPLETYPE_FLOAT
             Multisampled: false
             Bind slot: VIEW_lightmap => 1
+        Sampler 'smp':
+            Type: SG_SAMPLERTYPE_FILTERING
+            Bind slot: SMP_smp => 0
         Sampler 'lightmap_smp':
             Type: SG_SAMPLERTYPE_FILTERING
             Bind slot: SMP_lightmap_smp => 1
@@ -45,18 +53,20 @@
 #define ATTR_obj_norm (1)
 #define ATTR_obj_tex_uv (2)
 #define ATTR_obj_lightmap_uv (3)
-#define UB_vs_params (0)
+#define UB_obj_vs_params (0)
+#define VIEW_tex (0)
 #define VIEW_lightmap (1)
+#define SMP_smp (0)
 #define SMP_lightmap_smp (1)
 #pragma pack(push,1)
-SOKOL_SHDC_ALIGN(16) typedef struct vs_params_t {
-    HMM_Mat4 mvp;
-    HMM_Vec3 cam_pos;
+SOKOL_SHDC_ALIGN(16) typedef struct obj_vs_params_t {
+    mat4 mvp;
+    vec3 cam_pos;
     uint8_t _pad_76[4];
-} vs_params_t;
+} obj_vs_params_t;
 #pragma pack(pop)
 /*
-    cbuffer vs_params : register(b0)
+    cbuffer obj_vs_params : register(b0)
     {
         row_major float4x4 _14_mvp : packoffset(c0);
         float3 _14_cam_pos : packoffset(c4);
@@ -66,11 +76,11 @@ SOKOL_SHDC_ALIGN(16) typedef struct vs_params_t {
     static float4 gl_Position;
     static float4 position;
     static float depth;
-    static float3 fs_norm;
+    static float3 obj_fs_norm;
     static float3 norm;
-    static float2 fs_tex_uv;
+    static float2 obj_fs_tex_uv;
     static float2 tex_uv;
-    static float2 fs_lightmap_uv;
+    static float2 obj_fs_lightmap_uv;
     static float2 lightmap_uv;
 
     struct SPIRV_Cross_Input
@@ -83,9 +93,9 @@ SOKOL_SHDC_ALIGN(16) typedef struct vs_params_t {
 
     struct SPIRV_Cross_Output
     {
-        float3 fs_norm : TEXCOORD0;
-        float2 fs_tex_uv : TEXCOORD1;
-        float2 fs_lightmap_uv : TEXCOORD2;
+        float3 obj_fs_norm : TEXCOORD0;
+        float2 obj_fs_tex_uv : TEXCOORD1;
+        float2 obj_fs_lightmap_uv : TEXCOORD2;
         float depth : TEXCOORD3;
         float4 gl_Position : SV_Position;
     };
@@ -95,9 +105,9 @@ SOKOL_SHDC_ALIGN(16) typedef struct vs_params_t {
         float4 _23 = mul(position, _14_mvp);
         depth = -_23.z;
         gl_Position = _23;
-        fs_norm = norm;
-        fs_tex_uv = tex_uv;
-        fs_lightmap_uv = lightmap_uv;
+        obj_fs_norm = norm;
+        obj_fs_tex_uv = tex_uv;
+        obj_fs_lightmap_uv = lightmap_uv;
     }
 
     SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input)
@@ -110,13 +120,13 @@ SOKOL_SHDC_ALIGN(16) typedef struct vs_params_t {
         SPIRV_Cross_Output stage_output;
         stage_output.gl_Position = gl_Position;
         stage_output.depth = depth;
-        stage_output.fs_norm = fs_norm;
-        stage_output.fs_tex_uv = fs_tex_uv;
-        stage_output.fs_lightmap_uv = fs_lightmap_uv;
+        stage_output.obj_fs_norm = obj_fs_norm;
+        stage_output.obj_fs_tex_uv = obj_fs_tex_uv;
+        stage_output.obj_fs_lightmap_uv = obj_fs_lightmap_uv;
         return stage_output;
     }
 */
-static const uint8_t vs_source_hlsl5[1380] = {
+static const uint8_t obj_vs_source_hlsl5[1380] = {
     0x63,0x62,0x75,0x66,0x66,0x65,0x72,0x20,0x76,0x73,0x5f,0x70,0x61,0x72,0x61,0x6d,
     0x73,0x20,0x3a,0x20,0x72,0x65,0x67,0x69,0x73,0x74,0x65,0x72,0x28,0x62,0x30,0x29,
     0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x72,0x6f,0x77,0x5f,0x6d,0x61,0x6a,0x6f,0x72,
@@ -206,20 +216,22 @@ static const uint8_t vs_source_hlsl5[1380] = {
     0x0a,0x7d,0x0a,0x00,
 };
 /*
+    Texture2D<float4> tex : register(t0);
+    SamplerState smp : register(s0);
     Texture2D<float4> lightmap : register(t1);
     SamplerState lightmap_smp : register(s1);
 
-    static float2 fs_tex_uv;
-    static float2 fs_lightmap_uv;
+    static float2 obj_fs_tex_uv;
+    static float2 obj_fs_lightmap_uv;
     static float4 frag_color;
-    static float3 fs_norm;
+    static float3 obj_fs_norm;
     static float depth;
 
     struct SPIRV_Cross_Input
     {
-        float3 fs_norm : TEXCOORD0;
-        float2 fs_tex_uv : TEXCOORD1;
-        float2 fs_lightmap_uv : TEXCOORD2;
+        float3 obj_fs_norm : TEXCOORD0;
+        float2 obj_fs_tex_uv : TEXCOORD1;
+        float2 obj_fs_lightmap_uv : TEXCOORD2;
         float depth : TEXCOORD3;
     };
 
@@ -230,14 +242,14 @@ static const uint8_t vs_source_hlsl5[1380] = {
 
     void frag_main()
     {
-        frag_color = lightmap.Sample(lightmap_smp, fs_lightmap_uv);
+        frag_color = tex.Sample(smp, obj_fs_tex_uv) * lightmap.Sample(lightmap_smp, obj_fs_lightmap_uv);
     }
 
     SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input)
     {
-        fs_tex_uv = stage_input.fs_tex_uv;
-        fs_lightmap_uv = stage_input.fs_lightmap_uv;
-        fs_norm = stage_input.fs_norm;
+        obj_fs_tex_uv = stage_input.obj_fs_tex_uv;
+        obj_fs_lightmap_uv = stage_input.obj_fs_lightmap_uv;
+        obj_fs_norm = stage_input.obj_fs_norm;
         depth = stage_input.depth;
         frag_main();
         SPIRV_Cross_Output stage_output;
@@ -245,67 +257,73 @@ static const uint8_t vs_source_hlsl5[1380] = {
         return stage_output;
     }
 */
-static const uint8_t fs_source_hlsl5[865] = {
+static const uint8_t obj_fs_source_hlsl5[965] = {
     0x54,0x65,0x78,0x74,0x75,0x72,0x65,0x32,0x44,0x3c,0x66,0x6c,0x6f,0x61,0x74,0x34,
-    0x3e,0x20,0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,0x20,0x3a,0x20,0x72,0x65,0x67,
-    0x69,0x73,0x74,0x65,0x72,0x28,0x74,0x31,0x29,0x3b,0x0a,0x53,0x61,0x6d,0x70,0x6c,
-    0x65,0x72,0x53,0x74,0x61,0x74,0x65,0x20,0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,
-    0x5f,0x73,0x6d,0x70,0x20,0x3a,0x20,0x72,0x65,0x67,0x69,0x73,0x74,0x65,0x72,0x28,
-    0x73,0x31,0x29,0x3b,0x0a,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,
-    0x61,0x74,0x32,0x20,0x66,0x73,0x5f,0x74,0x65,0x78,0x5f,0x75,0x76,0x3b,0x0a,0x73,
-    0x74,0x61,0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,0x61,0x74,0x32,0x20,0x66,0x73,0x5f,
-    0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,0x5f,0x75,0x76,0x3b,0x0a,0x73,0x74,0x61,
-    0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x66,0x72,0x61,0x67,0x5f,
-    0x63,0x6f,0x6c,0x6f,0x72,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x66,0x6c,
-    0x6f,0x61,0x74,0x33,0x20,0x66,0x73,0x5f,0x6e,0x6f,0x72,0x6d,0x3b,0x0a,0x73,0x74,
-    0x61,0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,0x61,0x74,0x20,0x64,0x65,0x70,0x74,0x68,
-    0x3b,0x0a,0x0a,0x73,0x74,0x72,0x75,0x63,0x74,0x20,0x53,0x50,0x49,0x52,0x56,0x5f,
-    0x43,0x72,0x6f,0x73,0x73,0x5f,0x49,0x6e,0x70,0x75,0x74,0x0a,0x7b,0x0a,0x20,0x20,
-    0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x33,0x20,0x66,0x73,0x5f,0x6e,0x6f,0x72,0x6d,
-    0x20,0x3a,0x20,0x54,0x45,0x58,0x43,0x4f,0x4f,0x52,0x44,0x30,0x3b,0x0a,0x20,0x20,
-    0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x32,0x20,0x66,0x73,0x5f,0x74,0x65,0x78,0x5f,
-    0x75,0x76,0x20,0x3a,0x20,0x54,0x45,0x58,0x43,0x4f,0x4f,0x52,0x44,0x31,0x3b,0x0a,
-    0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x32,0x20,0x66,0x73,0x5f,0x6c,0x69,
-    0x67,0x68,0x74,0x6d,0x61,0x70,0x5f,0x75,0x76,0x20,0x3a,0x20,0x54,0x45,0x58,0x43,
-    0x4f,0x4f,0x52,0x44,0x32,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,
-    0x20,0x64,0x65,0x70,0x74,0x68,0x20,0x3a,0x20,0x54,0x45,0x58,0x43,0x4f,0x4f,0x52,
-    0x44,0x33,0x3b,0x0a,0x7d,0x3b,0x0a,0x0a,0x73,0x74,0x72,0x75,0x63,0x74,0x20,0x53,
-    0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,0x5f,0x4f,0x75,0x74,0x70,0x75,
-    0x74,0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x66,
-    0x72,0x61,0x67,0x5f,0x63,0x6f,0x6c,0x6f,0x72,0x20,0x3a,0x20,0x53,0x56,0x5f,0x54,
-    0x61,0x72,0x67,0x65,0x74,0x30,0x3b,0x0a,0x7d,0x3b,0x0a,0x0a,0x76,0x6f,0x69,0x64,
-    0x20,0x66,0x72,0x61,0x67,0x5f,0x6d,0x61,0x69,0x6e,0x28,0x29,0x0a,0x7b,0x0a,0x20,
-    0x20,0x20,0x20,0x66,0x72,0x61,0x67,0x5f,0x63,0x6f,0x6c,0x6f,0x72,0x20,0x3d,0x20,
-    0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,0x2e,0x53,0x61,0x6d,0x70,0x6c,0x65,0x28,
-    0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,0x5f,0x73,0x6d,0x70,0x2c,0x20,0x66,0x73,
-    0x5f,0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,0x5f,0x75,0x76,0x29,0x3b,0x0a,0x7d,
-    0x0a,0x0a,0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,0x5f,0x4f,0x75,
-    0x74,0x70,0x75,0x74,0x20,0x6d,0x61,0x69,0x6e,0x28,0x53,0x50,0x49,0x52,0x56,0x5f,
-    0x43,0x72,0x6f,0x73,0x73,0x5f,0x49,0x6e,0x70,0x75,0x74,0x20,0x73,0x74,0x61,0x67,
-    0x65,0x5f,0x69,0x6e,0x70,0x75,0x74,0x29,0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x66,
-    0x73,0x5f,0x74,0x65,0x78,0x5f,0x75,0x76,0x20,0x3d,0x20,0x73,0x74,0x61,0x67,0x65,
-    0x5f,0x69,0x6e,0x70,0x75,0x74,0x2e,0x66,0x73,0x5f,0x74,0x65,0x78,0x5f,0x75,0x76,
-    0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x73,0x5f,0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,
-    0x70,0x5f,0x75,0x76,0x20,0x3d,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,0x70,
-    0x75,0x74,0x2e,0x66,0x73,0x5f,0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,0x5f,0x75,
-    0x76,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x73,0x5f,0x6e,0x6f,0x72,0x6d,0x20,0x3d,
-    0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,0x70,0x75,0x74,0x2e,0x66,0x73,0x5f,
-    0x6e,0x6f,0x72,0x6d,0x3b,0x0a,0x20,0x20,0x20,0x20,0x64,0x65,0x70,0x74,0x68,0x20,
-    0x3d,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,0x70,0x75,0x74,0x2e,0x64,0x65,
-    0x70,0x74,0x68,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x72,0x61,0x67,0x5f,0x6d,0x61,
-    0x69,0x6e,0x28,0x29,0x3b,0x0a,0x20,0x20,0x20,0x20,0x53,0x50,0x49,0x52,0x56,0x5f,
-    0x43,0x72,0x6f,0x73,0x73,0x5f,0x4f,0x75,0x74,0x70,0x75,0x74,0x20,0x73,0x74,0x61,
-    0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,0x3b,0x0a,0x20,0x20,0x20,0x20,0x73,
-    0x74,0x61,0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,0x2e,0x66,0x72,0x61,0x67,
-    0x5f,0x63,0x6f,0x6c,0x6f,0x72,0x20,0x3d,0x20,0x66,0x72,0x61,0x67,0x5f,0x63,0x6f,
-    0x6c,0x6f,0x72,0x3b,0x0a,0x20,0x20,0x20,0x20,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,
-    0x73,0x74,0x61,0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,0x3b,0x0a,0x7d,0x0a,
-    0x00,
+    0x3e,0x20,0x74,0x65,0x78,0x20,0x3a,0x20,0x72,0x65,0x67,0x69,0x73,0x74,0x65,0x72,
+    0x28,0x74,0x30,0x29,0x3b,0x0a,0x53,0x61,0x6d,0x70,0x6c,0x65,0x72,0x53,0x74,0x61,
+    0x74,0x65,0x20,0x73,0x6d,0x70,0x20,0x3a,0x20,0x72,0x65,0x67,0x69,0x73,0x74,0x65,
+    0x72,0x28,0x73,0x30,0x29,0x3b,0x0a,0x54,0x65,0x78,0x74,0x75,0x72,0x65,0x32,0x44,
+    0x3c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x3e,0x20,0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,
+    0x70,0x20,0x3a,0x20,0x72,0x65,0x67,0x69,0x73,0x74,0x65,0x72,0x28,0x74,0x31,0x29,
+    0x3b,0x0a,0x53,0x61,0x6d,0x70,0x6c,0x65,0x72,0x53,0x74,0x61,0x74,0x65,0x20,0x6c,
+    0x69,0x67,0x68,0x74,0x6d,0x61,0x70,0x5f,0x73,0x6d,0x70,0x20,0x3a,0x20,0x72,0x65,
+    0x67,0x69,0x73,0x74,0x65,0x72,0x28,0x73,0x31,0x29,0x3b,0x0a,0x0a,0x73,0x74,0x61,
+    0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,0x61,0x74,0x32,0x20,0x66,0x73,0x5f,0x74,0x65,
+    0x78,0x5f,0x75,0x76,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,
+    0x61,0x74,0x32,0x20,0x66,0x73,0x5f,0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,0x5f,
+    0x75,0x76,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,0x61,0x74,
+    0x34,0x20,0x66,0x72,0x61,0x67,0x5f,0x63,0x6f,0x6c,0x6f,0x72,0x3b,0x0a,0x73,0x74,
+    0x61,0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,0x61,0x74,0x33,0x20,0x66,0x73,0x5f,0x6e,
+    0x6f,0x72,0x6d,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,0x61,
+    0x74,0x20,0x64,0x65,0x70,0x74,0x68,0x3b,0x0a,0x0a,0x73,0x74,0x72,0x75,0x63,0x74,
+    0x20,0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,0x5f,0x49,0x6e,0x70,
+    0x75,0x74,0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x33,0x20,
+    0x66,0x73,0x5f,0x6e,0x6f,0x72,0x6d,0x20,0x3a,0x20,0x54,0x45,0x58,0x43,0x4f,0x4f,
+    0x52,0x44,0x30,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x32,0x20,
+    0x66,0x73,0x5f,0x74,0x65,0x78,0x5f,0x75,0x76,0x20,0x3a,0x20,0x54,0x45,0x58,0x43,
+    0x4f,0x4f,0x52,0x44,0x31,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,
+    0x32,0x20,0x66,0x73,0x5f,0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,0x5f,0x75,0x76,
+    0x20,0x3a,0x20,0x54,0x45,0x58,0x43,0x4f,0x4f,0x52,0x44,0x32,0x3b,0x0a,0x20,0x20,
+    0x20,0x20,0x66,0x6c,0x6f,0x61,0x74,0x20,0x64,0x65,0x70,0x74,0x68,0x20,0x3a,0x20,
+    0x54,0x45,0x58,0x43,0x4f,0x4f,0x52,0x44,0x33,0x3b,0x0a,0x7d,0x3b,0x0a,0x0a,0x73,
+    0x74,0x72,0x75,0x63,0x74,0x20,0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,
+    0x73,0x5f,0x4f,0x75,0x74,0x70,0x75,0x74,0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x66,
+    0x6c,0x6f,0x61,0x74,0x34,0x20,0x66,0x72,0x61,0x67,0x5f,0x63,0x6f,0x6c,0x6f,0x72,
+    0x20,0x3a,0x20,0x53,0x56,0x5f,0x54,0x61,0x72,0x67,0x65,0x74,0x30,0x3b,0x0a,0x7d,
+    0x3b,0x0a,0x0a,0x76,0x6f,0x69,0x64,0x20,0x66,0x72,0x61,0x67,0x5f,0x6d,0x61,0x69,
+    0x6e,0x28,0x29,0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x66,0x72,0x61,0x67,0x5f,0x63,
+    0x6f,0x6c,0x6f,0x72,0x20,0x3d,0x20,0x74,0x65,0x78,0x2e,0x53,0x61,0x6d,0x70,0x6c,
+    0x65,0x28,0x73,0x6d,0x70,0x2c,0x20,0x66,0x73,0x5f,0x74,0x65,0x78,0x5f,0x75,0x76,
+    0x29,0x20,0x2a,0x20,0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,0x2e,0x53,0x61,0x6d,
+    0x70,0x6c,0x65,0x28,0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,0x5f,0x73,0x6d,0x70,
+    0x2c,0x20,0x66,0x73,0x5f,0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,0x5f,0x75,0x76,
+    0x29,0x3b,0x0a,0x7d,0x0a,0x0a,0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,
+    0x73,0x5f,0x4f,0x75,0x74,0x70,0x75,0x74,0x20,0x6d,0x61,0x69,0x6e,0x28,0x53,0x50,
+    0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,0x5f,0x49,0x6e,0x70,0x75,0x74,0x20,
+    0x73,0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,0x70,0x75,0x74,0x29,0x0a,0x7b,0x0a,0x20,
+    0x20,0x20,0x20,0x66,0x73,0x5f,0x74,0x65,0x78,0x5f,0x75,0x76,0x20,0x3d,0x20,0x73,
+    0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,0x70,0x75,0x74,0x2e,0x66,0x73,0x5f,0x74,0x65,
+    0x78,0x5f,0x75,0x76,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x73,0x5f,0x6c,0x69,0x67,
+    0x68,0x74,0x6d,0x61,0x70,0x5f,0x75,0x76,0x20,0x3d,0x20,0x73,0x74,0x61,0x67,0x65,
+    0x5f,0x69,0x6e,0x70,0x75,0x74,0x2e,0x66,0x73,0x5f,0x6c,0x69,0x67,0x68,0x74,0x6d,
+    0x61,0x70,0x5f,0x75,0x76,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x73,0x5f,0x6e,0x6f,
+    0x72,0x6d,0x20,0x3d,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,0x70,0x75,0x74,
+    0x2e,0x66,0x73,0x5f,0x6e,0x6f,0x72,0x6d,0x3b,0x0a,0x20,0x20,0x20,0x20,0x64,0x65,
+    0x70,0x74,0x68,0x20,0x3d,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,0x70,0x75,
+    0x74,0x2e,0x64,0x65,0x70,0x74,0x68,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x72,0x61,
+    0x67,0x5f,0x6d,0x61,0x69,0x6e,0x28,0x29,0x3b,0x0a,0x20,0x20,0x20,0x20,0x53,0x50,
+    0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,0x5f,0x4f,0x75,0x74,0x70,0x75,0x74,
+    0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,0x3b,0x0a,0x20,
+    0x20,0x20,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,0x2e,
+    0x66,0x72,0x61,0x67,0x5f,0x63,0x6f,0x6c,0x6f,0x72,0x20,0x3d,0x20,0x66,0x72,0x61,
+    0x67,0x5f,0x63,0x6f,0x6c,0x6f,0x72,0x3b,0x0a,0x20,0x20,0x20,0x20,0x72,0x65,0x74,
+    0x75,0x72,0x6e,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,
+    0x3b,0x0a,0x7d,0x0a,0x00,
 };
 /*
     #version 460
 
-    layout(set = 0, binding = 0, std140) uniform vs_params
+    layout(set = 0, binding = 0, std140) uniform obj_vs_params
     {
         mat4 mvp;
         vec3 cam_pos;
@@ -313,11 +331,11 @@ static const uint8_t fs_source_hlsl5[865] = {
 
     layout(location = 0) in vec4 position;
     layout(location = 3) out float depth;
-    layout(location = 0) out vec3 fs_norm;
+    layout(location = 0) out vec3 obj_fs_norm;
     layout(location = 1) in vec3 norm;
-    layout(location = 1) out vec2 fs_tex_uv;
+    layout(location = 1) out vec2 obj_fs_tex_uv;
     layout(location = 2) in vec2 tex_uv;
-    layout(location = 2) out vec2 fs_lightmap_uv;
+    layout(location = 2) out vec2 obj_fs_lightmap_uv;
     layout(location = 3) in vec2 lightmap_uv;
 
     void main()
@@ -325,13 +343,13 @@ static const uint8_t fs_source_hlsl5[865] = {
         vec4 _23 = _14.mvp * position;
         depth = -_23.z;
         gl_Position = _23;
-        fs_norm = norm;
-        fs_tex_uv = tex_uv;
-        fs_lightmap_uv = lightmap_uv;
+        obj_fs_norm = norm;
+        obj_fs_tex_uv = tex_uv;
+        obj_fs_lightmap_uv = lightmap_uv;
     }
 
 */
-static const uint8_t vs_bytecode_spirv_vk[1780] = {
+static const uint8_t obj_vs_bytecode_spirv_vk[1780] = {
     0x03,0x02,0x23,0x07,0x00,0x04,0x01,0x00,0x0b,0x00,0x08,0x00,0x36,0x00,0x00,0x00,
     0x00,0x00,0x00,0x00,0x11,0x00,0x02,0x00,0x01,0x00,0x00,0x00,0x0b,0x00,0x06,0x00,
     0x01,0x00,0x00,0x00,0x47,0x4c,0x53,0x4c,0x2e,0x73,0x74,0x64,0x2e,0x34,0x35,0x30,
@@ -448,49 +466,57 @@ static const uint8_t vs_bytecode_spirv_vk[1780] = {
 /*
     #version 460
 
+    layout(set = 1, binding = 0) uniform texture2D tex;
+    layout(set = 1, binding = 32) uniform sampler smp;
     layout(set = 1, binding = 1) uniform texture2D lightmap;
     layout(set = 1, binding = 33) uniform sampler lightmap_smp;
 
-    layout(location = 1) in vec2 fs_tex_uv;
-    layout(location = 2) in vec2 fs_lightmap_uv;
+    layout(location = 1) in vec2 obj_fs_tex_uv;
+    layout(location = 2) in vec2 obj_fs_lightmap_uv;
     layout(location = 0) out vec4 frag_color;
-    layout(location = 0) in vec3 fs_norm;
+    layout(location = 0) in vec3 obj_fs_norm;
     layout(location = 3) in float depth;
 
     void main()
     {
-        frag_color = texture(sampler2D(lightmap, lightmap_smp), fs_lightmap_uv);
+        frag_color = texture(sampler2D(tex, smp), obj_fs_tex_uv) * texture(sampler2D(lightmap, lightmap_smp), obj_fs_lightmap_uv);
     }
 
 */
-static const uint8_t fs_bytecode_spirv_vk[916] = {
-    0x03,0x02,0x23,0x07,0x00,0x04,0x01,0x00,0x0b,0x00,0x08,0x00,0x1f,0x00,0x00,0x00,
+static const uint8_t obj_fs_bytecode_spirv_vk[1152] = {
+    0x03,0x02,0x23,0x07,0x00,0x04,0x01,0x00,0x0b,0x00,0x08,0x00,0x27,0x00,0x00,0x00,
     0x00,0x00,0x00,0x00,0x11,0x00,0x02,0x00,0x01,0x00,0x00,0x00,0x0b,0x00,0x06,0x00,
     0x01,0x00,0x00,0x00,0x47,0x4c,0x53,0x4c,0x2e,0x73,0x74,0x64,0x2e,0x34,0x35,0x30,
     0x00,0x00,0x00,0x00,0x0e,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
-    0x0f,0x00,0x0c,0x00,0x04,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x6d,0x61,0x69,0x6e,
+    0x0f,0x00,0x0e,0x00,0x04,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x6d,0x61,0x69,0x6e,
     0x00,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x10,0x00,0x00,0x00,
-    0x16,0x00,0x00,0x00,0x19,0x00,0x00,0x00,0x1c,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,
-    0x10,0x00,0x03,0x00,0x04,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x03,0x00,0x03,0x00,
-    0x02,0x00,0x00,0x00,0xcc,0x01,0x00,0x00,0x05,0x00,0x04,0x00,0x04,0x00,0x00,0x00,
-    0x6d,0x61,0x69,0x6e,0x00,0x00,0x00,0x00,0x05,0x00,0x05,0x00,0x09,0x00,0x00,0x00,
-    0x66,0x72,0x61,0x67,0x5f,0x63,0x6f,0x6c,0x6f,0x72,0x00,0x00,0x05,0x00,0x05,0x00,
-    0x0c,0x00,0x00,0x00,0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,0x00,0x00,0x00,0x00,
-    0x05,0x00,0x06,0x00,0x10,0x00,0x00,0x00,0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,
-    0x5f,0x73,0x6d,0x70,0x00,0x00,0x00,0x00,0x05,0x00,0x06,0x00,0x16,0x00,0x00,0x00,
-    0x66,0x73,0x5f,0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,0x5f,0x75,0x76,0x00,0x00,
-    0x05,0x00,0x05,0x00,0x19,0x00,0x00,0x00,0x66,0x73,0x5f,0x74,0x65,0x78,0x5f,0x75,
-    0x76,0x00,0x00,0x00,0x05,0x00,0x04,0x00,0x1c,0x00,0x00,0x00,0x66,0x73,0x5f,0x6e,
-    0x6f,0x72,0x6d,0x00,0x05,0x00,0x04,0x00,0x1e,0x00,0x00,0x00,0x64,0x65,0x70,0x74,
+    0x16,0x00,0x00,0x00,0x19,0x00,0x00,0x00,0x1b,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,
+    0x24,0x00,0x00,0x00,0x26,0x00,0x00,0x00,0x10,0x00,0x03,0x00,0x04,0x00,0x00,0x00,
+    0x07,0x00,0x00,0x00,0x03,0x00,0x03,0x00,0x02,0x00,0x00,0x00,0xcc,0x01,0x00,0x00,
+    0x05,0x00,0x04,0x00,0x04,0x00,0x00,0x00,0x6d,0x61,0x69,0x6e,0x00,0x00,0x00,0x00,
+    0x05,0x00,0x05,0x00,0x09,0x00,0x00,0x00,0x66,0x72,0x61,0x67,0x5f,0x63,0x6f,0x6c,
+    0x6f,0x72,0x00,0x00,0x05,0x00,0x03,0x00,0x0c,0x00,0x00,0x00,0x74,0x65,0x78,0x00,
+    0x05,0x00,0x03,0x00,0x10,0x00,0x00,0x00,0x73,0x6d,0x70,0x00,0x05,0x00,0x05,0x00,
+    0x16,0x00,0x00,0x00,0x66,0x73,0x5f,0x74,0x65,0x78,0x5f,0x75,0x76,0x00,0x00,0x00,
+    0x05,0x00,0x05,0x00,0x19,0x00,0x00,0x00,0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,
+    0x00,0x00,0x00,0x00,0x05,0x00,0x06,0x00,0x1b,0x00,0x00,0x00,0x6c,0x69,0x67,0x68,
+    0x74,0x6d,0x61,0x70,0x5f,0x73,0x6d,0x70,0x00,0x00,0x00,0x00,0x05,0x00,0x06,0x00,
+    0x1e,0x00,0x00,0x00,0x66,0x73,0x5f,0x6c,0x69,0x67,0x68,0x74,0x6d,0x61,0x70,0x5f,
+    0x75,0x76,0x00,0x00,0x05,0x00,0x04,0x00,0x24,0x00,0x00,0x00,0x66,0x73,0x5f,0x6e,
+    0x6f,0x72,0x6d,0x00,0x05,0x00,0x04,0x00,0x26,0x00,0x00,0x00,0x64,0x65,0x70,0x74,
     0x68,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x09,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,
     0x00,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x0c,0x00,0x00,0x00,0x21,0x00,0x00,0x00,
-    0x01,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x0c,0x00,0x00,0x00,0x22,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x0c,0x00,0x00,0x00,0x22,0x00,0x00,0x00,
     0x01,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x10,0x00,0x00,0x00,0x21,0x00,0x00,0x00,
-    0x21,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x10,0x00,0x00,0x00,0x22,0x00,0x00,0x00,
+    0x20,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x10,0x00,0x00,0x00,0x22,0x00,0x00,0x00,
     0x01,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x16,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,
-    0x02,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x19,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,
-    0x01,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x1c,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,
-    0x00,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x1e,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,
+    0x01,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x19,0x00,0x00,0x00,0x21,0x00,0x00,0x00,
+    0x01,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x19,0x00,0x00,0x00,0x22,0x00,0x00,0x00,
+    0x01,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x1b,0x00,0x00,0x00,0x21,0x00,0x00,0x00,
+    0x21,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x1b,0x00,0x00,0x00,0x22,0x00,0x00,0x00,
+    0x01,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x1e,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,
+    0x02,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x24,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x26,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,
     0x03,0x00,0x00,0x00,0x13,0x00,0x02,0x00,0x02,0x00,0x00,0x00,0x21,0x00,0x03,0x00,
     0x03,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x16,0x00,0x03,0x00,0x06,0x00,0x00,0x00,
     0x20,0x00,0x00,0x00,0x17,0x00,0x04,0x00,0x07,0x00,0x00,0x00,0x06,0x00,0x00,0x00,
@@ -507,12 +533,14 @@ static const uint8_t fs_bytecode_spirv_vk[916] = {
     0x14,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x20,0x00,0x04,0x00,
     0x15,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x14,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,
     0x15,0x00,0x00,0x00,0x16,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,
-    0x15,0x00,0x00,0x00,0x19,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x17,0x00,0x04,0x00,
-    0x1a,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x20,0x00,0x04,0x00,
-    0x1b,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x1a,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,
-    0x1b,0x00,0x00,0x00,0x1c,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x20,0x00,0x04,0x00,
-    0x1d,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,
-    0x1d,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x36,0x00,0x05,0x00,
+    0x0b,0x00,0x00,0x00,0x19,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,
+    0x0f,0x00,0x00,0x00,0x1b,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,
+    0x15,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x17,0x00,0x04,0x00,
+    0x22,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x20,0x00,0x04,0x00,
+    0x23,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x22,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,
+    0x23,0x00,0x00,0x00,0x24,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x20,0x00,0x04,0x00,
+    0x25,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,
+    0x25,0x00,0x00,0x00,0x26,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x36,0x00,0x05,0x00,
     0x02,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
     0xf8,0x00,0x02,0x00,0x05,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x0a,0x00,0x00,0x00,
     0x0d,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x0e,0x00,0x00,0x00,
@@ -520,8 +548,15 @@ static const uint8_t fs_bytecode_spirv_vk[916] = {
     0x13,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,
     0x14,0x00,0x00,0x00,0x17,0x00,0x00,0x00,0x16,0x00,0x00,0x00,0x57,0x00,0x05,0x00,
     0x07,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x13,0x00,0x00,0x00,0x17,0x00,0x00,0x00,
-    0x3e,0x00,0x03,0x00,0x09,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0xfd,0x00,0x01,0x00,
-    0x38,0x00,0x01,0x00,
+    0x3d,0x00,0x04,0x00,0x0a,0x00,0x00,0x00,0x1a,0x00,0x00,0x00,0x19,0x00,0x00,0x00,
+    0x3d,0x00,0x04,0x00,0x0e,0x00,0x00,0x00,0x1c,0x00,0x00,0x00,0x1b,0x00,0x00,0x00,
+    0x56,0x00,0x05,0x00,0x12,0x00,0x00,0x00,0x1d,0x00,0x00,0x00,0x1a,0x00,0x00,0x00,
+    0x1c,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x14,0x00,0x00,0x00,0x1f,0x00,0x00,0x00,
+    0x1e,0x00,0x00,0x00,0x57,0x00,0x05,0x00,0x07,0x00,0x00,0x00,0x20,0x00,0x00,0x00,
+    0x1d,0x00,0x00,0x00,0x1f,0x00,0x00,0x00,0x85,0x00,0x05,0x00,0x07,0x00,0x00,0x00,
+    0x21,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x3e,0x00,0x03,0x00,
+    0x09,0x00,0x00,0x00,0x21,0x00,0x00,0x00,0xfd,0x00,0x01,0x00,0x38,0x00,0x01,0x00,
+
 };
 static inline const sg_shader_desc* obj_shader_desc(sg_backend backend) {
     if (backend == SG_BACKEND_D3D11) {
@@ -529,10 +564,10 @@ static inline const sg_shader_desc* obj_shader_desc(sg_backend backend) {
         static bool valid;
         if (!valid) {
             valid = true;
-            desc.vertex_func.source = (const char*)vs_source_hlsl5;
+            desc.vertex_func.source = (const char*)obj_vs_source_hlsl5;
             desc.vertex_func.d3d11_target = "vs_5_0";
             desc.vertex_func.entry = "main";
-            desc.fragment_func.source = (const char*)fs_source_hlsl5;
+            desc.fragment_func.source = (const char*)obj_fs_source_hlsl5;
             desc.fragment_func.d3d11_target = "ps_5_0";
             desc.fragment_func.entry = "main";
             desc.attrs[0].base_type = SG_SHADERATTRBASETYPE_FLOAT;
@@ -551,17 +586,28 @@ static inline const sg_shader_desc* obj_shader_desc(sg_backend backend) {
             desc.uniform_blocks[0].layout = SG_UNIFORMLAYOUT_STD140;
             desc.uniform_blocks[0].size = 80;
             desc.uniform_blocks[0].hlsl_register_b_n = 0;
+            desc.views[0].texture.stage = SG_SHADERSTAGE_FRAGMENT;
+            desc.views[0].texture.image_type = SG_IMAGETYPE_2D;
+            desc.views[0].texture.sample_type = SG_IMAGESAMPLETYPE_FLOAT;
+            desc.views[0].texture.multisampled = false;
+            desc.views[0].texture.hlsl_register_t_n = 0;
             desc.views[1].texture.stage = SG_SHADERSTAGE_FRAGMENT;
             desc.views[1].texture.image_type = SG_IMAGETYPE_2D;
             desc.views[1].texture.sample_type = SG_IMAGESAMPLETYPE_FLOAT;
             desc.views[1].texture.multisampled = false;
             desc.views[1].texture.hlsl_register_t_n = 1;
+            desc.samplers[0].stage = SG_SHADERSTAGE_FRAGMENT;
+            desc.samplers[0].sampler_type = SG_SAMPLERTYPE_FILTERING;
+            desc.samplers[0].hlsl_register_s_n = 0;
             desc.samplers[1].stage = SG_SHADERSTAGE_FRAGMENT;
             desc.samplers[1].sampler_type = SG_SAMPLERTYPE_FILTERING;
             desc.samplers[1].hlsl_register_s_n = 1;
             desc.texture_sampler_pairs[0].stage = SG_SHADERSTAGE_FRAGMENT;
-            desc.texture_sampler_pairs[0].view_slot = 1;
-            desc.texture_sampler_pairs[0].sampler_slot = 1;
+            desc.texture_sampler_pairs[0].view_slot = 0;
+            desc.texture_sampler_pairs[0].sampler_slot = 0;
+            desc.texture_sampler_pairs[1].stage = SG_SHADERSTAGE_FRAGMENT;
+            desc.texture_sampler_pairs[1].view_slot = 1;
+            desc.texture_sampler_pairs[1].sampler_slot = 1;
             desc.label = "obj_shader";
         }
         return &desc;
@@ -571,11 +617,11 @@ static inline const sg_shader_desc* obj_shader_desc(sg_backend backend) {
         static bool valid;
         if (!valid) {
             valid = true;
-            desc.vertex_func.bytecode.ptr = vs_bytecode_spirv_vk;
+            desc.vertex_func.bytecode.ptr = obj_vs_bytecode_spirv_vk;
             desc.vertex_func.bytecode.size = 1780;
             desc.vertex_func.entry = "main";
-            desc.fragment_func.bytecode.ptr = fs_bytecode_spirv_vk;
-            desc.fragment_func.bytecode.size = 916;
+            desc.fragment_func.bytecode.ptr = obj_fs_bytecode_spirv_vk;
+            desc.fragment_func.bytecode.size = 1152;
             desc.fragment_func.entry = "main";
             desc.attrs[0].base_type = SG_SHADERATTRBASETYPE_FLOAT;
             desc.attrs[1].base_type = SG_SHADERATTRBASETYPE_FLOAT;
@@ -585,17 +631,28 @@ static inline const sg_shader_desc* obj_shader_desc(sg_backend backend) {
             desc.uniform_blocks[0].layout = SG_UNIFORMLAYOUT_STD140;
             desc.uniform_blocks[0].size = 80;
             desc.uniform_blocks[0].spirv_set0_binding_n = 0;
+            desc.views[0].texture.stage = SG_SHADERSTAGE_FRAGMENT;
+            desc.views[0].texture.image_type = SG_IMAGETYPE_2D;
+            desc.views[0].texture.sample_type = SG_IMAGESAMPLETYPE_FLOAT;
+            desc.views[0].texture.multisampled = false;
+            desc.views[0].texture.spirv_set1_binding_n = 0;
             desc.views[1].texture.stage = SG_SHADERSTAGE_FRAGMENT;
             desc.views[1].texture.image_type = SG_IMAGETYPE_2D;
             desc.views[1].texture.sample_type = SG_IMAGESAMPLETYPE_FLOAT;
             desc.views[1].texture.multisampled = false;
             desc.views[1].texture.spirv_set1_binding_n = 1;
+            desc.samplers[0].stage = SG_SHADERSTAGE_FRAGMENT;
+            desc.samplers[0].sampler_type = SG_SAMPLERTYPE_FILTERING;
+            desc.samplers[0].spirv_set1_binding_n = 32;
             desc.samplers[1].stage = SG_SHADERSTAGE_FRAGMENT;
             desc.samplers[1].sampler_type = SG_SAMPLERTYPE_FILTERING;
             desc.samplers[1].spirv_set1_binding_n = 33;
             desc.texture_sampler_pairs[0].stage = SG_SHADERSTAGE_FRAGMENT;
-            desc.texture_sampler_pairs[0].view_slot = 1;
-            desc.texture_sampler_pairs[0].sampler_slot = 1;
+            desc.texture_sampler_pairs[0].view_slot = 0;
+            desc.texture_sampler_pairs[0].sampler_slot = 0;
+            desc.texture_sampler_pairs[1].stage = SG_SHADERSTAGE_FRAGMENT;
+            desc.texture_sampler_pairs[1].view_slot = 1;
+            desc.texture_sampler_pairs[1].sampler_slot = 1;
             desc.label = "obj_shader";
         }
         return &desc;
diff --git a/src/gen/triangle.h b/src/gen/triangle.h
deleted file mode 100644
index 5c07531..0000000
--- a/src/gen/triangle.h
+++ /dev/null
@@ -1,316 +0,0 @@
-#pragma once
-/*
-    #version:1# (machine generated, don't edit!)
-
-    Generated by sokol-shdc (https://github.com/floooh/sokol-tools)
-
-    Cmdline:
-        sokol-shdc -i data\triangle.glsl -o src/gen/triangle.h -l hlsl5:spirv_vk -f sokol
-
-    Overview:
-    =========
-    Shader program: 'triangle':
-        Get shader desc: triangle_shader_desc(sg_query_backend());
-        Vertex Shader: vs
-        Fragment Shader: fs
-        Attributes:
-            ATTR_triangle_position => 0
-            ATTR_triangle_color0 => 1
-    Bindings:
-*/
-#if !defined(SOKOL_GFX_INCLUDED)
-#error "Please include sokol_gfx.h before triangle.h"
-#endif
-#if !defined(SOKOL_SHDC_ALIGN)
-#if defined(_MSC_VER)
-#define SOKOL_SHDC_ALIGN(a) __declspec(align(a))
-#else
-#define SOKOL_SHDC_ALIGN(a) __attribute__((aligned(a)))
-#endif
-#endif
-#define ATTR_triangle_position (0)
-#define ATTR_triangle_color0 (1)
-/*
-    static float4 gl_Position;
-    static float4 position;
-    static float4 color;
-    static float4 color0;
-
-    struct SPIRV_Cross_Input
-    {
-        float4 position : TEXCOORD0;
-        float4 color0 : TEXCOORD1;
-    };
-
-    struct SPIRV_Cross_Output
-    {
-        float4 color : TEXCOORD0;
-        float4 gl_Position : SV_Position;
-    };
-
-    void vert_main()
-    {
-        gl_Position = position;
-        color = color0;
-    }
-
-    SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input)
-    {
-        position = stage_input.position;
-        color0 = stage_input.color0;
-        vert_main();
-        SPIRV_Cross_Output stage_output;
-        stage_output.gl_Position = gl_Position;
-        stage_output.color = color;
-        return stage_output;
-    }
-*/
-static const uint8_t vs_source_hlsl5[645] = {
-    0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x67,0x6c,
-    0x5f,0x50,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,
-    0x63,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x70,0x6f,0x73,0x69,0x74,0x69,0x6f,
-    0x6e,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,
-    0x20,0x63,0x6f,0x6c,0x6f,0x72,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x66,
-    0x6c,0x6f,0x61,0x74,0x34,0x20,0x63,0x6f,0x6c,0x6f,0x72,0x30,0x3b,0x0a,0x0a,0x73,
-    0x74,0x72,0x75,0x63,0x74,0x20,0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,
-    0x73,0x5f,0x49,0x6e,0x70,0x75,0x74,0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,
-    0x6f,0x61,0x74,0x34,0x20,0x70,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x20,0x3a,0x20,
-    0x54,0x45,0x58,0x43,0x4f,0x4f,0x52,0x44,0x30,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,
-    0x6c,0x6f,0x61,0x74,0x34,0x20,0x63,0x6f,0x6c,0x6f,0x72,0x30,0x20,0x3a,0x20,0x54,
-    0x45,0x58,0x43,0x4f,0x4f,0x52,0x44,0x31,0x3b,0x0a,0x7d,0x3b,0x0a,0x0a,0x73,0x74,
-    0x72,0x75,0x63,0x74,0x20,0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,
-    0x5f,0x4f,0x75,0x74,0x70,0x75,0x74,0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,
-    0x6f,0x61,0x74,0x34,0x20,0x63,0x6f,0x6c,0x6f,0x72,0x20,0x3a,0x20,0x54,0x45,0x58,
-    0x43,0x4f,0x4f,0x52,0x44,0x30,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,0x61,
-    0x74,0x34,0x20,0x67,0x6c,0x5f,0x50,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x20,0x3a,
-    0x20,0x53,0x56,0x5f,0x50,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x3b,0x0a,0x7d,0x3b,
-    0x0a,0x0a,0x76,0x6f,0x69,0x64,0x20,0x76,0x65,0x72,0x74,0x5f,0x6d,0x61,0x69,0x6e,
-    0x28,0x29,0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x67,0x6c,0x5f,0x50,0x6f,0x73,0x69,
-    0x74,0x69,0x6f,0x6e,0x20,0x3d,0x20,0x70,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x3b,
-    0x0a,0x20,0x20,0x20,0x20,0x63,0x6f,0x6c,0x6f,0x72,0x20,0x3d,0x20,0x63,0x6f,0x6c,
-    0x6f,0x72,0x30,0x3b,0x0a,0x7d,0x0a,0x0a,0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,
-    0x6f,0x73,0x73,0x5f,0x4f,0x75,0x74,0x70,0x75,0x74,0x20,0x6d,0x61,0x69,0x6e,0x28,
-    0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,0x5f,0x49,0x6e,0x70,0x75,
-    0x74,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,0x70,0x75,0x74,0x29,0x0a,0x7b,
-    0x0a,0x20,0x20,0x20,0x20,0x70,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x20,0x3d,0x20,
-    0x73,0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,0x70,0x75,0x74,0x2e,0x70,0x6f,0x73,0x69,
-    0x74,0x69,0x6f,0x6e,0x3b,0x0a,0x20,0x20,0x20,0x20,0x63,0x6f,0x6c,0x6f,0x72,0x30,
-    0x20,0x3d,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,0x70,0x75,0x74,0x2e,0x63,
-    0x6f,0x6c,0x6f,0x72,0x30,0x3b,0x0a,0x20,0x20,0x20,0x20,0x76,0x65,0x72,0x74,0x5f,
-    0x6d,0x61,0x69,0x6e,0x28,0x29,0x3b,0x0a,0x20,0x20,0x20,0x20,0x53,0x50,0x49,0x52,
-    0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,0x5f,0x4f,0x75,0x74,0x70,0x75,0x74,0x20,0x73,
-    0x74,0x61,0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,0x3b,0x0a,0x20,0x20,0x20,
-    0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,0x2e,0x67,0x6c,
-    0x5f,0x50,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x20,0x3d,0x20,0x67,0x6c,0x5f,0x50,
-    0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x3b,0x0a,0x20,0x20,0x20,0x20,0x73,0x74,0x61,
-    0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,0x2e,0x63,0x6f,0x6c,0x6f,0x72,0x20,
-    0x3d,0x20,0x63,0x6f,0x6c,0x6f,0x72,0x3b,0x0a,0x20,0x20,0x20,0x20,0x72,0x65,0x74,
-    0x75,0x72,0x6e,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,
-    0x3b,0x0a,0x7d,0x0a,0x00,
-};
-/*
-    static float4 frag_color;
-    static float4 color;
-
-    struct SPIRV_Cross_Input
-    {
-        float4 color : TEXCOORD0;
-    };
-
-    struct SPIRV_Cross_Output
-    {
-        float4 frag_color : SV_Target0;
-    };
-
-    void frag_main()
-    {
-        frag_color = color;
-    }
-
-    SPIRV_Cross_Output main(SPIRV_Cross_Input stage_input)
-    {
-        color = stage_input.color;
-        frag_main();
-        SPIRV_Cross_Output stage_output;
-        stage_output.frag_color = frag_color;
-        return stage_output;
-    }
-*/
-static const uint8_t fs_source_hlsl5[435] = {
-    0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x66,0x72,
-    0x61,0x67,0x5f,0x63,0x6f,0x6c,0x6f,0x72,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,
-    0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x63,0x6f,0x6c,0x6f,0x72,0x3b,0x0a,0x0a,
-    0x73,0x74,0x72,0x75,0x63,0x74,0x20,0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,
-    0x73,0x73,0x5f,0x49,0x6e,0x70,0x75,0x74,0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x66,
-    0x6c,0x6f,0x61,0x74,0x34,0x20,0x63,0x6f,0x6c,0x6f,0x72,0x20,0x3a,0x20,0x54,0x45,
-    0x58,0x43,0x4f,0x4f,0x52,0x44,0x30,0x3b,0x0a,0x7d,0x3b,0x0a,0x0a,0x73,0x74,0x72,
-    0x75,0x63,0x74,0x20,0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,0x5f,
-    0x4f,0x75,0x74,0x70,0x75,0x74,0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x66,0x6c,0x6f,
-    0x61,0x74,0x34,0x20,0x66,0x72,0x61,0x67,0x5f,0x63,0x6f,0x6c,0x6f,0x72,0x20,0x3a,
-    0x20,0x53,0x56,0x5f,0x54,0x61,0x72,0x67,0x65,0x74,0x30,0x3b,0x0a,0x7d,0x3b,0x0a,
-    0x0a,0x76,0x6f,0x69,0x64,0x20,0x66,0x72,0x61,0x67,0x5f,0x6d,0x61,0x69,0x6e,0x28,
-    0x29,0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x66,0x72,0x61,0x67,0x5f,0x63,0x6f,0x6c,
-    0x6f,0x72,0x20,0x3d,0x20,0x63,0x6f,0x6c,0x6f,0x72,0x3b,0x0a,0x7d,0x0a,0x0a,0x53,
-    0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,0x5f,0x4f,0x75,0x74,0x70,0x75,
-    0x74,0x20,0x6d,0x61,0x69,0x6e,0x28,0x53,0x50,0x49,0x52,0x56,0x5f,0x43,0x72,0x6f,
-    0x73,0x73,0x5f,0x49,0x6e,0x70,0x75,0x74,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x69,
-    0x6e,0x70,0x75,0x74,0x29,0x0a,0x7b,0x0a,0x20,0x20,0x20,0x20,0x63,0x6f,0x6c,0x6f,
-    0x72,0x20,0x3d,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x69,0x6e,0x70,0x75,0x74,0x2e,
-    0x63,0x6f,0x6c,0x6f,0x72,0x3b,0x0a,0x20,0x20,0x20,0x20,0x66,0x72,0x61,0x67,0x5f,
-    0x6d,0x61,0x69,0x6e,0x28,0x29,0x3b,0x0a,0x20,0x20,0x20,0x20,0x53,0x50,0x49,0x52,
-    0x56,0x5f,0x43,0x72,0x6f,0x73,0x73,0x5f,0x4f,0x75,0x74,0x70,0x75,0x74,0x20,0x73,
-    0x74,0x61,0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,0x3b,0x0a,0x20,0x20,0x20,
-    0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,0x2e,0x66,0x72,
-    0x61,0x67,0x5f,0x63,0x6f,0x6c,0x6f,0x72,0x20,0x3d,0x20,0x66,0x72,0x61,0x67,0x5f,
-    0x63,0x6f,0x6c,0x6f,0x72,0x3b,0x0a,0x20,0x20,0x20,0x20,0x72,0x65,0x74,0x75,0x72,
-    0x6e,0x20,0x73,0x74,0x61,0x67,0x65,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,0x3b,0x0a,
-    0x7d,0x0a,0x00,
-};
-/*
-    #version 460
-
-    layout(location = 0) in vec4 position;
-    layout(location = 0) out vec4 color;
-    layout(location = 1) in vec4 color0;
-
-    void main()
-    {
-        gl_Position = position;
-        color = color0;
-    }
-
-*/
-static const uint8_t vs_bytecode_spirv_vk[840] = {
-    0x03,0x02,0x23,0x07,0x00,0x04,0x01,0x00,0x0b,0x00,0x08,0x00,0x18,0x00,0x00,0x00,
-    0x00,0x00,0x00,0x00,0x11,0x00,0x02,0x00,0x01,0x00,0x00,0x00,0x0b,0x00,0x06,0x00,
-    0x01,0x00,0x00,0x00,0x47,0x4c,0x53,0x4c,0x2e,0x73,0x74,0x64,0x2e,0x34,0x35,0x30,
-    0x00,0x00,0x00,0x00,0x0e,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
-    0x0f,0x00,0x09,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x6d,0x61,0x69,0x6e,
-    0x00,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x15,0x00,0x00,0x00,
-    0x16,0x00,0x00,0x00,0x03,0x00,0x03,0x00,0x02,0x00,0x00,0x00,0xcc,0x01,0x00,0x00,
-    0x05,0x00,0x04,0x00,0x04,0x00,0x00,0x00,0x6d,0x61,0x69,0x6e,0x00,0x00,0x00,0x00,
-    0x05,0x00,0x06,0x00,0x0b,0x00,0x00,0x00,0x67,0x6c,0x5f,0x50,0x65,0x72,0x56,0x65,
-    0x72,0x74,0x65,0x78,0x00,0x00,0x00,0x00,0x06,0x00,0x06,0x00,0x0b,0x00,0x00,0x00,
-    0x00,0x00,0x00,0x00,0x67,0x6c,0x5f,0x50,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x00,
-    0x06,0x00,0x07,0x00,0x0b,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x67,0x6c,0x5f,0x50,
-    0x6f,0x69,0x6e,0x74,0x53,0x69,0x7a,0x65,0x00,0x00,0x00,0x00,0x06,0x00,0x07,0x00,
-    0x0b,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x67,0x6c,0x5f,0x43,0x6c,0x69,0x70,0x44,
-    0x69,0x73,0x74,0x61,0x6e,0x63,0x65,0x00,0x06,0x00,0x07,0x00,0x0b,0x00,0x00,0x00,
-    0x03,0x00,0x00,0x00,0x67,0x6c,0x5f,0x43,0x75,0x6c,0x6c,0x44,0x69,0x73,0x74,0x61,
-    0x6e,0x63,0x65,0x00,0x05,0x00,0x03,0x00,0x0d,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-    0x05,0x00,0x05,0x00,0x11,0x00,0x00,0x00,0x70,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,
-    0x00,0x00,0x00,0x00,0x05,0x00,0x04,0x00,0x15,0x00,0x00,0x00,0x63,0x6f,0x6c,0x6f,
-    0x72,0x00,0x00,0x00,0x05,0x00,0x04,0x00,0x16,0x00,0x00,0x00,0x63,0x6f,0x6c,0x6f,
-    0x72,0x30,0x00,0x00,0x47,0x00,0x03,0x00,0x0b,0x00,0x00,0x00,0x02,0x00,0x00,0x00,
-    0x48,0x00,0x05,0x00,0x0b,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,
-    0x00,0x00,0x00,0x00,0x48,0x00,0x05,0x00,0x0b,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
-    0x0b,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x48,0x00,0x05,0x00,0x0b,0x00,0x00,0x00,
-    0x02,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x48,0x00,0x05,0x00,
-    0x0b,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x04,0x00,0x00,0x00,
-    0x47,0x00,0x04,0x00,0x11,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-    0x47,0x00,0x04,0x00,0x15,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-    0x47,0x00,0x04,0x00,0x16,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
-    0x13,0x00,0x02,0x00,0x02,0x00,0x00,0x00,0x21,0x00,0x03,0x00,0x03,0x00,0x00,0x00,
-    0x02,0x00,0x00,0x00,0x16,0x00,0x03,0x00,0x06,0x00,0x00,0x00,0x20,0x00,0x00,0x00,
-    0x17,0x00,0x04,0x00,0x07,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x04,0x00,0x00,0x00,
-    0x15,0x00,0x04,0x00,0x08,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-    0x2b,0x00,0x04,0x00,0x08,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
-    0x1c,0x00,0x04,0x00,0x0a,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x09,0x00,0x00,0x00,
-    0x1e,0x00,0x06,0x00,0x0b,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x06,0x00,0x00,0x00,
-    0x0a,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x20,0x00,0x04,0x00,0x0c,0x00,0x00,0x00,
-    0x03,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,0x0c,0x00,0x00,0x00,
-    0x0d,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x15,0x00,0x04,0x00,0x0e,0x00,0x00,0x00,
-    0x20,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x2b,0x00,0x04,0x00,0x0e,0x00,0x00,0x00,
-    0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x04,0x00,0x10,0x00,0x00,0x00,
-    0x01,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,0x10,0x00,0x00,0x00,
-    0x11,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x20,0x00,0x04,0x00,0x13,0x00,0x00,0x00,
-    0x03,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,0x13,0x00,0x00,0x00,
-    0x15,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,0x10,0x00,0x00,0x00,
-    0x16,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x36,0x00,0x05,0x00,0x02,0x00,0x00,0x00,
-    0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0xf8,0x00,0x02,0x00,
-    0x05,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x07,0x00,0x00,0x00,0x12,0x00,0x00,0x00,
-    0x11,0x00,0x00,0x00,0x41,0x00,0x05,0x00,0x13,0x00,0x00,0x00,0x14,0x00,0x00,0x00,
-    0x0d,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x3e,0x00,0x03,0x00,0x14,0x00,0x00,0x00,
-    0x12,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x07,0x00,0x00,0x00,0x17,0x00,0x00,0x00,
-    0x16,0x00,0x00,0x00,0x3e,0x00,0x03,0x00,0x15,0x00,0x00,0x00,0x17,0x00,0x00,0x00,
-    0xfd,0x00,0x01,0x00,0x38,0x00,0x01,0x00,
-};
-/*
-    #version 460
-
-    layout(location = 0) out vec4 frag_color;
-    layout(location = 0) in vec4 color;
-
-    void main()
-    {
-        frag_color = color;
-    }
-
-*/
-static const uint8_t fs_bytecode_spirv_vk[376] = {
-    0x03,0x02,0x23,0x07,0x00,0x04,0x01,0x00,0x0b,0x00,0x08,0x00,0x0d,0x00,0x00,0x00,
-    0x00,0x00,0x00,0x00,0x11,0x00,0x02,0x00,0x01,0x00,0x00,0x00,0x0b,0x00,0x06,0x00,
-    0x01,0x00,0x00,0x00,0x47,0x4c,0x53,0x4c,0x2e,0x73,0x74,0x64,0x2e,0x34,0x35,0x30,
-    0x00,0x00,0x00,0x00,0x0e,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
-    0x0f,0x00,0x07,0x00,0x04,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x6d,0x61,0x69,0x6e,
-    0x00,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x10,0x00,0x03,0x00,
-    0x04,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x03,0x00,0x03,0x00,0x02,0x00,0x00,0x00,
-    0xcc,0x01,0x00,0x00,0x05,0x00,0x04,0x00,0x04,0x00,0x00,0x00,0x6d,0x61,0x69,0x6e,
-    0x00,0x00,0x00,0x00,0x05,0x00,0x05,0x00,0x09,0x00,0x00,0x00,0x66,0x72,0x61,0x67,
-    0x5f,0x63,0x6f,0x6c,0x6f,0x72,0x00,0x00,0x05,0x00,0x04,0x00,0x0b,0x00,0x00,0x00,
-    0x63,0x6f,0x6c,0x6f,0x72,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x09,0x00,0x00,0x00,
-    0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x47,0x00,0x04,0x00,0x0b,0x00,0x00,0x00,
-    0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x13,0x00,0x02,0x00,0x02,0x00,0x00,0x00,
-    0x21,0x00,0x03,0x00,0x03,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x16,0x00,0x03,0x00,
-    0x06,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x17,0x00,0x04,0x00,0x07,0x00,0x00,0x00,
-    0x06,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x20,0x00,0x04,0x00,0x08,0x00,0x00,0x00,
-    0x03,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,0x08,0x00,0x00,0x00,
-    0x09,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x20,0x00,0x04,0x00,0x0a,0x00,0x00,0x00,
-    0x01,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x3b,0x00,0x04,0x00,0x0a,0x00,0x00,0x00,
-    0x0b,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x36,0x00,0x05,0x00,0x02,0x00,0x00,0x00,
-    0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0xf8,0x00,0x02,0x00,
-    0x05,0x00,0x00,0x00,0x3d,0x00,0x04,0x00,0x07,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,
-    0x0b,0x00,0x00,0x00,0x3e,0x00,0x03,0x00,0x09,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,
-    0xfd,0x00,0x01,0x00,0x38,0x00,0x01,0x00,
-};
-static inline const sg_shader_desc* triangle_shader_desc(sg_backend backend) {
-    if (backend == SG_BACKEND_D3D11) {
-        static sg_shader_desc desc;
-        static bool valid;
-        if (!valid) {
-            valid = true;
-            desc.vertex_func.source = (const char*)vs_source_hlsl5;
-            desc.vertex_func.d3d11_target = "vs_5_0";
-            desc.vertex_func.entry = "main";
-            desc.fragment_func.source = (const char*)fs_source_hlsl5;
-            desc.fragment_func.d3d11_target = "ps_5_0";
-            desc.fragment_func.entry = "main";
-            desc.attrs[0].base_type = SG_SHADERATTRBASETYPE_FLOAT;
-            desc.attrs[0].hlsl_sem_name = "TEXCOORD";
-            desc.attrs[0].hlsl_sem_index = 0;
-            desc.attrs[1].base_type = SG_SHADERATTRBASETYPE_FLOAT;
-            desc.attrs[1].hlsl_sem_name = "TEXCOORD";
-            desc.attrs[1].hlsl_sem_index = 1;
-            desc.label = "triangle_shader";
-        }
-        return &desc;
-    }
-    if (backend == SG_BACKEND_VULKAN) {
-        static sg_shader_desc desc;
-        static bool valid;
-        if (!valid) {
-            valid = true;
-            desc.vertex_func.bytecode.ptr = vs_bytecode_spirv_vk;
-            desc.vertex_func.bytecode.size = 840;
-            desc.vertex_func.entry = "main";
-            desc.fragment_func.bytecode.ptr = fs_bytecode_spirv_vk;
-            desc.fragment_func.bytecode.size = 376;
-            desc.fragment_func.entry = "main";
-            desc.attrs[0].base_type = SG_SHADERATTRBASETYPE_FLOAT;
-            desc.attrs[1].base_type = SG_SHADERATTRBASETYPE_FLOAT;
-            desc.label = "triangle_shader";
-        }
-        return &desc;
-    }
-    return 0;
-}
diff --git a/src/gfx.c b/src/gfx.c
new file mode 100644
index 0000000..aa4271f
--- /dev/null
+++ b/src/gfx.c
@@ -0,0 +1,268 @@
+#include "gfx.h"
+#include "libs/sokol_app.h"
+#include "libs/stb_image.h"
+
+#include "gen/batcher.h"
+#include "utils.h"
+#include "utils.h"
+
+// batcher stuff ////////////////////////////////////
+
+typedef struct gfx_batch_render_data_t gfx_batch_render_data_t;
+struct gfx_batch_render_data_t {
+    vec2 one_over_window_size;
+    // float2 one_over_texture_size;
+    float zoom;
+    float padding;
+};
+
+struct gfx_batcher_t {
+    sg_buffer render_buffer;
+    sg_buffer instance_buffer;
+    sg_pipeline pipeline;
+    sg_image empty_texture;
+    sg_sampler sampler;
+
+    sg_image texture;
+
+    gfx_batch_render_data_t render_data;
+    gfx_batch_t *batch_data;
+    uint instance_count;
+    uint max_instances;
+
+    float zoom;
+
+    sg_image font;
+    int font_width;
+    int font_height;
+};
+
+gfx_batcher_t batcher = {0};
+
+bool gfx_init_batcher(arena_t *arena, uint max_instances) {
+    batcher.zoom = 1.f;
+
+    batcher.max_instances = max_instances;
+    batcher.batch_data = alloc(arena, gfx_batch_t, max_instances);
+
+    batcher.render_data = (gfx_batch_render_data_t){
+        .one_over_window_size = {
+            1.f / sapp_widthf(),
+            1.f / sapp_heightf(),
+        },
+        .zoom = batcher.zoom
+    };
+
+    batcher.render_buffer = sg_make_buffer(&(sg_buffer_desc){
+        .usage = {
+            .storage_buffer = true,
+            .dynamic_update = true,
+        },
+        .size = sizeof(batcher.render_data),
+        .label = "batcher",
+    });
+
+    sg_update_buffer(batcher.render_buffer, SG_RANGE_REF(batcher.render_data));
+    
+    batcher.instance_buffer = sg_make_buffer(&(sg_buffer_desc){
+        .usage = {
+            .vertex_buffer = true,
+            .stream_update = true,
+        },
+        .size = sizeof(gfx_batch_t) * batcher.max_instances,
+    });
+
+    sg_shader shd = sg_make_shader(batcher_shader_desc(sg_query_backend()));
+    batcher.pipeline = sg_make_pipeline(&(sg_pipeline_desc){
+        .shader = shd,
+        .layout = {
+            .buffers[0].step_func = SG_VERTEXSTEP_PER_INSTANCE,
+            .attrs = {
+                [ATTR_batcher_quad].format     = SG_VERTEXFORMAT_FLOAT4,
+                [ATTR_batcher_tex_quad].format = SG_VERTEXFORMAT_FLOAT4,
+                [ATTR_batcher_colour].format   = SG_VERTEXFORMAT_FLOAT4,
+            },
+        },
+    });
+
+    u32 empty_image[] = {
+        0xffffffff,
+    };
+
+    batcher.empty_texture = sg_make_image(&(sg_image_desc){
+        .data = SG_RANGE(empty_image),
+        .width = 1,
+        .height = 1,
+        .usage = {
+            .immutable = true,
+        },
+        .pixel_format = SG_PIXELFORMAT_RGBA8,
+        .label = "empty batcher texture",
+    });
+
+    batcher.sampler = sg_make_sampler(&(sg_sampler_desc){0});
+
+    int fw, fh;
+    u8 *data = stbi_load("data/font.png", &fw, &fh, NULL, 4);
+
+    batcher.font = sg_make_image(&(sg_image_desc){
+        .data = { data, fw * fh * 4 },
+        .width = fw,
+        .height = fh,
+        .usage = {
+            .immutable = true,
+        },
+        .pixel_format = SG_PIXELFORMAT_RGBA8,
+        .label = "xterm font"
+    });
+    batcher.font_width = fw;
+    batcher.font_height = fh;
+
+    stbi_image_free(data);
+
+    return true;
+}
+
+void gfx_batcher_cleanup(void) {
+    sg_dealloc_buffer(batcher.render_buffer);
+    sg_dealloc_buffer(batcher.instance_buffer);
+    sg_dealloc_pipeline(batcher.pipeline);
+    sg_dealloc_image(batcher.empty_texture);
+}
+
+void gfx_batcher_present(void) {
+    gfx_batcher_flush();
+}
+
+void gfx_batcher_flush(void) {
+    if (batcher.instance_count == 0) {
+        return;
+    }
+
+    if (win_has_resized() || batcher.render_data.zoom != batcher.zoom) {
+        batcher.render_data = (gfx_batch_render_data_t) {
+            .one_over_window_size = {
+                1.f / sapp_widthf(),
+                1.f / sapp_heightf(),
+            },
+            .zoom = batcher.zoom,
+        };
+        sg_update_buffer(batcher.render_buffer, SG_RANGE_REF(batcher.render_data));
+    }
+
+    if (batcher.texture.id == 0) {
+        batcher.texture = batcher.empty_texture;
+    }
+
+    buffer_t instance_data = (buffer_t){
+        (u8*)batcher.batch_data,
+        sizeof(gfx_batch_t) * batcher.instance_count,
+    };
+
+    sg_update_buffer(batcher.instance_buffer, &(sg_range){
+        .ptr = batcher.batch_data,
+        .size = sizeof(gfx_batch_t) * batcher.instance_count,
+    });
+
+    sg_view img_view = sg_make_view(&(sg_view_desc){
+        .texture.image = batcher.texture,
+    });
+
+    sg_apply_pipeline(batcher.pipeline);
+    sg_apply_uniforms(UB_render_data, SG_RANGE_REF(batcher.render_data));
+    sg_apply_bindings(&(sg_bindings){
+        .vertex_buffers[0] = batcher.instance_buffer,
+        .samplers[SMP_smp] = batcher.sampler,
+        .views[VIEW_tex] = img_view,
+    });
+
+    sg_draw(0, 6, batcher.instance_count);
+
+    sg_destroy_view(img_view);
+
+    batcher.instance_count = 0;
+}
+
+void gfx_batcher_set_texture(sg_image texture) {
+    if (texture.id != batcher.texture.id) {
+        gfx_batcher_flush();
+    }
+
+    batcher.texture = texture;
+}
+
+void gfx_batcher_push(gfx_batch_t *data) {
+    if (batcher.instance_count >= batcher.max_instances) {
+        gfx_batcher_flush();
+    }
+
+    memmove(&batcher.batch_data[batcher.instance_count++], data, sizeof(gfx_batch_t));
+}
+
+void gfx_batcher_push_arr(gfx_batch_t *arr, uint count) {
+    if (count == 0) {
+        return;
+    }
+
+    uint copy_off = 0;
+    while (count > 0) {
+        if (batcher.instance_count >= batcher.max_instances) {
+            gfx_batcher_flush();
+        }
+
+        uint remaining_in_batch = batcher.max_instances - batcher.instance_count;
+        uint to_copy = MIN(remaining_in_batch, count);
+
+        memmove(&batcher.batch_data[batcher.instance_count], &arr[copy_off], sizeof(gfx_batch_t) * to_copy);
+        
+        count -= to_copy;
+        copy_off += to_copy;
+        batcher.instance_count += to_copy;
+    }
+}
+
+typedef struct gfx_print_desc_t gfx_print_desc_t;
+struct gfx_print_desc_t {
+    strview_t str;
+    vec2 pos;
+    vec4 col;
+};
+
+void gfx_batcher_puts(gfx_print_desc_t *desc) {
+    float atlas_1ow          = 1.f / (float)batcher.font_width;
+    float atlas_1oh          = 1.f / (float)batcher.font_height;
+    float char_width         = 6.f;
+    float char_height        = 13.f;
+    float char_scaled_width  = char_width * atlas_1ow;
+    float char_scaled_height = char_height * atlas_1oh;
+
+    gfx_batcher_set_texture(batcher.font);
+
+    vec2 pos = desc->pos;
+
+    strview_t s = desc->str;
+    for (usize i = 0; i < s.len; ++i, pos.x += char_width) {
+        char c = s.buf[i];
+        int index = c - ' ';
+
+        if (index == 0) {
+            continue;
+        }
+
+        int cx = index % 16;
+        int cy = index / 16;
+
+        vec4 tex_quad = v4(
+            (float)cx * char_scaled_width,
+            (float)cy * char_scaled_height,
+            char_scaled_width, 
+            char_scaled_height
+        );
+
+        gfx_batcher_push(&(gfx_batch_t){
+            .tex_quad = tex_quad,
+            .colour = desc->col,
+            .quad = v4(pos.x, pos.y, char_width, char_height),
+        });
+    }
+}
diff --git a/src/gfx.h b/src/gfx.h
new file mode 100644
index 0000000..76aae07
--- /dev/null
+++ b/src/gfx.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include "colla/colla.h"
+
+#include "libs/handmademath.h"
+#include "libs/sokol_gfx.h"
+
+#define GFX_WHITE (float4){ 1, 1, 1, 1 }
+#define GFX_BLACK (vec4){ 0, 0, 0, 1 }
+#define GFX_RED   (vec4){ 1, 0, 0, 1 }
+#define GFX_GREEN (vec4){ 0, 1, 0, 1 }
+#define GFX_BLUE  (vec4){ 0, 0, 1, 1 }
+
+// batcher stuff ////////////////////////////////////
+
+typedef struct gfx_batch_t gfx_batch_t;
+struct gfx_batch_t {
+    vec4 quad;
+    vec4 tex_quad;
+    vec4 colour;
+};
+
+typedef struct gfx_batcher_t gfx_batcher_t;
+extern gfx_batcher_t batcher;
+
+bool gfx_init_batcher(arena_t *arena, uint max_instances);
+void gfx_batcher_cleanup(void);
+
+void gfx_batcher_present(void);
+void gfx_batcher_flush(void);
+
+void gfx_batcher_set_zoom(float zoom);
+void gfx_batcher_set_texture(sg_image texture);
+void gfx_batcher_push(gfx_batch_t *data);
+void gfx_batcher_push_arr(gfx_batch_t *arr, uint count);
+
+/////////////////////////////////////////////////////
diff --git a/src/libs/handmademath.h b/src/libs/handmademath.h
index 8e7b8cd..d81c8a2 100644
--- a/src/libs/handmademath.h
+++ b/src/libs/handmademath.h
@@ -173,18 +173,18 @@ extern "C"
 # define HANDMADE_MATH_USE_RADIANS
 #endif
 
-#define HMM_PI 3.14159265358979323846
-#define HMM_PI32 3.14159265359f
-#define HMM_DEG180 180.0
-#define HMM_DEG18032 180.0f
-#define HMM_TURNHALF 0.5
-#define HMM_TURNHALF32 0.5f
-#define HMM_RadToDeg ((float)(HMM_DEG180/HMM_PI))
-#define HMM_RadToTurn ((float)(HMM_TURNHALF/HMM_PI))
-#define HMM_DegToRad ((float)(HMM_PI/HMM_DEG180))
-#define HMM_DegToTurn ((float)(HMM_TURNHALF/HMM_DEG180))
-#define HMM_TurnToRad ((float)(HMM_PI/HMM_TURNHALF))
-#define HMM_TurnToDeg ((float)(HMM_DEG180/HMM_TURNHALF))
+#define hmm_pi 3.14159265358979323846
+#define hmm_pi32 3.14159265359f
+#define hmm_deg180 180.0
+#define hmm_deg18032 180.0f
+#define hmm_turnhalf 0.5
+#define hmm_turnhalf32 0.5f
+#define hmm_radtodeg ((float)(hmm_deg180/hmm_pi))
+#define hmm_radtoturn ((float)(hmm_turnhalf/hmm_pi))
+#define hmm_degtorad ((float)(hmm_pi/hmm_deg180))
+#define hmm_degtoturn ((float)(hmm_turnhalf/hmm_deg180))
+#define hmm_turntorad ((float)(hmm_pi/hmm_turnhalf))
+#define hmm_turntodeg ((float)(hmm_deg180/hmm_turnhalf))
 
 #if defined(HANDMADE_MATH_USE_RADIANS)
 # define HMM_AngleRad(a) (a)
@@ -229,136 +229,136 @@ extern "C"
 #define HMM_MOD(a, m) (((a) % (m)) >= 0 ? ((a) % (m)) : (((a) % (m)) + (m)))
 #define HMM_SQUARE(x) ((x) * (x))
 
-typedef union HMM_Vec2
+typedef union vec2
 {
     struct
     {
-        float X, Y;
+        float x, y;
     };
 
     struct
     {
-        float U, V;
+        float u, v;
     };
 
     struct
     {
-        float Left, Right;
+        float left, right;
     };
 
     struct
     {
-        float Width, Height;
+        float width, height;
     };
 
-    float Elements[2];
+    float elements[2];
 
 #ifdef __cplusplus
-    inline float &operator[](int Index) { return Elements[Index]; }
-    inline const float& operator[](int Index) const { return Elements[Index]; }
+    inline float &operator[](int Index) { return elements[Index]; }
+    inline const float& operator[](int Index) const { return elements[Index]; }
 #endif
-} HMM_Vec2;
+} vec2;
 
-typedef union HMM_Vec3
+typedef union vec3
 {
     struct
     {
-        float X, Y, Z;
+        float x, y, z;
     };
 
     struct
     {
-        float U, V, W;
+        float u, v, w;
     };
 
     struct
     {
-        float R, G, B;
+        float r, g, b;
     };
 
     struct
     {
-        HMM_Vec2 XY;
-        float _Ignored0;
+        vec2 xy;
+        float _ignored0;
     };
 
     struct
     {
-        float _Ignored1;
-        HMM_Vec2 YZ;
+        float _ignored1;
+        vec2 yz;
     };
 
     struct
     {
-        HMM_Vec2 UV;
-        float _Ignored2;
+        vec2 uv;
+        float _ignored2;
     };
 
     struct
     {
-        float _Ignored3;
-        HMM_Vec2 VW;
+        float _ignored3;
+        vec2 vw;
     };
 
-    float Elements[3];
+    float elements[3];
 
 #ifdef __cplusplus
-    inline float &operator[](int Index) { return Elements[Index]; }
-    inline const float &operator[](int Index) const { return Elements[Index]; }
+    inline float &operator[](int Index) { return elements[Index]; }
+    inline const float &operator[](int Index) const { return elements[Index]; }
 #endif
-} HMM_Vec3;
+} vec3;
 
-typedef union HMM_Vec4
+typedef union vec4
 {
     struct
     {
         union
         {
-            HMM_Vec3 XYZ;
+            vec3 xyz;
             struct
             {
-                float X, Y, Z;
+                float x, y, z;
             };
         };
 
-        float W;
+        float w;
     };
     struct
     {
         union
         {
-            HMM_Vec3 RGB;
+            vec3 rgb;
             struct
             {
-                float R, G, B;
+                float r, g, b;
             };
         };
 
-        float A;
+        float a;
     };
 
     struct
     {
-        HMM_Vec2 XY;
-        float _Ignored0;
-        float _Ignored1;
+        vec2 xy;
+        float _ignored0;
+        float _ignored1;
     };
 
     struct
     {
-        float _Ignored2;
-        HMM_Vec2 YZ;
-        float _Ignored3;
+        float _ignored2;
+        vec2 yz;
+        float _ignored3;
     };
 
     struct
     {
-        float _Ignored4;
-        float _Ignored5;
-        HMM_Vec2 ZW;
+        float _ignored4;
+        float _ignored5;
+        vec2 zw;
     };
 
-    float Elements[4];
+    float elements[4];
 
 #ifdef HANDMADE_MATH__USE_SSE
     __m128 SSE;
@@ -369,43 +369,43 @@ typedef union HMM_Vec4
 #endif
 
 #ifdef __cplusplus
-    inline float &operator[](int Index) { return Elements[Index]; }
-    inline const float &operator[](int Index) const { return Elements[Index]; }
+    inline float &operator[](int Index) { return elements[Index]; }
+    inline const float &operator[](int Index) const { return elements[Index]; }
 #endif
-} HMM_Vec4;
+} vec4;
 
-typedef union HMM_Mat2
+typedef union mat2
 {
-    float Elements[2][2];
-    HMM_Vec2 Columns[2];
+    float elements[2][2];
+    vec2 columns[2];
 
 #ifdef __cplusplus
-    inline HMM_Vec2 &operator[](int Index) { return Columns[Index]; }
-    inline const HMM_Vec2 &operator[](int Index) const { return Columns[Index]; }
+    inline vec2 &operator[](int Index) { return columns[Index]; }
+    inline const vec2 &operator[](int Index) const { return columns[Index]; }
 #endif
-} HMM_Mat2;
+} mat2;
 
-typedef union HMM_Mat3
+typedef union mat3
 {
-    float Elements[3][3];
-    HMM_Vec3 Columns[3];
+    float elements[3][3];
+    vec3 columns[3];
 
 #ifdef __cplusplus
-    inline HMM_Vec3 &operator[](int Index) { return Columns[Index]; }
-    inline const HMM_Vec3 &operator[](int Index) const { return Columns[Index]; }
+    inline vec3 &operator[](int Index) { return columns[Index]; }
+    inline const vec3 &operator[](int Index) const { return columns[Index]; }
 #endif
-} HMM_Mat3;
+} mat3;
 
-typedef union HMM_Mat4
+typedef union mat4
 {
-    float Elements[4][4];
-    HMM_Vec4 Columns[4];
+    float elements[4][4];
+    vec4 columns[4];
 
 #ifdef __cplusplus
-    inline HMM_Vec4 &operator[](int Index) { return Columns[Index]; }
-    inline const HMM_Vec4 &operator[](int Index) const { return Columns[Index]; }
+    inline vec4 &operator[](int Index) { return columns[Index]; }
+    inline const vec4 &operator[](int Index) const { return columns[Index]; }
 #endif
-} HMM_Mat4;
+} mat4;
 
 typedef union HMM_Quat
 {
@@ -413,17 +413,17 @@ typedef union HMM_Quat
     {
         union
         {
-            HMM_Vec3 XYZ;
+            vec3 xyz;
             struct
             {
-                float X, Y, Z;
+                float x, y, z;
             };
         };
 
-        float W;
+        float w;
     };
 
-    float Elements[4];
+    float elements[4];
 
 #ifdef HANDMADE_MATH__USE_SSE
     __m128 SSE;
@@ -454,7 +454,7 @@ static inline float HMM_ToRad(float Angle)
 static inline float HMM_ToDeg(float Angle)
 {
 #if defined(HANDMADE_MATH_USE_RADIANS)
-    float Result = Angle * HMM_RadToDeg;
+    float Result = Angle * hmm_radtodeg;
 #elif defined(HANDMADE_MATH_USE_DEGREES)
     float Result = Angle;
 #elif defined(HANDMADE_MATH_USE_TURNS)
@@ -467,7 +467,7 @@ static inline float HMM_ToDeg(float Angle)
 static inline float HMM_ToTurn(float Angle)
 {
 #if defined(HANDMADE_MATH_USE_RADIANS)
-    float Result = Angle * HMM_RadToTurn;
+    float Result = Angle * hmm_radtoturn;
 #elif defined(HANDMADE_MATH_USE_DEGREES)
     float Result = Angle * HMM_DegToTurn;
 #elif defined(HANDMADE_MATH_USE_TURNS)
@@ -548,17 +548,17 @@ static inline float HMM_InvSqrtF(float Float)
  * Utility functions
  */
 
-COVERAGE(HMM_Lerp, 1)
-static inline float HMM_Lerp(float A, float Time, float B)
+COVERAGE(lerp, 1)
+static inline float lerp(float A, float Time, float B)
 {
-    ASSERT_COVERED(HMM_Lerp);
+    ASSERT_COVERED(lerp);
     return (1.0f - Time) * A + Time * B;
 }
 
-COVERAGE(HMM_Clamp, 1)
-static inline float HMM_Clamp(float Min, float Value, float Max)
+COVERAGE(clamp, 1)
+static inline float clamp(float Min, float Value, float Max)
 {
-    ASSERT_COVERED(HMM_Clamp);
+    ASSERT_COVERED(clamp);
 
     float Result = Value;
 
@@ -580,37 +580,37 @@ static inline float HMM_Clamp(float Min, float Value, float Max)
  * Vector initialization
  */
 
-COVERAGE(HMM_V2, 1)
-static inline HMM_Vec2 HMM_V2(float X, float Y)
+COVERAGE(v2, 1)
+static inline vec2 v2(float X, float Y)
 {
-    ASSERT_COVERED(HMM_V2);
+    ASSERT_COVERED(v2);
 
-    HMM_Vec2 Result;
-    Result.X = X;
-    Result.Y = Y;
+    vec2 Result;
+    Result.x = X;
+    Result.y = Y;
 
     return Result;
 }
 
-COVERAGE(HMM_V3, 1)
-static inline HMM_Vec3 HMM_V3(float X, float Y, float Z)
+COVERAGE(v3, 1)
+static inline vec3 v3(float X, float Y, float Z)
 {
-    ASSERT_COVERED(HMM_V3);
+    ASSERT_COVERED(v3);
 
-    HMM_Vec3 Result;
-    Result.X = X;
-    Result.Y = Y;
-    Result.Z = Z;
+    vec3 Result;
+    Result.x = X;
+    Result.y = Y;
+    Result.z = Z;
 
     return Result;
 }
 
-COVERAGE(HMM_V4, 1)
-static inline HMM_Vec4 HMM_V4(float X, float Y, float Z, float W)
+COVERAGE(v4, 1)
+static inline vec4 v4(float X, float Y, float Z, float W)
 {
-    ASSERT_COVERED(HMM_V4);
+    ASSERT_COVERED(v4);
 
-    HMM_Vec4 Result;
+    vec4 Result;
 
 #ifdef HANDMADE_MATH__USE_SSE
     Result.SSE = _mm_setr_ps(X, Y, Z, W);
@@ -618,30 +618,30 @@ static inline HMM_Vec4 HMM_V4(float X, float Y, float Z, float W)
     float32x4_t v = {X, Y, Z, W};
     Result.NEON = v;
 #else
-    Result.X = X;
-    Result.Y = Y;
-    Result.Z = Z;
-    Result.W = W;
+    Result.x = X;
+    Result.y = Y;
+    Result.z = Z;
+    Result.w = W;
 #endif
 
     return Result;
 }
 
-COVERAGE(HMM_V4V, 1)
-static inline HMM_Vec4 HMM_V4V(HMM_Vec3 Vector, float W)
+COVERAGE(v4V, 1)
+static inline vec4 v4V(vec3 Vector, float W)
 {
-    ASSERT_COVERED(HMM_V4V);
+    ASSERT_COVERED(v4V);
 
-    HMM_Vec4 Result;
+    vec4 Result;
 
 #ifdef HANDMADE_MATH__USE_SSE
-    Result.SSE = _mm_setr_ps(Vector.X, Vector.Y, Vector.Z, W);
+    Result.SSE = _mm_setr_ps(Vector.x, Vector.y, Vector.z, W);
 #elif defined(HANDMADE_MATH__USE_NEON)
-    float32x4_t v = {Vector.X, Vector.Y, Vector.Z, W};
+    float32x4_t v = {Vector.x, Vector.y, Vector.z, W};
     Result.NEON = v;
 #else
-    Result.XYZ = Vector;
-    Result.W = W;
+    Result.xyz = Vector;
+    Result.w = W;
 #endif
 
     return Result;
@@ -653,174 +653,174 @@ static inline HMM_Vec4 HMM_V4V(HMM_Vec3 Vector, float W)
  */
 
 COVERAGE(HMM_AddV2, 1)
-static inline HMM_Vec2 HMM_AddV2(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline vec2 HMM_AddV2(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_AddV2);
 
-    HMM_Vec2 Result;
-    Result.X = Left.X + Right.X;
-    Result.Y = Left.Y + Right.Y;
+    vec2 Result;
+    Result.x = Left.x + Right.x;
+    Result.y = Left.y + Right.y;
 
     return Result;
 }
 
 COVERAGE(HMM_AddV3, 1)
-static inline HMM_Vec3 HMM_AddV3(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline vec3 HMM_AddV3(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_AddV3);
 
-    HMM_Vec3 Result;
-    Result.X = Left.X + Right.X;
-    Result.Y = Left.Y + Right.Y;
-    Result.Z = Left.Z + Right.Z;
+    vec3 Result;
+    Result.x = Left.x + Right.x;
+    Result.y = Left.y + Right.y;
+    Result.z = Left.z + Right.z;
 
     return Result;
 }
 
 COVERAGE(HMM_AddV4, 1)
-static inline HMM_Vec4 HMM_AddV4(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline vec4 HMM_AddV4(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_AddV4);
 
-    HMM_Vec4 Result;
+    vec4 Result;
 
 #ifdef HANDMADE_MATH__USE_SSE
     Result.SSE = _mm_add_ps(Left.SSE, Right.SSE);
 #elif defined(HANDMADE_MATH__USE_NEON)
     Result.NEON = vaddq_f32(Left.NEON, Right.NEON);
 #else
-    Result.X = Left.X + Right.X;
-    Result.Y = Left.Y + Right.Y;
-    Result.Z = Left.Z + Right.Z;
-    Result.W = Left.W + Right.W;
+    Result.x = Left.x + Right.x;
+    Result.y = Left.y + Right.y;
+    Result.z = Left.z + Right.z;
+    Result.w = Left.w + Right.w;
 #endif
 
     return Result;
 }
 
 COVERAGE(HMM_SubV2, 1)
-static inline HMM_Vec2 HMM_SubV2(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline vec2 HMM_SubV2(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_SubV2);
 
-    HMM_Vec2 Result;
-    Result.X = Left.X - Right.X;
-    Result.Y = Left.Y - Right.Y;
+    vec2 Result;
+    Result.x = Left.x - Right.x;
+    Result.y = Left.y - Right.y;
 
     return Result;
 }
 
 COVERAGE(HMM_SubV3, 1)
-static inline HMM_Vec3 HMM_SubV3(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline vec3 HMM_SubV3(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_SubV3);
 
-    HMM_Vec3 Result;
-    Result.X = Left.X - Right.X;
-    Result.Y = Left.Y - Right.Y;
-    Result.Z = Left.Z - Right.Z;
+    vec3 Result;
+    Result.x = Left.x - Right.x;
+    Result.y = Left.y - Right.y;
+    Result.z = Left.z - Right.z;
 
     return Result;
 }
 
 COVERAGE(HMM_SubV4, 1)
-static inline HMM_Vec4 HMM_SubV4(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline vec4 HMM_SubV4(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_SubV4);
 
-    HMM_Vec4 Result;
+    vec4 Result;
 
 #ifdef HANDMADE_MATH__USE_SSE
     Result.SSE = _mm_sub_ps(Left.SSE, Right.SSE);
 #elif defined(HANDMADE_MATH__USE_NEON)
     Result.NEON = vsubq_f32(Left.NEON, Right.NEON);
 #else
-    Result.X = Left.X - Right.X;
-    Result.Y = Left.Y - Right.Y;
-    Result.Z = Left.Z - Right.Z;
-    Result.W = Left.W - Right.W;
+    Result.x = Left.x - Right.x;
+    Result.y = Left.y - Right.y;
+    Result.z = Left.z - Right.z;
+    Result.w = Left.w - Right.w;
 #endif
 
     return Result;
 }
 
 COVERAGE(HMM_MulV2, 1)
-static inline HMM_Vec2 HMM_MulV2(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline vec2 HMM_MulV2(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_MulV2);
 
-    HMM_Vec2 Result;
-    Result.X = Left.X * Right.X;
-    Result.Y = Left.Y * Right.Y;
+    vec2 Result;
+    Result.x = Left.x * Right.x;
+    Result.y = Left.y * Right.y;
 
     return Result;
 }
 
 COVERAGE(HMM_MulV2F, 1)
-static inline HMM_Vec2 HMM_MulV2F(HMM_Vec2 Left, float Right)
+static inline vec2 HMM_MulV2F(vec2 Left, float Right)
 {
     ASSERT_COVERED(HMM_MulV2F);
 
-    HMM_Vec2 Result;
-    Result.X = Left.X * Right;
-    Result.Y = Left.Y * Right;
+    vec2 Result;
+    Result.x = Left.x * Right;
+    Result.y = Left.y * Right;
 
     return Result;
 }
 
 COVERAGE(HMM_MulV3, 1)
-static inline HMM_Vec3 HMM_MulV3(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline vec3 HMM_MulV3(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_MulV3);
 
-    HMM_Vec3 Result;
-    Result.X = Left.X * Right.X;
-    Result.Y = Left.Y * Right.Y;
-    Result.Z = Left.Z * Right.Z;
+    vec3 Result;
+    Result.x = Left.x * Right.x;
+    Result.y = Left.y * Right.y;
+    Result.z = Left.z * Right.z;
 
     return Result;
 }
 
 COVERAGE(HMM_MulV3F, 1)
-static inline HMM_Vec3 HMM_MulV3F(HMM_Vec3 Left, float Right)
+static inline vec3 HMM_MulV3F(vec3 Left, float Right)
 {
     ASSERT_COVERED(HMM_MulV3F);
 
-    HMM_Vec3 Result;
-    Result.X = Left.X * Right;
-    Result.Y = Left.Y * Right;
-    Result.Z = Left.Z * Right;
+    vec3 Result;
+    Result.x = Left.x * Right;
+    Result.y = Left.y * Right;
+    Result.z = Left.z * Right;
 
     return Result;
 }
 
 COVERAGE(HMM_MulV4, 1)
-static inline HMM_Vec4 HMM_MulV4(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline vec4 HMM_MulV4(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_MulV4);
 
-    HMM_Vec4 Result;
+    vec4 Result;
 
 #ifdef HANDMADE_MATH__USE_SSE
     Result.SSE = _mm_mul_ps(Left.SSE, Right.SSE);
 #elif defined(HANDMADE_MATH__USE_NEON)
     Result.NEON = vmulq_f32(Left.NEON, Right.NEON);
 #else
-    Result.X = Left.X * Right.X;
-    Result.Y = Left.Y * Right.Y;
-    Result.Z = Left.Z * Right.Z;
-    Result.W = Left.W * Right.W;
+    Result.x = Left.x * Right.x;
+    Result.y = Left.y * Right.y;
+    Result.z = Left.z * Right.z;
+    Result.w = Left.w * Right.w;
 #endif
 
     return Result;
 }
 
 COVERAGE(HMM_MulV4F, 1)
-static inline HMM_Vec4 HMM_MulV4F(HMM_Vec4 Left, float Right)
+static inline vec4 HMM_MulV4F(vec4 Left, float Right)
 {
     ASSERT_COVERED(HMM_MulV4F);
 
-    HMM_Vec4 Result;
+    vec4 Result;
 
 #ifdef HANDMADE_MATH__USE_SSE
     __m128 Scalar = _mm_set1_ps(Right);
@@ -828,92 +828,92 @@ static inline HMM_Vec4 HMM_MulV4F(HMM_Vec4 Left, float Right)
 #elif defined(HANDMADE_MATH__USE_NEON)
     Result.NEON = vmulq_n_f32(Left.NEON, Right);
 #else
-    Result.X = Left.X * Right;
-    Result.Y = Left.Y * Right;
-    Result.Z = Left.Z * Right;
-    Result.W = Left.W * Right;
+    Result.x = Left.x * Right;
+    Result.y = Left.y * Right;
+    Result.z = Left.z * Right;
+    Result.w = Left.w * Right;
 #endif
 
     return Result;
 }
 
 COVERAGE(HMM_DivV2, 1)
-static inline HMM_Vec2 HMM_DivV2(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline vec2 HMM_DivV2(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_DivV2);
 
-    HMM_Vec2 Result;
-    Result.X = Left.X / Right.X;
-    Result.Y = Left.Y / Right.Y;
+    vec2 Result;
+    Result.x = Left.x / Right.x;
+    Result.y = Left.y / Right.y;
 
     return Result;
 }
 
 COVERAGE(HMM_DivV2F, 1)
-static inline HMM_Vec2 HMM_DivV2F(HMM_Vec2 Left, float Right)
+static inline vec2 HMM_DivV2F(vec2 Left, float Right)
 {
     ASSERT_COVERED(HMM_DivV2F);
 
-    HMM_Vec2 Result;
-    Result.X = Left.X / Right;
-    Result.Y = Left.Y / Right;
+    vec2 Result;
+    Result.x = Left.x / Right;
+    Result.y = Left.y / Right;
 
     return Result;
 }
 
 COVERAGE(HMM_DivV3, 1)
-static inline HMM_Vec3 HMM_DivV3(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline vec3 HMM_DivV3(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_DivV3);
 
-    HMM_Vec3 Result;
-    Result.X = Left.X / Right.X;
-    Result.Y = Left.Y / Right.Y;
-    Result.Z = Left.Z / Right.Z;
+    vec3 Result;
+    Result.x = Left.x / Right.x;
+    Result.y = Left.y / Right.y;
+    Result.z = Left.z / Right.z;
 
     return Result;
 }
 
 COVERAGE(HMM_DivV3F, 1)
-static inline HMM_Vec3 HMM_DivV3F(HMM_Vec3 Left, float Right)
+static inline vec3 HMM_DivV3F(vec3 Left, float Right)
 {
     ASSERT_COVERED(HMM_DivV3F);
 
-    HMM_Vec3 Result;
-    Result.X = Left.X / Right;
-    Result.Y = Left.Y / Right;
-    Result.Z = Left.Z / Right;
+    vec3 Result;
+    Result.x = Left.x / Right;
+    Result.y = Left.y / Right;
+    Result.z = Left.z / Right;
 
     return Result;
 }
 
 COVERAGE(HMM_DivV4, 1)
-static inline HMM_Vec4 HMM_DivV4(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline vec4 HMM_DivV4(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_DivV4);
 
-    HMM_Vec4 Result;
+    vec4 Result;
 
 #ifdef HANDMADE_MATH__USE_SSE
     Result.SSE = _mm_div_ps(Left.SSE, Right.SSE);
 #elif defined(HANDMADE_MATH__USE_NEON)
     Result.NEON = vdivq_f32(Left.NEON, Right.NEON);
 #else
-    Result.X = Left.X / Right.X;
-    Result.Y = Left.Y / Right.Y;
-    Result.Z = Left.Z / Right.Z;
-    Result.W = Left.W / Right.W;
+    Result.x = Left.x / Right.x;
+    Result.y = Left.y / Right.y;
+    Result.z = Left.z / Right.z;
+    Result.w = Left.w / Right.w;
 #endif
 
     return Result;
 }
 
 COVERAGE(HMM_DivV4F, 1)
-static inline HMM_Vec4 HMM_DivV4F(HMM_Vec4 Left, float Right)
+static inline vec4 HMM_DivV4F(vec4 Left, float Right)
 {
     ASSERT_COVERED(HMM_DivV4F);
 
-    HMM_Vec4 Result;
+    vec4 Result;
 
 #ifdef HANDMADE_MATH__USE_SSE
     __m128 Scalar = _mm_set1_ps(Right);
@@ -922,52 +922,52 @@ static inline HMM_Vec4 HMM_DivV4F(HMM_Vec4 Left, float Right)
     float32x4_t Scalar = vdupq_n_f32(Right);
     Result.NEON = vdivq_f32(Left.NEON, Scalar);
 #else
-    Result.X = Left.X / Right;
-    Result.Y = Left.Y / Right;
-    Result.Z = Left.Z / Right;
-    Result.W = Left.W / Right;
+    Result.x = Left.x / Right;
+    Result.y = Left.y / Right;
+    Result.z = Left.z / Right;
+    Result.w = Left.w / Right;
 #endif
 
     return Result;
 }
 
 COVERAGE(HMM_EqV2, 1)
-static inline HMM_Bool HMM_EqV2(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline HMM_Bool HMM_EqV2(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_EqV2);
-    return Left.X == Right.X && Left.Y == Right.Y;
+    return Left.x == Right.x && Left.y == Right.y;
 }
 
 COVERAGE(HMM_EqV3, 1)
-static inline HMM_Bool HMM_EqV3(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline HMM_Bool HMM_EqV3(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_EqV3);
-    return Left.X == Right.X && Left.Y == Right.Y && Left.Z == Right.Z;
+    return Left.x == Right.x && Left.y == Right.y && Left.z == Right.z;
 }
 
 COVERAGE(HMM_EqV4, 1)
-static inline HMM_Bool HMM_EqV4(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline HMM_Bool HMM_EqV4(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_EqV4);
-    return Left.X == Right.X && Left.Y == Right.Y && Left.Z == Right.Z && Left.W == Right.W;
+    return Left.x == Right.x && Left.y == Right.y && Left.z == Right.z && Left.w == Right.w;
 }
 
 COVERAGE(HMM_DotV2, 1)
-static inline float HMM_DotV2(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline float HMM_DotV2(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_DotV2);
-    return (Left.X * Right.X) + (Left.Y * Right.Y);
+    return (Left.x * Right.x) + (Left.y * Right.y);
 }
 
 COVERAGE(HMM_DotV3, 1)
-static inline float HMM_DotV3(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline float HMM_DotV3(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_DotV3);
-    return (Left.X * Right.X) + (Left.Y * Right.Y) + (Left.Z * Right.Z);
+    return (Left.x * Right.x) + (Left.y * Right.y) + (Left.z * Right.z);
 }
 
 COVERAGE(HMM_DotV4, 1)
-static inline float HMM_DotV4(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline float HMM_DotV4(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_DotV4);
 
@@ -989,21 +989,21 @@ static inline float HMM_DotV4(HMM_Vec4 Left, HMM_Vec4 Right)
     float32x4_t NEONFullAdd = vpaddq_f32(NEONHalfAdd, NEONHalfAdd);
     Result = vgetq_lane_f32(NEONFullAdd, 0);
 #else
-    Result = ((Left.X * Right.X) + (Left.Z * Right.Z)) + ((Left.Y * Right.Y) + (Left.W * Right.W));
+    Result = ((Left.x * Right.x) + (Left.z * Right.z)) + ((Left.y * Right.y) + (Left.w * Right.w));
 #endif
 
     return Result;
 }
 
-COVERAGE(HMM_Cross, 1)
-static inline HMM_Vec3 HMM_Cross(HMM_Vec3 Left, HMM_Vec3 Right)
+COVERAGE(cross, 1)
+static inline vec3 cross(vec3 Left, vec3 Right)
 {
-    ASSERT_COVERED(HMM_Cross);
+    ASSERT_COVERED(cross);
 
-    HMM_Vec3 Result;
-    Result.X = (Left.Y * Right.Z) - (Left.Z * Right.Y);
-    Result.Y = (Left.Z * Right.X) - (Left.X * Right.Z);
-    Result.Z = (Left.X * Right.Y) - (Left.Y * Right.X);
+    vec3 Result;
+    Result.x = (Left.y * Right.z) - (Left.z * Right.y);
+    Result.y = (Left.z * Right.x) - (Left.x * Right.z);
+    Result.z = (Left.x * Right.y) - (Left.y * Right.x);
 
     return Result;
 }
@@ -1014,63 +1014,63 @@ static inline HMM_Vec3 HMM_Cross(HMM_Vec3 Left, HMM_Vec3 Right)
  */
 
 COVERAGE(HMM_LenSqrV2, 1)
-static inline float HMM_LenSqrV2(HMM_Vec2 A)
+static inline float HMM_LenSqrV2(vec2 A)
 {
     ASSERT_COVERED(HMM_LenSqrV2);
     return HMM_DotV2(A, A);
 }
 
 COVERAGE(HMM_LenSqrV3, 1)
-static inline float HMM_LenSqrV3(HMM_Vec3 A)
+static inline float HMM_LenSqrV3(vec3 A)
 {
     ASSERT_COVERED(HMM_LenSqrV3);
     return HMM_DotV3(A, A);
 }
 
 COVERAGE(HMM_LenSqrV4, 1)
-static inline float HMM_LenSqrV4(HMM_Vec4 A)
+static inline float HMM_LenSqrV4(vec4 A)
 {
     ASSERT_COVERED(HMM_LenSqrV4);
     return HMM_DotV4(A, A);
 }
 
 COVERAGE(HMM_LenV2, 1)
-static inline float HMM_LenV2(HMM_Vec2 A)
+static inline float HMM_LenV2(vec2 A)
 {
     ASSERT_COVERED(HMM_LenV2);
     return HMM_SqrtF(HMM_LenSqrV2(A));
 }
 
 COVERAGE(HMM_LenV3, 1)
-static inline float HMM_LenV3(HMM_Vec3 A)
+static inline float HMM_LenV3(vec3 A)
 {
     ASSERT_COVERED(HMM_LenV3);
     return HMM_SqrtF(HMM_LenSqrV3(A));
 }
 
 COVERAGE(HMM_LenV4, 1)
-static inline float HMM_LenV4(HMM_Vec4 A)
+static inline float HMM_LenV4(vec4 A)
 {
     ASSERT_COVERED(HMM_LenV4);
     return HMM_SqrtF(HMM_LenSqrV4(A));
 }
 
 COVERAGE(HMM_NormV2, 1)
-static inline HMM_Vec2 HMM_NormV2(HMM_Vec2 A)
+static inline vec2 HMM_NormV2(vec2 A)
 {
     ASSERT_COVERED(HMM_NormV2);
     return HMM_MulV2F(A, HMM_InvSqrtF(HMM_DotV2(A, A)));
 }
 
 COVERAGE(HMM_NormV3, 1)
-static inline HMM_Vec3 HMM_NormV3(HMM_Vec3 A)
+static inline vec3 HMM_NormV3(vec3 A)
 {
     ASSERT_COVERED(HMM_NormV3);
     return HMM_MulV3F(A, HMM_InvSqrtF(HMM_DotV3(A, A)));
 }
 
 COVERAGE(HMM_NormV4, 1)
-static inline HMM_Vec4 HMM_NormV4(HMM_Vec4 A)
+static inline vec4 HMM_NormV4(vec4 A)
 {
     ASSERT_COVERED(HMM_NormV4);
     return HMM_MulV4F(A, HMM_InvSqrtF(HMM_DotV4(A, A)));
@@ -1080,24 +1080,24 @@ static inline HMM_Vec4 HMM_NormV4(HMM_Vec4 A)
  * Utility vector functions
  */
 
-COVERAGE(HMM_LerpV2, 1)
-static inline HMM_Vec2 HMM_LerpV2(HMM_Vec2 A, float Time, HMM_Vec2 B)
+COVERAGE(lerpV2, 1)
+static inline vec2 lerpV2(vec2 A, float Time, vec2 B)
 {
-    ASSERT_COVERED(HMM_LerpV2);
+    ASSERT_COVERED(lerpV2);
     return HMM_AddV2(HMM_MulV2F(A, 1.0f - Time), HMM_MulV2F(B, Time));
 }
 
-COVERAGE(HMM_LerpV3, 1)
-static inline HMM_Vec3 HMM_LerpV3(HMM_Vec3 A, float Time, HMM_Vec3 B)
+COVERAGE(lerpV3, 1)
+static inline vec3 lerpV3(vec3 A, float Time, vec3 B)
 {
-    ASSERT_COVERED(HMM_LerpV3);
+    ASSERT_COVERED(lerpV3);
     return HMM_AddV3(HMM_MulV3F(A, 1.0f - Time), HMM_MulV3F(B, Time));
 }
 
-COVERAGE(HMM_LerpV4, 1)
-static inline HMM_Vec4 HMM_LerpV4(HMM_Vec4 A, float Time, HMM_Vec4 B)
+COVERAGE(lerpV4, 1)
+static inline vec4 lerpV4(vec4 A, float Time, vec4 B)
 {
-    ASSERT_COVERED(HMM_LerpV4);
+    ASSERT_COVERED(lerpV4);
     return HMM_AddV4(HMM_MulV4F(A, 1.0f - Time), HMM_MulV4F(B, Time));
 }
 
@@ -1106,41 +1106,41 @@ static inline HMM_Vec4 HMM_LerpV4(HMM_Vec4 A, float Time, HMM_Vec4 B)
  */
 
 COVERAGE(HMM_LinearCombineV4M4, 1)
-static inline HMM_Vec4 HMM_LinearCombineV4M4(HMM_Vec4 Left, HMM_Mat4 Right)
+static inline vec4 HMM_LinearCombineV4M4(vec4 Left, mat4 Right)
 {
     ASSERT_COVERED(HMM_LinearCombineV4M4);
 
-    HMM_Vec4 Result;
+    vec4 Result;
 #ifdef HANDMADE_MATH__USE_SSE
-    Result.SSE = _mm_mul_ps(_mm_shuffle_ps(Left.SSE, Left.SSE, 0x00), Right.Columns[0].SSE);
-    Result.SSE = _mm_add_ps(Result.SSE, _mm_mul_ps(_mm_shuffle_ps(Left.SSE, Left.SSE, 0x55), Right.Columns[1].SSE));
-    Result.SSE = _mm_add_ps(Result.SSE, _mm_mul_ps(_mm_shuffle_ps(Left.SSE, Left.SSE, 0xaa), Right.Columns[2].SSE));
-    Result.SSE = _mm_add_ps(Result.SSE, _mm_mul_ps(_mm_shuffle_ps(Left.SSE, Left.SSE, 0xff), Right.Columns[3].SSE));
+    Result.SSE = _mm_mul_ps(_mm_shuffle_ps(Left.SSE, Left.SSE, 0x00), Right.columns[0].SSE);
+    Result.SSE = _mm_add_ps(Result.SSE, _mm_mul_ps(_mm_shuffle_ps(Left.SSE, Left.SSE, 0x55), Right.columns[1].SSE));
+    Result.SSE = _mm_add_ps(Result.SSE, _mm_mul_ps(_mm_shuffle_ps(Left.SSE, Left.SSE, 0xaa), Right.columns[2].SSE));
+    Result.SSE = _mm_add_ps(Result.SSE, _mm_mul_ps(_mm_shuffle_ps(Left.SSE, Left.SSE, 0xff), Right.columns[3].SSE));
 #elif defined(HANDMADE_MATH__USE_NEON)
-    Result.NEON = vmulq_laneq_f32(Right.Columns[0].NEON, Left.NEON, 0);
-    Result.NEON = vfmaq_laneq_f32(Result.NEON, Right.Columns[1].NEON, Left.NEON, 1);
-    Result.NEON = vfmaq_laneq_f32(Result.NEON, Right.Columns[2].NEON, Left.NEON, 2);
-    Result.NEON = vfmaq_laneq_f32(Result.NEON, Right.Columns[3].NEON, Left.NEON, 3);
+    Result.NEON = vmulq_laneq_f32(Right.columns[0].NEON, Left.NEON, 0);
+    Result.NEON = vfmaq_laneq_f32(Result.NEON, Right.columns[1].NEON, Left.NEON, 1);
+    Result.NEON = vfmaq_laneq_f32(Result.NEON, Right.columns[2].NEON, Left.NEON, 2);
+    Result.NEON = vfmaq_laneq_f32(Result.NEON, Right.columns[3].NEON, Left.NEON, 3);
 #else
-    Result.X = Left.Elements[0] * Right.Columns[0].X;
-    Result.Y = Left.Elements[0] * Right.Columns[0].Y;
-    Result.Z = Left.Elements[0] * Right.Columns[0].Z;
-    Result.W = Left.Elements[0] * Right.Columns[0].W;
+    Result.x = Left.elements[0] * Right.columns[0].x;
+    Result.y = Left.elements[0] * Right.columns[0].y;
+    Result.z = Left.elements[0] * Right.columns[0].z;
+    Result.w = Left.elements[0] * Right.columns[0].w;
 
-    Result.X += Left.Elements[1] * Right.Columns[1].X;
-    Result.Y += Left.Elements[1] * Right.Columns[1].Y;
-    Result.Z += Left.Elements[1] * Right.Columns[1].Z;
-    Result.W += Left.Elements[1] * Right.Columns[1].W;
+    Result.x += Left.elements[1] * Right.columns[1].x;
+    Result.y += Left.elements[1] * Right.columns[1].y;
+    Result.z += Left.elements[1] * Right.columns[1].z;
+    Result.w += Left.elements[1] * Right.columns[1].w;
 
-    Result.X += Left.Elements[2] * Right.Columns[2].X;
-    Result.Y += Left.Elements[2] * Right.Columns[2].Y;
-    Result.Z += Left.Elements[2] * Right.Columns[2].Z;
-    Result.W += Left.Elements[2] * Right.Columns[2].W;
+    Result.x += Left.elements[2] * Right.columns[2].x;
+    Result.y += Left.elements[2] * Right.columns[2].y;
+    Result.z += Left.elements[2] * Right.columns[2].z;
+    Result.w += Left.elements[2] * Right.columns[2].w;
 
-    Result.X += Left.Elements[3] * Right.Columns[3].X;
-    Result.Y += Left.Elements[3] * Right.Columns[3].Y;
-    Result.Z += Left.Elements[3] * Right.Columns[3].Z;
-    Result.W += Left.Elements[3] * Right.Columns[3].W;
+    Result.x += Left.elements[3] * Right.columns[3].x;
+    Result.y += Left.elements[3] * Right.columns[3].y;
+    Result.z += Left.elements[3] * Right.columns[3].z;
+    Result.w += Left.elements[3] * Right.columns[3].w;
 #endif
 
     return Result;
@@ -1151,145 +1151,145 @@ static inline HMM_Vec4 HMM_LinearCombineV4M4(HMM_Vec4 Left, HMM_Mat4 Right)
  */
 
 COVERAGE(HMM_M2, 1)
-static inline HMM_Mat2 HMM_M2(void)
+static inline mat2 HMM_M2(void)
 {
     ASSERT_COVERED(HMM_M2);
-    HMM_Mat2 Result = {0};
+    mat2 Result = {0};
     return Result;
 }
 
 COVERAGE(HMM_M2D, 1)
-static inline HMM_Mat2 HMM_M2D(float Diagonal)
+static inline mat2 HMM_M2D(float Diagonal)
 {
     ASSERT_COVERED(HMM_M2D);
 
-    HMM_Mat2 Result = {0};
-    Result.Elements[0][0] = Diagonal;
-    Result.Elements[1][1] = Diagonal;
+    mat2 Result = {0};
+    Result.elements[0][0] = Diagonal;
+    Result.elements[1][1] = Diagonal;
 
     return Result;
 }
 
 COVERAGE(HMM_TransposeM2, 1)
-static inline HMM_Mat2 HMM_TransposeM2(HMM_Mat2 Matrix)
+static inline mat2 HMM_TransposeM2(mat2 Matrix)
 {
     ASSERT_COVERED(HMM_TransposeM2);
 
-    HMM_Mat2 Result = Matrix;
+    mat2 Result = Matrix;
 
-    Result.Elements[0][1] = Matrix.Elements[1][0];
-    Result.Elements[1][0] = Matrix.Elements[0][1];
+    Result.elements[0][1] = Matrix.elements[1][0];
+    Result.elements[1][0] = Matrix.elements[0][1];
 
     return Result;
 }
 
 COVERAGE(HMM_AddM2, 1)
-static inline HMM_Mat2 HMM_AddM2(HMM_Mat2 Left, HMM_Mat2 Right)
+static inline mat2 HMM_AddM2(mat2 Left, mat2 Right)
 {
     ASSERT_COVERED(HMM_AddM2);
 
-    HMM_Mat2 Result;
+    mat2 Result;
 
-    Result.Elements[0][0] = Left.Elements[0][0] + Right.Elements[0][0];
-    Result.Elements[0][1] = Left.Elements[0][1] + Right.Elements[0][1];
-    Result.Elements[1][0] = Left.Elements[1][0] + Right.Elements[1][0];
-    Result.Elements[1][1] = Left.Elements[1][1] + Right.Elements[1][1];
+    Result.elements[0][0] = Left.elements[0][0] + Right.elements[0][0];
+    Result.elements[0][1] = Left.elements[0][1] + Right.elements[0][1];
+    Result.elements[1][0] = Left.elements[1][0] + Right.elements[1][0];
+    Result.elements[1][1] = Left.elements[1][1] + Right.elements[1][1];
 
     return Result;
 }
 
 COVERAGE(HMM_SubM2, 1)
-static inline HMM_Mat2 HMM_SubM2(HMM_Mat2 Left, HMM_Mat2 Right)
+static inline mat2 HMM_SubM2(mat2 Left, mat2 Right)
 {
     ASSERT_COVERED(HMM_SubM2);
 
-    HMM_Mat2 Result;
+    mat2 Result;
 
-    Result.Elements[0][0] = Left.Elements[0][0] - Right.Elements[0][0];
-    Result.Elements[0][1] = Left.Elements[0][1] - Right.Elements[0][1];
-    Result.Elements[1][0] = Left.Elements[1][0] - Right.Elements[1][0];
-    Result.Elements[1][1] = Left.Elements[1][1] - Right.Elements[1][1];
+    Result.elements[0][0] = Left.elements[0][0] - Right.elements[0][0];
+    Result.elements[0][1] = Left.elements[0][1] - Right.elements[0][1];
+    Result.elements[1][0] = Left.elements[1][0] - Right.elements[1][0];
+    Result.elements[1][1] = Left.elements[1][1] - Right.elements[1][1];
 
     return Result;
 }
 
 COVERAGE(HMM_MulM2V2, 1)
-static inline HMM_Vec2 HMM_MulM2V2(HMM_Mat2 Matrix, HMM_Vec2 Vector)
+static inline vec2 HMM_MulM2V2(mat2 Matrix, vec2 Vector)
 {
     ASSERT_COVERED(HMM_MulM2V2);
 
-    HMM_Vec2 Result;
+    vec2 Result;
 
-    Result.X = Vector.Elements[0] * Matrix.Columns[0].X;
-    Result.Y = Vector.Elements[0] * Matrix.Columns[0].Y;
+    Result.x = Vector.elements[0] * Matrix.columns[0].x;
+    Result.y = Vector.elements[0] * Matrix.columns[0].y;
 
-    Result.X += Vector.Elements[1] * Matrix.Columns[1].X;
-    Result.Y += Vector.Elements[1] * Matrix.Columns[1].Y;
+    Result.x += Vector.elements[1] * Matrix.columns[1].x;
+    Result.y += Vector.elements[1] * Matrix.columns[1].y;
 
     return Result;
 }
 
 COVERAGE(HMM_MulM2, 1)
-static inline HMM_Mat2 HMM_MulM2(HMM_Mat2 Left, HMM_Mat2 Right)
+static inline mat2 HMM_MulM2(mat2 Left, mat2 Right)
 {
     ASSERT_COVERED(HMM_MulM2);
 
-    HMM_Mat2 Result;
-    Result.Columns[0] = HMM_MulM2V2(Left, Right.Columns[0]);
-    Result.Columns[1] = HMM_MulM2V2(Left, Right.Columns[1]);
+    mat2 Result;
+    Result.columns[0] = HMM_MulM2V2(Left, Right.columns[0]);
+    Result.columns[1] = HMM_MulM2V2(Left, Right.columns[1]);
 
     return Result;
 }
 
 COVERAGE(HMM_MulM2F, 1)
-static inline HMM_Mat2 HMM_MulM2F(HMM_Mat2 Matrix, float Scalar)
+static inline mat2 HMM_MulM2F(mat2 Matrix, float Scalar)
 {
     ASSERT_COVERED(HMM_MulM2F);
 
-    HMM_Mat2 Result;
+    mat2 Result;
 
-    Result.Elements[0][0] = Matrix.Elements[0][0] * Scalar;
-    Result.Elements[0][1] = Matrix.Elements[0][1] * Scalar;
-    Result.Elements[1][0] = Matrix.Elements[1][0] * Scalar;
-    Result.Elements[1][1] = Matrix.Elements[1][1] * Scalar;
+    Result.elements[0][0] = Matrix.elements[0][0] * Scalar;
+    Result.elements[0][1] = Matrix.elements[0][1] * Scalar;
+    Result.elements[1][0] = Matrix.elements[1][0] * Scalar;
+    Result.elements[1][1] = Matrix.elements[1][1] * Scalar;
 
     return Result;
 }
 
 COVERAGE(HMM_DivM2F, 1)
-static inline HMM_Mat2 HMM_DivM2F(HMM_Mat2 Matrix, float Scalar)
+static inline mat2 HMM_DivM2F(mat2 Matrix, float Scalar)
 {
     ASSERT_COVERED(HMM_DivM2F);
 
-    HMM_Mat2 Result;
+    mat2 Result;
 
-    Result.Elements[0][0] = Matrix.Elements[0][0] / Scalar;
-    Result.Elements[0][1] = Matrix.Elements[0][1] / Scalar;
-    Result.Elements[1][0] = Matrix.Elements[1][0] / Scalar;
-    Result.Elements[1][1] = Matrix.Elements[1][1] / Scalar;
+    Result.elements[0][0] = Matrix.elements[0][0] / Scalar;
+    Result.elements[0][1] = Matrix.elements[0][1] / Scalar;
+    Result.elements[1][0] = Matrix.elements[1][0] / Scalar;
+    Result.elements[1][1] = Matrix.elements[1][1] / Scalar;
 
     return Result;
 }
 
 COVERAGE(HMM_DeterminantM2, 1)
-static inline float HMM_DeterminantM2(HMM_Mat2 Matrix)
+static inline float HMM_DeterminantM2(mat2 Matrix)
 {
     ASSERT_COVERED(HMM_DeterminantM2);
-    return Matrix.Elements[0][0]*Matrix.Elements[1][1] - Matrix.Elements[0][1]*Matrix.Elements[1][0];
+    return Matrix.elements[0][0]*Matrix.elements[1][1] - Matrix.elements[0][1]*Matrix.elements[1][0];
 }
 
 
 COVERAGE(HMM_InvGeneralM2, 1)
-static inline HMM_Mat2 HMM_InvGeneralM2(HMM_Mat2 Matrix)
+static inline mat2 HMM_InvGeneralM2(mat2 Matrix)
 {
     ASSERT_COVERED(HMM_InvGeneralM2);
 
-    HMM_Mat2 Result;
+    mat2 Result;
     float InvDeterminant = 1.0f / HMM_DeterminantM2(Matrix);
-    Result.Elements[0][0] = InvDeterminant * +Matrix.Elements[1][1];
-    Result.Elements[1][1] = InvDeterminant * +Matrix.Elements[0][0];
-    Result.Elements[0][1] = InvDeterminant * -Matrix.Elements[0][1];
-    Result.Elements[1][0] = InvDeterminant * -Matrix.Elements[1][0];
+    Result.elements[0][0] = InvDeterminant * +Matrix.elements[1][1];
+    Result.elements[1][1] = InvDeterminant * +Matrix.elements[0][0];
+    Result.elements[0][1] = InvDeterminant * -Matrix.elements[0][1];
+    Result.elements[1][0] = InvDeterminant * -Matrix.elements[1][0];
 
     return Result;
 }
@@ -1299,187 +1299,187 @@ static inline HMM_Mat2 HMM_InvGeneralM2(HMM_Mat2 Matrix)
  */
 
 COVERAGE(HMM_M3, 1)
-static inline HMM_Mat3 HMM_M3(void)
+static inline mat3 HMM_M3(void)
 {
     ASSERT_COVERED(HMM_M3);
-    HMM_Mat3 Result = {0};
+    mat3 Result = {0};
     return Result;
 }
 
 COVERAGE(HMM_M3D, 1)
-static inline HMM_Mat3 HMM_M3D(float Diagonal)
+static inline mat3 HMM_M3D(float Diagonal)
 {
     ASSERT_COVERED(HMM_M3D);
 
-    HMM_Mat3 Result = {0};
-    Result.Elements[0][0] = Diagonal;
-    Result.Elements[1][1] = Diagonal;
-    Result.Elements[2][2] = Diagonal;
+    mat3 Result = {0};
+    Result.elements[0][0] = Diagonal;
+    Result.elements[1][1] = Diagonal;
+    Result.elements[2][2] = Diagonal;
 
     return Result;
 }
 
 COVERAGE(HMM_TransposeM3, 1)
-static inline HMM_Mat3 HMM_TransposeM3(HMM_Mat3 Matrix)
+static inline mat3 HMM_TransposeM3(mat3 Matrix)
 {
     ASSERT_COVERED(HMM_TransposeM3);
 
-    HMM_Mat3 Result = Matrix;
+    mat3 Result = Matrix;
 
-    Result.Elements[0][1] = Matrix.Elements[1][0];
-    Result.Elements[0][2] = Matrix.Elements[2][0];
-    Result.Elements[1][0] = Matrix.Elements[0][1];
-    Result.Elements[1][2] = Matrix.Elements[2][1];
-    Result.Elements[2][1] = Matrix.Elements[1][2];
-    Result.Elements[2][0] = Matrix.Elements[0][2];
+    Result.elements[0][1] = Matrix.elements[1][0];
+    Result.elements[0][2] = Matrix.elements[2][0];
+    Result.elements[1][0] = Matrix.elements[0][1];
+    Result.elements[1][2] = Matrix.elements[2][1];
+    Result.elements[2][1] = Matrix.elements[1][2];
+    Result.elements[2][0] = Matrix.elements[0][2];
 
     return Result;
 }
 
 COVERAGE(HMM_AddM3, 1)
-static inline HMM_Mat3 HMM_AddM3(HMM_Mat3 Left, HMM_Mat3 Right)
+static inline mat3 HMM_AddM3(mat3 Left, mat3 Right)
 {
     ASSERT_COVERED(HMM_AddM3);
 
-    HMM_Mat3 Result;
+    mat3 Result;
 
-    Result.Elements[0][0] = Left.Elements[0][0] + Right.Elements[0][0];
-    Result.Elements[0][1] = Left.Elements[0][1] + Right.Elements[0][1];
-    Result.Elements[0][2] = Left.Elements[0][2] + Right.Elements[0][2];
-    Result.Elements[1][0] = Left.Elements[1][0] + Right.Elements[1][0];
-    Result.Elements[1][1] = Left.Elements[1][1] + Right.Elements[1][1];
-    Result.Elements[1][2] = Left.Elements[1][2] + Right.Elements[1][2];
-    Result.Elements[2][0] = Left.Elements[2][0] + Right.Elements[2][0];
-    Result.Elements[2][1] = Left.Elements[2][1] + Right.Elements[2][1];
-    Result.Elements[2][2] = Left.Elements[2][2] + Right.Elements[2][2];
+    Result.elements[0][0] = Left.elements[0][0] + Right.elements[0][0];
+    Result.elements[0][1] = Left.elements[0][1] + Right.elements[0][1];
+    Result.elements[0][2] = Left.elements[0][2] + Right.elements[0][2];
+    Result.elements[1][0] = Left.elements[1][0] + Right.elements[1][0];
+    Result.elements[1][1] = Left.elements[1][1] + Right.elements[1][1];
+    Result.elements[1][2] = Left.elements[1][2] + Right.elements[1][2];
+    Result.elements[2][0] = Left.elements[2][0] + Right.elements[2][0];
+    Result.elements[2][1] = Left.elements[2][1] + Right.elements[2][1];
+    Result.elements[2][2] = Left.elements[2][2] + Right.elements[2][2];
 
     return Result;
 }
 
 COVERAGE(HMM_SubM3, 1)
-static inline HMM_Mat3 HMM_SubM3(HMM_Mat3 Left, HMM_Mat3 Right)
+static inline mat3 HMM_SubM3(mat3 Left, mat3 Right)
 {
     ASSERT_COVERED(HMM_SubM3);
 
-    HMM_Mat3 Result;
+    mat3 Result;
 
-    Result.Elements[0][0] = Left.Elements[0][0] - Right.Elements[0][0];
-    Result.Elements[0][1] = Left.Elements[0][1] - Right.Elements[0][1];
-    Result.Elements[0][2] = Left.Elements[0][2] - Right.Elements[0][2];
-    Result.Elements[1][0] = Left.Elements[1][0] - Right.Elements[1][0];
-    Result.Elements[1][1] = Left.Elements[1][1] - Right.Elements[1][1];
-    Result.Elements[1][2] = Left.Elements[1][2] - Right.Elements[1][2];
-    Result.Elements[2][0] = Left.Elements[2][0] - Right.Elements[2][0];
-    Result.Elements[2][1] = Left.Elements[2][1] - Right.Elements[2][1];
-    Result.Elements[2][2] = Left.Elements[2][2] - Right.Elements[2][2];
+    Result.elements[0][0] = Left.elements[0][0] - Right.elements[0][0];
+    Result.elements[0][1] = Left.elements[0][1] - Right.elements[0][1];
+    Result.elements[0][2] = Left.elements[0][2] - Right.elements[0][2];
+    Result.elements[1][0] = Left.elements[1][0] - Right.elements[1][0];
+    Result.elements[1][1] = Left.elements[1][1] - Right.elements[1][1];
+    Result.elements[1][2] = Left.elements[1][2] - Right.elements[1][2];
+    Result.elements[2][0] = Left.elements[2][0] - Right.elements[2][0];
+    Result.elements[2][1] = Left.elements[2][1] - Right.elements[2][1];
+    Result.elements[2][2] = Left.elements[2][2] - Right.elements[2][2];
 
     return Result;
 }
 
 COVERAGE(HMM_MulM3V3, 1)
-static inline HMM_Vec3 HMM_MulM3V3(HMM_Mat3 Matrix, HMM_Vec3 Vector)
+static inline vec3 HMM_MulM3V3(mat3 Matrix, vec3 Vector)
 {
     ASSERT_COVERED(HMM_MulM3V3);
 
-    HMM_Vec3 Result;
+    vec3 Result;
 
-    Result.X = Vector.Elements[0] * Matrix.Columns[0].X;
-    Result.Y = Vector.Elements[0] * Matrix.Columns[0].Y;
-    Result.Z = Vector.Elements[0] * Matrix.Columns[0].Z;
+    Result.x = Vector.elements[0] * Matrix.columns[0].x;
+    Result.y = Vector.elements[0] * Matrix.columns[0].y;
+    Result.z = Vector.elements[0] * Matrix.columns[0].z;
 
-    Result.X += Vector.Elements[1] * Matrix.Columns[1].X;
-    Result.Y += Vector.Elements[1] * Matrix.Columns[1].Y;
-    Result.Z += Vector.Elements[1] * Matrix.Columns[1].Z;
+    Result.x += Vector.elements[1] * Matrix.columns[1].x;
+    Result.y += Vector.elements[1] * Matrix.columns[1].y;
+    Result.z += Vector.elements[1] * Matrix.columns[1].z;
 
-    Result.X += Vector.Elements[2] * Matrix.Columns[2].X;
-    Result.Y += Vector.Elements[2] * Matrix.Columns[2].Y;
-    Result.Z += Vector.Elements[2] * Matrix.Columns[2].Z;
+    Result.x += Vector.elements[2] * Matrix.columns[2].x;
+    Result.y += Vector.elements[2] * Matrix.columns[2].y;
+    Result.z += Vector.elements[2] * Matrix.columns[2].z;
 
     return Result;
 }
 
 COVERAGE(HMM_MulM3, 1)
-static inline HMM_Mat3 HMM_MulM3(HMM_Mat3 Left, HMM_Mat3 Right)
+static inline mat3 HMM_MulM3(mat3 Left, mat3 Right)
 {
     ASSERT_COVERED(HMM_MulM3);
 
-    HMM_Mat3 Result;
-    Result.Columns[0] = HMM_MulM3V3(Left, Right.Columns[0]);
-    Result.Columns[1] = HMM_MulM3V3(Left, Right.Columns[1]);
-    Result.Columns[2] = HMM_MulM3V3(Left, Right.Columns[2]);
+    mat3 Result;
+    Result.columns[0] = HMM_MulM3V3(Left, Right.columns[0]);
+    Result.columns[1] = HMM_MulM3V3(Left, Right.columns[1]);
+    Result.columns[2] = HMM_MulM3V3(Left, Right.columns[2]);
 
     return Result;
 }
 
 COVERAGE(HMM_MulM3F, 1)
-static inline HMM_Mat3 HMM_MulM3F(HMM_Mat3 Matrix, float Scalar)
+static inline mat3 HMM_MulM3F(mat3 Matrix, float Scalar)
 {
     ASSERT_COVERED(HMM_MulM3F);
 
-    HMM_Mat3 Result;
+    mat3 Result;
 
-    Result.Elements[0][0] = Matrix.Elements[0][0] * Scalar;
-    Result.Elements[0][1] = Matrix.Elements[0][1] * Scalar;
-    Result.Elements[0][2] = Matrix.Elements[0][2] * Scalar;
-    Result.Elements[1][0] = Matrix.Elements[1][0] * Scalar;
-    Result.Elements[1][1] = Matrix.Elements[1][1] * Scalar;
-    Result.Elements[1][2] = Matrix.Elements[1][2] * Scalar;
-    Result.Elements[2][0] = Matrix.Elements[2][0] * Scalar;
-    Result.Elements[2][1] = Matrix.Elements[2][1] * Scalar;
-    Result.Elements[2][2] = Matrix.Elements[2][2] * Scalar;
+    Result.elements[0][0] = Matrix.elements[0][0] * Scalar;
+    Result.elements[0][1] = Matrix.elements[0][1] * Scalar;
+    Result.elements[0][2] = Matrix.elements[0][2] * Scalar;
+    Result.elements[1][0] = Matrix.elements[1][0] * Scalar;
+    Result.elements[1][1] = Matrix.elements[1][1] * Scalar;
+    Result.elements[1][2] = Matrix.elements[1][2] * Scalar;
+    Result.elements[2][0] = Matrix.elements[2][0] * Scalar;
+    Result.elements[2][1] = Matrix.elements[2][1] * Scalar;
+    Result.elements[2][2] = Matrix.elements[2][2] * Scalar;
 
     return Result;
 }
 
 COVERAGE(HMM_DivM3F, 1)
-static inline HMM_Mat3 HMM_DivM3F(HMM_Mat3 Matrix, float Scalar)
+static inline mat3 HMM_DivM3F(mat3 Matrix, float Scalar)
 {
     ASSERT_COVERED(HMM_DivM3F);
 
-    HMM_Mat3 Result;
+    mat3 Result;
 
-    Result.Elements[0][0] = Matrix.Elements[0][0] / Scalar;
-    Result.Elements[0][1] = Matrix.Elements[0][1] / Scalar;
-    Result.Elements[0][2] = Matrix.Elements[0][2] / Scalar;
-    Result.Elements[1][0] = Matrix.Elements[1][0] / Scalar;
-    Result.Elements[1][1] = Matrix.Elements[1][1] / Scalar;
-    Result.Elements[1][2] = Matrix.Elements[1][2] / Scalar;
-    Result.Elements[2][0] = Matrix.Elements[2][0] / Scalar;
-    Result.Elements[2][1] = Matrix.Elements[2][1] / Scalar;
-    Result.Elements[2][2] = Matrix.Elements[2][2] / Scalar;
+    Result.elements[0][0] = Matrix.elements[0][0] / Scalar;
+    Result.elements[0][1] = Matrix.elements[0][1] / Scalar;
+    Result.elements[0][2] = Matrix.elements[0][2] / Scalar;
+    Result.elements[1][0] = Matrix.elements[1][0] / Scalar;
+    Result.elements[1][1] = Matrix.elements[1][1] / Scalar;
+    Result.elements[1][2] = Matrix.elements[1][2] / Scalar;
+    Result.elements[2][0] = Matrix.elements[2][0] / Scalar;
+    Result.elements[2][1] = Matrix.elements[2][1] / Scalar;
+    Result.elements[2][2] = Matrix.elements[2][2] / Scalar;
 
     return Result;
 }
 
 COVERAGE(HMM_DeterminantM3, 1)
-static inline float HMM_DeterminantM3(HMM_Mat3 Matrix)
+static inline float HMM_DeterminantM3(mat3 Matrix)
 {
     ASSERT_COVERED(HMM_DeterminantM3);
 
-    HMM_Mat3 Cross;
-    Cross.Columns[0] = HMM_Cross(Matrix.Columns[1], Matrix.Columns[2]);
-    Cross.Columns[1] = HMM_Cross(Matrix.Columns[2], Matrix.Columns[0]);
-    Cross.Columns[2] = HMM_Cross(Matrix.Columns[0], Matrix.Columns[1]);
+    mat3 Cross;
+    Cross.columns[0] = cross(Matrix.columns[1], Matrix.columns[2]);
+    Cross.columns[1] = cross(Matrix.columns[2], Matrix.columns[0]);
+    Cross.columns[2] = cross(Matrix.columns[0], Matrix.columns[1]);
 
-    return HMM_DotV3(Cross.Columns[2], Matrix.Columns[2]);
+    return HMM_DotV3(Cross.columns[2], Matrix.columns[2]);
 }
 
 COVERAGE(HMM_InvGeneralM3, 1)
-static inline HMM_Mat3 HMM_InvGeneralM3(HMM_Mat3 Matrix)
+static inline mat3 HMM_InvGeneralM3(mat3 Matrix)
 {
     ASSERT_COVERED(HMM_InvGeneralM3);
 
-    HMM_Mat3 Cross;
-    Cross.Columns[0] = HMM_Cross(Matrix.Columns[1], Matrix.Columns[2]);
-    Cross.Columns[1] = HMM_Cross(Matrix.Columns[2], Matrix.Columns[0]);
-    Cross.Columns[2] = HMM_Cross(Matrix.Columns[0], Matrix.Columns[1]);
+    mat3 Cross;
+    Cross.columns[0] = cross(Matrix.columns[1], Matrix.columns[2]);
+    Cross.columns[1] = cross(Matrix.columns[2], Matrix.columns[0]);
+    Cross.columns[2] = cross(Matrix.columns[0], Matrix.columns[1]);
 
-    float InvDeterminant = 1.0f / HMM_DotV3(Cross.Columns[2], Matrix.Columns[2]);
+    float InvDeterminant = 1.0f / HMM_DotV3(Cross.columns[2], Matrix.columns[2]);
 
-    HMM_Mat3 Result;
-    Result.Columns[0] = HMM_MulV3F(Cross.Columns[0], InvDeterminant);
-    Result.Columns[1] = HMM_MulV3F(Cross.Columns[1], InvDeterminant);
-    Result.Columns[2] = HMM_MulV3F(Cross.Columns[2], InvDeterminant);
+    mat3 Result;
+    Result.columns[0] = HMM_MulV3F(Cross.columns[0], InvDeterminant);
+    Result.columns[1] = HMM_MulV3F(Cross.columns[1], InvDeterminant);
+    Result.columns[2] = HMM_MulV3F(Cross.columns[2], InvDeterminant);
 
     return HMM_TransposeM3(Result);
 }
@@ -1489,221 +1489,221 @@ static inline HMM_Mat3 HMM_InvGeneralM3(HMM_Mat3 Matrix)
  */
 
 COVERAGE(HMM_M4, 1)
-static inline HMM_Mat4 HMM_M4(void)
+static inline mat4 HMM_M4(void)
 {
     ASSERT_COVERED(HMM_M4);
-    HMM_Mat4 Result = {0};
+    mat4 Result = {0};
     return Result;
 }
 
 COVERAGE(HMM_M4D, 1)
-static inline HMM_Mat4 HMM_M4D(float Diagonal)
+static inline mat4 HMM_M4D(float Diagonal)
 {
     ASSERT_COVERED(HMM_M4D);
 
-    HMM_Mat4 Result = {0};
-    Result.Elements[0][0] = Diagonal;
-    Result.Elements[1][1] = Diagonal;
-    Result.Elements[2][2] = Diagonal;
-    Result.Elements[3][3] = Diagonal;
+    mat4 Result = {0};
+    Result.elements[0][0] = Diagonal;
+    Result.elements[1][1] = Diagonal;
+    Result.elements[2][2] = Diagonal;
+    Result.elements[3][3] = Diagonal;
 
     return Result;
 }
 
 COVERAGE(HMM_TransposeM4, 1)
-static inline HMM_Mat4 HMM_TransposeM4(HMM_Mat4 Matrix)
+static inline mat4 HMM_TransposeM4(mat4 Matrix)
 {
     ASSERT_COVERED(HMM_TransposeM4);
 
-    HMM_Mat4 Result;
+    mat4 Result;
 #ifdef HANDMADE_MATH__USE_SSE
     Result = Matrix;
-    _MM_TRANSPOSE4_PS(Result.Columns[0].SSE, Result.Columns[1].SSE, Result.Columns[2].SSE, Result.Columns[3].SSE);
+    _MM_TRANSPOSE4_PS(Result.columns[0].SSE, Result.columns[1].SSE, Result.columns[2].SSE, Result.columns[3].SSE);
 #elif defined(HANDMADE_MATH__USE_NEON)
-    float32x4x4_t Transposed = vld4q_f32((float*)Matrix.Columns);
-    Result.Columns[0].NEON = Transposed.val[0];
-    Result.Columns[1].NEON = Transposed.val[1];
-    Result.Columns[2].NEON = Transposed.val[2];
-    Result.Columns[3].NEON = Transposed.val[3];
+    float32x4x4_t Transposed = vld4q_f32((float*)Matrix.columns);
+    Result.columns[0].NEON = Transposed.val[0];
+    Result.columns[1].NEON = Transposed.val[1];
+    Result.columns[2].NEON = Transposed.val[2];
+    Result.columns[3].NEON = Transposed.val[3];
 #else
-    Result.Elements[0][0] = Matrix.Elements[0][0];
-    Result.Elements[0][1] = Matrix.Elements[1][0];
-    Result.Elements[0][2] = Matrix.Elements[2][0];
-    Result.Elements[0][3] = Matrix.Elements[3][0];
-    Result.Elements[1][0] = Matrix.Elements[0][1];
-    Result.Elements[1][1] = Matrix.Elements[1][1];
-    Result.Elements[1][2] = Matrix.Elements[2][1];
-    Result.Elements[1][3] = Matrix.Elements[3][1];
-    Result.Elements[2][0] = Matrix.Elements[0][2];
-    Result.Elements[2][1] = Matrix.Elements[1][2];
-    Result.Elements[2][2] = Matrix.Elements[2][2];
-    Result.Elements[2][3] = Matrix.Elements[3][2];
-    Result.Elements[3][0] = Matrix.Elements[0][3];
-    Result.Elements[3][1] = Matrix.Elements[1][3];
-    Result.Elements[3][2] = Matrix.Elements[2][3];
-    Result.Elements[3][3] = Matrix.Elements[3][3];
+    Result.elements[0][0] = Matrix.elements[0][0];
+    Result.elements[0][1] = Matrix.elements[1][0];
+    Result.elements[0][2] = Matrix.elements[2][0];
+    Result.elements[0][3] = Matrix.elements[3][0];
+    Result.elements[1][0] = Matrix.elements[0][1];
+    Result.elements[1][1] = Matrix.elements[1][1];
+    Result.elements[1][2] = Matrix.elements[2][1];
+    Result.elements[1][3] = Matrix.elements[3][1];
+    Result.elements[2][0] = Matrix.elements[0][2];
+    Result.elements[2][1] = Matrix.elements[1][2];
+    Result.elements[2][2] = Matrix.elements[2][2];
+    Result.elements[2][3] = Matrix.elements[3][2];
+    Result.elements[3][0] = Matrix.elements[0][3];
+    Result.elements[3][1] = Matrix.elements[1][3];
+    Result.elements[3][2] = Matrix.elements[2][3];
+    Result.elements[3][3] = Matrix.elements[3][3];
 #endif
 
     return Result;
 }
 
 COVERAGE(HMM_AddM4, 1)
-static inline HMM_Mat4 HMM_AddM4(HMM_Mat4 Left, HMM_Mat4 Right)
+static inline mat4 HMM_AddM4(mat4 Left, mat4 Right)
 {
     ASSERT_COVERED(HMM_AddM4);
 
-    HMM_Mat4 Result;
+    mat4 Result;
 
-    Result.Columns[0] = HMM_AddV4(Left.Columns[0], Right.Columns[0]);
-    Result.Columns[1] = HMM_AddV4(Left.Columns[1], Right.Columns[1]);
-    Result.Columns[2] = HMM_AddV4(Left.Columns[2], Right.Columns[2]);
-    Result.Columns[3] = HMM_AddV4(Left.Columns[3], Right.Columns[3]);
+    Result.columns[0] = HMM_AddV4(Left.columns[0], Right.columns[0]);
+    Result.columns[1] = HMM_AddV4(Left.columns[1], Right.columns[1]);
+    Result.columns[2] = HMM_AddV4(Left.columns[2], Right.columns[2]);
+    Result.columns[3] = HMM_AddV4(Left.columns[3], Right.columns[3]);
 
     return Result;
 }
 
 COVERAGE(HMM_SubM4, 1)
-static inline HMM_Mat4 HMM_SubM4(HMM_Mat4 Left, HMM_Mat4 Right)
+static inline mat4 HMM_SubM4(mat4 Left, mat4 Right)
 {
     ASSERT_COVERED(HMM_SubM4);
 
-    HMM_Mat4 Result;
+    mat4 Result;
 
-    Result.Columns[0] = HMM_SubV4(Left.Columns[0], Right.Columns[0]);
-    Result.Columns[1] = HMM_SubV4(Left.Columns[1], Right.Columns[1]);
-    Result.Columns[2] = HMM_SubV4(Left.Columns[2], Right.Columns[2]);
-    Result.Columns[3] = HMM_SubV4(Left.Columns[3], Right.Columns[3]);
+    Result.columns[0] = HMM_SubV4(Left.columns[0], Right.columns[0]);
+    Result.columns[1] = HMM_SubV4(Left.columns[1], Right.columns[1]);
+    Result.columns[2] = HMM_SubV4(Left.columns[2], Right.columns[2]);
+    Result.columns[3] = HMM_SubV4(Left.columns[3], Right.columns[3]);
 
     return Result;
 }
 
 COVERAGE(HMM_MulM4, 1)
-static inline HMM_Mat4 HMM_MulM4(HMM_Mat4 Left, HMM_Mat4 Right)
+static inline mat4 HMM_MulM4(mat4 Left, mat4 Right)
 {
     ASSERT_COVERED(HMM_MulM4);
 
-    HMM_Mat4 Result;
-    Result.Columns[0] = HMM_LinearCombineV4M4(Right.Columns[0], Left);
-    Result.Columns[1] = HMM_LinearCombineV4M4(Right.Columns[1], Left);
-    Result.Columns[2] = HMM_LinearCombineV4M4(Right.Columns[2], Left);
-    Result.Columns[3] = HMM_LinearCombineV4M4(Right.Columns[3], Left);
+    mat4 Result;
+    Result.columns[0] = HMM_LinearCombineV4M4(Right.columns[0], Left);
+    Result.columns[1] = HMM_LinearCombineV4M4(Right.columns[1], Left);
+    Result.columns[2] = HMM_LinearCombineV4M4(Right.columns[2], Left);
+    Result.columns[3] = HMM_LinearCombineV4M4(Right.columns[3], Left);
 
     return Result;
 }
 
 COVERAGE(HMM_MulM4F, 1)
-static inline HMM_Mat4 HMM_MulM4F(HMM_Mat4 Matrix, float Scalar)
+static inline mat4 HMM_MulM4F(mat4 Matrix, float Scalar)
 {
     ASSERT_COVERED(HMM_MulM4F);
 
-    HMM_Mat4 Result;
+    mat4 Result;
 
 
 #ifdef HANDMADE_MATH__USE_SSE
     __m128 SSEScalar = _mm_set1_ps(Scalar);
-    Result.Columns[0].SSE = _mm_mul_ps(Matrix.Columns[0].SSE, SSEScalar);
-    Result.Columns[1].SSE = _mm_mul_ps(Matrix.Columns[1].SSE, SSEScalar);
-    Result.Columns[2].SSE = _mm_mul_ps(Matrix.Columns[2].SSE, SSEScalar);
-    Result.Columns[3].SSE = _mm_mul_ps(Matrix.Columns[3].SSE, SSEScalar);
+    Result.columns[0].SSE = _mm_mul_ps(Matrix.columns[0].SSE, SSEScalar);
+    Result.columns[1].SSE = _mm_mul_ps(Matrix.columns[1].SSE, SSEScalar);
+    Result.columns[2].SSE = _mm_mul_ps(Matrix.columns[2].SSE, SSEScalar);
+    Result.columns[3].SSE = _mm_mul_ps(Matrix.columns[3].SSE, SSEScalar);
 #elif defined(HANDMADE_MATH__USE_NEON)
-    Result.Columns[0].NEON = vmulq_n_f32(Matrix.Columns[0].NEON, Scalar);
-    Result.Columns[1].NEON = vmulq_n_f32(Matrix.Columns[1].NEON, Scalar);
-    Result.Columns[2].NEON = vmulq_n_f32(Matrix.Columns[2].NEON, Scalar);
-    Result.Columns[3].NEON = vmulq_n_f32(Matrix.Columns[3].NEON, Scalar);
+    Result.columns[0].NEON = vmulq_n_f32(Matrix.columns[0].NEON, Scalar);
+    Result.columns[1].NEON = vmulq_n_f32(Matrix.columns[1].NEON, Scalar);
+    Result.columns[2].NEON = vmulq_n_f32(Matrix.columns[2].NEON, Scalar);
+    Result.columns[3].NEON = vmulq_n_f32(Matrix.columns[3].NEON, Scalar);
 #else
-    Result.Elements[0][0] = Matrix.Elements[0][0] * Scalar;
-    Result.Elements[0][1] = Matrix.Elements[0][1] * Scalar;
-    Result.Elements[0][2] = Matrix.Elements[0][2] * Scalar;
-    Result.Elements[0][3] = Matrix.Elements[0][3] * Scalar;
-    Result.Elements[1][0] = Matrix.Elements[1][0] * Scalar;
-    Result.Elements[1][1] = Matrix.Elements[1][1] * Scalar;
-    Result.Elements[1][2] = Matrix.Elements[1][2] * Scalar;
-    Result.Elements[1][3] = Matrix.Elements[1][3] * Scalar;
-    Result.Elements[2][0] = Matrix.Elements[2][0] * Scalar;
-    Result.Elements[2][1] = Matrix.Elements[2][1] * Scalar;
-    Result.Elements[2][2] = Matrix.Elements[2][2] * Scalar;
-    Result.Elements[2][3] = Matrix.Elements[2][3] * Scalar;
-    Result.Elements[3][0] = Matrix.Elements[3][0] * Scalar;
-    Result.Elements[3][1] = Matrix.Elements[3][1] * Scalar;
-    Result.Elements[3][2] = Matrix.Elements[3][2] * Scalar;
-    Result.Elements[3][3] = Matrix.Elements[3][3] * Scalar;
+    Result.elements[0][0] = Matrix.elements[0][0] * Scalar;
+    Result.elements[0][1] = Matrix.elements[0][1] * Scalar;
+    Result.elements[0][2] = Matrix.elements[0][2] * Scalar;
+    Result.elements[0][3] = Matrix.elements[0][3] * Scalar;
+    Result.elements[1][0] = Matrix.elements[1][0] * Scalar;
+    Result.elements[1][1] = Matrix.elements[1][1] * Scalar;
+    Result.elements[1][2] = Matrix.elements[1][2] * Scalar;
+    Result.elements[1][3] = Matrix.elements[1][3] * Scalar;
+    Result.elements[2][0] = Matrix.elements[2][0] * Scalar;
+    Result.elements[2][1] = Matrix.elements[2][1] * Scalar;
+    Result.elements[2][2] = Matrix.elements[2][2] * Scalar;
+    Result.elements[2][3] = Matrix.elements[2][3] * Scalar;
+    Result.elements[3][0] = Matrix.elements[3][0] * Scalar;
+    Result.elements[3][1] = Matrix.elements[3][1] * Scalar;
+    Result.elements[3][2] = Matrix.elements[3][2] * Scalar;
+    Result.elements[3][3] = Matrix.elements[3][3] * Scalar;
 #endif
 
     return Result;
 }
 
 COVERAGE(HMM_MulM4V4, 1)
-static inline HMM_Vec4 HMM_MulM4V4(HMM_Mat4 Matrix, HMM_Vec4 Vector)
+static inline vec4 HMM_MulM4V4(mat4 Matrix, vec4 Vector)
 {
     ASSERT_COVERED(HMM_MulM4V4);
     return HMM_LinearCombineV4M4(Vector, Matrix);
 }
 
 COVERAGE(HMM_DivM4F, 1)
-static inline HMM_Mat4 HMM_DivM4F(HMM_Mat4 Matrix, float Scalar)
+static inline mat4 HMM_DivM4F(mat4 Matrix, float Scalar)
 {
     ASSERT_COVERED(HMM_DivM4F);
 
-    HMM_Mat4 Result;
+    mat4 Result;
 
 #ifdef HANDMADE_MATH__USE_SSE
     __m128 SSEScalar = _mm_set1_ps(Scalar);
-    Result.Columns[0].SSE = _mm_div_ps(Matrix.Columns[0].SSE, SSEScalar);
-    Result.Columns[1].SSE = _mm_div_ps(Matrix.Columns[1].SSE, SSEScalar);
-    Result.Columns[2].SSE = _mm_div_ps(Matrix.Columns[2].SSE, SSEScalar);
-    Result.Columns[3].SSE = _mm_div_ps(Matrix.Columns[3].SSE, SSEScalar);
+    Result.columns[0].SSE = _mm_div_ps(Matrix.columns[0].SSE, SSEScalar);
+    Result.columns[1].SSE = _mm_div_ps(Matrix.columns[1].SSE, SSEScalar);
+    Result.columns[2].SSE = _mm_div_ps(Matrix.columns[2].SSE, SSEScalar);
+    Result.columns[3].SSE = _mm_div_ps(Matrix.columns[3].SSE, SSEScalar);
 #elif defined(HANDMADE_MATH__USE_NEON)
     float32x4_t NEONScalar = vdupq_n_f32(Scalar);
-    Result.Columns[0].NEON = vdivq_f32(Matrix.Columns[0].NEON, NEONScalar);
-    Result.Columns[1].NEON = vdivq_f32(Matrix.Columns[1].NEON, NEONScalar);
-    Result.Columns[2].NEON = vdivq_f32(Matrix.Columns[2].NEON, NEONScalar);
-    Result.Columns[3].NEON = vdivq_f32(Matrix.Columns[3].NEON, NEONScalar);
+    Result.columns[0].NEON = vdivq_f32(Matrix.columns[0].NEON, NEONScalar);
+    Result.columns[1].NEON = vdivq_f32(Matrix.columns[1].NEON, NEONScalar);
+    Result.columns[2].NEON = vdivq_f32(Matrix.columns[2].NEON, NEONScalar);
+    Result.columns[3].NEON = vdivq_f32(Matrix.columns[3].NEON, NEONScalar);
 #else
-    Result.Elements[0][0] = Matrix.Elements[0][0] / Scalar;
-    Result.Elements[0][1] = Matrix.Elements[0][1] / Scalar;
-    Result.Elements[0][2] = Matrix.Elements[0][2] / Scalar;
-    Result.Elements[0][3] = Matrix.Elements[0][3] / Scalar;
-    Result.Elements[1][0] = Matrix.Elements[1][0] / Scalar;
-    Result.Elements[1][1] = Matrix.Elements[1][1] / Scalar;
-    Result.Elements[1][2] = Matrix.Elements[1][2] / Scalar;
-    Result.Elements[1][3] = Matrix.Elements[1][3] / Scalar;
-    Result.Elements[2][0] = Matrix.Elements[2][0] / Scalar;
-    Result.Elements[2][1] = Matrix.Elements[2][1] / Scalar;
-    Result.Elements[2][2] = Matrix.Elements[2][2] / Scalar;
-    Result.Elements[2][3] = Matrix.Elements[2][3] / Scalar;
-    Result.Elements[3][0] = Matrix.Elements[3][0] / Scalar;
-    Result.Elements[3][1] = Matrix.Elements[3][1] / Scalar;
-    Result.Elements[3][2] = Matrix.Elements[3][2] / Scalar;
-    Result.Elements[3][3] = Matrix.Elements[3][3] / Scalar;
+    Result.elements[0][0] = Matrix.elements[0][0] / Scalar;
+    Result.elements[0][1] = Matrix.elements[0][1] / Scalar;
+    Result.elements[0][2] = Matrix.elements[0][2] / Scalar;
+    Result.elements[0][3] = Matrix.elements[0][3] / Scalar;
+    Result.elements[1][0] = Matrix.elements[1][0] / Scalar;
+    Result.elements[1][1] = Matrix.elements[1][1] / Scalar;
+    Result.elements[1][2] = Matrix.elements[1][2] / Scalar;
+    Result.elements[1][3] = Matrix.elements[1][3] / Scalar;
+    Result.elements[2][0] = Matrix.elements[2][0] / Scalar;
+    Result.elements[2][1] = Matrix.elements[2][1] / Scalar;
+    Result.elements[2][2] = Matrix.elements[2][2] / Scalar;
+    Result.elements[2][3] = Matrix.elements[2][3] / Scalar;
+    Result.elements[3][0] = Matrix.elements[3][0] / Scalar;
+    Result.elements[3][1] = Matrix.elements[3][1] / Scalar;
+    Result.elements[3][2] = Matrix.elements[3][2] / Scalar;
+    Result.elements[3][3] = Matrix.elements[3][3] / Scalar;
 #endif
 
     return Result;
 }
 
 COVERAGE(HMM_DeterminantM4, 1)
-static inline float HMM_DeterminantM4(HMM_Mat4 Matrix)
+static inline float HMM_DeterminantM4(mat4 Matrix)
 {
     ASSERT_COVERED(HMM_DeterminantM4);
 
-    HMM_Vec3 C01 = HMM_Cross(Matrix.Columns[0].XYZ, Matrix.Columns[1].XYZ);
-    HMM_Vec3 C23 = HMM_Cross(Matrix.Columns[2].XYZ, Matrix.Columns[3].XYZ);
-    HMM_Vec3 B10 = HMM_SubV3(HMM_MulV3F(Matrix.Columns[0].XYZ, Matrix.Columns[1].W), HMM_MulV3F(Matrix.Columns[1].XYZ, Matrix.Columns[0].W));
-    HMM_Vec3 B32 = HMM_SubV3(HMM_MulV3F(Matrix.Columns[2].XYZ, Matrix.Columns[3].W), HMM_MulV3F(Matrix.Columns[3].XYZ, Matrix.Columns[2].W));
+    vec3 C01 = cross(Matrix.columns[0].xyz, Matrix.columns[1].xyz);
+    vec3 C23 = cross(Matrix.columns[2].xyz, Matrix.columns[3].xyz);
+    vec3 B10 = HMM_SubV3(HMM_MulV3F(Matrix.columns[0].xyz, Matrix.columns[1].w), HMM_MulV3F(Matrix.columns[1].xyz, Matrix.columns[0].w));
+    vec3 B32 = HMM_SubV3(HMM_MulV3F(Matrix.columns[2].xyz, Matrix.columns[3].w), HMM_MulV3F(Matrix.columns[3].xyz, Matrix.columns[2].w));
 
     return HMM_DotV3(C01, B32) + HMM_DotV3(C23, B10);
 }
 
 COVERAGE(HMM_InvGeneralM4, 1)
-// Returns a general-purpose inverse of an HMM_Mat4. Note that special-purpose inverses of many transformations
+// Returns a general-purpose inverse of an mat4. Note that special-purpose inverses of many transformations
 // are available and will be more efficient.
-static inline HMM_Mat4 HMM_InvGeneralM4(HMM_Mat4 Matrix)
+static inline mat4 HMM_InvGeneralM4(mat4 Matrix)
 {
     ASSERT_COVERED(HMM_InvGeneralM4);
 
-    HMM_Vec3 C01 = HMM_Cross(Matrix.Columns[0].XYZ, Matrix.Columns[1].XYZ);
-    HMM_Vec3 C23 = HMM_Cross(Matrix.Columns[2].XYZ, Matrix.Columns[3].XYZ);
-    HMM_Vec3 B10 = HMM_SubV3(HMM_MulV3F(Matrix.Columns[0].XYZ, Matrix.Columns[1].W), HMM_MulV3F(Matrix.Columns[1].XYZ, Matrix.Columns[0].W));
-    HMM_Vec3 B32 = HMM_SubV3(HMM_MulV3F(Matrix.Columns[2].XYZ, Matrix.Columns[3].W), HMM_MulV3F(Matrix.Columns[3].XYZ, Matrix.Columns[2].W));
+    vec3 C01 = cross(Matrix.columns[0].xyz, Matrix.columns[1].xyz);
+    vec3 C23 = cross(Matrix.columns[2].xyz, Matrix.columns[3].xyz);
+    vec3 B10 = HMM_SubV3(HMM_MulV3F(Matrix.columns[0].xyz, Matrix.columns[1].w), HMM_MulV3F(Matrix.columns[1].xyz, Matrix.columns[0].w));
+    vec3 B32 = HMM_SubV3(HMM_MulV3F(Matrix.columns[2].xyz, Matrix.columns[3].w), HMM_MulV3F(Matrix.columns[3].xyz, Matrix.columns[2].w));
 
     float InvDeterminant = 1.0f / (HMM_DotV3(C01, B32) + HMM_DotV3(C23, B10));
     C01 = HMM_MulV3F(C01, InvDeterminant);
@@ -1711,11 +1711,11 @@ static inline HMM_Mat4 HMM_InvGeneralM4(HMM_Mat4 Matrix)
     B10 = HMM_MulV3F(B10, InvDeterminant);
     B32 = HMM_MulV3F(B32, InvDeterminant);
 
-    HMM_Mat4 Result;
-    Result.Columns[0] = HMM_V4V(HMM_AddV3(HMM_Cross(Matrix.Columns[1].XYZ, B32), HMM_MulV3F(C23, Matrix.Columns[1].W)), -HMM_DotV3(Matrix.Columns[1].XYZ, C23));
-    Result.Columns[1] = HMM_V4V(HMM_SubV3(HMM_Cross(B32, Matrix.Columns[0].XYZ), HMM_MulV3F(C23, Matrix.Columns[0].W)), +HMM_DotV3(Matrix.Columns[0].XYZ, C23));
-    Result.Columns[2] = HMM_V4V(HMM_AddV3(HMM_Cross(Matrix.Columns[3].XYZ, B10), HMM_MulV3F(C01, Matrix.Columns[3].W)), -HMM_DotV3(Matrix.Columns[3].XYZ, C01));
-    Result.Columns[3] = HMM_V4V(HMM_SubV3(HMM_Cross(B10, Matrix.Columns[2].XYZ), HMM_MulV3F(C01, Matrix.Columns[2].W)), +HMM_DotV3(Matrix.Columns[2].XYZ, C01));
+    mat4 Result;
+    Result.columns[0] = v4V(HMM_AddV3(cross(Matrix.columns[1].xyz, B32), HMM_MulV3F(C23, Matrix.columns[1].w)), -HMM_DotV3(Matrix.columns[1].xyz, C23));
+    Result.columns[1] = v4V(HMM_SubV3(cross(B32, Matrix.columns[0].xyz), HMM_MulV3F(C23, Matrix.columns[0].w)), +HMM_DotV3(Matrix.columns[0].xyz, C23));
+    Result.columns[2] = v4V(HMM_AddV3(cross(Matrix.columns[3].xyz, B10), HMM_MulV3F(C01, Matrix.columns[3].w)), -HMM_DotV3(Matrix.columns[3].xyz, C01));
+    Result.columns[3] = v4V(HMM_SubV3(cross(B10, Matrix.columns[2].xyz), HMM_MulV3F(C01, Matrix.columns[2].w)), +HMM_DotV3(Matrix.columns[2].xyz, C01));
 
     return HMM_TransposeM4(Result);
 }
@@ -1728,20 +1728,20 @@ COVERAGE(HMM_Orthographic_RH_NO, 1)
 // Produces a right-handed orthographic projection matrix with Z ranging from -1 to 1 (the GL convention).
 // Left, Right, Bottom, and Top specify the coordinates of their respective clipping planes.
 // Near and Far specify the distances to the near and far clipping planes.
-static inline HMM_Mat4 HMM_Orthographic_RH_NO(float Left, float Right, float Bottom, float Top, float Near, float Far)
+static inline mat4 HMM_Orthographic_RH_NO(float Left, float Right, float Bottom, float Top, float Near, float Far)
 {
     ASSERT_COVERED(HMM_Orthographic_RH_NO);
 
-    HMM_Mat4 Result = {0};
+    mat4 Result = {0};
 
-    Result.Elements[0][0] = 2.0f / (Right - Left);
-    Result.Elements[1][1] = 2.0f / (Top - Bottom);
-    Result.Elements[2][2] = 2.0f / (Near - Far);
-    Result.Elements[3][3] = 1.0f;
+    Result.elements[0][0] = 2.0f / (Right - Left);
+    Result.elements[1][1] = 2.0f / (Top - Bottom);
+    Result.elements[2][2] = 2.0f / (Near - Far);
+    Result.elements[3][3] = 1.0f;
 
-    Result.Elements[3][0] = (Left + Right) / (Left - Right);
-    Result.Elements[3][1] = (Bottom + Top) / (Bottom - Top);
-    Result.Elements[3][2] = (Near + Far) / (Near - Far);
+    Result.elements[3][0] = (Left + Right) / (Left - Right);
+    Result.elements[3][1] = (Bottom + Top) / (Bottom - Top);
+    Result.elements[3][2] = (Near + Far) / (Near - Far);
 
     return Result;
 }
@@ -1750,20 +1750,20 @@ COVERAGE(HMM_Orthographic_RH_ZO, 1)
 // Produces a right-handed orthographic projection matrix with Z ranging from 0 to 1 (the DirectX convention).
 // Left, Right, Bottom, and Top specify the coordinates of their respective clipping planes.
 // Near and Far specify the distances to the near and far clipping planes.
-static inline HMM_Mat4 HMM_Orthographic_RH_ZO(float Left, float Right, float Bottom, float Top, float Near, float Far)
+static inline mat4 HMM_Orthographic_RH_ZO(float Left, float Right, float Bottom, float Top, float Near, float Far)
 {
     ASSERT_COVERED(HMM_Orthographic_RH_ZO);
 
-    HMM_Mat4 Result = {0};
+    mat4 Result = {0};
 
-    Result.Elements[0][0] = 2.0f / (Right - Left);
-    Result.Elements[1][1] = 2.0f / (Top - Bottom);
-    Result.Elements[2][2] = 1.0f / (Near - Far);
-    Result.Elements[3][3] = 1.0f;
+    Result.elements[0][0] = 2.0f / (Right - Left);
+    Result.elements[1][1] = 2.0f / (Top - Bottom);
+    Result.elements[2][2] = 1.0f / (Near - Far);
+    Result.elements[3][3] = 1.0f;
 
-    Result.Elements[3][0] = (Left + Right) / (Left - Right);
-    Result.Elements[3][1] = (Bottom + Top) / (Bottom - Top);
-    Result.Elements[3][2] = (Near) / (Near - Far);
+    Result.elements[3][0] = (Left + Right) / (Left - Right);
+    Result.elements[3][1] = (Bottom + Top) / (Bottom - Top);
+    Result.elements[3][2] = (Near) / (Near - Far);
 
     return Result;
 }
@@ -1772,12 +1772,12 @@ COVERAGE(HMM_Orthographic_LH_NO, 1)
 // Produces a left-handed orthographic projection matrix with Z ranging from -1 to 1 (the GL convention).
 // Left, Right, Bottom, and Top specify the coordinates of their respective clipping planes.
 // Near and Far specify the distances to the near and far clipping planes.
-static inline HMM_Mat4 HMM_Orthographic_LH_NO(float Left, float Right, float Bottom, float Top, float Near, float Far)
+static inline mat4 HMM_Orthographic_LH_NO(float Left, float Right, float Bottom, float Top, float Near, float Far)
 {
     ASSERT_COVERED(HMM_Orthographic_LH_NO);
 
-    HMM_Mat4 Result = HMM_Orthographic_RH_NO(Left, Right, Bottom, Top, Near, Far);
-    Result.Elements[2][2] = -Result.Elements[2][2];
+    mat4 Result = HMM_Orthographic_RH_NO(Left, Right, Bottom, Top, Near, Far);
+    Result.elements[2][2] = -Result.elements[2][2];
 
     return Result;
 }
@@ -1786,12 +1786,12 @@ COVERAGE(HMM_Orthographic_LH_ZO, 1)
 // Produces a left-handed orthographic projection matrix with Z ranging from 0 to 1 (the DirectX convention).
 // Left, Right, Bottom, and Top specify the coordinates of their respective clipping planes.
 // Near and Far specify the distances to the near and far clipping planes.
-static inline HMM_Mat4 HMM_Orthographic_LH_ZO(float Left, float Right, float Bottom, float Top, float Near, float Far)
+static inline mat4 HMM_Orthographic_LH_ZO(float Left, float Right, float Bottom, float Top, float Near, float Far)
 {
     ASSERT_COVERED(HMM_Orthographic_LH_ZO);
 
-    HMM_Mat4 Result = HMM_Orthographic_RH_ZO(Left, Right, Bottom, Top, Near, Far);
-    Result.Elements[2][2] = -Result.Elements[2][2];
+    mat4 Result = HMM_Orthographic_RH_ZO(Left, Right, Bottom, Top, Near, Far);
+    Result.elements[2][2] = -Result.elements[2][2];
 
     return Result;
 }
@@ -1799,153 +1799,153 @@ static inline HMM_Mat4 HMM_Orthographic_LH_ZO(float Left, float Right, float Bot
 COVERAGE(HMM_InvOrthographic, 1)
 // Returns an inverse for the given orthographic projection matrix. Works for all orthographic
 // projection matrices, regardless of handedness or NDC convention.
-static inline HMM_Mat4 HMM_InvOrthographic(HMM_Mat4 OrthoMatrix)
+static inline mat4 HMM_InvOrthographic(mat4 OrthoMatrix)
 {
     ASSERT_COVERED(HMM_InvOrthographic);
 
-    HMM_Mat4 Result = {0};
-    Result.Elements[0][0] = 1.0f / OrthoMatrix.Elements[0][0];
-    Result.Elements[1][1] = 1.0f / OrthoMatrix.Elements[1][1];
-    Result.Elements[2][2] = 1.0f / OrthoMatrix.Elements[2][2];
-    Result.Elements[3][3] = 1.0f;
+    mat4 Result = {0};
+    Result.elements[0][0] = 1.0f / OrthoMatrix.elements[0][0];
+    Result.elements[1][1] = 1.0f / OrthoMatrix.elements[1][1];
+    Result.elements[2][2] = 1.0f / OrthoMatrix.elements[2][2];
+    Result.elements[3][3] = 1.0f;
 
-    Result.Elements[3][0] = -OrthoMatrix.Elements[3][0] * Result.Elements[0][0];
-    Result.Elements[3][1] = -OrthoMatrix.Elements[3][1] * Result.Elements[1][1];
-    Result.Elements[3][2] = -OrthoMatrix.Elements[3][2] * Result.Elements[2][2];
+    Result.elements[3][0] = -OrthoMatrix.elements[3][0] * Result.elements[0][0];
+    Result.elements[3][1] = -OrthoMatrix.elements[3][1] * Result.elements[1][1];
+    Result.elements[3][2] = -OrthoMatrix.elements[3][2] * Result.elements[2][2];
 
     return Result;
 }
 
 COVERAGE(HMM_Perspective_RH_NO, 1)
-static inline HMM_Mat4 HMM_Perspective_RH_NO(float FOV, float AspectRatio, float Near, float Far)
+static inline mat4 HMM_Perspective_RH_NO(float FOV, float AspectRatio, float Near, float Far)
 {
     ASSERT_COVERED(HMM_Perspective_RH_NO);
 
-    HMM_Mat4 Result = {0};
+    mat4 Result = {0};
 
     // See https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluPerspective.xml
 
     float Cotangent = 1.0f / HMM_TanF(FOV / 2.0f);
-    Result.Elements[0][0] = Cotangent / AspectRatio;
-    Result.Elements[1][1] = Cotangent;
-    Result.Elements[2][3] = -1.0f;
+    Result.elements[0][0] = Cotangent / AspectRatio;
+    Result.elements[1][1] = Cotangent;
+    Result.elements[2][3] = -1.0f;
 
-    Result.Elements[2][2] = (Near + Far) / (Near - Far);
-    Result.Elements[3][2] = (2.0f * Near * Far) / (Near - Far);
+    Result.elements[2][2] = (Near + Far) / (Near - Far);
+    Result.elements[3][2] = (2.0f * Near * Far) / (Near - Far);
 
     return Result;
 }
 
 COVERAGE(HMM_Perspective_RH_ZO, 1)
-static inline HMM_Mat4 HMM_Perspective_RH_ZO(float FOV, float AspectRatio, float Near, float Far)
+static inline mat4 HMM_Perspective_RH_ZO(float FOV, float AspectRatio, float Near, float Far)
 {
     ASSERT_COVERED(HMM_Perspective_RH_ZO);
 
-    HMM_Mat4 Result = {0};
+    mat4 Result = {0};
 
     // See https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluPerspective.xml
 
     float Cotangent = 1.0f / HMM_TanF(FOV / 2.0f);
-    Result.Elements[0][0] = Cotangent / AspectRatio;
-    Result.Elements[1][1] = Cotangent;
-    Result.Elements[2][3] = -1.0f;
+    Result.elements[0][0] = Cotangent / AspectRatio;
+    Result.elements[1][1] = Cotangent;
+    Result.elements[2][3] = -1.0f;
 
-    Result.Elements[2][2] = (Far) / (Near - Far);
-    Result.Elements[3][2] = (Near * Far) / (Near - Far);
+    Result.elements[2][2] = (Far) / (Near - Far);
+    Result.elements[3][2] = (Near * Far) / (Near - Far);
 
     return Result;
 }
 
 COVERAGE(HMM_Perspective_LH_NO, 1)
-static inline HMM_Mat4 HMM_Perspective_LH_NO(float FOV, float AspectRatio, float Near, float Far)
+static inline mat4 HMM_Perspective_LH_NO(float FOV, float AspectRatio, float Near, float Far)
 {
     ASSERT_COVERED(HMM_Perspective_LH_NO);
 
-    HMM_Mat4 Result = HMM_Perspective_RH_NO(FOV, AspectRatio, Near, Far);
-    Result.Elements[2][2] = -Result.Elements[2][2];
-    Result.Elements[2][3] = -Result.Elements[2][3];
+    mat4 Result = HMM_Perspective_RH_NO(FOV, AspectRatio, Near, Far);
+    Result.elements[2][2] = -Result.elements[2][2];
+    Result.elements[2][3] = -Result.elements[2][3];
 
     return Result;
 }
 
 COVERAGE(HMM_Perspective_LH_ZO, 1)
-static inline HMM_Mat4 HMM_Perspective_LH_ZO(float FOV, float AspectRatio, float Near, float Far)
+static inline mat4 HMM_Perspective_LH_ZO(float FOV, float AspectRatio, float Near, float Far)
 {
     ASSERT_COVERED(HMM_Perspective_LH_ZO);
 
-    HMM_Mat4 Result = HMM_Perspective_RH_ZO(FOV, AspectRatio, Near, Far);
-    Result.Elements[2][2] = -Result.Elements[2][2];
-    Result.Elements[2][3] = -Result.Elements[2][3];
+    mat4 Result = HMM_Perspective_RH_ZO(FOV, AspectRatio, Near, Far);
+    Result.elements[2][2] = -Result.elements[2][2];
+    Result.elements[2][3] = -Result.elements[2][3];
 
     return Result;
 }
 
 COVERAGE(HMM_InvPerspective_RH, 1)
-static inline HMM_Mat4 HMM_InvPerspective_RH(HMM_Mat4 PerspectiveMatrix)
+static inline mat4 HMM_InvPerspective_RH(mat4 PerspectiveMatrix)
 {
     ASSERT_COVERED(HMM_InvPerspective_RH);
 
-    HMM_Mat4 Result = {0};
-    Result.Elements[0][0] = 1.0f / PerspectiveMatrix.Elements[0][0];
-    Result.Elements[1][1] = 1.0f / PerspectiveMatrix.Elements[1][1];
-    Result.Elements[2][2] = 0.0f;
+    mat4 Result = {0};
+    Result.elements[0][0] = 1.0f / PerspectiveMatrix.elements[0][0];
+    Result.elements[1][1] = 1.0f / PerspectiveMatrix.elements[1][1];
+    Result.elements[2][2] = 0.0f;
 
-    Result.Elements[2][3] = 1.0f / PerspectiveMatrix.Elements[3][2];
-    Result.Elements[3][3] = PerspectiveMatrix.Elements[2][2] * Result.Elements[2][3];
-    Result.Elements[3][2] = PerspectiveMatrix.Elements[2][3];
+    Result.elements[2][3] = 1.0f / PerspectiveMatrix.elements[3][2];
+    Result.elements[3][3] = PerspectiveMatrix.elements[2][2] * Result.elements[2][3];
+    Result.elements[3][2] = PerspectiveMatrix.elements[2][3];
 
     return Result;
 }
 
 COVERAGE(HMM_InvPerspective_LH, 1)
-static inline HMM_Mat4 HMM_InvPerspective_LH(HMM_Mat4 PerspectiveMatrix)
+static inline mat4 HMM_InvPerspective_LH(mat4 PerspectiveMatrix)
 {
     ASSERT_COVERED(HMM_InvPerspective_LH);
 
-    HMM_Mat4 Result = {0};
-    Result.Elements[0][0] = 1.0f / PerspectiveMatrix.Elements[0][0];
-    Result.Elements[1][1] = 1.0f / PerspectiveMatrix.Elements[1][1];
-    Result.Elements[2][2] = 0.0f;
+    mat4 Result = {0};
+    Result.elements[0][0] = 1.0f / PerspectiveMatrix.elements[0][0];
+    Result.elements[1][1] = 1.0f / PerspectiveMatrix.elements[1][1];
+    Result.elements[2][2] = 0.0f;
 
-    Result.Elements[2][3] = 1.0f / PerspectiveMatrix.Elements[3][2];
-    Result.Elements[3][3] = PerspectiveMatrix.Elements[2][2] * -Result.Elements[2][3];
-    Result.Elements[3][2] = PerspectiveMatrix.Elements[2][3];
+    Result.elements[2][3] = 1.0f / PerspectiveMatrix.elements[3][2];
+    Result.elements[3][3] = PerspectiveMatrix.elements[2][2] * -Result.elements[2][3];
+    Result.elements[3][2] = PerspectiveMatrix.elements[2][3];
 
     return Result;
 }
 
 COVERAGE(HMM_Translate, 1)
-static inline HMM_Mat4 HMM_Translate(HMM_Vec3 Translation)
+static inline mat4 HMM_Translate(vec3 Translation)
 {
     ASSERT_COVERED(HMM_Translate);
 
-    HMM_Mat4 Result = HMM_M4D(1.0f);
-    Result.Elements[3][0] = Translation.X;
-    Result.Elements[3][1] = Translation.Y;
-    Result.Elements[3][2] = Translation.Z;
+    mat4 Result = HMM_M4D(1.0f);
+    Result.elements[3][0] = Translation.x;
+    Result.elements[3][1] = Translation.y;
+    Result.elements[3][2] = Translation.z;
 
     return Result;
 }
 
 COVERAGE(HMM_InvTranslate, 1)
-static inline HMM_Mat4 HMM_InvTranslate(HMM_Mat4 TranslationMatrix)
+static inline mat4 HMM_InvTranslate(mat4 TranslationMatrix)
 {
     ASSERT_COVERED(HMM_InvTranslate);
 
-    HMM_Mat4 Result = TranslationMatrix;
-    Result.Elements[3][0] = -Result.Elements[3][0];
-    Result.Elements[3][1] = -Result.Elements[3][1];
-    Result.Elements[3][2] = -Result.Elements[3][2];
+    mat4 Result = TranslationMatrix;
+    Result.elements[3][0] = -Result.elements[3][0];
+    Result.elements[3][1] = -Result.elements[3][1];
+    Result.elements[3][2] = -Result.elements[3][2];
 
     return Result;
 }
 
 COVERAGE(HMM_Rotate_RH, 1)
-static inline HMM_Mat4 HMM_Rotate_RH(float Angle, HMM_Vec3 Axis)
+static inline mat4 HMM_Rotate_RH(float Angle, vec3 Axis)
 {
     ASSERT_COVERED(HMM_Rotate_RH);
 
-    HMM_Mat4 Result = HMM_M4D(1.0f);
+    mat4 Result = HMM_M4D(1.0f);
 
     Axis = HMM_NormV3(Axis);
 
@@ -1953,23 +1953,23 @@ static inline HMM_Mat4 HMM_Rotate_RH(float Angle, HMM_Vec3 Axis)
     float CosTheta = HMM_CosF(Angle);
     float CosValue = 1.0f - CosTheta;
 
-    Result.Elements[0][0] = (Axis.X * Axis.X * CosValue) + CosTheta;
-    Result.Elements[0][1] = (Axis.X * Axis.Y * CosValue) + (Axis.Z * SinTheta);
-    Result.Elements[0][2] = (Axis.X * Axis.Z * CosValue) - (Axis.Y * SinTheta);
+    Result.elements[0][0] = (Axis.x * Axis.x * CosValue) + CosTheta;
+    Result.elements[0][1] = (Axis.x * Axis.y * CosValue) + (Axis.z * SinTheta);
+    Result.elements[0][2] = (Axis.x * Axis.z * CosValue) - (Axis.y * SinTheta);
 
-    Result.Elements[1][0] = (Axis.Y * Axis.X * CosValue) - (Axis.Z * SinTheta);
-    Result.Elements[1][1] = (Axis.Y * Axis.Y * CosValue) + CosTheta;
-    Result.Elements[1][2] = (Axis.Y * Axis.Z * CosValue) + (Axis.X * SinTheta);
+    Result.elements[1][0] = (Axis.y * Axis.x * CosValue) - (Axis.z * SinTheta);
+    Result.elements[1][1] = (Axis.y * Axis.y * CosValue) + CosTheta;
+    Result.elements[1][2] = (Axis.y * Axis.z * CosValue) + (Axis.x * SinTheta);
 
-    Result.Elements[2][0] = (Axis.Z * Axis.X * CosValue) + (Axis.Y * SinTheta);
-    Result.Elements[2][1] = (Axis.Z * Axis.Y * CosValue) - (Axis.X * SinTheta);
-    Result.Elements[2][2] = (Axis.Z * Axis.Z * CosValue) + CosTheta;
+    Result.elements[2][0] = (Axis.z * Axis.x * CosValue) + (Axis.y * SinTheta);
+    Result.elements[2][1] = (Axis.z * Axis.y * CosValue) - (Axis.x * SinTheta);
+    Result.elements[2][2] = (Axis.z * Axis.z * CosValue) + CosTheta;
 
     return Result;
 }
 
 COVERAGE(HMM_Rotate_LH, 1)
-static inline HMM_Mat4 HMM_Rotate_LH(float Angle, HMM_Vec3 Axis)
+static inline mat4 HMM_Rotate_LH(float Angle, vec3 Axis)
 {
     ASSERT_COVERED(HMM_Rotate_LH);
     /* NOTE(lcf): Matrix will be inverse/transpose of RH. */
@@ -1977,112 +1977,112 @@ static inline HMM_Mat4 HMM_Rotate_LH(float Angle, HMM_Vec3 Axis)
 }
 
 COVERAGE(HMM_InvRotate, 1)
-static inline HMM_Mat4 HMM_InvRotate(HMM_Mat4 RotationMatrix)
+static inline mat4 HMM_InvRotate(mat4 RotationMatrix)
 {
     ASSERT_COVERED(HMM_InvRotate);
     return HMM_TransposeM4(RotationMatrix);
 }
 
 COVERAGE(HMM_Scale, 1)
-static inline HMM_Mat4 HMM_Scale(HMM_Vec3 Scale)
+static inline mat4 HMM_Scale(vec3 Scale)
 {
     ASSERT_COVERED(HMM_Scale);
 
-    HMM_Mat4 Result = HMM_M4D(1.0f);
-    Result.Elements[0][0] = Scale.X;
-    Result.Elements[1][1] = Scale.Y;
-    Result.Elements[2][2] = Scale.Z;
+    mat4 Result = HMM_M4D(1.0f);
+    Result.elements[0][0] = Scale.x;
+    Result.elements[1][1] = Scale.y;
+    Result.elements[2][2] = Scale.z;
 
     return Result;
 }
 
 COVERAGE(HMM_InvScale, 1)
-static inline HMM_Mat4 HMM_InvScale(HMM_Mat4 ScaleMatrix)
+static inline mat4 HMM_InvScale(mat4 ScaleMatrix)
 {
     ASSERT_COVERED(HMM_InvScale);
 
-    HMM_Mat4 Result = ScaleMatrix;
-    Result.Elements[0][0] = 1.0f / Result.Elements[0][0];
-    Result.Elements[1][1] = 1.0f / Result.Elements[1][1];
-    Result.Elements[2][2] = 1.0f / Result.Elements[2][2];
+    mat4 Result = ScaleMatrix;
+    Result.elements[0][0] = 1.0f / Result.elements[0][0];
+    Result.elements[1][1] = 1.0f / Result.elements[1][1];
+    Result.elements[2][2] = 1.0f / Result.elements[2][2];
 
     return Result;
 }
 
-static inline HMM_Mat4 _HMM_LookAt(HMM_Vec3 F,  HMM_Vec3 S, HMM_Vec3 U,  HMM_Vec3 Eye)
+static inline mat4 _HMM_LookAt(vec3 F,  vec3 S, vec3 U,  vec3 Eye)
 {
-    HMM_Mat4 Result;
+    mat4 Result;
 
-    Result.Elements[0][0] = S.X;
-    Result.Elements[0][1] = U.X;
-    Result.Elements[0][2] = -F.X;
-    Result.Elements[0][3] = 0.0f;
+    Result.elements[0][0] = S.x;
+    Result.elements[0][1] = U.x;
+    Result.elements[0][2] = -F.x;
+    Result.elements[0][3] = 0.0f;
 
-    Result.Elements[1][0] = S.Y;
-    Result.Elements[1][1] = U.Y;
-    Result.Elements[1][2] = -F.Y;
-    Result.Elements[1][3] = 0.0f;
+    Result.elements[1][0] = S.y;
+    Result.elements[1][1] = U.y;
+    Result.elements[1][2] = -F.y;
+    Result.elements[1][3] = 0.0f;
 
-    Result.Elements[2][0] = S.Z;
-    Result.Elements[2][1] = U.Z;
-    Result.Elements[2][2] = -F.Z;
-    Result.Elements[2][3] = 0.0f;
+    Result.elements[2][0] = S.z;
+    Result.elements[2][1] = U.z;
+    Result.elements[2][2] = -F.z;
+    Result.elements[2][3] = 0.0f;
 
-    Result.Elements[3][0] = -HMM_DotV3(S, Eye);
-    Result.Elements[3][1] = -HMM_DotV3(U, Eye);
-    Result.Elements[3][2] = HMM_DotV3(F, Eye);
-    Result.Elements[3][3] = 1.0f;
+    Result.elements[3][0] = -HMM_DotV3(S, Eye);
+    Result.elements[3][1] = -HMM_DotV3(U, Eye);
+    Result.elements[3][2] = HMM_DotV3(F, Eye);
+    Result.elements[3][3] = 1.0f;
 
     return Result;
 }
 
 COVERAGE(HMM_LookAt_RH, 1)
-static inline HMM_Mat4 HMM_LookAt_RH(HMM_Vec3 Eye, HMM_Vec3 Center, HMM_Vec3 Up)
+static inline mat4 HMM_LookAt_RH(vec3 Eye, vec3 Center, vec3 Up)
 {
     ASSERT_COVERED(HMM_LookAt_RH);
 
-    HMM_Vec3 F = HMM_NormV3(HMM_SubV3(Center, Eye));
-    HMM_Vec3 S = HMM_NormV3(HMM_Cross(F, Up));
-    HMM_Vec3 U = HMM_Cross(S, F);
+    vec3 F = HMM_NormV3(HMM_SubV3(Center, Eye));
+    vec3 S = HMM_NormV3(cross(F, Up));
+    vec3 U = cross(S, F);
 
     return _HMM_LookAt(F, S, U, Eye);
 }
 
 COVERAGE(HMM_LookAt_LH, 1)
-static inline HMM_Mat4 HMM_LookAt_LH(HMM_Vec3 Eye, HMM_Vec3 Center, HMM_Vec3 Up)
+static inline mat4 HMM_LookAt_LH(vec3 Eye, vec3 Center, vec3 Up)
 {
     ASSERT_COVERED(HMM_LookAt_LH);
 
-    HMM_Vec3 F = HMM_NormV3(HMM_SubV3(Eye, Center));
-    HMM_Vec3 S = HMM_NormV3(HMM_Cross(F, Up));
-    HMM_Vec3 U = HMM_Cross(S, F);
+    vec3 F = HMM_NormV3(HMM_SubV3(Eye, Center));
+    vec3 S = HMM_NormV3(cross(F, Up));
+    vec3 U = cross(S, F);
 
     return _HMM_LookAt(F, S, U, Eye);
 }
 
 COVERAGE(HMM_InvLookAt, 1)
-static inline HMM_Mat4 HMM_InvLookAt(HMM_Mat4 Matrix)
+static inline mat4 HMM_InvLookAt(mat4 Matrix)
 {
     ASSERT_COVERED(HMM_InvLookAt);
-    HMM_Mat4 Result;
+    mat4 Result;
 
-    HMM_Mat3 Rotation = {0};
-    Rotation.Columns[0] = Matrix.Columns[0].XYZ;
-    Rotation.Columns[1] = Matrix.Columns[1].XYZ;
-    Rotation.Columns[2] = Matrix.Columns[2].XYZ;
+    mat3 Rotation = {0};
+    Rotation.columns[0] = Matrix.columns[0].xyz;
+    Rotation.columns[1] = Matrix.columns[1].xyz;
+    Rotation.columns[2] = Matrix.columns[2].xyz;
     Rotation = HMM_TransposeM3(Rotation);
 
-    Result.Columns[0] = HMM_V4V(Rotation.Columns[0], 0.0f);
-    Result.Columns[1] = HMM_V4V(Rotation.Columns[1], 0.0f);
-    Result.Columns[2] = HMM_V4V(Rotation.Columns[2], 0.0f);
-    Result.Columns[3] = HMM_MulV4F(Matrix.Columns[3], -1.0f);
-    Result.Elements[3][0] = -1.0f * Matrix.Elements[3][0] /
-        (Rotation.Elements[0][0] + Rotation.Elements[0][1] + Rotation.Elements[0][2]);
-    Result.Elements[3][1] = -1.0f * Matrix.Elements[3][1] /
-        (Rotation.Elements[1][0] + Rotation.Elements[1][1] + Rotation.Elements[1][2]);
-    Result.Elements[3][2] = -1.0f * Matrix.Elements[3][2] /
-        (Rotation.Elements[2][0] + Rotation.Elements[2][1] + Rotation.Elements[2][2]);
-    Result.Elements[3][3] = 1.0f;
+    Result.columns[0] = v4V(Rotation.columns[0], 0.0f);
+    Result.columns[1] = v4V(Rotation.columns[1], 0.0f);
+    Result.columns[2] = v4V(Rotation.columns[2], 0.0f);
+    Result.columns[3] = HMM_MulV4F(Matrix.columns[3], -1.0f);
+    Result.elements[3][0] = -1.0f * Matrix.elements[3][0] /
+        (Rotation.elements[0][0] + Rotation.elements[0][1] + Rotation.elements[0][2]);
+    Result.elements[3][1] = -1.0f * Matrix.elements[3][1] /
+        (Rotation.elements[1][0] + Rotation.elements[1][1] + Rotation.elements[1][2]);
+    Result.elements[3][2] = -1.0f * Matrix.elements[3][2] /
+        (Rotation.elements[2][0] + Rotation.elements[2][1] + Rotation.elements[2][2]);
+    Result.elements[3][3] = 1.0f;
 
     return Result;
 }
@@ -2104,17 +2104,17 @@ static inline HMM_Quat HMM_Q(float X, float Y, float Z, float W)
     float32x4_t v = { X, Y, Z, W };
     Result.NEON = v;
 #else
-    Result.X = X;
-    Result.Y = Y;
-    Result.Z = Z;
-    Result.W = W;
+    Result.x = X;
+    Result.y = Y;
+    Result.z = Z;
+    Result.w = W;
 #endif
 
     return Result;
 }
 
 COVERAGE(HMM_QV4, 1)
-static inline HMM_Quat HMM_QV4(HMM_Vec4 Vector)
+static inline HMM_Quat HMM_QV4(vec4 Vector)
 {
     ASSERT_COVERED(HMM_QV4);
 
@@ -2125,10 +2125,10 @@ static inline HMM_Quat HMM_QV4(HMM_Vec4 Vector)
 #elif defined(HANDMADE_MATH__USE_NEON)
     Result.NEON = Vector.NEON;
 #else
-    Result.X = Vector.X;
-    Result.Y = Vector.Y;
-    Result.Z = Vector.Z;
-    Result.W = Vector.W;
+    Result.x = Vector.x;
+    Result.y = Vector.y;
+    Result.z = Vector.z;
+    Result.w = Vector.w;
 #endif
 
     return Result;
@@ -2147,10 +2147,10 @@ static inline HMM_Quat HMM_AddQ(HMM_Quat Left, HMM_Quat Right)
     Result.NEON = vaddq_f32(Left.NEON, Right.NEON);
 #else
 
-    Result.X = Left.X + Right.X;
-    Result.Y = Left.Y + Right.Y;
-    Result.Z = Left.Z + Right.Z;
-    Result.W = Left.W + Right.W;
+    Result.x = Left.x + Right.x;
+    Result.y = Left.y + Right.y;
+    Result.z = Left.z + Right.z;
+    Result.w = Left.w + Right.w;
 #endif
 
     return Result;
@@ -2168,10 +2168,10 @@ static inline HMM_Quat HMM_SubQ(HMM_Quat Left, HMM_Quat Right)
 #elif defined(HANDMADE_MATH__USE_NEON)
     Result.NEON = vsubq_f32(Left.NEON, Right.NEON);
 #else
-    Result.X = Left.X - Right.X;
-    Result.Y = Left.Y - Right.Y;
-    Result.Z = Left.Z - Right.Z;
-    Result.W = Left.W - Right.W;
+    Result.x = Left.x - Right.x;
+    Result.y = Left.y - Right.y;
+    Result.z = Left.z - Right.z;
+    Result.w = Left.w - Right.w;
 #endif
 
     return Result;
@@ -2214,25 +2214,25 @@ static inline HMM_Quat HMM_MulQ(HMM_Quat Left, HMM_Quat Right)
     Result.NEON = vfmaq_laneq_f32(Result.NEON, Right.NEON, Left.NEON, 3);
 
 #else
-    Result.X =  Right.Elements[3] * +Left.Elements[0];
-    Result.Y =  Right.Elements[2] * -Left.Elements[0];
-    Result.Z =  Right.Elements[1] * +Left.Elements[0];
-    Result.W =  Right.Elements[0] * -Left.Elements[0];
+    Result.x =  Right.elements[3] * +Left.elements[0];
+    Result.y =  Right.elements[2] * -Left.elements[0];
+    Result.z =  Right.elements[1] * +Left.elements[0];
+    Result.w =  Right.elements[0] * -Left.elements[0];
 
-    Result.X += Right.Elements[2] * +Left.Elements[1];
-    Result.Y += Right.Elements[3] * +Left.Elements[1];
-    Result.Z += Right.Elements[0] * -Left.Elements[1];
-    Result.W += Right.Elements[1] * -Left.Elements[1];
+    Result.x += Right.elements[2] * +Left.elements[1];
+    Result.y += Right.elements[3] * +Left.elements[1];
+    Result.z += Right.elements[0] * -Left.elements[1];
+    Result.w += Right.elements[1] * -Left.elements[1];
 
-    Result.X += Right.Elements[1] * -Left.Elements[2];
-    Result.Y += Right.Elements[0] * +Left.Elements[2];
-    Result.Z += Right.Elements[3] * +Left.Elements[2];
-    Result.W += Right.Elements[2] * -Left.Elements[2];
+    Result.x += Right.elements[1] * -Left.elements[2];
+    Result.y += Right.elements[0] * +Left.elements[2];
+    Result.z += Right.elements[3] * +Left.elements[2];
+    Result.w += Right.elements[2] * -Left.elements[2];
 
-    Result.X += Right.Elements[0] * +Left.Elements[3];
-    Result.Y += Right.Elements[1] * +Left.Elements[3];
-    Result.Z += Right.Elements[2] * +Left.Elements[3];
-    Result.W += Right.Elements[3] * +Left.Elements[3];
+    Result.x += Right.elements[0] * +Left.elements[3];
+    Result.y += Right.elements[1] * +Left.elements[3];
+    Result.z += Right.elements[2] * +Left.elements[3];
+    Result.w += Right.elements[3] * +Left.elements[3];
 #endif
 
     return Result;
@@ -2251,10 +2251,10 @@ static inline HMM_Quat HMM_MulQF(HMM_Quat Left, float Multiplicative)
 #elif defined(HANDMADE_MATH__USE_NEON)
     Result.NEON = vmulq_n_f32(Left.NEON, Multiplicative);
 #else
-    Result.X = Left.X * Multiplicative;
-    Result.Y = Left.Y * Multiplicative;
-    Result.Z = Left.Z * Multiplicative;
-    Result.W = Left.W * Multiplicative;
+    Result.x = Left.x * Multiplicative;
+    Result.y = Left.y * Multiplicative;
+    Result.z = Left.z * Multiplicative;
+    Result.w = Left.w * Multiplicative;
 #endif
 
     return Result;
@@ -2274,10 +2274,10 @@ static inline HMM_Quat HMM_DivQF(HMM_Quat Left, float Divnd)
     float32x4_t Scalar = vdupq_n_f32(Divnd);
     Result.NEON = vdivq_f32(Left.NEON, Scalar);
 #else
-    Result.X = Left.X / Divnd;
-    Result.Y = Left.Y / Divnd;
-    Result.Z = Left.Z / Divnd;
-    Result.W = Left.W / Divnd;
+    Result.x = Left.x / Divnd;
+    Result.y = Left.y / Divnd;
+    Result.z = Left.z / Divnd;
+    Result.w = Left.w / Divnd;
 #endif
 
     return Result;
@@ -2303,7 +2303,7 @@ static inline float HMM_DotQ(HMM_Quat Left, HMM_Quat Right)
     float32x4_t NEONFullAdd = vpaddq_f32(NEONHalfAdd, NEONHalfAdd);
     Result = vgetq_lane_f32(NEONFullAdd, 0);
 #else
-    Result = ((Left.X * Right.X) + (Left.Z * Right.Z)) + ((Left.Y * Right.Y) + (Left.W * Right.W));
+    Result = ((Left.x * Right.x) + (Left.z * Right.z)) + ((Left.y * Right.y) + (Left.w * Right.w));
 #endif
 
     return Result;
@@ -2315,10 +2315,10 @@ static inline HMM_Quat HMM_InvQ(HMM_Quat Left)
     ASSERT_COVERED(HMM_InvQ);
 
     HMM_Quat Result;
-    Result.X = -Left.X;
-    Result.Y = -Left.Y;
-    Result.Z = -Left.Z;
-    Result.W = Left.W;
+    Result.x = -Left.x;
+    Result.y = -Left.y;
+    Result.z = -Left.z;
+    Result.w = Left.w;
 
     return HMM_DivQF(Result, (HMM_DotQ(Left, Left)));
 }
@@ -2329,9 +2329,9 @@ static inline HMM_Quat HMM_NormQ(HMM_Quat Quat)
     ASSERT_COVERED(HMM_NormQ);
 
     /* NOTE(lcf): Take advantage of SSE implementation in HMM_NormV4 */
-    HMM_Vec4 Vec = {Quat.X, Quat.Y, Quat.Z, Quat.W};
+    vec4 Vec = {Quat.x, Quat.y, Quat.z, Quat.w};
     Vec = HMM_NormV4(Vec);
-    HMM_Quat Result = {Vec.X, Vec.Y, Vec.Z, Vec.W};
+    HMM_Quat Result = {Vec.x, Vec.y, Vec.z, Vec.w};
 
     return Result;
 }
@@ -2350,10 +2350,10 @@ static inline HMM_Quat _HMM_MixQ(HMM_Quat Left, float MixLeft, HMM_Quat Right, f
     float32x4_t ScaledRight = vmulq_n_f32(Right.NEON, MixRight);
     Result.NEON = vaddq_f32(ScaledLeft, ScaledRight);
 #else
-    Result.X = Left.X*MixLeft + Right.X*MixRight;
-    Result.Y = Left.Y*MixLeft + Right.Y*MixRight;
-    Result.Z = Left.Z*MixLeft + Right.Z*MixRight;
-    Result.W = Left.W*MixLeft + Right.W*MixRight;
+    Result.x = Left.x*MixLeft + Right.x*MixRight;
+    Result.y = Left.y*MixLeft + Right.y*MixRight;
+    Result.z = Left.z*MixLeft + Right.z*MixRight;
+    Result.w = Left.w*MixLeft + Right.w*MixRight;
 #endif
 
     return Result;
@@ -2381,7 +2381,7 @@ static inline HMM_Quat HMM_SLerp(HMM_Quat Left, float Time, HMM_Quat Right)
 
     if (Cos_Theta < 0.0f) { /* NOTE(lcf): Take shortest path on Hyper-sphere */
         Cos_Theta = -Cos_Theta;
-        Right = HMM_Q(-Right.X, -Right.Y, -Right.Z, -Right.W);
+        Right = HMM_Q(-Right.x, -Right.y, -Right.z, -Right.w);
     }
 
     /* NOTE(lcf): Use Normalized Linear interpolation when vectors are roughly not L.I. */
@@ -2400,11 +2400,11 @@ static inline HMM_Quat HMM_SLerp(HMM_Quat Left, float Time, HMM_Quat Right)
 }
 
 COVERAGE(HMM_QToM4, 1)
-static inline HMM_Mat4 HMM_QToM4(HMM_Quat Left)
+static inline mat4 HMM_QToM4(HMM_Quat Left)
 {
     ASSERT_COVERED(HMM_QToM4);
 
-    HMM_Mat4 Result;
+    mat4 Result;
 
     HMM_Quat NormalizedQ = HMM_NormQ(Left);
 
@@ -2412,35 +2412,35 @@ static inline HMM_Mat4 HMM_QToM4(HMM_Quat Left)
           XY, XZ, YZ,
           WX, WY, WZ;
 
-    XX = NormalizedQ.X * NormalizedQ.X;
-    YY = NormalizedQ.Y * NormalizedQ.Y;
-    ZZ = NormalizedQ.Z * NormalizedQ.Z;
-    XY = NormalizedQ.X * NormalizedQ.Y;
-    XZ = NormalizedQ.X * NormalizedQ.Z;
-    YZ = NormalizedQ.Y * NormalizedQ.Z;
-    WX = NormalizedQ.W * NormalizedQ.X;
-    WY = NormalizedQ.W * NormalizedQ.Y;
-    WZ = NormalizedQ.W * NormalizedQ.Z;
+    XX = NormalizedQ.x * NormalizedQ.x;
+    YY = NormalizedQ.y * NormalizedQ.y;
+    ZZ = NormalizedQ.z * NormalizedQ.z;
+    XY = NormalizedQ.x * NormalizedQ.y;
+    XZ = NormalizedQ.x * NormalizedQ.z;
+    YZ = NormalizedQ.y * NormalizedQ.z;
+    WX = NormalizedQ.w * NormalizedQ.x;
+    WY = NormalizedQ.w * NormalizedQ.y;
+    WZ = NormalizedQ.w * NormalizedQ.z;
 
-    Result.Elements[0][0] = 1.0f - 2.0f * (YY + ZZ);
-    Result.Elements[0][1] = 2.0f * (XY + WZ);
-    Result.Elements[0][2] = 2.0f * (XZ - WY);
-    Result.Elements[0][3] = 0.0f;
+    Result.elements[0][0] = 1.0f - 2.0f * (YY + ZZ);
+    Result.elements[0][1] = 2.0f * (XY + WZ);
+    Result.elements[0][2] = 2.0f * (XZ - WY);
+    Result.elements[0][3] = 0.0f;
 
-    Result.Elements[1][0] = 2.0f * (XY - WZ);
-    Result.Elements[1][1] = 1.0f - 2.0f * (XX + ZZ);
-    Result.Elements[1][2] = 2.0f * (YZ + WX);
-    Result.Elements[1][3] = 0.0f;
+    Result.elements[1][0] = 2.0f * (XY - WZ);
+    Result.elements[1][1] = 1.0f - 2.0f * (XX + ZZ);
+    Result.elements[1][2] = 2.0f * (YZ + WX);
+    Result.elements[1][3] = 0.0f;
 
-    Result.Elements[2][0] = 2.0f * (XZ + WY);
-    Result.Elements[2][1] = 2.0f * (YZ - WX);
-    Result.Elements[2][2] = 1.0f - 2.0f * (XX + YY);
-    Result.Elements[2][3] = 0.0f;
+    Result.elements[2][0] = 2.0f * (XZ + WY);
+    Result.elements[2][1] = 2.0f * (YZ - WX);
+    Result.elements[2][2] = 1.0f - 2.0f * (XX + YY);
+    Result.elements[2][3] = 0.0f;
 
-    Result.Elements[3][0] = 0.0f;
-    Result.Elements[3][1] = 0.0f;
-    Result.Elements[3][2] = 0.0f;
-    Result.Elements[3][3] = 1.0f;
+    Result.elements[3][0] = 0.0f;
+    Result.elements[3][1] = 0.0f;
+    Result.elements[3][2] = 0.0f;
+    Result.elements[3][3] = 1.0f;
 
     return Result;
 }
@@ -2455,57 +2455,57 @@ static inline HMM_Mat4 HMM_QToM4(HMM_Quat Left)
 //
 // For example, m12 in the paper is row 1, column 2. We need to transpose it to
 // row 2, column 1. But, because the column comes first when referencing
-// elements, it looks like M.Elements[1][2].
+// elements, it looks like M.elements[1][2].
 //
 // Don't be confused! Or if you must be confused, at least trust this
 // comment. :)
 COVERAGE(HMM_M4ToQ_RH, 4)
-static inline HMM_Quat HMM_M4ToQ_RH(HMM_Mat4 M)
+static inline HMM_Quat HMM_M4ToQ_RH(mat4 M)
 {
     float T;
     HMM_Quat Q;
 
-    if (M.Elements[2][2] < 0.0f) {
-        if (M.Elements[0][0] > M.Elements[1][1]) {
+    if (M.elements[2][2] < 0.0f) {
+        if (M.elements[0][0] > M.elements[1][1]) {
             ASSERT_COVERED(HMM_M4ToQ_RH);
 
-            T = 1 + M.Elements[0][0] - M.Elements[1][1] - M.Elements[2][2];
+            T = 1 + M.elements[0][0] - M.elements[1][1] - M.elements[2][2];
             Q = HMM_Q(
                 T,
-                M.Elements[0][1] + M.Elements[1][0],
-                M.Elements[2][0] + M.Elements[0][2],
-                M.Elements[1][2] - M.Elements[2][1]
+                M.elements[0][1] + M.elements[1][0],
+                M.elements[2][0] + M.elements[0][2],
+                M.elements[1][2] - M.elements[2][1]
             );
         } else {
             ASSERT_COVERED(HMM_M4ToQ_RH);
 
-            T = 1 - M.Elements[0][0] + M.Elements[1][1] - M.Elements[2][2];
+            T = 1 - M.elements[0][0] + M.elements[1][1] - M.elements[2][2];
             Q = HMM_Q(
-                M.Elements[0][1] + M.Elements[1][0],
+                M.elements[0][1] + M.elements[1][0],
                 T,
-                M.Elements[1][2] + M.Elements[2][1],
-                M.Elements[2][0] - M.Elements[0][2]
+                M.elements[1][2] + M.elements[2][1],
+                M.elements[2][0] - M.elements[0][2]
             );
         }
     } else {
-        if (M.Elements[0][0] < -M.Elements[1][1]) {
+        if (M.elements[0][0] < -M.elements[1][1]) {
             ASSERT_COVERED(HMM_M4ToQ_RH);
 
-            T = 1 - M.Elements[0][0] - M.Elements[1][1] + M.Elements[2][2];
+            T = 1 - M.elements[0][0] - M.elements[1][1] + M.elements[2][2];
             Q = HMM_Q(
-                M.Elements[2][0] + M.Elements[0][2],
-                M.Elements[1][2] + M.Elements[2][1],
+                M.elements[2][0] + M.elements[0][2],
+                M.elements[1][2] + M.elements[2][1],
                 T,
-                M.Elements[0][1] - M.Elements[1][0]
+                M.elements[0][1] - M.elements[1][0]
             );
         } else {
             ASSERT_COVERED(HMM_M4ToQ_RH);
 
-            T = 1 + M.Elements[0][0] + M.Elements[1][1] + M.Elements[2][2];
+            T = 1 + M.elements[0][0] + M.elements[1][1] + M.elements[2][2];
             Q = HMM_Q(
-                M.Elements[1][2] - M.Elements[2][1],
-                M.Elements[2][0] - M.Elements[0][2],
-                M.Elements[0][1] - M.Elements[1][0],
+                M.elements[1][2] - M.elements[2][1],
+                M.elements[2][0] - M.elements[0][2],
+                M.elements[0][1] - M.elements[1][0],
                 T
             );
         }
@@ -2517,52 +2517,52 @@ static inline HMM_Quat HMM_M4ToQ_RH(HMM_Mat4 M)
 }
 
 COVERAGE(HMM_M4ToQ_LH, 4)
-static inline HMM_Quat HMM_M4ToQ_LH(HMM_Mat4 M)
+static inline HMM_Quat HMM_M4ToQ_LH(mat4 M)
 {
     float T;
     HMM_Quat Q;
 
-    if (M.Elements[2][2] < 0.0f) {
-        if (M.Elements[0][0] > M.Elements[1][1]) {
+    if (M.elements[2][2] < 0.0f) {
+        if (M.elements[0][0] > M.elements[1][1]) {
             ASSERT_COVERED(HMM_M4ToQ_LH);
 
-            T = 1 + M.Elements[0][0] - M.Elements[1][1] - M.Elements[2][2];
+            T = 1 + M.elements[0][0] - M.elements[1][1] - M.elements[2][2];
             Q = HMM_Q(
                 T,
-                M.Elements[0][1] + M.Elements[1][0],
-                M.Elements[2][0] + M.Elements[0][2],
-                M.Elements[2][1] - M.Elements[1][2]
+                M.elements[0][1] + M.elements[1][0],
+                M.elements[2][0] + M.elements[0][2],
+                M.elements[2][1] - M.elements[1][2]
             );
         } else {
             ASSERT_COVERED(HMM_M4ToQ_LH);
 
-            T = 1 - M.Elements[0][0] + M.Elements[1][1] - M.Elements[2][2];
+            T = 1 - M.elements[0][0] + M.elements[1][1] - M.elements[2][2];
             Q = HMM_Q(
-                M.Elements[0][1] + M.Elements[1][0],
+                M.elements[0][1] + M.elements[1][0],
                 T,
-                M.Elements[1][2] + M.Elements[2][1],
-                M.Elements[0][2] - M.Elements[2][0]
+                M.elements[1][2] + M.elements[2][1],
+                M.elements[0][2] - M.elements[2][0]
             );
         }
     } else {
-        if (M.Elements[0][0] < -M.Elements[1][1]) {
+        if (M.elements[0][0] < -M.elements[1][1]) {
             ASSERT_COVERED(HMM_M4ToQ_LH);
 
-            T = 1 - M.Elements[0][0] - M.Elements[1][1] + M.Elements[2][2];
+            T = 1 - M.elements[0][0] - M.elements[1][1] + M.elements[2][2];
             Q = HMM_Q(
-                M.Elements[2][0] + M.Elements[0][2],
-                M.Elements[1][2] + M.Elements[2][1],
+                M.elements[2][0] + M.elements[0][2],
+                M.elements[1][2] + M.elements[2][1],
                 T,
-                M.Elements[1][0] - M.Elements[0][1]
+                M.elements[1][0] - M.elements[0][1]
             );
         } else {
             ASSERT_COVERED(HMM_M4ToQ_LH);
 
-            T = 1 + M.Elements[0][0] + M.Elements[1][1] + M.Elements[2][2];
+            T = 1 + M.elements[0][0] + M.elements[1][1] + M.elements[2][2];
             Q = HMM_Q(
-                M.Elements[2][1] - M.Elements[1][2],
-                M.Elements[0][2] - M.Elements[2][0],
-                M.Elements[1][0] - M.Elements[0][2],
+                M.elements[2][1] - M.elements[1][2],
+                M.elements[0][2] - M.elements[2][0],
+                M.elements[1][0] - M.elements[0][2],
                 T
             );
         }
@@ -2575,23 +2575,23 @@ static inline HMM_Quat HMM_M4ToQ_LH(HMM_Mat4 M)
 
 
 COVERAGE(HMM_QFromAxisAngle_RH, 1)
-static inline HMM_Quat HMM_QFromAxisAngle_RH(HMM_Vec3 Axis, float Angle)
+static inline HMM_Quat HMM_QFromAxisAngle_RH(vec3 Axis, float Angle)
 {
     ASSERT_COVERED(HMM_QFromAxisAngle_RH);
 
     HMM_Quat Result;
 
-    HMM_Vec3 AxisNormalized = HMM_NormV3(Axis);
+    vec3 AxisNormalized = HMM_NormV3(Axis);
     float SineOfRotation = HMM_SinF(Angle / 2.0f);
 
-    Result.XYZ = HMM_MulV3F(AxisNormalized, SineOfRotation);
-    Result.W = HMM_CosF(Angle / 2.0f);
+    Result.xyz = HMM_MulV3F(AxisNormalized, SineOfRotation);
+    Result.w = HMM_CosF(Angle / 2.0f);
 
     return Result;
 }
 
 COVERAGE(HMM_QFromAxisAngle_LH, 1)
-static inline HMM_Quat HMM_QFromAxisAngle_LH(HMM_Vec3 Axis, float Angle)
+static inline HMM_Quat HMM_QFromAxisAngle_LH(vec3 Axis, float Angle)
 {
     ASSERT_COVERED(HMM_QFromAxisAngle_LH);
 
@@ -2599,20 +2599,20 @@ static inline HMM_Quat HMM_QFromAxisAngle_LH(HMM_Vec3 Axis, float Angle)
 }
 
 COVERAGE(HMM_QFromNormPair, 1)
-static inline HMM_Quat HMM_QFromNormPair(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline HMM_Quat HMM_QFromNormPair(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_QFromNormPair);
 
     HMM_Quat Result;
 
-    Result.XYZ = HMM_Cross(Left, Right);
-    Result.W = 1.0f + HMM_DotV3(Left, Right);
+    Result.xyz = cross(Left, Right);
+    Result.w = 1.0f + HMM_DotV3(Left, Right);
 
     return HMM_NormQ(Result);
 }
 
 COVERAGE(HMM_QFromVecPair, 1)
-static inline HMM_Quat HMM_QFromVecPair(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline HMM_Quat HMM_QFromVecPair(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_QFromVecPair);
 
@@ -2620,36 +2620,36 @@ static inline HMM_Quat HMM_QFromVecPair(HMM_Vec3 Left, HMM_Vec3 Right)
 }
 
 COVERAGE(HMM_RotateV2, 1)
-static inline HMM_Vec2 HMM_RotateV2(HMM_Vec2 V, float Angle)
+static inline vec2 HMM_RotateV2(vec2 V, float Angle)
 {
     ASSERT_COVERED(HMM_RotateV2)
 
     float sinA = HMM_SinF(Angle);
     float cosA = HMM_CosF(Angle);
 
-    return HMM_V2(V.X * cosA - V.Y * sinA, V.X * sinA + V.Y * cosA);
+    return v2(V.x * cosA - V.y * sinA, V.x * sinA + V.y * cosA);
 }
 
 // implementation from
 // https://blog.molecular-matters.com/2013/05/24/a-faster-quaternion-vector-multiplication/
 COVERAGE(HMM_RotateV3Q, 1)
-static inline HMM_Vec3 HMM_RotateV3Q(HMM_Vec3 V, HMM_Quat Q)
+static inline vec3 HMM_RotateV3Q(vec3 V, HMM_Quat Q)
 {
     ASSERT_COVERED(HMM_RotateV3Q);
 
-    HMM_Vec3 t = HMM_MulV3F(HMM_Cross(Q.XYZ, V), 2);
-    return HMM_AddV3(V, HMM_AddV3(HMM_MulV3F(t, Q.W), HMM_Cross(Q.XYZ, t)));
+    vec3 t = HMM_MulV3F(cross(Q.xyz, V), 2);
+    return HMM_AddV3(V, HMM_AddV3(HMM_MulV3F(t, Q.w), cross(Q.xyz, t)));
 }
 
 COVERAGE(HMM_RotateV3AxisAngle_LH, 1)
-static inline HMM_Vec3 HMM_RotateV3AxisAngle_LH(HMM_Vec3 V, HMM_Vec3 Axis, float Angle) {
+static inline vec3 HMM_RotateV3AxisAngle_LH(vec3 V, vec3 Axis, float Angle) {
     ASSERT_COVERED(HMM_RotateV3AxisAngle_LH);
 
     return HMM_RotateV3Q(V, HMM_QFromAxisAngle_LH(Axis, Angle));
 }
 
 COVERAGE(HMM_RotateV3AxisAngle_RH, 1)
-static inline HMM_Vec3 HMM_RotateV3AxisAngle_RH(HMM_Vec3 V, HMM_Vec3 Axis, float Angle) {
+static inline vec3 HMM_RotateV3AxisAngle_RH(vec3 V, vec3 Axis, float Angle) {
     ASSERT_COVERED(HMM_RotateV3AxisAngle_RH);
 
     return HMM_RotateV3Q(V, HMM_QFromAxisAngle_RH(Axis, Angle));
@@ -2663,63 +2663,63 @@ static inline HMM_Vec3 HMM_RotateV3AxisAngle_RH(HMM_Vec3 V, HMM_Vec3 Axis, float
 #ifdef __cplusplus
 
 COVERAGE(HMM_LenV2CPP, 1)
-static inline float HMM_Len(HMM_Vec2 A)
+static inline float HMM_Len(vec2 A)
 {
     ASSERT_COVERED(HMM_LenV2CPP);
     return HMM_LenV2(A);
 }
 
 COVERAGE(HMM_LenV3CPP, 1)
-static inline float HMM_Len(HMM_Vec3 A)
+static inline float HMM_Len(vec3 A)
 {
     ASSERT_COVERED(HMM_LenV3CPP);
     return HMM_LenV3(A);
 }
 
 COVERAGE(HMM_LenV4CPP, 1)
-static inline float HMM_Len(HMM_Vec4 A)
+static inline float HMM_Len(vec4 A)
 {
     ASSERT_COVERED(HMM_LenV4CPP);
     return HMM_LenV4(A);
 }
 
 COVERAGE(HMM_LenSqrV2CPP, 1)
-static inline float HMM_LenSqr(HMM_Vec2 A)
+static inline float HMM_LenSqr(vec2 A)
 {
     ASSERT_COVERED(HMM_LenSqrV2CPP);
     return HMM_LenSqrV2(A);
 }
 
 COVERAGE(HMM_LenSqrV3CPP, 1)
-static inline float HMM_LenSqr(HMM_Vec3 A)
+static inline float HMM_LenSqr(vec3 A)
 {
     ASSERT_COVERED(HMM_LenSqrV3CPP);
     return HMM_LenSqrV3(A);
 }
 
 COVERAGE(HMM_LenSqrV4CPP, 1)
-static inline float HMM_LenSqr(HMM_Vec4 A)
+static inline float HMM_LenSqr(vec4 A)
 {
     ASSERT_COVERED(HMM_LenSqrV4CPP);
     return HMM_LenSqrV4(A);
 }
 
 COVERAGE(HMM_NormV2CPP, 1)
-static inline HMM_Vec2 HMM_Norm(HMM_Vec2 A)
+static inline vec2 HMM_Norm(vec2 A)
 {
     ASSERT_COVERED(HMM_NormV2CPP);
     return HMM_NormV2(A);
 }
 
 COVERAGE(HMM_NormV3CPP, 1)
-static inline HMM_Vec3 HMM_Norm(HMM_Vec3 A)
+static inline vec3 HMM_Norm(vec3 A)
 {
     ASSERT_COVERED(HMM_NormV3CPP);
     return HMM_NormV3(A);
 }
 
 COVERAGE(HMM_NormV4CPP, 1)
-static inline HMM_Vec4 HMM_Norm(HMM_Vec4 A)
+static inline vec4 HMM_Norm(vec4 A)
 {
     ASSERT_COVERED(HMM_NormV4CPP);
     return HMM_NormV4(A);
@@ -2733,105 +2733,105 @@ static inline HMM_Quat HMM_Norm(HMM_Quat A)
 }
 
 COVERAGE(HMM_DotV2CPP, 1)
-static inline float HMM_Dot(HMM_Vec2 Left, HMM_Vec2 VecTwo)
+static inline float HMM_Dot(vec2 Left, vec2 VecTwo)
 {
     ASSERT_COVERED(HMM_DotV2CPP);
     return HMM_DotV2(Left, VecTwo);
 }
 
 COVERAGE(HMM_DotV3CPP, 1)
-static inline float HMM_Dot(HMM_Vec3 Left, HMM_Vec3 VecTwo)
+static inline float HMM_Dot(vec3 Left, vec3 VecTwo)
 {
     ASSERT_COVERED(HMM_DotV3CPP);
     return HMM_DotV3(Left, VecTwo);
 }
 
 COVERAGE(HMM_DotV4CPP, 1)
-static inline float HMM_Dot(HMM_Vec4 Left, HMM_Vec4 VecTwo)
+static inline float HMM_Dot(vec4 Left, vec4 VecTwo)
 {
     ASSERT_COVERED(HMM_DotV4CPP);
     return HMM_DotV4(Left, VecTwo);
 }
 
-COVERAGE(HMM_LerpV2CPP, 1)
-static inline HMM_Vec2 HMM_Lerp(HMM_Vec2 Left, float Time, HMM_Vec2 Right)
+COVERAGE(lerpV2CPP, 1)
+static inline vec2 lerp(vec2 Left, float Time, vec2 Right)
 {
-    ASSERT_COVERED(HMM_LerpV2CPP);
-    return HMM_LerpV2(Left, Time, Right);
+    ASSERT_COVERED(lerpV2CPP);
+    return lerpV2(Left, Time, Right);
 }
 
-COVERAGE(HMM_LerpV3CPP, 1)
-static inline HMM_Vec3 HMM_Lerp(HMM_Vec3 Left, float Time, HMM_Vec3 Right)
+COVERAGE(lerpV3CPP, 1)
+static inline vec3 lerp(vec3 Left, float Time, vec3 Right)
 {
-    ASSERT_COVERED(HMM_LerpV3CPP);
-    return HMM_LerpV3(Left, Time, Right);
+    ASSERT_COVERED(lerpV3CPP);
+    return lerpV3(Left, Time, Right);
 }
 
-COVERAGE(HMM_LerpV4CPP, 1)
-static inline HMM_Vec4 HMM_Lerp(HMM_Vec4 Left, float Time, HMM_Vec4 Right)
+COVERAGE(lerpV4CPP, 1)
+static inline vec4 lerp(vec4 Left, float Time, vec4 Right)
 {
-    ASSERT_COVERED(HMM_LerpV4CPP);
-    return HMM_LerpV4(Left, Time, Right);
+    ASSERT_COVERED(lerpV4CPP);
+    return lerpV4(Left, Time, Right);
 }
 
 COVERAGE(HMM_TransposeM2CPP, 1)
-static inline HMM_Mat2 HMM_Transpose(HMM_Mat2 Matrix)
+static inline mat2 HMM_Transpose(mat2 Matrix)
 {
     ASSERT_COVERED(HMM_TransposeM2CPP);
     return HMM_TransposeM2(Matrix);
 }
 
 COVERAGE(HMM_TransposeM3CPP, 1)
-static inline HMM_Mat3 HMM_Transpose(HMM_Mat3 Matrix)
+static inline mat3 HMM_Transpose(mat3 Matrix)
 {
     ASSERT_COVERED(HMM_TransposeM3CPP);
     return HMM_TransposeM3(Matrix);
 }
 
 COVERAGE(HMM_TransposeM4CPP, 1)
-static inline HMM_Mat4 HMM_Transpose(HMM_Mat4 Matrix)
+static inline mat4 HMM_Transpose(mat4 Matrix)
 {
     ASSERT_COVERED(HMM_TransposeM4CPP);
     return HMM_TransposeM4(Matrix);
 }
 
 COVERAGE(HMM_DeterminantM2CPP, 1)
-static inline float HMM_Determinant(HMM_Mat2 Matrix)
+static inline float HMM_Determinant(mat2 Matrix)
 {
     ASSERT_COVERED(HMM_DeterminantM2CPP);
     return HMM_DeterminantM2(Matrix);
 }
 
 COVERAGE(HMM_DeterminantM3CPP, 1)
-static inline float HMM_Determinant(HMM_Mat3 Matrix)
+static inline float HMM_Determinant(mat3 Matrix)
 {
     ASSERT_COVERED(HMM_DeterminantM3CPP);
     return HMM_DeterminantM3(Matrix);
 }
 
 COVERAGE(HMM_DeterminantM4CPP, 1)
-static inline float HMM_Determinant(HMM_Mat4 Matrix)
+static inline float HMM_Determinant(mat4 Matrix)
 {
     ASSERT_COVERED(HMM_DeterminantM4CPP);
     return HMM_DeterminantM4(Matrix);
 }
 
 COVERAGE(HMM_InvGeneralM2CPP, 1)
-static inline HMM_Mat2 HMM_InvGeneral(HMM_Mat2 Matrix)
+static inline mat2 HMM_InvGeneral(mat2 Matrix)
 {
     ASSERT_COVERED(HMM_InvGeneralM2CPP);
     return HMM_InvGeneralM2(Matrix);
 }
 
 COVERAGE(HMM_InvGeneralM3CPP, 1)
-static inline HMM_Mat3 HMM_InvGeneral(HMM_Mat3 Matrix)
+static inline mat3 HMM_InvGeneral(mat3 Matrix)
 {
     ASSERT_COVERED(HMM_InvGeneralM3CPP);
     return HMM_InvGeneralM3(Matrix);
 }
 
 COVERAGE(HMM_InvGeneralM4CPP, 1)
-static inline HMM_Mat4 HMM_InvGeneral(HMM_Mat4 Matrix)
+static inline mat4 HMM_InvGeneral(mat4 Matrix)
 {
     ASSERT_COVERED(HMM_InvGeneralM4CPP);
     return HMM_InvGeneralM4(Matrix);
@@ -2845,42 +2845,42 @@ static inline float HMM_Dot(HMM_Quat QuatOne, HMM_Quat QuatTwo)
 }
 
 COVERAGE(HMM_AddV2CPP, 1)
-static inline HMM_Vec2 HMM_Add(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline vec2 HMM_Add(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_AddV2CPP);
     return HMM_AddV2(Left, Right);
 }
 
 COVERAGE(HMM_AddV3CPP, 1)
-static inline HMM_Vec3 HMM_Add(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline vec3 HMM_Add(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_AddV3CPP);
     return HMM_AddV3(Left, Right);
 }
 
 COVERAGE(HMM_AddV4CPP, 1)
-static inline HMM_Vec4 HMM_Add(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline vec4 HMM_Add(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_AddV4CPP);
     return HMM_AddV4(Left, Right);
 }
 
 COVERAGE(HMM_AddM2CPP, 1)
-static inline HMM_Mat2 HMM_Add(HMM_Mat2 Left, HMM_Mat2 Right)
+static inline mat2 HMM_Add(mat2 Left, mat2 Right)
 {
     ASSERT_COVERED(HMM_AddM2CPP);
     return HMM_AddM2(Left, Right);
 }
 
 COVERAGE(HMM_AddM3CPP, 1)
-static inline HMM_Mat3 HMM_Add(HMM_Mat3 Left, HMM_Mat3 Right)
+static inline mat3 HMM_Add(mat3 Left, mat3 Right)
 {
     ASSERT_COVERED(HMM_AddM3CPP);
     return HMM_AddM3(Left, Right);
 }
 
 COVERAGE(HMM_AddM4CPP, 1)
-static inline HMM_Mat4 HMM_Add(HMM_Mat4 Left, HMM_Mat4 Right)
+static inline mat4 HMM_Add(mat4 Left, mat4 Right)
 {
     ASSERT_COVERED(HMM_AddM4CPP);
     return HMM_AddM4(Left, Right);
@@ -2894,42 +2894,42 @@ static inline HMM_Quat HMM_Add(HMM_Quat Left, HMM_Quat Right)
 }
 
 COVERAGE(HMM_SubV2CPP, 1)
-static inline HMM_Vec2 HMM_Sub(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline vec2 HMM_Sub(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_SubV2CPP);
     return HMM_SubV2(Left, Right);
 }
 
 COVERAGE(HMM_SubV3CPP, 1)
-static inline HMM_Vec3 HMM_Sub(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline vec3 HMM_Sub(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_SubV3CPP);
     return HMM_SubV3(Left, Right);
 }
 
 COVERAGE(HMM_SubV4CPP, 1)
-static inline HMM_Vec4 HMM_Sub(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline vec4 HMM_Sub(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_SubV4CPP);
     return HMM_SubV4(Left, Right);
 }
 
 COVERAGE(HMM_SubM2CPP, 1)
-static inline HMM_Mat2 HMM_Sub(HMM_Mat2 Left, HMM_Mat2 Right)
+static inline mat2 HMM_Sub(mat2 Left, mat2 Right)
 {
     ASSERT_COVERED(HMM_SubM2CPP);
     return HMM_SubM2(Left, Right);
 }
 
 COVERAGE(HMM_SubM3CPP, 1)
-static inline HMM_Mat3 HMM_Sub(HMM_Mat3 Left, HMM_Mat3 Right)
+static inline mat3 HMM_Sub(mat3 Left, mat3 Right)
 {
     ASSERT_COVERED(HMM_SubM3CPP);
     return HMM_SubM3(Left, Right);
 }
 
 COVERAGE(HMM_SubM4CPP, 1)
-static inline HMM_Mat4 HMM_Sub(HMM_Mat4 Left, HMM_Mat4 Right)
+static inline mat4 HMM_Sub(mat4 Left, mat4 Right)
 {
     ASSERT_COVERED(HMM_SubM4CPP);
     return HMM_SubM4(Left, Right);
@@ -2943,105 +2943,105 @@ static inline HMM_Quat HMM_Sub(HMM_Quat Left, HMM_Quat Right)
 }
 
 COVERAGE(HMM_MulV2CPP, 1)
-static inline HMM_Vec2 HMM_Mul(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline vec2 HMM_Mul(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_MulV2CPP);
     return HMM_MulV2(Left, Right);
 }
 
 COVERAGE(HMM_MulV2FCPP, 1)
-static inline HMM_Vec2 HMM_Mul(HMM_Vec2 Left, float Right)
+static inline vec2 HMM_Mul(vec2 Left, float Right)
 {
     ASSERT_COVERED(HMM_MulV2FCPP);
     return HMM_MulV2F(Left, Right);
 }
 
 COVERAGE(HMM_MulV3CPP, 1)
-static inline HMM_Vec3 HMM_Mul(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline vec3 HMM_Mul(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_MulV3CPP);
     return HMM_MulV3(Left, Right);
 }
 
 COVERAGE(HMM_MulV3FCPP, 1)
-static inline HMM_Vec3 HMM_Mul(HMM_Vec3 Left, float Right)
+static inline vec3 HMM_Mul(vec3 Left, float Right)
 {
     ASSERT_COVERED(HMM_MulV3FCPP);
     return HMM_MulV3F(Left, Right);
 }
 
 COVERAGE(HMM_MulV4CPP, 1)
-static inline HMM_Vec4 HMM_Mul(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline vec4 HMM_Mul(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_MulV4CPP);
     return HMM_MulV4(Left, Right);
 }
 
 COVERAGE(HMM_MulV4FCPP, 1)
-static inline HMM_Vec4 HMM_Mul(HMM_Vec4 Left, float Right)
+static inline vec4 HMM_Mul(vec4 Left, float Right)
 {
     ASSERT_COVERED(HMM_MulV4FCPP);
     return HMM_MulV4F(Left, Right);
 }
 
 COVERAGE(HMM_MulM2CPP, 1)
-static inline HMM_Mat2 HMM_Mul(HMM_Mat2 Left, HMM_Mat2 Right)
+static inline mat2 HMM_Mul(mat2 Left, mat2 Right)
 {
     ASSERT_COVERED(HMM_MulM2CPP);
     return HMM_MulM2(Left, Right);
 }
 
 COVERAGE(HMM_MulM3CPP, 1)
-static inline HMM_Mat3 HMM_Mul(HMM_Mat3 Left, HMM_Mat3 Right)
+static inline mat3 HMM_Mul(mat3 Left, mat3 Right)
 {
     ASSERT_COVERED(HMM_MulM3CPP);
     return HMM_MulM3(Left, Right);
 }
 
 COVERAGE(HMM_MulM4CPP, 1)
-static inline HMM_Mat4 HMM_Mul(HMM_Mat4 Left, HMM_Mat4 Right)
+static inline mat4 HMM_Mul(mat4 Left, mat4 Right)
 {
     ASSERT_COVERED(HMM_MulM4CPP);
     return HMM_MulM4(Left, Right);
 }
 
 COVERAGE(HMM_MulM2FCPP, 1)
-static inline HMM_Mat2 HMM_Mul(HMM_Mat2 Left, float Right)
+static inline mat2 HMM_Mul(mat2 Left, float Right)
 {
     ASSERT_COVERED(HMM_MulM2FCPP);
     return HMM_MulM2F(Left, Right);
 }
 
 COVERAGE(HMM_MulM3FCPP, 1)
-static inline HMM_Mat3 HMM_Mul(HMM_Mat3 Left, float Right)
+static inline mat3 HMM_Mul(mat3 Left, float Right)
 {
     ASSERT_COVERED(HMM_MulM3FCPP);
     return HMM_MulM3F(Left, Right);
 }
 
 COVERAGE(HMM_MulM4FCPP, 1)
-static inline HMM_Mat4 HMM_Mul(HMM_Mat4 Left, float Right)
+static inline mat4 HMM_Mul(mat4 Left, float Right)
 {
     ASSERT_COVERED(HMM_MulM4FCPP);
     return HMM_MulM4F(Left, Right);
 }
 
 COVERAGE(HMM_MulM2V2CPP, 1)
-static inline HMM_Vec2 HMM_Mul(HMM_Mat2 Matrix, HMM_Vec2 Vector)
+static inline vec2 HMM_Mul(mat2 Matrix, vec2 Vector)
 {
     ASSERT_COVERED(HMM_MulM2V2CPP);
     return HMM_MulM2V2(Matrix, Vector);
 }
 
 COVERAGE(HMM_MulM3V3CPP, 1)
-static inline HMM_Vec3 HMM_Mul(HMM_Mat3 Matrix, HMM_Vec3 Vector)
+static inline vec3 HMM_Mul(mat3 Matrix, vec3 Vector)
 {
     ASSERT_COVERED(HMM_MulM3V3CPP);
     return HMM_MulM3V3(Matrix, Vector);
 }
 
 COVERAGE(HMM_MulM4V4CPP, 1)
-static inline HMM_Vec4 HMM_Mul(HMM_Mat4 Matrix, HMM_Vec4 Vector)
+static inline vec4 HMM_Mul(mat4 Matrix, vec4 Vector)
 {
     ASSERT_COVERED(HMM_MulM4V4CPP);
     return HMM_MulM4V4(Matrix, Vector);
@@ -3062,63 +3062,63 @@ static inline HMM_Quat HMM_Mul(HMM_Quat Left, float Right)
 }
 
 COVERAGE(HMM_DivV2CPP, 1)
-static inline HMM_Vec2 HMM_Div(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline vec2 HMM_Div(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_DivV2CPP);
     return HMM_DivV2(Left, Right);
 }
 
 COVERAGE(HMM_DivV2FCPP, 1)
-static inline HMM_Vec2 HMM_Div(HMM_Vec2 Left, float Right)
+static inline vec2 HMM_Div(vec2 Left, float Right)
 {
     ASSERT_COVERED(HMM_DivV2FCPP);
     return HMM_DivV2F(Left, Right);
 }
 
 COVERAGE(HMM_DivV3CPP, 1)
-static inline HMM_Vec3 HMM_Div(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline vec3 HMM_Div(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_DivV3CPP);
     return HMM_DivV3(Left, Right);
 }
 
 COVERAGE(HMM_DivV3FCPP, 1)
-static inline HMM_Vec3 HMM_Div(HMM_Vec3 Left, float Right)
+static inline vec3 HMM_Div(vec3 Left, float Right)
 {
     ASSERT_COVERED(HMM_DivV3FCPP);
     return HMM_DivV3F(Left, Right);
 }
 
 COVERAGE(HMM_DivV4CPP, 1)
-static inline HMM_Vec4 HMM_Div(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline vec4 HMM_Div(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_DivV4CPP);
     return HMM_DivV4(Left, Right);
 }
 
 COVERAGE(HMM_DivV4FCPP, 1)
-static inline HMM_Vec4 HMM_Div(HMM_Vec4 Left, float Right)
+static inline vec4 HMM_Div(vec4 Left, float Right)
 {
     ASSERT_COVERED(HMM_DivV4FCPP);
     return HMM_DivV4F(Left, Right);
 }
 
 COVERAGE(HMM_DivM2FCPP, 1)
-static inline HMM_Mat2 HMM_Div(HMM_Mat2 Left, float Right)
+static inline mat2 HMM_Div(mat2 Left, float Right)
 {
     ASSERT_COVERED(HMM_DivM2FCPP);
     return HMM_DivM2F(Left, Right);
 }
 
 COVERAGE(HMM_DivM3FCPP, 1)
-static inline HMM_Mat3 HMM_Div(HMM_Mat3 Left, float Right)
+static inline mat3 HMM_Div(mat3 Left, float Right)
 {
     ASSERT_COVERED(HMM_DivM3FCPP);
     return HMM_DivM3F(Left, Right);
 }
 
 COVERAGE(HMM_DivM4FCPP, 1)
-static inline HMM_Mat4 HMM_Div(HMM_Mat4 Left, float Right)
+static inline mat4 HMM_Div(mat4 Left, float Right)
 {
     ASSERT_COVERED(HMM_DivM4FCPP);
     return HMM_DivM4F(Left, Right);
@@ -3132,63 +3132,63 @@ static inline HMM_Quat HMM_Div(HMM_Quat Left, float Right)
 }
 
 COVERAGE(HMM_EqV2CPP, 1)
-static inline HMM_Bool HMM_Eq(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline HMM_Bool HMM_Eq(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_EqV2CPP);
     return HMM_EqV2(Left, Right);
 }
 
 COVERAGE(HMM_EqV3CPP, 1)
-static inline HMM_Bool HMM_Eq(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline HMM_Bool HMM_Eq(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_EqV3CPP);
     return HMM_EqV3(Left, Right);
 }
 
 COVERAGE(HMM_EqV4CPP, 1)
-static inline HMM_Bool HMM_Eq(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline HMM_Bool HMM_Eq(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_EqV4CPP);
     return HMM_EqV4(Left, Right);
 }
 
 COVERAGE(HMM_AddV2Op, 1)
-static inline HMM_Vec2 operator+(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline vec2 operator+(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_AddV2Op);
     return HMM_AddV2(Left, Right);
 }
 
 COVERAGE(HMM_AddV3Op, 1)
-static inline HMM_Vec3 operator+(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline vec3 operator+(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_AddV3Op);
     return HMM_AddV3(Left, Right);
 }
 
 COVERAGE(HMM_AddV4Op, 1)
-static inline HMM_Vec4 operator+(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline vec4 operator+(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_AddV4Op);
     return HMM_AddV4(Left, Right);
 }
 
 COVERAGE(HMM_AddM2Op, 1)
-static inline HMM_Mat2 operator+(HMM_Mat2 Left, HMM_Mat2 Right)
+static inline mat2 operator+(mat2 Left, mat2 Right)
 {
     ASSERT_COVERED(HMM_AddM2Op);
     return HMM_AddM2(Left, Right);
 }
 
 COVERAGE(HMM_AddM3Op, 1)
-static inline HMM_Mat3 operator+(HMM_Mat3 Left, HMM_Mat3 Right)
+static inline mat3 operator+(mat3 Left, mat3 Right)
 {
     ASSERT_COVERED(HMM_AddM3Op);
     return HMM_AddM3(Left, Right);
 }
 
 COVERAGE(HMM_AddM4Op, 1)
-static inline HMM_Mat4 operator+(HMM_Mat4 Left, HMM_Mat4 Right)
+static inline mat4 operator+(mat4 Left, mat4 Right)
 {
     ASSERT_COVERED(HMM_AddM4Op);
     return HMM_AddM4(Left, Right);
@@ -3202,42 +3202,42 @@ static inline HMM_Quat operator+(HMM_Quat Left, HMM_Quat Right)
 }
 
 COVERAGE(HMM_SubV2Op, 1)
-static inline HMM_Vec2 operator-(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline vec2 operator-(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_SubV2Op);
     return HMM_SubV2(Left, Right);
 }
 
 COVERAGE(HMM_SubV3Op, 1)
-static inline HMM_Vec3 operator-(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline vec3 operator-(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_SubV3Op);
     return HMM_SubV3(Left, Right);
 }
 
 COVERAGE(HMM_SubV4Op, 1)
-static inline HMM_Vec4 operator-(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline vec4 operator-(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_SubV4Op);
     return HMM_SubV4(Left, Right);
 }
 
 COVERAGE(HMM_SubM2Op, 1)
-static inline HMM_Mat2 operator-(HMM_Mat2 Left, HMM_Mat2 Right)
+static inline mat2 operator-(mat2 Left, mat2 Right)
 {
     ASSERT_COVERED(HMM_SubM2Op);
     return HMM_SubM2(Left, Right);
 }
 
 COVERAGE(HMM_SubM3Op, 1)
-static inline HMM_Mat3 operator-(HMM_Mat3 Left, HMM_Mat3 Right)
+static inline mat3 operator-(mat3 Left, mat3 Right)
 {
     ASSERT_COVERED(HMM_SubM3Op);
     return HMM_SubM3(Left, Right);
 }
 
 COVERAGE(HMM_SubM4Op, 1)
-static inline HMM_Mat4 operator-(HMM_Mat4 Left, HMM_Mat4 Right)
+static inline mat4 operator-(mat4 Left, mat4 Right)
 {
     ASSERT_COVERED(HMM_SubM4Op);
     return HMM_SubM4(Left, Right);
@@ -3251,42 +3251,42 @@ static inline HMM_Quat operator-(HMM_Quat Left, HMM_Quat Right)
 }
 
 COVERAGE(HMM_MulV2Op, 1)
-static inline HMM_Vec2 operator*(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline vec2 operator*(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_MulV2Op);
     return HMM_MulV2(Left, Right);
 }
 
 COVERAGE(HMM_MulV3Op, 1)
-static inline HMM_Vec3 operator*(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline vec3 operator*(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_MulV3Op);
     return HMM_MulV3(Left, Right);
 }
 
 COVERAGE(HMM_MulV4Op, 1)
-static inline HMM_Vec4 operator*(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline vec4 operator*(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_MulV4Op);
     return HMM_MulV4(Left, Right);
 }
 
 COVERAGE(HMM_MulM2Op, 1)
-static inline HMM_Mat2 operator*(HMM_Mat2 Left, HMM_Mat2 Right)
+static inline mat2 operator*(mat2 Left, mat2 Right)
 {
     ASSERT_COVERED(HMM_MulM2Op);
     return HMM_MulM2(Left, Right);
 }
 
 COVERAGE(HMM_MulM3Op, 1)
-static inline HMM_Mat3 operator*(HMM_Mat3 Left, HMM_Mat3 Right)
+static inline mat3 operator*(mat3 Left, mat3 Right)
 {
     ASSERT_COVERED(HMM_MulM3Op);
     return HMM_MulM3(Left, Right);
 }
 
 COVERAGE(HMM_MulM4Op, 1)
-static inline HMM_Mat4 operator*(HMM_Mat4 Left, HMM_Mat4 Right)
+static inline mat4 operator*(mat4 Left, mat4 Right)
 {
     ASSERT_COVERED(HMM_MulM4Op);
     return HMM_MulM4(Left, Right);
@@ -3300,42 +3300,42 @@ static inline HMM_Quat operator*(HMM_Quat Left, HMM_Quat Right)
 }
 
 COVERAGE(HMM_MulV2FOp, 1)
-static inline HMM_Vec2 operator*(HMM_Vec2 Left, float Right)
+static inline vec2 operator*(vec2 Left, float Right)
 {
     ASSERT_COVERED(HMM_MulV2FOp);
     return HMM_MulV2F(Left, Right);
 }
 
 COVERAGE(HMM_MulV3FOp, 1)
-static inline HMM_Vec3 operator*(HMM_Vec3 Left, float Right)
+static inline vec3 operator*(vec3 Left, float Right)
 {
     ASSERT_COVERED(HMM_MulV3FOp);
     return HMM_MulV3F(Left, Right);
 }
 
 COVERAGE(HMM_MulV4FOp, 1)
-static inline HMM_Vec4 operator*(HMM_Vec4 Left, float Right)
+static inline vec4 operator*(vec4 Left, float Right)
 {
     ASSERT_COVERED(HMM_MulV4FOp);
     return HMM_MulV4F(Left, Right);
 }
 
 COVERAGE(HMM_MulM2FOp, 1)
-static inline HMM_Mat2 operator*(HMM_Mat2 Left, float Right)
+static inline mat2 operator*(mat2 Left, float Right)
 {
     ASSERT_COVERED(HMM_MulM2FOp);
     return HMM_MulM2F(Left, Right);
 }
 
 COVERAGE(HMM_MulM3FOp, 1)
-static inline HMM_Mat3 operator*(HMM_Mat3 Left, float Right)
+static inline mat3 operator*(mat3 Left, float Right)
 {
     ASSERT_COVERED(HMM_MulM3FOp);
     return HMM_MulM3F(Left, Right);
 }
 
 COVERAGE(HMM_MulM4FOp, 1)
-static inline HMM_Mat4 operator*(HMM_Mat4 Left, float Right)
+static inline mat4 operator*(mat4 Left, float Right)
 {
     ASSERT_COVERED(HMM_MulM4FOp);
     return HMM_MulM4F(Left, Right);
@@ -3349,42 +3349,42 @@ static inline HMM_Quat operator*(HMM_Quat Left, float Right)
 }
 
 COVERAGE(HMM_MulV2FOpLeft, 1)
-static inline HMM_Vec2 operator*(float Left, HMM_Vec2 Right)
+static inline vec2 operator*(float Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_MulV2FOpLeft);
     return HMM_MulV2F(Right, Left);
 }
 
 COVERAGE(HMM_MulV3FOpLeft, 1)
-static inline HMM_Vec3 operator*(float Left, HMM_Vec3 Right)
+static inline vec3 operator*(float Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_MulV3FOpLeft);
     return HMM_MulV3F(Right, Left);
 }
 
 COVERAGE(HMM_MulV4FOpLeft, 1)
-static inline HMM_Vec4 operator*(float Left, HMM_Vec4 Right)
+static inline vec4 operator*(float Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_MulV4FOpLeft);
     return HMM_MulV4F(Right, Left);
 }
 
 COVERAGE(HMM_MulM2FOpLeft, 1)
-static inline HMM_Mat2 operator*(float Left, HMM_Mat2 Right)
+static inline mat2 operator*(float Left, mat2 Right)
 {
     ASSERT_COVERED(HMM_MulM2FOpLeft);
     return HMM_MulM2F(Right, Left);
 }
 
 COVERAGE(HMM_MulM3FOpLeft, 1)
-static inline HMM_Mat3 operator*(float Left, HMM_Mat3 Right)
+static inline mat3 operator*(float Left, mat3 Right)
 {
     ASSERT_COVERED(HMM_MulM3FOpLeft);
     return HMM_MulM3F(Right, Left);
 }
 
 COVERAGE(HMM_MulM4FOpLeft, 1)
-static inline HMM_Mat4 operator*(float Left, HMM_Mat4 Right)
+static inline mat4 operator*(float Left, mat4 Right)
 {
     ASSERT_COVERED(HMM_MulM4FOpLeft);
     return HMM_MulM4F(Right, Left);
@@ -3398,84 +3398,84 @@ static inline HMM_Quat operator*(float Left, HMM_Quat Right)
 }
 
 COVERAGE(HMM_MulM2V2Op, 1)
-static inline HMM_Vec2 operator*(HMM_Mat2 Matrix, HMM_Vec2 Vector)
+static inline vec2 operator*(mat2 Matrix, vec2 Vector)
 {
     ASSERT_COVERED(HMM_MulM2V2Op);
     return HMM_MulM2V2(Matrix, Vector);
 }
 
 COVERAGE(HMM_MulM3V3Op, 1)
-static inline HMM_Vec3 operator*(HMM_Mat3 Matrix, HMM_Vec3 Vector)
+static inline vec3 operator*(mat3 Matrix, vec3 Vector)
 {
     ASSERT_COVERED(HMM_MulM3V3Op);
     return HMM_MulM3V3(Matrix, Vector);
 }
 
 COVERAGE(HMM_MulM4V4Op, 1)
-static inline HMM_Vec4 operator*(HMM_Mat4 Matrix, HMM_Vec4 Vector)
+static inline vec4 operator*(mat4 Matrix, vec4 Vector)
 {
     ASSERT_COVERED(HMM_MulM4V4Op);
     return HMM_MulM4V4(Matrix, Vector);
 }
 
 COVERAGE(HMM_DivV2Op, 1)
-static inline HMM_Vec2 operator/(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline vec2 operator/(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_DivV2Op);
     return HMM_DivV2(Left, Right);
 }
 
 COVERAGE(HMM_DivV3Op, 1)
-static inline HMM_Vec3 operator/(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline vec3 operator/(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_DivV3Op);
     return HMM_DivV3(Left, Right);
 }
 
 COVERAGE(HMM_DivV4Op, 1)
-static inline HMM_Vec4 operator/(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline vec4 operator/(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_DivV4Op);
     return HMM_DivV4(Left, Right);
 }
 
 COVERAGE(HMM_DivV2FOp, 1)
-static inline HMM_Vec2 operator/(HMM_Vec2 Left, float Right)
+static inline vec2 operator/(vec2 Left, float Right)
 {
     ASSERT_COVERED(HMM_DivV2FOp);
     return HMM_DivV2F(Left, Right);
 }
 
 COVERAGE(HMM_DivV3FOp, 1)
-static inline HMM_Vec3 operator/(HMM_Vec3 Left, float Right)
+static inline vec3 operator/(vec3 Left, float Right)
 {
     ASSERT_COVERED(HMM_DivV3FOp);
     return HMM_DivV3F(Left, Right);
 }
 
 COVERAGE(HMM_DivV4FOp, 1)
-static inline HMM_Vec4 operator/(HMM_Vec4 Left, float Right)
+static inline vec4 operator/(vec4 Left, float Right)
 {
     ASSERT_COVERED(HMM_DivV4FOp);
     return HMM_DivV4F(Left, Right);
 }
 
 COVERAGE(HMM_DivM4FOp, 1)
-static inline HMM_Mat4 operator/(HMM_Mat4 Left, float Right)
+static inline mat4 operator/(mat4 Left, float Right)
 {
     ASSERT_COVERED(HMM_DivM4FOp);
     return HMM_DivM4F(Left, Right);
 }
 
 COVERAGE(HMM_DivM3FOp, 1)
-static inline HMM_Mat3 operator/(HMM_Mat3 Left, float Right)
+static inline mat3 operator/(mat3 Left, float Right)
 {
     ASSERT_COVERED(HMM_DivM3FOp);
     return HMM_DivM3F(Left, Right);
 }
 
 COVERAGE(HMM_DivM2FOp, 1)
-static inline HMM_Mat2 operator/(HMM_Mat2 Left, float Right)
+static inline mat2 operator/(mat2 Left, float Right)
 {
     ASSERT_COVERED(HMM_DivM2FOp);
     return HMM_DivM2F(Left, Right);
@@ -3489,42 +3489,42 @@ static inline HMM_Quat operator/(HMM_Quat Left, float Right)
 }
 
 COVERAGE(HMM_AddV2Assign, 1)
-static inline HMM_Vec2 &operator+=(HMM_Vec2 &Left, HMM_Vec2 Right)
+static inline vec2 &operator+=(vec2 &Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_AddV2Assign);
     return Left = Left + Right;
 }
 
 COVERAGE(HMM_AddV3Assign, 1)
-static inline HMM_Vec3 &operator+=(HMM_Vec3 &Left, HMM_Vec3 Right)
+static inline vec3 &operator+=(vec3 &Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_AddV3Assign);
     return Left = Left + Right;
 }
 
 COVERAGE(HMM_AddV4Assign, 1)
-static inline HMM_Vec4 &operator+=(HMM_Vec4 &Left, HMM_Vec4 Right)
+static inline vec4 &operator+=(vec4 &Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_AddV4Assign);
     return Left = Left + Right;
 }
 
 COVERAGE(HMM_AddM2Assign, 1)
-static inline HMM_Mat2 &operator+=(HMM_Mat2 &Left, HMM_Mat2 Right)
+static inline mat2 &operator+=(mat2 &Left, mat2 Right)
 {
     ASSERT_COVERED(HMM_AddM2Assign);
     return Left = Left + Right;
 }
 
 COVERAGE(HMM_AddM3Assign, 1)
-static inline HMM_Mat3 &operator+=(HMM_Mat3 &Left, HMM_Mat3 Right)
+static inline mat3 &operator+=(mat3 &Left, mat3 Right)
 {
     ASSERT_COVERED(HMM_AddM3Assign);
     return Left = Left + Right;
 }
 
 COVERAGE(HMM_AddM4Assign, 1)
-static inline HMM_Mat4 &operator+=(HMM_Mat4 &Left, HMM_Mat4 Right)
+static inline mat4 &operator+=(mat4 &Left, mat4 Right)
 {
     ASSERT_COVERED(HMM_AddM4Assign);
     return Left = Left + Right;
@@ -3538,42 +3538,42 @@ static inline HMM_Quat &operator+=(HMM_Quat &Left, HMM_Quat Right)
 }
 
 COVERAGE(HMM_SubV2Assign, 1)
-static inline HMM_Vec2 &operator-=(HMM_Vec2 &Left, HMM_Vec2 Right)
+static inline vec2 &operator-=(vec2 &Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_SubV2Assign);
     return Left = Left - Right;
 }
 
 COVERAGE(HMM_SubV3Assign, 1)
-static inline HMM_Vec3 &operator-=(HMM_Vec3 &Left, HMM_Vec3 Right)
+static inline vec3 &operator-=(vec3 &Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_SubV3Assign);
     return Left = Left - Right;
 }
 
 COVERAGE(HMM_SubV4Assign, 1)
-static inline HMM_Vec4 &operator-=(HMM_Vec4 &Left, HMM_Vec4 Right)
+static inline vec4 &operator-=(vec4 &Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_SubV4Assign);
     return Left = Left - Right;
 }
 
 COVERAGE(HMM_SubM2Assign, 1)
-static inline HMM_Mat2 &operator-=(HMM_Mat2 &Left, HMM_Mat2 Right)
+static inline mat2 &operator-=(mat2 &Left, mat2 Right)
 {
     ASSERT_COVERED(HMM_SubM2Assign);
     return Left = Left - Right;
 }
 
 COVERAGE(HMM_SubM3Assign, 1)
-static inline HMM_Mat3 &operator-=(HMM_Mat3 &Left, HMM_Mat3 Right)
+static inline mat3 &operator-=(mat3 &Left, mat3 Right)
 {
     ASSERT_COVERED(HMM_SubM3Assign);
     return Left = Left - Right;
 }
 
 COVERAGE(HMM_SubM4Assign, 1)
-static inline HMM_Mat4 &operator-=(HMM_Mat4 &Left, HMM_Mat4 Right)
+static inline mat4 &operator-=(mat4 &Left, mat4 Right)
 {
     ASSERT_COVERED(HMM_SubM4Assign);
     return Left = Left - Right;
@@ -3587,63 +3587,63 @@ static inline HMM_Quat &operator-=(HMM_Quat &Left, HMM_Quat Right)
 }
 
 COVERAGE(HMM_MulV2Assign, 1)
-static inline HMM_Vec2 &operator*=(HMM_Vec2 &Left, HMM_Vec2 Right)
+static inline vec2 &operator*=(vec2 &Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_MulV2Assign);
     return Left = Left * Right;
 }
 
 COVERAGE(HMM_MulV3Assign, 1)
-static inline HMM_Vec3 &operator*=(HMM_Vec3 &Left, HMM_Vec3 Right)
+static inline vec3 &operator*=(vec3 &Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_MulV3Assign);
     return Left = Left * Right;
 }
 
 COVERAGE(HMM_MulV4Assign, 1)
-static inline HMM_Vec4 &operator*=(HMM_Vec4 &Left, HMM_Vec4 Right)
+static inline vec4 &operator*=(vec4 &Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_MulV4Assign);
     return Left = Left * Right;
 }
 
 COVERAGE(HMM_MulV2FAssign, 1)
-static inline HMM_Vec2 &operator*=(HMM_Vec2 &Left, float Right)
+static inline vec2 &operator*=(vec2 &Left, float Right)
 {
     ASSERT_COVERED(HMM_MulV2FAssign);
     return Left = Left * Right;
 }
 
 COVERAGE(HMM_MulV3FAssign, 1)
-static inline HMM_Vec3 &operator*=(HMM_Vec3 &Left, float Right)
+static inline vec3 &operator*=(vec3 &Left, float Right)
 {
     ASSERT_COVERED(HMM_MulV3FAssign);
     return Left = Left * Right;
 }
 
 COVERAGE(HMM_MulV4FAssign, 1)
-static inline HMM_Vec4 &operator*=(HMM_Vec4 &Left, float Right)
+static inline vec4 &operator*=(vec4 &Left, float Right)
 {
     ASSERT_COVERED(HMM_MulV4FAssign);
     return Left = Left * Right;
 }
 
 COVERAGE(HMM_MulM2FAssign, 1)
-static inline HMM_Mat2 &operator*=(HMM_Mat2 &Left, float Right)
+static inline mat2 &operator*=(mat2 &Left, float Right)
 {
     ASSERT_COVERED(HMM_MulM2FAssign);
     return Left = Left * Right;
 }
 
 COVERAGE(HMM_MulM3FAssign, 1)
-static inline HMM_Mat3 &operator*=(HMM_Mat3 &Left, float Right)
+static inline mat3 &operator*=(mat3 &Left, float Right)
 {
     ASSERT_COVERED(HMM_MulM3FAssign);
     return Left = Left * Right;
 }
 
 COVERAGE(HMM_MulM4FAssign, 1)
-static inline HMM_Mat4 &operator*=(HMM_Mat4 &Left, float Right)
+static inline mat4 &operator*=(mat4 &Left, float Right)
 {
     ASSERT_COVERED(HMM_MulM4FAssign);
     return Left = Left * Right;
@@ -3657,49 +3657,49 @@ static inline HMM_Quat &operator*=(HMM_Quat &Left, float Right)
 }
 
 COVERAGE(HMM_DivV2Assign, 1)
-static inline HMM_Vec2 &operator/=(HMM_Vec2 &Left, HMM_Vec2 Right)
+static inline vec2 &operator/=(vec2 &Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_DivV2Assign);
     return Left = Left / Right;
 }
 
 COVERAGE(HMM_DivV3Assign, 1)
-static inline HMM_Vec3 &operator/=(HMM_Vec3 &Left, HMM_Vec3 Right)
+static inline vec3 &operator/=(vec3 &Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_DivV3Assign);
     return Left = Left / Right;
 }
 
 COVERAGE(HMM_DivV4Assign, 1)
-static inline HMM_Vec4 &operator/=(HMM_Vec4 &Left, HMM_Vec4 Right)
+static inline vec4 &operator/=(vec4 &Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_DivV4Assign);
     return Left = Left / Right;
 }
 
 COVERAGE(HMM_DivV2FAssign, 1)
-static inline HMM_Vec2 &operator/=(HMM_Vec2 &Left, float Right)
+static inline vec2 &operator/=(vec2 &Left, float Right)
 {
     ASSERT_COVERED(HMM_DivV2FAssign);
     return Left = Left / Right;
 }
 
 COVERAGE(HMM_DivV3FAssign, 1)
-static inline HMM_Vec3 &operator/=(HMM_Vec3 &Left, float Right)
+static inline vec3 &operator/=(vec3 &Left, float Right)
 {
     ASSERT_COVERED(HMM_DivV3FAssign);
     return Left = Left / Right;
 }
 
 COVERAGE(HMM_DivV4FAssign, 1)
-static inline HMM_Vec4 &operator/=(HMM_Vec4 &Left, float Right)
+static inline vec4 &operator/=(vec4 &Left, float Right)
 {
     ASSERT_COVERED(HMM_DivV4FAssign);
     return Left = Left / Right;
 }
 
 COVERAGE(HMM_DivM4FAssign, 1)
-static inline HMM_Mat4 &operator/=(HMM_Mat4 &Left, float Right)
+static inline mat4 &operator/=(mat4 &Left, float Right)
 {
     ASSERT_COVERED(HMM_DivM4FAssign);
     return Left = Left / Right;
@@ -3713,88 +3713,88 @@ static inline HMM_Quat &operator/=(HMM_Quat &Left, float Right)
 }
 
 COVERAGE(HMM_EqV2Op, 1)
-static inline HMM_Bool operator==(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline HMM_Bool operator==(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_EqV2Op);
     return HMM_EqV2(Left, Right);
 }
 
 COVERAGE(HMM_EqV3Op, 1)
-static inline HMM_Bool operator==(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline HMM_Bool operator==(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_EqV3Op);
     return HMM_EqV3(Left, Right);
 }
 
 COVERAGE(HMM_EqV4Op, 1)
-static inline HMM_Bool operator==(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline HMM_Bool operator==(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_EqV4Op);
     return HMM_EqV4(Left, Right);
 }
 
 COVERAGE(HMM_EqV2OpNot, 1)
-static inline HMM_Bool operator!=(HMM_Vec2 Left, HMM_Vec2 Right)
+static inline HMM_Bool operator!=(vec2 Left, vec2 Right)
 {
     ASSERT_COVERED(HMM_EqV2OpNot);
     return !HMM_EqV2(Left, Right);
 }
 
 COVERAGE(HMM_EqV3OpNot, 1)
-static inline HMM_Bool operator!=(HMM_Vec3 Left, HMM_Vec3 Right)
+static inline HMM_Bool operator!=(vec3 Left, vec3 Right)
 {
     ASSERT_COVERED(HMM_EqV3OpNot);
     return !HMM_EqV3(Left, Right);
 }
 
 COVERAGE(HMM_EqV4OpNot, 1)
-static inline HMM_Bool operator!=(HMM_Vec4 Left, HMM_Vec4 Right)
+static inline HMM_Bool operator!=(vec4 Left, vec4 Right)
 {
     ASSERT_COVERED(HMM_EqV4OpNot);
     return !HMM_EqV4(Left, Right);
 }
 
 COVERAGE(HMM_UnaryMinusV2, 1)
-static inline HMM_Vec2 operator-(HMM_Vec2 In)
+static inline vec2 operator-(vec2 In)
 {
     ASSERT_COVERED(HMM_UnaryMinusV2);
 
-    HMM_Vec2 Result;
-    Result.X = -In.X;
-    Result.Y = -In.Y;
+    vec2 Result;
+    Result.x = -In.x;
+    Result.y = -In.y;
 
     return Result;
 }
 
 COVERAGE(HMM_UnaryMinusV3, 1)
-static inline HMM_Vec3 operator-(HMM_Vec3 In)
+static inline vec3 operator-(vec3 In)
 {
     ASSERT_COVERED(HMM_UnaryMinusV3);
 
-    HMM_Vec3 Result;
-    Result.X = -In.X;
-    Result.Y = -In.Y;
-    Result.Z = -In.Z;
+    vec3 Result;
+    Result.x = -In.x;
+    Result.y = -In.y;
+    Result.z = -In.z;
 
     return Result;
 }
 
 COVERAGE(HMM_UnaryMinusV4, 1)
-static inline HMM_Vec4 operator-(HMM_Vec4 In)
+static inline vec4 operator-(vec4 In)
 {
     ASSERT_COVERED(HMM_UnaryMinusV4);
 
-    HMM_Vec4 Result;
+    vec4 Result;
 #if HANDMADE_MATH__USE_SSE
     Result.SSE = _mm_xor_ps(In.SSE, _mm_set1_ps(-0.0f));
 #elif defined(HANDMADE_MATH__USE_NEON)
     float32x4_t Zero = vdupq_n_f32(0.0f);
     Result.NEON = vsubq_f32(Zero, In.NEON);
 #else
-    Result.X = -In.X;
-    Result.Y = -In.Y;
-    Result.Z = -In.Z;
-    Result.W = -In.W;
+    Result.x = -In.x;
+    Result.y = -In.y;
+    Result.z = -In.z;
+    Result.w = -In.w;
 #endif
 
     return Result;
@@ -3806,128 +3806,128 @@ static inline HMM_Vec4 operator-(HMM_Vec4 In)
 
 void __hmm_invalid_generic();
 
-#define HMM_Add(A, B) _Generic((A), \
-    HMM_Vec2: HMM_AddV2, \
-    HMM_Vec3: HMM_AddV3, \
-    HMM_Vec4: HMM_AddV4, \
-    HMM_Mat2: HMM_AddM2, \
-    HMM_Mat3: HMM_AddM3, \
-    HMM_Mat4: HMM_AddM4, \
+#define hmm_add(A, B) _Generic((A), \
+    vec2: HMM_AddV2, \
+    vec3: HMM_AddV3, \
+    vec4: HMM_AddV4, \
+    mat2: HMM_AddM2, \
+    mat3: HMM_AddM3, \
+    mat4: HMM_AddM4, \
     HMM_Quat: HMM_AddQ   \
 )(A, B)
 
-#define HMM_Sub(A, B) _Generic((A), \
-    HMM_Vec2: HMM_SubV2, \
-    HMM_Vec3: HMM_SubV3, \
-    HMM_Vec4: HMM_SubV4, \
-    HMM_Mat2: HMM_SubM2, \
-    HMM_Mat3: HMM_SubM3, \
-    HMM_Mat4: HMM_SubM4, \
+#define hmm_sub(A, B) _Generic((A), \
+    vec2: HMM_SubV2, \
+    vec3: HMM_SubV3, \
+    vec4: HMM_SubV4, \
+    mat2: HMM_SubM2, \
+    mat3: HMM_SubM3, \
+    mat4: HMM_SubM4, \
     HMM_Quat: HMM_SubQ   \
 )(A, B)
 
-#define HMM_Mul(A, B) _Generic((B), \
+#define hmm_mul(A, B) _Generic((B), \
     float: _Generic((A), \
-        HMM_Vec2: HMM_MulV2F, \
-        HMM_Vec3: HMM_MulV3F, \
-        HMM_Vec4: HMM_MulV4F, \
-        HMM_Mat2: HMM_MulM2F, \
-        HMM_Mat3: HMM_MulM3F, \
-        HMM_Mat4: HMM_MulM4F, \
+        vec2: HMM_MulV2F, \
+        vec3: HMM_MulV3F, \
+        vec4: HMM_MulV4F, \
+        mat2: HMM_MulM2F, \
+        mat3: HMM_MulM3F, \
+        mat4: HMM_MulM4F, \
         HMM_Quat: HMM_MulQF,  \
         default: __hmm_invalid_generic \
     ), \
-    HMM_Vec2: _Generic((A), \
-        HMM_Vec2: HMM_MulV2,   \
-        HMM_Mat2: HMM_MulM2V2, \
+    vec2: _Generic((A), \
+        vec2: HMM_MulV2,   \
+        mat2: HMM_MulM2V2, \
         default: __hmm_invalid_generic \
     ), \
-    HMM_Vec3: _Generic((A), \
-        HMM_Vec3: HMM_MulV3,   \
-        HMM_Mat3: HMM_MulM3V3, \
+    vec3: _Generic((A), \
+        vec3: HMM_MulV3,   \
+        mat3: HMM_MulM3V3, \
         default: __hmm_invalid_generic \
     ), \
-    HMM_Vec4: _Generic((A), \
-        HMM_Vec4: HMM_MulV4,   \
-        HMM_Mat4: HMM_MulM4V4, \
+    vec4: _Generic((A), \
+        vec4: HMM_MulV4,   \
+        mat4: HMM_MulM4V4, \
         default: __hmm_invalid_generic \
     ), \
-    HMM_Mat2: HMM_MulM2, \
-    HMM_Mat3: HMM_MulM3, \
-    HMM_Mat4: HMM_MulM4, \
+    mat2: HMM_MulM2, \
+    mat3: HMM_MulM3, \
+    mat4: HMM_MulM4, \
     HMM_Quat: HMM_MulQ   \
 )(A, B)
 
-#define HMM_Div(A, B) _Generic((B), \
+#define hmm_div(A, B) _Generic((B), \
     float: _Generic((A), \
-        HMM_Vec2: HMM_DivV2F, \
-        HMM_Vec3: HMM_DivV3F, \
-        HMM_Vec4: HMM_DivV4F, \
-        HMM_Mat2: HMM_DivM2F, \
-        HMM_Mat3: HMM_DivM3F, \
-        HMM_Mat4: HMM_DivM4F, \
+        vec2: HMM_DivV2F, \
+        vec3: HMM_DivV3F, \
+        vec4: HMM_DivV4F, \
+        mat2: HMM_DivM2F, \
+        mat3: HMM_DivM3F, \
+        mat4: HMM_DivM4F, \
         HMM_Quat: HMM_DivQF   \
     ), \
-    HMM_Vec2: HMM_DivV2, \
-    HMM_Vec3: HMM_DivV3, \
-    HMM_Vec4: HMM_DivV4  \
+    vec2: HMM_DivV2, \
+    vec3: HMM_DivV3, \
+    vec4: HMM_DivV4  \
 )(A, B)
 
-#define HMM_Len(A) _Generic((A), \
-    HMM_Vec2: HMM_LenV2, \
-    HMM_Vec3: HMM_LenV3, \
-    HMM_Vec4: HMM_LenV4  \
+#define hmm_len(A) _Generic((A), \
+    vec2: HMM_LenV2, \
+    vec3: HMM_LenV3, \
+    vec4: HMM_LenV4  \
 )(A)
 
-#define HMM_LenSqr(A) _Generic((A), \
-    HMM_Vec2: HMM_LenSqrV2, \
-    HMM_Vec3: HMM_LenSqrV3, \
-    HMM_Vec4: HMM_LenSqrV4  \
+#define hmm_lensqr(A) _Generic((A), \
+    vec2: HMM_LenSqrV2, \
+    vec3: HMM_LenSqrV3, \
+    vec4: HMM_LenSqrV4  \
 )(A)
 
-#define HMM_Norm(A) _Generic((A), \
-    HMM_Vec2: HMM_NormV2, \
-    HMM_Vec3: HMM_NormV3, \
-    HMM_Vec4: HMM_NormV4, \
+#define norm(A) _Generic((A), \
+    vec2: HMM_NormV2, \
+    vec3: HMM_NormV3, \
+    vec4: HMM_NormV4, \
     HMM_Quat: HMM_NormQ   \
 )(A)
 
-#define HMM_Dot(A, B) _Generic((A), \
-    HMM_Vec2: HMM_DotV2, \
-    HMM_Vec3: HMM_DotV3, \
-    HMM_Vec4: HMM_DotV4, \
+#define dot(A, B) _Generic((A), \
+    vec2: HMM_DotV2, \
+    vec3: HMM_DotV3, \
+    vec4: HMM_DotV4, \
     HMM_Quat: HMM_DotQ   \
 )(A, B)
 
-#define HMM_Lerp(A, T, B) _Generic((A), \
-    float: HMM_Lerp, \
-    HMM_Vec2: HMM_LerpV2, \
-    HMM_Vec3: HMM_LerpV3, \
-    HMM_Vec4: HMM_LerpV4  \
+#define lerp(A, T, B) _Generic((A), \
+    float: lerp, \
+    vec2: lerpV2, \
+    vec3: lerpV3, \
+    vec4: lerpV4  \
 )(A, T, B)
 
-#define HMM_Eq(A, B) _Generic((A), \
-    HMM_Vec2: HMM_EqV2, \
-    HMM_Vec3: HMM_EqV3, \
-    HMM_Vec4: HMM_EqV4  \
+#define hmm_eq(A, B) _Generic((A), \
+    vec2: HMM_EqV2, \
+    vec3: HMM_EqV3, \
+    vec4: HMM_EqV4  \
 )(A, B)
 
-#define HMM_Transpose(M) _Generic((M), \
-    HMM_Mat2: HMM_TransposeM2, \
-    HMM_Mat3: HMM_TransposeM3, \
-    HMM_Mat4: HMM_TransposeM4  \
+#define transpose(M) _Generic((M), \
+    mat2: HMM_TransposeM2, \
+    mat3: HMM_TransposeM3, \
+    mat4: HMM_TransposeM4  \
 )(M)
 
-#define HMM_Determinant(M) _Generic((M), \
-    HMM_Mat2: HMM_DeterminantM2, \
-    HMM_Mat3: HMM_DeterminantM3, \
-    HMM_Mat4: HMM_DeterminantM4  \
+#define hmm_determinant(M) _Generic((M), \
+    mat2: HMM_DeterminantM2, \
+    mat3: HMM_DeterminantM3, \
+    mat4: HMM_DeterminantM4  \
 )(M)
 
-#define HMM_InvGeneral(M) _Generic((M), \
-    HMM_Mat2: HMM_InvGeneralM2, \
-    HMM_Mat3: HMM_InvGeneralM3, \
-    HMM_Mat4: HMM_InvGeneralM4  \
+#define hmm_invgeneral(M) _Generic((M), \
+    mat2: HMM_InvGeneralM2, \
+    mat3: HMM_InvGeneralM3, \
+    mat4: HMM_InvGeneralM4  \
 )(M)
 
 #endif
diff --git a/src/main.c b/src/main.c
index 0ed54a5..6a10528 100644
--- a/src/main.c
+++ b/src/main.c
@@ -14,25 +14,26 @@
 #include "libs/sokol_glue.h"
 #include "libs/handmademath.h"
 
-#include "vecmath.h"
-
 #include "gen/obj.h"
 
 #include "utils.c"
+#include "gfx.c"
 #include "obj.c"
 #include "camera.c"
+#include "game.c"
+#include "player.c"
 
 ////////////////////////////////
 
-arena_t frame_arena = {0};
 sg_pipeline pip = {0};
 // sg_bindings binds = {0};
 sg_pass_action pass_action = {0};
 scene_t scene = {0};
-camera_t camera = {0};
+// camera_t camera = {0};
 u64 time_last = 0;
+// gfx_batcher_t *batch = NULL;
 
-vs_params_t vs_params = {0};
+obj_vs_params_t vs_params = {0};
 
 ////////////////////////////////
 
@@ -71,13 +72,15 @@ void app_init(void) {
 
     colla_init(COLLA_OS);
 
-    sapp_lock_mouse(true);
+    game_init();
 
-    frame_arena = arena_make(ARENA_VIRTUAL, GB(1));
+    gfx_init_batcher(&game.arena, 128);
 
-    // scene = obj_load_gltf(frame_arena, strv("data/metro.glb"));
-    scene = obj_load_gltf(frame_arena, strv("data/scene.glb"));
-    camera = cam_init();
+    player_init();
+
+    arena_t scratch = game.arena;
+
+    scene = obj_load_gltf(scratch, strv("data/scene.glb"));
 
     sg_shader shd = sg_make_shader(obj_shader_desc(sg_query_backend()));
 
@@ -107,6 +110,8 @@ void app_init(void) {
     };
 
     time_last = stm_now();
+
+    sapp_lock_mouse(true);
 }
 
 void app_frame(void) {
@@ -114,29 +119,47 @@ void app_frame(void) {
     float dt = (float)stm_sec(dt_ticks);
 
     utils_update();
-    cam_update(&camera, dt);
+    game_frame(dt);
+
+    entity_t *player = &game.active_by_type[ENTITY_PLAYER][0];
+    camera_t *cam = &player->camera;
 
     float aspect_ratio = sapp_widthf() / sapp_heightf();
 
-    HMM_Mat4 view = cam_view(&camera);
-    HMM_Mat4 proj = cam_proj(&camera);
-    HMM_Mat4 model = HMM_Translate(HMM_V3(0, 0, -10));
+    mat4 view = cam_view(cam);
+    mat4 proj = cam_proj(cam);
+    mat4 model = HMM_Translate(v3(0, 0, -10));
 
-    // HMM_Mat4 vp = HMM_Mul(HMM_Mul(proj, view), model);
-    // HMM_Mat4 vp = HMM_Mul(proj, view);
-
-    vs_params.mvp = HMM_Mul(proj, view);
-    vs_params.cam_pos = camera.pos;
-
-    arena_rewind(&frame_arena, 0);
+    vs_params.mvp = hmm_mul(proj, view);
+    vs_params.cam_pos = cam->pos;
 
     sg_begin_pass(&(sg_pass){ .action = pass_action, .swapchain = sglue_swapchain() });
-    sg_apply_pipeline(pip);
-    sg_apply_uniforms(0, SG_RANGE_REF(vs_params));
+    {
+        sg_apply_pipeline(pip);
+        sg_apply_uniforms(0, SG_RANGE_REF(vs_params));
         for (int i = 0; i < scene.object_count; ++i) {
             sg_apply_bindings(&scene.objects[i].bindings);
             sg_draw(0, scene.objects[i].draw_count, 1);
         }
+    }
+
+    {
+        // SHIT ASS CODE PLEASE DON'T LOOK
+        static float dt_avg = 0.f;
+        static u32 dt_count = 0;
+
+        dt_avg += dt;
+        dt_count++;
+
+        float delta_avg = dt_avg / (float)dt_count;
+
+        str_t fps = str_fmt(&game.frame_arena, "dt: %.5f // fps: %.2f", delta_avg, 1.f / delta_avg);
+        gfx_batcher_puts(&(gfx_print_desc_t){ 
+            .str = strv(fps), 
+            .col = v4(0.93, 0.6, 0.26, 1), 
+        });
+        gfx_batcher_present();
+    }
     sg_end_pass();
     sg_commit();
 }
@@ -151,9 +174,14 @@ void app_event(const sapp_event *e) {
             }
             set_key_state(e->key_code, e->type == SAPP_EVENTTYPE_KEY_DOWN);
             break;
+
         case SAPP_EVENTTYPE_MOUSE_MOVE:
             set_mouse_pos_and_delta(e->mouse_x, e->mouse_y, e->mouse_dx, e->mouse_dy);
             break;
+
+        case SAPP_EVENTTYPE_RESIZED:
+            set_win_resized();
+            break;
     }
 }
 
diff --git a/src/obj.c b/src/obj.c
index 3f3ca5b..ab36be0 100644
--- a/src/obj.c
+++ b/src/obj.c
@@ -5,7 +5,7 @@
 #define CGLTF_IMPLEMENTATION
 #include "libs/cgltf.h"
 
-#include "vecmath.h"
+#include "libs/handmademath.h"
 
 typedef struct vertex_t vertex_t;
 struct vertex_t {
@@ -15,236 +15,12 @@ struct vertex_t {
     vec2 lightmap;
 };
 
-typedef struct material_t material_t;
-struct material_t {
-    // texture
-    vec3 ambient_color;
-    vec3 diff_color;
-
-    /*
-     * (*) -> unused
-     * Ka: ambient color
-     * Kd: diffuse color
-     * Ks*: specular color
-     * Ns*: specular exponent
-     * d*: dissolve (opacity)
-     * Ni*: optical density (???)
-     * Ke*: emissive color
-     * illum*: illumination mode:
-        0. Color on and Ambient off
-        1. Color on and Ambient on
-        2. Highlight on
-        3. Reflection on and Ray trace on
-        4. Transparency: Glass on, Reflection: Ray trace on
-        5. Reflection: Fresnel on and Ray trace on
-        6. Transparency: Refraction on, Reflection: Fresnel off and Ray trace on
-        7. Transparency: Refraction on, Reflection: Fresnel on and Ray trace on
-        8. Reflection on and Ray trace off
-        9. Transparency: Glass on, Reflection: Ray trace off
-        10. Casts shadows onto invisible surfaces
-     * */
-};
-
 typedef struct obj_t obj_t;
 struct obj_t {
     sg_bindings bindings;
     u16 draw_count;
 };
 
-darr_define(f2_list_t, vec2);
-darr_define(f3_list_t, vec3);
-darr_define(i3_list_t, int3);
-
-#define list_get(l, i) do {  } while (0)
-
-typedef struct  {
-    f3_list_t *verts;
-    f3_list_t *norms;
-    f2_list_t *uvs;
-    i3_list_t *faces;
-    u32 vcount;
-    u32 ncount;
-    u32 tcount;
-    u32 fcount;
-} obj_ctx_t;
- 
-#define READ_F2(arr, c) do { \
-        vec2 v = {0}; \
-        istr_skip_whitespace(in); istr_get_float(in, &v.x); \
-        istr_skip_whitespace(in); istr_get_float(in, &v.y); \
-        darr_push(arena, arr, v); \
-        ++(c); \
-    } while (0)
-
-#define READ_F3(arr, c) do { \
-        vec3 v = {0}; \
-        istr_skip_whitespace(in); istr_get_float(in, &v.x); \
-        istr_skip_whitespace(in); istr_get_float(in, &v.y); \
-        istr_skip_whitespace(in); istr_get_float(in, &v.z); \
-        darr_push(arena, arr, v); \
-        ++(c); \
-    } while (0)
-
-#define READ_I3(arr, c) do { \
-        int3 v = {0}; \
-        istr_skip_whitespace(in); istr_get_i32(in, &v.x); \
-        istr_skip_whitespace(in); istr_get_i32(in, &v.y); \
-        istr_skip_whitespace(in); istr_get_i32(in, &v.z); \
-        darr_push(arena, arr, v); \
-        ++(c); \
-    } while (0)
-
-void obj__parse_line(arena_t *arena, instream_t *in, obj_ctx_t *ctx) {
-    if (istr_peek(in) == '#') {
-        return;
-    }
-
-    switch (istr_peek(in)) {
-        // vertex stuff
-        case 'v':
-            istr_skip(in, 1);
-            switch (istr_get(in)) {
-                // vertex
-                case ' ':
-                    READ_F3(ctx->verts, ctx->vcount);
-                    break;
-                // normal
-                case 'n':
-                    READ_F3(ctx->norms, ctx->ncount);
-                    break;
-                // texture
-                case 't':
-                    READ_F2(ctx->uvs, ctx->tcount);
-                    break;
-            }
-            return;
-
-        // faces
-        case 'f':
-            READ_I3(ctx->faces, ctx->fcount);
-            return;
-
-        // smooth shading
-        case 's':
-            // not implemented
-            return;
-        
-        // group
-        case 'g':
-            // not implemented
-            return;
-
-        // object
-        case 'o':
-            // not implemented
-            return;
-        
-        case '#': 
-            return;
-    }
-
-    strview_t word = istr_get_word(in);
-    if (strv_equals(word, strv("mtllib"))) {
-        // load mtl file
-    }
-    else if (strv_equals(word, strv("usemtl"))) {
-        // use material
-    }
-}
-
-obj_t obj_load(arena_t scratch, strview_t filename) {
-    obj_t out = {0};
-
-    str_t text = os_file_read_all_str(&scratch, filename);
-    instream_t in = istr_init(strv(text));
-
-    obj_ctx_t ctx = {0};
-    
-    while (!istr_is_finished(&in)) {
-        instream_t line = istr_init(istr_get_line(&in));
-        obj__parse_line(&scratch, &line, &ctx);
-    }
-
-    debug("%u %u %u", ctx.vcount, ctx.ncount, ctx.tcount);
-    colla_assert(ctx.vcount == ctx.ncount && ctx.vcount == ctx.tcount);
-
-    // copy over vertex data
-    vertex_t *vertices = alloc(&scratch, vertex_t, ctx.vcount);
-
-    {
-        u32 i = 0;
-        for_each (v, ctx.verts) {
-            for (int k = 0; k < v->count; ++k) {
-                vertices[i++].pos = v->items[k];
-            }
-        }
-    }
-
-    {
-        u32 i = 0;
-        for_each (v, ctx.uvs) {
-            for (int k = 0; k < v->count; ++k) {
-                vertices[i++].tex = v->items[k];
-            }
-        }
-    }
-
-    {
-        u32 i = 0;
-        for_each (v, ctx.norms) {
-            for (int k = 0; k < v->count; ++k) {
-                vertices[i++].norm = v->items[k];
-            }
-        }
-    }
-
-    // copy over indices data
-    u32 icount = ctx.fcount * 3;
-    u16 *indices = alloc(&scratch, u16, icount);
-
-    {
-        u32 i = 0;
-        for_each (v, ctx.faces) {
-            for (int k = 0; k < v->count; ++k) {
-                indices[i++] = v->items[k].x - 1;
-                indices[i++] = v->items[k].y - 1;
-                indices[i++] = v->items[k].z - 1;
-            }
-        }
-    }
-
-    sg_buffer vertex_buffer = sg_make_buffer(&(sg_buffer_desc){
-        .data = {
-            .ptr = vertices,
-            .size = sizeof(vertex_t) * ctx.vcount,
-        },
-        .usage = {
-            .vertex_buffer = true,
-            .immutable = true,
-        },
-    });
-
-    sg_buffer index_buffer = sg_make_buffer(&(sg_buffer_desc){
-        .data = {
-            .ptr = indices,
-            .size = sizeof(u16) * ctx.fcount * 3,
-        },
-        .usage = {
-            .index_buffer = true,
-            .immutable = true,
-        },
-    });
-
-    return (obj_t){
-        .bindings = {
-            .vertex_buffers[0] = vertex_buffer,
-            .index_buffer = index_buffer,
-            // .views[0] = {0},
-        },
-        .draw_count = icount,
-    };
-}
-
 cgltf_result obj__cgltf_file_read_cb(
     const cgltf_memory_options *m, 
     const cgltf_file_options *opt, 
@@ -466,25 +242,25 @@ scene_t obj_load_gltf(arena_t scratch, strview_t filename) {
                     case cgltf_attribute_type_position:
                     {
                         for (usize k = 0; k < acc->count; ++k) {
-                            cgltf_accessor_read_float(acc, k, verts[k].pos.data, 3);
+                            cgltf_accessor_read_float(acc, k, verts[k].pos.elements, 3);
                         }
                         break;
                     }
                     case cgltf_attribute_type_normal:
                         for (usize k = 0; k < acc->count; ++k) {
-                            cgltf_accessor_read_float(acc, k, verts[k].norm.data, 3);
+                            cgltf_accessor_read_float(acc, k, verts[k].norm.elements, 3);
                         }
                        break;
                     case cgltf_attribute_type_texcoord:
                     {
                         if (attr->index == 0) {
                             for (usize k = 0; k < acc->count; ++k) {
-                                cgltf_accessor_read_float(acc, k, verts[k].tex.data, 2);
+                                cgltf_accessor_read_float(acc, k, verts[k].tex.elements, 2);
                             }
                         }
                         else {
                             for (usize k = 0; k < acc->count; ++k) {
-                                cgltf_accessor_read_float(acc, k, verts[k].lightmap.data, 2);
+                                cgltf_accessor_read_float(acc, k, verts[k].lightmap.elements, 2);
                             }
                         }
                         break;
diff --git a/src/player.c b/src/player.c
new file mode 100644
index 0000000..b0de3e1
--- /dev/null
+++ b/src/player.c
@@ -0,0 +1,24 @@
+#include "game.h"
+#include "utils.h"
+
+entity_t *player_init(void) {
+    entity_t *e = game_new_entity(ENTITY_PLAYER);
+
+    e->camera = cam_init();
+    e->camera.mov_speed = 3;
+
+    return e;
+}
+
+void player__update(entity_t *e, float dt) {
+    e->camera.mov_speed = is_key_down(SAPP_KEYCODE_LEFT_SHIFT) ? 5 : 3;
+
+    cam_update(&e->camera, dt);
+    e->camera.pos.y = 1.6;
+}
+
+void player_frame(arena_t frame_arena, entity_t *players, float dt) {
+    for_each (e, players) {
+        player__update(e, dt);
+    }
+}
diff --git a/src/utils.c b/src/utils.c
index 19e74bb..e4884a1 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -8,9 +8,10 @@
 struct {
     bool keys[KEY_COUNT];
     bool prev_keys[KEY_COUNT];
-    HMM_Vec2 mouse_pos;
-    HMM_Vec2 mouse_delta;
+    vec2 mouse_pos;
+    vec2 mouse_delta;
     int delta_frames_passed;
+    bool resized;
 } utils_state = {0};
 
 bool is_key_down(sapp_keycode k) {
@@ -29,20 +30,29 @@ void set_key_state(sapp_keycode k, bool is_down) {
 void utils_update(void) {
     memmove(utils_state.prev_keys, utils_state.keys, sizeof(utils_state.keys));
     if (utils_state.delta_frames_passed++ > 0) {
-        utils_state.mouse_delta = HMM_V2(0, 0);
+        utils_state.mouse_delta = v2(0, 0);
     }
+    utils_state.resized = false;
 }
 
-HMM_Vec2 mouse_pos(void) {
+vec2 mouse_pos(void) {
     return utils_state.mouse_pos;
 }
 
-HMM_Vec2 mouse_delta(void) {
+vec2 mouse_delta(void) {
     return utils_state.mouse_delta;
 }
 
+bool win_has_resized(void) {
+    return utils_state.resized;
+}
+
 void set_mouse_pos_and_delta(float x, float y, float dx, float dy) {
-    utils_state.mouse_pos = HMM_V2(x, y);
-    utils_state.mouse_delta = HMM_V2(dx, dy);
+    utils_state.mouse_pos = v2(x, y);
+    utils_state.mouse_delta = v2(dx, dy);
     utils_state.delta_frames_passed = 0;
 }
+
+void set_win_resized(void) {
+    utils_state.resized = true;
+}
diff --git a/src/utils.h b/src/utils.h
index 135385b..cdc088d 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -8,7 +8,10 @@ bool is_key_pressed(sapp_keycode k);
 
 void set_key_state(sapp_keycode k, bool is_down);
 
-HMM_Vec2 mouse_pos(void);
-HMM_Vec2 mouse_delta(void);
+vec2 mouse_pos(void);
+vec2 mouse_delta(void);
+
+bool win_has_resized(void);
 
 void set_mouse_pos_and_delta(float x, float y, float dx, float dy);
+void set_win_resized(void);
diff --git a/src/vecmath.h b/src/vecmath.h
deleted file mode 100644
index f238f61..0000000
--- a/src/vecmath.h
+++ /dev/null
@@ -1,181 +0,0 @@
-#pragma once
-
-#include "colla/colla.h"
-#include <math.h>
-
-#include "libs/handmademath.h"
-
-typedef union int2 {
-    int data[2];
-    struct { int x, y; };
-} int2;
-
-typedef union int3 {
-    int data[3];
-    struct { int x, y, z; };
-} int3;
-
-typedef union float2 {
-    HMM_Vec2 hm;
-    float data[2];
-    struct { float x, y; };
-} vec2;
-
-typedef union float3 {
-    HMM_Vec3 hm;
-    float data[3];
-    struct { float x, y, z; };
-} vec3;
-
-typedef union float4 {
-    HMM_Vec4 hm;
-    float data[4];
-    struct { float x, y, z, w; };
-    struct { float r, g, b, a; };
-} vec4;
-
-typedef union mat4 {
-    HMM_Mat4 hm;
-    float data[16];
-    struct {
-        float m00, m01, m02, m03;
-        float m10, m11, m12, m13;
-        float m20, m21, m22, m23;
-        float m30, m31, m32, m33;
-    };
-} mat4;
-
-#define clamp(val, vmin, vmax) \
-    _Generic((val),            \
-        float:  fclamp,        \
-        float2: f2clamp,       \
-        float3: f3clamp,       \
-        float4: f4clamp        \
-    )(val, vmin, vmax)
-
-#define saturate(val)       \
-    _Generic((val),         \
-        float:   fsaturate, \
-        float2: f2saturate, \
-        float3: f3saturate, \
-        float4: f4saturate \
-    )(val)
-        
-#define add(a, b) \
-    _Generic((a), \
-        float2: f2add, \
-        float3: f3add, \
-        float4: f4add \
-    )(a, b)
-
-#define adds(v, s) \
-    _Generic((v), \
-        float2: f2adds, \
-        float3: f3adds, \
-        float4: f4adds \
-    )(v, s)
-
-#define cross HMM_Cross
-#define norm HMM_Norm
-#define mul HMM_Mul
-#define add HMM_Add
-#define m4_lookat HMM_LookAt_LH
-#define v3 HMM_V3
-#define m4_proj HMM_Perspective_LH_ZO
-
-#if 0
-force_inline float fclamp(float val, float vmin, float vmax) {
-    return MIN(MAX(val, vmin), vmax);
-}
-
-force_inline float2 f2clamp(float2 val, float2 vmin, float2 vmax) {
-    return (float2) {
-        fclamp(val.x, vmin.x, vmax.x),
-        fclamp(val.y, vmin.y, vmax.y),
-    };
-}
-
-force_inline float3 f3clamp(float3 val, float3 vmin, float3 vmax) {
-    return (float3) {
-        fclamp(val.x, vmin.x, vmax.x),
-        fclamp(val.y, vmin.y, vmax.y),
-        fclamp(val.z, vmin.z, vmax.z),
-    };
-}
-
-force_inline float4 f4clamp(float4 val, float4 vmin, float4 vmax) {
-    return (float4) {
-        fclamp(val.x, vmin.x, vmax.x),
-        fclamp(val.y, vmin.y, vmax.y),
-        fclamp(val.z, vmin.z, vmax.z),
-        fclamp(val.w, vmin.w, vmax.w),
-    };
-}
-
-force_inline float2 f2add(float2 a, float2 b) {
-    return (float2) { a.x + b.x, a.y + b.y };
-}
-
-force_inline float3 f3add(float3 a, float3 b) {
-    return (float3) { a.x + b.x, a.y + b.y, a.z + b.z };
-}
-
-force_inline float4 f4add(float4 a, float4 b) {
-    return (float4) { a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w };
-}
-
-force_inline float2 f2adds(float2 v, float s) {
-    return (float2) { v.x + s, v.y + s };
-}
-
-force_inline float3 f3adds(float3 v, float s) {
-    return (float3) { v.x + s, v.y + s, v.z + s };
-}
-
-force_inline float4 f4adds(float4 v, float s) {
-    return (float4) { v.x + s, v.y + s, v.z + s, v.w + s };
-}
-
-force_inline float fsaturate(float v) {
-    return fclamp(v, 0, 1);
-}
-
-force_inline float2 f2saturate(float2 v) {
-    return f2clamp(v, (float2){0}, (float2){1,1});
-}
-
-force_inline float3 f3saturate(float3 v) {
-    return f3clamp(v, (float3){0}, (float3){1,1,1});
-}
-
-force_inline float4 f4saturate(float4 v) {
-    return f4clamp(v, (float4){0}, (float4){1,1,1,1});
-}
-
-force_inline float f3mag2(float3 v) {
-    return v.x * v.x + v.y * v.y + v.z * v.z;
-}
-
-force_inline float f3mag(float3 v) {
-    return sqrtf(f3mag2(v));
-}
-
-force_inline float3 f3muls(float3 v, float s) {
-    return (float3) {
-        .x = v.x * s,
-        .y = v.y * s,
-        .z = v.z * s,
-    };
-}
-
-force_inline float3 f3divs(float3 v, float s) {
-    s = 1.f / s;
-    return f3muls(v, s);
-}
-
-force_inline float3 f3norm(float3 v) {
-    float mag = f3mag(v);
-    if (mag == 0) return v;
-    return f3divs(v, mag);
-}
-#endif