slight renderer refactor. grid shader.

src/draw.c

@@ -28,8 +28,14 @@ struct draw_startup_receipt draw_startup(struct renderer_startup_receipt *render
  * Texture
  * ========================== */
 
-INTERNAL void draw_sprite_quad_internal(struct renderer_canvas *canvas, struct clip_rect clip, u32 tint0, u32 tint1, struct quad quad)
+void draw_quad_sprite_ex(struct renderer_canvas *canvas, struct renderer_handle texture, struct sprite_tag sprite, struct clip_rect clip, u32 tint0, u32 tint1, struct quad quad)
 {
+    struct renderer_cmd_parameters cmd_params = ZI;
+    cmd_params.kind = SHADER_TEXTURE;
+    cmd_params.texture_params.texture = texture;
+    cmd_params.texture_params.sprite = sprite;
+    renderer_canvas_ensure_cmd(canvas, &cmd_params);
+
     struct texture_shader_vertex *vertices = NULL;
     vidx *indices = NULL;
     u32 offset = renderer_canvas_push_vertices(canvas, (u8 **)&vertices, &indices, 4, 6);
@@ -70,25 +76,26 @@ INTERNAL void draw_sprite_quad_internal(struct renderer_canvas *canvas, struct c
     indices[5] = offset + 3;
 }
 
-void draw_sprite_quad(struct renderer_canvas *canvas, struct draw_sprite_params params, struct quad quad)
+void draw_quad_sprite(struct renderer_canvas *canvas, struct draw_sprite_params params, struct quad quad)
 {
-    renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .sprite = params.sprite });
-
-    draw_sprite_quad_internal(canvas, params.clip, params.tint, params.tint, quad);
-}
-
-void draw_sprite_rect(struct renderer_canvas *canvas, struct draw_sprite_params params, struct rect rect)
-{
-    struct quad quad = quad_from_rect(rect);
-    draw_sprite_quad(canvas, params, quad);
+    draw_quad_sprite_ex(canvas, renderer_handle_nil(), params.sprite, params.clip, params.tint, params.tint, quad);
 }
 
 /* ========================== *
  * Solid fill shapes
  * ========================== */
 
-INTERNAL void draw_solid_poly_internal(struct renderer_canvas *canvas, struct v2_array array, u32 color)
+void draw_poly(struct renderer_canvas *canvas, struct v2_array array, u32 color)
 {
+    if (array.count < 3) {
+        return;
+    }
+
+    struct renderer_cmd_parameters cmd_params = ZI;
+    cmd_params.kind = SHADER_TEXTURE;
+    cmd_params.texture_params.texture = G.solid_white;
+    renderer_canvas_ensure_cmd(canvas, &cmd_params);
+
     u32 num_tris = array.count - 2;
     u32 num_indices = num_tris * 3;
 
@@ -113,17 +120,7 @@ INTERNAL void draw_solid_poly_internal(struct renderer_canvas *canvas, struct v2
     }
 }
 
-void draw_solid_poly(struct renderer_canvas *canvas, struct v2_array array, u32 color)
-{
-    if (array.count < 3) {
-        return;
-    }
-
-    renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_handle = G.solid_white });
-    draw_solid_poly_internal(canvas, array, color);
-}
-
-void draw_solid_circle(struct renderer_canvas *canvas, struct v2 pos, f32 radius, u32 color, u32 detail)
+void draw_circle(struct renderer_canvas *canvas, struct v2 pos, f32 radius, u32 color, u32 detail)
 {
     struct temp_arena scratch = scratch_begin_no_conflict();
 
@@ -140,71 +137,59 @@ void draw_solid_circle(struct renderer_canvas *canvas, struct v2 pos, f32 radius
         .points = points,
         .count = detail
     };
-    draw_solid_poly(canvas, a, color);
+    draw_poly(canvas, a, color);
 
     scratch_end(scratch);
 }
 
-void draw_solid_quad(struct renderer_canvas *canvas, struct quad quad, u32 color)
+void draw_quad(struct renderer_canvas *canvas, struct quad quad, u32 color)
 {
-    renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_handle = G.solid_white });
-    draw_sprite_quad_internal(canvas, CLIP_ALL, color, color, quad);
-}
-
-void draw_solid_rect(struct renderer_canvas *canvas, struct rect rect, u32 color)
-{
-    renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_handle = G.solid_white });
-    struct quad quad = quad_from_rect(rect);
-    draw_sprite_quad_internal(canvas, CLIP_ALL, color, color, quad);
+    draw_quad_sprite_ex(canvas, G.solid_white, sprite_tag_nil(), CLIP_ALL, color, color, quad);
 }
 
 /* ========================== *
  * Solid line shapes
  * ========================== */
 
-void draw_solid_line(struct renderer_canvas *canvas, struct v2 start, struct v2 end, f32 thickness, u32 color)
-{
-    renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_handle = G.solid_white });
-    struct quad quad = quad_from_line(start, end, thickness);
-    draw_sprite_quad_internal(canvas, CLIP_ALL, color, color, quad);
-}
-
 void draw_gradient_line(struct renderer_canvas *canvas, struct v2 start, struct v2 end, f32 thickness, u32 color_start, u32 color_end)
 {
-    renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_handle = G.solid_white });
     struct quad quad = quad_from_line(start, end, thickness);
-    draw_sprite_quad_internal(canvas, CLIP_ALL, color_start, color_end, quad);
+    draw_quad_sprite_ex(canvas, G.solid_white, sprite_tag_nil(), CLIP_ALL, color_start, color_end, quad);
 }
 
-void draw_solid_ray(struct renderer_canvas *canvas, struct v2 pos, struct v2 rel, f32 thickness, u32 color)
+void draw_line(struct renderer_canvas *canvas, struct v2 start, struct v2 end, f32 thickness, u32 color)
 {
-    renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_handle = G.solid_white });
-    struct quad quad = quad_from_ray(pos, rel, thickness);
-    draw_sprite_quad_internal(canvas, CLIP_ALL, color, color, quad);
+    struct quad quad = quad_from_line(start, end, thickness);
+    draw_quad(canvas, quad, color);
 }
 
-void draw_solid_poly_line(struct renderer_canvas *canvas, struct v2_array array, b32 loop, f32 thickness, u32 color)
+void draw_ray(struct renderer_canvas *canvas, struct v2 pos, struct v2 rel, f32 thickness, u32 color)
+{
+    struct quad quad = quad_from_ray(pos, rel, thickness);
+    draw_quad(canvas, quad, color);
+}
+
+void draw_poly_line(struct renderer_canvas *canvas, struct v2_array array, b32 loop, f32 thickness, u32 color)
 {
     if (array.count < 2) {
         return;
     }
 
-    renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_handle = G.solid_white });
     for (u64 i = 1; i < array.count; ++i) {
         struct v2 p1 = array.points[i - 1];
         struct v2 p2 = array.points[i];
         struct quad q = quad_from_line(p1, p2, thickness);
-        draw_sprite_quad_internal(canvas, CLIP_ALL, color, color, q);
+        draw_quad(canvas, q, color);
     }
     if (loop && array.count > 2) {
         struct v2 p1 = array.points[array.count - 1];
         struct v2 p2 = array.points[0];
         struct quad q = quad_from_line(p1, p2, thickness);
-        draw_sprite_quad_internal(canvas, CLIP_ALL, color, color, q);
+        draw_quad(canvas, q, color);
     }
 }
 
