From 54a8a4583562bd20e92ba740ac21a17b83aa5f0a Mon Sep 17 00:00:00 2001 From: jacob Date: Sun, 8 Jun 2025 18:47:25 -0500 Subject: [PATCH] validate dx12 root signature presence. create debug log arena before registering callback --- res/{shaders => gpu}/common.hlsl | 0 res/{shaders => gpu}/grid.hlsl | 0 res/{shaders => gpu}/mesh.hlsl | 0 res/{shaders => gpu}/test.hlsl | 0 res/{shaders => gpu}/texture.hlsl | 20 +- src/config.h | 2 +- src/gpu_dx12.c | 314 +++++++++++++++++++++++------- src/user.c | 4 +- 8 files changed, 252 insertions(+), 88 deletions(-) rename res/{shaders => gpu}/common.hlsl (100%) rename res/{shaders => gpu}/grid.hlsl (100%) rename res/{shaders => gpu}/mesh.hlsl (100%) rename res/{shaders => gpu}/test.hlsl (100%) rename res/{shaders => gpu}/texture.hlsl (77%) diff --git a/res/shaders/common.hlsl b/res/gpu/common.hlsl similarity index 100% rename from res/shaders/common.hlsl rename to res/gpu/common.hlsl diff --git a/res/shaders/grid.hlsl b/res/gpu/grid.hlsl similarity index 100% rename from res/shaders/grid.hlsl rename to res/gpu/grid.hlsl diff --git a/res/shaders/mesh.hlsl b/res/gpu/mesh.hlsl similarity index 100% rename from res/shaders/mesh.hlsl rename to res/gpu/mesh.hlsl diff --git a/res/shaders/test.hlsl b/res/gpu/test.hlsl similarity index 100% rename from res/shaders/test.hlsl rename to res/gpu/test.hlsl diff --git a/res/shaders/texture.hlsl b/res/gpu/texture.hlsl similarity index 77% rename from res/shaders/texture.hlsl rename to res/gpu/texture.hlsl index 7f152dbb..176c9950 100644 --- a/res/shaders/texture.hlsl +++ b/res/gpu/texture.hlsl @@ -1,4 +1,4 @@ -#include "shaders/common.hlsl" +#include "gpu/common.hlsl" struct instance { float2x3 xf; @@ -17,17 +17,17 @@ struct constants { * Root Signature * ========================== */ -#define SIG \ +#define ROOTSIG \ "CBV(b0), " \ "DescriptorTable(SRV(t0), SRV(t1)), " \ "DescriptorTable(Sampler(s0))" -cbuffer c : register(b0) +cbuffer cbuff : register(b0) { struct constants g_constants; }; -StructuredBuffer g_instance_buffer : register(t0); +StructuredBuffer g_instances : register(t0); Texture2D g_texture : register(t1); @@ -57,15 +57,15 @@ struct vs_output { DECL(float4, tint_lin); }; -[RootSignature(SIG)] -vs_output vs_main(uint instance_id : SV_InstanceID, uint vertex_id : SV_VertexID) +[RootSignature(ROOTSIG)] +struct vs_output vs(uint instance_id : SV_InstanceID, uint vertex_id : SV_VertexID) { - instance instance = g_instance_buffer[g_constants.instance_offset + instance_id]; + struct instance instance = g_instances[g_constants.instance_offset + instance_id]; float2 vert = g_quad_verts[vertex_id]; float2 uv_factor = g_uv_factors[vertex_id]; float2 world_pos = mul(instance.xf, float3(vert, 1)).xy; - vs_output output; + struct vs_output output; output.screen_pos = mul(g_constants.projection, float4(world_pos, 0, 1)); output.uv = instance.uv0 + uv_factor * (instance.uv1 - instance.uv0); output.tint_lin = linear_from_srgb32(instance.tint_srgb); @@ -77,8 +77,8 @@ vs_output vs_main(uint instance_id : SV_InstanceID, uint vertex_id : SV_VertexID * Pixel shader * ========================== */ -[RootSignature(SIG)] -float4 ps_main(vs_output input) : SV_TARGET +[RootSignature(ROOTSIG)] +float4 ps(struct vs_output input) : SV_TARGET { float4 color = g_texture.Sample(g_sampler, input.uv) * input.tint_lin; return color; diff --git a/src/config.h b/src/config.h index 3496649b..3b07856b 100644 --- a/src/config.h +++ b/src/config.h @@ -80,7 +80,7 @@ -#define DX12_TEST 0 +#define DX12_TEST 1 diff --git a/src/gpu_dx12.c b/src/gpu_dx12.c index e80e8a3e..a46a94de 100644 --- a/src/gpu_dx12.c +++ b/src/gpu_dx12.c @@ -43,20 +43,23 @@ # define DX12_SHADER_DEBUG 0 #endif -enum pipeline_desc_flags { - PIPELINE_DESC_FLAG_NONE = 0, - PIPELINE_DESC_FLAG_VS = (1 << 0), - PIPELINE_DESC_FLAG_PS = (1 << 1) +struct shader_desc { + char *file; + char *func; }; struct pipeline_desc { - char *shader; + char *name; + struct shader_desc vs; + struct shader_desc ps; u32 flags; }; struct pipeline { struct pipeline_desc desc; ID3D12PipelineState *pso; + ID3D12RootSignature *rs; + }; struct pipeline_result { @@ -72,6 +75,7 @@ struct pipeline_error { enum dx12_handle_kind { DX12_HANDLE_KIND_NONE, DX12_HANDLE_KIND_TEXTURE, + DX12_HANDLE_KIND_COMMAND_LIST, NUM_DX12_HANDLE_KINDS }; @@ -216,6 +220,22 @@ INTERNAL struct dx12_handle_entry *handle_get_entry(struct gpu_handle handle, st return res; } +INTERNAL void *handle_get_data(struct gpu_handle handle, enum dx12_handle_kind kind) +{ + void *data = NULL; + struct sys_lock lock = sys_mutex_lock_s(&G.handle_entries_mutex); + { + struct dx12_handle_entry *entry = handle_get_entry(handle, &lock); + data = entry->data; +#if RTC + /* Handle should match expected kind */ + ASSERT(entry->kind == kind); +#endif + } + sys_mutex_unlock(&lock); + return data; +} + /* TODO: The GPU api should ensure that resources freed by the caller will not cause issues on the GPU (via fencing), * however the caller is responsible for managing resource lifetimes on the CPU side (e.g. using sprites w/ sprite scopes * to ensure freed textures aren't being used in pending command lists. */ @@ -315,16 +335,14 @@ INTERNAL void dx12_init_base(struct sys_window *window) if (SUCCEEDED(hr)) { DXGI_ADAPTER_DESC1 desc; IDXGIAdapter1_GetDesc1(adapter, &desc); - if (!(desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE)) { - if (first_gpu_name.len == 0) { - first_gpu_name = string_from_wstr_no_limit(scratch.arena, desc.Description); - } - hr = D3D12CreateDevice((IUnknown *)adapter, D3D_FEATURE_LEVEL_12_0, &IID_ID3D12Device, (void **)&device); - if (SUCCEEDED(hr)) { - IDXGIAdapter1_Release(adapter); - adapter = NULL; - break; - } + if (first_gpu_name.len == 0) { + first_gpu_name = string_from_wstr_no_limit(scratch.arena, desc.Description); + } + hr = D3D12CreateDevice((IUnknown *)adapter, D3D_FEATURE_LEVEL_12_0, &IID_ID3D12Device, (void **)&device); + if (SUCCEEDED(hr)) { + IDXGIAdapter1_Release(adapter); + adapter = NULL; + break; } ID3D12Device_Release(device); IDXGIAdapter1_Release(adapter); @@ -556,9 +574,9 @@ INTERNAL void dx12_init_pipelines(void) struct pipeline_desc pipeline_descs[] = { /* Texture pipeline */ { - .shader = "shaders/texture.hlsl", - .flags = PIPELINE_DESC_FLAG_VS | - PIPELINE_DESC_FLAG_PS + .name = "texture", + .vs = { "gpu/texture.hlsl", "vs" }, + .ps = { "gpu/texture.hlsl", "ps" } } }; @@ -660,7 +678,8 @@ struct shader_compile_task_arg { /* In */ enum shader_compile_task_kind kind; struct pipeline *pipeline; - struct resource *src_res; + struct shader_desc shader_desc; + struct resource *shader_res; /* Out */ b32 success; @@ -673,24 +692,22 @@ INTERNAL WORK_TASK_FUNC_DEF(shader_compile_task, comp_arg_raw) { __prof; struct shader_compile_task_arg *comp_arg = (struct shader_compile_task_arg *)comp_arg_raw; - struct pipeline *pipeline = comp_arg->pipeline; - struct string shader_name = string_from_cstr_no_limit(pipeline->desc.shader); enum shader_compile_task_kind kind = comp_arg->kind; - struct resource *src_res = comp_arg->src_res; + struct pipeline *pipeline = comp_arg->pipeline; + struct shader_desc shader_desc = comp_arg->shader_desc; + struct resource *shader_res = comp_arg->shader_res; struct arena_temp scratch = scratch_begin_no_conflict(); { b32 success = false; ID3DBlob *blob = NULL; ID3DBlob *error_blob = NULL; - struct dx12_include_handler include_handler = dx12_include_handler_alloc(pipeline); - if (resource_exists(src_res)) { - #if 0 - #if RESOURCE_RELOADING - shader_reset_includes(shader_desc); - #endif - #endif + struct string file_name = string_from_cstr_no_limit(shader_desc.file); + struct string func_name = string_from_cstr_no_limit(shader_desc.func); + + if (resource_exists(shader_res)) { + struct dx12_include_handler include_handler = dx12_include_handler_alloc(pipeline); u32 d3d_compile_flags = 0; #if DX12_SHADER_DEBUG @@ -701,56 +718,33 @@ INTERNAL WORK_TASK_FUNC_DEF(shader_compile_task, comp_arg_raw) /* Compile shader */ { - struct string shader_src = resource_get_data(src_res); - logf_info("Compiling shader \"%F\"", FMT_STR(shader_name)); + struct string shader_src = resource_get_data(shader_res); + logf_info("Compiling shader \"%F:%F\"", FMT_STR(file_name), FMT_STR(func_name)); /* Compile shader */ - struct string friendly_name = string_cat(scratch.arena, LIT("res/"), shader_name); + struct string friendly_name = string_cat(scratch.arena, LIT("res/"), file_name); char *friendly_name_cstr = cstr_from_string(scratch.arena, friendly_name); - char *entry_point = NULL; char *target = NULL; switch (kind) { case SHADER_COMPILE_TASK_KIND_VS: { - entry_point = "vs_main"; target = "vs_5_1"; } break; case SHADER_COMPILE_TASK_KIND_PS: { - entry_point = "ps_main"; target = "ps_5_1"; } break; } - HRESULT hr = D3DCompile(shader_src.text, shader_src.len, friendly_name_cstr, NULL, (ID3DInclude *)&include_handler, entry_point, target, d3d_compile_flags, 0, &blob, &error_blob); + HRESULT hr = D3DCompile(shader_src.text, shader_src.len, friendly_name_cstr, NULL, (ID3DInclude *)&include_handler, shader_desc.func, target, d3d_compile_flags, 0, &blob, &error_blob); success = SUCCEEDED(hr) && !error_blob; } - #if 0 - if (success) { - /* Get number of device layout elements from NULL terminated array */ - u32 elem_count = 0; - for (; elem_count < ARRAY_COUNT(shader_desc->input_layout_desc); ++elem_count) { - const D3D11_INPUT_ELEMENT_DESC *d = &shader_desc->input_layout_desc[elem_count]; - if (d->SemanticName == NULL) { - break; - } - } - - /* Create device layout */ - if (elem_count > 0) { - HRESULT hr = ID3D11Device_CreateInputLayout(G.dev, shader_desc->input_layout_desc, elem_count, ID3D10Blob_GetBufferPointer(vs_blob), ID3D10Blob_GetBufferSize(vs_blob), &shader->input_layout); - if (!SUCCEEDED(hr)) { - success = false; - error_str = LIT("Failed to create input layout"); - } - } - } - #endif + dx12_include_handler_release(&include_handler); } #if 0 if (success) { - logf_success("Finished compiling shader \"%F\" in %F seconds", FMT_STR(shader_name), FMT_FLOAT(SECONDS_FROM_NS(sys_time_ns() - start_ns))); + logf_success("Finished compiling shader \"%F\" in %F seconds", FMT_STR(src_name), FMT_FLOAT(SECONDS_FROM_NS(sys_time_ns() - start_ns))); } #endif @@ -762,7 +756,6 @@ INTERNAL WORK_TASK_FUNC_DEF(shader_compile_task, comp_arg_raw) shader->valid = true; #endif - dx12_include_handler_release(&include_handler); } scratch_end(scratch); } @@ -786,39 +779,100 @@ INTERNAL WORK_TASK_FUNC_DEF(pipeline_load_task, load_arg_raw) struct arena_temp scratch = scratch_begin_no_conflict(); { - struct string shader_name = string_from_cstr_no_limit(desc.shader); - logf_info("Loading pipeline from shader '%F'", FMT_STR(shader_name)); - struct resource src_res = resource_open(shader_name); + struct string pipeline_name = string_from_cstr_no_limit(desc.name); + logf_info("Loading pipeline \"%F\"", FMT_STR(pipeline_name)); + HRESULT hr = 0; + struct string error_str = LIT("Unknown error"); + struct string vs_filename = string_from_cstr_no_limit(desc.vs.file); + struct string ps_filename = string_from_cstr_no_limit(desc.ps.file); + + b32 ps_res_is_shared = string_eq(vs_filename, ps_filename); + struct resource vs_res = resource_open(vs_filename); + struct resource ps_res = vs_res; + if (!ps_res_is_shared) { + ps_res = resource_open(ps_filename); + } + struct shader_compile_task_arg vs = ZI; vs.kind = SHADER_COMPILE_TASK_KIND_VS; - vs.src_res = &src_res; vs.pipeline = pipeline; + vs.shader_desc = desc.vs; + vs.shader_res = &vs_res; struct shader_compile_task_arg ps = ZI; ps.kind = SHADER_COMPILE_TASK_KIND_PS; - ps.src_res = &src_res; ps.pipeline = pipeline; + ps.shader_desc = desc.ps; + ps.shader_res = &ps_res; /* Compile shaders */ struct work_slate ws = work_slate_begin(); - if (desc.flags & PIPELINE_DESC_FLAG_VS) { - work_slate_push_task(&ws, shader_compile_task, &vs); - } - if (desc.flags & PIPELINE_DESC_FLAG_PS) { - work_slate_push_task(&ws, shader_compile_task, &ps); - } + work_slate_push_task(&ws, shader_compile_task, &vs); + work_slate_push_task(&ws, shader_compile_task, &ps); struct work_handle work = work_slate_end_and_help(&ws, WORK_PRIORITY_NORMAL); work_wait(work); - /* FIXME: Validate root signature blob exists in bytecode */ b32 success = vs.success && ps.success; + /* Get root signature blob + * NOTE: This isn't necessary for creating the RS (since it can just + * take the shader blob), however we'd like to verify that the root + * signature exists and matches between shaders. */ + ID3D10Blob *rs_blob = NULL; + if (success) { + __profscope(Validate root signatures); + char *vs_rs_data = NULL; + char *ps_rs_data = NULL; + u32 vs_rs_data_len = 0; + u32 ps_rs_data_len = 0; + ID3D10Blob *vs_rs_blob = NULL; + ID3D10Blob *ps_rs_blob = NULL; + D3DGetBlobPart(ID3D10Blob_GetBufferPointer(vs.blob), ID3D10Blob_GetBufferSize(vs.blob), D3D_BLOB_ROOT_SIGNATURE, 0, &vs_rs_blob); + D3DGetBlobPart(ID3D10Blob_GetBufferPointer(ps.blob), ID3D10Blob_GetBufferSize(ps.blob), D3D_BLOB_ROOT_SIGNATURE, 0, &ps_rs_blob); + if (vs_rs_blob) { + vs_rs_data = ID3D10Blob_GetBufferPointer(vs_rs_blob); + vs_rs_data_len = ID3D10Blob_GetBufferSize(vs_rs_blob); + } + if (ps_rs_blob) { + ps_rs_data = ID3D10Blob_GetBufferPointer(ps_rs_blob); + ps_rs_data_len = ID3D10Blob_GetBufferSize(ps_rs_blob); + } + u32 cmp_len = min_u32(vs_rs_data_len, ps_rs_data_len); + if (vs_rs_data_len == 0) { + success = false; + error_str = LIT("Vertex shader is missing root signature"); + } else if (ps_rs_data_len == 0) { + success = false; + error_str = LIT("Pixel shader is missing root signature"); + } else if (!MEMEQ(vs_rs_data, ps_rs_data, cmp_len)) { + success = false; + error_str = LIT("Root signature mismatch between vertex and pixel shader"); + } else { + rs_blob = vs_rs_blob; + } + if (ps_rs_blob) { + ID3D10Blob_Release(ps_rs_blob); + } + } + + /* Create root signature */ + ID3D12RootSignature *rs = NULL; + if (success) { + __profscope(Create root signature); + hr = ID3D12Device_CreateRootSignature(G.device, 0, ID3D10Blob_GetBufferPointer(rs_blob), ID3D10Blob_GetBufferSize(rs_blob), &IID_ID3D12RootSignature, (void **)&rs); + if (FAILED(hr)) { + error_str = LIT("Failed to create root signature"); + success = false; + } + } + /* Create PSO */ ID3D12PipelineState *pso = NULL; if (success) { /* Default rasterizer state */ + __profscope(Create PSO); D3D12_RASTERIZER_DESC raster_desc = { .FillMode = D3D12_FILL_MODE_SOLID, .CullMode = D3D12_CULL_MODE_BACK, @@ -855,7 +909,7 @@ INTERNAL WORK_TASK_FUNC_DEF(pipeline_load_task, load_arg_raw) /* PSO */ D3D12_GRAPHICS_PIPELINE_STATE_DESC pso_desc = { 0 }; - pso_desc.pRootSignature = NULL; /* Use embedded root signature */ + pso_desc.pRootSignature = rs; if (vs.success) { pso_desc.VS.pShaderBytecode = ID3D10Blob_GetBufferPointer(vs.blob); pso_desc.VS.BytecodeLength = ID3D10Blob_GetBufferSize(vs.blob); @@ -873,11 +927,10 @@ INTERNAL WORK_TASK_FUNC_DEF(pipeline_load_task, load_arg_raw) pso_desc.NumRenderTargets = 1; pso_desc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM; pso_desc.SampleDesc.Count = 1; - HRESULT hr = ID3D12Device_CreateGraphicsPipelineState(G.device, &pso_desc, &IID_ID3D12PipelineState, (void **)&pso); + hr = ID3D12Device_CreateGraphicsPipelineState(G.device, &pso_desc, &IID_ID3D12PipelineState, (void **)&pso); if (FAILED(hr)) { error_str = LIT("Failed to create pipeline state object"); success = false; - ASSERT(false); } } @@ -901,7 +954,15 @@ INTERNAL WORK_TASK_FUNC_DEF(pipeline_load_task, load_arg_raw) } pipeline->pso = pso; + pipeline->rs = rs; + resource_close(&vs_res); + if (!ps_res_is_shared) { + resource_close(&ps_res); + } + if (rs_blob) { + ID3D10Blob_Release(rs_blob); + } if (vs.blob) { ID3D10Blob_Release(vs.blob); } @@ -914,7 +975,6 @@ INTERNAL WORK_TASK_FUNC_DEF(pipeline_load_task, load_arg_raw) if (ps.error_blob) { ID3D10Blob_Release(ps.error_blob); } - resource_close(&src_res); } scratch_end(scratch); } @@ -1022,11 +1082,114 @@ struct gpu_handle gpu_dispatch_state_alloc(void) return res; } +#if 0 +void gpu_dispatch(struct gpu_handle gpu_dispatch_state, struct gpu_dispatch_params params, struct gpu_handle gpu_command_list) +{ + (UNUSED)gpu_dispatch_state; + (UNUSED)params; + + struct pipeline_scope *pipeline_scope = pipeline_scope_begin(); + + struct dx12_command_list *command_list = handle_get_data(gpu_command_list, DX12_HANDLE_KIND_COMMAND_LIST); + + /* Texture pass */ + { + struct pipeline *pipeline = dx12_get_pipeline(pipeline_scope, LIT("gpu/texture.hlsl")); + } + + pipeline_scope_end(pipeline_scope); + +#if 0 + __prof; + struct sprite_scope *sprite_scope = sprite_scope_begin(); + struct dx11_dispatch_state *state = (struct dx11_dispatch_state *)gpu_dispatch_state.v; + + struct rect viewport = params.draw_target_viewport; + + /* Set viewport */ + D3D11_VIEWPORT d3d11_viewport = ZI; + d3d11_viewport.Width = viewport.width; + d3d11_viewport.Height = viewport.height; + d3d11_viewport.MinDepth = 0.0f; + d3d11_viewport.MaxDepth = 1.0f; + d3d11_viewport.TopLeftX = viewport.x; + d3d11_viewport.TopLeftY = viewport.y; + ID3D11DeviceContext_RSSetViewports(G.devcon, 1, &d3d11_viewport); + + struct dx12_buffer *final_tex = (struct dx12_buffer *)params.draw_target.v; + struct v2i32 final_tex_size = final_tex->size; + + /* Texture pass */ + { + __profscope(Texture pass); + struct dx11_shader *shader = &G.shaders[DX11_SHADER_KIND_TEXTURE]; + if (shader->valid) { + struct dx12_buffer *texture = NULL; + if (cmd->texture.texture.v) { + /* Load texture if handle is set */ + texture = (struct dx12_buffer *)cmd->texture.texture.v; + } else if (cmd->texture.sprite.hash) { + /* Otherwise load sprite */ + struct sprite_texture *sprite_texture = sprite_texture_from_tag_async(sprite_scope, cmd->texture.sprite); + if (sprite_texture->loaded) { + texture = (struct dx12_buffer *)sprite_texture->texture.v; + } + } + + if (texture && texture->srv) { + struct dx11_buffer *instance_buffer = list->buffers.texture.instance_buffer; + u32 instance_offset = cmd->texture.instance_offset; + u32 instance_count = cmd->texture.instance_count; + + /* Bind shader */ + ID3D11DeviceContext_VSSetShader(G.devcon, shader->vs, 0, 0); + ID3D11DeviceContext_PSSetShader(G.devcon, shader->ps, 0, 0); + + /* Fill & bind constant buffer */ + { + struct dx11_texture_uniform *uniform = dx11_buffer_push(constant_buffer, sizeof(struct dx11_texture_uniform)); + uniform->vp = vp_matrix; + uniform->instance_offset = instance_offset; + dx11_buffer_submit(constant_buffer); + } + ID3D11DeviceContext_VSSetConstantBuffers(G.devcon, 0, 1, &constant_buffer->gpu_buffer); + ID3D11DeviceContext_PSSetConstantBuffers(G.devcon, 0, 1, &constant_buffer->gpu_buffer); + + /* Bind dummy vertex buffer */ + u32 zero = 0; + ID3D11DeviceContext_IASetVertexBuffers(G.devcon, 0, 1, &G.dummy_vertex_buffer->gpu_buffer, &zero, &zero); + ID3D11DeviceContext_IASetIndexBuffer(G.devcon, G.quad_index_buffer->gpu_buffer, DXGI_FORMAT_R16_UINT, zero); + + /* Bind SRVs */ + ID3D11ShaderResourceView *srvs[] = { instance_buffer->srv, texture->srv }; + ID3D11DeviceContext_VSSetShaderResources(G.devcon, 0, ARRAY_COUNT(srvs), srvs); + ID3D11DeviceContext_PSSetShaderResources(G.devcon, 0, ARRAY_COUNT(srvs), srvs); + + /* Bind RTVs */ + ID3D11RenderTargetView *rtvs[] = { final_tex->rtv }; + ID3D11DeviceContext_OMSetRenderTargets(G.devcon, ARRAY_COUNT(rtvs), rtvs, NULL); + + /* Draw */ + ID3D11DeviceContext_IASetPrimitiveTopology(G.devcon, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + ID3D11DeviceContext_DrawIndexedInstanced(G.devcon, 6, instance_count, 0, 0, 0); + + /* Unbind */ + dx11_unbind(DX11_UNBIND_VS | DX11_UNBIND_PS | DX11_UNBIND_CBUFF | DX11_UNBIND_VBUFF | DX11_UNBIND_IBUFF | DX11_UNBIND_SRV | DX11_UNBIND_RTV); + } + } + } + + sprite_scope_end(sprite_scope); +#endif +} +#else void gpu_dispatch(struct gpu_handle gpu_dispatch_state, struct gpu_dispatch_params params) { (UNUSED)gpu_dispatch_state; (UNUSED)params; + (UNUSED)handle_get_data; } +#endif /* ========================== * * Backbuffer @@ -1065,6 +1228,7 @@ void gpu_swap_backbuffer(i32 vsync) + #endif diff --git a/src/user.c b/src/user.c index 937a2384..72020bf3 100644 --- a/src/user.c +++ b/src/user.c @@ -264,10 +264,10 @@ struct user_startup_receipt user_startup(struct work_startup_receipt *work_sr, G.user_dispatch_state = gpu_dispatch_state_alloc(); G.backbuffer_dispatch_state = gpu_dispatch_state_alloc(); - //log_register_callback(debug_console_log_callback, LOG_LEVEL_SUCCESS); - log_register_callback(debug_console_log_callback, LOG_LEVEL_DEBUG); G.console_logs_mutex = sys_mutex_alloc(); G.console_logs_arena = arena_alloc(GIGABYTE(64)); + //log_register_callback(debug_console_log_callback, LOG_LEVEL_SUCCESS); + log_register_callback(debug_console_log_callback, LOG_LEVEL_DEBUG); G.window = window; sys_window_register_event_callback(G.window, &window_event_callback);