From 3c47774e67a08fc5644d36125c42fb7345cb4739 Mon Sep 17 00:00:00 2001 From: jacob Date: Mon, 20 Jan 2025 09:25:32 -0600 Subject: [PATCH] rename canvas -> cmd buffer --- src/draw.c | 80 +++++++++--------- src/draw.h | 36 ++++---- src/renderer.h | 18 ++-- src/renderer_d3d11.c | 110 ++++++++++++------------ src/user.c | 196 +++++++++++++++++++++---------------------- 5 files changed, 219 insertions(+), 221 deletions(-) diff --git a/src/draw.c b/src/draw.c index 5ac657f9..0b5ef7d2 100644 --- a/src/draw.c +++ b/src/draw.c @@ -28,17 +28,17 @@ struct draw_startup_receipt draw_startup(struct renderer_startup_receipt *render * Texture * ========================== */ -void draw_quad_texture_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_texture_ex(struct renderer_cmd_buffer *cmdbuff, 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); + renderer_cmd_buffer_ensure_cmd(cmdbuff, &cmd_params); struct texture_shader_vertex *vertices = NULL; vidx *indices = NULL; - u32 offset = renderer_canvas_push_vertices(canvas, (u8 **)&vertices, &indices, 4, 6); + u32 offset = renderer_cmd_buffer_push_vertices(cmdbuff, (u8 **)&vertices, &indices, 4, 6); /* Top left */ vertices[0] = (struct texture_shader_vertex) { @@ -76,16 +76,16 @@ void draw_quad_texture_ex(struct renderer_canvas *canvas, struct renderer_handle indices[5] = offset + 3; } -void draw_quad_texture(struct renderer_canvas *canvas, struct draw_texture_params params, struct quad quad) +void draw_quad_texture(struct renderer_cmd_buffer *cmdbuff, struct draw_texture_params params, struct quad quad) { - draw_quad_texture_ex(canvas, params.texture, params.sprite, params.clip, params.tint, params.tint, quad); + draw_quad_texture_ex(cmdbuff, params.texture, params.sprite, params.clip, params.tint, params.tint, quad); } /* ========================== * * Solid fill shapes * ========================== */ -void draw_poly(struct renderer_canvas *canvas, struct v2_array array, u32 color) +void draw_poly(struct renderer_cmd_buffer *cmdbuff, struct v2_array array, u32 color) { if (array.count < 3) { return; @@ -94,14 +94,14 @@ void draw_poly(struct renderer_canvas *canvas, struct v2_array array, u32 color) 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); + renderer_cmd_buffer_ensure_cmd(cmdbuff, &cmd_params); u32 num_tris = array.count - 2; u32 num_indices = num_tris * 3; struct texture_shader_vertex *vertices = NULL; vidx *indices = NULL; - u32 idx_offset = renderer_canvas_push_vertices(canvas, (u8 **)&vertices, &indices, array.count, num_indices); + u32 idx_offset = renderer_cmd_buffer_push_vertices(cmdbuff, (u8 **)&vertices, &indices, array.count, num_indices); /* Fill vertices */ for (u32 i = 0; i < array.count; ++i) { @@ -120,7 +120,7 @@ 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_circle(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, f32 radius, u32 color, u32 detail) { struct temp_arena scratch = scratch_begin_no_conflict(); @@ -137,39 +137,39 @@ void draw_circle(struct renderer_canvas *canvas, struct v2 pos, f32 radius, u32 .points = points, .count = detail }; - draw_poly(canvas, a, color); + draw_poly(cmdbuff, a, color); scratch_end(scratch); } -void draw_quad(struct renderer_canvas *canvas, struct quad quad, u32 color) +void draw_quad(struct renderer_cmd_buffer *cmdbuff, struct quad quad, u32 color) { - draw_quad_texture_ex(canvas, G.solid_white, sprite_tag_nil(), CLIP_ALL, color, color, quad); + draw_quad_texture_ex(cmdbuff, G.solid_white, sprite_tag_nil(), CLIP_ALL, color, color, quad); } /* ========================== * * Solid line shapes * ========================== */ -void draw_gradient_line(struct renderer_canvas *canvas, struct v2 start, struct v2 end, f32 thickness, u32 color_start, u32 color_end) +void draw_gradient_line(struct renderer_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, u32 color_start, u32 color_end) { struct quad quad = quad_from_line(start, end, thickness); - draw_quad_texture_ex(canvas, G.solid_white, sprite_tag_nil(), CLIP_ALL, color_start, color_end, quad); + draw_quad_texture_ex(cmdbuff, G.solid_white, sprite_tag_nil(), CLIP_ALL, color_start, color_end, quad); } -void draw_line(struct renderer_canvas *canvas, struct v2 start, struct v2 end, f32 thickness, u32 color) +void draw_line(struct renderer_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, u32 color) { struct quad quad = quad_from_line(start, end, thickness); - draw_quad(canvas, quad, color); + draw_quad(cmdbuff, quad, color); } -void draw_ray(struct renderer_canvas *canvas, struct v2 pos, struct v2 rel, f32 thickness, u32 color) +void draw_ray(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, struct v2 rel, f32 thickness, u32 color) { struct quad quad = quad_from_ray(pos, rel, thickness); - draw_quad(canvas, quad, color); + draw_quad(cmdbuff, quad, color); } -void draw_poly_line(struct renderer_canvas *canvas, struct v2_array array, b32 loop, f32 thickness, u32 color) +void draw_poly_line(struct renderer_cmd_buffer *cmdbuff, struct v2_array array, b32 loop, f32 thickness, u32 color) { if (array.count < 2) { return; @@ -179,17 +179,17 @@ void draw_poly_line(struct renderer_canvas *canvas, struct v2_array array, b32 l struct v2 p1 = array.points[i - 1]; struct v2 p2 = array.points[i]; struct quad q = quad_from_line(p1, p2, thickness); - draw_quad(canvas, q, color); + draw_quad(cmdbuff, 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_quad(canvas, q, color); + draw_quad(cmdbuff, q, color); } } -void draw_circle_line(struct renderer_canvas *canvas, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail) +void draw_circle_line(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail) { struct temp_arena scratch = scratch_begin_no_conflict(); @@ -206,19 +206,19 @@ void draw_circle_line(struct renderer_canvas *canvas, struct v2 pos, f32 radius, .points = points, .count = detail }; - draw_poly_line(canvas, a, true, thickness, color); + draw_poly_line(cmdbuff, a, true, thickness, color); scratch_end(scratch); } -void draw_quad_line(struct renderer_canvas *canvas, struct quad quad, f32 thickness, u32 color) +void draw_quad_line(struct renderer_cmd_buffer *cmdbuff, 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_poly_line(canvas, a, true, thickness, color); + draw_poly_line(cmdbuff, a, true, thickness, 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_line(struct renderer_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 color) { const f32 head_width_ratio = 0.5f; /* Width of arrowhead relative to its length */ @@ -242,19 +242,19 @@ void draw_arrow_line(struct renderer_canvas *canvas, struct v2 start, struct v2 .points = head_points, .count = ARRAY_COUNT(head_points) }; - draw_poly(canvas, head_points_v2_array, color); + draw_poly(cmdbuff, head_points_v2_array, color); struct quad line_quad = quad_from_line(start, head_start, thickness); - draw_quad(canvas, line_quad, color); + draw_quad(cmdbuff, line_quad, color); } -void draw_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_cmd_buffer *cmdbuff, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 color) { struct v2 end = v2_add(pos, rel); - draw_arrow_line(canvas, pos, end, thickness, arrowhead_height, color); + draw_arrow_line(cmdbuff, pos, end, thickness, arrowhead_height, 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_collider_line(struct renderer_cmd_buffer *cmdbuff, 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(); @@ -269,12 +269,12 @@ void draw_collider_line(struct renderer_canvas *canvas, struct xform draw_xf, st #if 1 struct v2_array poly = { .points = points, .count = detail }; - draw_poly_line(canvas, poly, true, thickness, color); + draw_poly_line(cmdbuff, poly, true, thickness, color); #else for (u64 i = 0; i < detail; ++i) { struct v2 point = points[i]; (UNUSED)thickness; - draw_circle(canvas, point, 3, color, 10); + draw_circle(cmdbuff, point, 3, color, 10); } #endif @@ -285,15 +285,15 @@ void draw_collider_line(struct renderer_canvas *canvas, struct xform draw_xf, st * Grid * ========================== */ -void draw_grid(struct renderer_canvas *canvas, struct rect rect, u32 color, f32 thickness, f32 spacing, struct v2 offset) +void draw_grid(struct renderer_cmd_buffer *cmdbuff, 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); + renderer_cmd_buffer_ensure_cmd(cmdbuff, &cmd_params); struct grid_shader_vertex *vertices = NULL; vidx *indices = NULL; - u32 index_offset = renderer_canvas_push_vertices(canvas, (u8 **)&vertices, &indices, 4, 6); + u32 index_offset = renderer_cmd_buffer_push_vertices(cmdbuff, (u8 **)&vertices, &indices, 4, 6); struct quad quad = quad_from_rect(rect); @@ -330,7 +330,7 @@ void draw_grid(struct renderer_canvas *canvas, struct rect rect, u32 color, f32 * Text * ========================== */ -void draw_text_ex(struct renderer_canvas *canvas, struct font *font, struct v2 pos, f32 scale, struct string str) +void draw_text_ex(struct renderer_cmd_buffer *cmdbuff, struct font *font, struct v2 pos, f32 scale, struct string str) { struct v2 draw_pos = pos; draw_pos.y += font->point_size * scale; @@ -365,14 +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_quad_texture_ex(canvas, font->image_renderer_handle, sprite_tag_nil(), clip, 0xFFFFFFFF, 0xFFFFFFFF, quad); + draw_quad_texture_ex(cmdbuff, 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) +void draw_text(struct renderer_cmd_buffer *cmdbuff, struct font *font, struct v2 pos, struct string str) { - draw_text_ex(canvas, font, pos, 1.0, str); + draw_text_ex(cmdbuff, font, pos, 1.0, str); } diff --git a/src/draw.h b/src/draw.h index ec5988bb..b412e711 100644 --- a/src/draw.h +++ b/src/draw.h @@ -1,7 +1,7 @@ #ifndef DRAW_H #define DRAW_H -struct renderer_canvas; +struct renderer_cmd_buffer; struct font; struct renderer_startup_receipt; struct font_startup_receipt; @@ -23,26 +23,26 @@ 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_quad_texture_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_texture(struct renderer_canvas *canvas, struct draw_texture_params params, struct quad quad); +void draw_quad_texture_ex(struct renderer_cmd_buffer *cmdbuff, struct renderer_handle texture, struct sprite_tag sprite, struct clip_rect clip, u32 tint0, u32 tint1, struct quad quad); +void draw_quad_texture(struct renderer_cmd_buffer *cmdbuff, struct draw_texture_params params, struct quad quad); -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_poly(struct renderer_cmd_buffer *cmdbuff, struct v2_array array, u32 color); +void draw_circle(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, f32 radius, u32 color, u32 detail); +void draw_quad(struct renderer_cmd_buffer *cmdbuff, struct quad quad, 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_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_gradient_line(struct renderer_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, u32 color_start, u32 color_end); +void draw_line(struct renderer_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, u32 color); +void draw_ray(struct renderer_cmd_buffer *cmdbuff, struct v2 start, struct v2 ray, f32 thickness, u32 color); +void draw_poly_line(struct renderer_cmd_buffer *cmdbuff, struct v2_array array, b32 loop, f32 thickness, u32 color); +void draw_circle_line(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail); +void draw_quad_line(struct renderer_cmd_buffer *cmdbuff, struct quad quad, f32 thickness, u32 color); +void draw_arrow_line(struct renderer_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 color); +void draw_arrow_ray(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 color); +void draw_collider_line(struct renderer_cmd_buffer *cmdbuff, 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_grid(struct renderer_cmd_buffer *cmdbuff, 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); +void draw_text(struct renderer_cmd_buffer *cmdbuff, struct font *font, struct v2 pos, struct string str); +void draw_text_ex(struct renderer_cmd_buffer *cmdbuff, struct font *font, struct v2 pos, f32 scale, struct string str); #endif diff --git a/src/renderer.h b/src/renderer.h index 7e26f15b..cdca9a53 100644 --- a/src/renderer.h +++ b/src/renderer.h @@ -9,7 +9,7 @@ struct sprite_scope; typedef u32 vidx; -struct renderer_canvas; +struct renderer_cmd_buffer; /* ========================== * * Shaders @@ -55,12 +55,12 @@ struct renderer_startup_receipt { i32 _; }; struct renderer_startup_receipt renderer_startup(struct sys_window *window); /* ========================== * - * Canvas + * Cmd buffer * ========================== */ -struct renderer_canvas *renderer_canvas_alloc(void); +struct renderer_cmd_buffer *renderer_cmd_buffer_alloc(void); -void renderer_canvas_release(struct renderer_canvas *canvas); +void renderer_cmd_buffer_release(struct renderer_cmd_buffer *cmdbuff); /* Pushes array of vertices based on `vertices_count` & `indices_count`. * Sets `vertices_out` and `indices_out` to start of the pushed arrays, to be filled out by the caller. @@ -69,18 +69,18 @@ void renderer_canvas_release(struct renderer_canvas *canvas); * NOTE: This should be preceded by an `ensure_cmd` call to ensure that the correct vertex types * are being pushed. */ -u32 renderer_canvas_push_vertices(struct renderer_canvas *canvas, u8 **vertices_out, vidx **indices_out, u32 vertices_count, u32 indices_count); +u32 renderer_cmd_buffer_push_vertices(struct renderer_cmd_buffer *cmdbuff, 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 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_cmd_buffer_ensure_cmd(struct renderer_cmd_buffer *cmdbuff, struct renderer_cmd_parameters *params); -void renderer_canvas_send_to_gpu(struct renderer_canvas *canvas); +void renderer_cmd_buffer_send_to_gpu(struct renderer_cmd_buffer *cmdbuff); -void renderer_render_to_texture(struct renderer_handle target_handle, struct renderer_canvas *canvas, struct xform view, struct rect viewport, struct sprite_scope *sprite_scope); +void renderer_render_to_texture(struct renderer_handle target_handle, struct renderer_cmd_buffer *cmdbuff, struct xform view, struct rect viewport, struct sprite_scope *sprite_scope); -void renderer_render_to_backbuffer(struct renderer_canvas *canvas, struct xform view, struct rect viewport, struct sprite_scope *sprite_scope); +void renderer_render_to_backbuffer(struct renderer_cmd_buffer *cmdbuff, struct xform view, struct rect viewport, struct sprite_scope *sprite_scope); void renderer_clear_texture(struct renderer_handle target_handle, u32 clear_color); diff --git a/src/renderer_d3d11.c b/src/renderer_d3d11.c index aa2cfbe0..e00ed75c 100644 --- a/src/renderer_d3d11.c +++ b/src/renderer_d3d11.c @@ -24,7 +24,7 @@ #pragma comment(lib, "dxguid") #pragma comment(lib, "d3dcompiler") -#define MAX_CANVASES 1024 +#define MAX_CMD_BUFFERS 1024 /* FIXME: Enable this and resolve unreleased references */ //#define D3D11_DEBUG RTC @@ -79,7 +79,7 @@ struct cmd_store { struct arena arena; }; -struct renderer_canvas { +struct renderer_cmd_buffer { struct dx11_buffer buffers[NUM_SHADERS]; struct cmd_store cpu_cmd_store; @@ -133,8 +133,8 @@ GLOBAL struct { struct handle_store handle_store; - /* Sparse array (canvas.valid) */ - struct renderer_canvas canvases[MAX_CANVASES]; + /* Sparse array (cmdbuff.valid) */ + struct renderer_cmd_buffer cmdbuffs[MAX_CMD_BUFFERS]; struct dx11_shader shaders[NUM_SHADERS]; @@ -621,50 +621,50 @@ struct renderer_startup_receipt renderer_startup(struct sys_window *window) } /* ========================== * - * Canvas + * Cmd buffer * ========================== */ -struct renderer_canvas *renderer_canvas_alloc(void) +struct renderer_cmd_buffer *renderer_cmd_buffer_alloc(void) { - struct renderer_canvas *canvas = NULL; - for (u32 i = 0; i < MAX_CANVASES; ++i) { - if (!G.canvases[i].valid) { - canvas = &G.canvases[i]; + struct renderer_cmd_buffer *cmdbuff = NULL; + for (u32 i = 0; i < MAX_CMD_BUFFERS; ++i) { + if (!G.cmdbuffs[i].valid) { + cmdbuff = &G.cmdbuffs[i]; break; } } - if (!canvas) { - sys_panic(STR("Max renderer canvases reached")); + if (!cmdbuff) { + sys_panic(STR("Max renderer cmdbuffs reached")); return NULL; } - MEMZERO_STRUCT(canvas); - canvas->cpu_cmd_store.arena = arena_alloc(GIGABYTE(8)); - canvas->gpu_cmd_store.arena = arena_alloc(GIGABYTE(8)); - canvas->valid = true; + MEMZERO_STRUCT(cmdbuff); + cmdbuff->cpu_cmd_store.arena = arena_alloc(GIGABYTE(8)); + cmdbuff->gpu_cmd_store.arena = arena_alloc(GIGABYTE(8)); + cmdbuff->valid = true; /* Initialize buffers */ - for (u32 i = SHADER_NONE + 1; i < ARRAY_COUNT(canvas->buffers); ++i) { - struct dx11_buffer *buffer = &canvas->buffers[i]; + for (u32 i = SHADER_NONE + 1; i < ARRAY_COUNT(cmdbuff->buffers); ++i) { + struct dx11_buffer *buffer = &cmdbuff->buffers[i]; buffer->vertex_arena = arena_alloc(GIGABYTE(8)); buffer->index_arena = arena_alloc(GIGABYTE(8)); buffer->cpu_vertex_buffer = arena_dry_push(&buffer->vertex_arena, u8); buffer->cpu_index_buffer = arena_dry_push(&buffer->index_arena, vidx); } - return canvas; + return cmdbuff; } -void renderer_canvas_release(struct renderer_canvas *canvas) +void renderer_cmd_buffer_release(struct renderer_cmd_buffer *cmdbuff) { - canvas->valid = false; - arena_release(&canvas->cpu_cmd_store.arena); - arena_release(&canvas->gpu_cmd_store.arena); + cmdbuff->valid = false; + arena_release(&cmdbuff->cpu_cmd_store.arena); + arena_release(&cmdbuff->gpu_cmd_store.arena); /* Destroy buffers */ - for (u32 i = SHADER_NONE + 1; i < ARRAY_COUNT(canvas->buffers); ++i) { - struct dx11_buffer *buffer = &canvas->buffers[i]; + for (u32 i = SHADER_NONE + 1; i < ARRAY_COUNT(cmdbuff->buffers); ++i) { + struct dx11_buffer *buffer = &cmdbuff->buffers[i]; arena_release(&buffer->vertex_arena); arena_release(&buffer->index_arena); @@ -672,18 +672,18 @@ void renderer_canvas_release(struct renderer_canvas *canvas) } } -u32 renderer_canvas_push_vertices(struct renderer_canvas *canvas, u8 **vertices_out, vidx **indices_out, u32 vertices_count, u32 indices_count) +u32 renderer_cmd_buffer_push_vertices(struct renderer_cmd_buffer *cmdbuff, u8 **vertices_out, vidx **indices_out, u32 vertices_count, u32 indices_count) { - struct renderer_cmd *cmd = canvas->cpu_cmd_store.cmd_last; + struct renderer_cmd *cmd = cmdbuff->cpu_cmd_store.cmd_last; if (!cmd) { - /* Tried to draw to canvas with no active draw cmd */ + /* Tried to draw to cmdbuff with no active draw cmd */ ASSERT(false); return 0; } struct dx11_shader *shader = cmd->shader; - struct dx11_buffer *buffer = &canvas->buffers[shader->kind]; + struct dx11_buffer *buffer = &cmdbuff->buffers[shader->kind]; if (!cmd->offsets_set) { cmd->vertex_offset = buffer->vertex_count; @@ -703,9 +703,9 @@ u32 renderer_canvas_push_vertices(struct renderer_canvas *canvas, u8 **vertices_ return first_vertex_index; } -void renderer_canvas_ensure_cmd(struct renderer_canvas *canvas, struct renderer_cmd_parameters *params) +void renderer_cmd_buffer_ensure_cmd(struct renderer_cmd_buffer *cmdbuff, struct renderer_cmd_parameters *params) { - struct renderer_cmd *last_cmd = canvas->cpu_cmd_store.cmd_last; + struct renderer_cmd *last_cmd = cmdbuff->cpu_cmd_store.cmd_last; struct renderer_cmd *new_cmd = NULL; switch (params->kind) { @@ -721,7 +721,7 @@ void renderer_canvas_ensure_cmd(struct renderer_canvas *canvas, struct renderer_ || 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 = arena_push(&cmdbuff->cpu_cmd_store.arena, struct renderer_cmd); *new_cmd = (struct renderer_cmd) { .shader = &G.shaders[SHADER_TEXTURE], .texture_handle = params->texture_params.texture, @@ -733,7 +733,7 @@ void renderer_canvas_ensure_cmd(struct renderer_canvas *canvas, struct renderer_ 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 = arena_push(&cmdbuff->cpu_cmd_store.arena, struct renderer_cmd); *new_cmd = (struct renderer_cmd) { .shader = &G.shaders[SHADER_GRID], }; @@ -742,26 +742,26 @@ void renderer_canvas_ensure_cmd(struct renderer_canvas *canvas, struct renderer_ } if (new_cmd) { - if (!canvas->cpu_cmd_store.cmd_first) { - canvas->cpu_cmd_store.cmd_first = new_cmd; + if (!cmdbuff->cpu_cmd_store.cmd_first) { + cmdbuff->cpu_cmd_store.cmd_first = new_cmd; } else { last_cmd->next = new_cmd; } - canvas->cpu_cmd_store.cmd_last = new_cmd; + cmdbuff->cpu_cmd_store.cmd_last = new_cmd; } } /* ========================== * - * Send canvas to GPU + * Send cmdbuff to GPU * ========================== */ -void renderer_canvas_send_to_gpu(struct renderer_canvas *canvas) +void renderer_cmd_buffer_send_to_gpu(struct renderer_cmd_buffer *cmdbuff) { __prof; /* Create / grow vertex buffers */ - for (u32 i = 1; i < ARRAY_COUNT(canvas->buffers); ++i) { - struct dx11_buffer *buffer = &canvas->buffers[i]; + for (u32 i = 1; i < ARRAY_COUNT(cmdbuff->buffers); ++i) { + struct dx11_buffer *buffer = &cmdbuff->buffers[i]; struct dx11_shader *shader = &G.shaders[i]; u32 vertex_size = shader->vertex_size; u32 index_size = sizeof(vidx); @@ -812,26 +812,26 @@ void renderer_canvas_send_to_gpu(struct renderer_canvas *canvas) } /* Swap CPU cmds to GPU store */ - struct cmd_store temp = canvas->gpu_cmd_store; - canvas->gpu_cmd_store = canvas->cpu_cmd_store; - canvas->cpu_cmd_store = temp; + struct cmd_store temp = cmdbuff->gpu_cmd_store; + cmdbuff->gpu_cmd_store = cmdbuff->cpu_cmd_store; + cmdbuff->cpu_cmd_store = temp; /* Reset CPU cmds */ - canvas->cpu_cmd_store.cmd_first = NULL; - canvas->cpu_cmd_store.cmd_last = NULL; - arena_reset(&canvas->cpu_cmd_store.arena); + cmdbuff->cpu_cmd_store.cmd_first = NULL; + cmdbuff->cpu_cmd_store.cmd_last = NULL; + arena_reset(&cmdbuff->cpu_cmd_store.arena); } /* ========================== * * Render * ========================== */ -/* TODO: Lock canvas or at least global state? (in-case multi-threaded present). - * Another option is to store a separate device on each canvas (need to +/* TODO: Lock cmdbuff or at least global state? (in-case multi-threaded present). + * Another option is to store a separate device on each cmdbuff (need to * research if that is smart first). * * I'm thinking we may also just need to lock texture modification access while presenting */ -INTERNAL void dx11_render_to_target(ID3D11RenderTargetView *target, struct renderer_canvas *canvas, struct xform view, struct rect viewport, struct sprite_scope *sprite_scope) +INTERNAL void dx11_render_to_target(ID3D11RenderTargetView *target, struct renderer_cmd_buffer *cmdbuff, struct xform view, struct rect viewport, struct sprite_scope *sprite_scope) { __prof; ID3D11DeviceContext_OMSetRenderTargets(G.devcon, 1, &target, NULL); @@ -854,10 +854,10 @@ INTERNAL void dx11_render_to_target(ID3D11RenderTargetView *target, struct rende struct dx11_shader *last_shader = NULL; - struct renderer_cmd *cmd = canvas ? canvas->gpu_cmd_store.cmd_first : NULL; + struct renderer_cmd *cmd = cmdbuff ? cmdbuff->gpu_cmd_store.cmd_first : NULL; for (; cmd; cmd = cmd->next) { struct dx11_shader *shader = cmd->shader; - struct dx11_buffer *buffer = &canvas->buffers[shader->kind]; + struct dx11_buffer *buffer = &cmdbuff->buffers[shader->kind]; /* Activate shader */ if (shader != last_shader) { @@ -935,7 +935,7 @@ INTERNAL void dx11_render_to_target(ID3D11RenderTargetView *target, struct rende } } -void renderer_render_to_texture(struct renderer_handle target_handle, struct renderer_canvas *canvas, struct xform view, struct rect viewport, struct sprite_scope *sprite_scope) +void renderer_render_to_texture(struct renderer_handle target_handle, struct renderer_cmd_buffer *cmdbuff, struct xform view, struct rect viewport, struct sprite_scope *sprite_scope) { __prof; @@ -952,7 +952,7 @@ void renderer_render_to_texture(struct renderer_handle target_handle, struct ren ID3D11RenderTargetView *target_view = NULL; ID3D11Device_CreateRenderTargetView(G.dev, (ID3D11Resource *)target_texture, NULL, &target_view); if (target_view) { - dx11_render_to_target(target_view, canvas, view, viewport, sprite_scope); + dx11_render_to_target(target_view, cmdbuff, view, viewport, sprite_scope); } if (target_view) { @@ -963,7 +963,7 @@ void renderer_render_to_texture(struct renderer_handle target_handle, struct ren } } -void renderer_render_to_backbuffer(struct renderer_canvas *canvas, struct xform view, struct rect viewport, struct sprite_scope *sprite_scope) +void renderer_render_to_backbuffer(struct renderer_cmd_buffer *cmdbuff, struct xform view, struct rect viewport, struct sprite_scope *sprite_scope) { __prof; @@ -974,7 +974,7 @@ void renderer_render_to_backbuffer(struct renderer_canvas *canvas, struct xform ID3D11Device_CreateRenderTargetView(G.dev, (ID3D11Resource *)backbuffer_texture, NULL, &backbuffer_view); if (backbuffer_view) { - dx11_render_to_target(backbuffer_view, canvas, view, viewport, sprite_scope); + dx11_render_to_target(backbuffer_view, cmdbuff, view, viewport, sprite_scope); } if (backbuffer_view) { diff --git a/src/user.c b/src/user.c index e3e2b3ee..0be1fa71 100644 --- a/src/user.c +++ b/src/user.c @@ -41,19 +41,19 @@ GLOBAL struct { struct sys_window *window; + /* Render targets */ struct renderer_handle final_rt; struct renderer_handle world_rt; struct renderer_handle ui_rt; - struct v2 final_rt_resolution; - struct v2 world_rt_resolution; struct v2 ui_rt_resolution; + struct v2 world_rt_resolution; struct v2 backbuffer_size; - struct renderer_canvas *world_canvas; - struct renderer_canvas *ui_canvas; - struct renderer_canvas *final_canvas; - struct renderer_canvas *backbuffer_canvas; + struct renderer_cmd_buffer *world_cmd_buffer; + struct renderer_cmd_buffer *ui_cmd_buffer; + struct renderer_cmd_buffer *final_cmd_buffer; + struct renderer_cmd_buffer *backbuffer_cmd_buffer; struct xform world_view; struct blend_tick *head_free_blend_tick; @@ -155,10 +155,10 @@ struct user_startup_receipt user_startup(struct work_startup_receipt *work_sr, world_alloc(&G.world); G.world_view = XFORM_TRS(.t = V2(0, 0), .r = 0, .s = V2(PIXELS_PER_UNIT, PIXELS_PER_UNIT)); - G.world_canvas = renderer_canvas_alloc(); - G.ui_canvas = renderer_canvas_alloc(); - G.final_canvas = renderer_canvas_alloc(); - G.backbuffer_canvas = renderer_canvas_alloc(); + G.world_cmd_buffer = renderer_cmd_buffer_alloc(); + G.ui_cmd_buffer = renderer_cmd_buffer_alloc(); + G.final_cmd_buffer = renderer_cmd_buffer_alloc(); + G.backbuffer_cmd_buffer = renderer_cmd_buffer_alloc(); G.window = window; sys_window_register_event_callback(G.window, &window_event_callback); @@ -418,13 +418,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_arrow_ray(G.ui_canvas, pos, x_ray, thickness, arrowhead_len, color_x); - draw_arrow_ray(G.ui_canvas, pos, y_ray, thickness, arrowhead_len, color_y); + draw_arrow_ray(G.ui_cmd_buffer, pos, x_ray, thickness, arrowhead_len, color_x); + draw_arrow_ray(G.ui_cmd_buffer, 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_quad(G.ui_canvas, quad, color); + //draw_quad(G.ui_cmd_buffer, quad, color); } /* TODO: remove this (testing) */ @@ -441,7 +441,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_arrow_ray(G.ui_canvas, pos, vel_ray, thickness, arrow_len, color_vel); + draw_arrow_ray(G.ui_cmd_buffer, pos, vel_ray, thickness, arrow_len, color_vel); } /* ========================== * @@ -885,7 +885,7 @@ INTERNAL void user_update(void) struct v2 pos = xform_invert_mul_v2(G.world_view, V2(0, 0)); struct v2 size = xform_basis_invert_mul_v2(G.world_view, G.viewport_size); - draw_grid(G.world_canvas, RECT_FROM_V2(pos, size), color, thickness, spacing, offset); + draw_grid(G.world_cmd_buffer, RECT_FROM_V2(pos, size), color, thickness, spacing, offset); } /* ---------------------------------------------------------------------- */ @@ -969,9 +969,9 @@ INTERNAL void user_update(void) u32 color_end = RGBA_32_F(1, 0.8, 0.4, opacity_b); if (opacity_b > 0.99f) { - draw_circle(G.world_canvas, b, thickness / 2, color_end, 20); + draw_circle(G.world_cmd_buffer, b, thickness / 2, color_end, 20); } - draw_gradient_line(G.world_canvas, a, b, thickness, color_start, color_end); + draw_gradient_line(G.world_cmd_buffer, a, b, thickness, color_start, color_end); } @@ -991,7 +991,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_texture_params params = DRAW_TEXTURE_PARAMS(.sprite = sprite, .tint = ent->sprite_tint, .clip = frame.clip); - draw_quad_texture(G.world_canvas, params, quad); + draw_quad_texture(G.world_cmd_buffer, params, quad); } } @@ -1017,7 +1017,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_arrow_line(G.ui_canvas, start, end, 3, 10, RGBA_32_F(1, 1, 1, 0.5)); + draw_arrow_line(G.ui_cmd_buffer, start, end, 3, 10, RGBA_32_F(1, 1, 1, 0.5)); } #if 0 @@ -1047,16 +1047,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_quad_line(G.ui_canvas, quad, 2, quad_color); + draw_quad_line(G.ui_cmd_buffer, quad, 2, quad_color); } - draw_circle(G.ui_canvas, center, 3, point_color, 20); + draw_circle(G.ui_cmd_buffer, 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_arrow_ray(G.ui_canvas, center, ray, 2, 10, ray_color); + draw_arrow_ray(G.ui_cmd_buffer, center, ray, 2, 10, ray_color); } } } @@ -1072,13 +1072,13 @@ INTERNAL void user_update(void) /* Draw collider using support points */ //u32 detail = 64; u32 detail = 512; - draw_collider_line(G.ui_canvas, G.world_view, collider, xf, thickness, color, detail); + draw_collider_line(G.ui_cmd_buffer, 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_circle(G.ui_canvas, p, 3, COLOR_BLUE, 10); + draw_circle(G.ui_cmd_buffer, p, 3, COLOR_BLUE, 10); } } if (collider.count == 1 && collider.radius > 0) { @@ -1087,14 +1087,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_line(G.ui_canvas, start, end, thickness, color); + draw_line(G.ui_cmd_buffer, 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_circle(G.ui_canvas, p, 3, COLOR_RED, 10); + draw_circle(G.ui_cmd_buffer, p, 3, COLOR_RED, 10); } #endif } @@ -1126,7 +1126,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_circle(G.ui_canvas, xform_mul_v2(G.world_view, dbg_pt), radius, color, 10); + draw_circle(G.ui_cmd_buffer, xform_mul_v2(G.world_view, dbg_pt), radius, color, 10); } /* Draw normal */ { @@ -1136,7 +1136,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_arrow_line(G.ui_canvas, start, end, arrow_thickness, arrow_height, color); + draw_arrow_line(G.ui_cmd_buffer, start, end, arrow_thickness, arrow_height, color); } #if 0 /* Draw contact info */ @@ -1166,7 +1166,7 @@ INTERNAL void user_update(void) FMT_UINT(data->num_points)); - draw_text(G.ui_canvas, disp_font, v2_add(v2_round(xform_mul_v2(G.world_view, dbg_pt)), V2(0, offset_px)), text); + draw_text(G.ui_cmd_buffer, disp_font, v2_add(v2_round(xform_mul_v2(G.world_view, dbg_pt)), V2(0, offset_px)), text); } } #endif @@ -1193,8 +1193,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_circle(G.ui_canvas, a, radius, color, 10); - draw_circle(G.ui_canvas, b, radius, color, 10); + draw_circle(G.ui_cmd_buffer, a, radius, color, 10); + draw_circle(G.ui_cmd_buffer, b, radius, color, 10); } #endif @@ -1211,28 +1211,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_line(G.ui_canvas, a, b, thickness, color_line); - draw_circle(G.ui_canvas, a, radius, color_a, 10); - draw_circle(G.ui_canvas, b, radius, color_b, 10); + draw_line(G.ui_cmd_buffer, a, b, thickness, color_line); + draw_circle(G.ui_cmd_buffer, a, radius, color_a, 10); + draw_circle(G.ui_cmd_buffer, 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_line(G.ui_canvas, a_clipped, b_clipped, thickness, color_line_clipped); - draw_circle(G.ui_canvas, a_clipped, radius, color_a_clipped, 10); - draw_circle(G.ui_canvas, b_clipped, radius, color_b_clipped, 10); + draw_line(G.ui_cmd_buffer, a_clipped, b_clipped, thickness, color_line_clipped); + draw_circle(G.ui_cmd_buffer, a_clipped, radius, color_a_clipped, 10); + draw_circle(G.ui_cmd_buffer, 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_line(G.ui_canvas, a, b, thickness, color_line); - draw_circle(G.ui_canvas, a, radius, color_a, 10); - draw_circle(G.ui_canvas, b, radius, color_b, 10); + draw_line(G.ui_cmd_buffer, a, b, thickness, color_line); + draw_circle(G.ui_cmd_buffer, a, radius, color_a, 10); + draw_circle(G.ui_cmd_buffer, 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_line(G.ui_canvas, a_clipped, b_clipped, thickness, color_line_clipped); - draw_circle(G.ui_canvas, a_clipped, radius, color_a_clipped, 10); - draw_circle(G.ui_canvas, b_clipped, radius, color_b_clipped, 10); + draw_line(G.ui_cmd_buffer, a_clipped, b_clipped, thickness, color_line_clipped); + draw_circle(G.ui_cmd_buffer, a_clipped, radius, color_a_clipped, 10); + draw_circle(G.ui_cmd_buffer, b_clipped, radius, color_b_clipped, 10); } } @@ -1273,7 +1273,7 @@ INTERNAL void user_update(void) FMT_FLOAT_P(xform_get_rotation(e1_xf), 24)); - draw_text(G.ui_canvas, disp_font, v2_add(v2_round(xform_mul_v2(G.world_view, V2(0, 0))), V2(0, offset_px)), text); + draw_text(G.ui_cmd_buffer, disp_font, v2_add(v2_round(xform_mul_v2(G.world_view, V2(0, 0))), V2(0, offset_px)), text); } } #endif @@ -1289,8 +1289,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_poly_line(G.ui_canvas, m, true, thickness, color); - //draw_poly(G.ui_canvas, m, color); + draw_poly_line(G.ui_cmd_buffer, m, true, thickness, color); + //draw_poly(G.ui_cmd_buffer, m, color); } /* Draw cloud */ @@ -1302,7 +1302,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_circle(G.ui_canvas, p, radius, color, 10); + draw_circle(G.ui_cmd_buffer, p, radius, color, 10); } } @@ -1314,7 +1314,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_arrow_line(G.ui_canvas, start, end, arrow_thickness, arrow_height, color); + draw_arrow_line(G.ui_cmd_buffer, start, end, arrow_thickness, arrow_height, color); } /* Draw prototype */ @@ -1327,8 +1327,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_poly_line(G.ui_canvas, m, true, thickness, color); - for (u64 i = 0; i < m.count; ++i) draw_circle(G.ui_canvas, m.points[i], 10, color, 10); + draw_poly_line(G.ui_cmd_buffer, m, true, thickness, color); + for (u64 i = 0; i < m.count; ++i) draw_circle(G.ui_cmd_buffer, m.points[i], 10, color, 10); } /* Draw simplex */ @@ -1346,18 +1346,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_circle(G.ui_canvas, simplex_array.points[0], thickness * 3, color, 10); + draw_circle(G.ui_cmd_buffer, simplex_array.points[0], thickness * 3, color, 10); } if (simplex.len >= 2) { u32 color = simplex.len == 2 ? color_first : color_second; - draw_circle(G.ui_canvas, simplex_array.points[1], thickness * 3, color, 10); + draw_circle(G.ui_cmd_buffer, simplex_array.points[1], thickness * 3, color, 10); } if (simplex.len >= 3) { u32 color = color_first; - draw_circle(G.ui_canvas, simplex_array.points[2], thickness * 3, color, 10); + draw_circle(G.ui_cmd_buffer, simplex_array.points[2], thickness * 3, color, 10); } if (simplex.len >= 2) { - draw_poly_line(G.ui_canvas, simplex_array, simplex.len > 2, thickness, line_color); + draw_poly_line(G.ui_cmd_buffer, simplex_array, simplex.len > 2, thickness, line_color); } } } @@ -1374,7 +1374,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_arrow_line(G.ui_canvas, start, end, thickness, arrow_height, color); + draw_arrow_line(G.ui_cmd_buffer, start, end, thickness, arrow_height, color); } /* Draw camera rect */ @@ -1386,7 +1386,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_quad_line(G.ui_canvas, quad, thickness, color); + draw_quad_line(G.ui_cmd_buffer, quad, thickness, color); } arena_temp_end(temp); @@ -1405,7 +1405,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_quad_texture(G.ui_canvas, DRAW_TEXTURE_PARAMS(.sprite = crosshair_tag, .tint = tint), quad); + draw_quad_texture(G.ui_cmd_buffer, DRAW_TEXTURE_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)); @@ -1524,65 +1524,65 @@ INTERNAL void user_update(void) if (font) { struct temp_arena temp = arena_temp_begin(scratch.arena); - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("time: %F"), FMT_FLOAT((f64)G.time))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("time: %F"), FMT_FLOAT((f64)G.time))); pos.y += spacing; - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("world time: %F"), FMT_FLOAT((f64)G.world.time))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("world time: %F"), FMT_FLOAT((f64)G.world.time))); pos.y += spacing; - //draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("time - world time: %F"), FMT_FLOAT((f64)G.time - (f64)G.world.time))); + //draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("time - world time: %F"), FMT_FLOAT((f64)G.time - (f64)G.world.time))); //pos.y += spacing; - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("entities: %F/%F"), FMT_UINT(G.world.entity_store->allocated), FMT_UINT(G.world.entity_store->reserved))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("entities: %F/%F"), FMT_UINT(G.world.entity_store->allocated), FMT_UINT(G.world.entity_store->reserved))); pos.y += spacing; - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("screen_size: (%F, %F)"), FMT_FLOAT((f64)G.screen_size.x), FMT_FLOAT((f64)G.screen_size.y))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("screen_size: (%F, %F)"), FMT_FLOAT((f64)G.screen_size.x), FMT_FLOAT((f64)G.screen_size.y))); pos.y += spacing; - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("screen_cursor: (%F, %F)"), FMT_FLOAT((f64)G.screen_cursor.x), FMT_FLOAT((f64)G.screen_cursor.y))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("screen_cursor: (%F, %F)"), FMT_FLOAT((f64)G.screen_cursor.x), FMT_FLOAT((f64)G.screen_cursor.y))); pos.y += spacing; - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("viewport_screen_offset: (%F, %F)"), FMT_FLOAT((f64)G.viewport_screen_offset.x), FMT_FLOAT((f64)G.viewport_screen_offset.y))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("viewport_screen_offset: (%F, %F)"), FMT_FLOAT((f64)G.viewport_screen_offset.x), FMT_FLOAT((f64)G.viewport_screen_offset.y))); pos.y += spacing; - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("viewport_size: (%F, %F)"), FMT_FLOAT((f64)G.viewport_size.x), FMT_FLOAT((f64)G.viewport_size.y))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("viewport_size: (%F, %F)"), FMT_FLOAT((f64)G.viewport_size.x), FMT_FLOAT((f64)G.viewport_size.y))); pos.y += spacing; - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("viewport_center: (%F, %F)"), FMT_FLOAT((f64)G.viewport_center.x), FMT_FLOAT((f64)G.viewport_center.y))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("viewport_center: (%F, %F)"), FMT_FLOAT((f64)G.viewport_center.x), FMT_FLOAT((f64)G.viewport_center.y))); pos.y += spacing; - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("viewport_cursor: (%F, %F)"), FMT_FLOAT((f64)G.viewport_cursor.x), FMT_FLOAT((f64)G.viewport_cursor.y))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("viewport_cursor: (%F, %F)"), FMT_FLOAT((f64)G.viewport_cursor.x), FMT_FLOAT((f64)G.viewport_cursor.y))); pos.y += spacing; - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("world_view.og: (%F, %F)"), FMT_FLOAT((f64)G.world_view.og.x), FMT_FLOAT((f64)G.world_view.og.y))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("world_view.og: (%F, %F)"), FMT_FLOAT((f64)G.world_view.og.x), FMT_FLOAT((f64)G.world_view.og.y))); pos.y += spacing; - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("world_view rotation: %F"), FMT_FLOAT((f64)xform_get_rotation(G.world_view)))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("world_view rotation: %F"), FMT_FLOAT((f64)xform_get_rotation(G.world_view)))); pos.y += spacing; - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("world_view scale: (%F, %F)"), FMT_FLOAT((f64)xform_get_scale(G.world_view).x), FMT_FLOAT((f64)xform_get_scale(G.world_view).x))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("world_view scale: (%F, %F)"), FMT_FLOAT((f64)xform_get_scale(G.world_view).x), FMT_FLOAT((f64)xform_get_scale(G.world_view).x))); pos.y += spacing; - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("world_cursor: (%F, %F)"), FMT_FLOAT((f64)G.world_cursor.x), FMT_FLOAT((f64)G.world_cursor.y))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("world_cursor: (%F, %F)"), FMT_FLOAT((f64)G.world_cursor.x), FMT_FLOAT((f64)G.world_cursor.y))); pos.y += spacing; - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("debug_camera: %F"), FMT_STR(G.debug_camera ? STR("true") : STR("false")))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("debug_camera: %F"), FMT_STR(G.debug_camera ? STR("true") : STR("false")))); pos.y += spacing; struct v2 player_linear_vel = entity_find_first_match_one(store, ENTITY_PROP_PLAYER_CONTROLLED)->linear_velocity; - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("player linear velocity: (%F, %F)"), FMT_FLOAT_P((f64)player_linear_vel.x, 12), FMT_FLOAT_P((f64)player_linear_vel.y, 12))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("player linear velocity: (%F, %F)"), FMT_FLOAT_P((f64)player_linear_vel.x, 12), FMT_FLOAT_P((f64)player_linear_vel.y, 12))); pos.y += spacing; f32 player_angular_vel = entity_find_first_match_one(store, ENTITY_PROP_PLAYER_CONTROLLED)->angular_velocity; - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("player angular velocity: %F"), FMT_FLOAT_P((f64)player_angular_vel, 12))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("player angular velocity: %F"), FMT_FLOAT_P((f64)player_angular_vel, 12))); pos.y += spacing; struct v2 player_pos = entity_get_xform(entity_find_first_match_one(store, ENTITY_PROP_PLAYER_CONTROLLED)).og; - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("player pos: (%F, %F)"), FMT_FLOAT_P((f64)player_pos.x, 12), FMT_FLOAT_P((f64)player_pos.y, 12))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("player pos: (%F, %F)"), FMT_FLOAT_P((f64)player_pos.x, 12), FMT_FLOAT_P((f64)player_pos.y, 12))); pos.y += spacing; #if COLLIDER_DEBUG - draw_text(G.ui_canvas, font, pos, string_format(temp.arena, STR("collider gjk steps: %F"), FMT_UINT(collider_debug_steps))); + draw_text(G.ui_cmd_buffer, font, pos, string_format(temp.arena, STR("collider gjk steps: %F"), FMT_UINT(collider_debug_steps))); pos.y += spacing; #endif @@ -1604,8 +1604,7 @@ INTERNAL void user_update(void) struct rect backbuffer_viewport = RECT_FROM_V2(V2(0, 0), G.screen_size); /* Allocate rt textures */ - struct v2 final_rt_resolution = G.viewport_size; - struct v2 ui_rt_resolution = final_rt_resolution; + struct v2 ui_rt_resolution = G.viewport_size; struct v2 world_rt_resolution = V2(target_viewport.width + target_viewport.x, target_viewport.height + target_viewport.y); { /* World rt */ @@ -1613,25 +1612,24 @@ INTERNAL void user_update(void) if (!renderer_handle_is_nil(G.world_rt)) { renderer_texture_release(G.world_rt); } - G.world_rt_resolution = world_rt_resolution; - G.world_rt = renderer_texture_target_alloc(G.world_rt_resolution); + G.world_rt = renderer_texture_target_alloc(world_rt_resolution); } /* Ui rt */ if (renderer_handle_is_nil(G.ui_rt) || !v2_eq(G.ui_rt_resolution, ui_rt_resolution)) { if (!renderer_handle_is_nil(G.ui_rt)) { renderer_texture_release(G.ui_rt); } - G.ui_rt_resolution = ui_rt_resolution; - G.ui_rt = renderer_texture_target_alloc(G.ui_rt_resolution); + G.ui_rt = renderer_texture_target_alloc(ui_rt_resolution); } /* Final rt */ - if (renderer_handle_is_nil(G.final_rt) || !v2_eq(G.final_rt_resolution, final_rt_resolution)) { + if (renderer_handle_is_nil(G.final_rt) || !v2_eq(G.ui_rt_resolution, ui_rt_resolution)) { if (!renderer_handle_is_nil(G.final_rt)) { renderer_texture_release(G.final_rt); } - G.final_rt_resolution = final_rt_resolution; - G.final_rt = renderer_texture_target_alloc(G.final_rt_resolution); + G.final_rt = renderer_texture_target_alloc(ui_rt_resolution); } + G.world_rt_resolution = world_rt_resolution; + G.ui_rt_resolution = ui_rt_resolution; } if (!v2_eq(G.backbuffer_size, G.screen_size)) { G.backbuffer_size = G.screen_size; @@ -1642,30 +1640,30 @@ INTERNAL void user_update(void) /* Draw world texture to final */ { struct draw_texture_params params = DRAW_TEXTURE_PARAMS(.texture = G.world_rt); - struct quad quad = quad_from_rect(RECT_FROM_V2(V2(0, 0), final_rt_resolution)); - draw_quad_texture(G.final_canvas, params, quad); + struct quad quad = quad_from_rect(RECT_FROM_V2(V2(0, 0), ui_rt_resolution)); + draw_quad_texture(G.final_cmd_buffer, params, quad); } /* Draw ui texture to final */ { struct draw_texture_params params = DRAW_TEXTURE_PARAMS(.texture = G.ui_rt); - struct quad quad = quad_from_rect(RECT_FROM_V2(V2(0, 0), final_rt_resolution)); - draw_quad_texture(G.final_canvas, params, quad); + struct quad quad = quad_from_rect(RECT_FROM_V2(V2(0, 0), ui_rt_resolution)); + draw_quad_texture(G.final_cmd_buffer, params, quad); } /* Draw final texture to backbuffer */ { struct draw_texture_params params = DRAW_TEXTURE_PARAMS(.texture = G.final_rt); struct quad quad = quad_from_rect(RECT_FROM_V2(G.viewport_screen_offset, G.viewport_size)); - draw_quad_texture(G.backbuffer_canvas, params, quad); + draw_quad_texture(G.backbuffer_cmd_buffer, params, quad); } } - /* Send canvases to GPU */ - renderer_canvas_send_to_gpu(G.world_canvas); - renderer_canvas_send_to_gpu(G.ui_canvas); - renderer_canvas_send_to_gpu(G.final_canvas); - renderer_canvas_send_to_gpu(G.backbuffer_canvas); + /* Send cmd buffers to GPU */ + renderer_cmd_buffer_send_to_gpu(G.world_cmd_buffer); + renderer_cmd_buffer_send_to_gpu(G.ui_cmd_buffer); + renderer_cmd_buffer_send_to_gpu(G.final_cmd_buffer); + renderer_cmd_buffer_send_to_gpu(G.backbuffer_cmd_buffer); /* Execute render cmds */ { @@ -1676,16 +1674,16 @@ INTERNAL void user_update(void) renderer_clear_backbuffer(RGBA_32_F(0, 0, 0, 1)); /* Render to world texture */ - renderer_render_to_texture(G.world_rt, G.world_canvas, G.world_view, target_viewport, sprite_frame_scope); + renderer_render_to_texture(G.world_rt, G.world_cmd_buffer, G.world_view, target_viewport, sprite_frame_scope); /* Render to UI texture */ - renderer_render_to_texture(G.ui_rt, G.ui_canvas, XFORM_IDENT, target_viewport, sprite_frame_scope); + renderer_render_to_texture(G.ui_rt, G.ui_cmd_buffer, XFORM_IDENT, target_viewport, sprite_frame_scope); /* Render to final texture */ - renderer_render_to_texture(G.final_rt, G.final_canvas, XFORM_IDENT, target_viewport, sprite_frame_scope); + renderer_render_to_texture(G.final_rt, G.final_cmd_buffer, XFORM_IDENT, target_viewport, sprite_frame_scope); /* Render to backbuffer */ - renderer_render_to_backbuffer(G.backbuffer_canvas, XFORM_IDENT, backbuffer_viewport, sprite_frame_scope); + renderer_render_to_backbuffer(G.backbuffer_cmd_buffer, XFORM_IDENT, backbuffer_viewport, sprite_frame_scope); } /* Present */