-void draw_solid_circle_line(struct renderer_canvas *canvas, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail)
+void draw_circle_line(struct renderer_canvas *canvas, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail)
 {
     struct temp_arena scratch = scratch_begin_no_conflict();
 
@@ -221,28 +206,20 @@ void draw_solid_circle_line(struct renderer_canvas *canvas, struct v2 pos, f32 r
         .points = points,
         .count = detail
     };
-    draw_solid_poly_line(canvas, a, true, thickness, color);
+    draw_poly_line(canvas, a, true, thickness, color);
 
     scratch_end(scratch);
 }
 
-void draw_solid_quad_line(struct renderer_canvas *canvas, struct quad quad, f32 thickness, u32 color)
+void draw_quad_line(struct renderer_canvas *canvas, struct quad quad, f32 thickness, u32 color)
 {
     struct v2 points[] = { quad.p1, quad.p2, quad.p3, quad.p4 };
     struct v2_array a = { .points = points, .count = ARRAY_COUNT(points) };
-    draw_solid_poly_line(canvas, a, true, thickness, color);
+    draw_poly_line(canvas, a, true, thickness, color);
 }
 
-void draw_solid_rect_line(struct renderer_canvas *canvas, struct rect rect, f32 thickness, u32 color)
+void draw_arrow_line(struct renderer_canvas *canvas, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 color)
 {
-    struct quad q = quad_from_rect(rect);
-    draw_solid_quad_line(canvas, q, thickness, color);
-}
-
-void draw_solid_arrow_line(struct renderer_canvas *canvas, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 color)
-{
-    renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_handle = G.solid_white });
-
     const f32 head_width_ratio = 0.5f;  /* Width of arrowhead relative to its length */
 
     const f32 max_height_to_line_ratio = 0.9f;  /* Maximum length of arrowhead relative to total line length */
@@ -265,19 +242,19 @@ void draw_solid_arrow_line(struct renderer_canvas *canvas, struct v2 start, stru
         .points = head_points,
         .count = ARRAY_COUNT(head_points)
     };
-    draw_solid_poly_internal(canvas, head_points_v2_array, color);
+    draw_poly(canvas, head_points_v2_array, color);
 
     struct quad line_quad = quad_from_line(start, head_start, thickness);
-    draw_sprite_quad_internal(canvas, CLIP_ALL, color, color, line_quad);
+    draw_quad(canvas, line_quad, color);
 }
 
-void draw_solid_arrow_ray(struct renderer_canvas *canvas, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 color)
+void draw_arrow_ray(struct renderer_canvas *canvas, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 color)
 {
     struct v2 end = v2_add(pos, rel);
-    draw_solid_arrow_line(canvas, pos, end, thickness, arrowhead_height, color);
+    draw_arrow_line(canvas, pos, end, thickness, arrowhead_height, color);
 }
 
-void draw_solid_collider_line(struct renderer_canvas *canvas, struct xform draw_xf, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 color, u32 detail)
+void draw_collider_line(struct renderer_canvas *canvas, struct xform draw_xf, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 color, u32 detail)
 {
     struct temp_arena scratch = scratch_begin_no_conflict();
 
@@ -292,31 +269,69 @@ void draw_solid_collider_line(struct renderer_canvas *canvas, struct xform draw_
 
 #if 1
     struct v2_array poly = { .points = points, .count = detail };
-    draw_solid_poly_line(canvas, poly, true, thickness, color);
+    draw_poly_line(canvas, poly, true, thickness, color);
 #else
     for (u64 i = 0; i < detail; ++i) {
         struct v2 point = points[i];
         (UNUSED)thickness;
-        draw_solid_circle(canvas, point, 3, color, 10);
+        draw_circle(canvas, point, 3, color, 10);
     }
 #endif
 
     scratch_end(scratch);
 }
 
+/* ========================== *
+ * Grid
+ * ========================== */
+
+void draw_grid(struct renderer_canvas *canvas, struct rect rect, u32 color, f32 thickness, f32 spacing, struct v2 offset)
+{
+    struct renderer_cmd_parameters cmd_params = ZI;
+    cmd_params.kind = SHADER_GRID;
+    renderer_canvas_ensure_cmd(canvas, &cmd_params);
+
+    struct grid_shader_vertex *vertices = NULL;
+    vidx *indices = NULL;
+    u32 index_offset = renderer_canvas_push_vertices(canvas, (u8 **)&vertices, &indices, 4, 6);
+
+    struct quad quad = quad_from_rect(rect);
+
+    struct grid_shader_vertex attributes = ZI;
+    attributes.color = color;
+    attributes.line_thickness = thickness;
+    attributes.line_spacing = spacing;
+    attributes.offset = offset;
+
+    /* Top left */
+    vertices[0] = attributes;
+    vertices[0].pos = quad.p1;
+    /* Top right */
+    vertices[1] = attributes;
+    vertices[1].pos = quad.p2;
+    /* Bottom right */
+    vertices[2] = attributes;
+    vertices[2].pos = quad.p3;
+    /* Bottom left */
+    vertices[3] = attributes;
+    vertices[3].pos = quad.p4;
+
+    /* Top / right triangle */
+    indices[0] = index_offset + 0;
+    indices[1] = index_offset + 1;
+    indices[2] = index_offset + 2;
+    /* Bottom / left triangle */
+    indices[3] = index_offset + 0;
+    indices[4] = index_offset + 2;
+    indices[5] = index_offset + 3;
+}
+
 /* ========================== *
  * Text
  * ========================== */
 
-void draw_text(struct renderer_canvas *canvas, struct font *font, struct v2 pos, struct string str)
-{
-    draw_text_ex(canvas, font, pos, 1.0, str);
-}
-
 void draw_text_ex(struct renderer_canvas *canvas, struct font *font, struct v2 pos, f32 scale, struct string str)
 {
-    renderer_canvas_ensure_texture_cmd(canvas, (struct texture_shader_parameters) { .texture_handle = font->image_renderer_handle });
-
     struct v2 draw_pos = pos;
     draw_pos.y += font->point_size * scale;
 
@@ -350,9 +365,14 @@ void draw_text_ex(struct renderer_canvas *canvas, struct font *font, struct v2 p
         };
 
         struct quad quad = quad_from_rect(RECT(x, y, width, height));
-        draw_sprite_quad_internal(canvas, clip, 0xFFFFFFFF, 0xFFFFFFFF, quad);
+        draw_quad_sprite_ex(canvas, font->image_renderer_handle, sprite_tag_nil(), clip, 0xFFFFFFFF, 0xFFFFFFFF, quad);
 
         draw_pos.x += glyph->advance * scale;
     }
     string_codepoint_iter_end(&iter);
 }
