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

rename shader handle -> shader ref

Browse Source
This commit is contained in:
jacob 2025-12-09 17:30:27 -06:00
parent 781e6ff75a
commit f773422abf
24 changed files with 231 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
src/base/base.cgh
View File

@ -732,36 +732,36 @@
#define PixelShader(name, return_type, ...) return_type name(__VA_ARGS__) #define PixelShader(name, return_type, ...) return_type name(__VA_ARGS__)
#endif #endif
//- Shader resource handles //- Shader resource references
Enum(ShaderHandleKind) Enum(ShaderRefKind)
{ {
ShaderHandleKind_StructuredBuffer, ShaderRefKind_StructuredBuffer,
ShaderHandleKind_RWStructuredBuffer, ShaderRefKind_RWStructuredBuffer,
ShaderHandleKind_ByteAddressBuffer, ShaderRefKind_ByteAddressBuffer,
ShaderHandleKind_RWByteAddressBuffer, ShaderRefKind_RWByteAddressBuffer,
ShaderHandleKind_Texture1D, ShaderRefKind_Texture1D,
ShaderHandleKind_RWTexture1D, ShaderRefKind_RWTexture1D,
ShaderHandleKind_Texture2D, ShaderRefKind_Texture2D,
ShaderHandleKind_RWTexture2D, ShaderRefKind_RWTexture2D,
ShaderHandleKind_Texture3D, ShaderRefKind_Texture3D,
ShaderHandleKind_RWTexture3D, ShaderRefKind_RWTexture3D,
ShaderHandleKind_SamplerState, ShaderRefKind_SamplerState,
}; };
Struct(StructuredBufferHandle) { u32 v; }; Struct(StructuredBufferRef) { u32 v; };
Struct(RWStructuredBufferHandle) { u32 v; }; Struct(RWStructuredBufferRef) { u32 v; };
Struct(ByteAddressBufferHandle) { u32 v; }; Struct(ByteAddressBufferRef) { u32 v; };
Struct(RWByteAddressBufferHandle) { u32 v; }; Struct(RWByteAddressBufferRef) { u32 v; };
Struct(Texture1DHandle) { u32 v; }; Struct(Texture1DRef) { u32 v; };
Struct(RWTexture1DHandle) { u32 v; }; Struct(RWTexture1DRef) { u32 v; };
Struct(Texture2DHandle) { u32 v; }; Struct(Texture2DRef) { u32 v; };
Struct(RWTexture2DHandle) { u32 v; }; Struct(RWTexture2DRef) { u32 v; };
Struct(Texture3DHandle) { u32 v; }; Struct(Texture3DRef) { u32 v; };
Struct(RWTexture3DHandle) { u32 v; }; Struct(RWTexture3DRef) { u32 v; };
Struct(SamplerStateHandle) { u32 v; }; Struct(SamplerStateRef) { u32 v; };
#define IsShaderHandleNil(h) ((h).v == 0) #define IsShaderRefNil(h) ((h).v == 0)
//- Shader constants //- Shader constants

24
src/base/base_shader.gh
View File

