diff --git a/src/draw.c b/src/draw.c index a822c367..a0d3cd01 100644 --- a/src/draw.c +++ b/src/draw.c @@ -28,7 +28,7 @@ struct draw_startup_receipt draw_startup(struct gp_startup_receipt *gp_sr, * Texture * ========================== */ -void draw_texture(struct gp_handle plan, struct draw_texture_params params) +void draw_texture(struct gp_handle flow, struct draw_texture_params params) { struct gp_cmd_params cmd = ZI; cmd.kind = GP_CMD_KIND_DRAW_TEXTURE; @@ -38,25 +38,25 @@ void draw_texture(struct gp_handle plan, struct draw_texture_params params) cmd.texture.clip = params.clip; cmd.texture.tint = params.tint; cmd.texture.emittance = params.emittance; - gp_push_cmd(plan, cmd); + gp_push_cmd(flow, cmd); } /* ========================== * * Fill shapes * ========================== */ -void draw_poly_ex(struct gp_handle plan, struct v2_array vertices, struct gp_indices indices, u32 color) +void draw_poly_ex(struct gp_handle flow, struct v2_array vertices, struct gp_indices indices, u32 color) { struct gp_cmd_params cmd = ZI; cmd.kind = GP_CMD_KIND_DRAW_MESH; cmd.mesh.vertices = vertices; cmd.mesh.indices = indices; cmd.mesh.color = color; - gp_push_cmd(plan, cmd); + gp_push_cmd(flow, cmd); } /* Draws a filled polygon using triangles in a fan pattern */ -void draw_poly(struct gp_handle plan, struct v2_array vertices, u32 color) +void draw_poly(struct gp_handle flow, struct v2_array vertices, u32 color) { if (vertices.count >= 3) { struct arena_temp scratch = scratch_begin_no_conflict(); @@ -76,13 +76,13 @@ void draw_poly(struct gp_handle plan, struct v2_array vertices, u32 color) indices.indices[tri_offset + 2] = (i + 2); } - draw_poly_ex(plan, vertices, indices, color); + draw_poly_ex(flow, vertices, indices, color); scratch_end(scratch); } } -void draw_circle(struct gp_handle plan, struct v2 pos, f32 radius, u32 color, u32 detail) +void draw_circle(struct gp_handle flow, struct v2 pos, f32 radius, u32 color, u32 detail) { struct arena_temp scratch = scratch_begin_no_conflict(); @@ -100,12 +100,12 @@ void draw_circle(struct gp_handle plan, struct v2 pos, f32 radius, u32 color, u3 .points = points, .count = detail }; - draw_poly(plan, vertices, color); + draw_poly(flow, vertices, color); scratch_end(scratch); } -void draw_quad(struct gp_handle plan, struct quad quad, u32 color) +void draw_quad(struct gp_handle flow, struct quad quad, u32 color) { LOCAL_PERSIST u32 indices_array[6] = { 0, 1, 2, @@ -113,57 +113,57 @@ void draw_quad(struct gp_handle plan, struct quad quad, u32 color) }; struct v2_array vertices = { .count = 4, .points = quad.e }; struct gp_indices indices = { .count = 6, .indices = indices_array }; - draw_poly_ex(plan, vertices, indices, color); + draw_poly_ex(flow, vertices, indices, color); } /* ========================== * * Line shapes * ========================== */ -void draw_gradient_line(struct gp_handle plan, struct v2 start, struct v2 end, f32 thickness, u32 start_color, u32 end_color) +void draw_gradient_line(struct gp_handle flow, struct v2 start, struct v2 end, f32 thickness, u32 start_color, u32 end_color) { #if 0 struct quad quad = quad_from_line(start, end, thickness); - draw_texture(plan, DRAW_TEXTURE_PARAMS(.texture = G.solid_white_texture, .tint0 = start_color, .tint1 = end_color, .quad = quad)); + draw_texture(flow, DRAW_TEXTURE_PARAMS(.texture = G.solid_white_texture, .tint0 = start_color, .tint1 = end_color, .quad = quad)); #else /* Placeholder */ (UNUSED)end_color; struct quad quad = quad_from_line(start, end, thickness); - draw_quad(plan, quad, start_color); + draw_quad(flow, quad, start_color); #endif } -void draw_line(struct gp_handle plan, struct v2 start, struct v2 end, f32 thickness, u32 color) +void draw_line(struct gp_handle flow, struct v2 start, struct v2 end, f32 thickness, u32 color) { struct quad quad = quad_from_line(start, end, thickness); - draw_quad(plan, quad, color); + draw_quad(flow, quad, color); } -void draw_ray(struct gp_handle plan, struct v2 pos, struct v2 rel, f32 thickness, u32 color) +void draw_ray(struct gp_handle flow, struct v2 pos, struct v2 rel, f32 thickness, u32 color) { struct quad quad = quad_from_ray(pos, rel, thickness); - draw_quad(plan, quad, color); + draw_quad(flow, quad, color); } -void draw_poly_line(struct gp_handle plan, struct v2_array points, b32 loop, f32 thickness, u32 color) +void draw_poly_line(struct gp_handle flow, struct v2_array points, b32 loop, f32 thickness, u32 color) { if (points.count >= 2) { for (u64 i = 1; i < points.count; ++i) { struct v2 p1 = points.points[i - 1]; struct v2 p2 = points.points[i]; struct quad q = quad_from_line(p1, p2, thickness); - draw_quad(plan, q, color); + draw_quad(flow, q, color); } if (loop && points.count > 2) { struct v2 p1 = points.points[points.count - 1]; struct v2 p2 = points.points[0]; struct quad q = quad_from_line(p1, p2, thickness); - draw_quad(plan, q, color); + draw_quad(flow, q, color); } } } -void draw_circle_line(struct gp_handle plan, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail) +void draw_circle_line(struct gp_handle flow, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail) { struct arena_temp scratch = scratch_begin_no_conflict(); @@ -181,19 +181,19 @@ void draw_circle_line(struct gp_handle plan, struct v2 pos, f32 radius, f32 thic .points = points, .count = detail }; - draw_poly_line(plan, a, true, thickness, color); + draw_poly_line(flow, a, true, thickness, color); scratch_end(scratch); } -void draw_quad_line(struct gp_handle plan, struct quad quad, f32 thickness, u32 color) +void draw_quad_line(struct gp_handle flow, struct quad quad, f32 thickness, u32 color) { struct v2 points[] = { quad.p0, quad.p1, quad.p2, quad.p3 }; struct v2_array a = { .points = points, .count = ARRAY_COUNT(points) }; - draw_poly_line(plan, a, true, thickness, color); + draw_poly_line(flow, a, true, thickness, color); } -void draw_arrow_line(struct gp_handle plan, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 color) +void draw_arrow_line(struct gp_handle flow, 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 */ @@ -217,19 +217,19 @@ void draw_arrow_line(struct gp_handle plan, struct v2 start, struct v2 end, f32 .points = head_points, .count = ARRAY_COUNT(head_points) }; - draw_poly(plan, head_points_v2_array, color); + draw_poly(flow, head_points_v2_array, color); struct quad line_quad = quad_from_line(start, head_start, thickness); - draw_quad(plan, line_quad, color); + draw_quad(flow, line_quad, color); } -void draw_arrow_ray(struct gp_handle plan, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 color) +void draw_arrow_ray(struct gp_handle flow, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 color) { struct v2 end = v2_add(pos, rel); - draw_arrow_line(plan, pos, end, thickness, arrowhead_height, color); + draw_arrow_line(flow, pos, end, thickness, arrowhead_height, color); } -void draw_collider_line(struct gp_handle plan, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 color, u32 detail) +void draw_collider_line(struct gp_handle flow, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 color, u32 detail) { struct arena_temp scratch = scratch_begin_no_conflict(); struct v2_array poly = ZI; @@ -250,7 +250,7 @@ void draw_collider_line(struct gp_handle plan, struct collider_shape shape, stru poly.points[i] = p; } } - draw_poly_line(plan, poly, true, thickness, color); + draw_poly_line(flow, poly, true, thickness, color); scratch_end(scratch); } @@ -258,7 +258,7 @@ void draw_collider_line(struct gp_handle plan, struct collider_shape shape, stru * Grid * ========================== */ -void draw_grid(struct gp_handle plan, 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 gp_handle flow, 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 gp_cmd_params cmd = ZI; cmd.kind = GP_CMD_KIND_DRAW_GRID; @@ -271,7 +271,7 @@ void draw_grid(struct gp_handle plan, struct xform xf, u32 bg0_color, u32 bg1_co cmd.grid.line_thickness = thickness; cmd.grid.line_spacing = spacing; cmd.grid.offset = offset; - gp_push_cmd(plan, cmd); + gp_push_cmd(flow, cmd); } /* ========================== * @@ -279,7 +279,7 @@ void draw_grid(struct gp_handle plan, struct xform xf, u32 bg0_color, u32 bg1_co * ========================== */ /* Returns the rect of the text area */ -struct rect draw_text(struct gp_handle plan, struct draw_text_params params) +struct rect draw_text(struct gp_handle flow, struct draw_text_params params) { struct arena_temp scratch = scratch_begin_no_conflict(); @@ -447,7 +447,7 @@ struct rect draw_text(struct gp_handle plan, struct draw_text_params params) 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 xform xf = xform_from_rect(RECT_FROM_V2(pos, size)); - draw_texture(plan, DRAW_TEXTURE_PARAMS(.xf = xf, .texture = params.font->texture, .tint = params.color, .clip = tg->clip)); + draw_texture(flow, DRAW_TEXTURE_PARAMS(.xf = xf, .texture = params.font->texture, .tint = params.color, .clip = tg->clip)); draw_pos.x += tg->advance; } diff --git a/src/draw.h b/src/draw.h index 12a1e620..b26001a8 100644 --- a/src/draw.h +++ b/src/draw.h @@ -29,47 +29,47 @@ struct draw_texture_params { f32 emittance; }; -void draw_texture(struct gp_handle plan, struct draw_texture_params params); +void draw_texture(struct gp_handle flow, struct draw_texture_params params); /* ========================== * * Fill shapes * ========================== */ -void draw_poly_ex(struct gp_handle plan, struct v2_array vertices, struct gp_indices indices, u32 color); +void draw_poly_ex(struct gp_handle flow, struct v2_array vertices, struct gp_indices indices, u32 color); -void draw_poly(struct gp_handle plan, struct v2_array points, u32 color); +void draw_poly(struct gp_handle flow, struct v2_array points, u32 color); -void draw_circle(struct gp_handle plan, struct v2 pos, f32 radius, u32 color, u32 detail); +void draw_circle(struct gp_handle flow, struct v2 pos, f32 radius, u32 color, u32 detail); -void draw_quad(struct gp_handle plan, struct quad quad, u32 color); +void draw_quad(struct gp_handle flow, struct quad quad, u32 color); /* ========================== * * Line shapes * ========================== */ -void draw_gradient_line(struct gp_handle plan, struct v2 start, struct v2 end, f32 thickness, u32 start_color, u32 end_color); +void draw_gradient_line(struct gp_handle flow, struct v2 start, struct v2 end, f32 thickness, u32 start_color, u32 end_color); -void draw_line(struct gp_handle plan, struct v2 start, struct v2 end, f32 thickness, u32 color); +void draw_line(struct gp_handle flow, struct v2 start, struct v2 end, f32 thickness, u32 color); -void draw_ray(struct gp_handle plan, struct v2 pos, struct v2 rel, f32 thickness, u32 color); +void draw_ray(struct gp_handle flow, struct v2 pos, struct v2 rel, f32 thickness, u32 color); -void draw_poly_line(struct gp_handle plan, struct v2_array points, b32 loop, f32 thickness, u32 color); +void draw_poly_line(struct gp_handle flow, struct v2_array points, b32 loop, f32 thickness, u32 color); -void draw_circle_line(struct gp_handle plan, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail); +void draw_circle_line(struct gp_handle flow, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail); -void draw_quad_line(struct gp_handle plan, struct quad quad, f32 thickness, u32 color); +void draw_quad_line(struct gp_handle flow, struct quad quad, f32 thickness, u32 color); -void draw_arrow_line(struct gp_handle plan, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 color); +void draw_arrow_line(struct gp_handle flow, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 color); -void draw_arrow_ray(struct gp_handle plan, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 color); +void draw_arrow_ray(struct gp_handle flow, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 color); -void draw_collider_line(struct gp_handle plan, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 color, u32 detail); +void draw_collider_line(struct gp_handle flow, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 color, u32 detail); /* ========================== * * Grid * ========================== */ -void draw_grid(struct gp_handle plan, 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 gp_handle flow, 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 @@ -117,6 +117,6 @@ struct draw_text_params { struct string str; }; -struct rect draw_text(struct gp_handle plan, struct draw_text_params params); +struct rect draw_text(struct gp_handle flow, struct draw_text_params params); #endif diff --git a/src/gp.h b/src/gp.h index 162edca8..06aa3665 100644 --- a/src/gp.h +++ b/src/gp.h @@ -109,16 +109,16 @@ struct gp_cmd_params { }; }; -struct gp_handle gp_plan_alloc(void); +struct gp_handle gp_flow_alloc(void); -void gp_push_cmd(struct gp_handle gp_plan, struct gp_cmd_params params); +void gp_push_cmd(struct gp_handle gp_flow, struct gp_cmd_params params); /* ========================== * * Dispatch * ========================== */ struct gp_dispatch_params { - struct gp_handle plan; + struct gp_handle flow; struct gp_handle draw_target; struct rect draw_target_viewport; struct xform draw_target_view; diff --git a/src/gp_dx11.c b/src/gp_dx11.c index d0310cf7..379d6324 100644 --- a/src/gp_dx11.c +++ b/src/gp_dx11.c @@ -78,7 +78,7 @@ enum dx11_shader_kind { enum dx11_handle_kind { DX11_HANDLE_KIND_NONE, DX11_HANDLE_KIND_TEXTURE, - DX11_HANDLE_KIND_PLAN, + DX11_HANDLE_KIND_FLOW, NUM_DX11_HANDLE_KINDS }; @@ -157,7 +157,7 @@ struct dx11_cmd { struct dx11_cmd *next; }; -struct dx11_plan { +struct dx11_flow { struct dx11_handle_header header; /* Commands w/ data still in cpu memory */ @@ -188,7 +188,7 @@ struct dx11_plan { struct dx11_buffer *constant_buffer; - struct dx11_plan *next_free; + struct dx11_flow *next_free; }; struct dx11_texture { @@ -245,10 +245,10 @@ GLOBAL struct { struct arena *buffers_arena; struct dx11_buffer *first_free_buffer; - /* Plan pool */ - struct sys_mutex *plans_mutex; - struct arena *plans_arena; - struct dx11_plan *first_free_plan; + /* Flow pool */ + struct sys_mutex *flows_mutex; + struct arena *flows_arena; + struct dx11_flow *first_free_flow; /* Dispatch state pool */ struct sys_mutex *dispatch_states_mutex; @@ -268,8 +268,8 @@ GLOBAL struct { struct dx11_buffer *dummy_vertex_buffer; struct dx11_buffer *quad_index_buffer; - /* Blit plan */ - struct gp_handle present_blit_plan; + /* Blit flow */ + struct gp_handle present_blit_flow; } G = ZI, DEBUG_ALIAS(G, G_gp_dx11); @@ -296,9 +296,9 @@ struct gp_startup_receipt gp_startup(struct work_startup_receipt *work_sr, struc G.buffers_mutex = sys_mutex_alloc(); G.buffers_arena = arena_alloc(GIGABYTE(64)); - /* Initialize plans pool */ - G.plans_mutex = sys_mutex_alloc(); - G.plans_arena = arena_alloc(GIGABYTE(64)); + /* Initialize flows pool */ + G.flows_mutex = sys_mutex_alloc(); + G.flows_arena = arena_alloc(GIGABYTE(64)); /* Initialize dispatch state pool */ G.dispatch_states_mutex = sys_mutex_alloc(); @@ -539,7 +539,7 @@ struct gp_startup_receipt gp_startup(struct work_startup_receipt *work_sr, struc resource_register_watch_callback(shader_resource_watch_callback); #endif - G.present_blit_plan = gp_plan_alloc(); + G.present_blit_flow = gp_flow_alloc(); return (struct gp_startup_receipt) { 0 }; } @@ -573,7 +573,7 @@ void gp_release(struct gp_handle handle) dx11_texture_release((struct dx11_texture *)header); } break; - case DX11_HANDLE_KIND_PLAN: + case DX11_HANDLE_KIND_FLOW: { /* TODO */ ASSERT(false); @@ -1280,41 +1280,41 @@ INTERNAL void dx11_buffer_submit(struct dx11_buffer *buffer) } /* ========================== * - * Plan + * Flow * ========================== */ -struct gp_handle gp_plan_alloc(void) +struct gp_handle gp_flow_alloc(void) { __prof; - struct dx11_plan *plan = NULL; + struct dx11_flow *flow = NULL; { struct arena *cpu_cmds_arena = NULL; struct arena *gp_cmds_arena = NULL; { - struct sys_lock lock = sys_mutex_lock_e(G.plans_mutex); - if (G.first_free_plan) { - plan = G.first_free_plan; - G.first_free_plan = plan->next_free; - cpu_cmds_arena = plan->cpu_cmds_arena; - gp_cmds_arena = plan->gp_cmds_arena; + struct sys_lock lock = sys_mutex_lock_e(G.flows_mutex); + if (G.first_free_flow) { + flow = G.first_free_flow; + G.first_free_flow = flow->next_free; + cpu_cmds_arena = flow->cpu_cmds_arena; + gp_cmds_arena = flow->gp_cmds_arena; } else { - plan = arena_push_no_zero(G.plans_arena, struct dx11_plan); + flow = arena_push_no_zero(G.flows_arena, struct dx11_flow); } sys_mutex_unlock(&lock); } - MEMZERO_STRUCT(plan); + MEMZERO_STRUCT(flow); if (!cpu_cmds_arena) { cpu_cmds_arena = arena_alloc(GIGABYTE(64)); } if (!gp_cmds_arena) { gp_cmds_arena = arena_alloc(GIGABYTE(64)); } - plan->cpu_cmds_arena = cpu_cmds_arena; - plan->gp_cmds_arena = gp_cmds_arena; - arena_reset(plan->cpu_cmds_arena); - arena_reset(plan->gp_cmds_arena); + flow->cpu_cmds_arena = cpu_cmds_arena; + flow->gp_cmds_arena = gp_cmds_arena; + arena_reset(flow->cpu_cmds_arena); + arena_reset(flow->gp_cmds_arena); } - plan->header.kind = DX11_HANDLE_KIND_PLAN; + flow->header.kind = DX11_HANDLE_KIND_FLOW; /* Desc template */ const D3D11_BUFFER_DESC structured_buffer_desc = { @@ -1339,41 +1339,41 @@ struct gp_handle gp_plan_alloc(void) idesc.BindFlags = D3D11_BIND_INDEX_BUFFER; idesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; - plan->cmd_buffers.mesh.vertex_buffer = dx11_buffer_alloc(vdesc, NULL); - plan->cmd_buffers.mesh.index_buffer = dx11_buffer_alloc(idesc, NULL); + flow->cmd_buffers.mesh.vertex_buffer = dx11_buffer_alloc(vdesc, NULL); + flow->cmd_buffers.mesh.index_buffer = dx11_buffer_alloc(idesc, NULL); } /* Texture buffers */ { struct D3D11_BUFFER_DESC desc = structured_buffer_desc; desc.StructureByteStride = sizeof(struct dx11_texture_instance); - plan->cmd_buffers.texture.instance_buffer = dx11_buffer_alloc(desc, NULL); + flow->cmd_buffers.texture.instance_buffer = dx11_buffer_alloc(desc, NULL); } /* Grid buffers */ { struct D3D11_BUFFER_DESC desc = structured_buffer_desc; desc.StructureByteStride = sizeof(struct dx11_grid_instance); - plan->cmd_buffers.grid.instance_buffer = dx11_buffer_alloc(desc, NULL); + flow->cmd_buffers.grid.instance_buffer = dx11_buffer_alloc(desc, NULL); } /* Test buffers */ { struct D3D11_BUFFER_DESC desc = structured_buffer_desc; desc.StructureByteStride = sizeof(struct dx11_test_instance); - plan->cmd_buffers.test.instance_buffer = dx11_buffer_alloc(desc, NULL); + flow->cmd_buffers.test.instance_buffer = dx11_buffer_alloc(desc, NULL); } } struct gp_handle res = ZI; - res.v = (u64)plan; + res.v = (u64)flow; return res; } -void gp_push_cmd(struct gp_handle gp_plan, struct gp_cmd_params params) +void gp_push_cmd(struct gp_handle gp_flow, struct gp_cmd_params params) { __prof; - struct dx11_plan *plan = (struct dx11_plan *)gp_plan.v; + struct dx11_flow *flow = (struct dx11_flow *)gp_flow.v; switch (params.kind) { default: @@ -1384,7 +1384,7 @@ void gp_push_cmd(struct gp_handle gp_plan, struct gp_cmd_params params) case GP_CMD_KIND_DRAW_MESH: { - struct dx11_cmd *cmd = plan->cpu_last_cmd; + struct dx11_cmd *cmd = flow->cpu_last_cmd; if (cmd && cmd->kind != params.kind) { /* Cannot batch */ cmd = NULL; @@ -1393,23 +1393,23 @@ void gp_push_cmd(struct gp_handle gp_plan, struct gp_cmd_params params) /* Start new cmd */ if (!cmd) { /* TODO: Better count method */ - cmd = arena_push(plan->cpu_cmds_arena, struct dx11_cmd); + cmd = arena_push(flow->cpu_cmds_arena, struct dx11_cmd); cmd->kind = params.kind; - cmd->mesh.vertex_offset = (plan->cmd_buffers.mesh.vertex_buffer->cpu_buffer_arena->pos / sizeof(struct dx11_mesh_vertex)); - cmd->mesh.index_offset = (plan->cmd_buffers.mesh.index_buffer->cpu_buffer_arena->pos / sizeof(u32)); - if (plan->cpu_last_cmd) { - plan->cpu_last_cmd->next = cmd; + cmd->mesh.vertex_offset = (flow->cmd_buffers.mesh.vertex_buffer->cpu_buffer_arena->pos / sizeof(struct dx11_mesh_vertex)); + cmd->mesh.index_offset = (flow->cmd_buffers.mesh.index_buffer->cpu_buffer_arena->pos / sizeof(u32)); + if (flow->cpu_last_cmd) { + flow->cpu_last_cmd->next = cmd; } else { - plan->cpu_first_cmd = cmd; + flow->cpu_first_cmd = cmd; } - plan->cpu_last_cmd = cmd; + flow->cpu_last_cmd = cmd; } /* Push vertices */ u64 vertex_count = params.mesh.vertices.count; u64 start_index = cmd->mesh.vertex_count; cmd->mesh.vertex_count += vertex_count; - struct dx11_mesh_vertex *verts = dx11_buffer_push(plan->cmd_buffers.mesh.vertex_buffer, sizeof(struct dx11_mesh_vertex) * vertex_count); + struct dx11_mesh_vertex *verts = dx11_buffer_push(flow->cmd_buffers.mesh.vertex_buffer, sizeof(struct dx11_mesh_vertex) * vertex_count); for (u64 i = 0; i < vertex_count; ++i) { struct dx11_mesh_vertex *vert = &verts[i]; vert->pos = params.mesh.vertices.points[i]; @@ -1418,7 +1418,7 @@ void gp_push_cmd(struct gp_handle gp_plan, struct gp_cmd_params params) /* Push indices */ u64 index_count = params.mesh.indices.count; - u32 *indices = dx11_buffer_push(plan->cmd_buffers.mesh.index_buffer, sizeof(u32) * index_count); + u32 *indices = dx11_buffer_push(flow->cmd_buffers.mesh.index_buffer, sizeof(u32) * index_count); cmd->mesh.index_count += index_count; for (u64 i = 0; i < index_count; ++i) { indices[i] = start_index + params.mesh.indices.indices[i]; @@ -1427,7 +1427,7 @@ void gp_push_cmd(struct gp_handle gp_plan, struct gp_cmd_params params) case GP_CMD_KIND_DRAW_TEXTURE: { - struct dx11_cmd *cmd = plan->cpu_last_cmd; + struct dx11_cmd *cmd = flow->cpu_last_cmd; if (cmd && ((cmd->kind != params.kind) || (cmd->texture.sprite.hash != params.texture.sprite.hash) || @@ -1439,22 +1439,22 @@ void gp_push_cmd(struct gp_handle gp_plan, struct gp_cmd_params params) /* Start new cmd */ if (!cmd) { /* TODO: Better count method */ - cmd = arena_push(plan->cpu_cmds_arena, struct dx11_cmd); + cmd = arena_push(flow->cpu_cmds_arena, struct dx11_cmd); cmd->kind = params.kind; cmd->texture.sprite = params.texture.sprite; cmd->texture.texture = params.texture.texture; - cmd->texture.instance_offset = (plan->cmd_buffers.texture.instance_buffer->cpu_buffer_arena->pos / sizeof(struct dx11_texture_instance)); - if (plan->cpu_last_cmd) { - plan->cpu_last_cmd->next = cmd; + cmd->texture.instance_offset = (flow->cmd_buffers.texture.instance_buffer->cpu_buffer_arena->pos / sizeof(struct dx11_texture_instance)); + if (flow->cpu_last_cmd) { + flow->cpu_last_cmd->next = cmd; } else { - plan->cpu_first_cmd = cmd; + flow->cpu_first_cmd = cmd; } - plan->cpu_last_cmd = cmd; + flow->cpu_last_cmd = cmd; } /* Push instance data */ ++cmd->texture.instance_count; - struct dx11_texture_instance *instance = dx11_buffer_push(plan->cmd_buffers.texture.instance_buffer, sizeof(struct dx11_texture_instance)); + struct dx11_texture_instance *instance = dx11_buffer_push(flow->cmd_buffers.texture.instance_buffer, sizeof(struct dx11_texture_instance)); instance->xf = params.texture.xf; instance->uv0 = params.texture.clip.p0; instance->uv1 = params.texture.clip.p1; @@ -1464,7 +1464,7 @@ void gp_push_cmd(struct gp_handle gp_plan, struct gp_cmd_params params) case GP_CMD_KIND_DRAW_GRID: { - struct dx11_cmd *cmd = plan->cpu_last_cmd; + struct dx11_cmd *cmd = flow->cpu_last_cmd; if (cmd && cmd->kind != params.kind) { /* Cannot batch */ cmd = NULL; @@ -1473,20 +1473,20 @@ void gp_push_cmd(struct gp_handle gp_plan, struct gp_cmd_params params) /* Start new cmd */ if (!cmd) { /* TODO: Better count method */ - cmd = arena_push(plan->cpu_cmds_arena, struct dx11_cmd); + cmd = arena_push(flow->cpu_cmds_arena, struct dx11_cmd); cmd->kind = params.kind; - cmd->grid.instance_offset = (plan->cmd_buffers.grid.instance_buffer->cpu_buffer_arena->pos / sizeof(struct dx11_grid_instance)); - if (plan->cpu_last_cmd) { - plan->cpu_last_cmd->next = cmd; + cmd->grid.instance_offset = (flow->cmd_buffers.grid.instance_buffer->cpu_buffer_arena->pos / sizeof(struct dx11_grid_instance)); + if (flow->cpu_last_cmd) { + flow->cpu_last_cmd->next = cmd; } else { - plan->cpu_first_cmd = cmd; + flow->cpu_first_cmd = cmd; } - plan->cpu_last_cmd = cmd; + flow->cpu_last_cmd = cmd; } /* Push instance data */ ++cmd->grid.instance_count; - struct dx11_grid_instance *instance = dx11_buffer_push(plan->cmd_buffers.grid.instance_buffer, sizeof(struct dx11_grid_instance)); + struct dx11_grid_instance *instance = dx11_buffer_push(flow->cmd_buffers.grid.instance_buffer, sizeof(struct dx11_grid_instance)); instance->xf = params.grid.xf; instance->line_thickness = params.grid.line_thickness; instance->line_spacing = params.grid.line_spacing; @@ -1500,19 +1500,19 @@ void gp_push_cmd(struct gp_handle gp_plan, struct gp_cmd_params params) case GP_CMD_KIND_TEST: { - struct dx11_cmd *cmd = arena_push(plan->cpu_cmds_arena, struct dx11_cmd); + struct dx11_cmd *cmd = arena_push(flow->cpu_cmds_arena, struct dx11_cmd); cmd->kind = params.kind; - cmd->test.instance_offset = (plan->cmd_buffers.test.instance_buffer->cpu_buffer_arena->pos / sizeof(struct dx11_test_instance)); - if (plan->cpu_last_cmd) { - plan->cpu_last_cmd->next = cmd; + cmd->test.instance_offset = (flow->cmd_buffers.test.instance_buffer->cpu_buffer_arena->pos / sizeof(struct dx11_test_instance)); + if (flow->cpu_last_cmd) { + flow->cpu_last_cmd->next = cmd; } else { - plan->cpu_first_cmd = cmd; + flow->cpu_first_cmd = cmd; } - plan->cpu_last_cmd = cmd; + flow->cpu_last_cmd = cmd; /* Push instance data */ ++cmd->test.instance_count; - struct dx11_test_instance *instance = dx11_buffer_push(plan->cmd_buffers.test.instance_buffer, sizeof(struct dx11_test_instance)); + struct dx11_test_instance *instance = dx11_buffer_push(flow->cmd_buffers.test.instance_buffer, sizeof(struct dx11_test_instance)); instance->xf = params.test.xf; } break; } @@ -1593,36 +1593,36 @@ void gp_dispatch(struct gp_dispatch_params params) { __prof; __profscope_dx11(G.profiling_ctx, Dispatch, RGB32_F(0.5, 0.2, 0.2)); - struct dx11_plan *plan = (struct dx11_plan *)params.plan.v; + struct dx11_flow *flow = (struct dx11_flow *)params.flow.v; /* Swap cmd lists */ - struct arena *swp_arena = plan->gp_cmds_arena; - plan->gp_cmds_arena = plan->cpu_cmds_arena; - plan->gpu_first_cmd = plan->cpu_first_cmd; - plan->gpu_last_cmd = plan->cpu_last_cmd; + struct arena *swp_arena = flow->gp_cmds_arena; + flow->gp_cmds_arena = flow->cpu_cmds_arena; + flow->gpu_first_cmd = flow->cpu_first_cmd; + flow->gpu_last_cmd = flow->cpu_last_cmd; /* Reset cpu cmd list */ - plan->cpu_cmds_arena = swp_arena; - plan->cpu_first_cmd = NULL; - plan->cpu_last_cmd = NULL; - arena_reset(plan->cpu_cmds_arena); + flow->cpu_cmds_arena = swp_arena; + flow->cpu_first_cmd = NULL; + flow->cpu_last_cmd = NULL; + arena_reset(flow->cpu_cmds_arena); /* Submit cmd data */ { __profscope(Submit buffers); /* Submit mesh buffers */ - dx11_buffer_submit(plan->cmd_buffers.mesh.vertex_buffer); - dx11_buffer_submit(plan->cmd_buffers.mesh.index_buffer); + dx11_buffer_submit(flow->cmd_buffers.mesh.vertex_buffer); + dx11_buffer_submit(flow->cmd_buffers.mesh.index_buffer); /* Submit texture buffers */ - dx11_buffer_submit(plan->cmd_buffers.texture.instance_buffer); + dx11_buffer_submit(flow->cmd_buffers.texture.instance_buffer); /* Submit grid buffers */ - dx11_buffer_submit(plan->cmd_buffers.grid.instance_buffer); + dx11_buffer_submit(flow->cmd_buffers.grid.instance_buffer); /* Submit test buffers */ - dx11_buffer_submit(plan->cmd_buffers.test.instance_buffer); + dx11_buffer_submit(flow->cmd_buffers.test.instance_buffer); } struct sprite_scope *sprite_scope = sprite_scope_begin(); @@ -1642,7 +1642,7 @@ void gp_dispatch(struct gp_dispatch_params params) struct dx11_texture *final_tex = (struct dx11_texture *)params.draw_target.v; /* Allocate constant buffer */ - struct dx11_buffer *constant_buffer = plan->constant_buffer; + struct dx11_buffer *constant_buffer = flow->constant_buffer; if (!constant_buffer) { const D3D11_BUFFER_DESC desc = { .Usage = D3D11_USAGE_DYNAMIC, @@ -1650,7 +1650,7 @@ void gp_dispatch(struct gp_dispatch_params params) .CPUAccessFlags = D3D11_CPU_ACCESS_WRITE }; constant_buffer = dx11_buffer_alloc(desc, NULL); - plan->constant_buffer = constant_buffer; + flow->constant_buffer = constant_buffer; } /* Regular pass */ @@ -1658,7 +1658,7 @@ void gp_dispatch(struct gp_dispatch_params params) { __profscope(Regular pass); __profscope_dx11(G.profiling_ctx, Regular pass, RGB32_F(0.2, 0.5, 0.5)); - for (struct dx11_cmd *cmd = plan->gpu_first_cmd; cmd; cmd = cmd->next) { + for (struct dx11_cmd *cmd = flow->gpu_first_cmd; cmd; cmd = cmd->next) { enum gp_cmd_kind cmd_kind = cmd->kind; switch (cmd_kind) { @@ -1674,8 +1674,8 @@ void gp_dispatch(struct gp_dispatch_params params) __profscope_dx11(G.profiling_ctx, Draw mesh, RGB32_F(0.5, 0.2, 0.2)); struct dx11_shader *shader = &G.shaders[DX11_SHADER_KIND_MESH]; if (shader->valid) { - struct dx11_buffer *vertex_buffer = plan->cmd_buffers.mesh.vertex_buffer; - struct dx11_buffer *index_buffer = plan->cmd_buffers.mesh.index_buffer; + struct dx11_buffer *vertex_buffer = flow->cmd_buffers.mesh.vertex_buffer; + struct dx11_buffer *index_buffer = flow->cmd_buffers.mesh.index_buffer; u32 vertex_offset = cmd->mesh.vertex_offset; u32 index_offset = cmd->mesh.index_offset; @@ -1733,7 +1733,7 @@ void gp_dispatch(struct gp_dispatch_params params) } if (texture && texture->srv) { - struct dx11_buffer *instance_buffer = plan->cmd_buffers.texture.instance_buffer; + struct dx11_buffer *instance_buffer = flow->cmd_buffers.texture.instance_buffer; u32 instance_offset = cmd->texture.instance_offset; u32 instance_count = cmd->texture.instance_count; @@ -1781,7 +1781,7 @@ void gp_dispatch(struct gp_dispatch_params params) __profscope_dx11(G.profiling_ctx, Draw grid, RGB32_F(0.2, 0.2, 0.5)); struct dx11_shader *shader = &G.shaders[DX11_SHADER_KIND_GRID]; if (shader->valid) { - struct dx11_buffer *instance_buffer = plan->cmd_buffers.grid.instance_buffer; + struct dx11_buffer *instance_buffer = flow->cmd_buffers.grid.instance_buffer; u32 instance_offset = cmd->grid.instance_offset; u32 instance_count = cmd->grid.instance_count; @@ -1828,7 +1828,7 @@ void gp_dispatch(struct gp_dispatch_params params) __profscope_dx11(G.profiling_ctx, Test, RGB32_F(1, 0.2, 1)); struct dx11_shader *shader = &G.shaders[DX11_SHADER_KIND_TEST]; if (shader->valid) { - struct dx11_buffer *instance_buffer = plan->cmd_buffers.test.instance_buffer; + struct dx11_buffer *instance_buffer = flow->cmd_buffers.test.instance_buffer; u32 instance_offset = cmd->test.instance_offset; u32 instance_count = cmd->test.instance_count; @@ -1963,7 +1963,7 @@ INTERNAL void present_blit(struct dx11_texture *dst, struct dx11_texture *src, s /* TODO: Specialized blit shader */ { struct draw_texture_params params = DRAW_TEXTURE_PARAMS(.xf = src_xf, .texture = src_texture_handle); - draw_texture(G.present_blit_plan, params); + draw_texture(G.present_blit_flow, params); } /* Clear textures */ @@ -1972,7 +1972,7 @@ INTERNAL void present_blit(struct dx11_texture *dst, struct dx11_texture *src, s /* Render to backbuffer texture */ { struct gp_dispatch_params params = ZI; - params.plan = G.present_blit_plan; + params.flow = G.present_blit_flow; params.draw_target = dst_texture_handle; params.draw_target_viewport = RECT_FROM_V2(V2(0, 0), V2(dst->size.x, dst->size.y)); params.draw_target_view = XFORM_IDENT; diff --git a/src/gp_dx12.c b/src/gp_dx12.c index 2ab3088e..3369567f 100644 --- a/src/gp_dx12.c +++ b/src/gp_dx12.c @@ -190,7 +190,7 @@ struct cpu_descriptor_heap { enum handle_kind { DX12_HANDLE_KIND_NONE, DX12_HANDLE_KIND_RESOURCE, - DX12_HANDLE_KIND_PLAN, + DX12_HANDLE_KIND_FLOW, NUM_DX12_HANDLE_KINDS }; @@ -1230,41 +1230,41 @@ INTERNAL void cpu_descriptor_heap_release(struct cpu_descriptor_heap *dh) #endif /* ========================== * - * Plan + * Flow * ========================== */ - /* TODO: Move command list out of plan struct */ -struct plan { + /* TODO: Move command list out of flow struct */ +struct flow { struct arena *arena; struct arena *material_instances_arena; - struct plan *next_free; + struct flow *next_free; }; -INTERNAL struct plan *plan_alloc(void) +INTERNAL struct flow *flow_alloc(void) { - struct plan *plan = NULL; + struct flow *flow = NULL; { struct arena *arena = arena_alloc(MEGABYTE(64)); - plan = arena_push(arena, struct plan); - plan->arena = arena; + flow = arena_push(arena, struct flow); + flow->arena = arena; } - plan->material_instances_arena = arena_alloc(GIGABYTE(1)); + flow->material_instances_arena = arena_alloc(GIGABYTE(1)); - return plan; + return flow; } -struct gp_handle gp_plan_alloc(void) +struct gp_handle gp_flow_alloc(void) { - struct plan *plan = plan_alloc(); - return handle_alloc(DX12_HANDLE_KIND_PLAN, plan); + struct flow *flow = flow_alloc(); + return handle_alloc(DX12_HANDLE_KIND_FLOW, flow); } -void gp_push_cmd(struct gp_handle gp_plan, struct gp_cmd_params params) +void gp_push_cmd(struct gp_handle gp_flow, struct gp_cmd_params params) { - (UNUSED)gp_plan; + (UNUSED)gp_flow; (UNUSED)params; } @@ -1856,7 +1856,7 @@ void gp_dispatch(struct gp_dispatch_params params) { __prof; - struct plan *plan = handle_get_data(params.plan, DX12_HANDLE_KIND_PLAN); + struct flow *flow = handle_get_data(params.flow, DX12_HANDLE_KIND_FLOW); struct dx12_resource *target = handle_get_data(params.draw_target, DX12_HANDLE_KIND_RESOURCE); struct command_queue *cq = G.cq_direct; @@ -1867,7 +1867,6 @@ void gp_dispatch(struct gp_dispatch_params params) /* Dummy vertex buffer */ LOCAL_PERSIST u16 quad_indices[6] = { 0, 1, 2, 0, 2, 3 }; struct command_buffer *dummy_vertex_buffer = command_list_push_buffer(cl, STRING(0, 0)); - struct command_buffer *quad_index_buffer = command_list_push_buffer(cl, STRING_FROM_ARRAY(quad_indices)); D3D12_VERTEX_BUFFER_VIEW dummy_vertex_buffer_view = ZI; dummy_vertex_buffer_view.BufferLocation = dummy_vertex_buffer->resource->gpu_address; @@ -1877,8 +1876,8 @@ void gp_dispatch(struct gp_dispatch_params params) quad_index_buffer_view.SizeInBytes = sizeof(quad_indices); /* Upload instance buffer */ - struct command_buffer *instance_buffer = command_list_push_buffer(cl, STRING_FROM_ARENA(plan->material_instances_arena)); - arena_reset(plan->material_instances_arena); + struct command_buffer *instance_buffer = command_list_push_buffer(cl, STRING_FROM_ARENA(flow->material_instances_arena)); + arena_reset(flow->material_instances_arena); /* Upload descriptor heap */ struct command_descriptor_heap *descriptor_heap = command_list_push_descriptor_heap(cl, G.cbv_srv_uav_heap); diff --git a/src/user.c b/src/user.c index d7f02e19..4a01d181 100644 --- a/src/user.c +++ b/src/user.c @@ -73,8 +73,8 @@ GLOBAL struct { /* Gpu handles */ struct gp_handle user_texture; - struct gp_handle world_gp_plan; - struct gp_handle ui_gp_plan; + struct gp_handle world_gp_flow; + struct gp_handle ui_gp_flow; struct xform world_to_user_xf; @@ -253,8 +253,8 @@ struct user_startup_receipt user_startup(struct work_startup_receipt *work_sr, /* GPU handles */ G.world_to_user_xf = XFORM_IDENT; - G.world_gp_plan = gp_plan_alloc(); - G.ui_gp_plan = gp_plan_alloc(); + G.world_gp_flow = gp_flow_alloc(); + G.ui_gp_flow = gp_flow_alloc(); G.console_logs_mutex = sys_mutex_alloc(); G.console_logs_arena = arena_alloc(GIGABYTE(64)); @@ -341,13 +341,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_gp_plan, pos, x_ray, thickness, arrowhead_len, color_x); - draw_arrow_ray(G.ui_gp_plan, pos, y_ray, thickness, arrowhead_len, color_y); + draw_arrow_ray(G.ui_gp_flow, pos, x_ray, thickness, arrowhead_len, color_x); + draw_arrow_ray(G.ui_gp_flow, pos, y_ray, thickness, arrowhead_len, color_y); //u32 color_quad = RGBA32_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_gp_plan, quad, color); + //draw_quad(G.ui_gp_flow, quad, color); } INTERNAL void debug_draw_movement(struct sim_ent *ent) @@ -364,7 +364,7 @@ INTERNAL void debug_draw_movement(struct sim_ent *ent) struct v2 vel_ray = xform_basis_mul_v2(G.world_to_user_xf, velocity); if (v2_len(vel_ray) > 0.00001) { - draw_arrow_ray(G.ui_gp_plan, pos, vel_ray, thickness, arrow_len, color_vel); + draw_arrow_ray(G.ui_gp_flow, pos, vel_ray, thickness, arrow_len, color_vel); } } @@ -534,7 +534,7 @@ INTERNAL void draw_debug_console(i32 level, b32 minimized) if (log->level <= level) { /* Draw background */ u32 color = colors[log->level][log->color_index]; - draw_quad(G.ui_gp_plan, quad_from_rect(log->bounds), ALPHA32_F(color, opacity)); + draw_quad(G.ui_gp_flow, quad_from_rect(log->bounds), ALPHA32_F(color, opacity)); /* Draw text */ struct string text = log->msg; @@ -551,7 +551,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 = ALPHA32_F(COLOR_WHITE, opacity), .str = text); - struct rect bounds = draw_text(G.ui_gp_plan, params); + struct rect bounds = draw_text(G.ui_gp_flow, params); struct rect draw_bounds = bounds; draw_bounds.x -= bg_margin; @@ -1050,7 +1050,7 @@ INTERNAL void user_update(void) struct v2 size = xform_basis_invert_mul_v2(G.world_to_user_xf, G.user_size); u32 color0 = RGBA32_F(0.17f, 0.17f, 0.17f, 1.f); u32 color1 = RGBA32_F(0.15f, 0.15f, 0.15f, 1.f); - draw_grid(G.world_gp_plan, xform_from_rect(RECT_FROM_V2(pos, size)), color0, color1, RGBA32(0x3f, 0x3f, 0x3f, 0xFF), COLOR_RED, COLOR_GREEN, thickness, spacing, offset); + draw_grid(G.world_gp_flow, xform_from_rect(RECT_FROM_V2(pos, size)), color0, color1, RGBA32(0x3f, 0x3f, 0x3f, 0xFF), COLOR_RED, COLOR_GREEN, thickness, spacing, offset); } /* ========================== * @@ -1063,7 +1063,7 @@ INTERNAL void user_update(void) struct gp_cmd_params cmd = ZI; cmd.kind = GP_CMD_KIND_TEST; cmd.test.xf = xform_from_rect(RECT_FROM_V2(pos, size)); - gp_push_cmd(G.world_gp_plan, cmd); + gp_push_cmd(G.world_gp_flow, cmd); } #if 0 @@ -1245,9 +1245,9 @@ INTERNAL void user_update(void) u32 color_end = RGBA32_F(1, 0.8, 0.4, opacity_b); if (opacity_b > 0.99f) { - draw_circle(G.world_gp_plan, b, thickness / 2, color_end, 20); + draw_circle(G.world_gp_flow, b, thickness / 2, color_end, 20); } - draw_gradient_line(G.world_gp_plan, a, b, thickness, color_start, color_end); + draw_gradient_line(G.world_gp_flow, a, b, thickness, color_start, color_end); } @@ -1263,7 +1263,7 @@ INTERNAL void user_update(void) u32 tint = ent->sprite_tint; 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); - draw_texture(G.world_gp_plan, params); + draw_texture(G.world_gp_flow, params); } } @@ -1283,7 +1283,7 @@ INTERNAL void user_update(void) 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 draw_texture_params params = DRAW_TEXTURE_PARAMS(.xf = tile_xf, .sprite = tile_sprite); - draw_texture(G.world_gp_plan, params); + draw_texture(G.world_gp_flow, params); } } } @@ -1311,7 +1311,7 @@ INTERNAL void user_update(void) u32 color = RGBA32_F(1, 0, 1, 0.5); struct quad quad = quad_from_aabb(aabb); quad = xform_mul_quad(G.world_to_user_xf, quad); - draw_quad_line(G.ui_gp_plan, quad, thickness, color); + draw_quad_line(G.ui_gp_flow, quad, thickness, color); } /* Draw focus arrow */ @@ -1322,7 +1322,7 @@ INTERNAL void user_update(void) start = xform_mul_v2(G.world_to_user_xf, start); struct v2 end = v2_add(xf.og, ent->control.focus); end = xform_mul_v2(G.world_to_user_xf, end); - draw_arrow_line(G.ui_gp_plan, start, end, 3, 10, RGBA32_F(1, 1, 1, 0.5)); + draw_arrow_line(G.ui_gp_flow, start, end, 3, 10, RGBA32_F(1, 1, 1, 0.5)); } #if 0 @@ -1348,16 +1348,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_to_user_xf, quad); - draw_quad_line(G.ui_gp_plan, quad, 2, quad_color); + draw_quad_line(G.ui_gp_flow, quad, 2, quad_color); } - draw_circle(G.ui_gp_plan, center, 3, point_color, 20); + draw_circle(G.ui_gp_flow, 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_to_user_xf, ray); ray = v2_with_len(ray, 25); - draw_arrow_ray(G.ui_gp_plan, center, ray, 2, 10, ray_color); + draw_arrow_ray(G.ui_gp_flow, center, ray, 2, 10, ray_color); } } } @@ -1374,7 +1374,7 @@ INTERNAL void user_update(void) f32 radius = 3; 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); - draw_circle(G.ui_gp_plan, point, radius, color, 10); + draw_circle(G.ui_gp_flow, point, radius, color, 10); DEBUGBREAKABLE; } @@ -1389,8 +1389,8 @@ INTERNAL void user_update(void) struct v2 point_end = G.world_cursor; point_start = xform_mul_v2(G.world_to_user_xf, point_start); point_end = xform_mul_v2(G.world_to_user_xf, point_end); - draw_arrow_line(G.ui_gp_plan, point_start, point_end, 3, 10, color); - draw_circle(G.ui_gp_plan, point_start, 4, color, 10); + draw_arrow_line(G.ui_gp_flow, point_start, point_end, 3, 10, color); + draw_circle(G.ui_gp_flow, point_start, 4, color, 10); } /* Draw collider */ @@ -1402,13 +1402,13 @@ INTERNAL void user_update(void) /* Draw collider using support points */ u32 detail = 32; struct xform collider_draw_xf = xform_mul(G.world_to_user_xf, xf); - draw_collider_line(G.ui_gp_plan, collider, collider_draw_xf, thickness, color, detail); + draw_collider_line(G.ui_gp_flow, collider, collider_draw_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_to_user_xf, xf), collider.points[i]); - draw_circle(G.ui_gp_plan, p, 3, COLOR_BLUE, 10); + draw_circle(G.ui_gp_flow, p, 3, COLOR_BLUE, 10); } } if (collider.count == 1 && collider.radius > 0) { @@ -1417,14 +1417,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_to_user_xf, start); end = xform_mul_v2(G.world_to_user_xf, end); - draw_line(G.ui_gp_plan, start, end, thickness, color); + draw_line(G.ui_gp_flow, 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_to_user_xf, p); - draw_circle(G.ui_gp_plan, p, 3, COLOR_RED, 10); + draw_circle(G.ui_gp_flow, p, 3, COLOR_RED, 10); } #endif } @@ -1448,7 +1448,7 @@ INTERNAL void user_update(void) /* Draw point */ { - draw_circle(G.ui_gp_plan, xform_mul_v2(G.world_to_user_xf, dbg_pt), radius, color, 10); + draw_circle(G.ui_gp_flow, xform_mul_v2(G.world_to_user_xf, dbg_pt), radius, color, 10); } /* Draw normal */ @@ -1458,7 +1458,7 @@ INTERNAL void user_update(void) f32 arrow_height = 5; 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))); - draw_arrow_line(G.ui_gp_plan, start, end, arrow_thickness, arrow_height, color); + draw_arrow_line(G.ui_gp_flow, start, end, arrow_thickness, arrow_height, color); } #if 0 /* Draw contact info */ @@ -1488,7 +1488,7 @@ INTERNAL void user_update(void) FMT_UINT(data->num_points)); - draw_text(G.ui_gp_plan, disp_font, v2_add(v2_round(xform_mul_v2(G.world_to_user_xf, dbg_pt)), V2(0, offset_px)), text); + draw_text(G.ui_gp_flow, disp_font, v2_add(v2_round(xform_mul_v2(G.world_to_user_xf, dbg_pt)), V2(0, offset_px)), text); } } #endif @@ -1516,8 +1516,8 @@ INTERNAL void user_update(void) u32 color = RGBA32_F(1, 1, 0, 0.5); 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); - draw_circle(G.ui_gp_plan, a, radius, color, 10); - draw_circle(G.ui_gp_plan, b, radius, color, 10); + draw_circle(G.ui_gp_flow, a, radius, color, 10); + draw_circle(G.ui_gp_flow, b, radius, color, 10); } #endif @@ -1534,28 +1534,28 @@ INTERNAL void user_update(void) { 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); - draw_line(G.ui_gp_plan, a, b, thickness, color_line); - draw_circle(G.ui_gp_plan, a, radius, color_a, 10); - draw_circle(G.ui_gp_plan, b, radius, color_b, 10); + draw_line(G.ui_gp_flow, a, b, thickness, color_line); + draw_circle(G.ui_gp_flow, a, radius, color_a, 10); + draw_circle(G.ui_gp_flow, b, radius, color_b, 10); 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); - draw_line(G.ui_gp_plan, a_clipped, b_clipped, thickness, color_line_clipped); - draw_circle(G.ui_gp_plan, a_clipped, radius, color_a_clipped, 10); - draw_circle(G.ui_gp_plan, b_clipped, radius, color_b_clipped, 10); + draw_line(G.ui_gp_flow, a_clipped, b_clipped, thickness, color_line_clipped); + draw_circle(G.ui_gp_flow, a_clipped, radius, color_a_clipped, 10); + draw_circle(G.ui_gp_flow, b_clipped, radius, color_b_clipped, 10); } { 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); - draw_line(G.ui_gp_plan, a, b, thickness, color_line); - draw_circle(G.ui_gp_plan, a, radius, color_a, 10); - draw_circle(G.ui_gp_plan, b, radius, color_b, 10); + draw_line(G.ui_gp_flow, a, b, thickness, color_line); + draw_circle(G.ui_gp_flow, a, radius, color_a, 10); + draw_circle(G.ui_gp_flow, b, radius, color_b, 10); 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); - draw_line(G.ui_gp_plan, a_clipped, b_clipped, thickness, color_line_clipped); - draw_circle(G.ui_gp_plan, a_clipped, radius, color_a_clipped, 10); - draw_circle(G.ui_gp_plan, b_clipped, radius, color_b_clipped, 10); + draw_line(G.ui_gp_flow, a_clipped, b_clipped, thickness, color_line_clipped); + draw_circle(G.ui_gp_flow, a_clipped, radius, color_a_clipped, 10); + draw_circle(G.ui_gp_flow, b_clipped, radius, color_b_clipped, 10); } } @@ -1596,7 +1596,7 @@ INTERNAL void user_update(void) FMT_FLOAT_P(xform_get_rotation(e1_xf), 24)); - draw_text(G.ui_gp_plan, 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.ui_gp_flow, disp_font, v2_add(v2_round(xform_mul_v2(G.world_to_user_xf, V2(0, 0))), V2(0, offset_px)), text); } } #endif @@ -1612,8 +1612,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_to_user_xf, m.points[i]); - draw_poly_line(G.ui_gp_plan, m, true, thickness, color); - //draw_poly(G.ui_gp_plan, m, color); + draw_poly_line(G.ui_gp_flow, m, true, thickness, color); + //draw_poly(G.ui_gp_flow, m, color); } /* Draw cloud */ @@ -1625,7 +1625,7 @@ INTERNAL void user_update(void) for (u64 i = 0; i < m.count; ++i) { struct v2 p = xform_mul_v2(G.world_to_user_xf, m.points[i]); - draw_circle(G.ui_gp_plan, p, radius, color, 10); + draw_circle(G.ui_gp_flow, p, radius, color, 10); } } @@ -1639,8 +1639,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_to_user_xf, m.points[i]); - draw_poly_line(G.ui_gp_plan, m, true, thickness, color); - for (u64 i = 0; i < m.count; ++i) draw_circle(G.ui_gp_plan, m.points[i], 10, color, 10); + draw_poly_line(G.ui_gp_flow, m, true, thickness, color); + for (u64 i = 0; i < m.count; ++i) draw_circle(G.ui_gp_flow, m.points[i], 10, color, 10); } /* Draw simplex */ @@ -1658,18 +1658,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_gp_plan, simplex_array.points[0], thickness * 3, color, 10); + draw_circle(G.ui_gp_flow, 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_gp_plan, simplex_array.points[1], thickness * 3, color, 10); + draw_circle(G.ui_gp_flow, simplex_array.points[1], thickness * 3, color, 10); } if (simplex.len >= 3) { u32 color = color_first; - draw_circle(G.ui_gp_plan, simplex_array.points[2], thickness * 3, color, 10); + draw_circle(G.ui_gp_flow, simplex_array.points[2], thickness * 3, color, 10); } if (simplex.len >= 2) { - draw_poly_line(G.ui_gp_plan, simplex_array, simplex.len > 2, thickness, line_color); + draw_poly_line(G.ui_gp_flow, simplex_array, simplex.len > 2, thickness, line_color); } } @@ -1681,7 +1681,7 @@ INTERNAL void user_update(void) f32 arrowhead_height = 10; 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)); - draw_arrow_line(G.ui_gp_plan, start, end, arrow_thickness, arrowhead_height, color); + draw_arrow_line(G.ui_gp_flow, start, end, arrow_thickness, arrowhead_height, color); } } #endif @@ -1696,7 +1696,7 @@ INTERNAL void user_update(void) 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); - draw_arrow_line(G.ui_gp_plan, start, end, thickness, arrow_height, color); + draw_arrow_line(G.ui_gp_flow, start, end, thickness, arrow_height, color); } /* Draw camera rect */ @@ -1708,7 +1708,7 @@ INTERNAL void user_update(void) struct quad quad = xform_mul_quad(quad_xf, QUAD_UNIT_SQUARE_CENTERED); quad = xform_mul_quad(G.world_to_user_xf, quad); - draw_quad_line(G.ui_gp_plan, quad, thickness, color); + draw_quad_line(G.ui_gp_flow, quad, thickness, color); } arena_temp_end(temp); @@ -1726,7 +1726,7 @@ INTERNAL void user_update(void) struct v2 size = V2(t->width, t->height); struct xform xf = XFORM_TRS(.t = crosshair_pos, .s = size); - draw_texture(G.ui_gp_plan, DRAW_TEXTURE_PARAMS(.xf = xf, .sprite = crosshair_tag)); + draw_texture(G.ui_gp_flow, DRAW_TEXTURE_PARAMS(.xf = xf, .sprite = crosshair_tag)); 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)); @@ -1924,7 +1924,7 @@ INTERNAL void user_update(void) struct string dbg_text = ZI; dbg_text.text = arena_push_dry(temp.arena, u8); dbg_text.len += get_ent_debug_text(temp.arena, ent).len; - draw_text(G.ui_gp_plan, DRAW_TEXT_PARAMS(.font = font, .pos = pos, .str = dbg_text)); + draw_text(G.ui_gp_flow, DRAW_TEXT_PARAMS(.font = font, .pos = pos, .str = dbg_text)); arena_temp_end(temp); } @@ -2024,16 +2024,16 @@ INTERNAL void user_update(void) //text.len += string_copy(temp.arena, LIT("\n")).len; #if COLLIDER_DEBUG - draw_text(G.ui_gp_plan, font, pos, string_format(temp.arena, LIT("collider gjk steps: %F"), FMT_UINT(collider_debug_steps))); + draw_text(G.ui_gp_flow, font, pos, string_format(temp.arena, LIT("collider gjk steps: %F"), FMT_UINT(collider_debug_steps))); pos.y += spacing; #endif - //draw_text(G.ui_gp_plan, 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.ui_gp_plan, font, pos, text); + //draw_text(G.ui_gp_flow, 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.ui_gp_flow, font, pos, text); struct v2 pos = V2(10, G.user_size.y); enum draw_text_offset_y offset_y = DRAW_TEXT_OFFSET_Y_BOTTOM; - draw_text(G.ui_gp_plan, DRAW_TEXT_PARAMS(.font = font, .pos = pos, .str = text, .offset_y = offset_y, .color = COLOR_WHITE)); + draw_text(G.ui_gp_flow, DRAW_TEXT_PARAMS(.font = font, .pos = pos, .str = text, .offset_y = offset_y, .color = COLOR_WHITE)); arena_temp_end(temp); } } @@ -2075,7 +2075,7 @@ INTERNAL void user_update(void) /* Render world to user texture */ { struct gp_dispatch_params params = ZI; - params.plan = G.world_gp_plan; + params.flow = G.world_gp_flow; params.draw_target = G.user_texture; params.draw_target_viewport = user_viewport; params.draw_target_view = G.world_to_user_xf; @@ -2085,7 +2085,7 @@ INTERNAL void user_update(void) /* Render ui to user texture */ { struct gp_dispatch_params params = ZI; - params.plan = G.ui_gp_plan; + params.flow = G.ui_gp_flow; params.draw_target = G.user_texture; params.draw_target_viewport = user_viewport; params.draw_target_view = XFORM_IDENT;