+
+void draw_text(struct renderer_canvas *canvas, struct font *font, struct v2 pos, struct string str)
+{
+    draw_text_ex(canvas, font, pos, 1.0, str);
+}

src/draw.h

@@ -22,24 +22,24 @@ struct draw_startup_receipt { i32 _; };
 struct draw_startup_receipt draw_startup(struct renderer_startup_receipt *renderer_sr,
                                          struct font_startup_receipt *font_sr);
 
-void draw_sprite_quad(struct renderer_canvas *canvas, struct draw_sprite_params params, struct quad quad);
-void draw_sprite_rect(struct renderer_canvas *canvas, struct draw_sprite_params params, struct rect rect);
+void draw_quad_sprite_ex(struct renderer_canvas *canvas, struct renderer_handle texture, struct sprite_tag sprite, struct clip_rect clip, u32 tint0, u32 tint1, struct quad quad);
+void draw_quad_sprite(struct renderer_canvas *canvas, struct draw_sprite_params params, struct quad quad);
 
-void draw_solid_poly(struct renderer_canvas *canvas, struct v2_array array, u32 color);
-void draw_solid_circle(struct renderer_canvas *canvas, struct v2 pos, f32 radius, u32 color, u32 detail);
-void draw_solid_quad(struct renderer_canvas *canvas, struct quad quad, u32 color);
-void draw_solid_rect(struct renderer_canvas *canvas, struct rect rect, u32 color);
+void draw_poly(struct renderer_canvas *canvas, struct v2_array array, u32 color);
+void draw_circle(struct renderer_canvas *canvas, struct v2 pos, f32 radius, u32 color, u32 detail);
+void draw_quad(struct renderer_canvas *canvas, struct quad quad, u32 color);
 
-void draw_solid_line(struct renderer_canvas *canvas, struct v2 start, struct v2 end, f32 thickness, u32 color);
 void draw_gradient_line(struct renderer_canvas *canvas, struct v2 start, struct v2 end, f32 thickness, u32 color_start, u32 color_end);
-void draw_solid_ray(struct renderer_canvas *canvas, struct v2 start, struct v2 ray, f32 thickness, u32 color);
-void draw_solid_poly_line(struct renderer_canvas *canvas, struct v2_array array, b32 loop, f32 thickness, u32 color);
-void draw_solid_circle_line(struct renderer_canvas *canvas, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail);
-void draw_solid_quad_line(struct renderer_canvas *canvas, struct quad quad, f32 thickness, u32 color);
-void draw_solid_rect_line(struct renderer_canvas *canvas, struct rect rect, f32 thickness, u32 color);
-void draw_solid_arrow_line(struct renderer_canvas *canvas, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 color);
-void draw_solid_arrow_ray(struct renderer_canvas *canvas, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 color);
-void draw_solid_collider_line(struct renderer_canvas *canvas, struct xform draw_xf, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 color, u32 detail);
+void draw_line(struct renderer_canvas *canvas, struct v2 start, struct v2 end, f32 thickness, u32 color);
+void draw_ray(struct renderer_canvas *canvas, struct v2 start, struct v2 ray, f32 thickness, u32 color);
+void draw_poly_line(struct renderer_canvas *canvas, struct v2_array array, b32 loop, f32 thickness, u32 color);
+void draw_circle_line(struct renderer_canvas *canvas, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail);
+void draw_quad_line(struct renderer_canvas *canvas, struct quad quad, f32 thickness, u32 color);
+void draw_arrow_line(struct renderer_canvas *canvas, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 color);
+void draw_arrow_ray(struct renderer_canvas *canvas, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 color);
+void draw_collider_line(struct renderer_canvas *canvas, struct xform draw_xf, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 color, u32 detail);
+
+void draw_grid(struct renderer_canvas *canvas, struct rect rect, u32 color, f32 thickness, f32 spacing, struct v2 offset);
 
 void draw_text(struct renderer_canvas *canvas, struct font *font, struct v2 pos, struct string str);
 void draw_text_ex(struct renderer_canvas *canvas, struct font *font, struct v2 pos, f32 scale, struct string str);

src/entity.c

@@ -392,8 +392,8 @@ void entity_unlink_from_parent(struct entity *ent)
     } else {
         parent->last = prev->handle;
     }
-    ent->prev = entity_nil_handle();
-    ent->next = entity_nil_handle();
+    ent->prev = entity_handle_nil();
+    ent->next = entity_handle_nil();
 }
 
 /* ========================== *

src/entity.h

@@ -304,7 +304,7 @@ struct entity_prop_array {
  * Handle helpers
  * ========================== */
 
-INLINE struct entity_handle entity_nil_handle(void)
+INLINE struct entity_handle entity_handle_nil(void)
 {
     return (struct entity_handle) { 0 };
 }

src/phys.c

@@ -826,7 +826,7 @@ void phys_create_mouse_joints(struct phys_ctx *ctx)
         joint->max_force = G.mouse_joint_max_force * mass;
     } else {
         if (entity_is_valid_and_active(joint_ent)) {
-            joint_ent->mouse_joint_data.target = entity_nil_handle();
+            joint_ent->mouse_joint_data.target = entity_handle_nil();
         }
     }
 }

src/renderer.h

@@ -18,13 +18,19 @@ struct renderer_canvas;
 enum shader_kind {
     SHADER_NONE,
     SHADER_TEXTURE,
+    SHADER_GRID,
 
     NUM_SHADERS
 };
 
