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

rename 'renderer' -> 'gpu'

Browse Source
This commit is contained in:
jacob 2025-05-23 20:43:51 -05:00
parent b228ffe7b6
commit 85bac53e78
15 changed files with 334 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
build.c
View File

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

4
res/shaders/common.hlsl
View File

@ -3,7 +3,3 @@ float4 linear_from_srgb(float4 srgb)
return float4(pow(srgb.rgb, 2.2), srgb.a); return float4(pow(srgb.rgb, 2.2), srgb.a);
} }
float bla(float a)
{
return a;
}

12
src/app.c
View File

@ -20,7 +20,7 @@
#include "settings.h" #include "settings.h"
#include "draw.h" #include "draw.h"
#include "math.h" #include "math.h"
#include "renderer.h" #include "gpu.h"
#include "phys.h" #include "phys.h"
#include "sock.h" #include "sock.h"
#include "host.h" #include "host.h"
@ -326,17 +326,17 @@ void app_entry_point(struct string args_str)
struct sock_startup_receipt sock_sr = sock_startup(); struct sock_startup_receipt sock_sr = sock_startup();
struct host_startup_receipt host_sr = host_startup(&sock_sr); struct host_startup_receipt host_sr = host_startup(&sock_sr);
struct resource_startup_receipt resource_sr = resource_startup(); struct resource_startup_receipt resource_sr = resource_startup();
struct renderer_startup_receipt renderer_sr = renderer_startup(&window); struct gpu_startup_receipt gpu_sr = gpu_startup(&window);
struct work_startup_receipt work_sr = work_startup(worker_count); struct work_startup_receipt work_sr = work_startup(worker_count);
struct asset_cache_startup_receipt asset_cache_sr = asset_cache_startup(&work_sr); struct asset_cache_startup_receipt asset_cache_sr = asset_cache_startup(&work_sr);
struct ttf_startup_receipt ttf_sr = ttf_startup(); struct ttf_startup_receipt ttf_sr = ttf_startup();
struct font_startup_receipt font_sr = font_startup(&work_sr, &renderer_sr, &asset_cache_sr, &ttf_sr, &resource_sr); 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(&renderer_sr, &resource_sr); struct sprite_startup_receipt sprite_sr = sprite_startup(&gpu_sr, &resource_sr);
struct mixer_startup_receipt mixer_sr = mixer_startup(); struct mixer_startup_receipt mixer_sr = mixer_startup();
struct sound_startup_receipt sound_sr = sound_startup(&work_sr, &asset_cache_sr, &resource_sr); struct sound_startup_receipt sound_sr = sound_startup(&work_sr, &asset_cache_sr, &resource_sr);
struct draw_startup_receipt draw_sr = draw_startup(&renderer_sr, &font_sr); struct draw_startup_receipt draw_sr = draw_startup(&gpu_sr, &font_sr);
struct sim_startup_receipt sim_sr = sim_startup(); struct sim_startup_receipt sim_sr = sim_startup();
struct user_startup_receipt user_sr = user_startup(&work_sr, &renderer_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, &gpu_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); struct playback_startup_receipt playback_sr = playback_startup(&mixer_sr);
(UNUSED)user_sr; (UNUSED)user_sr;

25
src/common.h
View File

