diff --git a/src/base/base.cgh b/src/base/base.cgh index 278a425e..09698c05 100644 --- a/src/base/base.cgh +++ b/src/base/base.cgh @@ -732,36 +732,36 @@ #define PixelShader(name, return_type, ...) return_type name(__VA_ARGS__) #endif -//- Shader resource handles +//- Shader resource references -Enum(ShaderHandleKind) +Enum(ShaderRefKind) { - ShaderHandleKind_StructuredBuffer, - ShaderHandleKind_RWStructuredBuffer, - ShaderHandleKind_ByteAddressBuffer, - ShaderHandleKind_RWByteAddressBuffer, - ShaderHandleKind_Texture1D, - ShaderHandleKind_RWTexture1D, - ShaderHandleKind_Texture2D, - ShaderHandleKind_RWTexture2D, - ShaderHandleKind_Texture3D, - ShaderHandleKind_RWTexture3D, - ShaderHandleKind_SamplerState, + ShaderRefKind_StructuredBuffer, + ShaderRefKind_RWStructuredBuffer, + ShaderRefKind_ByteAddressBuffer, + ShaderRefKind_RWByteAddressBuffer, + ShaderRefKind_Texture1D, + ShaderRefKind_RWTexture1D, + ShaderRefKind_Texture2D, + ShaderRefKind_RWTexture2D, + ShaderRefKind_Texture3D, + ShaderRefKind_RWTexture3D, + ShaderRefKind_SamplerState, }; -Struct(StructuredBufferHandle) { u32 v; }; -Struct(RWStructuredBufferHandle) { u32 v; }; -Struct(ByteAddressBufferHandle) { u32 v; }; -Struct(RWByteAddressBufferHandle) { u32 v; }; -Struct(Texture1DHandle) { u32 v; }; -Struct(RWTexture1DHandle) { u32 v; }; -Struct(Texture2DHandle) { u32 v; }; -Struct(RWTexture2DHandle) { u32 v; }; -Struct(Texture3DHandle) { u32 v; }; -Struct(RWTexture3DHandle) { u32 v; }; -Struct(SamplerStateHandle) { u32 v; }; +Struct(StructuredBufferRef) { u32 v; }; +Struct(RWStructuredBufferRef) { u32 v; }; +Struct(ByteAddressBufferRef) { u32 v; }; +Struct(RWByteAddressBufferRef) { u32 v; }; +Struct(Texture1DRef) { u32 v; }; +Struct(RWTexture1DRef) { u32 v; }; +Struct(Texture2DRef) { u32 v; }; +Struct(RWTexture2DRef) { u32 v; }; +Struct(Texture3DRef) { u32 v; }; +Struct(RWTexture3DRef) { u32 v; }; +Struct(SamplerStateRef) { u32 v; }; -#define IsShaderHandleNil(h) ((h).v == 0) +#define IsShaderRefNil(h) ((h).v == 0) //- Shader constants diff --git a/src/base/base_shader.gh b/src/base/base_shader.gh index 2d88d81a..5fb1e48e 100644 --- a/src/base/base_shader.gh +++ b/src/base/base_shader.gh @@ -22,26 +22,26 @@ typedef float4 Quad; typedef float4x4 Mat4x4; //////////////////////////////////////////////////////////// -//~ Handle dereference wrappers +//~ Dereference /* TODO: Non-uniform resource access is assumed as the default behavior. We * may want to add explicit "uniform" variants for optimization on AMD devices * in the future. */ -template StructuredBuffer StructuredBufferFromHandle(StructuredBufferHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } -template RWStructuredBuffer RWStructuredBufferFromHandle(RWStructuredBufferHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } +template StructuredBuffer StructuredBufferFromRef(StructuredBufferRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } +template RWStructuredBuffer RWStructuredBufferFromRef(RWStructuredBufferRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } -ByteAddressBuffer ByteAddressBufferFromHandle(ByteAddressBufferHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } -RWByteAddressBuffer RWByteAddressBufferFromHandle(RWByteAddressBufferHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } +ByteAddressBuffer ByteAddressBufferFromRef(ByteAddressBufferRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } +RWByteAddressBuffer RWByteAddressBufferFromRef(RWByteAddressBufferRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } -template Texture1D Texture1DFromHandle(Texture1DHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } -template Texture3D Texture3DFromHandle(Texture3DHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } -template RWTexture1D RWTexture1DFromHandle(RWTexture1DHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } -template Texture2D Texture2DFromHandle(Texture2DHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } -template RWTexture2D RWTexture2DFromHandle(RWTexture2DHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } -template RWTexture3D RWTexture3DFromHandle(RWTexture3DHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } +template Texture1D Texture1DFromRef(Texture1DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } +template Texture3D Texture3DFromRef(Texture3DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } +template RWTexture1D RWTexture1DFromRef(RWTexture1DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } +template Texture2D Texture2DFromRef(Texture2DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } +template RWTexture2D RWTexture2DFromRef(RWTexture2DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } +template RWTexture3D RWTexture3DFromRef(RWTexture3DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } -SamplerState SamplerStateFromHandle(SamplerStateHandle h) { return SamplerDescriptorHeap[NonUniformResourceIndex(h.v)]; } +SamplerState SamplerStateFromRef(SamplerStateRef h) { return SamplerDescriptorHeap[NonUniformResourceIndex(h.v)]; } //////////////////////////////////////////////////////////// //~ Countof diff --git a/src/glyph_cache/glyph_cache.h b/src/glyph_cache/glyph_cache.h index 328a429d..249ef94b 100644 --- a/src/glyph_cache/glyph_cache.h +++ b/src/glyph_cache/glyph_cache.h @@ -16,7 +16,7 @@ Struct(GC_RunRect) f32 advance; Vec2 size; - Texture2DHandle tex; + Texture2DRef tex; Rng2 uv; }; diff --git a/src/gpu/gpu.lay b/src/gpu/gpu.lay index bdb5daee..afd4c075 100644 --- a/src/gpu/gpu.lay +++ b/src/gpu/gpu.lay @@ -14,11 +14,10 @@ //- Api @IncludeC gpu_core.h -@IncludeC gpu_shader_extras.cgh +@IncludeC gpu_shader_core.cgh @IncludeC gpu_common.h -@IncludeG gpu_shader_core.gh -@IncludeG gpu_shader_extras.cgh +@IncludeG gpu_shader_core.cgh @Bootstrap GPU_Bootstrap @Bootstrap GPU_BootstrapExtra diff --git a/src/gpu/gpu_common.c b/src/gpu/gpu_common.c index 9cafcce7..3b5998ad 100644 --- a/src/gpu/gpu_common.c +++ b/src/gpu/gpu_common.c @@ -28,7 +28,7 @@ void GPU_BootstrapExtra(void) /* Init point sampler */ { GPU_ResourceHandle pt_sampler = GPU_PushSamplerResource(gpu_perm, (GPU_SamplerResourceDesc) { .filter = GPU_Filter_MinMagMipPoint }); - GPU_PushSamplerStateHandle(gpu_perm, pt_sampler, .forced = GPU_BasicPointSampler.v); + GPU_PushSamplerStateRef(gpu_perm, pt_sampler, .forced = GPU_BasicPointSampler.v); } /* Init noise texture */ @@ -49,7 +49,7 @@ void GPU_BootstrapExtra(void) noise_data.text, noise_dims, RNG3I32(VEC3I32(0, 0, 0), noise_dims)); - GPU_PushTexture3DHandle(gpu_perm, noise_tex, .forced = GPU_BasicNoiseTexture.v); + GPU_PushTexture3DRef(gpu_perm, noise_tex, .forced = GPU_BasicNoiseTexture.v); } } diff --git a/src/gpu/gpu_core.h b/src/gpu/gpu_core.h index 3f6a8882..a8c7b308 100644 --- a/src/gpu/gpu_core.h +++ b/src/gpu/gpu_core.h @@ -428,9 +428,9 @@ Struct(GPU_SamplerResourceDesc) //////////////////////////////////////////////////////////// //~ GPU pointer types -Struct(GPU_PointerDesc) +Struct(GPU_RefDesc) { - ShaderHandleKind kind; + ShaderRefKind kind; u64 element_size; u64 element_offset; @@ -576,64 +576,64 @@ i32 GPU_CountDepth(GPU_ResourceHandle texture); #define GPU_CountBuffer(buffer, type) GPU_CountBufferBytes(buffer) / sizeof(type) //////////////////////////////////////////////////////////// -//~ @hookdecl Shader-accessible pointer +//~ @hookdecl Shader resource references -u32 GPU_PushPointer(GPU_ArenaHandle arena, GPU_ResourceHandle resource, GPU_PointerDesc desc); +u32 GPU_PushRef(GPU_ArenaHandle arena, GPU_ResourceHandle resource, GPU_RefDesc desc); -#define GPU_PushStructuredBufferHandle(arena, resource, type, ...) (StructuredBufferHandle) { \ - .v = GPU_PushPointer((arena), (resource), \ - (GPU_PointerDesc) { .kind = ShaderHandleKind_StructuredBuffer, .element_size = sizeof(type), __VA_ARGS__ }) \ +#define GPU_PushStructuredBufferRef(arena, resource, type, ...) (StructuredBufferRef) { \ + .v = GPU_PushRef((arena), (resource), \ + (GPU_RefDesc) { .kind = ShaderRefKind_StructuredBuffer, .element_size = sizeof(type), __VA_ARGS__ }) \ } -#define GPU_PushRWStructuredBufferHandle(arena, resource, type, ...) (RWStructuredBufferHandle) { \ - .v = GPU_PushPointer((arena), (resource), \ - (GPU_PointerDesc) { .kind = ShaderHandleKind_RWStructuredBuffer, .element_size = sizeof(type), __VA_ARGS__ }) \ - }; +#define GPU_PushRWStructuredBufferRef(arena, resource, type, ...) (RWStructuredBufferRef) { \ + .v = GPU_PushRef((arena), (resource), \ + (GPU_RefDesc) { .kind = ShaderRefKind_RWStructuredBuffer, .element_size = sizeof(type), __VA_ARGS__ }) \ + } -#define GPU_PushByteAddressBufferHandle(arena, resource, ...) (ByteAddressBufferHandle) { \ - .v = GPU_PushPointer((arena), (resource), \ - (GPU_PointerDesc) { .kind = ShaderHandleKind_ByteAddressBuffer, __VA_ARGS__ }) \ - }; +#define GPU_PushByteAddressBufferRef(arena, resource, ...) (ByteAddressBufferRef) { \ + .v = GPU_PushRef((arena), (resource), \ + (GPU_RefDesc) { .kind = ShaderRefKind_ByteAddressBuffer, __VA_ARGS__ }) \ + } -#define GPU_PushRWByteAddressBufferHandleEx(arena, resource, ...) (RWByteAddressBufferHandle) { \ - .v = GPU_PushPointer((arena), (resource), \ - (GPU_PointerDesc) { .kind = ShaderHandleKind_RWByteAddressBuffer, __VA_ARGS__ }) \ - }; +#define GPU_PushRWByteAddressBufferRef(arena, resource, ...) (RWByteAddressBufferRef) { \ + .v = GPU_PushRef((arena), (resource), \ + (GPU_RefDesc) { .kind = ShaderRefKind_RWByteAddressBuffer, __VA_ARGS__ }) \ + } -#define GPU_PushTexture1DHandle(arena, resource, ...) (Texture1DHandle) { \ - .v = GPU_PushPointer((arena), (resource), \ - (GPU_PointerDesc) { .kind = ShaderHandleKind_Texture1D, __VA_ARGS__ }) \ - }; +#define GPU_PushTexture1DRef(arena, resource, ...) (Texture1DRef) { \ + .v = GPU_PushRef((arena), (resource), \ + (GPU_RefDesc) { .kind = ShaderRefKind_Texture1D, __VA_ARGS__ }) \ + } -#define GPU_PushRWTexture1DHandle(arena, resource, ...) (RWTexture1DHandle) { \ - .v = GPU_PushPointer((arena), (resource), \ - (GPU_PointerDesc) { .kind = ShaderHandleKind_RWTexture1D, __VA_ARGS__ }) \ - }; +#define GPU_PushRWTexture1DRef(arena, resource, ...) (RWTexture1DRef) { \ + .v = GPU_PushRef((arena), (resource), \ + (GPU_RefDesc) { .kind = ShaderRefKind_RWTexture1D, __VA_ARGS__ }) \ + } -#define GPU_PushTexture2DHandle(arena, resource, ...) (Texture2DHandle) { \ - .v = GPU_PushPointer((arena), (resource), \ - (GPU_PointerDesc) { .kind = ShaderHandleKind_Texture2D, __VA_ARGS__ }) \ - }; +#define GPU_PushTexture2DRef(arena, resource, ...) (Texture2DRef) { \ + .v = GPU_PushRef((arena), (resource), \ + (GPU_RefDesc) { .kind = ShaderRefKind_Texture2D, __VA_ARGS__ }) \ + } -#define GPU_PushRWTexture2DHandle(arena, resource, ...) (RWTexture2DHandle) { \ - .v = GPU_PushPointer((arena), (resource), \ - (GPU_PointerDesc) { .kind = ShaderHandleKind_RWTexture2D, __VA_ARGS__ }) \ - }; +#define GPU_PushRWTexture2DRef(arena, resource, ...) (RWTexture2DRef) { \ + .v = GPU_PushRef((arena), (resource), \ + (GPU_RefDesc) { .kind = ShaderRefKind_RWTexture2D, __VA_ARGS__ }) \ + } -#define GPU_PushTexture3DHandle(arena, resource, ...) (Texture3DHandle) { \ - .v = GPU_PushPointer((arena), (resource), \ - (GPU_PointerDesc) { .kind = ShaderHandleKind_Texture3D, __VA_ARGS__ }) \ - }; +#define GPU_PushTexture3DRef(arena, resource, ...) (Texture3DRef) { \ + .v = GPU_PushRef((arena), (resource), \ + (GPU_RefDesc) { .kind = ShaderRefKind_Texture3D, __VA_ARGS__ }) \ + } -#define GPU_PushRWTexture3DHandle(arena, resource, ...) (RWTexture3DHandle) { \ - .v = GPU_PushPointer((arena), (resource), \ - (GPU_PointerDesc) { .kind = ShaderHandleKind_RWTexture3D, __VA_ARGS__ }) \ - }; +#define GPU_PushRWTexture3DRef(arena, resource, ...) (RWTexture3DRef) { \ + .v = GPU_PushRef((arena), (resource), \ + (GPU_RefDesc) { .kind = ShaderRefKind_RWTexture3D, __VA_ARGS__ }) \ + } -#define GPU_PushSamplerStateHandle(arena, resource, ...) (SamplerStateHandle) { \ - .v = GPU_PushPointer((arena), (resource), \ - (GPU_PointerDesc) { .kind = ShaderHandleKind_SamplerState, __VA_ARGS__ }) \ - }; +#define GPU_PushSamplerStateRef(arena, resource, ...) (SamplerStateRef) { \ + .v = GPU_PushRef((arena), (resource), \ + (GPU_RefDesc) { .kind = ShaderRefKind_SamplerState, __VA_ARGS__ }) \ + } //////////////////////////////////////////////////////////// //~ @hookdecl Command diff --git a/src/gpu/gpu_dx12/gpu_dx12.lay b/src/gpu/gpu_dx12/gpu_dx12.lay index 0ac35ec4..a7006d0a 100644 --- a/src/gpu/gpu_dx12/gpu_dx12.lay +++ b/src/gpu/gpu_dx12/gpu_dx12.lay @@ -7,7 +7,6 @@ @IncludeC gpu_dx12_shader_core.cgh @IncludeG gpu_dx12_shader_core.cgh -@IncludeG gpu_dx12_shader_core.gh ////////////////////////////// //- Impl diff --git a/src/gpu/gpu_dx12/gpu_dx12_core.c b/src/gpu/gpu_dx12/gpu_dx12_core.c index be7fced1..d0c0680a 100644 --- a/src/gpu/gpu_dx12/gpu_dx12_core.c +++ b/src/gpu/gpu_dx12/gpu_dx12_core.c @@ -1052,44 +1052,44 @@ GPU_ResourceHandle GPU_PushSamplerResource(GPU_ArenaHandle arena_handle, GPU_Sam } //////////////////////////////////////////////////////////// -//~ @hookimpl Shader-accessible pointer +//~ @hookimpl Shader resource references -u32 GPU_PushPointer(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle, GPU_PointerDesc pointer_desc) +u32 GPU_PushRef(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle, GPU_RefDesc ref_desc) { GPU_D12_SharedState *g = &GPU_D12_shared_state; GPU_D12_Arena *gpu_arena = GPU_D12_ArenaFromHandle(arena_handle); GPU_D12_Resource *resource = GPU_D12_ResourceFromHandle(resource_handle); u32 result = 0; - ShaderHandleKind kind = pointer_desc.kind; + ShaderRefKind kind = ref_desc.kind; - b32 is_buffer = kind == ShaderHandleKind_StructuredBuffer || - kind == ShaderHandleKind_RWStructuredBuffer || - kind == ShaderHandleKind_ByteAddressBuffer || - kind == ShaderHandleKind_RWByteAddressBuffer; + b32 is_buffer = kind == ShaderRefKind_StructuredBuffer || + kind == ShaderRefKind_RWStructuredBuffer || + kind == ShaderRefKind_ByteAddressBuffer || + kind == ShaderRefKind_RWByteAddressBuffer; - b32 is_sampler = kind == ShaderHandleKind_SamplerState; + b32 is_sampler = kind == ShaderRefKind_SamplerState; b32 is_texture = !is_buffer && !is_sampler; - b32 is_raw = kind == ShaderHandleKind_ByteAddressBuffer || - kind == ShaderHandleKind_RWByteAddressBuffer; + b32 is_raw = kind == ShaderRefKind_ByteAddressBuffer || + kind == ShaderRefKind_RWByteAddressBuffer; - b32 is_uav = kind == ShaderHandleKind_RWStructuredBuffer || - kind == ShaderHandleKind_RWByteAddressBuffer || - kind == ShaderHandleKind_RWTexture1D || - kind == ShaderHandleKind_RWTexture2D || - kind == ShaderHandleKind_RWTexture3D; + b32 is_uav = kind == ShaderRefKind_RWStructuredBuffer || + kind == ShaderRefKind_RWByteAddressBuffer || + kind == ShaderRefKind_RWTexture1D || + kind == ShaderRefKind_RWTexture2D || + kind == ShaderRefKind_RWTexture3D; GPU_D12_Descriptor *descriptor = 0; if (is_buffer) { - descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav, pointer_desc.forced); + descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav, ref_desc.forced); u64 buffer_size_aligned = resource->buffer_size_aligned; - u64 num_elements_in_buffer = buffer_size_aligned / pointer_desc.element_size; - u64 num_elements_after_offset = num_elements_in_buffer > pointer_desc.element_offset ? num_elements_in_buffer - pointer_desc.element_offset : 0; + u64 num_elements_in_buffer = buffer_size_aligned / ref_desc.element_size; + u64 num_elements_after_offset = num_elements_in_buffer > ref_desc.element_offset ? num_elements_in_buffer - ref_desc.element_offset : 0; if (num_elements_after_offset > 0) { if (is_uav) @@ -1098,9 +1098,9 @@ u32 GPU_PushPointer(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_ha { desc.Format = DXGI_FORMAT_UNKNOWN; desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER ; - desc.Buffer.FirstElement = pointer_desc.element_offset; + desc.Buffer.FirstElement = ref_desc.element_offset; desc.Buffer.NumElements = num_elements_after_offset; - desc.Buffer.StructureByteStride = pointer_desc.element_size; + desc.Buffer.StructureByteStride = ref_desc.element_size; desc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_NONE; } if (is_raw) @@ -1117,9 +1117,9 @@ u32 GPU_PushPointer(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_ha desc.Format = DXGI_FORMAT_UNKNOWN; desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER; desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; - desc.Buffer.FirstElement = pointer_desc.element_offset; + desc.Buffer.FirstElement = ref_desc.element_offset; desc.Buffer.NumElements = num_elements_after_offset; - desc.Buffer.StructureByteStride = pointer_desc.element_size; + desc.Buffer.StructureByteStride = ref_desc.element_size; desc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_NONE; } if (is_raw) @@ -1133,7 +1133,7 @@ u32 GPU_PushPointer(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_ha } else if (is_texture) { - descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav, pointer_desc.forced); + descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav, ref_desc.forced); if (is_uav) { ID3D12Device_CreateUnorderedAccessView(g->device, resource->d3d_resource, 0, 0, descriptor->handle); @@ -1145,7 +1145,7 @@ u32 GPU_PushPointer(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_ha } else if (is_sampler) { - descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_Sampler, pointer_desc.forced); + descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_Sampler, ref_desc.forced); GPU_SamplerResourceDesc sampler_desc = resource->sampler_desc; D3D12_SAMPLER_DESC d3d_desc = ZI; { diff --git a/src/gpu/gpu_dx12/gpu_dx12_shader_core.cgh b/src/gpu/gpu_dx12/gpu_dx12_shader_core.cgh index 8012f11f..8734436a 100644 --- a/src/gpu/gpu_dx12/gpu_dx12_shader_core.cgh +++ b/src/gpu/gpu_dx12/gpu_dx12_shader_core.cgh @@ -7,5 +7,33 @@ /* Slots below assume they won't overlap user defined constants */ StaticAssert(NumGeneralPurposeShaderConstants == 8); -ForceShaderConstant(RWByteAddressBufferHandle, GPU_D12_DebugPrintBuff, 8); +ForceShaderConstant(RWByteAddressBufferRef, GPU_D12_DebugPrintBuff, 8); #define GPU_D12_NumShaderConstants (9) + +//////////////////////////////////////////////////////////// +//~ @hookimpl Shader printf + +#if IsLanguageG + + /* This technique comes from MJP's article: https://therealmjp.github.io/posts/hlsl-printf/ */ + #if GPU_DEBUG + #define DebugPrintImpl_(fmt_cstr) do { \ + u32 __strlen = 0; \ + for (;;) { if (U32FromChar(fmt_cstr[__strlen]) == 0) { break; } ++__strlen; } \ + RWByteAddressBuffer __print_buff; \ + __print_buff = RWByteAddressBufferFromRef(GPU_D12_DebugPrintBuff); \ + u32 __pos; \ + __print_buff.InterlockedAdd(0, __strlen, __pos); \ + if (__pos < countof(__print_buff)) \ + { \ + for (u32 char_idx = 0; char_idx < __strlen; ++char_idx) \ + { \ + __print_buff.Store(__pos + char_idx, U32FromChar(fmt_cstr[char_idx])); \ + } \ + } \ + } while (0) + #else + #define DebugPrintImpl_(fmt_cstr) + #endif + +#endif diff --git a/src/gpu/gpu_dx12/gpu_dx12_shader_core.gh b/src/gpu/gpu_dx12/gpu_dx12_shader_core.gh deleted file mode 100644 index 055fcb9a..00000000 --- a/src/gpu/gpu_dx12/gpu_dx12_shader_core.gh +++ /dev/null @@ -1,26 +0,0 @@ -//////////////////////////////////////////////////////////// -//~ Debug types - -//////////////////////////////////////////////////////////// -//~ @hookimpl Shader printf - -/* This technique comes from MJP's article: https://therealmjp.github.io/posts/hlsl-printf/ */ -#if GPU_DEBUG - #define DebugPrintImpl_(fmt_cstr) do { \ - u32 __strlen = 0; \ - for (;;) { if (U32FromChar(fmt_cstr[__strlen]) == 0) { break; } ++__strlen; } \ - RWByteAddressBuffer __print_buff; \ - __print_buff = RWByteAddressBufferFromHandle(GPU_D12_DebugPrintBuff); \ - u32 __pos; \ - __print_buff.InterlockedAdd(0, __strlen, __pos); \ - if (__pos < countof(__print_buff)) \ - { \ - for (u32 char_idx = 0; char_idx < __strlen; ++char_idx) \ - { \ - __print_buff.Store(__pos + char_idx, U32FromChar(fmt_cstr[char_idx])); \ - } \ - } \ - } while (0) -#else - #define DebugPrintImpl_(fmt_cstr) -#endif diff --git a/src/gpu/gpu_shader_core.cgh b/src/gpu/gpu_shader_core.cgh new file mode 100644 index 00000000..5b9a273c --- /dev/null +++ b/src/gpu/gpu_shader_core.cgh @@ -0,0 +1,21 @@ +//////////////////////////////////////////////////////////// +//~ Shared static handles (common resources available to all shaders) + +#if IsLanguageC + #define GPU_SharedRef(type, v) ((type) { (v) }) +#elif IsLanguageG + #define GPU_SharedRef(type, v) (type(v)) +#endif + +#define GPU_BasicPointSampler GPU_SharedRef(SamplerStateRef, 1) +#define GPU_BasicNoiseTexture GPU_SharedRef(Texture3DRef, 2) + +//////////////////////////////////////////////////////////// +//~ @hookdecl Shader printf + +#if IsLanguageG + + /* Implemented per graphics platform layer */ + #define DebugPrint(msg) DebugPrintImpl_(msg) + +#endif diff --git a/src/gpu/gpu_shader_core.gh b/src/gpu/gpu_shader_core.gh deleted file mode 100644 index e1f71d05..00000000 --- a/src/gpu/gpu_shader_core.gh +++ /dev/null @@ -1,5 +0,0 @@ -//////////////////////////////////////////////////////////// -//~ @hookdecl Shader printf - -/* Implemented per graphics platform layer */ -#define DebugPrint(msg) DebugPrintImpl_(msg) diff --git a/src/gpu/gpu_shader_extras.cgh b/src/gpu/gpu_shader_extras.cgh deleted file mode 100644 index 2547c107..00000000 --- a/src/gpu/gpu_shader_extras.cgh +++ /dev/null @@ -1,11 +0,0 @@ -//////////////////////////////////////////////////////////// -//~ Shared static handles (common resources available to all shaders) - -#if IsLanguageC - #define GPU_SharedHandle(type, v) ((type) { (v) }) -#elif IsLanguageG - #define GPU_SharedHandle(type, v) (type(v)) -#endif - -#define GPU_BasicPointSampler GPU_SharedHandle(SamplerStateHandle, 1) -#define GPU_BasicNoiseTexture GPU_SharedHandle(Texture3DHandle, 2) diff --git a/src/pp/pp_vis/pp_vis_core.c b/src/pp/pp_vis/pp_vis_core.c index 56f9be90..39e92488 100644 --- a/src/pp/pp_vis/pp_vis_core.c +++ b/src/pp/pp_vis/pp_vis_core.c @@ -568,13 +568,13 @@ void V_TickForever(WaveLaneCtx *lane) GPU_Layout_DirectQueue_ShaderReadWrite, .flags = GPU_ResourceFlag_AllowShaderReadWrite | GPU_ResourceFlag_AllowRenderTarget ); - Texture2DHandle draw_target_ro = GPU_PushTexture2DHandle(frame->gpu_arena, draw_target); - RWTexture2DHandle draw_target_rw = GPU_PushRWTexture2DHandle(frame->gpu_arena, draw_target); + Texture2DRef draw_target_ro = GPU_PushTexture2DRef(frame->gpu_arena, draw_target); + RWTexture2DRef draw_target_rw = GPU_PushRWTexture2DRef(frame->gpu_arena, draw_target); /* Verts */ GPU_ResourceHandle dverts_buff = GPU_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromArena(frame->dverts_arena)); GPU_ResourceHandle dvert_idxs_buff = GPU_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromArena(frame->dvert_idxs_arena)); - StructuredBufferHandle dverts_ro = GPU_PushStructuredBufferHandle(frame->gpu_arena, dverts_buff, V_DVert); + StructuredBufferRef dverts_ro = GPU_PushStructuredBufferRef(frame->gpu_arena, dverts_buff, V_DVert); GPU_IndexBufferDesc dvert_idxs_ib = GPU_IdxBuff32(dvert_idxs_buff); /* Params */ @@ -587,7 +587,7 @@ void V_TickForever(WaveLaneCtx *lane) params.world_to_draw_xf = world_to_draw_xf; } GPU_ResourceHandle params_buff = GPU_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromStruct(¶ms)); - StructuredBufferHandle params_ro = GPU_PushStructuredBufferHandle(frame->gpu_arena, params_buff, V_DParams); + StructuredBufferRef params_ro = GPU_PushStructuredBufferRef(frame->gpu_arena, params_buff, V_DParams); /* Constants */ GPU_SetConstant(frame->cl, V_ShaderConst_Params, params_ro); diff --git a/src/pp/pp_vis/pp_vis_shaders.cgh b/src/pp/pp_vis/pp_vis_shaders.cgh index b7ce8f0e..26ea5191 100644 --- a/src/pp/pp_vis/pp_vis_shaders.cgh +++ b/src/pp/pp_vis/pp_vis_shaders.cgh @@ -1,15 +1,15 @@ //////////////////////////////////////////////////////////// //~ Constant types -ShaderConstant(StructuredBufferHandle, V_ShaderConst_Params, 0); +ShaderConstant(StructuredBufferRef, V_ShaderConst_Params, 0); Struct(V_DParams) { Vec2I32 target_size; - Texture2DHandle target_ro; - RWTexture2DHandle target_rw; - StructuredBufferHandle quads; - StructuredBufferHandle shape_verts; + Texture2DRef target_ro; + RWTexture2DRef target_rw; + StructuredBufferRef quads; + StructuredBufferRef shape_verts; Xform world_to_draw_xf; }; diff --git a/src/pp/pp_vis/pp_vis_shaders.g b/src/pp/pp_vis/pp_vis_shaders.g index 7a936cf3..d7edb46d 100644 --- a/src/pp/pp_vis/pp_vis_shaders.g +++ b/src/pp/pp_vis/pp_vis_shaders.g @@ -3,8 +3,8 @@ ComputeShader2D(V_BackdropCS, 8, 8) { - V_DParams params = StructuredBufferFromHandle(V_ShaderConst_Params)[0]; - RWTexture2D target = RWTexture2DFromHandle(params.target_rw); + V_DParams params = StructuredBufferFromRef(V_ShaderConst_Params)[0]; + RWTexture2D target = RWTexture2DFromRef(params.target_rw); Vec2U32 target_pos = SV_DispatchThreadID; Vec2I32 target_size = params.target_size; @@ -23,9 +23,9 @@ ComputeShader2D(V_BackdropCS, 8, 8) VertexShader(V_DQuadVS, V_DQuadPSInput) { - V_DParams params = StructuredBufferFromHandle(V_ShaderConst_Params)[0]; - StructuredBuffer quads = StructuredBufferFromHandle(params.quads); - RWTexture2D target = RWTexture2DFromHandle(params.target_rw); + V_DParams params = StructuredBufferFromRef(V_ShaderConst_Params)[0]; + StructuredBuffer quads = StructuredBufferFromRef(params.quads); + RWTexture2D target = RWTexture2DFromRef(params.target_rw); V_DQuad quad = quads[SV_InstanceID]; @@ -45,8 +45,8 @@ VertexShader(V_DQuadVS, V_DQuadPSInput) PixelShader(V_DQuadPS, V_DQuadPSOutput, V_DQuadPSInput input) { - V_DParams params = StructuredBufferFromHandle(V_ShaderConst_Params)[0]; - StructuredBuffer quads = StructuredBufferFromHandle(params.quads); + V_DParams params = StructuredBufferFromRef(V_ShaderConst_Params)[0]; + StructuredBuffer quads = StructuredBufferFromRef(params.quads); V_DQuad quad = quads[input.quad_idx]; Vec4 final_color = 0; @@ -64,9 +64,9 @@ PixelShader(V_DQuadPS, V_DQuadPSOutput, V_DQuadPSInput input) VertexShader(V_DVertVS, V_DVertPSInput) { - V_DParams params = StructuredBufferFromHandle(V_ShaderConst_Params)[0]; - StructuredBuffer verts = StructuredBufferFromHandle(params.shape_verts); - RWTexture2D target = RWTexture2DFromHandle(params.target_rw); + V_DParams params = StructuredBufferFromRef(V_ShaderConst_Params)[0]; + StructuredBuffer verts = StructuredBufferFromRef(params.shape_verts); + RWTexture2D target = RWTexture2DFromRef(params.target_rw); V_DVert vert = verts[SV_VertexID]; diff --git a/src/proto/proto.c b/src/proto/proto.c index 1ed90e65..86a2e33f 100644 --- a/src/proto/proto.c +++ b/src/proto/proto.c @@ -28,16 +28,18 @@ void PT_RunForever(WaveLaneCtx *lane) .flags = GPU_ResourceFlag_AllowShaderReadWrite); /* Push resource handles */ - Texture2DHandle final_target_rhandle = GPU_PushTexture2DHandle(gpu_frame_arena, final_target); - RWTexture2DHandle final_target_rwhandle = GPU_PushRWTexture2DHandle(gpu_frame_arena, final_target); + Texture2DRef final_target_rhandle = GPU_PushTexture2DRef(gpu_frame_arena, final_target); + RWTexture2DRef final_target_rwhandle = GPU_PushRWTexture2DRef(gpu_frame_arena, final_target); /* Prep test pass */ { - GPU_SetConstant(cl, PT_ShaderConst_TestTarget, final_target_rwhandle); - GPU_SetConstant(cl, PT_ShaderConst_TestConst, 3.123); - GPU_SetConstant(cl, PT_ShaderConst_BlitSampler, GPU_GetSharedSPointSampler()); - GPU_SetConstant(cl, PT_ShaderConst_BlitSrc, final_target_rhandle); - GPU_SetConstant(cl, PT_ShaderConst_NoiseTex, GPU_GetSharedNoise()); + GPU_SetConstant(cl, PT_ShaderConst_TestTargetWidth, final_target_size.x); + GPU_SetConstant(cl, PT_ShaderConst_TestTargetHeight, final_target_size.y); + GPU_SetConstant(cl, PT_ShaderConst_TestTarget, final_target_rwhandle); + GPU_SetConstant(cl, PT_ShaderConst_TestConst, 3.123); + GPU_SetConstant(cl, PT_ShaderConst_BlitSampler, GPU_BasicPointSampler); + GPU_SetConstant(cl, PT_ShaderConst_BlitSrc, final_target_rhandle); + GPU_SetConstant(cl, PT_ShaderConst_NoiseTex, GPU_BasicNoiseTexture); } /* Test pass */ diff --git a/src/proto/proto.lay b/src/proto/proto.lay index 51787ee6..e0b47ff3 100644 --- a/src/proto/proto.lay +++ b/src/proto/proto.lay @@ -17,8 +17,8 @@ ////////////////////////////// //- Api -@IncludeC proto_shaders.h -@IncludeG proto_shaders.h +@IncludeC proto_shaders.cgh +@IncludeG proto_shaders.cgh @Bootstrap PT_Bootstrap diff --git a/src/proto/proto_shaders.cgh b/src/proto/proto_shaders.cgh index 1d5c0fca..3b864469 100644 --- a/src/proto/proto_shaders.cgh +++ b/src/proto/proto_shaders.cgh @@ -1,13 +1,15 @@ //////////////////////////////////////////////////////////// //~ Constants -ShaderConstant(Texture3DHandle, PT_ShaderConst_NoiseTex, 0); +ShaderConstant(Texture3DRef, PT_ShaderConst_NoiseTex, 0); /* Test shader */ -ShaderConstant(RWTexture2DHandle, PT_ShaderConst_TestTarget, 1); -ShaderConstant(StructuredBufferHandle, PT_ShaderConst_TestBuff, 2); -ShaderConstant(f32, PT_ShaderConst_TestConst, 3); +ShaderConstant(i32, PT_ShaderConst_TestTargetWidth, 1); +ShaderConstant(i32, PT_ShaderConst_TestTargetHeight, 2); +ShaderConstant(RWTexture2DRef, PT_ShaderConst_TestTarget, 3); +ShaderConstant(StructuredBufferRef, PT_ShaderConst_TestBuff, 4); +ShaderConstant(f32, PT_ShaderConst_TestConst, 5); /* Blit shader */ -ShaderConstant(SamplerStateHandle, PT_ShaderConst_BlitSampler, 4); -ShaderConstant(Texture2DHandle, PT_ShaderConst_BlitSrc, 5); +ShaderConstant(SamplerStateRef, PT_ShaderConst_BlitSampler, 6); +ShaderConstant(Texture2DRef, PT_ShaderConst_BlitSrc, 7); diff --git a/src/proto/proto_shaders.g b/src/proto/proto_shaders.g index bd4bc4e0..c4963411 100644 --- a/src/proto/proto_shaders.g +++ b/src/proto/proto_shaders.g @@ -8,10 +8,10 @@ Struct(TestStruct) ComputeShader2D(PT_TestCS, 8, 8) { - StructuredBuffer sb = StructuredBufferFromHandle(PT_ShaderConst_TestBuff); + StructuredBuffer sb = StructuredBufferFromRef(PT_ShaderConst_TestBuff); - RWTexture2D target_tex = RWTexture2DFromHandle(PT_ShaderConst_TestTarget); - Vec2U32 target_tex_size = Count2D(target_tex); + RWTexture2D target_tex = RWTexture2DFromRef(PT_ShaderConst_TestTarget); + Vec2U32 target_tex_size = Vec2(PT_ShaderConst_TestTargetWidth, PT_ShaderConst_TestTargetHeight ); Vec2I32 id = SV_DispatchThreadID; if (id.x < target_tex_size.x && id.y < target_tex_size.y) @@ -51,9 +51,9 @@ VertexShader(PT_BlitVS, PT_BlitPSInput) PixelShader(PT_BlitPS, PT_BlitPSOutput, PT_BlitPSInput input) { - SamplerState sampler = SamplerStateFromHandle(PT_ShaderConst_BlitSampler); - Texture2D tex = Texture2DFromHandle(PT_ShaderConst_BlitSrc); - Texture3D noise = Texture3DFromHandle(PT_ShaderConst_NoiseTex); + SamplerState sampler = SamplerStateFromRef(PT_ShaderConst_BlitSampler); + Texture2D tex = Texture2DFromRef(PT_ShaderConst_BlitSrc); + Texture3D noise = Texture3DFromRef(PT_ShaderConst_NoiseTex); Vec2 uv = input.src_uv; Vec4 tex_col = tex.Sample(sampler, uv); diff --git a/src/ui/ui_core.c b/src/ui/ui_core.c index a10c4a26..26ccfafa 100644 --- a/src/ui/ui_core.c +++ b/src/ui/ui_core.c @@ -406,7 +406,7 @@ UI_Key UI_BuildBoxEx(UI_Key key) } -void UI_SetRawTexture(UI_Key key, Texture2DHandle tex, Vec2 uv0, Vec2 uv1) +void UI_SetRawTexture(UI_Key key, Texture2DRef tex, Vec2 uv0, Vec2 uv1) { UI_Frame *frame = UI_CurrentFrame(); UI_CmdNode *n = PushStruct(frame->arena, UI_CmdNode); @@ -1378,11 +1378,11 @@ void UI_EndFrame(UI_Frame *frame) GPU_Layout_DirectQueue_RenderTargetWrite, .flags = GPU_ResourceFlag_AllowRenderTarget ); - Texture2DHandle draw_target_ro = GPU_PushTexture2DHandle(frame->gpu_arena, draw_target); + Texture2DRef draw_target_ro = GPU_PushTexture2DRef(frame->gpu_arena, draw_target); /* Rects */ GPU_ResourceHandle rects_buff = GPU_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromArena(frame->rects_arena)); - StructuredBufferHandle rects_ro = GPU_PushStructuredBufferHandle(frame->gpu_arena, rects_buff, UI_DRect); + StructuredBufferRef rects_ro = GPU_PushStructuredBufferRef(frame->gpu_arena, rects_buff, UI_DRect); /* Params */ UI_DParams params = ZI; @@ -1392,7 +1392,7 @@ void UI_EndFrame(UI_Frame *frame) params.rects = rects_ro; } GPU_ResourceHandle params_buff = GPU_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromStruct(¶ms)); - StructuredBufferHandle params_ro = GPU_PushStructuredBufferHandle(frame->gpu_arena, params_buff, UI_DParams); + StructuredBufferRef params_ro = GPU_PushStructuredBufferRef(frame->gpu_arena, params_buff, UI_DParams); /* Constants */ GPU_SetConstant(frame->cl, UI_ShaderConst_Params, params_ro); diff --git a/src/ui/ui_core.h b/src/ui/ui_core.h index 4d80c112..7b523643 100644 --- a/src/ui/ui_core.h +++ b/src/ui/ui_core.h @@ -109,7 +109,7 @@ Enum(UI_BoxFlag) X(Font, GC_FontKey) \ X(FontSize, u32) \ X(Text, String) \ - X(BackgroundTexture, Texture2DHandle) \ + X(BackgroundTexture, Texture2DRef) \ X(BackgroundTextureUv0, Vec2) \ X(BackgroundTextureUv1, Vec2) \ /* --------------------------------------- */ \ @@ -232,7 +232,7 @@ Struct(UI_Cmd) struct { UI_Key key; - Texture2DHandle tex; + Texture2DRef tex; Vec2 uv0; Vec2 uv1; } set_raw_texture; @@ -268,7 +268,7 @@ Struct(UI_Box) //- Cmd data UI_BoxDesc desc; - Texture2DHandle raw_texture; + Texture2DRef raw_texture; Vec2 raw_texture_uv0; Vec2 raw_texture_uv1; @@ -443,7 +443,7 @@ UI_Style UI_PopStyle(UI_StyleDesc desc); UI_Key UI_BuildBoxEx(UI_Key key); #define UI_BuildBox() UI_BuildBoxEx(UI_TransKey()) -void UI_SetRawTexture(UI_Key key, Texture2DHandle tex, Vec2 uv0, Vec2 uv1); +void UI_SetRawTexture(UI_Key key, Texture2DRef tex, Vec2 uv0, Vec2 uv1); //////////////////////////////////////////////////////////// //~ Report diff --git a/src/ui/ui_shaders.cgh b/src/ui/ui_shaders.cgh index 501fb450..7e689145 100644 --- a/src/ui/ui_shaders.cgh +++ b/src/ui/ui_shaders.cgh @@ -1,14 +1,14 @@ //////////////////////////////////////////////////////////// //~ Constant types -ShaderConstant(StructuredBufferHandle, UI_ShaderConst_Params, 0); -ShaderConstant(b32, UI_ShaderConst_DebugDraw, 1); +ShaderConstant(StructuredBufferRef, UI_ShaderConst_Params, 0); +ShaderConstant(b32, UI_ShaderConst_DebugDraw, 1); Struct(UI_DParams) { - Vec2I32 target_size; - Texture2DHandle target_ro; - StructuredBufferHandle rects; + Vec2I32 target_size; + Texture2DRef target_ro; + StructuredBufferRef rects; }; //////////////////////////////////////////////////////////// @@ -25,7 +25,7 @@ Struct(UI_DRect) f32 border; Vec2 tex_uv0; Vec2 tex_uv1; - Texture2DHandle tex; + Texture2DRef tex; f32 tl_rounding; f32 tr_rounding; diff --git a/src/ui/ui_shaders.g b/src/ui/ui_shaders.g index d9db300a..3623505a 100644 --- a/src/ui/ui_shaders.g +++ b/src/ui/ui_shaders.g @@ -6,8 +6,8 @@ VertexShader(UI_DRectVS, UI_DRectPSInput) { - UI_DParams params = StructuredBufferFromHandle(UI_ShaderConst_Params)[0]; - StructuredBuffer rects = StructuredBufferFromHandle(params.rects); + UI_DParams params = StructuredBufferFromRef(UI_ShaderConst_Params)[0]; + StructuredBuffer rects = StructuredBufferFromRef(params.rects); UI_DRect rect = rects[SV_InstanceID]; Vec2 rect_uv = RectUvFromVertexId(SV_VertexID); @@ -31,9 +31,9 @@ VertexShader(UI_DRectVS, UI_DRectPSInput) PixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input) { - UI_DParams params = StructuredBufferFromHandle(UI_ShaderConst_Params)[0]; - StructuredBuffer rects = StructuredBufferFromHandle(params.rects); - SamplerState sampler = SamplerStateFromHandle(GPU_BasicPointSampler); + UI_DParams params = StructuredBufferFromRef(UI_ShaderConst_Params)[0]; + StructuredBuffer rects = StructuredBufferFromRef(params.rects); + SamplerState sampler = SamplerStateFromRef(GPU_BasicPointSampler); UI_DRect rect = rects[input.rect_idx]; @@ -91,9 +91,9 @@ PixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input) { background_color = border_color; } - else if (!IsShaderHandleNil(rect.tex)) + else if (!IsShaderRefNil(rect.tex)) { - Texture2D tex = Texture2DFromHandle(rect.tex); + Texture2D tex = Texture2DFromRef(rect.tex); background_color = tex.Sample(sampler, input.tex_uv); } else @@ -138,9 +138,9 @@ VertexShader(UI_BlitVS, UI_BlitPSInput) PixelShader(UI_BlitPS, UI_BlitPSOutput, UI_BlitPSInput input) { - UI_DParams params = StructuredBufferFromHandle(UI_ShaderConst_Params)[0]; - Texture2D tex = Texture2DFromHandle(params.target_ro); - SamplerState sampler = SamplerStateFromHandle(GPU_BasicPointSampler); + UI_DParams params = StructuredBufferFromRef(UI_ShaderConst_Params)[0]; + Texture2D tex = Texture2DFromRef(params.target_ro); + SamplerState sampler = SamplerStateFromRef(GPU_BasicPointSampler); Vec2 uv = input.src_uv; Vec4 result = tex.Sample(sampler, uv);