-struct texture_shader_parameters {
-    struct renderer_handle texture_handle;  /* Overrides sprite */
+struct renderer_cmd_parameters {
+    enum shader_kind kind;
+    union {
+        struct {
+            struct renderer_handle texture;  /* Overrides sprite if set */
             struct sprite_tag sprite;
+        } texture_params;
+    };
 };
 
 PACK(struct texture_shader_vertex {
@@ -33,6 +39,13 @@ PACK(struct texture_shader_vertex {
     u32 color;
 });
 
+PACK(struct grid_shader_vertex {
+    struct v2 pos;
+    u32 color;
+    f32 line_thickness;
+    f32 line_spacing;
+    struct v2 offset;
+});
 
 /* ========================== *
  * Startup
@@ -64,9 +77,9 @@ void renderer_canvas_set_view(struct renderer_canvas *canvas, struct xform view)
 u32 renderer_canvas_push_vertices(struct renderer_canvas *canvas, u8 **vertices_out, vidx **indices_out, u32 vertices_count, u32 indices_count);
 
 /* Checks the currently active draw command. Ensures a new command is created
- * if it doesn't match the expected type (otherwise the command can be re-used
- * for batching). */
-void renderer_canvas_ensure_texture_cmd(struct renderer_canvas *canvas, struct texture_shader_parameters params);
+ * if it doesn't match the expected parameters (otherwise the existing command
+ * can be re-used for batching). */
+void renderer_canvas_ensure_cmd(struct renderer_canvas *canvas, struct renderer_cmd_parameters *params);
 
 void renderer_canvas_send_to_gpu(struct renderer_canvas *canvas);
 
@@ -76,6 +89,8 @@ void renderer_canvas_present(struct renderer_canvas **canvases, u32 canvases_cou
  * Texture
  * ========================== */
 
+INLINE struct renderer_handle renderer_handle_nil(void) { return (struct renderer_handle) { 0 }; }
+
 struct renderer_handle renderer_texture_alloc(struct image_rgba data);
 void renderer_texture_release(struct renderer_handle handle);
 b32 renderer_texture_is_nil(struct renderer_handle handle);

src/renderer_d3d11.c

@@ -113,7 +113,7 @@ struct handle_store {
 struct dx11_shader_desc {
     char *name_cstr;
     u32 vertex_size;
-    D3D11_INPUT_ELEMENT_DESC input_layout_desc[8];  /* NULL terminated array */
+    D3D11_INPUT_ELEMENT_DESC input_layout_desc[64];  /* NULL terminated array */
 };
 
 GLOBAL struct {
@@ -308,13 +308,28 @@ INTERNAL void process_shader_compilation_error(ID3DBlob *error_blob)
 INTERNAL void init_shader_table(void)
 {
     MEMZERO_ARRAY(G.shader_info);
+
+    /* Texture shader layout */
     G.shader_info[SHADER_TEXTURE] = (struct dx11_shader_desc) {
         "shaders/texture.hlsl",
         sizeof(struct texture_shader_vertex),
         {
-            { "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT,   0, FIELD_OFFSETOF(struct texture_shader_vertex, pos),   D3D11_INPUT_PER_VERTEX_DATA, 0 },
-            { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT,   0, FIELD_OFFSETOF(struct texture_shader_vertex, uv),    D3D11_INPUT_PER_VERTEX_DATA, 0 },
-            { "COLOR",    0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, FIELD_OFFSETOF(struct texture_shader_vertex, color), D3D11_INPUT_PER_VERTEX_DATA, 0 }
+            { "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT,   0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+            { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT,   0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+            { "COLOR",    0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
+        }
+    };
+
+    /* Grid shader layout */
+    G.shader_info[SHADER_GRID] = (struct dx11_shader_desc) {
+        "shaders/grid.hlsl",
+        sizeof(struct grid_shader_vertex),
+        {
+            { "POSITION",       0, DXGI_FORMAT_R32G32_FLOAT,    0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+            { "COLOR",         0, DXGI_FORMAT_R8G8B8A8_UNORM,  0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+            { "THICKNESS",      0, DXGI_FORMAT_R32_FLOAT,       0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+            { "SPACING",        0, DXGI_FORMAT_R32_FLOAT,       0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+            { "OFFSET",         0, DXGI_FORMAT_R32G32_FLOAT,    0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
         }
     };
 }
@@ -603,7 +618,7 @@ struct renderer_startup_receipt renderer_startup(struct sys_window *window)
     }
 
     /* Init shaders */
-    for (u32 i = 1; i < NUM_SHADERS; ++i) {
+    for (u32 i = SHADER_NONE + 1; i < NUM_SHADERS; ++i) {
         /* Create shader */
         shader_init(&G.shaders[i], i);
     }
@@ -636,8 +651,8 @@ struct renderer_canvas *renderer_canvas_alloc(void)
     canvas->view = xform_from_trs(TRS());
     canvas->valid = true;
 
-    /* Initialize buffers, skipping index 0 (SHADER_NONE) */
-    for (u32 i = 1; i < ARRAY_COUNT(canvas->buffers); ++i) {
+    /* Initialize buffers */
+    for (u32 i = SHADER_NONE + 1; i < ARRAY_COUNT(canvas->buffers); ++i) {
         struct dx11_buffer *buffer = &canvas->buffers[i];
         buffer->vertex_arena = arena_alloc(GIGABYTE(8));
         buffer->index_arena = arena_alloc(GIGABYTE(8));
@@ -654,8 +669,8 @@ void renderer_canvas_release(struct renderer_canvas *canvas)
     arena_release(&canvas->cpu_cmd_store.arena);
     arena_release(&canvas->gpu_cmd_store.arena);
 
-    /* Destroy buffers, skipping index 0 (SHADER_NONE) */
-    for (u32 i = 1; i < ARRAY_COUNT(canvas->buffers); ++i) {
+    /* Destroy buffers */
+    for (u32 i = SHADER_NONE + 1; i < ARRAY_COUNT(canvas->buffers); ++i) {
         struct dx11_buffer *buffer = &canvas->buffers[i];
         arena_release(&buffer->vertex_arena);
         arena_release(&buffer->index_arena);
@@ -700,27 +715,51 @@ u32 renderer_canvas_push_vertices(struct renderer_canvas *canvas, u8 **vertices_
     return first_vertex_index;
 }
 
-void renderer_canvas_ensure_texture_cmd(struct renderer_canvas *canvas, struct texture_shader_parameters params)
+void renderer_canvas_ensure_cmd(struct renderer_canvas *canvas, struct renderer_cmd_parameters *params)
 {
     struct renderer_cmd *last_cmd = canvas->cpu_cmd_store.cmd_last;
-    if (!last_cmd || last_cmd->shader->kind != SHADER_TEXTURE ||
-        !handle_eq(last_cmd->texture_handle, params.texture_handle) ||
-        !sprite_tag_eq(last_cmd->sprite, params.sprite)) {
-        /* Command parameters are not the same, insert new command */
-        struct renderer_cmd *cmd = arena_push(&canvas->cpu_cmd_store.arena, struct renderer_cmd);
-        *cmd = (struct renderer_cmd){
-            .shader = &G.shaders[SHADER_TEXTURE],
-            .texture_handle = params.texture_handle,
-            .sprite = params.sprite
-        };
 
-        if (!canvas->cpu_cmd_store.cmd_first) {
-            canvas->cpu_cmd_store.cmd_first = cmd;
-        } else {
-            last_cmd->next = cmd;
+    struct renderer_cmd *new_cmd = NULL;
+    switch (params->kind) {
+        default:
+        {
+            /* Unknown shader kind */
+            ASSERT(false);
+        } break;
+
+        case SHADER_TEXTURE:
+        {
+            if (!last_cmd
+                || last_cmd->shader->kind != SHADER_TEXTURE
+                || !handle_eq(last_cmd->texture_handle, params->texture_params.texture)
+                || !sprite_tag_eq(last_cmd->sprite, params->texture_params.sprite)) {
+                new_cmd = arena_push(&canvas->cpu_cmd_store.arena, struct renderer_cmd);
+                *new_cmd = (struct renderer_cmd) {
+                    .shader = &G.shaders[SHADER_TEXTURE],
+                    .texture_handle = params->texture_params.texture,
+                    .sprite = params->texture_params.sprite
+                };
+            }
+        } break;
+
+        case SHADER_GRID:
+        {
+            if (!last_cmd || last_cmd->shader->kind != SHADER_GRID) {
+                new_cmd = arena_push(&canvas->cpu_cmd_store.arena, struct renderer_cmd);
+                *new_cmd = (struct renderer_cmd) {
+                    .shader = &G.shaders[SHADER_GRID],
+                };
+            }
+        } break;
     }
 
-        canvas->cpu_cmd_store.cmd_last = cmd;
+    if (new_cmd) {
+        if (!canvas->cpu_cmd_store.cmd_first) {
+            canvas->cpu_cmd_store.cmd_first = new_cmd;
+        } else {
+            last_cmd->next = new_cmd;
+        }
+        canvas->cpu_cmd_store.cmd_last = new_cmd;
     }
 }
 
@@ -877,18 +916,6 @@ void renderer_canvas_present(struct renderer_canvas **canvases, u32 canvases_cou
             struct dx11_shader *shader = cmd->shader;
             struct dx11_buffer *buffer = &canvas->buffers[shader->kind];
 
-            b32 texture_loaded;
-            struct renderer_handle texture_handle;
-            if (handle_is_nil(cmd->texture_handle)) {
-                struct sprite_texture *sprite_texture = sprite_texture_from_tag_async(sprite_scope, cmd->sprite);
-                texture_loaded = sprite_texture->loaded;
-                texture_handle = sprite_texture->renderer_handle;
-            } else {
-                texture_loaded = true;
-                texture_handle = cmd->texture_handle;
-            }
-
-            if (texture_loaded) {
             /* Activate shader */
             if (shader != last_shader) {
                 ID3D11DeviceContext_VSSetShader(G.devcon, shader->vs, 0, 0);
@@ -897,6 +924,29 @@ void renderer_canvas_present(struct renderer_canvas **canvases, u32 canvases_cou
                 last_shader = shader;
             }
 
+            switch (shader->kind) {
+                default:
+                {
+                    /* Unknown shader */
+                    ASSERT(false);
+                } break;
+
+                case SHADER_TEXTURE:
+                {
+                    b32 texture_loaded;
+                    struct renderer_handle texture_handle;
+                    if (!handle_is_nil(cmd->texture_handle)) {
+                        /* Load texture if handle is set */
+                        texture_loaded = true;
+                        texture_handle = cmd->texture_handle;
+                    } else {
+                        /* Otherwise load sprite */
+                        struct sprite_texture *sprite_texture = sprite_texture_from_tag_async(sprite_scope, cmd->sprite);
+                        texture_loaded = sprite_texture->loaded;
+                        texture_handle = sprite_texture->renderer_handle;
+                    }
+
+                    if (texture_loaded) {
                         /* FIXME: what if texture_srv is 0? will this unset it correctly? */
                         /* Activate texture */
                         if (!handle_eq(texture_handle, last_texture_handle)) {
@@ -905,10 +955,6 @@ void renderer_canvas_present(struct renderer_canvas **canvases, u32 canvases_cou
                             last_texture_handle = texture_handle;
                         }
 
-                u32 vertex_offset = cmd->vertex_offset;
-                u32 index_offset = cmd->index_offset;
-                u32 index_count = cmd->index_count;
-
                         /* Activate buffer */
                         u32 zero = 0;
                         UINT vertex_stride = shader->vertex_size;
@@ -916,8 +962,28 @@ void renderer_canvas_present(struct renderer_canvas **canvases, u32 canvases_cou
                         ID3D11DeviceContext_IASetIndexBuffer(G.devcon, buffer->gpu_index_buffer, DXGI_FORMAT_R32_UINT, zero);
 
                         /* Draw */
+                        u32 vertex_offset = cmd->vertex_offset;
+                        u32 index_offset = cmd->index_offset;
+                        u32 index_count = cmd->index_count;
                         ID3D11DeviceContext_DrawIndexed(G.devcon, index_count, index_offset, vertex_offset);
                     }
+                } break;
+
+                case SHADER_GRID:
+                {
+                    /* Activate buffer */
+                    u32 zero = 0;
+                    UINT vertex_stride = shader->vertex_size;
+                    ID3D11DeviceContext_IASetVertexBuffers(G.devcon, 0, 1, &buffer->gpu_vertex_buffer, &vertex_stride, &zero);
+                    ID3D11DeviceContext_IASetIndexBuffer(G.devcon, buffer->gpu_index_buffer, DXGI_FORMAT_R32_UINT, zero);
+
+                    /* Draw */
+                    u32 vertex_offset = cmd->vertex_offset;
+                    u32 index_offset = cmd->index_offset;
+                    u32 index_count = cmd->index_count;
+                    ID3D11DeviceContext_DrawIndexed(G.devcon, index_count, index_offset, vertex_offset);
+                } break;
+            }
         }
     }
 

src/shaders/grid.hlsl

@@ -0,0 +1,50 @@
+struct vs_input {
+    float4 pos              : POSITION;
+    float4 col              : COLOR;
+    float line_thickness    : THICKNESS;
+    float line_spacing      : SPACING;
+    float2 offset           : OFFSET;
+};
+
+struct ps_input {
+    float4 screen_pos       : SV_POSITION;
+    float4 col              : COLOR;
+    float line_thickness    : THICKNESS;
+    float line_spacing      : SPACING;
+    float2 offset           : OFFSET;
+};
+
+cbuffer vs_constants : register(b0)
+{
+    float4x4 projection;
+};
+
+ps_input vs_main(vs_input input)
+{
+    ps_input output;
+
+    output.screen_pos = mul(projection, float4(input.pos.xy, 0.f, 1.f));
+    output.col = input.col;
+    output.line_thickness = input.line_thickness;
+    output.line_spacing = input.line_spacing;
+    output.offset = input.offset;
+
+    return output;
+}
+
+float4 ps_main(ps_input input) : SV_TARGET
+{
+    float2 screen_pos = input.screen_pos.xy;
+    float thickness = input.line_thickness;
+    float spacing = input.line_spacing;
+    float2 offset = input.offset;
+
+    float xmod = fmod(abs(screen_pos.x + offset.x), spacing);
+    float ymod = fmod(abs(screen_pos.y + offset.y), spacing);
+
+    bool should_draw = (xmod < thickness || xmod > spacing - thickness) || (ymod < thickness || ymod > spacing - thickness);
+
+    float4 color = input.col * should_draw;
+
+    return color;
+}

src/sprite.h

@@ -20,6 +20,8 @@ struct sprite_startup_receipt sprite_startup(struct renderer_startup_receipt *re
  * Tag
  * ========================== */
 
+INLINE struct sprite_tag sprite_tag_nil(void) { return (struct sprite_tag) { 0 }; }
+
 struct sprite_tag sprite_tag_from_path(struct string path);
 b32 sprite_tag_is_nil(struct sprite_tag tag);
 b32 sprite_tag_eq(struct sprite_tag t1, struct sprite_tag t2);

src/sys_win32.c

@@ -1872,7 +1872,6 @@ void sys_exit(void)
 
 void sys_panic(struct string msg)
 {
-    ASSERT(false);
     if (atomic_i32_eval_compare_exchange(&G.panicking, 0, 1) == 0) {
         log_panic(msg);
 

src/user.c

@@ -404,13 +404,13 @@ INTERNAL void debug_draw_xform(struct xform xf, u32 color_x, u32 color_y)
     x_ray = v2_mul(x_ray, ray_scale);
     y_ray = v2_mul(y_ray, ray_scale);
 
-    draw_solid_arrow_ray(G.viewport_canvas, pos, x_ray, thickness, arrowhead_len, color_x);
-    draw_solid_arrow_ray(G.viewport_canvas, pos, y_ray, thickness, arrowhead_len, color_y);
+    draw_arrow_ray(G.viewport_canvas, pos, x_ray, thickness, arrowhead_len, color_x);
+    draw_arrow_ray(G.viewport_canvas, pos, y_ray, thickness, arrowhead_len, color_y);
 
     //u32 color_quad   = RGBA_32_F(0, 1, 1, 0.3);
     //struct quad quad = quad_from_rect(RECT(0, 0, 1, -1));
     //quad = xform_mul_quad(xf, quad_scale(quad, 0.075f));
-    //draw_solid_quad(G.viewport_canvas, quad, color);
+    //draw_quad(G.viewport_canvas, quad, color);
 }
 
 /* TODO: remove this (testing) */
@@ -427,7 +427,7 @@ INTERNAL void debug_draw_movement(struct entity *ent)
     struct v2 pos       = xform_mul_v2(G.world_view, xf.og);
     struct v2 vel_ray   = xform_basis_mul_v2(G.world_view, velocity);
 
-    draw_solid_arrow_ray(G.viewport_canvas, pos, vel_ray, thickness, arrow_len, color_vel);
+    draw_arrow_ray(G.viewport_canvas, pos, vel_ray, thickness, arrow_len, color_vel);
 }
 
 /* ========================== *
@@ -863,7 +863,8 @@ INTERNAL void user_update(void)
 
     {
         u32 color = RGBA_32_F(0.2f, 0.2f, 0.2f, 1.f);
-        draw_solid_rect(G.viewport_bg_canvas, RECT(0, 0, G.viewport_size.x, G.viewport_size.y), color);
+        struct quad quad = quad_from_rect(RECT(0, 0, G.viewport_size.x, G.viewport_size.y));
+        draw_quad(G.viewport_bg_canvas, quad, color);
     }
 
     /* ========================== *
@@ -871,37 +872,13 @@ INTERNAL void user_update(void)
      * ========================== */
 
     {
-        f32 thickness = 3.f;
+        f32 thickness = 1;
         u32 color = RGBA_32(0x3f, 0x3f, 0x3f, 0xFF);
-        u32 x_color = RGBA_32(0x3f, 0, 0, 0xFF);
-        u32 y_color = RGBA_32(0, 0x3f, 0, 0xFF);
 
-        i64 rows = 500;
-        i64 cols = 500;
-        i64 startx = -(rows / 2);
-        i64 starty = -(cols / 2);
+        struct v2 offset = v2_neg(G.world_view.og);
+        f32 spacing = xform_get_scale(G.world_view).x;
 
-        /* Draw column lines */
-        struct v2 col_ray = xform_basis_mul_v2(G.world_view, V2(0, rows));
-        for (i64 col = starty; col <= (starty + cols); ++col) {
-            u32 line_color = color;
-            if (col == 0) {
-                line_color = y_color;
-            }
-
-            struct v2 pos = xform_mul_v2(G.world_view, V2(col, starty));
-            draw_solid_ray(G.viewport_bg_canvas, pos, col_ray, thickness, line_color);
-        }
-
-        struct v2 row_ray = xform_basis_mul_v2(G.world_view, V2(cols, 0));
-        for (i64 row = startx; row <= (startx + rows); ++row) {
-            u32 line_color = color;
-            if (row == 0) {
-                line_color = x_color;
-            }
-            struct v2 pos = xform_mul_v2(G.world_view, V2(startx, row));
-            draw_solid_ray(G.viewport_bg_canvas, pos, row_ray, thickness, line_color);
-        }
+        draw_grid(G.viewport_bg_canvas, RECT(0, 0, G.viewport_size.x, G.viewport_size.y), color, thickness, spacing, offset);
     }
 
     /* ---------------------------------------------------------------------- */
@@ -986,7 +963,7 @@ INTERNAL void user_update(void)
                 u32 color_end = RGBA_32_F(1, 0.8, 0.4, opacity_b);
 
                 if (opacity_b > 0.99f) {
-                    draw_solid_circle(G.world_canvas, b, thickness / 2, color_end, 20);
+                    draw_circle(G.world_canvas, b, thickness / 2, color_end, 20);
                 }
                 draw_gradient_line(G.world_canvas, a, b, thickness, color_start, color_end);
 
@@ -1008,7 +985,7 @@ INTERNAL void user_update(void)
                     struct sprite_sheet_frame frame = sprite_sheet_get_frame(sheet, ent->animation_frame);
                     struct quad quad = xform_mul_quad(sprite_xform, QUAD_UNIT_SQUARE_CENTERED);
                     struct draw_sprite_params params = DRAW_SPRITE_PARAMS(.sprite = sprite, .tint = ent->sprite_tint, .clip = frame.clip);
-                    draw_sprite_quad(G.world_canvas, params, quad);
+                    draw_quad_sprite(G.world_canvas, params, quad);
                 }
             }
 
@@ -1034,7 +1011,7 @@ INTERNAL void user_update(void)
                     start = xform_mul_v2(G.world_view, start);
                     struct v2 end = v2_add(xf.og, ent->control.focus);
                     end = xform_mul_v2(G.world_view, end);
-                    draw_solid_arrow_line(G.viewport_canvas, start, end, 3, 10, RGBA_32_F(1, 1, 1, 0.5));
+                    draw_arrow_line(G.viewport_canvas, start, end, 3, 10, RGBA_32_F(1, 1, 1, 0.5));
                 }
 
     #if 0
@@ -1064,16 +1041,16 @@ INTERNAL void user_update(void)
                                 struct quad quad = quad_from_rect(slice.rect);
                                 quad = xform_mul_quad(sprite_xform, quad);
                                 quad = xform_mul_quad(G.world_view, quad);
-                                draw_solid_quad_line(G.viewport_canvas, quad, 2, quad_color);
+                                draw_quad_line(G.viewport_canvas, quad, 2, quad_color);
                             }
 
-                            draw_solid_circle(G.viewport_canvas, center, 3, point_color, 20);
+                            draw_circle(G.viewport_canvas, center, 3, point_color, 20);
 
                             if (slice.has_ray) {
                                 struct v2 ray = xform_basis_mul_v2(sprite_xform, slice.dir);
                                 ray = xform_basis_mul_v2(G.world_view, ray);
                                 ray = v2_with_len(ray, 25);
-                                draw_solid_arrow_ray(G.viewport_canvas, center, ray, 2, 10, ray_color);
+                                draw_arrow_ray(G.viewport_canvas, center, ray, 2, 10, ray_color);
                             }
                         }
                     }
@@ -1089,13 +1066,13 @@ INTERNAL void user_update(void)
                         /* Draw collider using support points */
                         //u32 detail = 64;
                         u32 detail = 512;
-                        draw_solid_collider_line(G.viewport_canvas, G.world_view, collider, xf, thickness, color, detail);
+                        draw_collider_line(G.viewport_canvas, G.world_view, collider, xf, thickness, color, detail);
                     }
                     {
                         /* Draw collider shape points */
                         for (u32 i = 0; i < collider.count; ++i) {
                             struct v2 p = xform_mul_v2(xform_mul(G.world_view, xf), collider.points[i]);
-                            draw_solid_circle(G.viewport_canvas, p, 3, COLOR_BLUE, 10);
+                            draw_circle(G.viewport_canvas, p, 3, COLOR_BLUE, 10);
                         }
                     }
                     if (collider.count == 1 && collider.radius > 0) {
@@ -1104,14 +1081,14 @@ INTERNAL void user_update(void)
                         struct v2 end = collider_get_support_point(&collider, xf, v2_neg(xf.by)).p;
                         start = xform_mul_v2(G.world_view, start);
                         end = xform_mul_v2(G.world_view, end);
-                        draw_solid_line(G.viewport_canvas, start, end, thickness, color);
+                        draw_line(G.viewport_canvas, start, end, thickness, color);
                     }
     #if 0
                     /* Draw support point at focus dir */
                     {
                         struct v2 p = collider_support_point(&collider, xf, ent->control.focus);
                         p = xform_mul_v2(G.world_view, p);
-                        draw_solid_circle(G.viewport_canvas, p, 3, COLOR_RED, 10);
+                        draw_circle(G.viewport_canvas, p, 3, COLOR_RED, 10);
                     }
     #endif
                 }
@@ -1143,7 +1120,7 @@ INTERNAL void user_update(void)
                                 u32 color = RGBA_32_F(1, 1, 0, 0.50);
                                 //struct v2 point = xform_mul_v2(e0_xf, contact.p0_local);
                                 //struct v2 point = contact.p0_initial_world;
-                                draw_solid_circle(G.viewport_canvas, xform_mul_v2(G.world_view, dbg_pt), radius, color, 10);
+                                draw_circle(G.viewport_canvas, xform_mul_v2(G.world_view, dbg_pt), radius, color, 10);
                             }
                             /* Draw normal */
                             {
@@ -1153,7 +1130,7 @@ INTERNAL void user_update(void)
                                 f32 arrow_height = 5;
                                 struct v2 start = xform_mul_v2(G.world_view, dbg_pt);
                                 struct v2 end = xform_mul_v2(G.world_view, v2_add(dbg_pt, v2_mul(v2_norm(data->normal), len)));
-                                draw_solid_arrow_line(G.viewport_canvas, start, end, arrow_thickness, arrow_height, color);
+                                draw_arrow_line(G.viewport_canvas, start, end, arrow_thickness, arrow_height, color);
                             }
     #if 0
                             /* Draw contact info */
@@ -1210,8 +1187,8 @@ INTERNAL void user_update(void)
                         u32 color = RGBA_32_F(1, 1, 0, 0.5);
                         struct v2 a = xform_mul_v2(G.world_view, data->closest0);
                         struct v2 b = xform_mul_v2(G.world_view, data->closest1);
-                        draw_solid_circle(G.viewport_canvas, a, radius, color, 10);
-                        draw_solid_circle(G.viewport_canvas, b, radius, color, 10);
+                        draw_circle(G.viewport_canvas, a, radius, color, 10);
+                        draw_circle(G.viewport_canvas, b, radius, color, 10);
                     }
     #endif
 
@@ -1228,28 +1205,28 @@ INTERNAL void user_update(void)
                         {
                             struct v2 a = xform_mul_v2(G.world_view, collider_res.a0);
                             struct v2 b = xform_mul_v2(G.world_view, collider_res.b0);
-                            draw_solid_line(G.viewport_canvas, a, b, thickness, color_line);
-                            draw_solid_circle(G.viewport_canvas, a, radius, color_a, 10);
-                            draw_solid_circle(G.viewport_canvas, b, radius, color_b, 10);
+                            draw_line(G.viewport_canvas, a, b, thickness, color_line);
+                            draw_circle(G.viewport_canvas, a, radius, color_a, 10);
+                            draw_circle(G.viewport_canvas, b, radius, color_b, 10);
 
                             struct v2 a_clipped = xform_mul_v2(G.world_view, collider_res.a0_clipped);
                             struct v2 b_clipped = xform_mul_v2(G.world_view, collider_res.b0_clipped);
-                            draw_solid_line(G.viewport_canvas, a_clipped, b_clipped, thickness, color_line_clipped);
-                            draw_solid_circle(G.viewport_canvas, a_clipped, radius, color_a_clipped, 10);
-                            draw_solid_circle(G.viewport_canvas, b_clipped, radius, color_b_clipped, 10);
+                            draw_line(G.viewport_canvas, a_clipped, b_clipped, thickness, color_line_clipped);
+                            draw_circle(G.viewport_canvas, a_clipped, radius, color_a_clipped, 10);
+                            draw_circle(G.viewport_canvas, b_clipped, radius, color_b_clipped, 10);
                         }
                         {
                             struct v2 a = xform_mul_v2(G.world_view, collider_res.a1);
                             struct v2 b = xform_mul_v2(G.world_view, collider_res.b1);
-                            draw_solid_line(G.viewport_canvas, a, b, thickness, color_line);
-                            draw_solid_circle(G.viewport_canvas, a, radius, color_a, 10);
-                            draw_solid_circle(G.viewport_canvas, b, radius, color_b, 10);
+                            draw_line(G.viewport_canvas, a, b, thickness, color_line);
+                            draw_circle(G.viewport_canvas, a, radius, color_a, 10);
+                            draw_circle(G.viewport_canvas, b, radius, color_b, 10);
 
                             struct v2 a_clipped = xform_mul_v2(G.world_view, collider_res.a1_clipped);
                             struct v2 b_clipped = xform_mul_v2(G.world_view, collider_res.b1_clipped);
-                            draw_solid_line(G.viewport_canvas, a_clipped, b_clipped, thickness, color_line_clipped);
-                            draw_solid_circle(G.viewport_canvas, a_clipped, radius, color_a_clipped, 10);
-                            draw_solid_circle(G.viewport_canvas, b_clipped, radius, color_b_clipped, 10);
+                            draw_line(G.viewport_canvas, a_clipped, b_clipped, thickness, color_line_clipped);
+                            draw_circle(G.viewport_canvas, a_clipped, radius, color_a_clipped, 10);
+                            draw_circle(G.viewport_canvas, b_clipped, radius, color_b_clipped, 10);
                         }
                     }
 
@@ -1306,8 +1283,8 @@ INTERNAL void user_update(void)
                             struct v2_array m = menkowski(temp.arena, &e0_collider, &e1_collider, e0_xf, e1_xf, detail);
 
                             for (u64 i = 0; i < m.count; ++i) m.points[i] = xform_mul_v2(G.world_view, m.points[i]);
-                            draw_solid_poly_line(G.viewport_canvas, m, true, thickness, color);
-                            //draw_solid_poly(G.viewport_canvas, m, color);
+                            draw_poly_line(G.viewport_canvas, m, true, thickness, color);
+                            //draw_poly(G.viewport_canvas, m, color);
                         }
 
                         /* Draw cloud */
@@ -1319,7 +1296,7 @@ INTERNAL void user_update(void)
 
                             for (u64 i = 0; i < m.count; ++i) {
                                 struct v2 p = xform_mul_v2(G.world_view, m.points[i]);
-                                draw_solid_circle(G.viewport_canvas, p, radius, color, 10);
+                                draw_circle(G.viewport_canvas, p, radius, color, 10);
                             }
                         }
 
@@ -1331,7 +1308,7 @@ INTERNAL void user_update(void)
                             f32 arrow_height = 5;
                             struct v2 start = xform_mul_v2(G.world_view, V2(0, 0));
                             struct v2 end = xform_mul_v2(G.world_view, v2_mul(v2_norm(collider_res.normal), len));
-                            draw_solid_arrow_line(G.viewport_canvas, start, end, arrow_thickness, arrow_height, color);
+                            draw_arrow_line(G.viewport_canvas, start, end, arrow_thickness, arrow_height, color);
                         }
 
                         /* Draw prototype */
@@ -1344,8 +1321,8 @@ INTERNAL void user_update(void)
                                 .count = collider_res.prototype.len
                             };
                             for (u64 i = 0; i < m.count; ++i) m.points[i] = xform_mul_v2(G.world_view, m.points[i]);
-                            draw_solid_poly_line(G.viewport_canvas, m, true, thickness, color);
-                            for (u64 i = 0; i < m.count; ++i) draw_solid_circle(G.viewport_canvas, m.points[i], 10, color, 10);
+                            draw_poly_line(G.viewport_canvas, m, true, thickness, color);
+                            for (u64 i = 0; i < m.count; ++i) draw_circle(G.viewport_canvas, m.points[i], 10, color, 10);
                         }
 
                         /* Draw simplex */
@@ -1363,18 +1340,18 @@ INTERNAL void user_update(void)
 
                             if (simplex.len >= 1) {
                                 u32 color = simplex.len == 1 ? color_first : (simplex.len == 2 ? color_second : color_third);
-                                draw_solid_circle(G.viewport_canvas, simplex_array.points[0], thickness * 3, color, 10);
+                                draw_circle(G.viewport_canvas, simplex_array.points[0], thickness * 3, color, 10);
                             }
                             if (simplex.len >= 2) {
                                 u32 color = simplex.len == 2 ? color_first : color_second;
-                                draw_solid_circle(G.viewport_canvas, simplex_array.points[1], thickness * 3, color, 10);
+                                draw_circle(G.viewport_canvas, simplex_array.points[1], thickness * 3, color, 10);
                             }
                             if (simplex.len >= 3) {
                                 u32 color = color_first;
-                                draw_solid_circle(G.viewport_canvas, simplex_array.points[2], thickness * 3, color, 10);
+                                draw_circle(G.viewport_canvas, simplex_array.points[2], thickness * 3, color, 10);
                             }
                             if (simplex.len >= 2) {
-                                draw_solid_poly_line(G.viewport_canvas, simplex_array, simplex.len > 2, thickness, line_color);
+                                draw_poly_line(G.viewport_canvas, simplex_array, simplex.len > 2, thickness, line_color);
                             }
                         }
                     }
@@ -1391,7 +1368,7 @@ INTERNAL void user_update(void)
 
                     struct v2 start = xform_mul_v2(G.world_view, xf.og);
                     struct v2 end = xform_mul_v2(G.world_view, parent_xf.og);
-                    draw_solid_arrow_line(G.viewport_canvas, start, end, thickness, arrow_height, color);
+                    draw_arrow_line(G.viewport_canvas, start, end, thickness, arrow_height, color);
                 }
 
                 /* Draw camera rect */
@@ -1403,7 +1380,7 @@ INTERNAL void user_update(void)
                     struct quad quad = xform_mul_quad(quad_xf, QUAD_UNIT_SQUARE_CENTERED);
                     quad = xform_mul_quad(G.world_view, quad);
 
-                    draw_solid_quad_line(G.viewport_canvas, quad, thickness, color);
+                    draw_quad_line(G.viewport_canvas, quad, thickness, color);
                 }
 
                 arena_temp_end(temp);
@@ -1422,7 +1399,7 @@ INTERNAL void user_update(void)
         struct v2 size = V2(t->width, t->height);
         struct xform xf = XFORM_TRS(.t = crosshair_pos, .s = size);
         struct quad quad = xform_mul_quad(xf, QUAD_UNIT_SQUARE_CENTERED);
-        draw_sprite_quad(G.viewport_canvas, DRAW_SPRITE_PARAMS(.sprite = crosshair_tag, .tint = tint), quad);
+        draw_quad_sprite(G.viewport_canvas, DRAW_SPRITE_PARAMS(.sprite = crosshair_tag, .tint = tint), quad);
 
         struct rect cursor_clip = RECT_FROM_V2(G.viewport_screen_offset, G.viewport_size);
         cursor_clip.pos = v2_add(cursor_clip.pos, v2_mul(size, 0.5f));