@ -281,8 +281,9 @@ void __asan_unpoison_memory_region(void const volatile *add, size_t);
#endif #endif
/* Color */ /* Color */
#define RGBA(r, g, b, a) (u32)((u32)(r) | ((u32)(g) << 8) | ((u32)(b) << 16) | ((u32)(a) << 24))
#define RGB(r, g, b) RGBA((r), (g), (b), 0xFF) #define RGB(r, g, b) RGBA((r), (g), (b), 0xFF)
#define RGBA(r, g, b, a) (u32)((u32)(r) | ((u32)(g) << 8) | ((u32)(b) << 16) | ((u32)(a) << 24))
#define BGR(rgb) ((((rgb >> 0) & 0xFF) << 16) | (((rgb >> 8) & 0xFF) << 8) | (((rgb >> 16) & 0xFF) << 0))
#define _RGB_U8_FROM_F(fl) ((u8)((fl * 255.0) + 0.5)) #define _RGB_U8_FROM_F(fl) ((u8)((fl * 255.0) + 0.5))
#define RGBA_F(r, g, b, a) RGBA(_RGB_U8_FROM_F((r)), _RGB_U8_FROM_F((g)), _RGB_U8_FROM_F((b)), _RGB_U8_FROM_F((a))) #define RGBA_F(r, g, b, a) RGBA(_RGB_U8_FROM_F((r)), _RGB_U8_FROM_F((g)), _RGB_U8_FROM_F((b)), _RGB_U8_FROM_F((a)))
@ -647,10 +648,10 @@ INLINE f64 clamp_f64(f64 v, f64 min, f64 max) { return v < min ? min : v > max ?
# define __prof static const struct ___tracy_source_location_data CAT(__tracy_source_location,__LINE__) = { NULL, __func__, __FILE__, (uint32_t)__LINE__, 0 }; __attribute((cleanup(__prof_zone_cleanup_func))) TracyCZoneCtx __tracy_zone_ctx = ___tracy_emit_zone_begin_callstack( &CAT(__tracy_source_location,__LINE__), TRACY_CALLSTACK, true ); # define __prof static const struct ___tracy_source_location_data CAT(__tracy_source_location,__LINE__) = { NULL, __func__, __FILE__, (uint32_t)__LINE__, 0 }; __attribute((cleanup(__prof_zone_cleanup_func))) TracyCZoneCtx __tracy_zone_ctx = ___tracy_emit_zone_begin_callstack( &CAT(__tracy_source_location,__LINE__), TRACY_CALLSTACK, true );
# define __profscope(name) static const struct ___tracy_source_location_data CAT(__tracy_source_location,__LINE__) = { #name, __func__, __FILE__, (uint32_t)__LINE__, 0 }; __attribute((cleanup(__prof_zone_cleanup_func))) TracyCZoneCtx __tracy_zone_ctx = ___tracy_emit_zone_begin_callstack( &CAT(__tracy_source_location,__LINE__), TRACY_CALLSTACK, true ); # define __profscope(name) static const struct ___tracy_source_location_data CAT(__tracy_source_location,__LINE__) = { #name, __func__, __FILE__, (uint32_t)__LINE__, 0 }; __attribute((cleanup(__prof_zone_cleanup_func))) TracyCZoneCtx __tracy_zone_ctx = ___tracy_emit_zone_begin_callstack( &CAT(__tracy_source_location,__LINE__), TRACY_CALLSTACK, true );
# endif # endif
# define __profscope_d3d11(d3d11_ctx, name) static const struct ___tracy_source_location_data CAT(__tracy_gpu_d3d11_source_location,__LINE__) = { #name, __func__, __FILE__, (uint32_t)__LINE__, 0 }; __attribute((cleanup(__prof_d3d11_zone_cleanup_func))) TracyCD3D11ZoneCtx __tracy_d3d11_zone_ctx; ___tracy_d3d11_emit_zone_begin( d3d11_ctx, &__tracy_d3d11_zone_ctx, &CAT(__tracy_gpu_d3d11_source_location,__LINE__), true); # define __profscope_dx11(dx11_ctx, name, color) static const struct ___tracy_source_location_data CAT(__tracy_gpu_d3d11_source_location,__LINE__) = { #name, __func__, __FILE__, (uint32_t)__LINE__, BGR(color) }; __attribute((cleanup(__prof_dx11_zone_cleanup_func))) TracyCD3D11ZoneCtx __tracy_d3d11_zone_ctx; ___tracy_d3d11_emit_zone_begin( dx11_ctx, &__tracy_d3d11_zone_ctx, &CAT(__tracy_gpu_d3d11_source_location,__LINE__), true);
#endif #endif
INLINE void __prof_zone_cleanup_func(TracyCZoneCtx *ctx) { TracyCZoneEnd(*ctx); } INLINE void __prof_zone_cleanup_func(TracyCZoneCtx *ctx) { TracyCZoneEnd(*ctx); }
INLINE void __prof_d3d11_zone_cleanup_func(TracyCD3D11ZoneCtx *ctx) { ___tracy_d3d11_emit_zone_end(*ctx); } INLINE void __prof_dx11_zone_cleanup_func(TracyCD3D11ZoneCtx *ctx) { ___tracy_d3d11_emit_zone_end(*ctx); }
#define __profalloc(ptr, size) TracyCAlloc((ptr), (size)) #define __profalloc(ptr, size) TracyCAlloc((ptr), (size))
#define __proffree(ptr) TracyCFree((ptr)) #define __proffree(ptr) TracyCFree((ptr))
@ -672,10 +673,10 @@ INLINE void __prof_d3d11_zone_cleanup_func(TracyCD3D11ZoneCtx *ctx) { ___tracy_d
#define __proflock_mark(ctx) TracyCSharedLockMark((ctx)) #define __proflock_mark(ctx) TracyCSharedLockMark((ctx))
#define __proflock_custom_name(ctx, name, len) TracyCSharedLockCustomName((ctx), (name), (len)) #define __proflock_custom_name(ctx, name, len) TracyCSharedLockCustomName((ctx), (name), (len))
#define __prof_d3d11_ctx TracyCD3D11Ctx #define __prof_dx11_ctx TracyCD3D11Ctx
#define __prof_d3d11_ctx_alloc(ctx, device, devicectx, name, name_len) ctx = ___tracy_d3d11_context_announce(device, devicectx, name, name_len) #define __prof_dx11_ctx_alloc(ctx, device, devicectx, name, name_len) ctx = ___tracy_d3d11_context_announce(device, devicectx, name, name_len)
#define __prof_d3d11_ctx_release(ctx) ___tracy_d3d11_context_terminate(ctx) #define __prof_dx11_ctx_release(ctx) ___tracy_d3d11_context_terminate(ctx)
#define __prof_d3d11_collect(ctx) ___tracy_d3d11_context_collect(ctx) #define __prof_dx11_collect(ctx) ___tracy_d3d11_context_collect(ctx)
enum __prof_plot_type { enum __prof_plot_type {
__prof_plot_type_number = TracyPlotFormatNumber, __prof_plot_type_number = TracyPlotFormatNumber,
@ -699,7 +700,7 @@ enum __prof_plot_type {
#define __prof #define __prof
#define __profscope(name) #define __profscope(name)
#define __profscope_d3d11(d3d11_ctx, name) #define __profscope_dx11(dx11_ctx, name, color)
#define __profalloc(ptr, size) #define __profalloc(ptr, size)
#define __proffree(ptr) #define __proffree(ptr)
#define __profmsg(txt, len, col) #define __profmsg(txt, len, col)
@ -719,10 +720,10 @@ enum __prof_plot_type {
#define __proflock_after_try_shared_lock(ctx, acquired) #define __proflock_after_try_shared_lock(ctx, acquired)
#define __proflock_mark(ctx) #define __proflock_mark(ctx)
#define __proflock_custom_name(ctx, name, len) #define __proflock_custom_name(ctx, name, len)
#define __prof_d3d11_ctx #define __prof_dx11_ctx
#define __prof_d3d11_ctx_alloc(ctx, device, devicectx, name, name_len) #define __prof_dx11_ctx_alloc(ctx, device, devicectx, name, name_len)
#define __prof_d3d11_ctx_release(ctx) #define __prof_dx11_ctx_release(ctx)
#define __prof_d3d11_collect(ctx) #define __prof_dx11_collect(ctx)
#define __prof_plot_init(name, type, step, fill, color) #define __prof_plot_init(name, type, step, fill, color)
#define __prof_plot(name, val) #define __prof_plot(name, val)
#define __prof_plot_i(name, val) #define __prof_plot_i(name, val)

62
src/draw.c
View File

@ -1,5 +1,5 @@
#include "draw.h" #include "draw.h"
#include "renderer.h" #include "gpu.h"
#include "math.h" #include "math.h"
#include "font.h" #include "font.h"
#include "scratch.h" #include "scratch.h"
@ -7,20 +7,20 @@
#include "collider.h" #include "collider.h"
GLOBAL struct { GLOBAL struct {
struct renderer_texture solid_white; struct gpu_texture solid_white;
} G = ZI, DEBUG_ALIAS(G, G_draw); } G = ZI, DEBUG_ALIAS(G, G_draw);
/* ========================== * /* ========================== *
* Startup * Startup
* ========================== */ * ========================== */
struct draw_startup_receipt draw_startup(struct renderer_startup_receipt *renderer_sr, struct draw_startup_receipt draw_startup(struct gpu_startup_receipt *gpu_sr,
struct font_startup_receipt *font_sr) struct font_startup_receipt *font_sr)
{ {
(UNUSED)renderer_sr; (UNUSED)gpu_sr;
(UNUSED)font_sr; (UNUSED)font_sr;
u32 pixel_white = 0xFFFFFFFF; u32 pixel_white = 0xFFFFFFFF;
G.solid_white = renderer_texture_alloc(RENDERER_TEXTURE_FORMAT_R8G8B8A8_UNORM, 0, V2I32(1, 1), &pixel_white); G.solid_white = gpu_texture_alloc(GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM, 0, V2I32(1, 1), &pixel_white);
return (struct draw_startup_receipt) { 0 }; return (struct draw_startup_receipt) { 0 };
} }
@ -28,17 +28,17 @@ struct draw_startup_receipt draw_startup(struct renderer_startup_receipt *render
* Texture * Texture
* ========================== */ * ========================== */
void draw_quad_texture_ex(struct renderer_cmd_buffer *cmdbuff, struct renderer_texture texture, struct sprite_tag sprite, struct clip_rect clip, u32 tint0_srgb, u32 tint1_srgb, struct quad quad) void draw_quad_texture_ex(struct gpu_cmd_buffer *cmdbuff, struct gpu_texture texture, struct sprite_tag sprite, struct clip_rect clip, u32 tint0_srgb, u32 tint1_srgb, struct quad quad)
{ {
struct renderer_cmd_parameters cmd_params = ZI; struct gpu_cmd_parameters cmd_params = ZI;
cmd_params.kind = SHADER_TRIANGLE; cmd_params.kind = SHADER_TRIANGLE;
cmd_params.texture_params.texture = texture; cmd_params.texture_params.texture = texture;
cmd_params.texture_params.sprite = sprite; cmd_params.texture_params.sprite = sprite;
renderer_cmd_buffer_ensure_cmd(cmdbuff, &cmd_params); gpu_cmd_buffer_ensure_cmd(cmdbuff, &cmd_params);
struct triangle_shader_vertex *vertices = NULL; struct triangle_shader_vertex *vertices = NULL;
vidx *indices = NULL; vidx *indices = NULL;
u32 offset = renderer_cmd_buffer_push_vertices(cmdbuff, (u8 **)&vertices, &indices, 4, 6); u32 offset = gpu_cmd_buffer_push_vertices(cmdbuff, (u8 **)&vertices, &indices, 4, 6);
/* Top left */ /* Top left */
vertices[0] = (struct triangle_shader_vertex) { vertices[0] = (struct triangle_shader_vertex) {
@ -76,7 +76,7 @@ void draw_quad_texture_ex(struct renderer_cmd_buffer *cmdbuff, struct renderer_t
indices[5] = offset + 3; indices[5] = offset + 3;
} }
void draw_quad_texture(struct renderer_cmd_buffer *cmdbuff, struct draw_texture_params params, struct quad quad) void draw_quad_texture(struct gpu_cmd_buffer *cmdbuff, struct draw_texture_params params, struct quad quad)
{ {
draw_quad_texture_ex(cmdbuff, params.texture, params.sprite, params.clip, params.tint, params.tint, quad); draw_quad_texture_ex(cmdbuff, params.texture, params.sprite, params.clip, params.tint, params.tint, quad);
} }
@ -85,23 +85,23 @@ void draw_quad_texture(struct renderer_cmd_buffer *cmdbuff, struct draw_texture_
* Solid fill shapes * Solid fill shapes
* ========================== */ * ========================== */
void draw_poly(struct renderer_cmd_buffer *cmdbuff, struct v2_array array, u32 srgb) void draw_poly(struct gpu_cmd_buffer *cmdbuff, struct v2_array array, u32 srgb)
{ {
if (array.count < 3) { if (array.count < 3) {
return; return;
} }
struct renderer_cmd_parameters cmd_params = ZI; struct gpu_cmd_parameters cmd_params = ZI;
cmd_params.kind = SHADER_TRIANGLE; cmd_params.kind = SHADER_TRIANGLE;
cmd_params.texture_params.texture = G.solid_white; cmd_params.texture_params.texture = G.solid_white;
renderer_cmd_buffer_ensure_cmd(cmdbuff, &cmd_params); gpu_cmd_buffer_ensure_cmd(cmdbuff, &cmd_params);
u32 num_tris = array.count - 2; u32 num_tris = array.count - 2;
u32 num_indices = num_tris * 3; u32 num_indices = num_tris * 3;
struct triangle_shader_vertex *vertices = NULL; struct triangle_shader_vertex *vertices = NULL;
vidx *indices = NULL; vidx *indices = NULL;
u32 idx_offset = renderer_cmd_buffer_push_vertices(cmdbuff, (u8 **)&vertices, &indices, array.count, num_indices); u32 idx_offset = gpu_cmd_buffer_push_vertices(cmdbuff, (u8 **)&vertices, &indices, array.count, num_indices);
/* Fill vertices */ /* Fill vertices */
for (u32 i = 0; i < array.count; ++i) { for (u32 i = 0; i < array.count; ++i) {
@ -120,7 +120,7 @@ void draw_poly(struct renderer_cmd_buffer *cmdbuff, struct v2_array array, u32 s
} }
} }
void draw_circle(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, f32 radius, u32 srgb, u32 detail) void draw_circle(struct gpu_cmd_buffer *cmdbuff, struct v2 pos, f32 radius, u32 srgb, u32 detail)
{ {
struct temp_arena scratch = scratch_begin_no_conflict(); struct temp_arena scratch = scratch_begin_no_conflict();
@ -142,7 +142,7 @@ void draw_circle(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, f32 radius,
scratch_end(scratch); scratch_end(scratch);
} }
void draw_quad(struct renderer_cmd_buffer *cmdbuff, struct quad quad, u32 srgb) void draw_quad(struct gpu_cmd_buffer *cmdbuff, struct quad quad, u32 srgb)
{ {
draw_quad_texture_ex(cmdbuff, G.solid_white, sprite_tag_nil(), CLIP_ALL, srgb, srgb, quad); draw_quad_texture_ex(cmdbuff, G.solid_white, sprite_tag_nil(), CLIP_ALL, srgb, srgb, quad);
} }
@ -151,25 +151,25 @@ void draw_quad(struct renderer_cmd_buffer *cmdbuff, struct quad quad, u32 srgb)
* Solid line shapes * Solid line shapes
* ========================== */ * ========================== */
void draw_gradient_line(struct renderer_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, u32 start_srgb, u32 end_srgb) void draw_gradient_line(struct gpu_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, u32 start_srgb, u32 end_srgb)
{ {
struct quad quad = quad_from_line(start, end, thickness); struct quad quad = quad_from_line(start, end, thickness);
draw_quad_texture_ex(cmdbuff, G.solid_white, sprite_tag_nil(), CLIP_ALL, start_srgb, end_srgb, quad); draw_quad_texture_ex(cmdbuff, G.solid_white, sprite_tag_nil(), CLIP_ALL, start_srgb, end_srgb, quad);
} }
void draw_line(struct renderer_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, u32 srgb) void draw_line(struct gpu_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, u32 srgb)
{ {
struct quad quad = quad_from_line(start, end, thickness); struct quad quad = quad_from_line(start, end, thickness);
draw_quad(cmdbuff, quad, srgb); draw_quad(cmdbuff, quad, srgb);
} }
void draw_ray(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, struct v2 rel, f32 thickness, u32 srgb) void draw_ray(struct gpu_cmd_buffer *cmdbuff, struct v2 pos, struct v2 rel, f32 thickness, u32 srgb)
{ {
struct quad quad = quad_from_ray(pos, rel, thickness); struct quad quad = quad_from_ray(pos, rel, thickness);
draw_quad(cmdbuff, quad, srgb); draw_quad(cmdbuff, quad, srgb);
} }
void draw_poly_line(struct renderer_cmd_buffer *cmdbuff, struct v2_array array, b32 loop, f32 thickness, u32 srgb) void draw_poly_line(struct gpu_cmd_buffer *cmdbuff, struct v2_array array, b32 loop, f32 thickness, u32 srgb)
{ {
if (array.count < 2) { if (array.count < 2) {
return; return;
@ -189,7 +189,7 @@ void draw_poly_line(struct renderer_cmd_buffer *cmdbuff, struct v2_array array,
} }
} }
void draw_circle_line(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, f32 radius, f32 thickness, u32 srgb, u32 detail) void draw_circle_line(struct gpu_cmd_buffer *cmdbuff, struct v2 pos, f32 radius, f32 thickness, u32 srgb, u32 detail)
{ {
struct temp_arena scratch = scratch_begin_no_conflict(); struct temp_arena scratch = scratch_begin_no_conflict();
@ -211,14 +211,14 @@ void draw_circle_line(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, f32 ra
scratch_end(scratch); scratch_end(scratch);
} }
void draw_quad_line(struct renderer_cmd_buffer *cmdbuff, struct quad quad, f32 thickness, u32 srgb) void draw_quad_line(struct gpu_cmd_buffer *cmdbuff, struct quad quad, f32 thickness, u32 srgb)
{ {
struct v2 points[] = { quad.p0, quad.p1, quad.p2, quad.p3 }; struct v2 points[] = { quad.p0, quad.p1, quad.p2, quad.p3 };
struct v2_array a = { .points = points, .count = ARRAY_COUNT(points) }; struct v2_array a = { .points = points, .count = ARRAY_COUNT(points) };
draw_poly_line(cmdbuff, a, true, thickness, srgb); draw_poly_line(cmdbuff, a, true, thickness, srgb);
} }
void draw_arrow_line(struct renderer_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 srgb) void draw_arrow_line(struct gpu_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 srgb)
{ {
const f32 head_width_ratio = 0.5f; /* Width of arrowhead relative to its length */ const f32 head_width_ratio = 0.5f; /* Width of arrowhead relative to its length */
@ -248,13 +248,13 @@ void draw_arrow_line(struct renderer_cmd_buffer *cmdbuff, struct v2 start, struc
draw_quad(cmdbuff, line_quad, srgb); draw_quad(cmdbuff, line_quad, srgb);
} }
void draw_arrow_ray(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 srgb) void draw_arrow_ray(struct gpu_cmd_buffer *cmdbuff, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 srgb)
{ {
struct v2 end = v2_add(pos, rel); struct v2 end = v2_add(pos, rel);
draw_arrow_line(cmdbuff, pos, end, thickness, arrowhead_height, srgb); draw_arrow_line(cmdbuff, pos, end, thickness, arrowhead_height, srgb);
} }
void draw_collider_line(struct renderer_cmd_buffer *cmdbuff, struct xform draw_xf, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 srgb, u32 detail) void draw_collider_line(struct gpu_cmd_buffer *cmdbuff, struct xform draw_xf, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 srgb, u32 detail)
{ {
struct temp_arena scratch = scratch_begin_no_conflict(); struct temp_arena scratch = scratch_begin_no_conflict();
@ -285,15 +285,15 @@ void draw_collider_line(struct renderer_cmd_buffer *cmdbuff, struct xform draw_x
* Grid * Grid
* ========================== */ * ========================== */
void draw_grid(struct renderer_cmd_buffer *cmdbuff, struct rect rect, u32 bg0_srgb, u32 bg1_srgb, u32 line_srgb, u32 x_srgb, u32 y_srgb, f32 thickness, f32 spacing, struct v2 offset) void draw_grid(struct gpu_cmd_buffer *cmdbuff, struct rect rect, u32 bg0_srgb, u32 bg1_srgb, u32 line_srgb, u32 x_srgb, u32 y_srgb, f32 thickness, f32 spacing, struct v2 offset)
{ {
struct renderer_cmd_parameters cmd_params = ZI; struct gpu_cmd_parameters cmd_params = ZI;
cmd_params.kind = SHADER_GRID; cmd_params.kind = SHADER_GRID;
renderer_cmd_buffer_ensure_cmd(cmdbuff, &cmd_params); gpu_cmd_buffer_ensure_cmd(cmdbuff, &cmd_params);
struct grid_shader_vertex *vertices = NULL; struct grid_shader_vertex *vertices = NULL;
vidx *indices = NULL; vidx *indices = NULL;
u32 index_offset = renderer_cmd_buffer_push_vertices(cmdbuff, (u8 **)&vertices, &indices, 4, 6); u32 index_offset = gpu_cmd_buffer_push_vertices(cmdbuff, (u8 **)&vertices, &indices, 4, 6);
struct quad quad = quad_from_rect(rect); struct quad quad = quad_from_rect(rect);
@ -334,7 +334,7 @@ void draw_grid(struct renderer_cmd_buffer *cmdbuff, struct rect rect, u32 bg0_sr
* Text * Text
* ========================== */ * ========================== */
void draw_text_ex(struct renderer_cmd_buffer *cmdbuff, struct font *font, struct v2 pos, f32 scale, struct string str) void draw_text_ex(struct gpu_cmd_buffer *cmdbuff, struct font *font, struct v2 pos, f32 scale, struct string str)
{ {
struct v2 draw_pos = pos; struct v2 draw_pos = pos;
draw_pos.y += font->point_size * scale; draw_pos.y += font->point_size * scale;
@ -376,7 +376,7 @@ void draw_text_ex(struct renderer_cmd_buffer *cmdbuff, struct font *font, struct
string_codepoint_iter_end(&iter); string_codepoint_iter_end(&iter);
} }
void draw_text(struct renderer_cmd_buffer *cmdbuff, struct font *font, struct v2 pos, struct string str) void draw_text(struct gpu_cmd_buffer *cmdbuff, struct font *font, struct v2 pos, struct string str)
{ {
draw_text_ex(cmdbuff, font, pos, 1.0, str); draw_text_ex(cmdbuff, font, pos, 1.0, str);
} }

44
src/draw.h
View File

@ -1,11 +1,11 @@
#ifndef DRAW_H #ifndef DRAW_H
#define DRAW_H #define DRAW_H
#include "renderer.h" #include "gpu.h"
struct renderer_cmd_buffer; struct gpu_cmd_buffer;
struct font; struct font;
struct renderer_startup_receipt; struct gpu_startup_receipt;
struct font_startup_receipt; struct font_startup_receipt;
#define DRAW_TEXTURE_PARAMS(...) ((struct draw_texture_params) { \ #define DRAW_TEXTURE_PARAMS(...) ((struct draw_texture_params) { \
@ -15,36 +15,36 @@ struct font_startup_receipt;
}) })
struct draw_texture_params { struct draw_texture_params {
struct renderer_texture texture; /* Overrides sprite if set */ struct gpu_texture texture; /* Overrides sprite if set */
struct sprite_tag sprite; struct sprite_tag sprite;
struct clip_rect clip; struct clip_rect clip;
u32 tint; u32 tint;
}; };
struct draw_startup_receipt { i32 _; }; struct draw_startup_receipt { i32 _; };
struct draw_startup_receipt draw_startup(struct renderer_startup_receipt *renderer_sr, struct draw_startup_receipt draw_startup(struct gpu_startup_receipt *gpu_sr,
struct font_startup_receipt *font_sr); struct font_startup_receipt *font_sr);
void draw_quad_texture_ex(struct renderer_cmd_buffer *cmdbuff, struct renderer_texture texture, struct sprite_tag sprite, struct clip_rect clip, u32 tint0, u32 tint1, struct quad quad); void draw_quad_texture_ex(struct gpu_cmd_buffer *cmdbuff, struct gpu_texture texture, struct sprite_tag sprite, struct clip_rect clip, u32 tint0, u32 tint1, struct quad quad);
void draw_quad_texture(struct renderer_cmd_buffer *cmdbuff, struct draw_texture_params params, struct quad quad); void draw_quad_texture(struct gpu_cmd_buffer *cmdbuff, struct draw_texture_params params, struct quad quad);
void draw_poly(struct renderer_cmd_buffer *cmdbuff, struct v2_array array, u32 srgb); void draw_poly(struct gpu_cmd_buffer *cmdbuff, struct v2_array array, u32 srgb);
void draw_circle(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, f32 radius, u32 srgb, u32 detail); void draw_circle(struct gpu_cmd_buffer *cmdbuff, struct v2 pos, f32 radius, u32 srgb, u32 detail);
void draw_quad(struct renderer_cmd_buffer *cmdbuff, struct quad quad, u32 srgb); void draw_quad(struct gpu_cmd_buffer *cmdbuff, struct quad quad, u32 srgb);
void draw_gradient_line(struct renderer_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, u32 start_srgb, u32 end_srgb); void draw_gradient_line(struct gpu_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, u32 start_srgb, u32 end_srgb);
void draw_line(struct renderer_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, u32 srgb); void draw_line(struct gpu_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, u32 srgb);
void draw_ray(struct renderer_cmd_buffer *cmdbuff, struct v2 start, struct v2 ray, f32 thickness, u32 srgb); void draw_ray(struct gpu_cmd_buffer *cmdbuff, struct v2 start, struct v2 ray, f32 thickness, u32 srgb);
void draw_poly_line(struct renderer_cmd_buffer *cmdbuff, struct v2_array array, b32 loop, f32 thickness, u32 srgb); void draw_poly_line(struct gpu_cmd_buffer *cmdbuff, struct v2_array array, b32 loop, f32 thickness, u32 srgb);
void draw_circle_line(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, f32 radius, f32 thickness, u32 srgb, u32 detail); void draw_circle_line(struct gpu_cmd_buffer *cmdbuff, struct v2 pos, f32 radius, f32 thickness, u32 srgb, u32 detail);
void draw_quad_line(struct renderer_cmd_buffer *cmdbuff, struct quad quad, f32 thickness, u32 srgb); void draw_quad_line(struct gpu_cmd_buffer *cmdbuff, struct quad quad, f32 thickness, u32 srgb);
void draw_arrow_line(struct renderer_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 srgb); void draw_arrow_line(struct gpu_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, f32 thickness, f32 arrowhead_height, u32 srgb);
void draw_arrow_ray(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 srgb); void draw_arrow_ray(struct gpu_cmd_buffer *cmdbuff, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 srgb);
void draw_collider_line(struct renderer_cmd_buffer *cmdbuff, struct xform draw_xf, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 srgb, u32 detail); void draw_collider_line(struct gpu_cmd_buffer *cmdbuff, struct xform draw_xf, struct collider_shape shape, struct xform shape_xf, f32 thickness, u32 srgb, u32 detail);
void draw_grid(struct renderer_cmd_buffer *cmdbuff, struct rect rect, u32 bg0_srgb, u32 bg1_srgb, u32 line_srgb, u32 x_srgb, u32 y_srgb, f32 thickness, f32 spacing, struct v2 offset); void draw_grid(struct gpu_cmd_buffer *cmdbuff, struct rect rect, u32 bg0_srgb, u32 bg1_srgb, u32 line_srgb, u32 x_srgb, u32 y_srgb, f32 thickness, f32 spacing, struct v2 offset);
void draw_text(struct renderer_cmd_buffer *cmdbuff, struct font *font, struct v2 pos, struct string str); void draw_text(struct gpu_cmd_buffer *cmdbuff, struct font *font, struct v2 pos, struct string str);
void draw_text_ex(struct renderer_cmd_buffer *cmdbuff, struct font *font, struct v2 pos, f32 scale, struct string str); void draw_text_ex(struct gpu_cmd_buffer *cmdbuff, struct font *font, struct v2 pos, f32 scale, struct string str);
#endif #endif

8
src/font.c
View File

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

8
src/font.h
View File

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

121
src/gpu.h Normal file
View File

@ -0,0 +1,121 @@
#ifndef GPU_H
#define GPU_H
struct sys_window;
#define GPU_TEXTURE_MAX_WIDTH 16384
#define GPU_TEXTURE_MAX_HEIGHT 16384
typedef u32 vidx;
struct gpu_cmd_buffer;
struct gpu_texture {
u64 handle;
};
/* ========================== *
* Shaders
* ========================== */
enum shader_kind {
SHADER_NONE,
SHADER_TRIANGLE,
SHADER_GRID,
NUM_SHADERS
};
struct gpu_cmd_parameters {
enum shader_kind kind;
union {
struct {
struct gpu_texture texture; /* Overrides sprite if set */
struct sprite_tag sprite;
} texture_params;
};
};
PACK(struct triangle_shader_vertex {
struct v2 pos;
struct v2 uv;
u32 tint_srgb;
});
PACK(struct grid_shader_vertex {
struct v2 pos;
f32 line_thickness;
f32 line_spacing;
struct v2 offset;
u32 bg0_srgb;
u32 bg1_srgb;
u32 line_srgb;
u32 x_srgb;
u32 y_srgb;
});
/* ========================== *
* Startup
* ========================== */
struct gpu_startup_receipt { i32 _; };
struct gpu_startup_receipt gpu_startup(struct sys_window *window);
/* ========================== *
* Texture
* ========================== */
enum gpu_texture_format {
GPU_TEXTURE_FORMAT_NONE,
GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM,
GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB,
NUM_GPU_TEXTURE_FORMATS
};
#define GPU_TEXTURE_FLAG_NONE (0)
#define GPU_TEXTURE_FLAG_TARGET (1<<0)
struct gpu_texture gpu_texture_alloc(enum gpu_texture_format format, u32 flags, struct v2i32 size, void *initial_data);
void gpu_texture_release(struct gpu_texture t);
void gpu_texture_clear(struct gpu_texture target_texture, u32 clear_color);
void gpu_texture_render(struct gpu_texture texture, struct gpu_cmd_buffer *cmdbuff, struct xform view, struct rect viewport);
struct v2i32 gpu_texture_get_size(struct gpu_texture texture);
/* ========================== *
* Backbuffer
* ========================== */
/* Returns a texture linking to the internal backbuffer. Lifetime is managed by gpu layer. */
struct gpu_texture gpu_recreate_backbuffer(struct v2i32 size);
void gpu_present_backbuffer(i32 vsync);
/* ========================== *
* Cmd buffer
* ========================== */
struct gpu_cmd_buffer *gpu_cmd_buffer_alloc(void);
void gpu_cmd_buffer_release(struct gpu_cmd_buffer *cmdbuff);
/* Pushes array of vertices based on `vertices_count` & `indices_count`.
* Sets `vertices_out` and `indices_out` to start of the pushed arrays, to be filled out by the caller.
* Returns the index of the first vertex. Each inserted index should be incremented by this.
*
* NOTE: This should be preceded by an `ensure_cmd` call to ensure that the correct vertex types
* are being pushed.
*/
u32 gpu_cmd_buffer_push_vertices(struct gpu_cmd_buffer *cmdbuff, u8 **vertices_out, vidx **indices_out, u32 vertices_count, u32 indices_count);
/* Checks the currently active draw command. Ensures a new command is created
* if it doesn't match the expected parameters (otherwise the existing command
* can be re-used for batching). */
void gpu_cmd_buffer_ensure_cmd(struct gpu_cmd_buffer *cmdbuff, struct gpu_cmd_parameters *params);
void gpu_cmd_buffer_flush_to_gpu(struct gpu_cmd_buffer *cmdbuff);
#endif

151
src/renderer_d3d11.c → src/gpu_dx11.c
View File

@ -1,4 +1,4 @@
#include "renderer.h" #include "gpu.h"
#include "resource.h" #include "resource.h"
#include "sys.h" #include "sys.h"
#include "memory.h" #include "memory.h"
@ -31,17 +31,17 @@
/* FIXME: Enable this and resolve unreleased references */ /* FIXME: Enable this and resolve unreleased references */
#if RTC #if RTC
# define D3D11_DEBUG 0 # define DX11_DEBUG 0
# define D3D11_SHADER_DEBUG 1 # define DX11_SHADER_DEBUG 1
#else #else
# define D3D11_DEBUG 0 # define DX11_DEBUG 0
# define D3D11_SHADER_DEBUG 0 # define DX11_SHADER_DEBUG 0
#endif #endif
#define D3D11_SWAPCHAIN_FLAGS (DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING) #define DX11_SWAPCHAIN_FLAGS (DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING)
#define D3D11_SWAPCHAIN_FORMAT (DXGI_FORMAT_R8G8B8A8_UNORM) #define DX11_SWAPCHAIN_FORMAT (DXGI_FORMAT_R8G8B8A8_UNORM)
#define D3D11_SWAPCHAIN_RTV_FORMAT (DXGI_FORMAT_R8G8B8A8_UNORM_SRGB) #define DX11_SWAPCHAIN_RTV_FORMAT (DXGI_FORMAT_R8G8B8A8_UNORM_SRGB)
#define SHADER_NAME_LEN 255 #define SHADER_NAME_LEN 255
@ -76,10 +76,10 @@ struct dx11_buffer {
ID3D11Buffer *gpu_index_buffer; ID3D11Buffer *gpu_index_buffer;
}; };
struct renderer_cmd { struct gpu_cmd {
struct dx11_shader *shader; struct dx11_shader *shader;
struct renderer_texture texture; /* Overrides sprite if set */ struct gpu_texture texture; /* Overrides sprite if set */
struct sprite_tag sprite; struct sprite_tag sprite;
/* Associated buffer data */ /* Associated buffer data */
@ -89,16 +89,16 @@ struct renderer_cmd {
u32 index_offset; u32 index_offset;
b32 offsets_set; b32 offsets_set;
struct renderer_cmd *next; struct gpu_cmd *next;
}; };
struct cmd_store { struct cmd_store {
struct renderer_cmd *cmd_first; struct gpu_cmd *cmd_first;
struct renderer_cmd *cmd_last; struct gpu_cmd *cmd_last;
struct arena arena; struct arena arena;
}; };
struct renderer_cmd_buffer { struct gpu_cmd_buffer {
struct dx11_buffer buffers[NUM_SHADERS]; struct dx11_buffer buffers[NUM_SHADERS];
struct cmd_store cpu_cmd_store; struct cmd_store cpu_cmd_store;
@ -121,7 +121,7 @@ struct dx11_texture {
struct dx11_texture *next_free; struct dx11_texture *next_free;
}; };
INTERNAL void renderer_capture_image_for_profiler(void); INTERNAL void gpu_capture_image_for_profiler(void);
/* ========================== * /* ========================== *
* Global state * Global state
@ -161,7 +161,7 @@ GLOBAL struct {
struct arena arena; struct arena arena;
#if PROFILING #if PROFILING
struct __prof_d3d11_ctx *profiling_ctx; struct __prof_dx11_ctx *profiling_ctx;
#endif #endif
ID3D11Device *dev; ID3D11Device *dev;
@ -185,18 +185,18 @@ GLOBAL struct {
struct dx11_texture *textures_first_free; struct dx11_texture *textures_first_free;
/* Sparse array (cmdbuff.valid) */ /* Sparse array (cmdbuff.valid) */
struct renderer_cmd_buffer cmdbuffs[MAX_CMD_BUFFERS]; struct gpu_cmd_buffer cmdbuffs[MAX_CMD_BUFFERS];
struct dx11_shader shaders[NUM_SHADERS]; struct dx11_shader shaders[NUM_SHADERS];
struct dx11_shader_desc shader_info[NUM_SHADERS]; struct dx11_shader_desc shader_info[NUM_SHADERS];
} G = ZI, DEBUG_ALIAS(G, G_renderer_d3d11); } G = ZI, DEBUG_ALIAS(G, G_gpu_dx11);
/* ========================== * /* ========================== *
* Util * Util
* ========================== */ * ========================== */
/* Calculate the view projection matrix */ /* Calculate the view projection matrix */
INLINE struct mat4x4 calculate_vp(struct xform view, f32 viewport_width, f32 viewport_height) INLINE struct mat4x4 calculate_vp(struct xform view, f32 viewport_width, f32 viewport_height)
{ {
struct mat4x4 projection = mat4x4_from_ortho(0.0, viewport_width, viewport_height, 0.0, -1.0, 1.0); struct mat4x4 projection = mat4x4_from_ortho(0.0, viewport_width, viewport_height, 0.0, -1.0, 1.0);
@ -227,9 +227,9 @@ INTERNAL void reload_shader(struct dx11_shader *shader, struct dx11_shader_desc
INTERNAL RESOURCE_WATCH_CALLBACK_FUNC_DEF(shader_resource_watch_callback, name); INTERNAL RESOURCE_WATCH_CALLBACK_FUNC_DEF(shader_resource_watch_callback, name);
#endif #endif
struct renderer_startup_receipt renderer_startup(struct sys_window *window) struct gpu_startup_receipt gpu_startup(struct sys_window *window)
{ {
__profscope(initializing_d3d11); __prof;
G.arena = arena_alloc(GIGABYTE(64)); G.arena = arena_alloc(GIGABYTE(64));
@ -247,7 +247,7 @@ struct renderer_startup_receipt renderer_startup(struct sys_window *window)
/* Create D3D11 device & context */ /* Create D3D11 device & context */
{ {
#if D3D11_DEBUG #if DX11_DEBUG
u32 flags = D3D11_CREATE_DEVICE_DEBUG; u32 flags = D3D11_CREATE_DEVICE_DEBUG;
#else #else
u32 flags = 0; u32 flags = 0;
@ -268,7 +268,7 @@ struct renderer_startup_receipt renderer_startup(struct sys_window *window)
ASSERT(SUCCEEDED(hr)); ASSERT(SUCCEEDED(hr));
} }
#if D3D11_DEBUG #if DX11_DEBUG
/* D3D11 Debug break */ /* D3D11 Debug break */
{ {
ID3D11InfoQueue *info; ID3D11InfoQueue *info;
@ -309,12 +309,12 @@ struct renderer_startup_receipt renderer_startup(struct sys_window *window)
ASSERT(SUCCEEDED(hr)); ASSERT(SUCCEEDED(hr));
DXGI_SWAP_CHAIN_DESC1 desc = { DXGI_SWAP_CHAIN_DESC1 desc = {
.Format = D3D11_SWAPCHAIN_FORMAT, .Format = DX11_SWAPCHAIN_FORMAT,
.SampleDesc = { 1, 0 }, .SampleDesc = { 1, 0 },
.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT, .BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT,
.BufferCount = 2, .BufferCount = 2,
.Scaling = DXGI_SCALING_NONE, .Scaling = DXGI_SCALING_NONE,
.Flags = D3D11_SWAPCHAIN_FLAGS, .Flags = DX11_SWAPCHAIN_FLAGS,
.AlphaMode = DXGI_ALPHA_MODE_IGNORE, .AlphaMode = DXGI_ALPHA_MODE_IGNORE,
.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD, .SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD,
}; };
@ -331,9 +331,9 @@ struct renderer_startup_receipt renderer_startup(struct sys_window *window)
} }
if (!SUCCEEDED(hr) || !device || !context || !swapchain) { if (!SUCCEEDED(hr) || !device || !context || !swapchain) {
/* Renderer initialization failure */ /* Gpu initialization failure */
/* TODO: Better message */ /* TODO: Better message */
sys_panic(LIT("Failed to initialize renderer")); sys_panic(LIT("Failed to initialize DirectX 11"));
} }
G.dev = device; G.dev = device;
G.devcon = context; G.devcon = context;
@ -342,7 +342,7 @@ struct renderer_startup_receipt renderer_startup(struct sys_window *window)
struct string prof_ctx_name = LIT("D3d11 Context"); struct string prof_ctx_name = LIT("D3d11 Context");
(UNUSED)prof_ctx_name; (UNUSED)prof_ctx_name;
__prof_d3d11_ctx_alloc(G.profiling_ctx, G.dev, G.devcon, prof_ctx_name.text, prof_ctx_name.len); __prof_dx11_ctx_alloc(G.profiling_ctx, G.dev, G.devcon, prof_ctx_name.text, prof_ctx_name.len);
/* Create the blending setup */ /* Create the blending setup */
{ {
@ -447,7 +447,7 @@ struct renderer_startup_receipt renderer_startup(struct sys_window *window)
resource_register_watch_callback(shader_resource_watch_callback); resource_register_watch_callback(shader_resource_watch_callback);
#endif #endif
return (struct renderer_startup_receipt) { 0 }; return (struct gpu_startup_receipt) { 0 };
} }
/* ========================== * /* ========================== *
@ -505,6 +505,7 @@ INTERNAL void init_shader_table(void)
#if RESOURCE_RELOADING #if RESOURCE_RELOADING
INTERNAL void shader_add_include(struct dx11_shader_desc *desc, struct string include_name_src) INTERNAL void shader_add_include(struct dx11_shader_desc *desc, struct string include_name_src)
{ {
__prof;
u64 hash = hash_fnv64(HASH_FNV64_BASIS, include_name_src); u64 hash = hash_fnv64(HASH_FNV64_BASIS, include_name_src);
struct dict *dict = &desc->includes_dict; struct dict *dict = &desc->includes_dict;
struct sys_lock lock = sys_mutex_lock_e(&desc->includes_mutex); struct sys_lock lock = sys_mutex_lock_e(&desc->includes_mutex);
@ -516,6 +517,7 @@ INTERNAL void shader_add_include(struct dx11_shader_desc *desc, struct string in
INTERNAL void shader_reset_includes(struct dx11_shader_desc *desc) INTERNAL void shader_reset_includes(struct dx11_shader_desc *desc)
{ {
__prof;
struct dict *dict = &desc->includes_dict; struct dict *dict = &desc->includes_dict;
struct sys_lock lock = sys_mutex_lock_e(&desc->includes_mutex); struct sys_lock lock = sys_mutex_lock_e(&desc->includes_mutex);
{ {
@ -526,6 +528,7 @@ INTERNAL void shader_reset_includes(struct dx11_shader_desc *desc)
INTERNAL b32 shader_set_dirty(struct string name) INTERNAL b32 shader_set_dirty(struct string name)
{ {
__prof;
b32 caused_dirty = false; b32 caused_dirty = false;
for (u64 i = 0; i < NUM_SHADERS; ++i) { for (u64 i = 0; i < NUM_SHADERS; ++i) {
struct dx11_shader_desc *desc = &G.shader_info[i]; struct dx11_shader_desc *desc = &G.shader_info[i];
@ -639,10 +642,10 @@ INTERNAL struct string shader_alloc(struct arena *arena, struct dx11_shader *sha
struct string res_name = resource_get_name(src_res); struct string res_name = resource_get_name(src_res);
if (res_name.len > SHADER_NAME_LEN) { if (res_name.len > SHADER_NAME_LEN) {
sys_panic(string_format(scratch.arena, sys_panic(string_format(scratch.arena,
LIT("Shader name \"%F\" too long (%F > %F)"), LIT("Shader name \"%F\" too long (%F > %F)"),
FMT_STR(res_name), FMT_STR(res_name),
FMT_UINT(res_name.len), FMT_UINT(res_name.len),
FMT_UINT(SHADER_NAME_LEN))); FMT_UINT(SHADER_NAME_LEN)));
} }
MEMCPY(shader->name_text, res_name.text, res_name.len); MEMCPY(shader->name_text, res_name.text, res_name.len);
@ -656,7 +659,7 @@ INTERNAL struct string shader_alloc(struct arena *arena, struct dx11_shader *sha
struct dx11_include_handler include_handler = dx11_include_handler_alloc(shader); struct dx11_include_handler include_handler = dx11_include_handler_alloc(shader);
u32 flags = D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR; u32 flags = D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR;
#if D3D11_SHADER_DEBUG #if DX11_SHADER_DEBUG
flags |= D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION | D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_WARNINGS_ARE_ERRORS; flags |= D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION | D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_WARNINGS_ARE_ERRORS;
#else #else
flags |= D3DCOMPILE_OPTIMIZATION_LEVEL3; flags |= D3DCOMPILE_OPTIMIZATION_LEVEL3;
@ -804,10 +807,10 @@ INTERNAL RESOURCE_WATCH_CALLBACK_FUNC_DEF(shader_resource_watch_callback, name)
* Another option is to store a separate device on each cmdbuff? * Another option is to store a separate device on each cmdbuff?
* *
* I'm thinking we may also just need to lock texture modification access while presenting */ * I'm thinking we may also just need to lock texture modification access while presenting */
INTERNAL void dx11_render(ID3D11RenderTargetView *target, struct renderer_cmd_buffer *cmdbuff, struct xform view, struct rect viewport) INTERNAL void dx11_render(ID3D11RenderTargetView *target, struct gpu_cmd_buffer *cmdbuff, struct xform view, struct rect viewport)
{ {
__prof; __prof;
__profscope_d3d11(G.profiling_ctx, Render); __profscope_dx11(G.profiling_ctx, Render, RGB_F(0.5, 0.2, 0.2));
struct sprite_scope *sprite_scope = sprite_scope_begin(); struct sprite_scope *sprite_scope = sprite_scope_begin();
ID3D11DeviceContext_OMSetRenderTargets(G.devcon, 1, &target, NULL); ID3D11DeviceContext_OMSetRenderTargets(G.devcon, 1, &target, NULL);
@ -831,7 +834,7 @@ INTERNAL void dx11_render(ID3D11RenderTargetView *target, struct renderer_cmd_bu
struct dx11_shader *prev_shader = NULL; struct dx11_shader *prev_shader = NULL;
struct renderer_cmd *cmd = cmdbuff ? cmdbuff->gpu_cmd_store.cmd_first : NULL; struct gpu_cmd *cmd = cmdbuff ? cmdbuff->gpu_cmd_store.cmd_first : NULL;
for (; cmd; cmd = cmd->next) { for (; cmd; cmd = cmd->next) {
struct dx11_shader *shader = cmd->shader; struct dx11_shader *shader = cmd->shader;
struct dx11_buffer *buffer = &cmdbuff->buffers[shader->kind]; struct dx11_buffer *buffer = &cmdbuff->buffers[shader->kind];
@ -855,7 +858,7 @@ INTERNAL void dx11_render(ID3D11RenderTargetView *target, struct renderer_cmd_bu
case SHADER_TRIANGLE: case SHADER_TRIANGLE:
{ {
__profscope_d3d11(G.profiling_ctx, Triangle Shader); __profscope_dx11(G.profiling_ctx, Triangle Shader, RGB_F(0.2, 0.2, 0.5));
/* FIXME: Texture refcount needs to be increased here to prevent release mid-render */ /* FIXME: Texture refcount needs to be increased here to prevent release mid-render */
ID3D11Texture2D *texture = NULL; ID3D11Texture2D *texture = NULL;
if (cmd->texture.handle) { if (cmd->texture.handle) {
@ -905,7 +908,7 @@ INTERNAL void dx11_render(ID3D11RenderTargetView *target, struct renderer_cmd_bu
case SHADER_GRID: case SHADER_GRID:
{ {
__profscope_d3d11(G.profiling_ctx, Grid Shader); __profscope_dx11(G.profiling_ctx, Grid Shader, RGB_F(0.2, 0.5, 0.2));
ID3D11DeviceContext_IASetPrimitiveTopology(G.devcon, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); ID3D11DeviceContext_IASetPrimitiveTopology(G.devcon, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
/* Activate buffer */ /* Activate buffer */
@ -930,14 +933,14 @@ INTERNAL void dx11_render(ID3D11RenderTargetView *target, struct renderer_cmd_bu
* Texture * Texture
* ========================== */ * ========================== */
INTERNAL struct dx11_format dx11_format_from_renderer_format(enum renderer_texture_format format) INTERNAL struct dx11_format dx11_format_from_gpu_format(enum gpu_texture_format format)
{ {
LOCAL_PERSIST const struct dx11_format sizes[NUM_RENDERER_TEXTURE_FORMATS] = { LOCAL_PERSIST const struct dx11_format sizes[NUM_GPU_TEXTURE_FORMATS] = {
[RENDERER_TEXTURE_FORMAT_R8G8B8A8_UNORM] = { [GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM] = {
.format = DXGI_FORMAT_R8G8B8A8_UNORM, .format = DXGI_FORMAT_R8G8B8A8_UNORM,
.pixel_size = 4 .pixel_size = 4
}, },
[RENDERER_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB] = { [GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB] = {
.format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, .format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
.pixel_size = 4 .pixel_size = 4
} }
@ -949,7 +952,7 @@ INTERNAL struct dx11_format dx11_format_from_renderer_format(enum renderer_textu
return res; return res;
} }
INTERNAL struct dx11_texture *dx11_texture_alloc(enum renderer_texture_format format, u32 flags, struct v2i32 size, void *initial_data) INTERNAL struct dx11_texture *dx11_texture_alloc(enum gpu_texture_format format, u32 flags, struct v2i32 size, void *initial_data)
{ {
struct dx11_texture *t = NULL; struct dx11_texture *t = NULL;
{ {
@ -971,7 +974,7 @@ INTERNAL struct dx11_texture *dx11_texture_alloc(enum renderer_texture_format fo
G.textures_last = t; G.textures_last = t;
sys_mutex_unlock(&lock); sys_mutex_unlock(&lock);
} }
struct dx11_format dx11_format = dx11_format_from_renderer_format(format); struct dx11_format dx11_format = dx11_format_from_gpu_format(format);
if (dx11_format.format == DXGI_FORMAT_UNKNOWN) { if (dx11_format.format == DXGI_FORMAT_UNKNOWN) {
/* Unknown format */ /* Unknown format */
ASSERT(false); ASSERT(false);
@ -979,7 +982,7 @@ INTERNAL struct dx11_texture *dx11_texture_alloc(enum renderer_texture_format fo
} }
u32 bind_flags = D3D11_BIND_SHADER_RESOURCE; u32 bind_flags = D3D11_BIND_SHADER_RESOURCE;
if (flags & RENDERER_TEXTURE_FLAG_TARGET) { if (flags & GPU_TEXTURE_FLAG_TARGET) {
bind_flags |= D3D11_BIND_RENDER_TARGET; bind_flags |= D3D11_BIND_RENDER_TARGET;
} }
@ -1037,22 +1040,22 @@ INTERNAL void dx11_texture_release(struct dx11_texture *t)
} }
} }
struct renderer_texture renderer_texture_alloc(enum renderer_texture_format format, u32 flags, struct v2i32 size, void *initial_data) struct gpu_texture gpu_texture_alloc(enum gpu_texture_format format, u32 flags, struct v2i32 size, void *initial_data)
{ {
__prof; __prof;
struct renderer_texture res = ZI; struct gpu_texture res = ZI;
struct dx11_texture *t = dx11_texture_alloc(format, flags, size, initial_data); struct dx11_texture *t = dx11_texture_alloc(format, flags, size, initial_data);
res.handle = (u64)t; res.handle = (u64)t;
return res; return res;
} }
void renderer_texture_release(struct renderer_texture t) void gpu_texture_release(struct gpu_texture t)
{ {
__prof; __prof;
dx11_texture_release((struct dx11_texture *)t.handle); dx11_texture_release((struct dx11_texture *)t.handle);
} }
void renderer_texture_clear(struct renderer_texture target_texture, u32 clear_color) void gpu_texture_clear(struct gpu_texture target_texture, u32 clear_color)
{ {
__prof; __prof;
@ -1074,7 +1077,7 @@ void renderer_texture_clear(struct renderer_texture target_texture, u32 clear_co
} }
} }
void renderer_texture_render(struct renderer_texture texture, struct renderer_cmd_buffer *cmdbuff, struct xform view, struct rect viewport) void gpu_texture_render(struct gpu_texture texture, struct gpu_cmd_buffer *cmdbuff, struct xform view, struct rect viewport)
{ {
__prof; __prof;
@ -1083,7 +1086,7 @@ void renderer_texture_render(struct renderer_texture texture, struct renderer_cm
D3D11_RENDER_TARGET_VIEW_DESC rtv_desc = ZI; D3D11_RENDER_TARGET_VIEW_DESC rtv_desc = ZI;
D3D11_RENDER_TARGET_VIEW_DESC *rtv_desc_param = NULL; D3D11_RENDER_TARGET_VIEW_DESC *rtv_desc_param = NULL;
if (t->is_backbuffer) { if (t->is_backbuffer) {
rtv_desc.Format = D3D11_SWAPCHAIN_RTV_FORMAT; rtv_desc.Format = DX11_SWAPCHAIN_RTV_FORMAT;
rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
rtv_desc_param = &rtv_desc; rtv_desc_param = &rtv_desc;
} }
@ -1099,7 +1102,7 @@ void renderer_texture_render(struct renderer_texture texture, struct renderer_cm
} }
} }
struct v2i32 renderer_texture_get_size(struct renderer_texture texture) struct v2i32 gpu_texture_get_size(struct gpu_texture texture)
{ {
struct v2i32 res = ZI; struct v2i32 res = ZI;
D3D11_TEXTURE2D_DESC desc; D3D11_TEXTURE2D_DESC desc;
@ -1149,22 +1152,22 @@ INTERNAL struct DXGI_QUERY_VIDEO_MEMORY_INFO get_memory_info(void)
} }
#endif #endif
struct renderer_texture renderer_backbuffer_recreate(struct v2i32 size) struct gpu_texture gpu_recreate_backbuffer(struct v2i32 size)
{ {
struct renderer_texture res = ZI; struct gpu_texture res = ZI;
/* Resize */ /* Resize */
if (G.backbuffer_texture.texture != 0) { if (G.backbuffer_texture.texture != 0) {
ID3D11Texture2D_Release(G.backbuffer_texture.texture); ID3D11Texture2D_Release(G.backbuffer_texture.texture);
} }
IDXGISwapChain_ResizeBuffers(G.swapchain, 0, size.x, size.y, DXGI_FORMAT_UNKNOWN, D3D11_SWAPCHAIN_FLAGS); IDXGISwapChain_ResizeBuffers(G.swapchain, 0, size.x, size.y, DXGI_FORMAT_UNKNOWN, DX11_SWAPCHAIN_FLAGS);
IDXGISwapChain_GetBuffer(G.swapchain, 0, &IID_ID3D11Texture2D, (LPVOID *)&G.backbuffer_texture.texture); IDXGISwapChain_GetBuffer(G.swapchain, 0, &IID_ID3D11Texture2D, (LPVOID *)&G.backbuffer_texture.texture);
res.handle = (u64)&G.backbuffer_texture; res.handle = (u64)&G.backbuffer_texture;
return res; return res;
} }
void renderer_backbuffer_present(i32 vsync) void gpu_present_backbuffer(i32 vsync)
{ {
__prof; __prof;
#if RESOURCE_RELOADING #if RESOURCE_RELOADING
@ -1203,11 +1206,11 @@ void renderer_backbuffer_present(i32 vsync)
flags = DXGI_PRESENT_ALLOW_TEARING; flags = DXGI_PRESENT_ALLOW_TEARING;
} }
renderer_capture_image_for_profiler(); gpu_capture_image_for_profiler();
{ {
__profscope(IDXGISwapchain_Present); __profscope(IDXGISwapchain_Present);
IDXGISwapChain1_Present(G.swapchain, vsync, flags); IDXGISwapChain1_Present(G.swapchain, vsync, flags);
__prof_d3d11_collect(G.profiling_ctx); __prof_dx11_collect(G.profiling_ctx);
__profframe(0); __profframe(0);
} }
} }
@ -1216,9 +1219,9 @@ void renderer_backbuffer_present(i32 vsync)
* Cmd buffer * Cmd buffer
* ========================== */ * ========================== */
struct renderer_cmd_buffer *renderer_cmd_buffer_alloc(void) struct gpu_cmd_buffer *gpu_cmd_buffer_alloc(void)
{ {
struct renderer_cmd_buffer *cmdbuff = NULL; struct gpu_cmd_buffer *cmdbuff = NULL;
for (u32 i = 0; i < MAX_CMD_BUFFERS; ++i) { for (u32 i = 0; i < MAX_CMD_BUFFERS; ++i) {
if (!G.cmdbuffs[i].valid) { if (!G.cmdbuffs[i].valid) {
cmdbuff = &G.cmdbuffs[i]; cmdbuff = &G.cmdbuffs[i];
@ -1227,7 +1230,7 @@ struct renderer_cmd_buffer *renderer_cmd_buffer_alloc(void)
} }
if (!cmdbuff) { if (!cmdbuff) {
sys_panic(LIT("Max renderer cmdbuffs reached")); sys_panic(LIT("Max gpu cmdbuffs reached"));
return NULL; return NULL;
} }
@ -1248,7 +1251,7 @@ struct renderer_cmd_buffer *renderer_cmd_buffer_alloc(void)
return cmdbuff; return cmdbuff;
} }
void renderer_cmd_buffer_release(struct renderer_cmd_buffer *cmdbuff) void gpu_cmd_buffer_release(struct gpu_cmd_buffer *cmdbuff)
{ {
cmdbuff->valid = false; cmdbuff->valid = false;
arena_release(&cmdbuff->cpu_cmd_store.arena); arena_release(&cmdbuff->cpu_cmd_store.arena);
@ -1264,9 +1267,9 @@ void renderer_cmd_buffer_release(struct renderer_cmd_buffer *cmdbuff)
} }
} }
u32 renderer_cmd_buffer_push_vertices(struct renderer_cmd_buffer *cmdbuff, u8 **vertices_out, vidx **indices_out, u32 vertices_count, u32 indices_count) u32 gpu_cmd_buffer_push_vertices(struct gpu_cmd_buffer *cmdbuff, u8 **vertices_out, vidx **indices_out, u32 vertices_count, u32 indices_count)
{ {
struct renderer_cmd *cmd = cmdbuff->cpu_cmd_store.cmd_last; struct gpu_cmd *cmd = cmdbuff->cpu_cmd_store.cmd_last;
if (!cmd) { if (!cmd) {
/* Tried to draw to cmdbuff with no active draw cmd */ /* Tried to draw to cmdbuff with no active draw cmd */
@ -1295,11 +1298,11 @@ u32 renderer_cmd_buffer_push_vertices(struct renderer_cmd_buffer *cmdbuff, u8 **
return first_vertex_index; return first_vertex_index;
} }
void renderer_cmd_buffer_ensure_cmd(struct renderer_cmd_buffer *cmdbuff, struct renderer_cmd_parameters *params) void gpu_cmd_buffer_ensure_cmd(struct gpu_cmd_buffer *cmdbuff, struct gpu_cmd_parameters *params)
{ {
struct renderer_cmd *last_cmd = cmdbuff->cpu_cmd_store.cmd_last; struct gpu_cmd *last_cmd = cmdbuff->cpu_cmd_store.cmd_last;
struct renderer_cmd *new_cmd = NULL; struct gpu_cmd *new_cmd = NULL;
switch (params->kind) { switch (params->kind) {
default: default:
{ {
@ -1313,7 +1316,7 @@ void renderer_cmd_buffer_ensure_cmd(struct renderer_cmd_buffer *cmdbuff, struct
|| last_cmd->shader->kind != SHADER_TRIANGLE || last_cmd->shader->kind != SHADER_TRIANGLE
|| (last_cmd->texture.handle != params->texture_params.texture.handle) || (last_cmd->texture.handle != params->texture_params.texture.handle)
|| !sprite_tag_eq(last_cmd->sprite, params->texture_params.sprite)) { || !sprite_tag_eq(last_cmd->sprite, params->texture_params.sprite)) {
new_cmd = arena_push(&cmdbuff->cpu_cmd_store.arena, struct renderer_cmd); new_cmd = arena_push(&cmdbuff->cpu_cmd_store.arena, struct gpu_cmd);
new_cmd->shader = &G.shaders[SHADER_TRIANGLE]; new_cmd->shader = &G.shaders[SHADER_TRIANGLE];
new_cmd->texture = params->texture_params.texture; new_cmd->texture = params->texture_params.texture;
new_cmd->sprite = params->texture_params.sprite; new_cmd->sprite = params->texture_params.sprite;
@ -1323,7 +1326,7 @@ void renderer_cmd_buffer_ensure_cmd(struct renderer_cmd_buffer *cmdbuff, struct
case SHADER_GRID: case SHADER_GRID:
{ {
if (!last_cmd || last_cmd->shader->kind != SHADER_GRID) { if (!last_cmd || last_cmd->shader->kind != SHADER_GRID) {
new_cmd = arena_push(&cmdbuff->cpu_cmd_store.arena, struct renderer_cmd); new_cmd = arena_push(&cmdbuff->cpu_cmd_store.arena, struct gpu_cmd);
new_cmd->shader = &G.shaders[SHADER_GRID]; new_cmd->shader = &G.shaders[SHADER_GRID];
} }
} break; } break;
@ -1339,7 +1342,7 @@ void renderer_cmd_buffer_ensure_cmd(struct renderer_cmd_buffer *cmdbuff, struct
} }
} }
void renderer_cmd_buffer_send_to_gpu(struct renderer_cmd_buffer *cmdbuff) void gpu_cmd_buffer_flush_to_gpu(struct gpu_cmd_buffer *cmdbuff)
{ {
__prof; __prof;
@ -1424,7 +1427,7 @@ void renderer_cmd_buffer_send_to_gpu(struct renderer_cmd_buffer *cmdbuff)
* Profiling frame capture * Profiling frame capture
* ========================== */ * ========================== */
/* FIXME: enable this */ /* FIXME: enable this */
#if PROFILING && PROFILING_CAPTURE_FRAME_IMAGE #if PROFILING && PROFILING_CAPTURE_FRAME_IMAGE
#define CAP_WIDTH 320 #define CAP_WIDTH 320
@ -1435,7 +1438,7 @@ struct prof_cap {
struct v2 size; struct v2 size;
}; };
INTERNAL void renderer_capture_image_for_profiler(void) INTERNAL void gpu_capture_image_for_profiler(void)
{ {
__prof; __prof;
@ -1512,7 +1515,7 @@ INTERNAL void renderer_capture_image_for_profiler(void)
} }
#else #else
INTERNAL void renderer_capture_image_for_profiler(void) INTERNAL void gpu_capture_image_for_profiler(void)
{ {
} }

121
src/renderer.h
View File

@ -1,121 +0,0 @@
#ifndef RENDERER_H
#define RENDERER_H
struct sys_window;
#define RENDERER_TEXTURE_MAX_WIDTH 16384
#define RENDERER_TEXTURE_MAX_HEIGHT 16384
typedef u32 vidx;
struct renderer_cmd_buffer;
struct renderer_texture {
u64 handle;
};
/* ========================== *
* Shaders
* ========================== */
enum shader_kind {
SHADER_NONE,
SHADER_TRIANGLE,
SHADER_GRID,
NUM_SHADERS
};
struct renderer_cmd_parameters {
enum shader_kind kind;
union {
struct {
struct renderer_texture texture; /* Overrides sprite if set */
struct sprite_tag sprite;
} texture_params;
};
};
PACK(struct triangle_shader_vertex {
struct v2 pos;
struct v2 uv;
u32 tint_srgb;
});
PACK(struct grid_shader_vertex {
struct v2 pos;
f32 line_thickness;
f32 line_spacing;
struct v2 offset;
u32 bg0_srgb;
u32 bg1_srgb;
u32 line_srgb;
u32 x_srgb;
u32 y_srgb;
});
/* ========================== *
* Startup
* ========================== */
struct renderer_startup_receipt { i32 _; };
struct renderer_startup_receipt renderer_startup(struct sys_window *window);
/* ========================== *
* Texture
* ========================== */
enum renderer_texture_format {
RENDERER_TEXTURE_FORMAT_NONE,
RENDERER_TEXTURE_FORMAT_R8G8B8A8_UNORM,
RENDERER_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB,
NUM_RENDERER_TEXTURE_FORMATS
};
#define RENDERER_TEXTURE_FLAG_NONE (0)
#define RENDERER_TEXTURE_FLAG_TARGET (1<<0)
struct renderer_texture renderer_texture_alloc(enum renderer_texture_format format, u32 flags, struct v2i32 size, void *initial_data);
void renderer_texture_release(struct renderer_texture t);
void renderer_texture_clear(struct renderer_texture target_texture, u32 clear_color);
void renderer_texture_render(struct renderer_texture texture, struct renderer_cmd_buffer *cmdbuff, struct xform view, struct rect viewport);
struct v2i32 renderer_texture_get_size(struct renderer_texture texture);
/* ========================== *
* Backbuffer
* ========================== */
/* Returns a texture linking to the internal backbuffer. Lifetime is managed by renderer. */
struct renderer_texture renderer_backbuffer_recreate(struct v2i32 size);
void renderer_backbuffer_present(i32 vsync);
/* ========================== *
* Cmd buffer
* ========================== */
struct renderer_cmd_buffer *renderer_cmd_buffer_alloc(void);
void renderer_cmd_buffer_release(struct renderer_cmd_buffer *cmdbuff);
/* Pushes array of vertices based on `vertices_count` & `indices_count`.
* Sets `vertices_out` and `indices_out` to start of the pushed arrays, to be filled out by the caller.
* Returns the index of the first vertex. Each inserted index should be incremented by this.
*
* NOTE: This should be preceded by an `ensure_cmd` call to ensure that the correct vertex types
* are being pushed.
*/
u32 renderer_cmd_buffer_push_vertices(struct renderer_cmd_buffer *cmdbuff, u8 **vertices_out, vidx **indices_out, u32 vertices_count, u32 indices_count);
/* Checks the currently active draw command. Ensures a new command is created
* if it doesn't match the expected parameters (otherwise the existing command
* can be re-used for batching). */
void renderer_cmd_buffer_ensure_cmd(struct renderer_cmd_buffer *cmdbuff, struct renderer_cmd_parameters *params);
void renderer_cmd_buffer_send_to_gpu(struct renderer_cmd_buffer *cmdbuff);
#endif

18
src/sprite.c
View File

@ -9,7 +9,7 @@
#include "work.h" #include "work.h"
#include "atomic.h" #include "atomic.h"
#include "app.h" #include "app.h"
#include "renderer.h" #include "gpu.h"
#include "math.h" #include "math.h"
#include "rand.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); INTERNAL RESOURCE_WATCH_CALLBACK_FUNC_DEF(sprite_resource_watch_callback, info);
#endif #endif
struct sprite_startup_receipt sprite_startup(struct renderer_startup_receipt *renderer_sr, struct sprite_startup_receipt sprite_startup(struct gpu_startup_receipt *gpu_sr,
struct resource_startup_receipt *resource_sr) struct resource_startup_receipt *resource_sr)
{ {
(UNUSED)renderer_sr; (UNUSED)gpu_sr;
(UNUSED)resource_sr; (UNUSED)resource_sr;
G.perm_arena = arena_alloc(MEGABYTE(1)); G.perm_arena = arena_alloc(MEGABYTE(1));
@ -227,7 +227,7 @@ struct sprite_startup_receipt sprite_startup(struct renderer_startup_receipt *re
{ {
struct temp_arena scratch = scratch_begin_no_conflict(); struct temp_arena scratch = scratch_begin_no_conflict();
struct image_rgba purple_black_image = generate_purple_black_image(scratch.arena, 64, 64); struct image_rgba purple_black_image = generate_purple_black_image(scratch.arena, 64, 64);
G.nil_texture->texture = renderer_texture_alloc(RENDERER_TEXTURE_FORMAT_R8G8B8A8_UNORM, 0, V2I32(purple_black_image.width, purple_black_image.height), purple_black_image.pixels); 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);
scratch_end(scratch); scratch_end(scratch);
} }
@ -368,19 +368,19 @@ INTERNAL void cache_entry_load_texture(struct cache_ref ref, struct sprite_tag t
decoded = ase_decode_image(scratch.arena, resource_get_data(&texture_rs)); decoded = ase_decode_image(scratch.arena, resource_get_data(&texture_rs));
resource_close(&texture_rs); resource_close(&texture_rs);
enum renderer_texture_format format = RENDERER_TEXTURE_FORMAT_R8G8B8A8_UNORM; enum gpu_texture_format format = GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM;
if (decoded.srgb) { if (decoded.srgb) {
format = RENDERER_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB; format = GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB;
} }
/* Initialize */ /* Initialize */
e->texture = arena_push(&e->arena, struct sprite_texture); e->texture = arena_push(&e->arena, struct sprite_texture);
e->texture->width = decoded.image.width; e->texture->width = decoded.image.width;
e->texture->height = decoded.image.height; e->texture->height = decoded.image.height;
e->texture->texture = renderer_texture_alloc(format, 0, V2I32(decoded.image.width, decoded.image.height), decoded.image.pixels); e->texture->texture = gpu_texture_alloc(format, 0, V2I32(decoded.image.width, decoded.image.height), decoded.image.pixels);
e->texture->valid = true; e->texture->valid = true;
e->texture->loaded = true; e->texture->loaded = true;
/* TODO: Query renderer for more accurate texture size in VRAM */ /* TODO: Query gpu for more accurate texture size in VRAM */
memory_size += (decoded.image.width * decoded.image.height) * sizeof(*decoded.image.pixels); memory_size += (decoded.image.width * decoded.image.height) * sizeof(*decoded.image.pixels);
} else { } else {
logf_error("Sprite [%F] \"%F\" not found", FMT_HEX(e->hash.v), FMT_STR(path)); logf_error("Sprite [%F] \"%F\" not found", FMT_HEX(e->hash.v), FMT_STR(path));
@ -1331,7 +1331,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) { for (struct evict_node *en = first_evicted; en; en = en->next_evicted) {
struct cache_entry *n = en->cache_entry; struct cache_entry *n = en->cache_entry;
if (n->kind == CACHE_ENTRY_KIND_TEXTURE && n->texture->valid) { if (n->kind == CACHE_ENTRY_KIND_TEXTURE && n->texture->valid) {
renderer_texture_release(n->texture->texture); gpu_texture_release(n->texture->texture);
} }
arena_release(&n->arena); arena_release(&n->arena);
} }

8
src/sprite.h
View File

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

78
src/user.c
View File

@ -2,7 +2,7 @@
#include "sim.h" #include "sim.h"
#include "sim_ent.h" #include "sim_ent.h"
#include "sim_step.h" #include "sim_step.h"
#include "renderer.h" #include "gpu.h"
#include "font.h" #include "font.h"
#include "sprite.h" #include "sprite.h"
#include "draw.h" #include "draw.h"
@ -60,15 +60,15 @@ GLOBAL struct {
struct second_stat net_bytes_sent; struct second_stat net_bytes_sent;
/* Render targets */ /* Render targets */
struct renderer_texture final_texture; struct gpu_texture final_texture;
struct renderer_texture world_texture; struct gpu_texture world_texture;
struct renderer_texture ui_texture; struct gpu_texture ui_texture;
struct renderer_texture backbuffer_texture; struct gpu_texture backbuffer_texture;
struct renderer_cmd_buffer *world_cmd_buffer; struct gpu_cmd_buffer *world_cmd_buffer;
struct renderer_cmd_buffer *ui_cmd_buffer; struct gpu_cmd_buffer *ui_cmd_buffer;
struct renderer_cmd_buffer *final_cmd_buffer; struct gpu_cmd_buffer *final_cmd_buffer;
struct renderer_cmd_buffer *backbuffer_cmd_buffer; struct gpu_cmd_buffer *backbuffer_cmd_buffer;
struct xform world_to_ui_xf; struct xform world_to_ui_xf;
@ -183,7 +183,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); INTERNAL SYS_WINDOW_EVENT_CALLBACK_FUNC_DEF(window_event_callback, event);
struct user_startup_receipt user_startup(struct work_startup_receipt *work_sr, struct user_startup_receipt user_startup(struct work_startup_receipt *work_sr,
struct renderer_startup_receipt *renderer_sr, struct gpu_startup_receipt *gpu_sr,
struct font_startup_receipt *font_sr, struct font_startup_receipt *font_sr,
struct sprite_startup_receipt *sprite_sr, struct sprite_startup_receipt *sprite_sr,
struct draw_startup_receipt *draw_sr, struct draw_startup_receipt *draw_sr,
@ -196,7 +196,7 @@ struct user_startup_receipt user_startup(struct work_startup_receipt *work_sr,
struct sys_window *window) struct sys_window *window)
{ {
(UNUSED)work_sr; (UNUSED)work_sr;
(UNUSED)renderer_sr; (UNUSED)gpu_sr;
(UNUSED)font_sr; (UNUSED)font_sr;
(UNUSED)sprite_sr; (UNUSED)sprite_sr;
(UNUSED)draw_sr; (UNUSED)draw_sr;
@ -234,10 +234,10 @@ struct user_startup_receipt user_startup(struct work_startup_receipt *work_sr,
G.user_sim_cmd_mutex = sys_mutex_alloc(); G.user_sim_cmd_mutex = sys_mutex_alloc();
G.world_to_ui_xf = XFORM_IDENT; G.world_to_ui_xf = XFORM_IDENT;
G.world_cmd_buffer = renderer_cmd_buffer_alloc(); G.world_cmd_buffer = gpu_cmd_buffer_alloc();
G.ui_cmd_buffer = renderer_cmd_buffer_alloc(); G.ui_cmd_buffer = gpu_cmd_buffer_alloc();
G.final_cmd_buffer = renderer_cmd_buffer_alloc(); G.final_cmd_buffer = gpu_cmd_buffer_alloc();
G.backbuffer_cmd_buffer = renderer_cmd_buffer_alloc(); G.backbuffer_cmd_buffer = gpu_cmd_buffer_alloc();
G.window = window; G.window = window;
sys_window_register_event_callback(G.window, &window_event_callback); sys_window_register_event_callback(G.window, &window_event_callback);
@ -1939,29 +1939,29 @@ INTERNAL void user_update(void)
{ {
/* World texture */ /* World texture */
if (!G.world_texture.handle || !v2i32_eq(renderer_texture_get_size(G.world_texture), world_resolution)) { if (!G.world_texture.handle || !v2i32_eq(gpu_texture_get_size(G.world_texture), world_resolution)) {
if (G.world_texture.handle) { if (G.world_texture.handle) {
renderer_texture_release(G.world_texture); gpu_texture_release(G.world_texture);
} }
G.world_texture = renderer_texture_alloc(RENDERER_TEXTURE_FORMAT_R8G8B8A8_UNORM, RENDERER_TEXTURE_FLAG_TARGET, world_resolution, NULL); G.world_texture = gpu_texture_alloc(GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM, GPU_TEXTURE_FLAG_TARGET, world_resolution, NULL);
} }
/* Ui texture */ /* Ui texture */
if (!G.ui_texture.handle || !v2i32_eq(renderer_texture_get_size(G.ui_texture), ui_resolution)) { if (!G.ui_texture.handle || !v2i32_eq(gpu_texture_get_size(G.ui_texture), ui_resolution)) {
if (G.ui_texture.handle) { if (G.ui_texture.handle) {
renderer_texture_release(G.ui_texture); gpu_texture_release(G.ui_texture);
} }
G.ui_texture = renderer_texture_alloc(RENDERER_TEXTURE_FORMAT_R8G8B8A8_UNORM, RENDERER_TEXTURE_FLAG_TARGET, ui_resolution, NULL); G.ui_texture = gpu_texture_alloc(GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM, GPU_TEXTURE_FLAG_TARGET, ui_resolution, NULL);
} }
/* Final texture */ /* Final texture */
if (!G.final_texture.handle || !v2i32_eq(renderer_texture_get_size(G.final_texture), ui_resolution)) { if (!G.final_texture.handle || !v2i32_eq(gpu_texture_get_size(G.final_texture), ui_resolution)) {
if (G.final_texture.handle) { if (G.final_texture.handle) {
renderer_texture_release(G.final_texture); gpu_texture_release(G.final_texture);
} }
G.final_texture = renderer_texture_alloc(RENDERER_TEXTURE_FORMAT_R8G8B8A8_UNORM, RENDERER_TEXTURE_FLAG_TARGET, ui_resolution, NULL); G.final_texture = gpu_texture_alloc(GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM, GPU_TEXTURE_FLAG_TARGET, ui_resolution, NULL);
} }
/* Backbuffer texture */ /* Backbuffer texture */
if (!G.backbuffer_texture.handle || !v2i32_eq(renderer_texture_get_size(G.backbuffer_texture), backbuffer_resolution)) { if (!G.backbuffer_texture.handle || !v2i32_eq(gpu_texture_get_size(G.backbuffer_texture), backbuffer_resolution)) {
G.backbuffer_texture = renderer_backbuffer_recreate(backbuffer_resolution); G.backbuffer_texture = gpu_recreate_backbuffer(backbuffer_resolution);
} }
} }
@ -1990,34 +1990,34 @@ INTERNAL void user_update(void)
} }
/* Send cmd buffers to GPU */ /* Send cmd buffers to GPU */
renderer_cmd_buffer_send_to_gpu(G.world_cmd_buffer); gpu_cmd_buffer_flush_to_gpu(G.world_cmd_buffer);
renderer_cmd_buffer_send_to_gpu(G.ui_cmd_buffer); gpu_cmd_buffer_flush_to_gpu(G.ui_cmd_buffer);
renderer_cmd_buffer_send_to_gpu(G.final_cmd_buffer); gpu_cmd_buffer_flush_to_gpu(G.final_cmd_buffer);
renderer_cmd_buffer_send_to_gpu(G.backbuffer_cmd_buffer); gpu_cmd_buffer_flush_to_gpu(G.backbuffer_cmd_buffer);
/* Execute render cmds */ /* Execute render cmds */
{ {
/* Clear textures */ /* Clear textures */
renderer_texture_clear(G.world_texture, 0); gpu_texture_clear(G.world_texture, 0);
renderer_texture_clear(G.ui_texture, 0); gpu_texture_clear(G.ui_texture, 0);
renderer_texture_clear(G.final_texture, 0); gpu_texture_clear(G.final_texture, 0);
renderer_texture_clear(G.backbuffer_texture, RGBA_F(0, 0, 0, 1)); gpu_texture_clear(G.backbuffer_texture, RGBA_F(0, 0, 0, 1));
/* Render to world texture */ /* Render to world texture */
renderer_texture_render(G.world_texture, G.world_cmd_buffer, G.world_to_ui_xf, ui_viewport); gpu_texture_render(G.world_texture, G.world_cmd_buffer, G.world_to_ui_xf, ui_viewport);
/* Render to UI texture */ /* Render to UI texture */
renderer_texture_render(G.ui_texture, G.ui_cmd_buffer, XFORM_IDENT, ui_viewport); gpu_texture_render(G.ui_texture, G.ui_cmd_buffer, XFORM_IDENT, ui_viewport);
/* Render to final texture */ /* Render to final texture */
renderer_texture_render(G.final_texture, G.final_cmd_buffer, XFORM_IDENT, ui_viewport); gpu_texture_render(G.final_texture, G.final_cmd_buffer, XFORM_IDENT, ui_viewport);
/* Render to backbuffer */ /* Render to backbuffer */
renderer_texture_render(G.backbuffer_texture, G.backbuffer_cmd_buffer, XFORM_IDENT, backbuffer_viewport); gpu_texture_render(G.backbuffer_texture, G.backbuffer_cmd_buffer, XFORM_IDENT, backbuffer_viewport);
} }
/* Present */ /* Present */
renderer_backbuffer_present(VSYNC_ENABLED); gpu_present_backbuffer(VSYNC_ENABLED);
} }
/* ========================== * /* ========================== *

4
src/user.h
View File

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