@ -22,26 +22,26 @@ typedef float4 Quad;
typedef float4x4 Mat4x4; typedef float4x4 Mat4x4;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Handle dereference wrappers //~ Dereference
/* TODO: Non-uniform resource access is assumed as the default behavior. We /* TODO: Non-uniform resource access is assumed as the default behavior. We
* may want to add explicit "uniform" variants for optimization on AMD devices * may want to add explicit "uniform" variants for optimization on AMD devices
* in the future. */ * in the future. */
template<typename T> StructuredBuffer<T> StructuredBufferFromHandle(StructuredBufferHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } template<typename T> StructuredBuffer<T> StructuredBufferFromRef(StructuredBufferRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
template<typename T> RWStructuredBuffer<T> RWStructuredBufferFromHandle(RWStructuredBufferHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } template<typename T> RWStructuredBuffer<T> RWStructuredBufferFromRef(RWStructuredBufferRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
ByteAddressBuffer ByteAddressBufferFromHandle(ByteAddressBufferHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } ByteAddressBuffer ByteAddressBufferFromRef(ByteAddressBufferRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
RWByteAddressBuffer RWByteAddressBufferFromHandle(RWByteAddressBufferHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } RWByteAddressBuffer RWByteAddressBufferFromRef(RWByteAddressBufferRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
template<typename T> Texture1D<T> Texture1DFromHandle(Texture1DHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } template<typename T> Texture1D<T> Texture1DFromRef(Texture1DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
template<typename T> Texture3D<T> Texture3DFromHandle(Texture3DHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } template<typename T> Texture3D<T> Texture3DFromRef(Texture3DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
template<typename T> RWTexture1D<T> RWTexture1DFromHandle(RWTexture1DHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } template<typename T> RWTexture1D<T> RWTexture1DFromRef(RWTexture1DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
template<typename T> Texture2D<T> Texture2DFromHandle(Texture2DHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } template<typename T> Texture2D<T> Texture2DFromRef(Texture2DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
template<typename T> RWTexture2D<T> RWTexture2DFromHandle(RWTexture2DHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } template<typename T> RWTexture2D<T> RWTexture2DFromRef(RWTexture2DRef h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; }
template<typename T> RWTexture3D<T> RWTexture3DFromHandle(RWTexture3DHandle h) { return ResourceDescriptorHeap[NonUniformResourceIndex(h.v)]; } template<typename T> RWTexture3D<T> 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 //~ Countof

2
src/glyph_cache/glyph_cache.h
View File

@ -16,7 +16,7 @@ Struct(GC_RunRect)
f32 advance; f32 advance;
Vec2 size; Vec2 size;
Texture2DHandle tex; Texture2DRef tex;
Rng2 uv; Rng2 uv;
}; };

5
src/gpu/gpu.lay
View File

@ -14,11 +14,10 @@
//- Api //- Api
@IncludeC gpu_core.h @IncludeC gpu_core.h
@IncludeC gpu_shader_extras.cgh @IncludeC gpu_shader_core.cgh
@IncludeC gpu_common.h @IncludeC gpu_common.h
@IncludeG gpu_shader_core.gh @IncludeG gpu_shader_core.cgh
@IncludeG gpu_shader_extras.cgh
@Bootstrap GPU_Bootstrap @Bootstrap GPU_Bootstrap
@Bootstrap GPU_BootstrapExtra @Bootstrap GPU_BootstrapExtra

4
src/gpu/gpu_common.c
View File

@ -28,7 +28,7 @@ void GPU_BootstrapExtra(void)
/* Init point sampler */ /* Init point sampler */
{ {
GPU_ResourceHandle pt_sampler = GPU_PushSamplerResource(gpu_perm, (GPU_SamplerResourceDesc) { .filter = GPU_Filter_MinMagMipPoint }); 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 */ /* Init noise texture */
@ -49,7 +49,7 @@ void GPU_BootstrapExtra(void)
noise_data.text, noise_dims, noise_data.text, noise_dims,
RNG3I32(VEC3I32(0, 0, 0), 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);
} }
} }

94
src/gpu/gpu_core.h
View File

@ -428,9 +428,9 @@ Struct(GPU_SamplerResourceDesc)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ GPU pointer types //~ GPU pointer types
Struct(GPU_PointerDesc) Struct(GPU_RefDesc)
{ {
ShaderHandleKind kind; ShaderRefKind kind;
u64 element_size; u64 element_size;
u64 element_offset; u64 element_offset;
@ -576,64 +576,64 @@ i32 GPU_CountDepth(GPU_ResourceHandle texture);
#define GPU_CountBuffer(buffer, type) GPU_CountBufferBytes(buffer) / sizeof(type) #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) { \ #define GPU_PushStructuredBufferRef(arena, resource, type, ...) (StructuredBufferRef) { \
.v = GPU_PushPointer((arena), (resource), \ .v = GPU_PushRef((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_StructuredBuffer, .element_size = sizeof(type), __VA_ARGS__ }) \ (GPU_RefDesc) { .kind = ShaderRefKind_StructuredBuffer, .element_size = sizeof(type), __VA_ARGS__ }) \
} }
#define GPU_PushRWStructuredBufferHandle(arena, resource, type, ...) (RWStructuredBufferHandle) { \ #define GPU_PushRWStructuredBufferRef(arena, resource, type, ...) (RWStructuredBufferRef) { \
.v = GPU_PushPointer((arena), (resource), \ .v = GPU_PushRef((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_RWStructuredBuffer, .element_size = sizeof(type), __VA_ARGS__ }) \ (GPU_RefDesc) { .kind = ShaderRefKind_RWStructuredBuffer, .element_size = sizeof(type), __VA_ARGS__ }) \
}; }
#define GPU_PushByteAddressBufferHandle(arena, resource, ...) (ByteAddressBufferHandle) { \ #define GPU_PushByteAddressBufferRef(arena, resource, ...) (ByteAddressBufferRef) { \
.v = GPU_PushPointer((arena), (resource), \ .v = GPU_PushRef((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_ByteAddressBuffer, __VA_ARGS__ }) \ (GPU_RefDesc) { .kind = ShaderRefKind_ByteAddressBuffer, __VA_ARGS__ }) \
}; }
#define GPU_PushRWByteAddressBufferHandleEx(arena, resource, ...) (RWByteAddressBufferHandle) { \ #define GPU_PushRWByteAddressBufferRef(arena, resource, ...) (RWByteAddressBufferRef) { \
.v = GPU_PushPointer((arena), (resource), \ .v = GPU_PushRef((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_RWByteAddressBuffer, __VA_ARGS__ }) \ (GPU_RefDesc) { .kind = ShaderRefKind_RWByteAddressBuffer, __VA_ARGS__ }) \
}; }
#define GPU_PushTexture1DHandle(arena, resource, ...) (Texture1DHandle) { \ #define GPU_PushTexture1DRef(arena, resource, ...) (Texture1DRef) { \
.v = GPU_PushPointer((arena), (resource), \ .v = GPU_PushRef((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_Texture1D, __VA_ARGS__ }) \ (GPU_RefDesc) { .kind = ShaderRefKind_Texture1D, __VA_ARGS__ }) \
}; }
#define GPU_PushRWTexture1DHandle(arena, resource, ...) (RWTexture1DHandle) { \ #define GPU_PushRWTexture1DRef(arena, resource, ...) (RWTexture1DRef) { \
.v = GPU_PushPointer((arena), (resource), \ .v = GPU_PushRef((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_RWTexture1D, __VA_ARGS__ }) \ (GPU_RefDesc) { .kind = ShaderRefKind_RWTexture1D, __VA_ARGS__ }) \
}; }
#define GPU_PushTexture2DHandle(arena, resource, ...) (Texture2DHandle) { \ #define GPU_PushTexture2DRef(arena, resource, ...) (Texture2DRef) { \
.v = GPU_PushPointer((arena), (resource), \ .v = GPU_PushRef((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_Texture2D, __VA_ARGS__ }) \ (GPU_RefDesc) { .kind = ShaderRefKind_Texture2D, __VA_ARGS__ }) \
}; }
#define GPU_PushRWTexture2DHandle(arena, resource, ...) (RWTexture2DHandle) { \ #define GPU_PushRWTexture2DRef(arena, resource, ...) (RWTexture2DRef) { \
.v = GPU_PushPointer((arena), (resource), \ .v = GPU_PushRef((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_RWTexture2D, __VA_ARGS__ }) \ (GPU_RefDesc) { .kind = ShaderRefKind_RWTexture2D, __VA_ARGS__ }) \
}; }
#define GPU_PushTexture3DHandle(arena, resource, ...) (Texture3DHandle) { \ #define GPU_PushTexture3DRef(arena, resource, ...) (Texture3DRef) { \
.v = GPU_PushPointer((arena), (resource), \ .v = GPU_PushRef((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_Texture3D, __VA_ARGS__ }) \ (GPU_RefDesc) { .kind = ShaderRefKind_Texture3D, __VA_ARGS__ }) \
}; }
#define GPU_PushRWTexture3DHandle(arena, resource, ...) (RWTexture3DHandle) { \ #define GPU_PushRWTexture3DRef(arena, resource, ...) (RWTexture3DRef) { \
.v = GPU_PushPointer((arena), (resource), \ .v = GPU_PushRef((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_RWTexture3D, __VA_ARGS__ }) \ (GPU_RefDesc) { .kind = ShaderRefKind_RWTexture3D, __VA_ARGS__ }) \
}; }
#define GPU_PushSamplerStateHandle(arena, resource, ...) (SamplerStateHandle) { \ #define GPU_PushSamplerStateRef(arena, resource, ...) (SamplerStateRef) { \
.v = GPU_PushPointer((arena), (resource), \ .v = GPU_PushRef((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_SamplerState, __VA_ARGS__ }) \ (GPU_RefDesc) { .kind = ShaderRefKind_SamplerState, __VA_ARGS__ }) \
}; }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ @hookdecl Command //~ @hookdecl Command

