rename gp plan -> flow
This commit is contained in:
parent
8ff4ec4a12
commit
15b4ca9442
70
src/draw.c
70
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;
|
||||
|
||||
}
|
||||
|
||||
32
src/draw.h
32
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
|
||||
|
||||
6
src/gp.h
6
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;
|
||||
|
||||
190
src/gp_dx11.c
190
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;
|
||||
|
||||
@ -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);
|
||||
|
||||
132
src/user.c
132
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;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user