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

rename layer 'gpu' -> 'gp'

Browse Source
This commit is contained in:
jacob 2025-06-19 14:51:06 -05:00
parent 40e7abcc4e
commit 4313b1c768
13 changed files with 287 additions and 287 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
build.c
View File

@ -867,15 +867,15 @@ void OnBuild(StringList cli_args)
if (is_c || is_cpp) {
if (StringBeginsWith(name, Lit("sys_")) ||
StringBeginsWith(name, Lit("sock_")) ||
StringBeginsWith(name, Lit("gpu_")) ||
StringBeginsWith(name, Lit("gp_")) ||
StringBeginsWith(name, Lit("playback_")) ||
StringBeginsWith(name, Lit("mp3_")) ||
StringBeginsWith(name, Lit("ttf_"))) {
if (PlatformWindows) {
ignore = !(StringEqual(name, Lit("sys_win32.c")) ||
StringEqual(name, Lit("sock_win32.c")) ||
StringEqual(name, Lit("gpu_dx11.c")) ||
StringEqual(name, Lit("gpu_dx12.c")) ||
StringEqual(name, Lit("gp_dx11.c")) ||
StringEqual(name, Lit("gp_dx12.c")) ||
StringEqual(name, Lit("playback_wasapi.c")) ||
StringEqual(name, Lit("mp3_mmf.c")) ||
StringEqual(name, Lit("ttf_dwrite.cpp")));

12
src/app.c
View File

@ -20,7 +20,7 @@
#include "settings.h"
#include "draw.h"
#include "math.h"
#include "gpu.h"
#include "gp.h"
#include "phys.h"
#include "sock.h"
#include "host.h"
@ -323,16 +323,16 @@ void app_entry_point(struct string args_str)
struct host_startup_receipt host_sr = host_startup(&sock_sr);
struct resource_startup_receipt resource_sr = resource_startup();
struct work_startup_receipt work_sr = work_startup(worker_count);
struct gpu_startup_receipt gpu_sr = gpu_startup(&work_sr, window);
struct gp_startup_receipt gp_sr = gp_startup(&work_sr, window);
struct asset_cache_startup_receipt asset_cache_sr = asset_cache_startup(&work_sr);
struct ttf_startup_receipt ttf_sr = ttf_startup();
struct font_startup_receipt font_sr = font_startup(&work_sr, &gpu_sr, &asset_cache_sr, &ttf_sr, &resource_sr);
struct sprite_startup_receipt sprite_sr = sprite_startup(&gpu_sr, &resource_sr);
struct font_startup_receipt font_sr = font_startup(&work_sr, &gp_sr, &asset_cache_sr, &ttf_sr, &resource_sr);
struct sprite_startup_receipt sprite_sr = sprite_startup(&gp_sr, &resource_sr);
struct mixer_startup_receipt mixer_sr = mixer_startup();
struct sound_startup_receipt sound_sr = sound_startup(&work_sr, &asset_cache_sr, &resource_sr);
struct draw_startup_receipt draw_sr = draw_startup(&gpu_sr, &font_sr);
struct draw_startup_receipt draw_sr = draw_startup(&gp_sr, &font_sr);
struct sim_startup_receipt sim_sr = sim_startup();
struct user_startup_receipt user_sr = user_startup(&work_sr, &gpu_sr, &font_sr, &sprite_sr, &draw_sr, &asset_cache_sr, &sound_sr, &mixer_sr, &host_sr, &sim_sr, connect_address, window);
struct user_startup_receipt user_sr = user_startup(&work_sr, &gp_sr, &font_sr, &sprite_sr, &draw_sr, &asset_cache_sr, &sound_sr, &mixer_sr, &host_sr, &sim_sr, connect_address, window);
struct playback_startup_receipt playback_sr = playback_startup(&mixer_sr);
(UNUSED)user_sr;

64
src/draw.c
View File

@ -1,5 +1,5 @@
#include "draw.h"
#include "gpu.h"
#include "gp.h"
#include "math.h"
#include "font.h"
#include "scratch.h"
@ -7,20 +7,20 @@
#include "collider.h"
GLOBAL struct {
struct gpu_handle solid_white_texture;
struct gp_handle solid_white_texture;
} G = ZI, DEBUG_ALIAS(G, G_draw);
/* ========================== *
* Startup
* ========================== */
struct draw_startup_receipt draw_startup(struct gpu_startup_receipt *gpu_sr,
struct draw_startup_receipt draw_startup(struct gp_startup_receipt *gp_sr,
struct font_startup_receipt *font_sr)
{
(UNUSED)gpu_sr;
(UNUSED)gp_sr;
(UNUSED)font_sr;
u32 pixel_white = 0xFFFFFFFF;
G.solid_white_texture = gpu_texture_alloc(GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM, 0, V2I32(1, 1), &pixel_white);
G.solid_white_texture = gp_texture_alloc(GP_TEXTURE_FORMAT_R8G8B8A8_UNORM, 0, V2I32(1, 1), &pixel_white);
return (struct draw_startup_receipt) { 0 };
}
@ -28,35 +28,35 @@ struct draw_startup_receipt draw_startup(struct gpu_startup_receipt *gpu_sr,
* Texture
* ========================== */
void draw_texture(struct gpu_handle plan, struct draw_texture_params params)
void draw_texture(struct gp_handle plan, struct draw_texture_params params)
{
struct gpu_cmd_params cmd = ZI;
cmd.kind = GPU_CMD_KIND_DRAW_TEXTURE;
struct gp_cmd_params cmd = ZI;
cmd.kind = GP_CMD_KIND_DRAW_TEXTURE;
cmd.texture.xf = params.xf;
cmd.texture.sprite = params.sprite;
cmd.texture.texture = params.texture;
cmd.texture.clip = params.clip;
cmd.texture.tint = params.tint;
cmd.texture.emittance = params.emittance;
gpu_push_cmd(plan, cmd);
gp_push_cmd(plan, cmd);
}
/* ========================== *
* Fill shapes
* ========================== */
void draw_poly_ex(struct gpu_handle plan, struct v2_array vertices, struct gpu_indices indices, u32 color)
void draw_poly_ex(struct gp_handle plan, struct v2_array vertices, struct gp_indices indices, u32 color)
{
struct gpu_cmd_params cmd = ZI;
cmd.kind = GPU_CMD_KIND_DRAW_MESH;
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;
gpu_push_cmd(plan, cmd);
gp_push_cmd(plan, cmd);
}
/* Draws a filled polygon using triangles in a fan pattern */
void draw_poly(struct gpu_handle plan, struct v2_array vertices, u32 color)
void draw_poly(struct gp_handle plan, struct v2_array vertices, u32 color)
{
if (vertices.count >= 3) {
struct arena_temp scratch = scratch_begin_no_conflict();
@ -65,7 +65,7 @@ void draw_poly(struct gpu_handle plan, struct v2_array vertices, u32 color)
u32 num_indices = num_tris * 3;
/* Generate indices in a fan pattern */
struct gpu_indices indices = {
struct gp_indices indices = {
.count = num_indices,
.indices = arena_push_array_no_zero(scratch.arena, u32, num_indices)
};
@ -82,7 +82,7 @@ void draw_poly(struct gpu_handle plan, struct v2_array vertices, u32 color)
}
}
void draw_circle(struct gpu_handle plan, struct v2 pos, f32 radius, u32 color, u32 detail)
void draw_circle(struct gp_handle plan, struct v2 pos, f32 radius, u32 color, u32 detail)
{
struct arena_temp scratch = scratch_begin_no_conflict();
@ -105,14 +105,14 @@ void draw_circle(struct gpu_handle plan, struct v2 pos, f32 radius, u32 color, u
scratch_end(scratch);
}
void draw_quad(struct gpu_handle plan, struct quad quad, u32 color)
void draw_quad(struct gp_handle plan, struct quad quad, u32 color)
{
LOCAL_PERSIST u32 indices_array[6] = {
0, 1, 2,
0, 2, 3
};
struct v2_array vertices = { .count = 4, .points = quad.e };
struct gpu_indices indices = { .count = 6, .indices = indices_array };
struct gp_indices indices = { .count = 6, .indices = indices_array };
draw_poly_ex(plan, vertices, indices, color);
}
@ -120,7 +120,7 @@ void draw_quad(struct gpu_handle plan, struct quad quad, u32 color)
* Line shapes
* ========================== */
void draw_gradient_line(struct gpu_handle plan, struct v2 start, struct v2 end, f32 thickness, u32 start_color, u32 end_color)
void draw_gradient_line(struct gp_handle plan, 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);
@ -133,19 +133,19 @@ void draw_gradient_line(struct gpu_handle plan, struct v2 start, struct v2 end,
#endif
}
void draw_line(struct gpu_handle plan, struct v2 start, struct v2 end, f32 thickness, u32 color)
void draw_line(struct gp_handle plan, struct v2 start, struct v2 end, f32 thickness, u32 color)
{
struct quad quad = quad_from_line(start, end, thickness);
draw_quad(plan, quad, color);
}
void draw_ray(struct gpu_handle plan, struct v2 pos, struct v2 rel, f32 thickness, u32 color)
void draw_ray(struct gp_handle plan, struct v2 pos, struct v2 rel, f32 thickness, u32 color)
{
struct quad quad = quad_from_ray(pos, rel, thickness);
draw_quad(plan, quad, color);
}
void draw_poly_line(struct gpu_handle plan, struct v2_array points, b32 loop, f32 thickness, u32 color)
void draw_poly_line(struct gp_handle plan, struct v2_array points, b32 loop, f32 thickness, u32 color)
{
if (points.count >= 2) {
for (u64 i = 1; i < points.count; ++i) {
@ -163,7 +163,7 @@ void draw_poly_line(struct gpu_handle plan, struct v2_array points, b32 loop, f3
}
}
void draw_circle_line(struct gpu_handle plan, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail)
void draw_circle_line(struct gp_handle plan, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail)
{
struct arena_temp scratch = scratch_begin_no_conflict();
@ -186,14 +186,14 @@ void draw_circle_line(struct gpu_handle plan, struct v2 pos, f32 radius, f32 thi
scratch_end(scratch);
}
void draw_quad_line(struct gpu_handle plan, struct quad quad, f32 thickness, u32 color)
void draw_quad_line(struct gp_handle plan, 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);
}
void draw_arrow_line(struct gpu_handle plan, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 color)
void draw_arrow_line(struct gp_handle plan, 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 */
@ -223,13 +223,13 @@ void draw_arrow_line(struct gpu_handle plan, struct v2 start, struct v2 end, f32
draw_quad(plan, line_quad, color);
}
void draw_arrow_ray(struct gpu_handle plan, struct v2 pos, struct v2 rel, 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)
{
struct v2 end = v2_add(pos, rel);
draw_arrow_line(plan, pos, end, thickness, arrowhead_height, color);
}
void draw_collider_line(struct gpu_handle plan, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 color, u32 detail)
void draw_collider_line(struct gp_handle plan, 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;
@ -258,10 +258,10 @@ void draw_collider_line(struct gpu_handle plan, struct collider_shape shape, str
* Grid
* ========================== */
void draw_grid(struct gpu_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 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)
{
struct gpu_cmd_params cmd = ZI;
cmd.kind = GPU_CMD_KIND_DRAW_GRID;
struct gp_cmd_params cmd = ZI;
cmd.kind = GP_CMD_KIND_DRAW_GRID;
cmd.grid.xf = xf;
cmd.grid.bg0_color = bg0_color;
cmd.grid.bg1_color = bg1_color;
@ -271,7 +271,7 @@ void draw_grid(struct gpu_handle plan, struct xform xf, u32 bg0_color, u32 bg1_c
cmd.grid.line_thickness = thickness;
cmd.grid.line_spacing = spacing;
cmd.grid.offset = offset;
gpu_push_cmd(plan, cmd);
gp_push_cmd(plan, cmd);
}
/* ========================== *
@ -279,7 +279,7 @@ void draw_grid(struct gpu_handle plan, struct xform xf, u32 bg0_color, u32 bg1_c
* ========================== */
/* Returns the rect of the text area */
struct rect draw_text(struct gpu_handle plan, struct draw_text_params params)
struct rect draw_text(struct gp_handle plan, struct draw_text_params params)
{
struct arena_temp scratch = scratch_begin_no_conflict();

38
src/draw.h
View File

@ -1,13 +1,13 @@
#ifndef DRAW_H
#define DRAW_H
#include "gpu.h"
#include "gp.h"
struct font;
struct font_startup_receipt;
struct draw_startup_receipt { i32 _; };
struct draw_startup_receipt draw_startup(struct gpu_startup_receipt *gpu_sr,
struct draw_startup_receipt draw_startup(struct gp_startup_receipt *gp_sr,
struct font_startup_receipt *font_sr);
/* ========================== *
@ -22,54 +22,54 @@ struct draw_startup_receipt draw_startup(struct gpu_startup_receipt *gpu_sr,
struct draw_texture_params {
struct xform xf;
struct gpu_handle texture; /* Overrides sprite if set */
struct gp_handle texture; /* Overrides sprite if set */
struct sprite_tag sprite;
struct clip_rect clip;
u32 tint;
f32 emittance;
};
void draw_texture(struct gpu_handle plan, struct draw_texture_params params);
void draw_texture(struct gp_handle plan, struct draw_texture_params params);
/* ========================== *
* Fill shapes
* ========================== */
void draw_poly_ex(struct gpu_handle plan, struct v2_array vertices, struct gpu_indices indices, u32 color);
void draw_poly_ex(struct gp_handle plan, struct v2_array vertices, struct gp_indices indices, u32 color);
void draw_poly(struct gpu_handle plan, struct v2_array points, u32 color);
void draw_poly(struct gp_handle plan, struct v2_array points, u32 color);
void draw_circle(struct gpu_handle plan, struct v2 pos, f32 radius, u32 color, u32 detail);
void draw_circle(struct gp_handle plan, struct v2 pos, f32 radius, u32 color, u32 detail);
void draw_quad(struct gpu_handle plan, struct quad quad, u32 color);
void draw_quad(struct gp_handle plan, struct quad quad, u32 color);
/* ========================== *
* Line shapes
* ========================== */
void draw_gradient_line(struct gpu_handle plan, struct v2 start, struct v2 end, f32 thickness, u32 start_color, u32 end_color);
void draw_gradient_line(struct gp_handle plan, struct v2 start, struct v2 end, f32 thickness, u32 start_color, u32 end_color);
void draw_line(struct gpu_handle plan, struct v2 start, struct v2 end, f32 thickness, u32 color);
void draw_line(struct gp_handle plan, struct v2 start, struct v2 end, f32 thickness, u32 color);
void draw_ray(struct gpu_handle plan, struct v2 pos, struct v2 rel, f32 thickness, u32 color);
void draw_ray(struct gp_handle plan, struct v2 pos, struct v2 rel, f32 thickness, u32 color);
void draw_poly_line(struct gpu_handle plan, struct v2_array points, b32 loop, f32 thickness, u32 color);
void draw_poly_line(struct gp_handle plan, struct v2_array points, b32 loop, f32 thickness, u32 color);
void draw_circle_line(struct gpu_handle plan, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail);
void draw_circle_line(struct gp_handle plan, struct v2 pos, f32 radius, f32 thickness, u32 color, u32 detail);
void draw_quad_line(struct gpu_handle plan, struct quad quad, f32 thickness, u32 color);
void draw_quad_line(struct gp_handle plan, struct quad quad, f32 thickness, u32 color);
void draw_arrow_line(struct gpu_handle plan, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, 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_ray(struct gpu_handle plan, struct v2 pos, struct v2 rel, 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_collider_line(struct gpu_handle plan, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 color, u32 detail);
void draw_collider_line(struct gp_handle plan, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 color, u32 detail);
/* ========================== *
* Grid
* ========================== */
void draw_grid(struct gpu_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 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);
/* ========================== *
* Text
@ -117,6 +117,6 @@ struct draw_text_params {
struct string str;
};
struct rect draw_text(struct gpu_handle plan, struct draw_text_params params);
struct rect draw_text(struct gp_handle plan, struct draw_text_params params);
#endif

8
src/font.c
View File

@ -7,7 +7,7 @@
#include "resource.h"
#include "log.h"
#include "string.h"
#include "gpu.h"
#include "gp.h"
#define LOOKUP_TABLE_SIZE (256)
GLOBAL u32 g_font_codes[] = {
@ -42,13 +42,13 @@ GLOBAL struct {
* ========================== */
struct font_startup_receipt font_startup(struct work_startup_receipt *work_sr,
struct gpu_startup_receipt *gpu_sr,
struct gp_startup_receipt *gp_sr,
struct asset_cache_startup_receipt *asset_cache_sr,
struct ttf_startup_receipt *ttf_sr,
struct resource_startup_receipt *resource_sr)
{
(UNUSED)work_sr;
(UNUSED)gpu_sr;
(UNUSED)gp_sr;
(UNUSED)asset_cache_sr;
(UNUSED)ttf_sr;
(UNUSED)resource_sr;
@ -119,7 +119,7 @@ INTERNAL WORK_TASK_FUNC_DEF(font_load_asset_task, vparams)
resource_close(&res);
/* Send texture to GPU */
struct gpu_handle texture = gpu_texture_alloc(GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM, 0, V2I32(result.image_data.width, result.image_data.height), result.image_data.pixels);
struct gp_handle texture = gp_texture_alloc(GP_TEXTURE_FORMAT_R8G8B8A8_UNORM, 0, V2I32(result.image_data.width, result.image_data.height), result.image_data.pixels);
/* Allocate store memory */
struct font *font = NULL;

8
src/font.h
View File

@ -2,11 +2,11 @@
#define FONT_H
#include "util.h"
#include "gpu.h"
#include "gp.h"
struct asset;
struct work_startup_receipt;
struct gpu_startup_receipt;
struct gp_startup_receipt;
struct asset_cache_startup_receipt;
struct ttf_startup_receipt;
struct resource_startup_receipt;
@ -21,7 +21,7 @@ struct font_glyph {
};
struct font {
struct gpu_handle texture;
struct gp_handle texture;
u32 image_width;
u32 image_height;
f32 point_size;
@ -32,7 +32,7 @@ struct font {
struct font_startup_receipt { i32 _; };
struct font_startup_receipt font_startup(struct work_startup_receipt *work_sr,
struct gpu_startup_receipt *gpu_sr,
struct gp_startup_receipt *gp_sr,
struct asset_cache_startup_receipt *asset_cache_sr,
struct ttf_startup_receipt *ttf_sr,
struct resource_startup_receipt *resource_sr);

76
src/gpu.h → src/gp.h
View File

@ -1,5 +1,5 @@
#ifndef GPU_H
#define GPU_H
#ifndef GP_H
#define GP_H
struct sys_window;
struct work_startup_receipt;
@ -8,14 +8,14 @@ struct work_startup_receipt;
* Startup
* ========================== */
struct gpu_startup_receipt { i32 _; };
struct gpu_startup_receipt gpu_startup(struct work_startup_receipt *work_sr, struct sys_window *window);
struct gp_startup_receipt { i32 _; };
struct gp_startup_receipt gp_startup(struct work_startup_receipt *work_sr, struct sys_window *window);
/* ========================== *
* Handle
* ========================== */
struct gpu_handle {
struct gp_handle {
union {
/* dx11 style */
u64 v;
@ -27,67 +27,67 @@ struct gpu_handle {
};
};
struct gpu_handle_array {
struct gp_handle_array {
u64 count;
struct gpu_handle **handles;
struct gp_handle **handles;
};
void gpu_release(struct gpu_handle handle);
void gp_release(struct gp_handle handle);
/* ========================== *
* Texture
* ========================== */
enum gpu_texture_format {
GPU_TEXTURE_FORMAT_NONE,
GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM,
GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB,
enum gp_texture_format {
GP_TEXTURE_FORMAT_NONE,
GP_TEXTURE_FORMAT_R8G8B8A8_UNORM,
GP_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB,
NUM_GPU_TEXTURE_FORMATS
NUM_GP_TEXTURE_FORMATS
};
enum gpu_texture_flag {
GPU_TEXTURE_FLAG_NONE = (0),
GPU_TEXTURE_FLAG_TARGETABLE = (1 << 0)
enum gp_texture_flag {
GP_TEXTURE_FLAG_NONE = (0),
GP_TEXTURE_FLAG_TARGETABLE = (1 << 0)
};
struct gpu_handle gpu_texture_alloc(enum gpu_texture_format format, u32 flags, struct v2i32 size, void *initial_data);
struct gp_handle gp_texture_alloc(enum gp_texture_format format, u32 flags, struct v2i32 size, void *initial_data);
void gpu_texture_clear(struct gpu_handle target_texture, u32 clear_color);
void gp_texture_clear(struct gp_handle target_texture, u32 clear_color);
struct v2i32 gpu_texture_get_size(struct gpu_handle texture);
struct v2i32 gp_texture_get_size(struct gp_handle texture);
/* ========================== *
* Cmd buffer
* ========================== */
struct gpu_indices {
struct gp_indices {
u32 count;
u32 *indices;
};
enum gpu_cmd_kind {
GPU_CMD_KIND_NONE,
GPU_CMD_KIND_DRAW_MESH,
GPU_CMD_KIND_DRAW_TEXTURE,
GPU_CMD_KIND_DRAW_GRID,
GPU_CMD_KIND_TEST,
enum gp_cmd_kind {
GP_CMD_KIND_NONE,
GP_CMD_KIND_DRAW_MESH,
GP_CMD_KIND_DRAW_TEXTURE,
GP_CMD_KIND_DRAW_GRID,
GP_CMD_KIND_TEST,
NUM_GPU_CMD_KINDS
NUM_GP_CMD_KINDS
};
struct gpu_cmd_params {
enum gpu_cmd_kind kind;
struct gp_cmd_params {
enum gp_cmd_kind kind;
union {
struct {
struct v2_array vertices;
struct gpu_indices indices;
struct gp_indices indices;
u32 color;
} mesh;
struct {
struct xform xf;
struct sprite_tag sprite;
struct gpu_handle texture;
struct gp_handle texture;
struct clip_rect clip;
u32 tint;
f32 emittance;
@ -109,22 +109,22 @@ struct gpu_cmd_params {
};
};
struct gpu_handle gpu_plan_alloc(void);
struct gp_handle gp_plan_alloc(void);
void gpu_push_cmd(struct gpu_handle gpu_plan, struct gpu_cmd_params params);
void gp_push_cmd(struct gp_handle gp_plan, struct gp_cmd_params params);
/* ========================== *
* Dispatch
* ========================== */
struct gpu_dispatch_params {
struct gpu_handle plan;
struct gpu_handle draw_target;
struct gp_dispatch_params {
struct gp_handle plan;
struct gp_handle draw_target;
struct rect draw_target_viewport;
struct xform draw_target_view;
};
void gpu_dispatch(struct gpu_dispatch_params params);
void gp_dispatch(struct gp_dispatch_params params);
/* ========================== *
* Present
@ -133,6 +133,6 @@ void gpu_dispatch(struct gpu_dispatch_params params);
/* 1. Ensures the backbuffer is at size `backbuffer_resolution`
* 2. Blits `texture` to the backbuffer using `texture_xf` (applied to centered unit square)
* 3. Presents the backbuffer */
void gpu_present(struct v2i32 backbuffer_resolution, struct gpu_handle texture, struct xform texture_xf, i32 vsync);
void gp_present(struct v2i32 backbuffer_resolution, struct gp_handle texture, struct xform texture_xf, i32 vsync);
#endif

108
src/gpu_dx11.c → src/gp_dx11.c
View File

@ -1,6 +1,6 @@
#if !DX12_TEST
#include "gpu.h"
#include "gp.h"
#include "resource.h"
#include "sys.h"
#include "memory.h"
@ -127,7 +127,7 @@ struct dx11_cmd_buffers {
};
struct dx11_cmd {
enum gpu_cmd_kind kind;
enum gp_cmd_kind kind;
union {
struct {
struct xform xf;
@ -139,7 +139,7 @@ struct dx11_cmd {
u32 index_count;
} mesh;
struct {
struct gpu_handle texture; /* Overrides sprite if set */
struct gp_handle texture; /* Overrides sprite if set */
struct sprite_tag sprite;
u32 instance_offset;
u32 instance_count;
@ -166,7 +166,7 @@ struct dx11_plan {
struct dx11_cmd *cpu_last_cmd;
/* Commands w/ buffer data submitted to video memory */
struct arena *gpu_cmds_arena;
struct arena *gp_cmds_arena;
struct dx11_cmd *gpu_first_cmd;
struct dx11_cmd *gpu_last_cmd;
@ -269,9 +269,9 @@ GLOBAL struct {
struct dx11_buffer *quad_index_buffer;
/* Blit plan */
struct gpu_handle present_blit_plan;
struct gp_handle present_blit_plan;
} G = ZI, DEBUG_ALIAS(G, G_gpu_dx11);
} G = ZI, DEBUG_ALIAS(G, G_gp_dx11);
/* ========================== *
* Startup
@ -285,7 +285,7 @@ INTERNAL struct dx11_buffer *dx11_buffer_alloc(struct D3D11_BUFFER_DESC desc, D3
INTERNAL RESOURCE_WATCH_CALLBACK_FUNC_DEF(shader_resource_watch_callback, name);
#endif
struct gpu_startup_receipt gpu_startup(struct work_startup_receipt *work_sr, struct sys_window *window)
struct gp_startup_receipt gp_startup(struct work_startup_receipt *work_sr, struct sys_window *window)
{
__prof;
(UNUSED)work_sr;
@ -539,9 +539,9 @@ struct gpu_startup_receipt gpu_startup(struct work_startup_receipt *work_sr, str
resource_register_watch_callback(shader_resource_watch_callback);
#endif
G.present_blit_plan = gpu_plan_alloc();
G.present_blit_plan = gp_plan_alloc();
return (struct gpu_startup_receipt) { 0 };
return (struct gp_startup_receipt) { 0 };
}
/* ========================== *
@ -562,7 +562,7 @@ INLINE struct mat4x4 calculate_vp(struct xform view, f32 viewport_width, f32 vie
INTERNAL void dx11_texture_release(struct dx11_texture *t);
void gpu_release(struct gpu_handle handle)
void gp_release(struct gp_handle handle)
{
struct dx11_handle_header *header = (struct dx11_handle_header *)handle.v;
switch (header->kind) {
@ -1009,15 +1009,15 @@ INTERNAL RESOURCE_WATCH_CALLBACK_FUNC_DEF(shader_resource_watch_callback, name)
* Texture
* ========================== */
INTERNAL enum DXGI_FORMAT dx11_format_from_gpu_format(enum gpu_texture_format gpu_format)
INTERNAL enum DXGI_FORMAT dx11_format_from_gp_format(enum gp_texture_format gp_format)
{
LOCAL_PERSIST const enum DXGI_FORMAT dx11_formats[NUM_GPU_TEXTURE_FORMATS] = {
[GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM] = DXGI_FORMAT_R8G8B8A8_UNORM,
[GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB] = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB
LOCAL_PERSIST const enum DXGI_FORMAT dx11_formats[NUM_GP_TEXTURE_FORMATS] = {
[GP_TEXTURE_FORMAT_R8G8B8A8_UNORM] = DXGI_FORMAT_R8G8B8A8_UNORM,
[GP_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB] = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB
};
enum DXGI_FORMAT res = DXGI_FORMAT_UNKNOWN;
if ((u32)gpu_format < ARRAY_COUNT(dx11_formats)) {
res = dx11_formats[gpu_format];
if ((u32)gp_format < ARRAY_COUNT(dx11_formats)) {
res = dx11_formats[gp_format];
}
return res;
}
@ -1111,13 +1111,13 @@ INTERNAL void dx11_texture_release(struct dx11_texture *t)
}
}
struct gpu_handle gpu_texture_alloc(enum gpu_texture_format format, u32 flags, struct v2i32 size, void *initial_data)
struct gp_handle gp_texture_alloc(enum gp_texture_format format, u32 flags, struct v2i32 size, void *initial_data)
{
__prof;
struct gpu_handle res = ZI;
struct gp_handle res = ZI;
/* Convert format to dx11 format */
enum DXGI_FORMAT dx11_format = dx11_format_from_gpu_format(format);
enum DXGI_FORMAT dx11_format = dx11_format_from_gp_format(format);
if (dx11_format == DXGI_FORMAT_UNKNOWN) {
/* Unknown format */
ASSERT(false);
@ -1126,7 +1126,7 @@ struct gpu_handle gpu_texture_alloc(enum gpu_texture_format format, u32 flags, s
/* Convert flags to dx11 flags */
u32 dx11_flags = D3D11_BIND_SHADER_RESOURCE;
if (flags & GPU_TEXTURE_FLAG_TARGETABLE) {
if (flags & GP_TEXTURE_FLAG_TARGETABLE) {
dx11_flags |= D3D11_BIND_RENDER_TARGET;
}
@ -1135,7 +1135,7 @@ struct gpu_handle gpu_texture_alloc(enum gpu_texture_format format, u32 flags, s
return res;
}
void gpu_texture_clear(struct gpu_handle target_texture, u32 clear_color)
void gp_texture_clear(struct gp_handle target_texture, u32 clear_color)
{
__prof;
struct dx11_texture *t = (struct dx11_texture *)target_texture.v;
@ -1150,7 +1150,7 @@ void gpu_texture_clear(struct gpu_handle target_texture, u32 clear_color)
}
}
struct v2i32 gpu_texture_get_size(struct gpu_handle texture)
struct v2i32 gp_texture_get_size(struct gp_handle texture)
{
return ((struct dx11_texture *)texture.v)->size;
}
@ -1283,20 +1283,20 @@ INTERNAL void dx11_buffer_submit(struct dx11_buffer *buffer)
* Plan
* ========================== */
struct gpu_handle gpu_plan_alloc(void)
struct gp_handle gp_plan_alloc(void)
{
__prof;
struct dx11_plan *plan = NULL;
{
struct arena *cpu_cmds_arena = NULL;
struct arena *gpu_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;
gpu_cmds_arena = plan->gpu_cmds_arena;
gp_cmds_arena = plan->gp_cmds_arena;
} else {
plan = arena_push_no_zero(G.plans_arena, struct dx11_plan);
}
@ -1306,13 +1306,13 @@ struct gpu_handle gpu_plan_alloc(void)
if (!cpu_cmds_arena) {
cpu_cmds_arena = arena_alloc(GIGABYTE(64));
}
if (!gpu_cmds_arena) {
gpu_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->gpu_cmds_arena = gpu_cmds_arena;
plan->gp_cmds_arena = gp_cmds_arena;
arena_reset(plan->cpu_cmds_arena);
arena_reset(plan->gpu_cmds_arena);
arena_reset(plan->gp_cmds_arena);
}
plan->header.kind = DX11_HANDLE_KIND_PLAN;
@ -1365,15 +1365,15 @@ struct gpu_handle gpu_plan_alloc(void)
}
}
struct gpu_handle res = ZI;
struct gp_handle res = ZI;
res.v = (u64)plan;
return res;
}
void gpu_push_cmd(struct gpu_handle gpu_plan, struct gpu_cmd_params params)
void gp_push_cmd(struct gp_handle gp_plan, struct gp_cmd_params params)
{
__prof;
struct dx11_plan *plan = (struct dx11_plan *)gpu_plan.v;
struct dx11_plan *plan = (struct dx11_plan *)gp_plan.v;
switch (params.kind) {
default:
@ -1382,7 +1382,7 @@ void gpu_push_cmd(struct gpu_handle gpu_plan, struct gpu_cmd_params params)
ASSERT(false);
} break;
case GPU_CMD_KIND_DRAW_MESH:
case GP_CMD_KIND_DRAW_MESH:
{
struct dx11_cmd *cmd = plan->cpu_last_cmd;
if (cmd && cmd->kind != params.kind) {
@ -1425,7 +1425,7 @@ void gpu_push_cmd(struct gpu_handle gpu_plan, struct gpu_cmd_params params)
}
} break;
case GPU_CMD_KIND_DRAW_TEXTURE:
case GP_CMD_KIND_DRAW_TEXTURE:
{
struct dx11_cmd *cmd = plan->cpu_last_cmd;
if (cmd &&
@ -1462,7 +1462,7 @@ void gpu_push_cmd(struct gpu_handle gpu_plan, struct gpu_cmd_params params)
instance->emittance = params.texture.emittance;
} break;
case GPU_CMD_KIND_DRAW_GRID:
case GP_CMD_KIND_DRAW_GRID:
{
struct dx11_cmd *cmd = plan->cpu_last_cmd;
if (cmd && cmd->kind != params.kind) {
@ -1498,7 +1498,7 @@ void gpu_push_cmd(struct gpu_handle gpu_plan, struct gpu_cmd_params params)
instance->y_srgb = params.grid.y_color;
} break;
case GPU_CMD_KIND_TEST:
case GP_CMD_KIND_TEST:
{
struct dx11_cmd *cmd = arena_push(plan->cpu_cmds_arena, struct dx11_cmd);
cmd->kind = params.kind;
@ -1589,15 +1589,15 @@ INTERNAL void dx11_unbind(u32 flags)
}
/* TODO: Lock resources during dispatch */
void gpu_dispatch(struct gpu_dispatch_params params)
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;
/* Swap cmd lists */
struct arena *swp_arena = plan->gpu_cmds_arena;
plan->gpu_cmds_arena = plan->cpu_cmds_arena;
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;
@ -1659,7 +1659,7 @@ void gpu_dispatch(struct gpu_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) {
enum gpu_cmd_kind cmd_kind = cmd->kind;
enum gp_cmd_kind cmd_kind = cmd->kind;
switch (cmd_kind) {
default:
@ -1668,7 +1668,7 @@ void gpu_dispatch(struct gpu_dispatch_params params)
ASSERT(false);
} break;
case GPU_CMD_KIND_DRAW_MESH:
case GP_CMD_KIND_DRAW_MESH:
{
__profscope(Draw mesh);
__profscope_dx11(G.profiling_ctx, Draw mesh, RGB32_F(0.5, 0.2, 0.2));
@ -1714,7 +1714,7 @@ void gpu_dispatch(struct gpu_dispatch_params params)
}
} break;
case GPU_CMD_KIND_DRAW_TEXTURE:
case GP_CMD_KIND_DRAW_TEXTURE:
{
__profscope(Draw texture);
__profscope_dx11(G.profiling_ctx, Draw texture, RGB32_F(0.2, 0.5, 0.2));
@ -1775,7 +1775,7 @@ void gpu_dispatch(struct gpu_dispatch_params params)
}
} break;
case GPU_CMD_KIND_DRAW_GRID:
case GP_CMD_KIND_DRAW_GRID:
{
__profscope(Draw grid);
__profscope_dx11(G.profiling_ctx, Draw grid, RGB32_F(0.2, 0.2, 0.5));
@ -1822,7 +1822,7 @@ void gpu_dispatch(struct gpu_dispatch_params params)
}
} break;
case GPU_CMD_KIND_TEST:
case GP_CMD_KIND_TEST:
{
__profscope(Test);
__profscope_dx11(G.profiling_ctx, Test, RGB32_F(1, 0.2, 1));
@ -1879,7 +1879,7 @@ void gpu_dispatch(struct gpu_dispatch_params params)
* Backbuffer
* ========================== */
INTERNAL void gpu_capture_image_for_profiler(void);
INTERNAL void capture_image_for_profiler(void);
#if GSTAT_ENABLED || PROFILING
INTERNAL struct DXGI_QUERY_VIDEO_MEMORY_INFO get_memory_info(void)
@ -1956,8 +1956,8 @@ INTERNAL void present_blit(struct dx11_texture *dst, struct dx11_texture *src, s
{
__prof;
__profscope_dx11(G.profiling_ctx, Blit, RGB32_F(0.3, 0.1, 0.1));
struct gpu_handle src_texture_handle = { .v = (u64)src };
struct gpu_handle dst_texture_handle = { .v = (u64)dst };
struct gp_handle src_texture_handle = { .v = (u64)src };
struct gp_handle dst_texture_handle = { .v = (u64)dst };
/* Draw texture to backbuffer texture */
/* TODO: Specialized blit shader */
@ -1967,20 +1967,20 @@ INTERNAL void present_blit(struct dx11_texture *dst, struct dx11_texture *src, s
}
/* Clear textures */
gpu_texture_clear(dst_texture_handle, RGBA32_F(0, 0, 0, 1));
gp_texture_clear(dst_texture_handle, RGBA32_F(0, 0, 0, 1));
/* Render to backbuffer texture */
{
struct gpu_dispatch_params params = ZI;
struct gp_dispatch_params params = ZI;
params.plan = G.present_blit_plan;
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;
gpu_dispatch(params);
gp_dispatch(params);
}
}
void gpu_present(struct v2i32 backbuffer_resolution, struct gpu_handle texture, struct xform texture_xf, i32 vsync)
void gp_present(struct v2i32 backbuffer_resolution, struct gp_handle texture, struct xform texture_xf, i32 vsync)
{
__prof;
@ -2047,7 +2047,7 @@ void gpu_present(struct v2i32 backbuffer_resolution, struct gpu_handle texture,
present_blit(&G.backbuffer_texture, (struct dx11_texture *)texture.v, texture_xf);
/* Present */
gpu_capture_image_for_profiler();
capture_image_for_profiler();
{
__profscope(Present);
IDXGISwapChain2_Present(G.swapchain, vsync, flags);
@ -2071,7 +2071,7 @@ struct prof_cap {
struct v2 size;
};
INTERNAL void gpu_capture_image_for_profiler(void)
INTERNAL void capture_image_for_profiler(void)
{
__prof;
@ -2148,7 +2148,7 @@ INTERNAL void gpu_capture_image_for_profiler(void)
}
#else
INTERNAL void gpu_capture_image_for_profiler(void)
INTERNAL void capture_image_for_profiler(void)
{
}

68
src/gpu_dx12.c → src/gp_dx12.c
View File

@ -1,6 +1,6 @@
#if DX12_TEST
#include "gpu.h"
#include "gp.h"
#include "sys.h"
#include "arena.h"
#include "memory.h"
@ -115,7 +115,7 @@ struct command_descriptor_heap {
D3D12_DESCRIPTOR_HEAP_TYPE type;
ID3D12DescriptorHeap *heap;
D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle;
D3D12_GPU_DESCRIPTOR_HANDLE gpu_handle;
D3D12_GPU_DESCRIPTOR_HANDLE gp_handle;
struct command_descriptor_heap *next_in_command_list;
@ -280,13 +280,13 @@ GLOBAL struct {
struct dx12_resource *dummy_index_buffer;
D3D12_VERTEX_BUFFER_VIEW dummy_vertex_buffer_view;
D3D12_INDEX_BUFFER_VIEW quad_index_buffer_view;
} G = ZI, DEBUG_ALIAS(G, G_gpu_dx12);
} G = ZI, DEBUG_ALIAS(G, G_gp_dx12);
/* ========================== *
* Startup
* ========================== */
INTERNAL APP_EXIT_CALLBACK_FUNC_DEF(gpu_shutdown);
INTERNAL APP_EXIT_CALLBACK_FUNC_DEF(gp_shutdown);
INTERNAL void dx12_init_device(void);
INTERNAL void dx12_init_objects(void);
INTERNAL void dx12_init_swapchain(struct sys_window *window);
@ -297,7 +297,7 @@ INTERNAL void command_queue_release(struct command_queue *cq);
INTERNAL struct dx12_resource *dx12_resource_alloc_from_swapchain_buffer(ID3D12Resource *buff);
INTERNAL void dx12_resource_release(struct dx12_resource *resource);
struct gpu_startup_receipt gpu_startup(struct work_startup_receipt *work_sr, struct sys_window *window)
struct gp_startup_receipt gp_startup(struct work_startup_receipt *work_sr, struct sys_window *window)
{
__prof;
(UNUSED)work_sr;
@ -328,8 +328,8 @@ struct gpu_startup_receipt gpu_startup(struct work_startup_receipt *work_sr, str
#if 0
{
LOCAL_PERSIST const DXGI_FORMAT formats[] = {
[GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM] = DXGI_FORMAT_R8G8B8A8_UNORM,
[GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB] = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB
[GP_TEXTURE_FORMAT_R8G8B8A8_UNORM] = DXGI_FORMAT_R8G8B8A8_UNORM,
[GP_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB] = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB
};
enum dx12_resource_view_flags view_flags = DX12_RESOURCE_VIEW_FLAG_SRV;
@ -349,7 +349,7 @@ struct gpu_startup_receipt gpu_startup(struct work_startup_receipt *work_sr, str
desc.MipLevels = 1;
desc.SampleDesc.Count = 1;
desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
if (flags & GPU_TEXTURE_FLAG_TARGETABLE) {
if (flags & GP_TEXTURE_FLAG_TARGETABLE) {
desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
view_flags |= DX12_RESOURCE_VIEW_FLAG_RTV;
}
@ -388,13 +388,13 @@ struct gpu_startup_receipt gpu_startup(struct work_startup_receipt *work_sr, str
/* Register callbacks */
app_register_exit_callback(gpu_shutdown);
app_register_exit_callback(gp_shutdown);
struct gpu_startup_receipt res = ZI;
struct gp_startup_receipt res = ZI;
return res;
}
INTERNAL APP_EXIT_CALLBACK_FUNC_DEF(gpu_shutdown)
INTERNAL APP_EXIT_CALLBACK_FUNC_DEF(gp_shutdown)
{
__prof;
#if DX12_DEBUG
@ -417,7 +417,7 @@ INTERNAL APP_EXIT_CALLBACK_FUNC_DEF(gpu_shutdown)
INTERNAL void dx12_resource_release(struct dx12_resource *t);
INTERNAL struct gpu_handle handle_alloc(enum handle_kind kind, void *data)
INTERNAL struct gp_handle handle_alloc(enum handle_kind kind, void *data)
{
u64 old_gen = 0;
u64 idx = 0;
@ -441,13 +441,13 @@ INTERNAL struct gpu_handle handle_alloc(enum handle_kind kind, void *data)
entry->idx = idx;
entry->data = data;
struct gpu_handle res = ZI;
struct gp_handle res = ZI;
res.gen = entry->gen;
res.idx = entry->idx;
return res;
}
INTERNAL struct handle_entry *handle_get_entry(struct gpu_handle handle, struct sys_lock *lock)
INTERNAL struct handle_entry *handle_get_entry(struct gp_handle handle, struct sys_lock *lock)
{
sys_assert_locked_e_or_s(lock, G.handle_entries_mutex);
struct handle_entry *res = NULL;
@ -460,7 +460,7 @@ INTERNAL struct handle_entry *handle_get_entry(struct gpu_handle handle, struct
return res;
}
INTERNAL void *handle_get_data(struct gpu_handle handle, enum handle_kind kind)
INTERNAL void *handle_get_data(struct gp_handle handle, enum handle_kind kind)
{
void *data = NULL;
struct sys_lock lock = sys_mutex_lock_s(G.handle_entries_mutex);
@ -479,7 +479,7 @@ INTERNAL void *handle_get_data(struct gpu_handle handle, enum handle_kind kind)
/* TODO: The GPU api should ensure that resources freed by the caller will not cause issues on the GPU (via fencing),
* however the caller is responsible for managing resource lifetimes on the CPU side (e.g. using sprites w/ sprite scopes
* to ensure freed textures aren't being used in pending command lists. */
void gpu_release(struct gpu_handle handle)
void gp_release(struct gp_handle handle)
{
enum handle_kind kind = 0;
void *data = NULL;
@ -1322,15 +1322,15 @@ INTERNAL struct plan *plan_alloc(void)
return plan;
}
struct gpu_handle gpu_plan_alloc(void)
struct gp_handle gp_plan_alloc(void)
{
struct plan *plan = plan_alloc();
return handle_alloc(DX12_HANDLE_KIND_PLAN, plan);
}
void gpu_push_cmd(struct gpu_handle gpu_plan, struct gpu_cmd_params params)
void gp_push_cmd(struct gp_handle gp_plan, struct gp_cmd_params params)
{
(UNUSED)gpu_plan;
(UNUSED)gp_plan;
(UNUSED)params;
}
@ -1450,11 +1450,11 @@ INTERNAL enum D3D12_RESOURCE_STATES dx12_resource_barrier(ID3D12GraphicsCommandL
return old_state;
}
struct gpu_handle gpu_texture_alloc(enum gpu_texture_format format, u32 flags, struct v2i32 size, void *initial_data)
struct gp_handle gp_texture_alloc(enum gp_texture_format format, u32 flags, struct v2i32 size, void *initial_data)
{
LOCAL_PERSIST const DXGI_FORMAT formats[] = {
[GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM] = DXGI_FORMAT_R8G8B8A8_UNORM,
[GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB] = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB
[GP_TEXTURE_FORMAT_R8G8B8A8_UNORM] = DXGI_FORMAT_R8G8B8A8_UNORM,
[GP_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB] = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB
};
DXGI_FORMAT dxgi_format = 0;
@ -1483,7 +1483,7 @@ struct gpu_handle gpu_texture_alloc(enum gpu_texture_format format, u32 flags, s
desc.Format = dxgi_format;
desc.SampleDesc.Count = 1;
desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
if (flags & GPU_TEXTURE_FLAG_TARGETABLE) {
if (flags & GP_TEXTURE_FLAG_TARGETABLE) {
desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
view_flags |= DX12_RESOURCE_VIEW_FLAG_RTV;
}
@ -1498,13 +1498,13 @@ struct gpu_handle gpu_texture_alloc(enum gpu_texture_format format, u32 flags, s
return handle_alloc(DX12_HANDLE_KIND_RESOURCE, r);
}
void gpu_texture_clear(struct gpu_handle target_resource, u32 clear_color)
void gp_texture_clear(struct gp_handle target_resource, u32 clear_color)
{
(UNUSED)target_resource;
(UNUSED)clear_color;
}
struct v2i32 gpu_texture_get_size(struct gpu_handle resource)
struct v2i32 gp_texture_get_size(struct gp_handle resource)
{
struct v2i32 res = ZI;
struct dx12_resource *dx12_resource = handle_get_data(resource, DX12_HANDLE_KIND_RESOURCE);
@ -1725,7 +1725,7 @@ INTERNAL struct command_descriptor_heap *command_list_push_descriptor_heap(struc
/* Remove from submitted list */
old_heap = cdh->heap;
old_cpu_handle = cdh->cpu_handle;
old_gpu_handle = cdh->gpu_handle;
old_gpu_handle = cdh->gp_handle;
struct command_descriptor_heap *prev = cdh->prev_submitted;
struct command_descriptor_heap *next = cdh->next_submitted;
if (prev) {
@ -1749,7 +1749,7 @@ INTERNAL struct command_descriptor_heap *command_list_push_descriptor_heap(struc
if (old_heap) {
cdh->heap = old_heap;
cdh->cpu_handle = old_cpu_handle;
cdh->gpu_handle = old_gpu_handle;
cdh->gp_handle = old_gpu_handle;
} else {
D3D12_DESCRIPTOR_HEAP_DESC desc = ZI;
desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
@ -1760,7 +1760,7 @@ INTERNAL struct command_descriptor_heap *command_list_push_descriptor_heap(struc
sys_panic(LIT("Failed to create GPU descriptor heap"));
}
ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(cdh->heap, &cdh->cpu_handle);
ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(cdh->heap, &cdh->gpu_handle);
ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(cdh->heap, &cdh->gp_handle);
}
/* Copy CPU heap */
@ -1868,8 +1868,8 @@ INTERNAL struct command_buffer *command_list_push_buffer(struct command_list *cl
{
#if 0
LOCAL_PERSIST const DXGI_FORMAT formats[] = {
[GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM] = DXGI_FORMAT_R8G8B8A8_UNORM,
[GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB] = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB
[GP_TEXTURE_FORMAT_R8G8B8A8_UNORM] = DXGI_FORMAT_R8G8B8A8_UNORM,
[GP_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB] = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB
};
DXGI_FORMAT dxgi_format = 0;
@ -1924,7 +1924,7 @@ INTERNAL struct command_buffer *command_list_push_buffer(struct command_list *cl
* Dispatch
* ========================== */
void gpu_dispatch(struct gpu_dispatch_params params)
void gp_dispatch(struct gp_dispatch_params params)
{
__prof;
@ -1976,12 +1976,12 @@ void gpu_dispatch(struct gpu_dispatch_params params)
#endif
/* Bind instance buffer */
//ID3D12GraphicsCommandList_SetGraphicsRootShaderResourceView(cl->cl, 1, instance_buffer->gpu_handle);
//ID3D12GraphicsCommandList_SetGraphicsRootShaderResourceView(cl->cl, 1, instance_buffer->gp_handle);
/* Bind descriptor heap */
ID3D12DescriptorHeap *heaps[] = { descriptor_heap->heap };
ID3D12GraphicsCommandList_SetDescriptorHeaps(cl->cl, ARRAY_COUNT(heaps), heaps);
ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(cl->cl, 2, descriptor_heap->gpu_handle);
ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(cl->cl, 2, descriptor_heap->gp_handle);
/* Setup Rasterizer State */
ID3D12GraphicsCommandList_RSSetViewports(cl->cl, 1, &d3d12_viewport);
@ -2011,7 +2011,7 @@ void gpu_dispatch(struct gpu_dispatch_params params)
* Present
* ========================== */
void gpu_present(struct v2i32 backbuffer_resolution, struct gpu_handle texture, struct xform texture_xf, i32 vsync)
void gp_present(struct v2i32 backbuffer_resolution, struct gp_handle texture, struct xform texture_xf, i32 vsync)
{
(UNUSED)backbuffer_resolution;
(UNUSED)texture;

12
src/sprite.c
View File

@ -9,7 +9,7 @@
#include "work.h"
#include "atomic.h"
#include "app.h"
#include "gpu.h"
#include "gp.h"
#include "math.h"
#include "rand.h"
@ -210,10 +210,10 @@ INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(sprite_evictor_thread_entry_point, arg)
INTERNAL RESOURCE_WATCH_CALLBACK_FUNC_DEF(sprite_resource_watch_callback, info);
#endif
struct sprite_startup_receipt sprite_startup(struct gpu_startup_receipt *gpu_sr,
struct sprite_startup_receipt sprite_startup(struct gp_startup_receipt *gp_sr,
struct resource_startup_receipt *resource_sr)
{
(UNUSED)gpu_sr;
(UNUSED)gp_sr;
(UNUSED)resource_sr;
G.perm_arena = arena_alloc(MEGABYTE(1));
@ -227,7 +227,7 @@ struct sprite_startup_receipt sprite_startup(struct gpu_startup_receipt *gpu_sr,
{
struct arena_temp scratch = scratch_begin_no_conflict();
struct image_rgba purple_black_image = generate_purple_black_image(scratch.arena, 64, 64);
G.nil_texture->texture = gpu_texture_alloc(GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM, 0, V2I32(purple_black_image.width, purple_black_image.height), purple_black_image.pixels);
G.nil_texture->texture = gp_texture_alloc(GP_TEXTURE_FORMAT_R8G8B8A8_UNORM, 0, V2I32(purple_black_image.width, purple_black_image.height), purple_black_image.pixels);
scratch_end(scratch);
}
@ -379,7 +379,7 @@ INTERNAL void cache_entry_load_texture(struct cache_ref ref, struct sprite_tag t
e->texture = arena_push(e->arena, struct sprite_texture);
e->texture->width = decoded.image.width;
e->texture->height = decoded.image.height;
e->texture->texture = gpu_texture_alloc(GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB, 0, V2I32(decoded.image.width, decoded.image.height), decoded.image.pixels);
e->texture->texture = gp_texture_alloc(GP_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB, 0, V2I32(decoded.image.width, decoded.image.height), decoded.image.pixels);
e->texture->valid = true;
e->texture->loaded = true;
/* TODO: Query gpu for more accurate texture size in VRAM */
@ -1358,7 +1358,7 @@ INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(sprite_evictor_thread_entry_point, arg)
for (struct evict_node *en = first_evicted; en; en = en->next_evicted) {
struct cache_entry *n = en->cache_entry;
if (n->kind == CACHE_ENTRY_KIND_TEXTURE && n->texture->valid) {
gpu_release(n->texture->texture);
gp_release(n->texture->texture);
}
arena_release(n->arena);
}

8
src/sprite.h
View File

@ -1,10 +1,10 @@
#ifndef SPRITE_H
#define SPRITE_H
#include "gpu.h"
#include "gp.h"
#include "util.h"
struct gpu_startup_receipt;
struct gp_startup_receipt;
struct resource_startup_receipt;
struct sprite_sheet_span;
struct sprite_sheet_slice_group;
@ -14,7 +14,7 @@ struct sprite_sheet_slice_group;
* ========================== */
struct sprite_startup_receipt { i32 _; };
struct sprite_startup_receipt sprite_startup(struct gpu_startup_receipt *gpu_sr,
struct sprite_startup_receipt sprite_startup(struct gp_startup_receipt *gp_sr,
struct resource_startup_receipt *resource_sr);
/* ========================== *
@ -48,7 +48,7 @@ void sprite_scope_end(struct sprite_scope *scope);
struct sprite_texture {
b32 loaded;
b32 valid;
struct gpu_handle texture;
struct gp_handle texture;
u32 width;
u32 height;
};

162
src/user.c
View File

@ -2,7 +2,7 @@
#include "sim.h"
#include "sim_ent.h"
#include "sim_step.h"
#include "gpu.h"
#include "gp.h"
#include "font.h"
#include "sprite.h"
#include "draw.h"
@ -71,10 +71,10 @@ GLOBAL struct {
struct second_stat net_bytes_sent;
/* Gpu handles */
struct gpu_handle user_texture;
struct gp_handle user_texture;
struct gpu_handle world_gpu_plan;
struct gpu_handle ui_gpu_plan;
struct gp_handle world_gp_plan;
struct gp_handle ui_gp_plan;
struct xform world_to_user_xf;
@ -201,7 +201,7 @@ INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(user_local_sim_thread_entry_point, arg)
INTERNAL SYS_WINDOW_EVENT_CALLBACK_FUNC_DEF(window_event_callback, event);
struct user_startup_receipt user_startup(struct work_startup_receipt *work_sr,
struct gpu_startup_receipt *gpu_sr,
struct gp_startup_receipt *gp_sr,
struct font_startup_receipt *font_sr,
struct sprite_startup_receipt *sprite_sr,
struct draw_startup_receipt *draw_sr,
@ -214,7 +214,7 @@ struct user_startup_receipt user_startup(struct work_startup_receipt *work_sr,
struct sys_window *window)
{
(UNUSED)work_sr;
(UNUSED)gpu_sr;
(UNUSED)gp_sr;
(UNUSED)font_sr;
(UNUSED)sprite_sr;
(UNUSED)draw_sr;
@ -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_gpu_plan = gpu_plan_alloc();
G.ui_gpu_plan = gpu_plan_alloc();
G.world_gp_plan = gp_plan_alloc();
G.ui_gp_plan = gp_plan_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_gpu_plan, pos, x_ray, thickness, arrowhead_len, color_x);
draw_arrow_ray(G.ui_gpu_plan, pos, y_ray, thickness, arrowhead_len, color_y);
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);
//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_gpu_plan, quad, color);
//draw_quad(G.ui_gp_plan, 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_gpu_plan, pos, vel_ray, thickness, arrow_len, color_vel);
draw_arrow_ray(G.ui_gp_plan, 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_gpu_plan, quad_from_rect(log->bounds), ALPHA32_F(color, opacity));
draw_quad(G.ui_gp_plan, 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_gpu_plan, params);
struct rect bounds = draw_text(G.ui_gp_plan, 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_gpu_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_plan, xform_from_rect(RECT_FROM_V2(pos, size)), color0, color1, RGBA32(0x3f, 0x3f, 0x3f, 0xFF), COLOR_RED, COLOR_GREEN, thickness, spacing, offset);
}
/* ========================== *
@ -1060,10 +1060,10 @@ INTERNAL void user_update(void)
{
struct v2 pos = xform_invert_mul_v2(G.world_to_user_xf, V2(0, 0));
struct v2 size = xform_basis_invert_mul_v2(G.world_to_user_xf, G.user_size);
struct gpu_cmd_params cmd = ZI;
cmd.kind = GPU_CMD_KIND_TEST;
struct gp_cmd_params cmd = ZI;
cmd.kind = GP_CMD_KIND_TEST;
cmd.test.xf = xform_from_rect(RECT_FROM_V2(pos, size));
gpu_push_cmd(G.world_gpu_plan, cmd);
gp_push_cmd(G.world_gp_plan, 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_gpu_plan, b, thickness / 2, color_end, 20);
draw_circle(G.world_gp_plan, b, thickness / 2, color_end, 20);
}
draw_gradient_line(G.world_gpu_plan, a, b, thickness, color_start, color_end);
draw_gradient_line(G.world_gp_plan, 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_gpu_plan, params);
draw_texture(G.world_gp_plan, 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_gpu_plan, params);
draw_texture(G.world_gp_plan, 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_gpu_plan, quad, thickness, color);
draw_quad_line(G.ui_gp_plan, 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_gpu_plan, start, end, 3, 10, RGBA32_F(1, 1, 1, 0.5));
draw_arrow_line(G.ui_gp_plan, 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_gpu_plan, quad, 2, quad_color);
draw_quad_line(G.ui_gp_plan, quad, 2, quad_color);
}
draw_circle(G.ui_gpu_plan, center, 3, point_color, 20);
draw_circle(G.ui_gp_plan, 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_gpu_plan, center, ray, 2, 10, ray_color);
draw_arrow_ray(G.ui_gp_plan, 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_gpu_plan, point, radius, color, 10);
draw_circle(G.ui_gp_plan, 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_gpu_plan, point_start, point_end, 3, 10, color);
draw_circle(G.ui_gpu_plan, point_start, 4, color, 10);
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 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_gpu_plan, collider, collider_draw_xf, thickness, color, detail);
draw_collider_line(G.ui_gp_plan, 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_gpu_plan, p, 3, COLOR_BLUE, 10);
draw_circle(G.ui_gp_plan, 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_gpu_plan, start, end, thickness, color);
draw_line(G.ui_gp_plan, 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_gpu_plan, p, 3, COLOR_RED, 10);
draw_circle(G.ui_gp_plan, p, 3, COLOR_RED, 10);
}
#endif
}
@ -1448,7 +1448,7 @@ INTERNAL void user_update(void)
/* Draw point */
{
draw_circle(G.ui_gpu_plan, xform_mul_v2(G.world_to_user_xf, dbg_pt), radius, color, 10);
draw_circle(G.ui_gp_plan, 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_gpu_plan, start, end, arrow_thickness, arrow_height, color);
draw_arrow_line(G.ui_gp_plan, 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_gpu_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_plan, 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_gpu_plan, a, radius, color, 10);
draw_circle(G.ui_gpu_plan, b, radius, color, 10);
draw_circle(G.ui_gp_plan, a, radius, color, 10);
draw_circle(G.ui_gp_plan, 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_gpu_plan, a, b, thickness, color_line);
draw_circle(G.ui_gpu_plan, a, radius, color_a, 10);
draw_circle(G.ui_gpu_plan, b, radius, color_b, 10);
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);
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_gpu_plan, a_clipped, b_clipped, thickness, color_line_clipped);
draw_circle(G.ui_gpu_plan, a_clipped, radius, color_a_clipped, 10);
draw_circle(G.ui_gpu_plan, b_clipped, radius, color_b_clipped, 10);
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);
}
{
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_gpu_plan, a, b, thickness, color_line);
draw_circle(G.ui_gpu_plan, a, radius, color_a, 10);
draw_circle(G.ui_gpu_plan, b, radius, color_b, 10);
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);
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_gpu_plan, a_clipped, b_clipped, thickness, color_line_clipped);
draw_circle(G.ui_gpu_plan, a_clipped, radius, color_a_clipped, 10);
draw_circle(G.ui_gpu_plan, b_clipped, radius, color_b_clipped, 10);
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);
}
}
@ -1596,7 +1596,7 @@ INTERNAL void user_update(void)
FMT_FLOAT_P(xform_get_rotation(e1_xf), 24));
draw_text(G.ui_gpu_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_plan, 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_gpu_plan, m, true, thickness, color);
//draw_poly(G.ui_gpu_plan, m, color);
draw_poly_line(G.ui_gp_plan, m, true, thickness, color);
//draw_poly(G.ui_gp_plan, 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_gpu_plan, p, radius, color, 10);
draw_circle(G.ui_gp_plan, 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_gpu_plan, m, true, thickness, color);
for (u64 i = 0; i < m.count; ++i) draw_circle(G.ui_gpu_plan, m.points[i], 10, color, 10);
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 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_gpu_plan, simplex_array.points[0], thickness * 3, color, 10);
draw_circle(G.ui_gp_plan, 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_gpu_plan, simplex_array.points[1], thickness * 3, color, 10);
draw_circle(G.ui_gp_plan, simplex_array.points[1], thickness * 3, color, 10);
}
if (simplex.len >= 3) {
u32 color = color_first;
draw_circle(G.ui_gpu_plan, simplex_array.points[2], thickness * 3, color, 10);
draw_circle(G.ui_gp_plan, simplex_array.points[2], thickness * 3, color, 10);
}
if (simplex.len >= 2) {
draw_poly_line(G.ui_gpu_plan, simplex_array, simplex.len > 2, thickness, line_color);
draw_poly_line(G.ui_gp_plan, 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_gpu_plan, start, end, arrow_thickness, arrowhead_height, color);
draw_arrow_line(G.ui_gp_plan, 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_gpu_plan, start, end, thickness, arrow_height, color);
draw_arrow_line(G.ui_gp_plan, 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_gpu_plan, quad, thickness, color);
draw_quad_line(G.ui_gp_plan, 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_gpu_plan, DRAW_TEXTURE_PARAMS(.xf = xf, .sprite = crosshair_tag));
draw_texture(G.ui_gp_plan, 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_gpu_plan, DRAW_TEXT_PARAMS(.font = font, .pos = pos, .str = dbg_text));
draw_text(G.ui_gp_plan, 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_gpu_plan, font, pos, string_format(temp.arena, LIT("collider gjk steps: %F"), FMT_UINT(collider_debug_steps)));
draw_text(G.ui_gp_plan, font, pos, string_format(temp.arena, LIT("collider gjk steps: %F"), FMT_UINT(collider_debug_steps)));
pos.y += spacing;
#endif
//draw_text(G.ui_gpu_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_gpu_plan, font, pos, text);
//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);
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_gpu_plan, DRAW_TEXT_PARAMS(.font = font, .pos = pos, .str = text, .offset_y = offset_y, .color = COLOR_WHITE));
draw_text(G.ui_gp_plan, DRAW_TEXT_PARAMS(.font = font, .pos = pos, .str = text, .offset_y = offset_y, .color = COLOR_WHITE));
arena_temp_end(temp);
}
}
@ -2062,38 +2062,38 @@ INTERNAL void user_update(void)
struct v2i32 backbuffer_resolution = v2_round_to_int(G.screen_size);
/* Allocate user texture */
if (!G.user_texture.v || !v2i32_eq(gpu_texture_get_size(G.user_texture), user_resolution)) {
if (!G.user_texture.v || !v2i32_eq(gp_texture_get_size(G.user_texture), user_resolution)) {
if (G.user_texture.v) {
gpu_release(G.user_texture);
gp_release(G.user_texture);
}
G.user_texture = gpu_texture_alloc(GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM, GPU_TEXTURE_FLAG_TARGETABLE, user_resolution, NULL);
G.user_texture = gp_texture_alloc(GP_TEXTURE_FORMAT_R8G8B8A8_UNORM, GP_TEXTURE_FLAG_TARGETABLE, user_resolution, NULL);
}
/* Clear textures */
gpu_texture_clear(G.user_texture, 0);
gp_texture_clear(G.user_texture, 0);
/* Render world to user texture */
{
struct gpu_dispatch_params params = ZI;
params.plan = G.world_gpu_plan;
struct gp_dispatch_params params = ZI;
params.plan = G.world_gp_plan;
params.draw_target = G.user_texture;
params.draw_target_viewport = user_viewport;
params.draw_target_view = G.world_to_user_xf;
gpu_dispatch(params);
gp_dispatch(params);
}
/* Render ui to user texture */
{
struct gpu_dispatch_params params = ZI;
params.plan = G.ui_gpu_plan;
struct gp_dispatch_params params = ZI;
params.plan = G.ui_gp_plan;
params.draw_target = G.user_texture;
params.draw_target_viewport = user_viewport;
params.draw_target_view = XFORM_IDENT;
gpu_dispatch(params);
gp_dispatch(params);
}
/* Present user texture */
gpu_present(backbuffer_resolution, G.user_texture, XFORM_TRS(.t = v2_mul(G.screen_size, 0.5), .s = G.user_size), VSYNC_ENABLED);
gp_present(backbuffer_resolution, G.user_texture, XFORM_TRS(.t = v2_mul(G.screen_size, 0.5), .s = G.user_size), VSYNC_ENABLED);
}
/* ========================== *

4
src/user.h
View File

@ -3,7 +3,7 @@
struct sys_window;
struct work_startup_receipt;
struct gpu_startup_receipt;
struct gp_startup_receipt;
struct font_startup_receipt;
struct sprite_startup_receipt;
struct draw_startup_receipt;
@ -62,7 +62,7 @@ enum user_bind_kind {
struct user_startup_receipt { i32 _; };
struct user_startup_receipt user_startup(struct work_startup_receipt *work_sr,
struct gpu_startup_receipt *gpu_sr,
struct gp_startup_receipt *gp_sr,
struct font_startup_receipt *font_sr,
struct sprite_startup_receipt *sprite_sr,
struct draw_startup_receipt *draw_sr,