1
src/gpu/gpu_dx12/gpu_dx12.lay
View File

@ -7,7 +7,6 @@
@IncludeC gpu_dx12_shader_core.cgh @IncludeC gpu_dx12_shader_core.cgh
@IncludeG gpu_dx12_shader_core.cgh @IncludeG gpu_dx12_shader_core.cgh
@IncludeG gpu_dx12_shader_core.gh
////////////////////////////// //////////////////////////////
//- Impl //- Impl

48
src/gpu/gpu_dx12/gpu_dx12_core.c
View File

@ -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_SharedState *g = &GPU_D12_shared_state;
GPU_D12_Arena *gpu_arena = GPU_D12_ArenaFromHandle(arena_handle); GPU_D12_Arena *gpu_arena = GPU_D12_ArenaFromHandle(arena_handle);
GPU_D12_Resource *resource = GPU_D12_ResourceFromHandle(resource_handle); GPU_D12_Resource *resource = GPU_D12_ResourceFromHandle(resource_handle);
u32 result = 0; u32 result = 0;
ShaderHandleKind kind = pointer_desc.kind; ShaderRefKind kind = ref_desc.kind;
b32 is_buffer = kind == ShaderHandleKind_StructuredBuffer || b32 is_buffer = kind == ShaderRefKind_StructuredBuffer ||
kind == ShaderHandleKind_RWStructuredBuffer || kind == ShaderRefKind_RWStructuredBuffer ||
kind == ShaderHandleKind_ByteAddressBuffer || kind == ShaderRefKind_ByteAddressBuffer ||
kind == ShaderHandleKind_RWByteAddressBuffer; kind == ShaderRefKind_RWByteAddressBuffer;
b32 is_sampler = kind == ShaderHandleKind_SamplerState; b32 is_sampler = kind == ShaderRefKind_SamplerState;
b32 is_texture = !is_buffer && !is_sampler; b32 is_texture = !is_buffer && !is_sampler;
b32 is_raw = kind == ShaderHandleKind_ByteAddressBuffer || b32 is_raw = kind == ShaderRefKind_ByteAddressBuffer ||
kind == ShaderHandleKind_RWByteAddressBuffer; kind == ShaderRefKind_RWByteAddressBuffer;
b32 is_uav = kind == ShaderHandleKind_RWStructuredBuffer || b32 is_uav = kind == ShaderRefKind_RWStructuredBuffer ||
kind == ShaderHandleKind_RWByteAddressBuffer || kind == ShaderRefKind_RWByteAddressBuffer ||
kind == ShaderHandleKind_RWTexture1D || kind == ShaderRefKind_RWTexture1D ||
kind == ShaderHandleKind_RWTexture2D || kind == ShaderRefKind_RWTexture2D ||
kind == ShaderHandleKind_RWTexture3D; kind == ShaderRefKind_RWTexture3D;
GPU_D12_Descriptor *descriptor = 0; GPU_D12_Descriptor *descriptor = 0;
if (is_buffer) 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 buffer_size_aligned = resource->buffer_size_aligned;
u64 num_elements_in_buffer = buffer_size_aligned / pointer_desc.element_size; u64 num_elements_in_buffer = buffer_size_aligned / ref_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_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 (num_elements_after_offset > 0)
{ {
if (is_uav) if (is_uav)
@ -1098,9 +1098,9 @@ u32 GPU_PushPointer(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_ha
{ {
desc.Format = DXGI_FORMAT_UNKNOWN; desc.Format = DXGI_FORMAT_UNKNOWN;
desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER ; 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.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; desc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_NONE;
} }
if (is_raw) if (is_raw)
@ -1117,9 +1117,9 @@ u32 GPU_PushPointer(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_ha
desc.Format = DXGI_FORMAT_UNKNOWN; desc.Format = DXGI_FORMAT_UNKNOWN;
desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER; desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; 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.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; desc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_NONE;
} }
if (is_raw) if (is_raw)
@ -1133,7 +1133,7 @@ u32 GPU_PushPointer(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_ha
} }
else if (is_texture) 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) if (is_uav)
{ {
ID3D12Device_CreateUnorderedAccessView(g->device, resource->d3d_resource, 0, 0, descriptor->handle); 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) 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; GPU_SamplerResourceDesc sampler_desc = resource->sampler_desc;
D3D12_SAMPLER_DESC d3d_desc = ZI; D3D12_SAMPLER_DESC d3d_desc = ZI;
{ {

30
src/gpu/gpu_dx12/gpu_dx12_shader_core.cgh
View File

@ -7,5 +7,33 @@
/* Slots below assume they won't overlap user defined constants */ /* Slots below assume they won't overlap user defined constants */
StaticAssert(NumGeneralPurposeShaderConstants == 8); StaticAssert(NumGeneralPurposeShaderConstants == 8);
ForceShaderConstant(RWByteAddressBufferHandle, GPU_D12_DebugPrintBuff, 8); ForceShaderConstant(RWByteAddressBufferRef, GPU_D12_DebugPrintBuff, 8);
#define GPU_D12_NumShaderConstants (9) #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

26
src/gpu/gpu_dx12/gpu_dx12_shader_core.gh
View File

@ -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

21
src/gpu/gpu_shader_core.cgh Normal file
View File

@ -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

5
src/gpu/gpu_shader_core.gh
View File

@ -1,5 +0,0 @@
////////////////////////////////////////////////////////////
//~ @hookdecl Shader printf
/* Implemented per graphics platform layer */
#define DebugPrint(msg) DebugPrintImpl_(msg)

11
src/gpu/gpu_shader_extras.cgh
View File

@ -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)

8
src/pp/pp_vis/pp_vis_core.c
View File

@ -568,13 +568,13 @@ void V_TickForever(WaveLaneCtx *lane)
GPU_Layout_DirectQueue_ShaderReadWrite, GPU_Layout_DirectQueue_ShaderReadWrite,
.flags = GPU_ResourceFlag_AllowShaderReadWrite | GPU_ResourceFlag_AllowRenderTarget .flags = GPU_ResourceFlag_AllowShaderReadWrite | 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);
RWTexture2DHandle draw_target_rw = GPU_PushRWTexture2DHandle(frame->gpu_arena, draw_target); RWTexture2DRef draw_target_rw = GPU_PushRWTexture2DRef(frame->gpu_arena, draw_target);
/* Verts */ /* Verts */
GPU_ResourceHandle dverts_buff = GPU_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromArena(frame->dverts_arena)); 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)); 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); GPU_IndexBufferDesc dvert_idxs_ib = GPU_IdxBuff32(dvert_idxs_buff);
/* Params */ /* Params */
@ -587,7 +587,7 @@ void V_TickForever(WaveLaneCtx *lane)
params.world_to_draw_xf = world_to_draw_xf; params.world_to_draw_xf = world_to_draw_xf;
} }
GPU_ResourceHandle params_buff = GPU_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromStruct(&params)); GPU_ResourceHandle params_buff = GPU_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromStruct(&params));
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 */ /* Constants */
GPU_SetConstant(frame->cl, V_ShaderConst_Params, params_ro); GPU_SetConstant(frame->cl, V_ShaderConst_Params, params_ro);

