jacob/power_play
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rename gpu_cmd_store -> gpu_cmd_list

Browse Source
This commit is contained in:
jacob 2025-06-07 20:26:20 -05:00
parent 74609cdb3c
commit df4eb24fe3
6 changed files with 243 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
src/draw.c
View File

@ -28,19 +28,19 @@ struct draw_startup_receipt draw_startup(struct gpu_startup_receipt *gpu_sr,
* View * View
* ========================== */ * ========================== */
void draw_set_view(struct gpu_handle store, struct xform xf) void draw_set_view(struct gpu_handle cmd_list, struct xform xf)
{ {
struct gpu_cmd_params cmd = ZI; struct gpu_cmd_params cmd = ZI;
cmd.kind = GPU_CMD_KIND_DRAW_VIEW; cmd.kind = GPU_CMD_KIND_DRAW_VIEW;
cmd.view.xf = xf; cmd.view.xf = xf;
gpu_push_cmd(store, cmd); gpu_push_cmd(cmd_list, cmd);
} }
/* ========================== * /* ========================== *
* Texture * Texture
* ========================== */ * ========================== */
void draw_texture(struct gpu_handle store, struct draw_texture_params params) void draw_texture(struct gpu_handle cmd_list, struct draw_texture_params params)
{ {
struct gpu_cmd_params cmd = ZI; struct gpu_cmd_params cmd = ZI;
cmd.kind = GPU_CMD_KIND_DRAW_TEXTURE; cmd.kind = GPU_CMD_KIND_DRAW_TEXTURE;
@ -50,25 +50,25 @@ void draw_texture(struct gpu_handle store, struct draw_texture_params params)
cmd.texture.clip = params.clip; cmd.texture.clip = params.clip;
cmd.texture.tint = params.tint; cmd.texture.tint = params.tint;
cmd.texture.emittance = params.emittance; cmd.texture.emittance = params.emittance;
gpu_push_cmd(store, cmd); gpu_push_cmd(cmd_list, cmd);
} }
/* ========================== * /* ========================== *
* Fill shapes * Fill shapes
* ========================== */ * ========================== */
void draw_poly_ex(struct gpu_handle store, struct v2_array vertices, struct gpu_indices indices, u32 color) void draw_poly_ex(struct gpu_handle cmd_list, struct v2_array vertices, struct gpu_indices indices, u32 color)
{ {
struct gpu_cmd_params cmd = ZI; struct gpu_cmd_params cmd = ZI;
cmd.kind = GPU_CMD_KIND_DRAW_MESH; cmd.kind = GPU_CMD_KIND_DRAW_MESH;
cmd.mesh.vertices = vertices; cmd.mesh.vertices = vertices;
cmd.mesh.indices = indices; cmd.mesh.indices = indices;
cmd.mesh.color = color; cmd.mesh.color = color;
gpu_push_cmd(store, cmd); gpu_push_cmd(cmd_list, cmd);
} }
/* Draws a filled polygon using triangles in a fan pattern */ /* Draws a filled polygon using triangles in a fan pattern */
void draw_poly(struct gpu_handle store, struct v2_array vertices, u32 color) void draw_poly(struct gpu_handle cmd_list, struct v2_array vertices, u32 color)
{ {
if (vertices.count >= 3) { if (vertices.count >= 3) {
struct temp_arena scratch = scratch_begin_no_conflict(); struct temp_arena scratch = scratch_begin_no_conflict();
@ -88,13 +88,13 @@ void draw_poly(struct gpu_handle store, struct v2_array vertices, u32 color)
indices.indices[tri_offset + 2] = (i + 2); indices.indices[tri_offset + 2] = (i + 2);
} }
draw_poly_ex(store, vertices, indices, color); draw_poly_ex(cmd_list, vertices, indices, color);
scratch_end(scratch); scratch_end(scratch);
} }
} }
void draw_circle(struct gpu_handle store, struct v2 pos, f32 radius, u32 color, u32 detail) void draw_circle(struct gpu_handle cmd_list, struct v2 pos, f32 radius, u32 color, u32 detail)
{ {
struct temp_arena scratch = scratch_begin_no_conflict(); struct temp_arena scratch = scratch_begin_no_conflict();
@ -111,12 +111,12 @@ void draw_circle(struct gpu_handle store, struct v2 pos, f32 radius, u32 color,
.points = points, .points = points,
.count = detail .count = detail
}; };
draw_poly(store, vertices, color); draw_poly(cmd_list, vertices, color);
scratch_end(scratch); scratch_end(scratch);
} }
void draw_quad(struct gpu_handle store, struct quad quad, u32 color) void draw_quad(struct gpu_handle cmd_list, struct quad quad, u32 color)
{ {
LOCAL_PERSIST u16 indices_array[6] = { LOCAL_PERSIST u16 indices_array[6] = {
0, 1, 2, 0, 1, 2,
@ -124,57 +124,57 @@ void draw_quad(struct gpu_handle store, struct quad quad, u32 color)
}; };
struct v2_array vertices = { .count = 4, .points = quad.e }; struct v2_array vertices = { .count = 4, .points = quad.e };
struct gpu_indices indices = { .count = 6, .indices = indices_array }; struct gpu_indices indices = { .count = 6, .indices = indices_array };
draw_poly_ex(store, vertices, indices, color); draw_poly_ex(cmd_list, vertices, indices, color);
} }
/* ========================== * /* ========================== *
* Line shapes * Line shapes
* ========================== */ * ========================== */
void draw_gradient_line(struct gpu_handle store, struct v2 start, struct v2 end, f32 thickness, u32 start_color, u32 end_color) void draw_gradient_line(struct gpu_handle cmd_list, struct v2 start, struct v2 end, f32 thickness, u32 start_color, u32 end_color)
{ {
#if 0 #if 0
struct quad quad = quad_from_line(start, end, thickness); struct quad quad = quad_from_line(start, end, thickness);
draw_texture(store, DRAW_TEXTURE_PARAMS(.texture = G.solid_white_texture, .tint0 = start_color, .tint1 = end_color, .quad = quad)); draw_texture(cmd_list, DRAW_TEXTURE_PARAMS(.texture = G.solid_white_texture, .tint0 = start_color, .tint1 = end_color, .quad = quad));
#else #else
/* Placeholder */ /* Placeholder */
(UNUSED)end_color; (UNUSED)end_color;
struct quad quad = quad_from_line(start, end, thickness); struct quad quad = quad_from_line(start, end, thickness);
draw_quad(store, quad, start_color); draw_quad(cmd_list, quad, start_color);
#endif #endif
} }
void draw_line(struct gpu_handle store, struct v2 start, struct v2 end, f32 thickness, u32 color) void draw_line(struct gpu_handle cmd_list, struct v2 start, struct v2 end, f32 thickness, u32 color)
{ {
struct quad quad = quad_from_line(start, end, thickness); struct quad quad = quad_from_line(start, end, thickness);
draw_quad(store, quad, color); draw_quad(cmd_list, quad, color);
} }
void draw_ray(struct gpu_handle store, struct v2 pos, struct v2 rel, f32 thickness, u32 color) void draw_ray(struct gpu_handle cmd_list, struct v2 pos, struct v2 rel, f32 thickness, u32 color)
{ {
struct quad quad = quad_from_ray(pos, rel, thickness); struct quad quad = quad_from_ray(pos, rel, thickness);
draw_quad(store, quad, color); draw_quad(cmd_list, quad, color);
} }
void draw_poly_line(struct gpu_handle store, struct v2_array points, b32 loop, f32 thickness, u32 color) void draw_poly_line(struct gpu_handle cmd_list, struct v2_array points, b32 loop, f32 thickness, u32 color)
{ {
if (points.count >= 2) { if (points.count >= 2) {
for (u64 i = 1; i < points.count; ++i) { for (u64 i = 1; i < points.count; ++i) {
struct v2 p1 = points.points[i - 1]; struct v2 p1 = points.points[i - 1];
struct v2 p2 = points.points[i]; struct v2 p2 = points.points[i];
struct quad q = quad_from_line(p1, p2, thickness); struct quad q = quad_from_line(p1, p2, thickness);
draw_quad(store, q, color); draw_quad(cmd_list, q, color);
} }
if (loop && points.count > 2) { if (loop && points.count > 2) {
struct v2 p1 = points.points[points.count - 1]; struct v2 p1 = points.points[points.count - 1];
struct v2 p2 = points.points[0]; struct v2 p2 = points.points[0];
struct quad q = quad_from_line(p1, p2, thickness); struct quad q = quad_from_line(p1, p2, thickness);
draw_quad(store, q, color); draw_quad(cmd_list, q, color);
} }
} }
} }
void draw_circle_line(struct gpu_handle store, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail) void draw_circle_line(struct gpu_handle cmd_list, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail)
{ {
struct temp_arena scratch = scratch_begin_no_conflict(); struct temp_arena scratch = scratch_begin_no_conflict();
@ -191,19 +191,19 @@ void draw_circle_line(struct gpu_handle store, struct v2 pos, f32 radius, f32 th
.points = points, .points = points,
.count = detail .count = detail
}; };
draw_poly_line(store, a, true, thickness, color); draw_poly_line(cmd_list, a, true, thickness, color);
scratch_end(scratch); scratch_end(scratch);
} }
void draw_quad_line(struct gpu_handle store, struct quad quad, f32 thickness, u32 color) void draw_quad_line(struct gpu_handle cmd_list, struct quad quad, f32 thickness, u32 color)
{ {
struct v2 points[] = { quad.p0, quad.p1, quad.p2, quad.p3 }; struct v2 points[] = { quad.p0, quad.p1, quad.p2, quad.p3 };
struct v2_array a = { .points = points, .count = ARRAY_COUNT(points) }; struct v2_array a = { .points = points, .count = ARRAY_COUNT(points) };
draw_poly_line(store, a, true, thickness, color); draw_poly_line(cmd_list, a, true, thickness, color);
} }
void draw_arrow_line(struct gpu_handle store, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 color) void draw_arrow_line(struct gpu_handle cmd_list, 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 */ const f32 head_width_ratio = 0.5f; /* Width of arrowhead relative to its length */
@ -227,19 +227,19 @@ void draw_arrow_line(struct gpu_handle store, struct v2 start, struct v2 end, f3
.points = head_points, .points = head_points,
.count = ARRAY_COUNT(head_points) .count = ARRAY_COUNT(head_points)
}; };
draw_poly(store, head_points_v2_array, color); draw_poly(cmd_list, head_points_v2_array, color);
struct quad line_quad = quad_from_line(start, head_start, thickness); struct quad line_quad = quad_from_line(start, head_start, thickness);
draw_quad(store, line_quad, color); draw_quad(cmd_list, line_quad, color);
} }
void draw_arrow_ray(struct gpu_handle store, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 color) void draw_arrow_ray(struct gpu_handle cmd_list, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 color)
{ {
struct v2 end = v2_add(pos, rel); struct v2 end = v2_add(pos, rel);
draw_arrow_line(store, pos, end, thickness, arrowhead_height, color); draw_arrow_line(cmd_list, pos, end, thickness, arrowhead_height, color);
} }
void draw_collider_line(struct gpu_handle store, struct xform draw_xf, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 color, u32 detail) void draw_collider_line(struct gpu_handle cmd_list, 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(); struct temp_arena scratch = scratch_begin_no_conflict();
@ -253,7 +253,7 @@ void draw_collider_line(struct gpu_handle store, struct xform draw_xf, struct co
} }
struct v2_array poly = { .points = points, .count = detail }; struct v2_array poly = { .points = points, .count = detail };
draw_poly_line(store, poly, true, thickness, color); draw_poly_line(cmd_list, poly, true, thickness, color);
scratch_end(scratch); scratch_end(scratch);
} }
@ -262,7 +262,7 @@ void draw_collider_line(struct gpu_handle store, struct xform draw_xf, struct co
* Grid * Grid
* ========================== */ * ========================== */
void draw_grid(struct gpu_handle store, struct xform xf, u32 bg0_color, u32 bg1_color, u32 line_color, u32 x_color, u32 y_color, f32 thickness, f32 spacing, struct v2 offset) void draw_grid(struct gpu_handle cmd_list, struct xform xf, u32 bg0_color, u32 bg1_color, u32 line_color, u32 x_color, u32 y_color, f32 thickness, f32 spacing, struct v2 offset)
{ {
struct gpu_cmd_params cmd = ZI; struct gpu_cmd_params cmd = ZI;
cmd.kind = GPU_CMD_KIND_DRAW_GRID; cmd.kind = GPU_CMD_KIND_DRAW_GRID;
@ -275,7 +275,7 @@ void draw_grid(struct gpu_handle store, struct xform xf, u32 bg0_color, u32 bg1_
cmd.grid.line_thickness = thickness; cmd.grid.line_thickness = thickness;
cmd.grid.line_spacing = spacing; cmd.grid.line_spacing = spacing;
cmd.grid.offset = offset; cmd.grid.offset = offset;
gpu_push_cmd(store, cmd); gpu_push_cmd(cmd_list, cmd);
} }
/* ========================== * /* ========================== *
@ -283,7 +283,7 @@ void draw_grid(struct gpu_handle store, struct xform xf, u32 bg0_color, u32 bg1_
* ========================== */ * ========================== */
/* Returns the rect of the text area */ /* Returns the rect of the text area */
struct rect draw_text(struct gpu_handle store, struct draw_text_params params) struct rect draw_text(struct gpu_handle cmd_list, struct draw_text_params params)
{ {
struct temp_arena scratch = scratch_begin_no_conflict(); struct temp_arena scratch = scratch_begin_no_conflict();
@ -451,7 +451,7 @@ struct rect draw_text(struct gpu_handle store, struct draw_text_params params)
struct v2 pos = V2(draw_pos.x + tg->off_x, draw_pos.y + tg->off_y); struct v2 pos = V2(draw_pos.x + tg->off_x, draw_pos.y + tg->off_y);
struct v2 size = V2(tg->width, tg->height); struct v2 size = V2(tg->width, tg->height);
struct xform xf = xform_from_rect(RECT_FROM_V2(pos, size)); struct xform xf = xform_from_rect(RECT_FROM_V2(pos, size));
draw_texture(store, DRAW_TEXTURE_PARAMS(.xf = xf, .texture = params.font->texture, .tint = params.color, .clip = tg->clip)); draw_texture(cmd_list, DRAW_TEXTURE_PARAMS(.xf = xf, .texture = params.font->texture, .tint = params.color, .clip = tg->clip));
draw_pos.x += tg->advance; draw_pos.x += tg->advance;
} }

34
src/draw.h
View File

@ -14,7 +14,7 @@ struct draw_startup_receipt draw_startup(struct gpu_startup_receipt *gpu_sr,
* View * View
* ========================== */ * ========================== */
void draw_set_view(struct gpu_handle store, struct xform xf); void draw_set_view(struct gpu_handle cmd_list, struct xform xf);
/* ========================== * /* ========================== *
* Texture * Texture
@ -35,47 +35,47 @@ struct draw_texture_params {
f32 emittance; f32 emittance;
}; };
void draw_texture(struct gpu_handle store, struct draw_texture_params params); void draw_texture(struct gpu_handle cmd_list, struct draw_texture_params params);
/* ========================== * /* ========================== *
* Fill shapes * Fill shapes
* ========================== */ * ========================== */
void draw_poly_ex(struct gpu_handle store, struct v2_array vertices, struct gpu_indices indices, u32 color); void draw_poly_ex(struct gpu_handle cmd_list, struct v2_array vertices, struct gpu_indices indices, u32 color);
void draw_poly(struct gpu_handle store, struct v2_array points, u32 color); void draw_poly(struct gpu_handle cmd_list, struct v2_array points, u32 color);
void draw_circle(struct gpu_handle store, struct v2 pos, f32 radius, u32 color, u32 detail); void draw_circle(struct gpu_handle cmd_list, struct v2 pos, f32 radius, u32 color, u32 detail);
void draw_quad(struct gpu_handle store, struct quad quad, u32 color); void draw_quad(struct gpu_handle cmd_list, struct quad quad, u32 color);
/* ========================== * /* ========================== *
* Line shapes * Line shapes
* ========================== */ * ========================== */
void draw_gradient_line(struct gpu_handle store, struct v2 start, struct v2 end, f32 thickness, u32 start_color, u32 end_color); void draw_gradient_line(struct gpu_handle cmd_list, struct v2 start, struct v2 end, f32 thickness, u32 start_color, u32 end_color);
void draw_line(struct gpu_handle store, struct v2 start, struct v2 end, f32 thickness, u32 color); void draw_line(struct gpu_handle cmd_list, struct v2 start, struct v2 end, f32 thickness, u32 color);
void draw_ray(struct gpu_handle store, struct v2 pos, struct v2 rel, f32 thickness, u32 color); void draw_ray(struct gpu_handle cmd_list, struct v2 pos, struct v2 rel, f32 thickness, u32 color);
void draw_poly_line(struct gpu_handle store, struct v2_array points, b32 loop, f32 thickness, u32 color); void draw_poly_line(struct gpu_handle cmd_list, struct v2_array points, b32 loop, f32 thickness, u32 color);
void draw_circle_line(struct gpu_handle store, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail); void draw_circle_line(struct gpu_handle cmd_list, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail);
void draw_quad_line(struct gpu_handle store, struct quad quad, f32 thickness, u32 color); void draw_quad_line(struct gpu_handle cmd_list, struct quad quad, f32 thickness, u32 color);
void draw_arrow_line(struct gpu_handle store, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 color); void draw_arrow_line(struct gpu_handle cmd_list, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 color);
void draw_arrow_ray(struct gpu_handle store, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 color); void draw_arrow_ray(struct gpu_handle cmd_list, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 color);
void draw_collider_line(struct gpu_handle store, struct xform draw_xf, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 color, u32 detail); void draw_collider_line(struct gpu_handle cmd_list, struct xform draw_xf, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 color, u32 detail);
/* ========================== * /* ========================== *
* Grid * Grid
* ========================== */ * ========================== */
void draw_grid(struct gpu_handle store, struct xform xf, u32 bg0_color, u32 bg1_color, u32 line_color, u32 x_color, u32 y_color, f32 thickness, f32 spacing, struct v2 offset); void draw_grid(struct gpu_handle cmd_list, struct xform xf, u32 bg0_color, u32 bg1_color, u32 line_color, u32 x_color, u32 y_color, f32 thickness, f32 spacing, struct v2 offset);
/* ========================== * /* ========================== *
* Text * Text
@ -123,6 +123,6 @@ struct draw_text_params {
struct string str; struct string str;
}; };
struct rect draw_text(struct gpu_handle store, struct draw_text_params params); struct rect draw_text(struct gpu_handle cmd_list, struct draw_text_params params);
#endif #endif

18
src/gpu.h
View File

@ -27,6 +27,11 @@ struct gpu_handle {
}; };
}; };
struct gpu_handle_array {
u64 count;
struct gpu_handle **handles;
};
void gpu_release(struct gpu_handle handle); void gpu_release(struct gpu_handle handle);
/* ========================== * /* ========================== *
@ -108,23 +113,18 @@ struct gpu_cmd_params {
}; };
}; };
struct gpu_handle gpu_cmd_store_alloc(void); struct gpu_handle gpu_cmd_list_alloc(void);
void gpu_push_cmd(struct gpu_handle gpu_cmd_store, struct gpu_cmd_params params); void gpu_push_cmd(struct gpu_handle gpu_cmd_list, struct gpu_cmd_params params);
void gpu_submit_cmds(struct gpu_handle gpu_cmd_store); void gpu_submit_cmds(struct gpu_handle gpu_cmd_list);
/* ========================== * /* ========================== *
* Dispatch * Dispatch
* ========================== */ * ========================== */
struct gpu_dispatch_cmds_array {
u64 count;
struct gpu_handle **stores;
};
struct gpu_dispatch_params { struct gpu_dispatch_params {
struct gpu_dispatch_cmds_array cmds_array; struct gpu_handle_array cmd_lists;
struct gpu_handle draw_target; struct gpu_handle draw_target;
struct rect draw_target_viewport; struct rect draw_target_viewport;
}; };

192
src/gpu_dx11.c
View File

@ -60,7 +60,7 @@ enum dx11_shader_kind {
enum dx11_handle_kind { enum dx11_handle_kind {
DX11_HANDLE_KIND_NONE, DX11_HANDLE_KIND_NONE,
DX11_HANDLE_KIND_TEXTURE, DX11_HANDLE_KIND_TEXTURE,
DX11_HANDLE_KIND_CMD_STORE, DX11_HANDLE_KIND_CMD_LIST,
DX11_HANDLE_KIND_DISPATCH_STATE, DX11_HANDLE_KIND_DISPATCH_STATE,
NUM_DX11_HANDLE_KINDS NUM_DX11_HANDLE_KINDS
@ -149,7 +149,7 @@ struct dx11_cmd {
struct dx11_cmd *next; struct dx11_cmd *next;
}; };
struct dx11_cmd_store { struct dx11_cmd_list {
struct dx11_handle_header header; struct dx11_handle_header header;
/* Commands w/ data still in cpu memory */ /* Commands w/ data still in cpu memory */
@ -178,7 +178,7 @@ struct dx11_cmd_store {
} test; } test;
} buffers; } buffers;
struct dx11_cmd_store *next_free; struct dx11_cmd_list *next_free;
}; };
struct dx11_texture { struct dx11_texture {
@ -236,10 +236,10 @@ GLOBAL struct {
struct arena buffers_arena; struct arena buffers_arena;
struct dx11_buffer *first_free_buffer; struct dx11_buffer *first_free_buffer;
/* Cmd store pool */ /* Cmd list pool */
struct sys_mutex cmd_stores_mutex; struct sys_mutex handles_mutex;
struct arena cmd_stores_arena; struct arena handles_arena;
struct dx11_cmd_store *first_free_cmd_store; struct dx11_cmd_list *first_free_cmd_list;
/* Dispatch state pool */ /* Dispatch state pool */
struct sys_mutex dispatch_states_mutex; struct sys_mutex dispatch_states_mutex;
@ -284,9 +284,9 @@ struct gpu_startup_receipt gpu_startup(struct work_startup_receipt *work_sr, str
G.buffers_mutex = sys_mutex_alloc(); G.buffers_mutex = sys_mutex_alloc();
G.buffers_arena = arena_alloc(GIGABYTE(64)); G.buffers_arena = arena_alloc(GIGABYTE(64));
/* Initialize cmd store pool */ /* Initialize cmd list pool */
G.cmd_stores_mutex = sys_mutex_alloc(); G.handles_mutex = sys_mutex_alloc();
G.cmd_stores_arena = arena_alloc(GIGABYTE(64)); G.handles_arena = arena_alloc(GIGABYTE(64));
/* Initialize dispatch state pool */ /* Initialize dispatch state pool */
G.dispatch_states_mutex = sys_mutex_alloc(); G.dispatch_states_mutex = sys_mutex_alloc();
@ -560,7 +560,7 @@ void gpu_release(struct gpu_handle handle)
dx11_texture_release((struct dx11_texture *)header); dx11_texture_release((struct dx11_texture *)header);
} break; } break;
case DX11_HANDLE_KIND_CMD_STORE: case DX11_HANDLE_KIND_CMD_LIST:
{ {
/* TODO */ /* TODO */
ASSERT(false); ASSERT(false);
@ -1274,41 +1274,41 @@ INTERNAL void dx11_buffer_submit(struct dx11_buffer *buffer)
} }
/* ========================== * /* ========================== *
* Cmd store * Cmd list
* ========================== */ * ========================== */
struct gpu_handle gpu_cmd_store_alloc(void) struct gpu_handle gpu_cmd_list_alloc(void)
{ {
__prof; __prof;
struct dx11_cmd_store *store = NULL; struct dx11_cmd_list *list = NULL;
{ {
struct arena cpu_cmds_arena = ZI; struct arena cpu_cmds_arena = ZI;
struct arena gpu_cmds_arena = ZI; struct arena gpu_cmds_arena = ZI;
{ {
struct sys_lock lock = sys_mutex_lock_e(&G.cmd_stores_mutex); struct sys_lock lock = sys_mutex_lock_e(&G.handles_mutex);
if (G.first_free_cmd_store) { if (G.first_free_cmd_list) {
store = G.first_free_cmd_store; list = G.first_free_cmd_list;
G.first_free_cmd_store = store->next_free; G.first_free_cmd_list = list->next_free;
cpu_cmds_arena = store->cpu_cmds_arena; cpu_cmds_arena = list->cpu_cmds_arena;
gpu_cmds_arena = store->gpu_cmds_arena; gpu_cmds_arena = list->gpu_cmds_arena;
} else { } else {
store = arena_push_no_zero(&G.cmd_stores_arena, struct dx11_cmd_store); list = arena_push_no_zero(&G.handles_arena, struct dx11_cmd_list);
} }
sys_mutex_unlock(&lock); sys_mutex_unlock(&lock);
} }
MEMZERO_STRUCT(store); MEMZERO_STRUCT(list);
if (!cpu_cmds_arena.base) { if (!cpu_cmds_arena.base) {
cpu_cmds_arena = arena_alloc(GIGABYTE(64)); cpu_cmds_arena = arena_alloc(GIGABYTE(64));
} }
if (!gpu_cmds_arena.base) { if (!gpu_cmds_arena.base) {
gpu_cmds_arena = arena_alloc(GIGABYTE(64)); gpu_cmds_arena = arena_alloc(GIGABYTE(64));
} }
store->cpu_cmds_arena = cpu_cmds_arena; list->cpu_cmds_arena = cpu_cmds_arena;
store->gpu_cmds_arena = gpu_cmds_arena; list->gpu_cmds_arena = gpu_cmds_arena;
arena_reset(&store->cpu_cmds_arena); arena_reset(&list->cpu_cmds_arena);
arena_reset(&store->gpu_cmds_arena); arena_reset(&list->gpu_cmds_arena);
} }
store->header.kind = DX11_HANDLE_KIND_CMD_STORE; list->header.kind = DX11_HANDLE_KIND_CMD_LIST;
/* Desc template */ /* Desc template */
const D3D11_BUFFER_DESC structured_buffer_desc = { const D3D11_BUFFER_DESC structured_buffer_desc = {
@ -1333,41 +1333,41 @@ struct gpu_handle gpu_cmd_store_alloc(void)
idesc.BindFlags = D3D11_BIND_INDEX_BUFFER; idesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
idesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; idesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
store->buffers.mesh.vertex_buffer = dx11_buffer_alloc(vdesc, NULL); list->buffers.mesh.vertex_buffer = dx11_buffer_alloc(vdesc, NULL);
store->buffers.mesh.index_buffer = dx11_buffer_alloc(idesc, NULL); list->buffers.mesh.index_buffer = dx11_buffer_alloc(idesc, NULL);
} }
/* Texture buffers */ /* Texture buffers */
{ {
struct D3D11_BUFFER_DESC desc = structured_buffer_desc; struct D3D11_BUFFER_DESC desc = structured_buffer_desc;
desc.StructureByteStride = sizeof(struct dx11_texture_instance); desc.StructureByteStride = sizeof(struct dx11_texture_instance);
store->buffers.texture.instance_buffer = dx11_buffer_alloc(desc, NULL); list->buffers.texture.instance_buffer = dx11_buffer_alloc(desc, NULL);
} }
/* Grid buffers */ /* Grid buffers */
{ {
struct D3D11_BUFFER_DESC desc = structured_buffer_desc; struct D3D11_BUFFER_DESC desc = structured_buffer_desc;
desc.StructureByteStride = sizeof(struct dx11_grid_instance); desc.StructureByteStride = sizeof(struct dx11_grid_instance);
store->buffers.grid.instance_buffer = dx11_buffer_alloc(desc, NULL); list->buffers.grid.instance_buffer = dx11_buffer_alloc(desc, NULL);
} }
/* Test buffers */ /* Test buffers */
{ {
struct D3D11_BUFFER_DESC desc = structured_buffer_desc; struct D3D11_BUFFER_DESC desc = structured_buffer_desc;
desc.StructureByteStride = sizeof(struct dx11_test_instance); desc.StructureByteStride = sizeof(struct dx11_test_instance);
store->buffers.test.instance_buffer = dx11_buffer_alloc(desc, NULL); list->buffers.test.instance_buffer = dx11_buffer_alloc(desc, NULL);
} }
} }
struct gpu_handle res = ZI; struct gpu_handle res = ZI;
res.v = (u64)store; res.v = (u64)list;
return res; return res;
} }
void gpu_push_cmd(struct gpu_handle gpu_cmd_store, struct gpu_cmd_params params) void gpu_push_cmd(struct gpu_handle gpu_cmd_list, struct gpu_cmd_params params)
{ {
__prof; __prof;
struct dx11_cmd_store *store = (struct dx11_cmd_store *)gpu_cmd_store.v; struct dx11_cmd_list *list = (struct dx11_cmd_list *)gpu_cmd_list.v;
switch (params.kind) { switch (params.kind) {
default: default:
@ -1378,20 +1378,20 @@ void gpu_push_cmd(struct gpu_handle gpu_cmd_store, struct gpu_cmd_params params)
case GPU_CMD_KIND_DRAW_VIEW: case GPU_CMD_KIND_DRAW_VIEW:
{ {
struct dx11_cmd *cmd = arena_push(&store->cpu_cmds_arena, struct dx11_cmd); struct dx11_cmd *cmd = arena_push(&list->cpu_cmds_arena, struct dx11_cmd);
cmd->kind = params.kind; cmd->kind = params.kind;
cmd->view.xf = params.view.xf; cmd->view.xf = params.view.xf;
if (store->cpu_last_cmd) { if (list->cpu_last_cmd) {
store->cpu_last_cmd->next = cmd; list->cpu_last_cmd->next = cmd;
} else { } else {
store->cpu_first_cmd = cmd; list->cpu_first_cmd = cmd;
} }
store->cpu_last_cmd = cmd; list->cpu_last_cmd = cmd;
} break; } break;
case GPU_CMD_KIND_DRAW_MESH: case GPU_CMD_KIND_DRAW_MESH:
{ {
struct dx11_cmd *cmd = store->cpu_last_cmd; struct dx11_cmd *cmd = list->cpu_last_cmd;
if (cmd && cmd->kind != params.kind) { if (cmd && cmd->kind != params.kind) {
/* Cannot batch */ /* Cannot batch */
cmd = NULL; cmd = NULL;
@ -1400,23 +1400,23 @@ void gpu_push_cmd(struct gpu_handle gpu_cmd_store, struct gpu_cmd_params params)
/* Start new cmd */ /* Start new cmd */
if (!cmd) { if (!cmd) {
/* TODO: Better count method */ /* TODO: Better count method */
cmd = arena_push(&store->cpu_cmds_arena, struct dx11_cmd); cmd = arena_push(&list->cpu_cmds_arena, struct dx11_cmd);
cmd->kind = params.kind; cmd->kind = params.kind;
cmd->mesh.vertex_offset = (store->buffers.mesh.vertex_buffer->cpu_buffer_arena.pos / sizeof(struct dx11_mesh_vertex)); cmd->mesh.vertex_offset = (list->buffers.mesh.vertex_buffer->cpu_buffer_arena.pos / sizeof(struct dx11_mesh_vertex));
cmd->mesh.index_offset = (store->buffers.mesh.index_buffer->cpu_buffer_arena.pos / sizeof(u16)); cmd->mesh.index_offset = (list->buffers.mesh.index_buffer->cpu_buffer_arena.pos / sizeof(u16));
if (store->cpu_last_cmd) { if (list->cpu_last_cmd) {
store->cpu_last_cmd->next = cmd; list->cpu_last_cmd->next = cmd;
} else { } else {
store->cpu_first_cmd = cmd; list->cpu_first_cmd = cmd;
} }
store->cpu_last_cmd = cmd; list->cpu_last_cmd = cmd;
} }
/* Push vertices */ /* Push vertices */
u64 vertex_count = params.mesh.vertices.count; u64 vertex_count = params.mesh.vertices.count;
u64 start_index = cmd->mesh.vertex_count; u64 start_index = cmd->mesh.vertex_count;
cmd->mesh.vertex_count += vertex_count; cmd->mesh.vertex_count += vertex_count;
struct dx11_mesh_vertex *verts = dx11_buffer_push(store->buffers.mesh.vertex_buffer, sizeof(struct dx11_mesh_vertex) * vertex_count); struct dx11_mesh_vertex *verts = dx11_buffer_push(list->buffers.mesh.vertex_buffer, sizeof(struct dx11_mesh_vertex) * vertex_count);
for (u64 i = 0; i < vertex_count; ++i) { for (u64 i = 0; i < vertex_count; ++i) {
struct dx11_mesh_vertex *vert = &verts[i]; struct dx11_mesh_vertex *vert = &verts[i];
vert->pos = params.mesh.vertices.points[i]; vert->pos = params.mesh.vertices.points[i];
@ -1425,7 +1425,7 @@ void gpu_push_cmd(struct gpu_handle gpu_cmd_store, struct gpu_cmd_params params)
/* Push indices */ /* Push indices */
u64 index_count = params.mesh.indices.count; u64 index_count = params.mesh.indices.count;
u16 *indices = dx11_buffer_push(store->buffers.mesh.index_buffer, sizeof(u16) * index_count); u16 *indices = dx11_buffer_push(list->buffers.mesh.index_buffer, sizeof(u16) * index_count);
cmd->mesh.index_count += index_count; cmd->mesh.index_count += index_count;
for (u64 i = 0; i < index_count; ++i) { for (u64 i = 0; i < index_count; ++i) {
indices[i] = start_index + params.mesh.indices.indices[i]; indices[i] = start_index + params.mesh.indices.indices[i];
@ -1434,7 +1434,7 @@ void gpu_push_cmd(struct gpu_handle gpu_cmd_store, struct gpu_cmd_params params)
case GPU_CMD_KIND_DRAW_TEXTURE: case GPU_CMD_KIND_DRAW_TEXTURE:
{ {
struct dx11_cmd *cmd = store->cpu_last_cmd; struct dx11_cmd *cmd = list->cpu_last_cmd;
if (cmd && if (cmd &&
((cmd->kind != params.kind) || ((cmd->kind != params.kind) ||
(cmd->texture.sprite.hash != params.texture.sprite.hash) || (cmd->texture.sprite.hash != params.texture.sprite.hash) ||
@ -1446,22 +1446,22 @@ void gpu_push_cmd(struct gpu_handle gpu_cmd_store, struct gpu_cmd_params params)
/* Start new cmd */ /* Start new cmd */
if (!cmd) { if (!cmd) {
/* TODO: Better count method */ /* TODO: Better count method */
cmd = arena_push(&store->cpu_cmds_arena, struct dx11_cmd); cmd = arena_push(&list->cpu_cmds_arena, struct dx11_cmd);
cmd->kind = params.kind; cmd->kind = params.kind;
cmd->texture.sprite = params.texture.sprite; cmd->texture.sprite = params.texture.sprite;
cmd->texture.texture = params.texture.texture; cmd->texture.texture = params.texture.texture;
cmd->texture.instance_offset = (store->buffers.texture.instance_buffer->cpu_buffer_arena.pos / sizeof(struct dx11_texture_instance)); cmd->texture.instance_offset = (list->buffers.texture.instance_buffer->cpu_buffer_arena.pos / sizeof(struct dx11_texture_instance));
if (store->cpu_last_cmd) { if (list->cpu_last_cmd) {
store->cpu_last_cmd->next = cmd; list->cpu_last_cmd->next = cmd;
} else { } else {
store->cpu_first_cmd = cmd; list->cpu_first_cmd = cmd;
} }
store->cpu_last_cmd = cmd; list->cpu_last_cmd = cmd;
} }
/* Push instance data */ /* Push instance data */
++cmd->texture.instance_count; ++cmd->texture.instance_count;
struct dx11_texture_instance *instance = dx11_buffer_push(store->buffers.texture.instance_buffer, sizeof(struct dx11_texture_instance)); struct dx11_texture_instance *instance = dx11_buffer_push(list->buffers.texture.instance_buffer, sizeof(struct dx11_texture_instance));
instance->xf = params.texture.xf; instance->xf = params.texture.xf;
instance->uv0 = params.texture.clip.p0; instance->uv0 = params.texture.clip.p0;
instance->uv1 = params.texture.clip.p1; instance->uv1 = params.texture.clip.p1;
@ -1471,7 +1471,7 @@ void gpu_push_cmd(struct gpu_handle gpu_cmd_store, struct gpu_cmd_params params)
case GPU_CMD_KIND_DRAW_GRID: case GPU_CMD_KIND_DRAW_GRID:
{ {
struct dx11_cmd *cmd = store->cpu_last_cmd; struct dx11_cmd *cmd = list->cpu_last_cmd;
if (cmd && cmd->kind != params.kind) { if (cmd && cmd->kind != params.kind) {
/* Cannot batch */ /* Cannot batch */
cmd = NULL; cmd = NULL;
@ -1480,20 +1480,20 @@ void gpu_push_cmd(struct gpu_handle gpu_cmd_store, struct gpu_cmd_params params)
/* Start new cmd */ /* Start new cmd */
if (!cmd) { if (!cmd) {
/* TODO: Better count method */ /* TODO: Better count method */
cmd = arena_push(&store->cpu_cmds_arena, struct dx11_cmd); cmd = arena_push(&list->cpu_cmds_arena, struct dx11_cmd);
cmd->kind = params.kind; cmd->kind = params.kind;
cmd->grid.instance_offset = (store->buffers.grid.instance_buffer->cpu_buffer_arena.pos / sizeof(struct dx11_grid_instance)); cmd->grid.instance_offset = (list->buffers.grid.instance_buffer->cpu_buffer_arena.pos / sizeof(struct dx11_grid_instance));
if (store->cpu_last_cmd) { if (list->cpu_last_cmd) {
store->cpu_last_cmd->next = cmd; list->cpu_last_cmd->next = cmd;
} else { } else {
store->cpu_first_cmd = cmd; list->cpu_first_cmd = cmd;
} }
store->cpu_last_cmd = cmd; list->cpu_last_cmd = cmd;
} }
/* Push instance data */ /* Push instance data */
++cmd->grid.instance_count; ++cmd->grid.instance_count;
struct dx11_grid_instance *instance = dx11_buffer_push(store->buffers.grid.instance_buffer, sizeof(struct dx11_grid_instance)); struct dx11_grid_instance *instance = dx11_buffer_push(list->buffers.grid.instance_buffer, sizeof(struct dx11_grid_instance));
instance->xf = params.grid.xf; instance->xf = params.grid.xf;
instance->line_thickness = params.grid.line_thickness; instance->line_thickness = params.grid.line_thickness;
instance->line_spacing = params.grid.line_spacing; instance->line_spacing = params.grid.line_spacing;
@ -1507,53 +1507,53 @@ void gpu_push_cmd(struct gpu_handle gpu_cmd_store, struct gpu_cmd_params params)
case GPU_CMD_KIND_TEST: case GPU_CMD_KIND_TEST:
{ {
struct dx11_cmd *cmd = arena_push(&store->cpu_cmds_arena, struct dx11_cmd); struct dx11_cmd *cmd = arena_push(&list->cpu_cmds_arena, struct dx11_cmd);
cmd->kind = params.kind; cmd->kind = params.kind;
cmd->test.instance_offset = (store->buffers.test.instance_buffer->cpu_buffer_arena.pos / sizeof(struct dx11_test_instance)); cmd->test.instance_offset = (list->buffers.test.instance_buffer->cpu_buffer_arena.pos / sizeof(struct dx11_test_instance));
if (store->cpu_last_cmd) { if (list->cpu_last_cmd) {
store->cpu_last_cmd->next = cmd; list->cpu_last_cmd->next = cmd;
} else { } else {
store->cpu_first_cmd = cmd; list->cpu_first_cmd = cmd;
} }
store->cpu_last_cmd = cmd; list->cpu_last_cmd = cmd;
/* Push instance data */ /* Push instance data */
++cmd->test.instance_count; ++cmd->test.instance_count;
struct dx11_test_instance *instance = dx11_buffer_push(store->buffers.test.instance_buffer, sizeof(struct dx11_test_instance)); struct dx11_test_instance *instance = dx11_buffer_push(list->buffers.test.instance_buffer, sizeof(struct dx11_test_instance));
instance->xf = params.test.xf; instance->xf = params.test.xf;
} break; } break;
} }
} }
void gpu_submit_cmds(struct gpu_handle gpu_cmd_store) void gpu_submit_cmds(struct gpu_handle gpu_cmd_list)
{ {
__prof; __prof;
struct dx11_cmd_store *store = (struct dx11_cmd_store *)gpu_cmd_store.v; struct dx11_cmd_list *list = (struct dx11_cmd_list *)gpu_cmd_list.v;
/* Swap cmd lists */ /* Swap cmd lists */
struct arena swp_arena = store->gpu_cmds_arena; struct arena swp_arena = list->gpu_cmds_arena;
store->gpu_cmds_arena = store->cpu_cmds_arena; list->gpu_cmds_arena = list->cpu_cmds_arena;
store->gpu_first_cmd = store->cpu_first_cmd; list->gpu_first_cmd = list->cpu_first_cmd;
store->gpu_last_cmd = store->cpu_last_cmd; list->gpu_last_cmd = list->cpu_last_cmd;
/* Reset cpu cmds */ /* Reset cpu cmds */
store->cpu_cmds_arena = swp_arena; list->cpu_cmds_arena = swp_arena;
store->cpu_first_cmd = NULL; list->cpu_first_cmd = NULL;
store->cpu_last_cmd = NULL; list->cpu_last_cmd = NULL;
arena_reset(&store->cpu_cmds_arena); arena_reset(&list->cpu_cmds_arena);
/* Submit mesh buffers */ /* Submit mesh buffers */
dx11_buffer_submit(store->buffers.mesh.vertex_buffer); dx11_buffer_submit(list->buffers.mesh.vertex_buffer);
dx11_buffer_submit(store->buffers.mesh.index_buffer); dx11_buffer_submit(list->buffers.mesh.index_buffer);
/* Submit texture buffers */ /* Submit texture buffers */
dx11_buffer_submit(store->buffers.texture.instance_buffer); dx11_buffer_submit(list->buffers.texture.instance_buffer);
/* Submit grid buffers */ /* Submit grid buffers */
dx11_buffer_submit(store->buffers.grid.instance_buffer); dx11_buffer_submit(list->buffers.grid.instance_buffer);
/* Submit test buffers */ /* Submit test buffers */
dx11_buffer_submit(store->buffers.test.instance_buffer); dx11_buffer_submit(list->buffers.test.instance_buffer);
} }
/* ========================== * /* ========================== *
@ -1702,9 +1702,9 @@ void gpu_dispatch(struct gpu_handle gpu_dispatch_state, struct gpu_dispatch_para
{ {
__profscope(Regular pass); __profscope(Regular pass);
__profscope_dx11(G.profiling_ctx, Regular pass, RGB_F(0.2, 0.5, 0.5)); __profscope_dx11(G.profiling_ctx, Regular pass, RGB_F(0.2, 0.5, 0.5));
for (u64 cmd_stores_array_index = 0; cmd_stores_array_index < params.cmds_array.count; ++cmd_stores_array_index) { for (u64 handles_array_index = 0; handles_array_index < params.cmd_lists.count; ++handles_array_index) {
struct dx11_cmd_store *store = (struct dx11_cmd_store *)params.cmds_array.stores[cmd_stores_array_index]->v; struct dx11_cmd_list *list = (struct dx11_cmd_list *)params.cmd_lists.handles[handles_array_index]->v;
for (struct dx11_cmd *cmd = store->gpu_first_cmd; cmd; cmd = cmd->next) { for (struct dx11_cmd *cmd = list->gpu_first_cmd; cmd; cmd = cmd->next) {
enum gpu_cmd_kind cmd_kind = cmd->kind; enum gpu_cmd_kind cmd_kind = cmd->kind;
switch (cmd_kind) { switch (cmd_kind) {
@ -1726,8 +1726,8 @@ void gpu_dispatch(struct gpu_handle gpu_dispatch_state, struct gpu_dispatch_para
__profscope_dx11(G.profiling_ctx, Draw mesh, RGB_F(0.5, 0.2, 0.2)); __profscope_dx11(G.profiling_ctx, Draw mesh, RGB_F(0.5, 0.2, 0.2));
struct dx11_shader *shader = &G.shaders[DX11_SHADER_KIND_MESH]; struct dx11_shader *shader = &G.shaders[DX11_SHADER_KIND_MESH];
if (shader->valid) { if (shader->valid) {
struct dx11_buffer *vertex_buffer = store->buffers.mesh.vertex_buffer; struct dx11_buffer *vertex_buffer = list->buffers.mesh.vertex_buffer;
struct dx11_buffer *index_buffer = store->buffers.mesh.index_buffer; struct dx11_buffer *index_buffer = list->buffers.mesh.index_buffer;
u32 vertex_offset = cmd->mesh.vertex_offset; u32 vertex_offset = cmd->mesh.vertex_offset;
u32 index_offset = cmd->mesh.index_offset; u32 index_offset = cmd->mesh.index_offset;
@ -1785,7 +1785,7 @@ void gpu_dispatch(struct gpu_handle gpu_dispatch_state, struct gpu_dispatch_para
} }
if (texture && texture->srv) { if (texture && texture->srv) {
struct dx11_buffer *instance_buffer = store->buffers.texture.instance_buffer; struct dx11_buffer *instance_buffer = list->buffers.texture.instance_buffer;
u32 instance_offset = cmd->texture.instance_offset; u32 instance_offset = cmd->texture.instance_offset;
u32 instance_count = cmd->texture.instance_count; u32 instance_count = cmd->texture.instance_count;
@ -1833,7 +1833,7 @@ void gpu_dispatch(struct gpu_handle gpu_dispatch_state, struct gpu_dispatch_para
__profscope_dx11(G.profiling_ctx, Draw grid, RGB_F(0.2, 0.2, 0.5)); __profscope_dx11(G.profiling_ctx, Draw grid, RGB_F(0.2, 0.2, 0.5));
struct dx11_shader *shader = &G.shaders[DX11_SHADER_KIND_GRID]; struct dx11_shader *shader = &G.shaders[DX11_SHADER_KIND_GRID];
if (shader->valid) { if (shader->valid) {
struct dx11_buffer *instance_buffer = store->buffers.grid.instance_buffer; struct dx11_buffer *instance_buffer = list->buffers.grid.instance_buffer;
u32 instance_offset = cmd->grid.instance_offset; u32 instance_offset = cmd->grid.instance_offset;
u32 instance_count = cmd->grid.instance_count; u32 instance_count = cmd->grid.instance_count;
@ -1880,7 +1880,7 @@ void gpu_dispatch(struct gpu_handle gpu_dispatch_state, struct gpu_dispatch_para
__profscope_dx11(G.profiling_ctx, Test, RGB_F(1, 0.2, 1)); __profscope_dx11(G.profiling_ctx, Test, RGB_F(1, 0.2, 1));
struct dx11_shader *shader = &G.shaders[DX11_SHADER_KIND_TEST]; struct dx11_shader *shader = &G.shaders[DX11_SHADER_KIND_TEST];
if (shader->valid) { if (shader->valid) {
struct dx11_buffer *instance_buffer = store->buffers.test.instance_buffer; struct dx11_buffer *instance_buffer = list->buffers.test.instance_buffer;
u32 instance_offset = cmd->test.instance_offset; u32 instance_offset = cmd->test.instance_offset;
u32 instance_count = cmd->test.instance_count; u32 instance_count = cmd->test.instance_count;

12
src/gpu_dx12.c
View File

@ -962,24 +962,24 @@ struct v2i32 gpu_texture_get_size(struct gpu_handle texture)
} }
/* ========================== * /* ========================== *
* Cmd buffer * Cmd list
* ========================== */ * ========================== */
struct gpu_handle gpu_cmd_store_alloc(void) struct gpu_handle gpu_cmd_list_alloc(void)
{ {
struct gpu_handle res = ZI; struct gpu_handle res = ZI;
return res; return res;
} }
void gpu_push_cmd(struct gpu_handle gpu_cmd_store, struct gpu_cmd_params params) void gpu_push_cmd(struct gpu_handle gpu_cmd_list, struct gpu_cmd_params params)
{ {
(UNUSED)gpu_cmd_store; (UNUSED)gpu_cmd_list;
(UNUSED)params; (UNUSED)params;
} }
void gpu_submit_cmds(struct gpu_handle gpu_cmd_store) void gpu_submit_cmds(struct gpu_handle gpu_cmd_list)
{ {
(UNUSED)gpu_cmd_store; (UNUSED)gpu_cmd_list;
} }
/* ========================== * /* ========================== *

156
src/user.c
View File

@ -74,9 +74,9 @@ GLOBAL struct {
struct gpu_handle user_texture; struct gpu_handle user_texture;
struct gpu_handle backbuffer_texture; struct gpu_handle backbuffer_texture;
struct gpu_handle world_gpu_cmd_store; struct gpu_handle world_gpu_cmd_list;
struct gpu_handle user_gpu_cmd_store; struct gpu_handle user_gpu_cmd_list;
struct gpu_handle backbuffer_gpu_cmd_store; struct gpu_handle backbuffer_gpu_cmd_list;
struct gpu_handle user_dispatch_state; struct gpu_handle user_dispatch_state;
struct gpu_handle backbuffer_dispatch_state; struct gpu_handle backbuffer_dispatch_state;
@ -258,9 +258,9 @@ struct user_startup_receipt user_startup(struct work_startup_receipt *work_sr,
/* GPU handles */ /* GPU handles */
G.world_to_user_xf = XFORM_IDENT; G.world_to_user_xf = XFORM_IDENT;
G.world_gpu_cmd_store = gpu_cmd_store_alloc(); G.world_gpu_cmd_list = gpu_cmd_list_alloc();
G.user_gpu_cmd_store = gpu_cmd_store_alloc(); G.user_gpu_cmd_list = gpu_cmd_list_alloc();
G.backbuffer_gpu_cmd_store = gpu_cmd_store_alloc(); G.backbuffer_gpu_cmd_list = gpu_cmd_list_alloc();
G.user_dispatch_state = gpu_dispatch_state_alloc(); G.user_dispatch_state = gpu_dispatch_state_alloc();
G.backbuffer_dispatch_state = gpu_dispatch_state_alloc(); G.backbuffer_dispatch_state = gpu_dispatch_state_alloc();
@ -349,13 +349,13 @@ INTERNAL void debug_draw_xform(struct xform xf, u32 color_x, u32 color_y)
x_ray = v2_mul(x_ray, ray_scale); x_ray = v2_mul(x_ray, ray_scale);
y_ray = v2_mul(y_ray, ray_scale); y_ray = v2_mul(y_ray, ray_scale);
draw_arrow_ray(G.user_gpu_cmd_store, pos, x_ray, thickness, arrowhead_len, color_x); draw_arrow_ray(G.user_gpu_cmd_list, pos, x_ray, thickness, arrowhead_len, color_x);
draw_arrow_ray(G.user_gpu_cmd_store, pos, y_ray, thickness, arrowhead_len, color_y); draw_arrow_ray(G.user_gpu_cmd_list, pos, y_ray, thickness, arrowhead_len, color_y);
//u32 color_quad = RGBA_F(0, 1, 1, 0.3); //u32 color_quad = RGBA_F(0, 1, 1, 0.3);
//struct quad quad = quad_from_rect(RECT(0, 0, 1, -1)); //struct quad quad = quad_from_rect(RECT(0, 0, 1, -1));
//quad = xform_mul_quad(xf, quad_scale(quad, 0.075f)); //quad = xform_mul_quad(xf, quad_scale(quad, 0.075f));
//draw_quad(G.user_gpu_cmd_store, quad, color); //draw_quad(G.user_gpu_cmd_list, quad, color);
} }
INTERNAL void debug_draw_movement(struct sim_ent *ent) INTERNAL void debug_draw_movement(struct sim_ent *ent)
@ -372,7 +372,7 @@ INTERNAL void debug_draw_movement(struct sim_ent *ent)
struct v2 vel_ray = xform_basis_mul_v2(G.world_to_user_xf, velocity); struct v2 vel_ray = xform_basis_mul_v2(G.world_to_user_xf, velocity);
if (v2_len(vel_ray) > 0.00001) { if (v2_len(vel_ray) > 0.00001) {
draw_arrow_ray(G.user_gpu_cmd_store, pos, vel_ray, thickness, arrow_len, color_vel); draw_arrow_ray(G.user_gpu_cmd_list, pos, vel_ray, thickness, arrow_len, color_vel);
} }
} }
@ -542,7 +542,7 @@ INTERNAL void draw_debug_console(i32 level, b32 minimized)
if (log->level <= level) { if (log->level <= level) {
/* Draw background */ /* Draw background */
u32 color = colors[log->level][log->color_index]; u32 color = colors[log->level][log->color_index];
draw_quad(G.user_gpu_cmd_store, quad_from_rect(log->bounds), ALPHA_F(color, opacity)); draw_quad(G.user_gpu_cmd_list, quad_from_rect(log->bounds), ALPHA_F(color, opacity));
/* Draw text */ /* Draw text */
struct string text = log->msg; struct string text = log->msg;
@ -559,7 +559,7 @@ INTERNAL void draw_debug_console(i32 level, b32 minimized)
} }
struct draw_text_params params = DRAW_TEXT_PARAMS(.font = font, .pos = draw_pos, .offset_y = DRAW_TEXT_OFFSET_Y_BOTTOM, .color = ALPHA_F(COLOR_WHITE, opacity), .str = text); struct draw_text_params params = DRAW_TEXT_PARAMS(.font = font, .pos = draw_pos, .offset_y = DRAW_TEXT_OFFSET_Y_BOTTOM, .color = ALPHA_F(COLOR_WHITE, opacity), .str = text);
struct rect bounds = draw_text(G.user_gpu_cmd_store, params); struct rect bounds = draw_text(G.user_gpu_cmd_list, params);
struct rect draw_bounds = bounds; struct rect draw_bounds = bounds;
draw_bounds.x -= bg_margin; draw_bounds.x -= bg_margin;
@ -1037,8 +1037,8 @@ INTERNAL void user_update(void)
* Set draw views * Set draw views
* ========================== */ * ========================== */
draw_set_view(G.world_gpu_cmd_store, G.world_to_user_xf); draw_set_view(G.world_gpu_cmd_list, G.world_to_user_xf);
draw_set_view(G.user_gpu_cmd_store, XFORM_IDENT); draw_set_view(G.user_gpu_cmd_list, XFORM_IDENT);
/* ========================== * /* ========================== *
* Update listener from view * Update listener from view
@ -1065,7 +1065,7 @@ INTERNAL void user_update(void)
struct v2 size = xform_basis_invert_mul_v2(G.world_to_user_xf, G.user_size); struct v2 size = xform_basis_invert_mul_v2(G.world_to_user_xf, G.user_size);
u32 color0 = RGBA_F(0.17f, 0.17f, 0.17f, 1.f); u32 color0 = RGBA_F(0.17f, 0.17f, 0.17f, 1.f);
u32 color1 = RGBA_F(0.15f, 0.15f, 0.15f, 1.f); u32 color1 = RGBA_F(0.15f, 0.15f, 0.15f, 1.f);
draw_grid(G.world_gpu_cmd_store, xform_from_rect(RECT_FROM_V2(pos, size)), color0, color1, RGBA(0x3f, 0x3f, 0x3f, 0xFF), COLOR_RED, COLOR_GREEN, thickness, spacing, offset); draw_grid(G.world_gpu_cmd_list, xform_from_rect(RECT_FROM_V2(pos, size)), color0, color1, RGBA(0x3f, 0x3f, 0x3f, 0xFF), COLOR_RED, COLOR_GREEN, thickness, spacing, offset);
} }
/* ========================== * /* ========================== *
@ -1078,7 +1078,7 @@ INTERNAL void user_update(void)
struct gpu_cmd_params cmd = ZI; struct gpu_cmd_params cmd = ZI;
cmd.kind = GPU_CMD_KIND_TEST; cmd.kind = GPU_CMD_KIND_TEST;
cmd.test.xf = xform_from_rect(RECT_FROM_V2(pos, size)); cmd.test.xf = xform_from_rect(RECT_FROM_V2(pos, size));
gpu_push_cmd(G.world_gpu_cmd_store, cmd); gpu_push_cmd(G.world_gpu_cmd_list, cmd);
} }
#if 0 #if 0
@ -1260,9 +1260,9 @@ INTERNAL void user_update(void)
u32 color_end = RGBA_F(1, 0.8, 0.4, opacity_b); u32 color_end = RGBA_F(1, 0.8, 0.4, opacity_b);
if (opacity_b > 0.99f) { if (opacity_b > 0.99f) {
draw_circle(G.world_gpu_cmd_store, b, thickness / 2, color_end, 20); draw_circle(G.world_gpu_cmd_list, b, thickness / 2, color_end, 20);
} }
draw_gradient_line(G.world_gpu_cmd_store, a, b, thickness, color_start, color_end); draw_gradient_line(G.world_gpu_cmd_list, a, b, thickness, color_start, color_end);
} }
@ -1284,7 +1284,7 @@ INTERNAL void user_update(void)
u32 tint = ent->sprite_tint; u32 tint = ent->sprite_tint;
struct sprite_sheet_frame frame = sprite_sheet_get_frame(sheet, ent->animation_frame); struct sprite_sheet_frame frame = sprite_sheet_get_frame(sheet, ent->animation_frame);
struct draw_texture_params params = DRAW_TEXTURE_PARAMS(.xf = sprite_xform, .sprite = sprite, .tint = tint, .clip = frame.clip, .emittance = emittance); struct draw_texture_params params = DRAW_TEXTURE_PARAMS(.xf = sprite_xform, .sprite = sprite, .tint = tint, .clip = frame.clip, .emittance = emittance);
draw_texture(G.world_gpu_cmd_store, params); draw_texture(G.world_gpu_cmd_list, params);
} }
} }
@ -1304,7 +1304,7 @@ INTERNAL void user_update(void)
struct v2 pos = sim_pos_from_world_tile_index(world_tile_index); struct v2 pos = sim_pos_from_world_tile_index(world_tile_index);
struct xform tile_xf = xform_from_rect(RECT_FROM_V2(pos, V2(tile_size, tile_size))); struct xform tile_xf = xform_from_rect(RECT_FROM_V2(pos, V2(tile_size, tile_size)));
struct draw_texture_params params = DRAW_TEXTURE_PARAMS(.xf = tile_xf, .sprite = tile_sprite); struct draw_texture_params params = DRAW_TEXTURE_PARAMS(.xf = tile_xf, .sprite = tile_sprite);
draw_texture(G.world_gpu_cmd_store, params); draw_texture(G.world_gpu_cmd_list, params);
} }
} }
} }
@ -1332,7 +1332,7 @@ INTERNAL void user_update(void)
u32 color = RGBA_F(1, 0, 1, 0.5); u32 color = RGBA_F(1, 0, 1, 0.5);
struct quad quad = quad_from_aabb(aabb); struct quad quad = quad_from_aabb(aabb);
quad = xform_mul_quad(G.world_to_user_xf, quad); quad = xform_mul_quad(G.world_to_user_xf, quad);
draw_quad_line(G.user_gpu_cmd_store, quad, thickness, color); draw_quad_line(G.user_gpu_cmd_list, quad, thickness, color);
} }
/* Draw focus arrow */ /* Draw focus arrow */
@ -1343,7 +1343,7 @@ INTERNAL void user_update(void)
start = xform_mul_v2(G.world_to_user_xf, start); start = xform_mul_v2(G.world_to_user_xf, start);
struct v2 end = v2_add(xf.og, ent->control.focus); struct v2 end = v2_add(xf.og, ent->control.focus);
end = xform_mul_v2(G.world_to_user_xf, end); end = xform_mul_v2(G.world_to_user_xf, end);
draw_arrow_line(G.user_gpu_cmd_store, start, end, 3, 10, RGBA_F(1, 1, 1, 0.5)); draw_arrow_line(G.user_gpu_cmd_list, start, end, 3, 10, RGBA_F(1, 1, 1, 0.5));
} }
#if 0 #if 0
@ -1369,16 +1369,16 @@ INTERNAL void user_update(void)
struct quad quad = quad_from_rect(slice.rect); struct quad quad = quad_from_rect(slice.rect);
quad = xform_mul_quad(sprite_xform, quad); quad = xform_mul_quad(sprite_xform, quad);
quad = xform_mul_quad(G.world_to_user_xf, quad); quad = xform_mul_quad(G.world_to_user_xf, quad);
draw_quad_line(G.user_gpu_cmd_store, quad, 2, quad_color); draw_quad_line(G.user_gpu_cmd_list, quad, 2, quad_color);
} }
draw_circle(G.user_gpu_cmd_store, center, 3, point_color, 20); draw_circle(G.user_gpu_cmd_list, center, 3, point_color, 20);
if (slice.has_ray) { if (slice.has_ray) {
struct v2 ray = xform_basis_mul_v2(sprite_xform, slice.dir); struct v2 ray = xform_basis_mul_v2(sprite_xform, slice.dir);
ray = xform_basis_mul_v2(G.world_to_user_xf, ray); ray = xform_basis_mul_v2(G.world_to_user_xf, ray);
ray = v2_with_len(ray, 25); ray = v2_with_len(ray, 25);
draw_arrow_ray(G.user_gpu_cmd_store, center, ray, 2, 10, ray_color); draw_arrow_ray(G.user_gpu_cmd_list, center, ray, 2, 10, ray_color);
} }
} }
} }
@ -1395,7 +1395,7 @@ INTERNAL void user_update(void)
f32 radius = 3; f32 radius = 3;
struct v2 point = xform_mul_v2(e1_xf, ent->weld_joint_data.point_local_e1); struct v2 point = xform_mul_v2(e1_xf, ent->weld_joint_data.point_local_e1);
point = xform_mul_v2(G.world_to_user_xf, point); point = xform_mul_v2(G.world_to_user_xf, point);
draw_circle(G.user_gpu_cmd_store, point, radius, color, 10); draw_circle(G.user_gpu_cmd_list, point, radius, color, 10);
DEBUGBREAKABLE; DEBUGBREAKABLE;
} }
@ -1410,8 +1410,8 @@ INTERNAL void user_update(void)
struct v2 point_end = G.world_cursor; struct v2 point_end = G.world_cursor;
point_start = xform_mul_v2(G.world_to_user_xf, point_start); point_start = xform_mul_v2(G.world_to_user_xf, point_start);
point_end = xform_mul_v2(G.world_to_user_xf, point_end); point_end = xform_mul_v2(G.world_to_user_xf, point_end);
draw_arrow_line(G.user_gpu_cmd_store, point_start, point_end, 3, 10, color); draw_arrow_line(G.user_gpu_cmd_list, point_start, point_end, 3, 10, color);
draw_circle(G.user_gpu_cmd_store, point_start, 4, color, 10); draw_circle(G.user_gpu_cmd_list, point_start, 4, color, 10);
} }
/* Draw collider */ /* Draw collider */
@ -1422,13 +1422,13 @@ INTERNAL void user_update(void)
{ {
/* Draw collider using support points */ /* Draw collider using support points */
u32 detail = 32; u32 detail = 32;
draw_collider_line(G.user_gpu_cmd_store, G.world_to_user_xf, collider, xf, thickness, color, detail); draw_collider_line(G.user_gpu_cmd_list, G.world_to_user_xf, collider, xf, thickness, color, detail);
} }
{ {
/* Draw collider shape points */ /* Draw collider shape points */
for (u32 i = 0; i < collider.count; ++i) { for (u32 i = 0; i < collider.count; ++i) {
struct v2 p = xform_mul_v2(xform_mul(G.world_to_user_xf, xf), collider.points[i]); struct v2 p = xform_mul_v2(xform_mul(G.world_to_user_xf, xf), collider.points[i]);
draw_circle(G.user_gpu_cmd_store, p, 3, COLOR_BLUE, 10); draw_circle(G.user_gpu_cmd_list, p, 3, COLOR_BLUE, 10);
} }
} }
if (collider.count == 1 && collider.radius > 0) { if (collider.count == 1 && collider.radius > 0) {
@ -1437,14 +1437,14 @@ INTERNAL void user_update(void)
struct v2 end = collider_get_support_point(&collider, xf, v2_neg(xf.by)).p; struct v2 end = collider_get_support_point(&collider, xf, v2_neg(xf.by)).p;
start = xform_mul_v2(G.world_to_user_xf, start); start = xform_mul_v2(G.world_to_user_xf, start);
end = xform_mul_v2(G.world_to_user_xf, end); end = xform_mul_v2(G.world_to_user_xf, end);
draw_line(G.user_gpu_cmd_store, start, end, thickness, color); draw_line(G.user_gpu_cmd_list, start, end, thickness, color);
} }
#if 0 #if 0
/* Draw support point at focus dir */ /* Draw support point at focus dir */
{ {
struct v2 p = collider_support_point(&collider, xf, ent->control.focus); struct v2 p = collider_support_point(&collider, xf, ent->control.focus);
p = xform_mul_v2(G.world_to_user_xf, p); p = xform_mul_v2(G.world_to_user_xf, p);
draw_circle(G.user_gpu_cmd_store, p, 3, COLOR_RED, 10); draw_circle(G.user_gpu_cmd_list, p, 3, COLOR_RED, 10);
} }
#endif #endif
} }
@ -1468,7 +1468,7 @@ INTERNAL void user_update(void)
/* Draw point */ /* Draw point */
{ {
draw_circle(G.user_gpu_cmd_store, xform_mul_v2(G.world_to_user_xf, dbg_pt), radius, color, 10); draw_circle(G.user_gpu_cmd_list, xform_mul_v2(G.world_to_user_xf, dbg_pt), radius, color, 10);
} }
/* Draw normal */ /* Draw normal */
@ -1478,7 +1478,7 @@ INTERNAL void user_update(void)
f32 arrow_height = 5; f32 arrow_height = 5;
struct v2 start = xform_mul_v2(G.world_to_user_xf, dbg_pt); struct v2 start = xform_mul_v2(G.world_to_user_xf, dbg_pt);
struct v2 end = xform_mul_v2(G.world_to_user_xf, v2_add(dbg_pt, v2_mul(v2_norm(data->normal), len))); struct v2 end = xform_mul_v2(G.world_to_user_xf, v2_add(dbg_pt, v2_mul(v2_norm(data->normal), len)));
draw_arrow_line(G.user_gpu_cmd_store, start, end, arrow_thickness, arrow_height, color); draw_arrow_line(G.user_gpu_cmd_list, start, end, arrow_thickness, arrow_height, color);
} }
#if 0 #if 0
/* Draw contact info */ /* Draw contact info */
@ -1508,7 +1508,7 @@ INTERNAL void user_update(void)
FMT_UINT(data->num_points)); FMT_UINT(data->num_points));
draw_text(G.user_gpu_cmd_store, disp_font, v2_add(v2_round(xform_mul_v2(G.world_to_user_xf, dbg_pt)), V2(0, offset_px)), text); draw_text(G.user_gpu_cmd_list, disp_font, v2_add(v2_round(xform_mul_v2(G.world_to_user_xf, dbg_pt)), V2(0, offset_px)), text);
} }
} }
#endif #endif
@ -1536,8 +1536,8 @@ INTERNAL void user_update(void)
u32 color = RGBA_F(1, 1, 0, 0.5); u32 color = RGBA_F(1, 1, 0, 0.5);
struct v2 a = xform_mul_v2(G.world_to_user_xf, data->closest0); struct v2 a = xform_mul_v2(G.world_to_user_xf, data->closest0);
struct v2 b = xform_mul_v2(G.world_to_user_xf, data->closest1); struct v2 b = xform_mul_v2(G.world_to_user_xf, data->closest1);
draw_circle(G.user_gpu_cmd_store, a, radius, color, 10); draw_circle(G.user_gpu_cmd_list, a, radius, color, 10);
draw_circle(G.user_gpu_cmd_store, b, radius, color, 10); draw_circle(G.user_gpu_cmd_list, b, radius, color, 10);
} }
#endif #endif
@ -1554,28 +1554,28 @@ INTERNAL void user_update(void)
{ {
struct v2 a = xform_mul_v2(G.world_to_user_xf, collider_res.a0); struct v2 a = xform_mul_v2(G.world_to_user_xf, collider_res.a0);
struct v2 b = xform_mul_v2(G.world_to_user_xf, collider_res.b0); struct v2 b = xform_mul_v2(G.world_to_user_xf, collider_res.b0);
draw_line(G.user_gpu_cmd_store, a, b, thickness, color_line); draw_line(G.user_gpu_cmd_list, a, b, thickness, color_line);
draw_circle(G.user_gpu_cmd_store, a, radius, color_a, 10); draw_circle(G.user_gpu_cmd_list, a, radius, color_a, 10);
draw_circle(G.user_gpu_cmd_store, b, radius, color_b, 10); draw_circle(G.user_gpu_cmd_list, b, radius, color_b, 10);
struct v2 a_clipped = xform_mul_v2(G.world_to_user_xf, collider_res.a0_clipped); struct v2 a_clipped = xform_mul_v2(G.world_to_user_xf, collider_res.a0_clipped);
struct v2 b_clipped = xform_mul_v2(G.world_to_user_xf, collider_res.b0_clipped); struct v2 b_clipped = xform_mul_v2(G.world_to_user_xf, collider_res.b0_clipped);
draw_line(G.user_gpu_cmd_store, a_clipped, b_clipped, thickness, color_line_clipped); draw_line(G.user_gpu_cmd_list, a_clipped, b_clipped, thickness, color_line_clipped);
draw_circle(G.user_gpu_cmd_store, a_clipped, radius, color_a_clipped, 10); draw_circle(G.user_gpu_cmd_list, a_clipped, radius, color_a_clipped, 10);
draw_circle(G.user_gpu_cmd_store, b_clipped, radius, color_b_clipped, 10); draw_circle(G.user_gpu_cmd_list, b_clipped, radius, color_b_clipped, 10);
} }
{ {
struct v2 a = xform_mul_v2(G.world_to_user_xf, collider_res.a1); struct v2 a = xform_mul_v2(G.world_to_user_xf, collider_res.a1);
struct v2 b = xform_mul_v2(G.world_to_user_xf, collider_res.b1); struct v2 b = xform_mul_v2(G.world_to_user_xf, collider_res.b1);
draw_line(G.user_gpu_cmd_store, a, b, thickness, color_line); draw_line(G.user_gpu_cmd_list, a, b, thickness, color_line);
draw_circle(G.user_gpu_cmd_store, a, radius, color_a, 10); draw_circle(G.user_gpu_cmd_list, a, radius, color_a, 10);
draw_circle(G.user_gpu_cmd_store, b, radius, color_b, 10); draw_circle(G.user_gpu_cmd_list, b, radius, color_b, 10);
struct v2 a_clipped = xform_mul_v2(G.world_to_user_xf, collider_res.a1_clipped); struct v2 a_clipped = xform_mul_v2(G.world_to_user_xf, collider_res.a1_clipped);
struct v2 b_clipped = xform_mul_v2(G.world_to_user_xf, collider_res.b1_clipped); struct v2 b_clipped = xform_mul_v2(G.world_to_user_xf, collider_res.b1_clipped);
draw_line(G.user_gpu_cmd_store, a_clipped, b_clipped, thickness, color_line_clipped); draw_line(G.user_gpu_cmd_list, a_clipped, b_clipped, thickness, color_line_clipped);
draw_circle(G.user_gpu_cmd_store, a_clipped, radius, color_a_clipped, 10); draw_circle(G.user_gpu_cmd_list, a_clipped, radius, color_a_clipped, 10);
draw_circle(G.user_gpu_cmd_store, b_clipped, radius, color_b_clipped, 10); draw_circle(G.user_gpu_cmd_list, b_clipped, radius, color_b_clipped, 10);
} }
} }
@ -1616,7 +1616,7 @@ INTERNAL void user_update(void)
FMT_FLOAT_P(xform_get_rotation(e1_xf), 24)); FMT_FLOAT_P(xform_get_rotation(e1_xf), 24));
draw_text(G.user_gpu_cmd_store, disp_font, v2_add(v2_round(xform_mul_v2(G.world_to_user_xf, V2(0, 0))), V2(0, offset_px)), text); draw_text(G.user_gpu_cmd_list, disp_font, v2_add(v2_round(xform_mul_v2(G.world_to_user_xf, V2(0, 0))), V2(0, offset_px)), text);
} }
} }
#endif #endif
@ -1632,8 +1632,8 @@ INTERNAL void user_update(void)
struct v2_array m = menkowski(temp.arena, &e0_collider, &e1_collider, e0_xf, e1_xf, detail); 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_to_user_xf, m.points[i]); for (u64 i = 0; i < m.count; ++i) m.points[i] = xform_mul_v2(G.world_to_user_xf, m.points[i]);
draw_poly_line(G.user_gpu_cmd_store, m, true, thickness, color); draw_poly_line(G.user_gpu_cmd_list, m, true, thickness, color);
//draw_poly(G.user_gpu_cmd_store, m, color); //draw_poly(G.user_gpu_cmd_list, m, color);
} }
/* Draw cloud */ /* Draw cloud */
@ -1645,7 +1645,7 @@ INTERNAL void user_update(void)
for (u64 i = 0; i < m.count; ++i) { for (u64 i = 0; i < m.count; ++i) {
struct v2 p = xform_mul_v2(G.world_to_user_xf, m.points[i]); struct v2 p = xform_mul_v2(G.world_to_user_xf, m.points[i]);
draw_circle(G.user_gpu_cmd_store, p, radius, color, 10); draw_circle(G.user_gpu_cmd_list, p, radius, color, 10);
} }
} }
@ -1659,8 +1659,8 @@ INTERNAL void user_update(void)
.count = collider_res.prototype.len .count = collider_res.prototype.len
}; };
for (u64 i = 0; i < m.count; ++i) m.points[i] = xform_mul_v2(G.world_to_user_xf, m.points[i]); for (u64 i = 0; i < m.count; ++i) m.points[i] = xform_mul_v2(G.world_to_user_xf, m.points[i]);
draw_poly_line(G.user_gpu_cmd_store, m, true, thickness, color); draw_poly_line(G.user_gpu_cmd_list, m, true, thickness, color);
for (u64 i = 0; i < m.count; ++i) draw_circle(G.user_gpu_cmd_store, m.points[i], 10, color, 10); for (u64 i = 0; i < m.count; ++i) draw_circle(G.user_gpu_cmd_list, m.points[i], 10, color, 10);
} }
/* Draw simplex */ /* Draw simplex */
@ -1678,18 +1678,18 @@ INTERNAL void user_update(void)
if (simplex.len >= 1) { if (simplex.len >= 1) {
u32 color = simplex.len == 1 ? color_first : (simplex.len == 2 ? color_second : color_third); u32 color = simplex.len == 1 ? color_first : (simplex.len == 2 ? color_second : color_third);
draw_circle(G.user_gpu_cmd_store, simplex_array.points[0], thickness * 3, color, 10); draw_circle(G.user_gpu_cmd_list, simplex_array.points[0], thickness * 3, color, 10);
} }
if (simplex.len >= 2) { if (simplex.len >= 2) {
u32 color = simplex.len == 2 ? color_first : color_second; u32 color = simplex.len == 2 ? color_first : color_second;
draw_circle(G.user_gpu_cmd_store, simplex_array.points[1], thickness * 3, color, 10); draw_circle(G.user_gpu_cmd_list, simplex_array.points[1], thickness * 3, color, 10);
} }
if (simplex.len >= 3) { if (simplex.len >= 3) {
u32 color = color_first; u32 color = color_first;
draw_circle(G.user_gpu_cmd_store, simplex_array.points[2], thickness * 3, color, 10); draw_circle(G.user_gpu_cmd_list, simplex_array.points[2], thickness * 3, color, 10);
} }
if (simplex.len >= 2) { if (simplex.len >= 2) {
draw_poly_line(G.user_gpu_cmd_store, simplex_array, simplex.len > 2, thickness, line_color); draw_poly_line(G.user_gpu_cmd_list, simplex_array, simplex.len > 2, thickness, line_color);
} }
} }
@ -1701,7 +1701,7 @@ INTERNAL void user_update(void)
f32 arrowhead_height = 10; f32 arrowhead_height = 10;
struct v2 start = xform_mul_v2(G.world_to_user_xf, V2(0, 0)); struct v2 start = xform_mul_v2(G.world_to_user_xf, V2(0, 0));
struct v2 end = xform_mul_v2(G.world_to_user_xf, v2_mul(v2_norm(collider_res.normal), len)); struct v2 end = xform_mul_v2(G.world_to_user_xf, v2_mul(v2_norm(collider_res.normal), len));
draw_arrow_line(G.user_gpu_cmd_store, start, end, arrow_thickness, arrowhead_height, color); draw_arrow_line(G.user_gpu_cmd_list, start, end, arrow_thickness, arrowhead_height, color);
} }
} }
#endif #endif
@ -1716,7 +1716,7 @@ INTERNAL void user_update(void)
struct v2 start = xform_mul_v2(G.world_to_user_xf, xf.og); struct v2 start = xform_mul_v2(G.world_to_user_xf, xf.og);
struct v2 end = xform_mul_v2(G.world_to_user_xf, parent_xf.og); struct v2 end = xform_mul_v2(G.world_to_user_xf, parent_xf.og);
draw_arrow_line(G.user_gpu_cmd_store, start, end, thickness, arrow_height, color); draw_arrow_line(G.user_gpu_cmd_list, start, end, thickness, arrow_height, color);
} }
/* Draw camera rect */ /* Draw camera rect */
@ -1728,7 +1728,7 @@ INTERNAL void user_update(void)
struct quad quad = xform_mul_quad(quad_xf, QUAD_UNIT_SQUARE_CENTERED); struct quad quad = xform_mul_quad(quad_xf, QUAD_UNIT_SQUARE_CENTERED);
quad = xform_mul_quad(G.world_to_user_xf, quad); quad = xform_mul_quad(G.world_to_user_xf, quad);
draw_quad_line(G.user_gpu_cmd_store, quad, thickness, color); draw_quad_line(G.user_gpu_cmd_list, quad, thickness, color);
} }
arena_temp_end(temp); arena_temp_end(temp);
@ -1746,7 +1746,7 @@ INTERNAL void user_update(void)
struct v2 size = V2(t->width, t->height); struct v2 size = V2(t->width, t->height);
struct xform xf = XFORM_TRS(.t = crosshair_pos, .s = size); struct xform xf = XFORM_TRS(.t = crosshair_pos, .s = size);
draw_texture(G.user_gpu_cmd_store, DRAW_TEXTURE_PARAMS(.xf = xf, .sprite = crosshair_tag)); draw_texture(G.user_gpu_cmd_list, DRAW_TEXTURE_PARAMS(.xf = xf, .sprite = crosshair_tag));
struct rect cursor_clip = RECT_FROM_V2(G.user_screen_offset, G.user_size); struct rect cursor_clip = RECT_FROM_V2(G.user_screen_offset, G.user_size);
cursor_clip.pos = v2_add(cursor_clip.pos, v2_mul(size, 0.5f)); cursor_clip.pos = v2_add(cursor_clip.pos, v2_mul(size, 0.5f));
@ -1944,7 +1944,7 @@ INTERNAL void user_update(void)
struct string dbg_text = ZI; struct string dbg_text = ZI;
dbg_text.text = arena_dry_push(temp.arena, u8); dbg_text.text = arena_dry_push(temp.arena, u8);
dbg_text.len += get_ent_debug_text(temp.arena, ent).len; dbg_text.len += get_ent_debug_text(temp.arena, ent).len;
draw_text(G.user_gpu_cmd_store, DRAW_TEXT_PARAMS(.font = font, .pos = pos, .str = dbg_text)); draw_text(G.user_gpu_cmd_list, DRAW_TEXT_PARAMS(.font = font, .pos = pos, .str = dbg_text));
arena_temp_end(temp); arena_temp_end(temp);
} }
@ -2044,16 +2044,16 @@ INTERNAL void user_update(void)
//text.len += string_copy(temp.arena, LIT("\n")).len; //text.len += string_copy(temp.arena, LIT("\n")).len;
#if COLLIDER_DEBUG #if COLLIDER_DEBUG
draw_text(G.user_gpu_cmd_store, font, pos, string_format(temp.arena, LIT("collider gjk steps: %F"), FMT_UINT(collider_debug_steps))); draw_text(G.user_gpu_cmd_list, font, pos, string_format(temp.arena, LIT("collider gjk steps: %F"), FMT_UINT(collider_debug_steps)));
pos.y += spacing; pos.y += spacing;
#endif #endif
//draw_text(G.user_gpu_cmd_store, font, pos, string_format(temp.arena, LIT("blended world entities: %F/%F"), FMT_UINT(G.ss_blended->num_ents_allocated), FMT_UINT(G.ss_blended->num_ents_reserved))); //draw_text(G.user_gpu_cmd_list, font, pos, string_format(temp.arena, LIT("blended world entities: %F/%F"), FMT_UINT(G.ss_blended->num_ents_allocated), FMT_UINT(G.ss_blended->num_ents_reserved)));
//draw_text(G.user_gpu_cmd_store, font, pos, text); //draw_text(G.user_gpu_cmd_list, font, pos, text);
struct v2 pos = V2(10, G.user_size.y); struct v2 pos = V2(10, G.user_size.y);
enum draw_text_offset_y offset_y = DRAW_TEXT_OFFSET_Y_BOTTOM; enum draw_text_offset_y offset_y = DRAW_TEXT_OFFSET_Y_BOTTOM;
draw_text(G.user_gpu_cmd_store, DRAW_TEXT_PARAMS(.font = font, .pos = pos, .str = text, .offset_y = offset_y, .color = COLOR_WHITE)); draw_text(G.user_gpu_cmd_list, DRAW_TEXT_PARAMS(.font = font, .pos = pos, .str = text, .offset_y = offset_y, .color = COLOR_WHITE));
arena_temp_end(temp); arena_temp_end(temp);
} }
} }
@ -2103,13 +2103,13 @@ INTERNAL void user_update(void)
{ {
struct xform xf = XFORM_TRS(.t = v2_mul(V2(backbuffer_resolution.x, backbuffer_resolution.y), 0.5), .s = G.user_size); struct xform xf = XFORM_TRS(.t = v2_mul(V2(backbuffer_resolution.x, backbuffer_resolution.y), 0.5), .s = G.user_size);
struct draw_texture_params params = DRAW_TEXTURE_PARAMS(.xf = xf, .texture = G.user_texture); struct draw_texture_params params = DRAW_TEXTURE_PARAMS(.xf = xf, .texture = G.user_texture);
draw_texture(G.backbuffer_gpu_cmd_store, params); draw_texture(G.backbuffer_gpu_cmd_list, params);
} }
/* Send cmds to GPU */ /* Send cmds to GPU */
gpu_submit_cmds(G.world_gpu_cmd_store); gpu_submit_cmds(G.world_gpu_cmd_list);
gpu_submit_cmds(G.user_gpu_cmd_store); gpu_submit_cmds(G.user_gpu_cmd_list);
gpu_submit_cmds(G.backbuffer_gpu_cmd_store); gpu_submit_cmds(G.backbuffer_gpu_cmd_list);
/* Clear textures */ /* Clear textures */
gpu_texture_clear(G.user_texture, 0); gpu_texture_clear(G.user_texture, 0);
@ -2117,10 +2117,10 @@ INTERNAL void user_update(void)
/* Render to user texture */ /* Render to user texture */
{ {
struct gpu_handle *dispatch_cmds[] = { &G.world_gpu_cmd_store, &G.user_gpu_cmd_store }; struct gpu_handle *dispatch_cmds[] = { &G.world_gpu_cmd_list, &G.user_gpu_cmd_list };
struct gpu_dispatch_params params = ZI; struct gpu_dispatch_params params = ZI;
params.cmds_array.stores = dispatch_cmds; params.cmd_lists.handles = dispatch_cmds;
params.cmds_array.count = ARRAY_COUNT(dispatch_cmds); params.cmd_lists.count = ARRAY_COUNT(dispatch_cmds);
params.draw_target = G.user_texture; params.draw_target = G.user_texture;
params.draw_target_viewport = user_viewport; params.draw_target_viewport = user_viewport;
gpu_dispatch(G.user_dispatch_state, params); gpu_dispatch(G.user_dispatch_state, params);
@ -2128,10 +2128,10 @@ INTERNAL void user_update(void)
/* Render to backbuffer texture */ /* Render to backbuffer texture */
{ {
struct gpu_handle *dispatch_cmds[] = { &G.backbuffer_gpu_cmd_store }; struct gpu_handle *dispatch_cmds[] = { &G.backbuffer_gpu_cmd_list };
struct gpu_dispatch_params params = ZI; struct gpu_dispatch_params params = ZI;
params.cmds_array.stores = dispatch_cmds; params.cmd_lists.handles = dispatch_cmds;
params.cmds_array.count = ARRAY_COUNT(dispatch_cmds); params.cmd_lists.count = ARRAY_COUNT(dispatch_cmds);
params.draw_target = G.backbuffer_texture; params.draw_target = G.backbuffer_texture;
params.draw_target_viewport = backbuffer_viewport; params.draw_target_viewport = backbuffer_viewport;
gpu_dispatch(G.backbuffer_dispatch_state, params); gpu_dispatch(G.backbuffer_dispatch_state, params);