diff --git a/build.c b/build.c index 2cfe065a..56f613cb 100644 --- a/build.c +++ b/build.c @@ -856,14 +856,14 @@ void OnBuild(StringList cli_args) if (is_c || is_cpp) { if (StringBeginsWith(name, Lit("sys_")) || StringBeginsWith(name, Lit("sock_")) || - StringBeginsWith(name, Lit("renderer_")) || + StringBeginsWith(name, Lit("gpu_")) || 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("renderer_d3d11.c")) || + StringEqual(name, Lit("gpu_dx11.c")) || StringEqual(name, Lit("playback_wasapi.c")) || StringEqual(name, Lit("mp3_mmf.c")) || StringEqual(name, Lit("ttf_dwrite.cpp"))); diff --git a/res/shaders/common.hlsl b/res/shaders/common.hlsl index 600817e7..72f64b82 100644 --- a/res/shaders/common.hlsl +++ b/res/shaders/common.hlsl @@ -3,7 +3,3 @@ float4 linear_from_srgb(float4 srgb) return float4(pow(srgb.rgb, 2.2), srgb.a); } -float bla(float a) -{ - return a; -} diff --git a/src/app.c b/src/app.c index 97a19427..6b2286ab 100644 --- a/src/app.c +++ b/src/app.c @@ -20,7 +20,7 @@ #include "settings.h" #include "draw.h" #include "math.h" -#include "renderer.h" +#include "gpu.h" #include "phys.h" #include "sock.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 host_startup_receipt host_sr = host_startup(&sock_sr); 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 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, &renderer_sr, &asset_cache_sr, &ttf_sr, &resource_sr); - struct sprite_startup_receipt sprite_sr = sprite_startup(&renderer_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(&gpu_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(&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 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); (UNUSED)user_sr; diff --git a/src/common.h b/src/common.h index 9b7e4280..2e6cbcc2 100644 --- a/src/common.h +++ b/src/common.h @@ -281,8 +281,9 @@ void __asan_unpoison_memory_region(void const volatile *add, size_t); #endif /* 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 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 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 __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 -# 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 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 __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_custom_name(ctx, name, len) TracyCSharedLockCustomName((ctx), (name), (len)) -#define __prof_d3d11_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_d3d11_ctx_release(ctx) ___tracy_d3d11_context_terminate(ctx) -#define __prof_d3d11_collect(ctx) ___tracy_d3d11_context_collect(ctx) +#define __prof_dx11_ctx TracyCD3D11Ctx +#define __prof_dx11_ctx_alloc(ctx, device, devicectx, name, name_len) ctx = ___tracy_d3d11_context_announce(device, devicectx, name, name_len) +#define __prof_dx11_ctx_release(ctx) ___tracy_d3d11_context_terminate(ctx) +#define __prof_dx11_collect(ctx) ___tracy_d3d11_context_collect(ctx) enum __prof_plot_type { __prof_plot_type_number = TracyPlotFormatNumber, @@ -699,7 +700,7 @@ enum __prof_plot_type { #define __prof #define __profscope(name) -#define __profscope_d3d11(d3d11_ctx, name) +#define __profscope_dx11(dx11_ctx, name, color) #define __profalloc(ptr, size) #define __proffree(ptr) #define __profmsg(txt, len, col) @@ -719,10 +720,10 @@ enum __prof_plot_type { #define __proflock_after_try_shared_lock(ctx, acquired) #define __proflock_mark(ctx) #define __proflock_custom_name(ctx, name, len) -#define __prof_d3d11_ctx -#define __prof_d3d11_ctx_alloc(ctx, device, devicectx, name, name_len) -#define __prof_d3d11_ctx_release(ctx) -#define __prof_d3d11_collect(ctx) +#define __prof_dx11_ctx +#define __prof_dx11_ctx_alloc(ctx, device, devicectx, name, name_len) +#define __prof_dx11_ctx_release(ctx) +#define __prof_dx11_collect(ctx) #define __prof_plot_init(name, type, step, fill, color) #define __prof_plot(name, val) #define __prof_plot_i(name, val) diff --git a/src/draw.c b/src/draw.c index 936b4600..212b1b6f 100644 --- a/src/draw.c +++ b/src/draw.c @@ -1,5 +1,5 @@ #include "draw.h" -#include "renderer.h" +#include "gpu.h" #include "math.h" #include "font.h" #include "scratch.h" @@ -7,20 +7,20 @@ #include "collider.h" GLOBAL struct { - struct renderer_texture solid_white; + struct gpu_texture solid_white; } G = ZI, DEBUG_ALIAS(G, G_draw); /* ========================== * * 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) { - (UNUSED)renderer_sr; + (UNUSED)gpu_sr; (UNUSED)font_sr; 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 }; } @@ -28,17 +28,17 @@ struct draw_startup_receipt draw_startup(struct renderer_startup_receipt *render * 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.texture_params.texture = texture; 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; 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 */ 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; } -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); } @@ -85,23 +85,23 @@ void draw_quad_texture(struct renderer_cmd_buffer *cmdbuff, struct draw_texture_ * 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) { return; } - struct renderer_cmd_parameters cmd_params = ZI; + struct gpu_cmd_parameters cmd_params = ZI; cmd_params.kind = SHADER_TRIANGLE; 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_indices = num_tris * 3; struct triangle_shader_vertex *vertices = 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 */ 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(); @@ -142,7 +142,7 @@ void draw_circle(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, f32 radius, 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); } @@ -151,25 +151,25 @@ void draw_quad(struct renderer_cmd_buffer *cmdbuff, struct quad quad, u32 srgb) * 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); 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); 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); 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) { 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(); @@ -211,14 +211,14 @@ void draw_circle_line(struct renderer_cmd_buffer *cmdbuff, struct v2 pos, f32 ra 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_array a = { .points = points, .count = ARRAY_COUNT(points) }; 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 */ @@ -248,13 +248,13 @@ void draw_arrow_line(struct renderer_cmd_buffer *cmdbuff, struct v2 start, struc 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); 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(); @@ -285,15 +285,15 @@ void draw_collider_line(struct renderer_cmd_buffer *cmdbuff, struct xform draw_x * 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; - renderer_cmd_buffer_ensure_cmd(cmdbuff, &cmd_params); + gpu_cmd_buffer_ensure_cmd(cmdbuff, &cmd_params); struct grid_shader_vertex *vertices = 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); @@ -334,7 +334,7 @@ void draw_grid(struct renderer_cmd_buffer *cmdbuff, struct rect rect, u32 bg0_sr * 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; 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); } -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); } diff --git a/src/draw.h b/src/draw.h index 06c87e34..9b234219 100644 --- a/src/draw.h +++ b/src/draw.h @@ -1,11 +1,11 @@ #ifndef DRAW_H #define DRAW_H -#include "renderer.h" +#include "gpu.h" -struct renderer_cmd_buffer; +struct gpu_cmd_buffer; struct font; -struct renderer_startup_receipt; +struct gpu_startup_receipt; struct font_startup_receipt; #define DRAW_TEXTURE_PARAMS(...) ((struct draw_texture_params) { \ @@ -15,36 +15,36 @@ struct font_startup_receipt; }) 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 clip_rect clip; u32 tint; }; 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); -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(struct renderer_cmd_buffer *cmdbuff, struct draw_texture_params params, 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 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_circle(struct renderer_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_poly(struct gpu_cmd_buffer *cmdbuff, struct v2_array array, u32 srgb); +void draw_circle(struct gpu_cmd_buffer *cmdbuff, struct v2 pos, f32 radius, u32 srgb, u32 detail); +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_line(struct renderer_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_poly_line(struct renderer_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_quad_line(struct renderer_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_ray(struct renderer_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_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 gpu_cmd_buffer *cmdbuff, struct v2 start, struct v2 end, 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 gpu_cmd_buffer *cmdbuff, struct v2_array array, b32 loop, f32 thickness, u32 srgb); +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 gpu_cmd_buffer *cmdbuff, struct quad quad, f32 thickness, 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 gpu_cmd_buffer *cmdbuff, struct v2 pos, struct v2 rel, f32 thickness, f32 arrowhead_height, u32 srgb); +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_ex(struct renderer_cmd_buffer *cmdbuff, struct font *font, struct v2 pos, f32 scale, 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 gpu_cmd_buffer *cmdbuff, struct font *font, struct v2 pos, f32 scale, struct string str); #endif diff --git a/src/font.c b/src/font.c index 6c56bb79..b8b27b3a 100644 --- a/src/font.c +++ b/src/font.c @@ -7,7 +7,7 @@ #include "resource.h" #include "log.h" #include "string.h" -#include "renderer.h" +#include "gpu.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 renderer_startup_receipt *renderer_sr, + struct gpu_startup_receipt *gpu_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)renderer_sr; + (UNUSED)gpu_sr; (UNUSED)asset_cache_sr; (UNUSED)ttf_sr; (UNUSED)resource_sr; @@ -120,7 +120,7 @@ INTERNAL WORK_TASK_FUNC_DEF(font_load_asset_task, vparams) resource_close(&res); /* 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 */ struct font *font = NULL; diff --git a/src/font.h b/src/font.h index 53be6a09..40669d77 100644 --- a/src/font.h +++ b/src/font.h @@ -2,11 +2,11 @@ #define FONT_H #include "util.h" -#include "renderer.h" +#include "gpu.h" struct asset; struct work_startup_receipt; -struct renderer_startup_receipt; +struct gpu_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 renderer_texture texture; + struct gpu_texture 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 renderer_startup_receipt *renderer_sr, + struct gpu_startup_receipt *gpu_sr, struct asset_cache_startup_receipt *asset_cache_sr, struct ttf_startup_receipt *ttf_sr, struct resource_startup_receipt *resource_sr); diff --git a/src/gpu.h b/src/gpu.h new file mode 100644 index 00000000..8be7e4be --- /dev/null +++ b/src/gpu.h @@ -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 diff --git a/src/renderer_d3d11.c b/src/gpu_dx11.c similarity index 91% rename from src/renderer_d3d11.c rename to src/gpu_dx11.c index f51fab78..15dac0e9 100644 --- a/src/renderer_d3d11.c +++ b/src/gpu_dx11.c @@ -1,4 +1,4 @@ -#include "renderer.h" +#include "gpu.h" #include "resource.h" #include "sys.h" #include "memory.h" @@ -31,17 +31,17 @@ /* FIXME: Enable this and resolve unreleased references */ #if RTC -# define D3D11_DEBUG 0 -# define D3D11_SHADER_DEBUG 1 +# define DX11_DEBUG 0 +# define DX11_SHADER_DEBUG 1 #else -# define D3D11_DEBUG 0 -# define D3D11_SHADER_DEBUG 0 +# define DX11_DEBUG 0 +# define DX11_SHADER_DEBUG 0 #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 D3D11_SWAPCHAIN_RTV_FORMAT (DXGI_FORMAT_R8G8B8A8_UNORM_SRGB) +#define DX11_SWAPCHAIN_FORMAT (DXGI_FORMAT_R8G8B8A8_UNORM) +#define DX11_SWAPCHAIN_RTV_FORMAT (DXGI_FORMAT_R8G8B8A8_UNORM_SRGB) #define SHADER_NAME_LEN 255 @@ -76,10 +76,10 @@ struct dx11_buffer { ID3D11Buffer *gpu_index_buffer; }; -struct renderer_cmd { +struct gpu_cmd { struct dx11_shader *shader; - struct renderer_texture texture; /* Overrides sprite if set */ + struct gpu_texture texture; /* Overrides sprite if set */ struct sprite_tag sprite; /* Associated buffer data */ @@ -89,16 +89,16 @@ struct renderer_cmd { u32 index_offset; b32 offsets_set; - struct renderer_cmd *next; + struct gpu_cmd *next; }; struct cmd_store { - struct renderer_cmd *cmd_first; - struct renderer_cmd *cmd_last; + struct gpu_cmd *cmd_first; + struct gpu_cmd *cmd_last; struct arena arena; }; -struct renderer_cmd_buffer { +struct gpu_cmd_buffer { struct dx11_buffer buffers[NUM_SHADERS]; struct cmd_store cpu_cmd_store; @@ -121,7 +121,7 @@ struct dx11_texture { struct dx11_texture *next_free; }; -INTERNAL void renderer_capture_image_for_profiler(void); +INTERNAL void gpu_capture_image_for_profiler(void); /* ========================== * * Global state @@ -161,7 +161,7 @@ GLOBAL struct { struct arena arena; #if PROFILING - struct __prof_d3d11_ctx *profiling_ctx; + struct __prof_dx11_ctx *profiling_ctx; #endif ID3D11Device *dev; @@ -185,18 +185,18 @@ GLOBAL struct { struct dx11_texture *textures_first_free; /* 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_desc shader_info[NUM_SHADERS]; -} G = ZI, DEBUG_ALIAS(G, G_renderer_d3d11); +} G = ZI, DEBUG_ALIAS(G, G_gpu_dx11); /* ========================== * * 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) { 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); #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)); @@ -247,7 +247,7 @@ struct renderer_startup_receipt renderer_startup(struct sys_window *window) /* Create D3D11 device & context */ { -#if D3D11_DEBUG +#if DX11_DEBUG u32 flags = D3D11_CREATE_DEVICE_DEBUG; #else u32 flags = 0; @@ -268,7 +268,7 @@ struct renderer_startup_receipt renderer_startup(struct sys_window *window) ASSERT(SUCCEEDED(hr)); } -#if D3D11_DEBUG +#if DX11_DEBUG /* D3D11 Debug break */ { ID3D11InfoQueue *info; @@ -309,12 +309,12 @@ struct renderer_startup_receipt renderer_startup(struct sys_window *window) ASSERT(SUCCEEDED(hr)); DXGI_SWAP_CHAIN_DESC1 desc = { - .Format = D3D11_SWAPCHAIN_FORMAT, + .Format = DX11_SWAPCHAIN_FORMAT, .SampleDesc = { 1, 0 }, .BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT, .BufferCount = 2, .Scaling = DXGI_SCALING_NONE, - .Flags = D3D11_SWAPCHAIN_FLAGS, + .Flags = DX11_SWAPCHAIN_FLAGS, .AlphaMode = DXGI_ALPHA_MODE_IGNORE, .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) { - /* Renderer initialization failure */ + /* Gpu initialization failure */ /* TODO: Better message */ - sys_panic(LIT("Failed to initialize renderer")); + sys_panic(LIT("Failed to initialize DirectX 11")); } G.dev = device; 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"); (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 */ { @@ -447,7 +447,7 @@ struct renderer_startup_receipt renderer_startup(struct sys_window *window) resource_register_watch_callback(shader_resource_watch_callback); #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 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); struct dict *dict = &desc->includes_dict; 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) { + __prof; struct dict *dict = &desc->includes_dict; 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) { + __prof; b32 caused_dirty = false; for (u64 i = 0; i < NUM_SHADERS; ++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); if (res_name.len > SHADER_NAME_LEN) { sys_panic(string_format(scratch.arena, - LIT("Shader name \"%F\" too long (%F > %F)"), - FMT_STR(res_name), - FMT_UINT(res_name.len), - FMT_UINT(SHADER_NAME_LEN))); + LIT("Shader name \"%F\" too long (%F > %F)"), + FMT_STR(res_name), + FMT_UINT(res_name.len), + FMT_UINT(SHADER_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); 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; #else 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? * * 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; - __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(); 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 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) { struct dx11_shader *shader = cmd->shader; 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: { - __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 */ ID3D11Texture2D *texture = NULL; if (cmd->texture.handle) { @@ -905,7 +908,7 @@ INTERNAL void dx11_render(ID3D11RenderTargetView *target, struct renderer_cmd_bu 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); /* Activate buffer */ @@ -930,14 +933,14 @@ INTERNAL void dx11_render(ID3D11RenderTargetView *target, struct renderer_cmd_bu * 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] = { - [RENDERER_TEXTURE_FORMAT_R8G8B8A8_UNORM] = { + LOCAL_PERSIST const struct dx11_format sizes[NUM_GPU_TEXTURE_FORMATS] = { + [GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM] = { .format = DXGI_FORMAT_R8G8B8A8_UNORM, .pixel_size = 4 }, - [RENDERER_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB] = { + [GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB] = { .format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, .pixel_size = 4 } @@ -949,7 +952,7 @@ INTERNAL struct dx11_format dx11_format_from_renderer_format(enum renderer_textu 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; { @@ -971,7 +974,7 @@ INTERNAL struct dx11_texture *dx11_texture_alloc(enum renderer_texture_format fo G.textures_last = t; 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) { /* Unknown format */ 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; - if (flags & RENDERER_TEXTURE_FLAG_TARGET) { + if (flags & GPU_TEXTURE_FLAG_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; - struct renderer_texture res = ZI; + struct gpu_texture res = ZI; struct dx11_texture *t = dx11_texture_alloc(format, flags, size, initial_data); res.handle = (u64)t; return res; } -void renderer_texture_release(struct renderer_texture t) +void gpu_texture_release(struct gpu_texture t) { __prof; 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; @@ -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; @@ -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_param = NULL; 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_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; D3D11_TEXTURE2D_DESC desc; @@ -1149,22 +1152,22 @@ INTERNAL struct DXGI_QUERY_VIDEO_MEMORY_INFO get_memory_info(void) } #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 */ if (G.backbuffer_texture.texture != 0) { 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); res.handle = (u64)&G.backbuffer_texture; return res; } -void renderer_backbuffer_present(i32 vsync) +void gpu_present_backbuffer(i32 vsync) { __prof; #if RESOURCE_RELOADING @@ -1203,11 +1206,11 @@ void renderer_backbuffer_present(i32 vsync) flags = DXGI_PRESENT_ALLOW_TEARING; } - renderer_capture_image_for_profiler(); + gpu_capture_image_for_profiler(); { __profscope(IDXGISwapchain_Present); IDXGISwapChain1_Present(G.swapchain, vsync, flags); - __prof_d3d11_collect(G.profiling_ctx); + __prof_dx11_collect(G.profiling_ctx); __profframe(0); } } @@ -1216,9 +1219,9 @@ void renderer_backbuffer_present(i32 vsync) * 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) { if (!G.cmdbuffs[i].valid) { cmdbuff = &G.cmdbuffs[i]; @@ -1227,7 +1230,7 @@ struct renderer_cmd_buffer *renderer_cmd_buffer_alloc(void) } if (!cmdbuff) { - sys_panic(LIT("Max renderer cmdbuffs reached")); + sys_panic(LIT("Max gpu cmdbuffs reached")); return NULL; } @@ -1248,7 +1251,7 @@ struct renderer_cmd_buffer *renderer_cmd_buffer_alloc(void) 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; 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) { /* 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; } -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) { 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->texture.handle != params->texture_params.texture.handle) || !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->texture = params->texture_params.texture; 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: { 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]; } } 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; @@ -1424,7 +1427,7 @@ void renderer_cmd_buffer_send_to_gpu(struct renderer_cmd_buffer *cmdbuff) * Profiling frame capture * ========================== */ -/* FIXME: enable this */ + /* FIXME: enable this */ #if PROFILING && PROFILING_CAPTURE_FRAME_IMAGE #define CAP_WIDTH 320 @@ -1435,7 +1438,7 @@ struct prof_cap { struct v2 size; }; -INTERNAL void renderer_capture_image_for_profiler(void) +INTERNAL void gpu_capture_image_for_profiler(void) { __prof; @@ -1512,7 +1515,7 @@ INTERNAL void renderer_capture_image_for_profiler(void) } #else -INTERNAL void renderer_capture_image_for_profiler(void) +INTERNAL void gpu_capture_image_for_profiler(void) { } diff --git a/src/renderer.h b/src/renderer.h deleted file mode 100644 index 45de4d82..00000000 --- a/src/renderer.h +++ /dev/null @@ -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 diff --git a/src/sprite.c b/src/sprite.c index 3dbef2d6..b596b507 100644 --- a/src/sprite.c +++ b/src/sprite.c @@ -9,7 +9,7 @@ #include "work.h" #include "atomic.h" #include "app.h" -#include "renderer.h" +#include "gpu.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 renderer_startup_receipt *renderer_sr, +struct sprite_startup_receipt sprite_startup(struct gpu_startup_receipt *gpu_sr, struct resource_startup_receipt *resource_sr) { - (UNUSED)renderer_sr; + (UNUSED)gpu_sr; (UNUSED)resource_sr; 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 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); } @@ -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)); 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) { - format = RENDERER_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB; + format = GPU_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB; } /* Initialize */ e->texture = arena_push(&e->arena, struct sprite_texture); e->texture->width = decoded.image.width; 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->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); } else { 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) { struct cache_entry *n = en->cache_entry; 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); } diff --git a/src/sprite.h b/src/sprite.h index 80f941aa..277223df 100644 --- a/src/sprite.h +++ b/src/sprite.h @@ -1,10 +1,10 @@ #ifndef SPRITE_H #define SPRITE_H -#include "renderer.h" +#include "gpu.h" #include "util.h" -struct renderer_startup_receipt; +struct gpu_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 renderer_startup_receipt *renderer_sr, +struct sprite_startup_receipt sprite_startup(struct gpu_startup_receipt *gpu_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 renderer_texture texture; + struct gpu_texture texture; u32 width; u32 height; }; diff --git a/src/user.c b/src/user.c index 8b43bf7b..0a140c65 100644 --- a/src/user.c +++ b/src/user.c @@ -2,7 +2,7 @@ #include "sim.h" #include "sim_ent.h" #include "sim_step.h" -#include "renderer.h" +#include "gpu.h" #include "font.h" #include "sprite.h" #include "draw.h" @@ -60,15 +60,15 @@ GLOBAL struct { struct second_stat net_bytes_sent; /* Render targets */ - struct renderer_texture final_texture; - struct renderer_texture world_texture; - struct renderer_texture ui_texture; - struct renderer_texture backbuffer_texture; + struct gpu_texture final_texture; + struct gpu_texture world_texture; + struct gpu_texture ui_texture; + struct gpu_texture backbuffer_texture; - struct renderer_cmd_buffer *world_cmd_buffer; - struct renderer_cmd_buffer *ui_cmd_buffer; - struct renderer_cmd_buffer *final_cmd_buffer; - struct renderer_cmd_buffer *backbuffer_cmd_buffer; + struct gpu_cmd_buffer *world_cmd_buffer; + struct gpu_cmd_buffer *ui_cmd_buffer; + struct gpu_cmd_buffer *final_cmd_buffer; + struct gpu_cmd_buffer *backbuffer_cmd_buffer; 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); 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 sprite_startup_receipt *sprite_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) { (UNUSED)work_sr; - (UNUSED)renderer_sr; + (UNUSED)gpu_sr; (UNUSED)font_sr; (UNUSED)sprite_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.world_to_ui_xf = XFORM_IDENT; - G.world_cmd_buffer = renderer_cmd_buffer_alloc(); - G.ui_cmd_buffer = renderer_cmd_buffer_alloc(); - G.final_cmd_buffer = renderer_cmd_buffer_alloc(); - G.backbuffer_cmd_buffer = renderer_cmd_buffer_alloc(); + G.world_cmd_buffer = gpu_cmd_buffer_alloc(); + G.ui_cmd_buffer = gpu_cmd_buffer_alloc(); + G.final_cmd_buffer = gpu_cmd_buffer_alloc(); + G.backbuffer_cmd_buffer = gpu_cmd_buffer_alloc(); G.window = window; sys_window_register_event_callback(G.window, &window_event_callback); @@ -1939,29 +1939,29 @@ INTERNAL void user_update(void) { /* 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) { - 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 */ - 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) { - 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 */ - 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) { - 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 */ - if (!G.backbuffer_texture.handle || !v2i32_eq(renderer_texture_get_size(G.backbuffer_texture), backbuffer_resolution)) { - G.backbuffer_texture = renderer_backbuffer_recreate(backbuffer_resolution); + if (!G.backbuffer_texture.handle || !v2i32_eq(gpu_texture_get_size(G.backbuffer_texture), backbuffer_resolution)) { + G.backbuffer_texture = gpu_recreate_backbuffer(backbuffer_resolution); } } @@ -1990,34 +1990,34 @@ INTERNAL void user_update(void) } /* Send cmd buffers to GPU */ - renderer_cmd_buffer_send_to_gpu(G.world_cmd_buffer); - renderer_cmd_buffer_send_to_gpu(G.ui_cmd_buffer); - renderer_cmd_buffer_send_to_gpu(G.final_cmd_buffer); - renderer_cmd_buffer_send_to_gpu(G.backbuffer_cmd_buffer); + gpu_cmd_buffer_flush_to_gpu(G.world_cmd_buffer); + gpu_cmd_buffer_flush_to_gpu(G.ui_cmd_buffer); + gpu_cmd_buffer_flush_to_gpu(G.final_cmd_buffer); + gpu_cmd_buffer_flush_to_gpu(G.backbuffer_cmd_buffer); /* Execute render cmds */ { /* Clear textures */ - renderer_texture_clear(G.world_texture, 0); - renderer_texture_clear(G.ui_texture, 0); - renderer_texture_clear(G.final_texture, 0); - renderer_texture_clear(G.backbuffer_texture, RGBA_F(0, 0, 0, 1)); + gpu_texture_clear(G.world_texture, 0); + gpu_texture_clear(G.ui_texture, 0); + gpu_texture_clear(G.final_texture, 0); + gpu_texture_clear(G.backbuffer_texture, RGBA_F(0, 0, 0, 1)); /* 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 */ - 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 */ - 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 */ - 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 */ - renderer_backbuffer_present(VSYNC_ENABLED); + gpu_present_backbuffer(VSYNC_ENABLED); } /* ========================== * diff --git a/src/user.h b/src/user.h index e4284af2..3b88606f 100644 --- a/src/user.h +++ b/src/user.h @@ -3,7 +3,7 @@ struct sys_window; struct work_startup_receipt; -struct renderer_startup_receipt; +struct gpu_startup_receipt; struct font_startup_receipt; struct sprite_startup_receipt; struct draw_startup_receipt; @@ -60,7 +60,7 @@ enum user_bind_kind { struct user_startup_receipt { i32 _; }; 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 sprite_startup_receipt *sprite_sr, struct draw_startup_receipt *draw_sr,