10
src/pp/pp_vis/pp_vis_shaders.cgh
View File

@ -1,15 +1,15 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Constant types //~ Constant types
ShaderConstant(StructuredBufferHandle, V_ShaderConst_Params, 0); ShaderConstant(StructuredBufferRef, V_ShaderConst_Params, 0);
Struct(V_DParams) Struct(V_DParams)
{ {
Vec2I32 target_size; Vec2I32 target_size;
Texture2DHandle target_ro; Texture2DRef target_ro;
RWTexture2DHandle target_rw; RWTexture2DRef target_rw;
StructuredBufferHandle quads; StructuredBufferRef quads;
StructuredBufferHandle shape_verts; StructuredBufferRef shape_verts;
Xform world_to_draw_xf; Xform world_to_draw_xf;
}; };

20
src/pp/pp_vis/pp_vis_shaders.g
View File

@ -3,8 +3,8 @@
ComputeShader2D(V_BackdropCS, 8, 8) ComputeShader2D(V_BackdropCS, 8, 8)
{ {
V_DParams params = StructuredBufferFromHandle<V_DParams>(V_ShaderConst_Params)[0]; V_DParams params = StructuredBufferFromRef<V_DParams>(V_ShaderConst_Params)[0];
RWTexture2D<Vec4> target = RWTexture2DFromHandle<Vec4>(params.target_rw); RWTexture2D<Vec4> target = RWTexture2DFromRef<Vec4>(params.target_rw);
Vec2U32 target_pos = SV_DispatchThreadID; Vec2U32 target_pos = SV_DispatchThreadID;
Vec2I32 target_size = params.target_size; Vec2I32 target_size = params.target_size;
@ -23,9 +23,9 @@ ComputeShader2D(V_BackdropCS, 8, 8)
VertexShader(V_DQuadVS, V_DQuadPSInput) VertexShader(V_DQuadVS, V_DQuadPSInput)
{ {
V_DParams params = StructuredBufferFromHandle<V_DParams>(V_ShaderConst_Params)[0]; V_DParams params = StructuredBufferFromRef<V_DParams>(V_ShaderConst_Params)[0];
StructuredBuffer<V_DQuad> quads = StructuredBufferFromHandle<V_DQuad>(params.quads); StructuredBuffer<V_DQuad> quads = StructuredBufferFromRef<V_DQuad>(params.quads);
RWTexture2D<Vec4> target = RWTexture2DFromHandle<Vec4>(params.target_rw); RWTexture2D<Vec4> target = RWTexture2DFromRef<Vec4>(params.target_rw);
V_DQuad quad = quads[SV_InstanceID]; V_DQuad quad = quads[SV_InstanceID];
@ -45,8 +45,8 @@ VertexShader(V_DQuadVS, V_DQuadPSInput)
PixelShader(V_DQuadPS, V_DQuadPSOutput, V_DQuadPSInput input) PixelShader(V_DQuadPS, V_DQuadPSOutput, V_DQuadPSInput input)
{ {
V_DParams params = StructuredBufferFromHandle<V_DParams>(V_ShaderConst_Params)[0]; V_DParams params = StructuredBufferFromRef<V_DParams>(V_ShaderConst_Params)[0];
StructuredBuffer<V_DQuad> quads = StructuredBufferFromHandle<V_DQuad>(params.quads); StructuredBuffer<V_DQuad> quads = StructuredBufferFromRef<V_DQuad>(params.quads);
V_DQuad quad = quads[input.quad_idx]; V_DQuad quad = quads[input.quad_idx];
Vec4 final_color = 0; Vec4 final_color = 0;
@ -64,9 +64,9 @@ PixelShader(V_DQuadPS, V_DQuadPSOutput, V_DQuadPSInput input)
VertexShader(V_DVertVS, V_DVertPSInput) VertexShader(V_DVertVS, V_DVertPSInput)
{ {
V_DParams params = StructuredBufferFromHandle<V_DParams>(V_ShaderConst_Params)[0]; V_DParams params = StructuredBufferFromRef<V_DParams>(V_ShaderConst_Params)[0];
StructuredBuffer<V_DVert> verts = StructuredBufferFromHandle<V_DVert>(params.shape_verts); StructuredBuffer<V_DVert> verts = StructuredBufferFromRef<V_DVert>(params.shape_verts);
RWTexture2D<Vec4> target = RWTexture2DFromHandle<Vec4>(params.target_rw); RWTexture2D<Vec4> target = RWTexture2DFromRef<Vec4>(params.target_rw);
V_DVert vert = verts[SV_VertexID]; V_DVert vert = verts[SV_VertexID];

10
src/proto/proto.c
View File

@ -28,16 +28,18 @@ void PT_RunForever(WaveLaneCtx *lane)
.flags = GPU_ResourceFlag_AllowShaderReadWrite); .flags = GPU_ResourceFlag_AllowShaderReadWrite);
/* Push resource handles */ /* Push resource handles */
Texture2DHandle final_target_rhandle = GPU_PushTexture2DHandle(gpu_frame_arena, final_target); Texture2DRef final_target_rhandle = GPU_PushTexture2DRef(gpu_frame_arena, final_target);
RWTexture2DHandle final_target_rwhandle = GPU_PushRWTexture2DHandle(gpu_frame_arena, final_target); RWTexture2DRef final_target_rwhandle = GPU_PushRWTexture2DRef(gpu_frame_arena, final_target);
/* Prep test pass */ /* Prep test pass */
{ {
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_TestTarget, final_target_rwhandle);
GPU_SetConstant(cl, PT_ShaderConst_TestConst, 3.123); GPU_SetConstant(cl, PT_ShaderConst_TestConst, 3.123);
GPU_SetConstant(cl, PT_ShaderConst_BlitSampler, GPU_GetSharedSPointSampler()); GPU_SetConstant(cl, PT_ShaderConst_BlitSampler, GPU_BasicPointSampler);
GPU_SetConstant(cl, PT_ShaderConst_BlitSrc, final_target_rhandle); GPU_SetConstant(cl, PT_ShaderConst_BlitSrc, final_target_rhandle);
GPU_SetConstant(cl, PT_ShaderConst_NoiseTex, GPU_GetSharedNoise()); GPU_SetConstant(cl, PT_ShaderConst_NoiseTex, GPU_BasicNoiseTexture);
} }
/* Test pass */ /* Test pass */

4
src/proto/proto.lay
View File

@ -17,8 +17,8 @@
////////////////////////////// //////////////////////////////
//- Api //- Api
@IncludeC proto_shaders.h @IncludeC proto_shaders.cgh
@IncludeG proto_shaders.h @IncludeG proto_shaders.cgh
@Bootstrap PT_Bootstrap @Bootstrap PT_Bootstrap

14
src/proto/proto_shaders.cgh
View File

@ -1,13 +1,15 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Constants //~ Constants
ShaderConstant(Texture3DHandle, PT_ShaderConst_NoiseTex, 0); ShaderConstant(Texture3DRef, PT_ShaderConst_NoiseTex, 0);
/* Test shader */ /* Test shader */
ShaderConstant(RWTexture2DHandle, PT_ShaderConst_TestTarget, 1); ShaderConstant(i32, PT_ShaderConst_TestTargetWidth, 1);
ShaderConstant(StructuredBufferHandle, PT_ShaderConst_TestBuff, 2); ShaderConstant(i32, PT_ShaderConst_TestTargetHeight, 2);
ShaderConstant(f32, PT_ShaderConst_TestConst, 3); ShaderConstant(RWTexture2DRef, PT_ShaderConst_TestTarget, 3);
ShaderConstant(StructuredBufferRef, PT_ShaderConst_TestBuff, 4);
ShaderConstant(f32, PT_ShaderConst_TestConst, 5);
/* Blit shader */ /* Blit shader */
ShaderConstant(SamplerStateHandle, PT_ShaderConst_BlitSampler, 4); ShaderConstant(SamplerStateRef, PT_ShaderConst_BlitSampler, 6);
ShaderConstant(Texture2DHandle, PT_ShaderConst_BlitSrc, 5); ShaderConstant(Texture2DRef, PT_ShaderConst_BlitSrc, 7);

12
src/proto/proto_shaders.g
View File

@ -8,10 +8,10 @@ Struct(TestStruct)
ComputeShader2D(PT_TestCS, 8, 8) ComputeShader2D(PT_TestCS, 8, 8)
{ {
StructuredBuffer<TestStruct> sb = StructuredBufferFromHandle<TestStruct>(PT_ShaderConst_TestBuff); StructuredBuffer<TestStruct> sb = StructuredBufferFromRef<TestStruct>(PT_ShaderConst_TestBuff);
RWTexture2D<Vec4> target_tex = RWTexture2DFromHandle<Vec4>(PT_ShaderConst_TestTarget); RWTexture2D<Vec4> target_tex = RWTexture2DFromRef<Vec4>(PT_ShaderConst_TestTarget);
Vec2U32 target_tex_size = Count2D(target_tex); Vec2U32 target_tex_size = Vec2(PT_ShaderConst_TestTargetWidth, PT_ShaderConst_TestTargetHeight );
Vec2I32 id = SV_DispatchThreadID; Vec2I32 id = SV_DispatchThreadID;
if (id.x < target_tex_size.x && id.y < target_tex_size.y) 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) PixelShader(PT_BlitPS, PT_BlitPSOutput, PT_BlitPSInput input)
{ {
SamplerState sampler = SamplerStateFromHandle(PT_ShaderConst_BlitSampler); SamplerState sampler = SamplerStateFromRef(PT_ShaderConst_BlitSampler);
Texture2D<Vec4> tex = Texture2DFromHandle<Vec4>(PT_ShaderConst_BlitSrc); Texture2D<Vec4> tex = Texture2DFromRef<Vec4>(PT_ShaderConst_BlitSrc);
Texture3D<u32> noise = Texture3DFromHandle<u32>(PT_ShaderConst_NoiseTex); Texture3D<u32> noise = Texture3DFromRef<u32>(PT_ShaderConst_NoiseTex);
Vec2 uv = input.src_uv; Vec2 uv = input.src_uv;
Vec4 tex_col = tex.Sample(sampler, uv); Vec4 tex_col = tex.Sample(sampler, uv);

8
src/ui/ui_core.c
View File

@ -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_Frame *frame = UI_CurrentFrame();
UI_CmdNode *n = PushStruct(frame->arena, UI_CmdNode); UI_CmdNode *n = PushStruct(frame->arena, UI_CmdNode);
@ -1378,11 +1378,11 @@ void UI_EndFrame(UI_Frame *frame)
GPU_Layout_DirectQueue_RenderTargetWrite, GPU_Layout_DirectQueue_RenderTargetWrite,
.flags = GPU_ResourceFlag_AllowRenderTarget .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 */ /* Rects */
GPU_ResourceHandle rects_buff = GPU_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromArena(frame->rects_arena)); 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 */ /* Params */
UI_DParams params = ZI; UI_DParams params = ZI;
@ -1392,7 +1392,7 @@ void UI_EndFrame(UI_Frame *frame)
params.rects = rects_ro; params.rects = rects_ro;
} }
GPU_ResourceHandle params_buff = GPU_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromStruct(&params)); GPU_ResourceHandle params_buff = GPU_PushBufferFromCpu(frame->gpu_arena, frame->cl, StringFromStruct(&params));
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 */ /* Constants */
GPU_SetConstant(frame->cl, UI_ShaderConst_Params, params_ro); GPU_SetConstant(frame->cl, UI_ShaderConst_Params, params_ro);

8
src/ui/ui_core.h
View File

@ -109,7 +109,7 @@ Enum(UI_BoxFlag)
X(Font, GC_FontKey) \ X(Font, GC_FontKey) \
X(FontSize, u32) \ X(FontSize, u32) \
X(Text, String) \ X(Text, String) \
X(BackgroundTexture, Texture2DHandle) \ X(BackgroundTexture, Texture2DRef) \
X(BackgroundTextureUv0, Vec2) \ X(BackgroundTextureUv0, Vec2) \
X(BackgroundTextureUv1, Vec2) \ X(BackgroundTextureUv1, Vec2) \
/* --------------------------------------- */ \ /* --------------------------------------- */ \
@ -232,7 +232,7 @@ Struct(UI_Cmd)
struct struct
{ {
UI_Key key; UI_Key key;
Texture2DHandle tex; Texture2DRef tex;
Vec2 uv0; Vec2 uv0;
Vec2 uv1; Vec2 uv1;
} set_raw_texture; } set_raw_texture;
@ -268,7 +268,7 @@ Struct(UI_Box)
//- Cmd data //- Cmd data
UI_BoxDesc desc; UI_BoxDesc desc;
Texture2DHandle raw_texture; Texture2DRef raw_texture;
Vec2 raw_texture_uv0; Vec2 raw_texture_uv0;
Vec2 raw_texture_uv1; Vec2 raw_texture_uv1;
@ -443,7 +443,7 @@ UI_Style UI_PopStyle(UI_StyleDesc desc);
UI_Key UI_BuildBoxEx(UI_Key key); UI_Key UI_BuildBoxEx(UI_Key key);
#define UI_BuildBox() UI_BuildBoxEx(UI_TransKey()) #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 //~ Report

8
src/ui/ui_shaders.cgh
View File

@ -1,14 +1,14 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Constant types //~ Constant types
ShaderConstant(StructuredBufferHandle, UI_ShaderConst_Params, 0); ShaderConstant(StructuredBufferRef, UI_ShaderConst_Params, 0);
ShaderConstant(b32, UI_ShaderConst_DebugDraw, 1); ShaderConstant(b32, UI_ShaderConst_DebugDraw, 1);
Struct(UI_DParams) Struct(UI_DParams)
{ {
Vec2I32 target_size; Vec2I32 target_size;
Texture2DHandle target_ro; Texture2DRef target_ro;
StructuredBufferHandle rects; StructuredBufferRef rects;
}; };
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
@ -25,7 +25,7 @@ Struct(UI_DRect)
f32 border; f32 border;
Vec2 tex_uv0; Vec2 tex_uv0;
Vec2 tex_uv1; Vec2 tex_uv1;
Texture2DHandle tex; Texture2DRef tex;
f32 tl_rounding; f32 tl_rounding;
f32 tr_rounding; f32 tr_rounding;

20
src/ui/ui_shaders.g
View File

@ -6,8 +6,8 @@
VertexShader(UI_DRectVS, UI_DRectPSInput) VertexShader(UI_DRectVS, UI_DRectPSInput)
{ {
UI_DParams params = StructuredBufferFromHandle<UI_DParams>(UI_ShaderConst_Params)[0]; UI_DParams params = StructuredBufferFromRef<UI_DParams>(UI_ShaderConst_Params)[0];
StructuredBuffer<UI_DRect> rects = StructuredBufferFromHandle<UI_DRect>(params.rects); StructuredBuffer<UI_DRect> rects = StructuredBufferFromRef<UI_DRect>(params.rects);
UI_DRect rect = rects[SV_InstanceID]; UI_DRect rect = rects[SV_InstanceID];
Vec2 rect_uv = RectUvFromVertexId(SV_VertexID); Vec2 rect_uv = RectUvFromVertexId(SV_VertexID);
@ -31,9 +31,9 @@ VertexShader(UI_DRectVS, UI_DRectPSInput)
PixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input) PixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input)
{ {
UI_DParams params = StructuredBufferFromHandle<UI_DParams>(UI_ShaderConst_Params)[0]; UI_DParams params = StructuredBufferFromRef<UI_DParams>(UI_ShaderConst_Params)[0];
StructuredBuffer<UI_DRect> rects = StructuredBufferFromHandle<UI_DRect>(params.rects); StructuredBuffer<UI_DRect> rects = StructuredBufferFromRef<UI_DRect>(params.rects);
SamplerState sampler = SamplerStateFromHandle(GPU_BasicPointSampler); SamplerState sampler = SamplerStateFromRef(GPU_BasicPointSampler);
UI_DRect rect = rects[input.rect_idx]; UI_DRect rect = rects[input.rect_idx];
@ -91,9 +91,9 @@ PixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input)
{ {
background_color = border_color; background_color = border_color;
} }
else if (!IsShaderHandleNil(rect.tex)) else if (!IsShaderRefNil(rect.tex))
{ {
Texture2D<Vec4> tex = Texture2DFromHandle<Vec4>(rect.tex); Texture2D<Vec4> tex = Texture2DFromRef<Vec4>(rect.tex);
background_color = tex.Sample(sampler, input.tex_uv); background_color = tex.Sample(sampler, input.tex_uv);
} }
else else
@ -138,9 +138,9 @@ VertexShader(UI_BlitVS, UI_BlitPSInput)
PixelShader(UI_BlitPS, UI_BlitPSOutput, UI_BlitPSInput input) PixelShader(UI_BlitPS, UI_BlitPSOutput, UI_BlitPSInput input)
{ {
UI_DParams params = StructuredBufferFromHandle<UI_DParams>(UI_ShaderConst_Params)[0]; UI_DParams params = StructuredBufferFromRef<UI_DParams>(UI_ShaderConst_Params)[0];
Texture2D<Vec4> tex = Texture2DFromHandle<Vec4>(params.target_ro); Texture2D<Vec4> tex = Texture2DFromRef<Vec4>(params.target_ro);
SamplerState sampler = SamplerStateFromHandle(GPU_BasicPointSampler); SamplerState sampler = SamplerStateFromRef(GPU_BasicPointSampler);
Vec2 uv = input.src_uv; Vec2 uv = input.src_uv;
Vec4 result = tex.Sample(sampler, uv); Vec4 result = tex.Sample(sampler, uv);