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

compile-time shader resource handles

Browse Source
This commit is contained in:
jacob 2025-12-08 18:47:28 -06:00
parent 3e722bb982
commit 9772e4ce4c
16 changed files with 348 additions and 325 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/base/base.h
View File

@ -728,6 +728,21 @@
//- Shader resource handles //- Shader resource handles
Enum(ShaderHandleKind)
{
ShaderHandleKind_StructuredBuffer,
ShaderHandleKind_RWStructuredBuffer,
ShaderHandleKind_ByteAddressBuffer,
ShaderHandleKind_RWByteAddressBuffer,
ShaderHandleKind_Texture1D,
ShaderHandleKind_RWTexture1D,
ShaderHandleKind_Texture2D,
ShaderHandleKind_RWTexture2D,
ShaderHandleKind_Texture3D,
ShaderHandleKind_RWTexture3D,
ShaderHandleKind_SamplerState,
};
Struct(StructuredBufferHandle) { u32 v; }; Struct(StructuredBufferHandle) { u32 v; };
Struct(RWStructuredBufferHandle) { u32 v; }; Struct(RWStructuredBufferHandle) { u32 v; };
Struct(ByteAddressBufferHandle) { u32 v; }; Struct(ByteAddressBufferHandle) { u32 v; };
@ -739,7 +754,8 @@ Struct(RWTexture2DHandle) { u32 v; };
Struct(Texture3DHandle) { u32 v; }; Struct(Texture3DHandle) { u32 v; };
Struct(RWTexture3DHandle) { u32 v; }; Struct(RWTexture3DHandle) { u32 v; };
Struct(SamplerStateHandle) { u32 v; }; Struct(SamplerStateHandle) { u32 v; };
#define IsGpuHandleNil(h) ((h).v == 0)
#define IsShaderHandleNil(h) ((h).v == 0)
//- Shader constants //- Shader constants

4
src/base/base_arena.h
View File

@ -57,8 +57,8 @@ void *ResetArena(Arena *arena);
#define PopStructsNoCopy(a, type, n) PopBytesNoCopy((a), sizeof(type) * (n)) #define PopStructsNoCopy(a, type, n) PopBytesNoCopy((a), sizeof(type) * (n))
#define PopStructNoCopy(a, type) PopStructsNoCopy((a), type, 1) #define PopStructNoCopy(a, type) PopStructsNoCopy((a), type, 1)
#define ArenaFirst(arena, type) (type *)ArenaFirst_((arena), alignof(type)) #define ArenaFirst(arena, type) ((type *)ArenaFirst_((arena), alignof(type)))
#define ArenaNext(arena, type) (type *)ArenaNext_((arena), alignof(type)) #define ArenaNext(arena, type) ((type *)ArenaNext_((arena), alignof(type)))
#define ArenaCount(arena, type) ((arena)->pos / sizeof(type)) #define ArenaCount(arena, type) ((arena)->pos / sizeof(type))
void *PushBytesNoZero(Arena *arena, u64 size, u64 align); void *PushBytesNoZero(Arena *arena, u64 size, u64 align);

4
src/gpu/gpu.lay
View File

@ -6,11 +6,11 @@
//- Api //- Api
@IncludeC gpu_core.h @IncludeC gpu_core.h
@IncludeC gpu_shader_extras.h @IncludeC gpu_shader_extras.h
@IncludeC gpu_extras.h @IncludeC gpu_common.h
@IncludeGpu gpu_shader_extras.h @IncludeGpu gpu_shader_extras.h
//- Impl //- Impl
@IncludeC gpu_extras.c @IncludeC gpu_common.c
@IncludeGpu gpu_shader_extras.hlsl @IncludeGpu gpu_shader_extras.hlsl
//- Dx12 impl //- Dx12 impl

42
src/gpu/gpu_extras.c → src/gpu/gpu_common.c
View File

@ -10,23 +10,22 @@ void GPU_StartupExtra(void)
GPU_ArenaHandle gpu_perm = GPU_PermArena(); GPU_ArenaHandle gpu_perm = GPU_PermArena();
/* Init point sampler */
{
GPU_ResourceHandle pt_sampler = GPU_PushSampler(gpu_perm, (GPU_SamplerDesc) { .filter = GPU_Filter_MinMagMipPoint });
g->pt_sampler = GPU_PushSamplerStateHandle(gpu_perm, pt_sampler);
}
GPU_CommandListHandle cl = GPU_PrepareCommandList(GPU_QueueKind_Direct); GPU_CommandListHandle cl = GPU_PrepareCommandList(GPU_QueueKind_Direct);
{ {
/* Init quad index buffer */ /* Init quad index buffer */
GPU_ResourceHandle quad_indices = ZI;
{ {
u16 quad_data[6] = { 0, 1, 2, 0, 2, 3 }; u16 quad_data[6] = { 0, 1, 2, 0, 2, 3 };
GPU_ResourceHandle quad_indices = GPU_PushBuffer(gpu_perm, u16, countof(quad_data)); quad_indices = GPU_PushBuffer(gpu_perm, u16, countof(quad_data));
GPU_CopyCpuToBuffer(cl, quad_indices, 0, quad_data, RNGU64(0, sizeof(quad_data))); GPU_CopyCpuToBuffer(cl, quad_indices, 0, quad_data, RNGU64(0, sizeof(quad_data)));
g->quad_indices = GPU_IdxBuff16(quad_indices);
} }
g->quad_indices = GPU_IdxBuff16(quad_indices);
/* TODO: Init noise texture */ /* Init point sampler */
GPU_ResourceHandle pt_sampler = GPU_PushSamplerResource(gpu_perm, (GPU_SamplerResourceDesc) { .filter = GPU_Filter_MinMagMipPoint });
/* Init noise texture */
GPU_ResourceHandle noise_tex = ZI;
{ {
String noise_data = DataFromResource(ResourceKeyFromStore(&GPU_Resources, Lit("noise_128x128x64_16.dat"))); String noise_data = DataFromResource(ResourceKeyFromStore(&GPU_Resources, Lit("noise_128x128x64_16.dat")));
Vec3I32 noise_dims = VEC3I32(128, 128, 64); Vec3I32 noise_dims = VEC3I32(128, 128, 64);
@ -34,16 +33,19 @@ void GPU_StartupExtra(void)
{ {
Panic(Lit("Unexpected noise texture size")); Panic(Lit("Unexpected noise texture size"));
} }
GPU_ResourceHandle noise_tex = GPU_PushTexture3D(gpu_perm, noise_tex = GPU_PushTexture3D(gpu_perm,
GPU_Format_R16_Uint, GPU_Format_R16_Uint,
noise_dims, noise_dims,
GPU_Layout_AnyQueue_ShaderRead_CopyRead_CopyWrite_Present); GPU_Layout_AnyQueue_ShaderRead_CopyRead_CopyWrite_Present);
GPU_CopyCpuToTexture(cl, GPU_CopyCpuToTexture(cl,
noise_tex, VEC3I32(0, 0, 0), noise_tex, VEC3I32(0, 0, 0),
noise_data.text, noise_dims, noise_data.text, noise_dims,
RNG3I32(VEC3I32(0, 0, 0), noise_dims)); RNG3I32(VEC3I32(0, 0, 0), noise_dims));
g->noise_tex = GPU_PushTexture3DHandle(gpu_perm, noise_tex);
} }
/* Initialize static shader handles */
GPU_PushSamplerStateHandle(gpu_perm, pt_sampler, .forced = GPU_BasicPointSampler.v);
GPU_PushTexture3DHandle(gpu_perm, noise_tex, .forced = GPU_BasicNoiseTexture.v);
} }
GPU_CommitCommandList(cl); GPU_CommitCommandList(cl);
@ -70,7 +72,7 @@ GPU_ArenaHandle GPU_PermArena(void)
GPU_ResourceHandle GPU_PushBufferFromCpu(GPU_ArenaHandle gpu_arena, GPU_CommandListHandle cl, String src) GPU_ResourceHandle GPU_PushBufferFromCpu(GPU_ArenaHandle gpu_arena, GPU_CommandListHandle cl, String src)
{ {
GPU_ResourceHandle buffer = GPU_PushBufferEx(gpu_arena, (GPU_BufferDesc) { .size = src.len }); GPU_ResourceHandle buffer = GPU_PushBufferResource(gpu_arena, (GPU_BufferResourceDesc) { .size = src.len });
GPU_CopyCpuToBuffer(cl, buffer, 0, src.text, RNGU64(0, src.len)); GPU_CopyCpuToBuffer(cl, buffer, 0, src.text, RNGU64(0, src.len));
GPU_MemorySync( GPU_MemorySync(
cl, buffer, cl, buffer,
@ -96,17 +98,7 @@ Rng2 GPU_ScissorFromTexture(GPU_ResourceHandle texture)
//- Shared resources //- Shared resources
SamplerStateHandle GPU_GetSharedPointSampler(void)
{
return GPU_shared_util_state.pt_sampler;
}
GPU_IndexBufferDesc GPU_GetSharedQuadIndices(void) GPU_IndexBufferDesc GPU_GetSharedQuadIndices(void)
{ {
return GPU_shared_util_state.quad_indices; return GPU_shared_util_state.quad_indices;
} }
Texture3DHandle GPU_GetSharedNoise(void)
{
return GPU_shared_util_state.noise_tex;
}

4
src/gpu/gpu_extras.h → src/gpu/gpu_common.h
View File

@ -4,9 +4,7 @@
Struct(GPU_SharedUtilState) Struct(GPU_SharedUtilState)
{ {
/* Common shared resources */ /* Common shared resources */
SamplerStateHandle pt_sampler;
GPU_IndexBufferDesc quad_indices; GPU_IndexBufferDesc quad_indices;
Texture3DHandle noise_tex;
} extern GPU_shared_util_state; } extern GPU_shared_util_state;
extern ThreadLocal GPU_ArenaHandle GPU_t_perm_arena; extern ThreadLocal GPU_ArenaHandle GPU_t_perm_arena;
@ -34,6 +32,4 @@ Rng2 GPU_ScissorFromTexture(GPU_ResourceHandle texture);
//- Shared resources //- Shared resources
SamplerStateHandle GPU_GetSharedPointSampler(void);
GPU_IndexBufferDesc GPU_GetSharedQuadIndices(void); GPU_IndexBufferDesc GPU_GetSharedQuadIndices(void);
Texture3DHandle GPU_GetSharedNoise(void);

177
src/gpu/gpu_core.h
View File

@ -303,7 +303,7 @@ Enum(GPU_ResourceFlag)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Buffer types //~ Buffer types
Struct(GPU_BufferDesc) Struct(GPU_BufferResourceDesc)
{ {
u64 size; u64 size;
GPU_ResourceFlag flags; GPU_ResourceFlag flags;
@ -321,7 +321,7 @@ Enum(GPU_TextureKind)
GPU_TextureKind_3D, GPU_TextureKind_3D,
}; };
Struct(GPU_TextureDesc) Struct(GPU_TextureResourceDesc)
{ {
GPU_TextureKind kind; GPU_TextureKind kind;
GPU_ResourceFlag flags; GPU_ResourceFlag flags;
@ -411,7 +411,7 @@ Enum(GPU_ComparisonFunc)
GPU_ComparisonFunc_Always = 8 GPU_ComparisonFunc_Always = 8
}; };
Struct(GPU_SamplerDesc) Struct(GPU_SamplerResourceDesc)
{ {
GPU_Filter filter; GPU_Filter filter;
GPU_AddressMode x; GPU_AddressMode x;
@ -425,6 +425,23 @@ Struct(GPU_SamplerDesc)
f32 max_lod; f32 max_lod;
}; };
////////////////////////////////////////////////////////////
//~ GPU pointer types
Struct(GPU_PointerDesc)
{
ShaderHandleKind kind;
u64 element_size;
u64 element_offset;
/* If set, then the shader-visible pointer will attempt to allocate the
* pointer in the specified slot. This position can only be allocated to
* once globally. Any subsequent static allocations to the same slot will
* cause a panic. 0 will result in a regular dynamic shader-visible pointer.
*/
u32 forced;
};
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Rasterization types //~ Rasterization types
@ -500,68 +517,48 @@ void GPU_ReleaseArena(GPU_ArenaHandle arena);
//- Resource creation //- Resource creation
GPU_ResourceHandle GPU_PushBufferEx(GPU_ArenaHandle arena, GPU_BufferDesc desc); GPU_ResourceHandle GPU_PushBufferResource(GPU_ArenaHandle arena, GPU_BufferResourceDesc desc);
GPU_ResourceHandle GPU_PushTextureEx(GPU_ArenaHandle arena, GPU_TextureDesc desc); GPU_ResourceHandle GPU_PushTextureResource(GPU_ArenaHandle arena, GPU_TextureResourceDesc desc);
GPU_ResourceHandle GPU_PushSampler(GPU_ArenaHandle arena, GPU_SamplerDesc desc); GPU_ResourceHandle GPU_PushSamplerResource(GPU_ArenaHandle arena, GPU_SamplerResourceDesc desc);
#define GPU_PushBuffer(arena, type, count, ...) GPU_PushBufferEx((arena), \ #define GPU_PushBuffer(arena, type, count, ...) GPU_PushBufferResource((arena), \
(GPU_BufferDesc) { \ (GPU_BufferResourceDesc) { \
.size = sizeof(type) * (count), \ .size = sizeof(type) * (count), \
__VA_ARGS__ \ __VA_ARGS__ \
} \ } \
) )
#define GPU_PushTexture1D(arena, _format, _size, _initial_layout, ...) GPU_PushTextureEx((arena), \ #define GPU_PushTexture1D(arena, _format, _size, _initial_layout, ...) GPU_PushTextureResource((arena), \
(GPU_TextureDesc) { \ (GPU_TextureResourceDesc) { \
.kind = GPU_TextureKind_1D, \ .kind = GPU_TextureKind_1D, \
.format = (_format), \ .format = (_format), \
.dims = VEC3I32((_size), 1, 1), \ .dims = VEC3I32((_size), 1, 1), \
.initial_layout = (_initial_layout), \ .initial_layout = (_initial_layout), \
__VA_ARGS__ \ __VA_ARGS__ \
} \ } \
) )
#define GPU_PushTexture2D(arena, _format, _size, _initial_layout, ...) GPU_PushTextureEx((arena), \ #define GPU_PushTexture2D(arena, _format, _size, _initial_layout, ...) GPU_PushTextureResource((arena), \
(GPU_TextureDesc) { \ (GPU_TextureResourceDesc) { \
.kind = GPU_TextureKind_2D, \ .kind = GPU_TextureKind_2D, \
.format = (_format), \ .format = (_format), \
.dims = VEC3I32((_size).x, (_size).y, 1), \ .dims = VEC3I32((_size).x, (_size).y, 1), \
.initial_layout = (_initial_layout), \ .initial_layout = (_initial_layout), \
__VA_ARGS__ \ __VA_ARGS__ \
} \ } \
) )
#define GPU_PushTexture3D(arena, _format, _size, _initial_layout, ...) GPU_PushTextureEx((arena), \ #define GPU_PushTexture3D(arena, _format, _size, _initial_layout, ...) GPU_PushTextureResource((arena), \
(GPU_TextureDesc) { \ (GPU_TextureResourceDesc) { \
.kind = GPU_TextureKind_3D, \ .kind = GPU_TextureKind_3D, \
.format = (_format), \ .format = (_format), \
.dims = (_size), \ .dims = (_size), \
.initial_layout = (_initial_layout), \ .initial_layout = (_initial_layout), \
__VA_ARGS__ \ __VA_ARGS__ \
} \ } \
) )
//- Shader handle creation //- Index buffer helpers
StructuredBufferHandle GPU_PushStructuredBufferHandleEx (GPU_ArenaHandle arena, GPU_ResourceHandle resource, u64 element_size, u64 element_offset);
RWStructuredBufferHandle GPU_PushRWStructuredBufferHandleEx (GPU_ArenaHandle arena, GPU_ResourceHandle resource, u64 element_size, u64 element_offset);
ByteAddressBufferHandle GPU_PushByteAddressBufferHandleEx (GPU_ArenaHandle arena, GPU_ResourceHandle resource, u64 u32_offset);
RWByteAddressBufferHandle GPU_PushRWByteAddressBufferHandleEx (GPU_ArenaHandle arena, GPU_ResourceHandle resource, u64 u32_offset);
Texture1DHandle GPU_PushTexture1DHandle (GPU_ArenaHandle arena, GPU_ResourceHandle resource);
RWTexture1DHandle GPU_PushRWTexture1DHandle (GPU_ArenaHandle arena, GPU_ResourceHandle resource);
Texture2DHandle GPU_PushTexture2DHandle (GPU_ArenaHandle arena, GPU_ResourceHandle resource);
RWTexture2DHandle GPU_PushRWTexture2DHandle (GPU_ArenaHandle arena, GPU_ResourceHandle resource);
Texture3DHandle GPU_PushTexture3DHandle (GPU_ArenaHandle arena, GPU_ResourceHandle resource);
RWTexture3DHandle GPU_PushRWTexture3DHandle (GPU_ArenaHandle arena, GPU_ResourceHandle resource);
SamplerStateHandle GPU_PushSamplerStateHandle (GPU_ArenaHandle arena, GPU_ResourceHandle resource);
#define GPU_PushStructuredBufferHandle(arena, resource, type) GPU_PushStructuredBufferHandleEx((arena), (resource), sizeof(type), 0)
#define GPU_PushRWStructuredBufferHandle(arena, resource, type) GPU_PushRWStructuredBufferHandleEx((arena), (resource), sizeof(type), 0)
#define GPU_PushByteAddressBufferHandle(arena, resource) GPU_PushByteAddressBufferHandleEx((arena), (resource), 0)
#define GPU_PushRWByteAddressBufferHandle(arena, resource) GPU_PushRWByteAddressBufferHandleEx((arena), (resource), 0)
//- Index buffer creation
#define GPU_IdxBuff16(_res) ((GPU_IndexBufferDesc) { .resource = (_res), .index_size = 2, .index_count = (GPU_CountBuffer((_res), i16)) }) #define GPU_IdxBuff16(_res) ((GPU_IndexBufferDesc) { .resource = (_res), .index_size = 2, .index_count = (GPU_CountBuffer((_res), i16)) })
#define GPU_IdxBuff32(_res) ((GPU_IndexBufferDesc) { .resource = (_res), .index_size = 4, .index_count = (GPU_CountBuffer((_res), i32)) }) #define GPU_IdxBuff32(_res) ((GPU_IndexBufferDesc) { .resource = (_res), .index_size = 4, .index_count = (GPU_CountBuffer((_res), i32)) })
@ -578,6 +575,66 @@ 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
u32 GPU_PushPointer(GPU_ArenaHandle arena, GPU_ResourceHandle resource, GPU_PointerDesc 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_PushRWStructuredBufferHandle(arena, resource, type, ...) (RWStructuredBufferHandle) { \
.v = GPU_PushPointer((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_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_PushRWByteAddressBufferHandleEx(arena, resource, ...) (RWByteAddressBufferHandle) { \
.v = GPU_PushPointer((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_RWByteAddressBuffer, __VA_ARGS__ }) \
};
#define GPU_PushTexture1DHandle(arena, resource, ...) (Texture1DHandle) { \
.v = GPU_PushPointer((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_Texture1D, __VA_ARGS__ }) \
};
#define GPU_PushRWTexture1DHandle(arena, resource, ...) (RWTexture1DHandle) { \
.v = GPU_PushPointer((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_RWTexture1D, __VA_ARGS__ }) \
};
#define GPU_PushTexture2DHandle(arena, resource, ...) (Texture2DHandle) { \
.v = GPU_PushPointer((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_Texture2D, __VA_ARGS__ }) \
};
#define GPU_PushRWTexture2DHandle(arena, resource, ...) (RWTexture2DHandle) { \
.v = GPU_PushPointer((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_RWTexture2D, __VA_ARGS__ }) \
};
#define GPU_PushTexture3DHandle(arena, resource, ...) (Texture3DHandle) { \
.v = GPU_PushPointer((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_Texture3D, __VA_ARGS__ }) \
};
#define GPU_PushRWTexture3DHandle(arena, resource, ...) (RWTexture3DHandle) { \
.v = GPU_PushPointer((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_RWTexture3D, __VA_ARGS__ }) \
};
#define GPU_PushSamplerStateHandle(arena, resource, ...) (SamplerStateHandle) { \
.v = GPU_PushPointer((arena), (resource), \
(GPU_PointerDesc) { .kind = ShaderHandleKind_SamplerState, __VA_ARGS__ }) \
};
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ @hookdecl Command //~ @hookdecl Command
@ -616,10 +673,10 @@ void GPU_SetConstant_(GPU_CommandListHandle cl, i32 slot, void *src_32bit, u32 s
//- Barrier //- Barrier
void GPU_BarrierEx(GPU_CommandListHandle cl, GPU_BarrierDesc desc); void GPU_Sync(GPU_CommandListHandle cl, GPU_BarrierDesc desc);
#define GPU_MemorySync(_cl, _resource, _sync_prev, _access_prev, _sync_next, _access_next) \ #define GPU_MemorySync(_cl, _resource, _sync_prev, _access_prev, _sync_next, _access_next) \
GPU_BarrierEx((_cl), (GPU_BarrierDesc) { \ GPU_Sync((_cl), (GPU_BarrierDesc) { \
.resource = (_resource), \ .resource = (_resource), \
.sync_prev = _sync_prev, \ .sync_prev = _sync_prev, \
.access_prev = _access_prev, \ .access_prev = _access_prev, \
@ -628,7 +685,7 @@ void GPU_BarrierEx(GPU_CommandListHandle cl, GPU_BarrierDesc desc);
}) })
#define GPU_MemoryLayoutSync(_cl, _resource, _sync_prev, _access_prev, _sync_next, _access_next, _layout) \ #define GPU_MemoryLayoutSync(_cl, _resource, _sync_prev, _access_prev, _sync_next, _access_next, _layout) \
GPU_BarrierEx((_cl), (GPU_BarrierDesc) { \ GPU_Sync((_cl), (GPU_BarrierDesc) { \
.resource = (_resource), \ .resource = (_resource), \
.sync_prev = _sync_prev, \ .sync_prev = _sync_prev, \
.access_prev = _access_prev, \ .access_prev = _access_prev, \
@ -638,7 +695,7 @@ void GPU_BarrierEx(GPU_CommandListHandle cl, GPU_BarrierDesc desc);
}) })
#define GPU_GlobalMemorySync(_cl, _sync_prev, _access_prev, _sync_next, _access_next) \ #define GPU_GlobalMemorySync(_cl, _sync_prev, _access_prev, _sync_next, _access_next) \
GPU_BarrierEx((_cl), (GPU_BarrierDesc) { \ GPU_Sync((_cl), (GPU_BarrierDesc) { \
.is_global = 1, \ .is_global = 1, \
.sync_prev = _sync_prev, \ .sync_prev = _sync_prev, \
.access_prev = _access_prev, \ .access_prev = _access_prev, \

347
src/gpu/gpu_dx12/gpu_dx12.c
View File

@ -226,7 +226,7 @@ void GPU_Startup(void)
{ {
/* Push an empty descriptor at index 0, so that a handle with a value of 0 always represents nil */ /* Push an empty descriptor at index 0, so that a handle with a value of 0 always represents nil */
GPU_D12_Arena *gpu_perm = GPU_D12_ArenaFromHandle(GPU_PermArena()); GPU_D12_Arena *gpu_perm = GPU_D12_ArenaFromHandle(GPU_PermArena());
GPU_D12_Descriptor *nil_descriptor = GPU_D12_PushDescriptor(gpu_perm, kind); GPU_D12_Descriptor *nil_descriptor = GPU_D12_PushDescriptor(gpu_perm, kind, 0);
Assert(nil_descriptor->index == 0); Assert(nil_descriptor->index == 0);
} }
@ -623,9 +623,9 @@ GPU_D12_RawCommandList *GPU_D12_PrepareRawCommandList(GPU_QueueKind queue_kind)
GPU_D12_Arena *gpu_perm = GPU_D12_ArenaFromHandle(GPU_PermArena()); GPU_D12_Arena *gpu_perm = GPU_D12_ArenaFromHandle(GPU_PermArena());
for (u32 i = 0; i < countof(cl->rtv_descriptors); ++i) for (u32 i = 0; i < countof(cl->rtv_descriptors); ++i)
{ {
cl->rtv_descriptors[i] = GPU_D12_PushDescriptor(gpu_perm, GPU_D12_DescriptorHeapKind_Rtv); cl->rtv_descriptors[i] = GPU_D12_PushDescriptor(gpu_perm, GPU_D12_DescriptorHeapKind_Rtv, 0);
} }
cl->rtv_clear_descriptor = GPU_D12_PushDescriptor(gpu_perm, GPU_D12_DescriptorHeapKind_Rtv); cl->rtv_clear_descriptor = GPU_D12_PushDescriptor(gpu_perm, GPU_D12_DescriptorHeapKind_Rtv, 0);
} }
} }
@ -724,7 +724,7 @@ GPU_D12_Descriptor *GPU_D12_DescriptorFromIndex(GPU_D12_DescriptorHeapKind heap_
return &descriptors[index]; return &descriptors[index];
} }
GPU_D12_Descriptor *GPU_D12_PushDescriptor(GPU_D12_Arena *gpu_arena, GPU_D12_DescriptorHeapKind heap_kind) GPU_D12_Descriptor *GPU_D12_PushDescriptor(GPU_D12_Arena *gpu_arena, GPU_D12_DescriptorHeapKind heap_kind, u32 forced)
{ {
GPU_D12_SharedState *g = &GPU_D12_shared_state; GPU_D12_SharedState *g = &GPU_D12_shared_state;
GPU_D12_DescriptorHeap *heap = &g->descriptor_heaps[heap_kind]; GPU_D12_DescriptorHeap *heap = &g->descriptor_heaps[heap_kind];
@ -732,7 +732,7 @@ GPU_D12_Descriptor *GPU_D12_PushDescriptor(GPU_D12_Arena *gpu_arena, GPU_D12_Des
GPU_D12_Descriptor *descriptor = 0; GPU_D12_Descriptor *descriptor = 0;
/* Grab completed descriptor from arena */ /* Grab completed descriptor from arena */
if (!descriptor) if (forced == 0)
{ {
GPU_D12_DescriptorList *descriptors_by_queue = gpu_arena->committed_descriptors_by_heap_and_queue[heap_kind]; GPU_D12_DescriptorList *descriptors_by_queue = gpu_arena->committed_descriptors_by_heap_and_queue[heap_kind];
for (GPU_QueueKind queue_kind = 0; !descriptor && queue_kind < GPU_NumQueues; ++queue_kind) for (GPU_QueueKind queue_kind = 0; !descriptor && queue_kind < GPU_NumQueues; ++queue_kind)
@ -746,7 +746,7 @@ GPU_D12_Descriptor *GPU_D12_PushDescriptor(GPU_D12_Arena *gpu_arena, GPU_D12_Des
if (queue_commit_completion >= descriptor->queue_commit_target) if (queue_commit_completion >= descriptor->queue_commit_target)
{ {
/* Descriptor no longer in use by gpu, reuse it */ /* Descriptor no longer in use by gpu, reuse it */
SllQueuePop(descriptors->first, descriptors->last); DllQueueRemove(descriptors->first, descriptors->last, descriptor);
} }
else else
{ {
@ -758,25 +758,79 @@ GPU_D12_Descriptor *GPU_D12_PushDescriptor(GPU_D12_Arena *gpu_arena, GPU_D12_Des
} }
/* Allocate new descriptor from heap */ /* Allocate new descriptor from heap */
u32 index = 0; u32 index = forced;
if (!descriptor) if (!descriptor)
{ {
Lock lock = LockE(&heap->mutex); Lock lock = LockE(&heap->mutex);
{ {
if (heap->first_free) if (index == 0)
{ {
descriptor = heap->first_free; if (heap->first_free)
SllStackPop(heap->first_free); {
index = descriptor->index; descriptor = heap->first_free;
DllStackRemove(heap->first_free, descriptor);
index = descriptor->index;
}
else
{
u32 descriptors_count = ArenaCount(heap->descriptors_arena, GPU_D12_Descriptor);
if (descriptors_count >= heap->max_count)
{
Panic(Lit("Max descriptors reached in heap"));
}
descriptor = PushStruct(heap->descriptors_arena, GPU_D12_Descriptor);
index = descriptors_count;
}
} }
else else
{ {
index = ArenaCount(heap->descriptors_arena, GPU_D12_Descriptor);
if (index >= heap->max_count) if (index >= heap->max_count)
{ {
Panic(Lit("Max descriptors reached in heap")); Panic(Lit("Max descriptors reached in heap"));
} }
descriptor = PushStructNoZero(heap->descriptors_arena, GPU_D12_Descriptor);
/* Push descriptors if index slot is past end of heap */
u32 descriptors_count = ArenaCount(heap->descriptors_arena, GPU_D12_Descriptor);
if (index >= descriptors_count)
{
u32 pushed_count = index - descriptors_count + 1;
PushStructs(heap->descriptors_arena, GPU_D12_Descriptor, pushed_count);
for (u32 pushed_index = descriptors_count; pushed_index < descriptors_count + pushed_count; ++pushed_index)
{
GPU_D12_Descriptor *pushed = &(ArenaFirst(heap->descriptors_arena, GPU_D12_Descriptor)[pushed_index]);
if (pushed_index < index)
{
pushed->heap = heap;
pushed->index = pushed_index;
pushed->handle.ptr = heap->start_handle.ptr + (pushed_index * heap->descriptor_size);
DllStackPush(heap->first_free, pushed);
}
else
{
descriptor = pushed;
}
}
}
/* Search free list for freed descriptor with matching index */
if (!descriptor)
{
for (GPU_D12_Descriptor *n = heap->first_free; n; n = n->next)
{
if (n->index == index)
{
DllStackRemove(heap->first_free, n);
descriptor = n;
break;
}
}
}
if (!descriptor)
{
Arena *perm = PermArena();
Panic(StringF(perm, "Tried to force push a GPU pointer into slot %F, but a descriptor already exists there (current heap count: %F)", FmtUint(index), FmtUint(ArenaCount(heap->descriptors_arena, GPU_D12_Descriptor))));
}
} }
} }
Unlock(&lock); Unlock(&lock);
@ -791,60 +845,12 @@ GPU_D12_Descriptor *GPU_D12_PushDescriptor(GPU_D12_Arena *gpu_arena, GPU_D12_Des
return descriptor; return descriptor;
} }
void GPU_D12_InitBufferDescriptor(GPU_D12_Descriptor *descriptor, GPU_D12_Resource *resource, u64 element_size, u64 element_offset, b32 is_raw, b32 is_uav)
{
GPU_D12_SharedState *g = &GPU_D12_shared_state;
u64 buffer_size_aligned = resource->buffer_size_aligned;
u64 num_elements_in_buffer = buffer_size_aligned / element_size;
u64 num_elements_after_offset = num_elements_in_buffer > element_offset ? num_elements_in_buffer - element_offset : 0;
if (num_elements_after_offset > 0)
{
if (is_uav)
{
D3D12_UNORDERED_ACCESS_VIEW_DESC desc = ZI;
{
desc.Format = DXGI_FORMAT_UNKNOWN;
desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER ;
desc.Buffer.FirstElement = element_offset;
desc.Buffer.NumElements = num_elements_after_offset;
desc.Buffer.StructureByteStride = element_size;
desc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_NONE;
}
if (is_raw)
{
desc.Format = DXGI_FORMAT_R32_TYPELESS;
desc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_RAW;
}
ID3D12Device_CreateUnorderedAccessView(g->device, resource->d3d_resource, 0, &desc, descriptor->handle);
}
else
{
D3D12_SHADER_RESOURCE_VIEW_DESC desc = ZI;
{
desc.Format = DXGI_FORMAT_UNKNOWN;
desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
desc.Buffer.FirstElement = element_offset;
desc.Buffer.NumElements = num_elements_after_offset;
desc.Buffer.StructureByteStride = element_size;
desc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_NONE;
}
if (is_raw)
{
desc.Format = DXGI_FORMAT_R32_TYPELESS;
desc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_RAW;
}
ID3D12Device_CreateShaderResourceView(g->device, resource->d3d_resource, &desc, descriptor->handle);
}
}
}
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ @hookimpl Resource //~ @hookimpl Resource
//- Resource creation //- Resource creation
GPU_ResourceHandle GPU_PushBufferEx(GPU_ArenaHandle arena_handle, GPU_BufferDesc desc) GPU_ResourceHandle GPU_PushBufferResource(GPU_ArenaHandle arena_handle, GPU_BufferResourceDesc 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);
@ -929,7 +935,7 @@ GPU_ResourceHandle GPU_PushBufferEx(GPU_ArenaHandle arena_handle, GPU_BufferDesc
return GPU_D12_MakeHandle(GPU_ResourceHandle, resource); return GPU_D12_MakeHandle(GPU_ResourceHandle, resource);
} }
GPU_ResourceHandle GPU_PushTextureEx(GPU_ArenaHandle arena_handle, GPU_TextureDesc desc) GPU_ResourceHandle GPU_PushTextureResource(GPU_ArenaHandle arena_handle, GPU_TextureResourceDesc 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);
@ -1027,7 +1033,7 @@ GPU_ResourceHandle GPU_PushTextureEx(GPU_ArenaHandle arena_handle, GPU_TextureDe
return GPU_D12_MakeHandle(GPU_ResourceHandle, resource); return GPU_D12_MakeHandle(GPU_ResourceHandle, resource);
} }
GPU_ResourceHandle GPU_PushSampler(GPU_ArenaHandle arena_handle, GPU_SamplerDesc desc) GPU_ResourceHandle GPU_PushSamplerResource(GPU_ArenaHandle arena_handle, GPU_SamplerResourceDesc 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);
@ -1039,133 +1045,118 @@ GPU_ResourceHandle GPU_PushSampler(GPU_ArenaHandle arena_handle, GPU_SamplerDesc
return GPU_D12_MakeHandle(GPU_ResourceHandle, resource); return GPU_D12_MakeHandle(GPU_ResourceHandle, resource);
} }
//- Shader handle creation ////////////////////////////////////////////////////////////
//~ @hookimpl Shader-accessible pointer
StructuredBufferHandle GPU_PushStructuredBufferHandleEx(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle, u64 element_size, u64 element_offset) u32 GPU_PushPointer(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle, GPU_PointerDesc pointer_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);
GPU_D12_Descriptor *descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav); u32 result = 0;
GPU_D12_InitBufferDescriptor(descriptor, resource, element_size, element_offset, 0, 0);
return GPU_D12_MakeHandle(StructuredBufferHandle, descriptor->index);
}
RWStructuredBufferHandle GPU_PushRWStructuredBufferHandleEx(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle, u64 element_size, u64 element_offset) ShaderHandleKind kind = pointer_desc.kind;
{
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);
GPU_D12_Descriptor *descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav);
GPU_D12_InitBufferDescriptor(descriptor, resource, element_size, element_offset, 0, 1);
return GPU_D12_MakeHandle(RWStructuredBufferHandle, descriptor->index);
}
ByteAddressBufferHandle GPU_PushByteAddressBufferHandleEx(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle, u64 u32_offset) b32 is_buffer = kind == ShaderHandleKind_StructuredBuffer ||
{ kind == ShaderHandleKind_RWStructuredBuffer ||
GPU_D12_SharedState *g = &GPU_D12_shared_state; kind == ShaderHandleKind_ByteAddressBuffer ||
GPU_D12_Arena *gpu_arena = GPU_D12_ArenaFromHandle(arena_handle); kind == ShaderHandleKind_RWByteAddressBuffer;
GPU_D12_Resource *resource = GPU_D12_ResourceFromHandle(resource_handle);
GPU_D12_Descriptor *descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav);
GPU_D12_InitBufferDescriptor(descriptor, resource, 4, u32_offset, 1, 0);
return GPU_D12_MakeHandle(ByteAddressBufferHandle, descriptor->index);
}
RWByteAddressBufferHandle GPU_PushRWByteAddressBufferHandleEx(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle, u64 u32_offset) b32 is_sampler = kind == ShaderHandleKind_SamplerState;
{
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);
GPU_D12_Descriptor *descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav);
GPU_D12_InitBufferDescriptor(descriptor, resource, 4, u32_offset, 1, 1);
return GPU_D12_MakeHandle(RWByteAddressBufferHandle, descriptor->index);
}
Texture1DHandle GPU_PushTexture1DHandle(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle) b32 is_texture = !is_buffer && !is_sampler;
{
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);
GPU_D12_Descriptor *descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav);
ID3D12Device_CreateShaderResourceView(g->device, resource->d3d_resource, 0, descriptor->handle);
return GPU_D12_MakeHandle(Texture1DHandle, descriptor->index);
}
RWTexture1DHandle GPU_PushRWTexture1DHandle(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle) b32 is_raw = kind == ShaderHandleKind_ByteAddressBuffer ||
{ kind == ShaderHandleKind_RWByteAddressBuffer;
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);
GPU_D12_Descriptor *descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav);
ID3D12Device_CreateUnorderedAccessView(g->device, resource->d3d_resource, 0, 0, descriptor->handle);
return GPU_D12_MakeHandle(RWTexture1DHandle, descriptor->index);
}
Texture2DHandle GPU_PushTexture2DHandle(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle) b32 is_uav = kind == ShaderHandleKind_RWStructuredBuffer ||
{ kind == ShaderHandleKind_RWByteAddressBuffer ||
GPU_D12_SharedState *g = &GPU_D12_shared_state; kind == ShaderHandleKind_RWTexture1D ||
GPU_D12_Arena *gpu_arena = GPU_D12_ArenaFromHandle(arena_handle); kind == ShaderHandleKind_RWTexture2D ||
GPU_D12_Resource *resource = GPU_D12_ResourceFromHandle(resource_handle); kind == ShaderHandleKind_RWTexture3D;
GPU_D12_Descriptor *descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav);
ID3D12Device_CreateShaderResourceView(g->device, resource->d3d_resource, 0, descriptor->handle);
return GPU_D12_MakeHandle(Texture2DHandle, descriptor->index);
}
RWTexture2DHandle GPU_PushRWTexture2DHandle(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle)
{
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);
GPU_D12_Descriptor *descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav);
ID3D12Device_CreateUnorderedAccessView(g->device, resource->d3d_resource, 0, 0, descriptor->handle);
return GPU_D12_MakeHandle(RWTexture2DHandle, descriptor->index);
}
Texture3DHandle GPU_PushTexture3DHandle(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle)
{
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);
GPU_D12_Descriptor *descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav);
ID3D12Device_CreateShaderResourceView(g->device, resource->d3d_resource, 0, descriptor->handle);
return GPU_D12_MakeHandle(Texture3DHandle, descriptor->index);
}
RWTexture3DHandle GPU_PushRWTexture3DHandle(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle) GPU_D12_Descriptor *descriptor = 0;
{ if (is_buffer)
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);
GPU_D12_Descriptor *descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav);
ID3D12Device_CreateUnorderedAccessView(g->device, resource->d3d_resource, 0, 0, descriptor->handle);
return GPU_D12_MakeHandle(RWTexture3DHandle, descriptor->index);
}
SamplerStateHandle GPU_PushSamplerStateHandle(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle)
{
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);
GPU_D12_Descriptor *descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_Sampler);
{ {
GPU_SamplerDesc sampler_desc = resource->sampler_desc; descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav, pointer_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;
if (num_elements_after_offset > 0)
{
if (is_uav)
{
D3D12_UNORDERED_ACCESS_VIEW_DESC desc = ZI;
{
desc.Format = DXGI_FORMAT_UNKNOWN;
desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER ;
desc.Buffer.FirstElement = pointer_desc.element_offset;
desc.Buffer.NumElements = num_elements_after_offset;
desc.Buffer.StructureByteStride = pointer_desc.element_size;
desc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_NONE;
}
if (is_raw)
{
desc.Format = DXGI_FORMAT_R32_TYPELESS;
desc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_RAW;
}
ID3D12Device_CreateUnorderedAccessView(g->device, resource->d3d_resource, 0, &desc, descriptor->handle);
}
else
{
D3D12_SHADER_RESOURCE_VIEW_DESC desc = ZI;
{
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.NumElements = num_elements_after_offset;
desc.Buffer.StructureByteStride = pointer_desc.element_size;
desc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_NONE;
}
if (is_raw)
{
desc.Format = DXGI_FORMAT_R32_TYPELESS;
desc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_RAW;
}
ID3D12Device_CreateShaderResourceView(g->device, resource->d3d_resource, &desc, descriptor->handle);
}
}
}
else if (is_texture)
{
descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav, pointer_desc.forced);
if (is_uav)
{
ID3D12Device_CreateUnorderedAccessView(g->device, resource->d3d_resource, 0, 0, descriptor->handle);
}
else
{
ID3D12Device_CreateShaderResourceView(g->device, resource->d3d_resource, 0, descriptor->handle);
}
}
else if (is_sampler)
{
descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_Sampler, pointer_desc.forced);
GPU_SamplerResourceDesc sampler_desc = resource->sampler_desc;
D3D12_SAMPLER_DESC d3d_desc = ZI; D3D12_SAMPLER_DESC d3d_desc = ZI;
d3d_desc.Filter = (D3D12_FILTER)sampler_desc.filter; {
d3d_desc.AddressU = (D3D12_TEXTURE_ADDRESS_MODE)sampler_desc.x; d3d_desc.Filter = (D3D12_FILTER)sampler_desc.filter;
d3d_desc.AddressV = (D3D12_TEXTURE_ADDRESS_MODE)sampler_desc.y; d3d_desc.AddressU = (D3D12_TEXTURE_ADDRESS_MODE)sampler_desc.x;
d3d_desc.AddressW = (D3D12_TEXTURE_ADDRESS_MODE)sampler_desc.z; d3d_desc.AddressV = (D3D12_TEXTURE_ADDRESS_MODE)sampler_desc.y;
d3d_desc.MipLODBias = sampler_desc.mip_lod_bias; d3d_desc.AddressW = (D3D12_TEXTURE_ADDRESS_MODE)sampler_desc.z;
d3d_desc.MaxAnisotropy = MaxU32(sampler_desc.max_anisotropy, 1); d3d_desc.MipLODBias = sampler_desc.mip_lod_bias;
d3d_desc.ComparisonFunc = (D3D12_COMPARISON_FUNC)sampler_desc.comparison; d3d_desc.MaxAnisotropy = MaxU32(sampler_desc.max_anisotropy, 1);
d3d_desc.BorderColor[0] = sampler_desc.border_color.x; d3d_desc.ComparisonFunc = (D3D12_COMPARISON_FUNC)sampler_desc.comparison;
d3d_desc.BorderColor[1] = sampler_desc.border_color.y; d3d_desc.BorderColor[0] = sampler_desc.border_color.x;
d3d_desc.BorderColor[2] = sampler_desc.border_color.z; d3d_desc.BorderColor[1] = sampler_desc.border_color.y;
d3d_desc.BorderColor[3] = sampler_desc.border_color.w; d3d_desc.BorderColor[2] = sampler_desc.border_color.z;
d3d_desc.MinLOD = sampler_desc.min_lod; d3d_desc.BorderColor[3] = sampler_desc.border_color.w;
d3d_desc.MaxLOD = sampler_desc.max_lod; d3d_desc.MinLOD = sampler_desc.min_lod;
d3d_desc.MaxLOD = sampler_desc.max_lod;
/* Defaults */ }
if (d3d_desc.AddressU == 0) d3d_desc.AddressU = D3D12_TEXTURE_ADDRESS_MODE_CLAMP; if (d3d_desc.AddressU == 0) d3d_desc.AddressU = D3D12_TEXTURE_ADDRESS_MODE_CLAMP;
if (d3d_desc.AddressV == 0) d3d_desc.AddressV = D3D12_TEXTURE_ADDRESS_MODE_CLAMP; if (d3d_desc.AddressV == 0) d3d_desc.AddressV = D3D12_TEXTURE_ADDRESS_MODE_CLAMP;
if (d3d_desc.AddressW == 0) d3d_desc.AddressW = D3D12_TEXTURE_ADDRESS_MODE_CLAMP; if (d3d_desc.AddressW == 0) d3d_desc.AddressW = D3D12_TEXTURE_ADDRESS_MODE_CLAMP;
@ -1173,10 +1164,10 @@ SamplerStateHandle GPU_PushSamplerStateHandle(GPU_ArenaHandle arena_handle, GPU_
{ {
d3d_desc.MaxLOD = D3D12_FLOAT32_MAX; d3d_desc.MaxLOD = D3D12_FLOAT32_MAX;
} }
ID3D12Device_CreateSampler(g->device, &d3d_desc, descriptor->handle); ID3D12Device_CreateSampler(g->device, &d3d_desc, descriptor->handle);
} }
return GPU_D12_MakeHandle(SamplerStateHandle, descriptor->index);
return descriptor->index;
} }
//- Count //- Count
@ -2313,7 +2304,7 @@ void GPU_SetConstant_(GPU_CommandListHandle cl_handle, i32 slot, void *src_32bit
//- Barrier //- Barrier
void GPU_BarrierEx(GPU_CommandListHandle cl_handle, GPU_BarrierDesc desc) void GPU_Sync(GPU_CommandListHandle cl_handle, GPU_BarrierDesc desc)
{ {
GPU_D12_CmdList *cl = GPU_D12_CmdListFromHandle(cl_handle); GPU_D12_CmdList *cl = GPU_D12_CmdListFromHandle(cl_handle);
GPU_D12_Cmd *cmd = GPU_D12_PushCmd(cl); GPU_D12_Cmd *cmd = GPU_D12_PushCmd(cl);

6
src/gpu/gpu_dx12/gpu_dx12.h
View File

@ -84,6 +84,7 @@ Struct(GPU_D12_DescriptorHeap)
Struct(GPU_D12_Descriptor) Struct(GPU_D12_Descriptor)
{ {
GPU_D12_Descriptor *next; GPU_D12_Descriptor *next;
GPU_D12_Descriptor *prev;
u64 queue_commit_target; u64 queue_commit_target;
GPU_D12_DescriptorHeap *heap; GPU_D12_DescriptorHeap *heap;
@ -140,7 +141,7 @@ Struct(GPU_D12_Resource)
D3D12_BARRIER_LAYOUT texture_layout; D3D12_BARRIER_LAYOUT texture_layout;
/* Sampler info */ /* Sampler info */
GPU_SamplerDesc sampler_desc; GPU_SamplerResourceDesc sampler_desc;
/* Backbuffer info */ /* Backbuffer info */
struct GPU_D12_Swapchain *swapchain; struct GPU_D12_Swapchain *swapchain;
@ -412,8 +413,7 @@ GPU_D12_Queue *GPU_D12_QueueFromKind(GPU_QueueKind kind);
//~ Resource helpers //~ Resource helpers
GPU_D12_Descriptor *GPU_D12_DescriptorFromIndex(GPU_D12_DescriptorHeapKind heap_kind, u32 index); GPU_D12_Descriptor *GPU_D12_DescriptorFromIndex(GPU_D12_DescriptorHeapKind heap_kind, u32 index);
GPU_D12_Descriptor *GPU_D12_PushDescriptor(GPU_D12_Arena *gpu_arena, GPU_D12_DescriptorHeapKind heap_kind); GPU_D12_Descriptor *GPU_D12_PushDescriptor(GPU_D12_Arena *gpu_arena, GPU_D12_DescriptorHeapKind heap_kind, u32 forced);
void GPU_D12_InitBufferDescriptor(GPU_D12_Descriptor *descriptor, GPU_D12_Resource *resource, u64 element_size, u64 element_offset, b32 is_raw, b32 is_uav);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Raw command list //~ Raw command list

12
src/gpu/gpu_shader_extras.h
View File

@ -1,12 +1,12 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Static handles (common resources available to all shaders) //~ Shared static handles (common resources available to all shaders)
#if IsLanguageC #if IsLanguageC
#define GPU_StaticHandle(type, v) ((type) { (v) }) #define GPU_SharedHandle(type, v) ((type) { (v) })
#elif IsLanguageHlsl #elif IsLanguageHlsl
#define GPU_StaticHandle(type, v) (type(v)) #define GPU_SharedHandle(type, v) (type(v))
#endif #endif
#define GPU_ShaderPrintBufferHandle RWByteAddressBufferHandle (1) #define GPU_ShaderPrintBuffer GPU_SharedHandle(RWByteAddressBufferHandle, 1)
#define GPU_BasicPointSamplerHandle SamplerStateHandle (2) #define GPU_BasicPointSampler GPU_SharedHandle(SamplerStateHandle, 2)
#define GPU_BasicNoiseTextureHandle Texture2DHandle (3) #define GPU_BasicNoiseTexture GPU_SharedHandle(Texture3DHandle, 3)

24
src/gpu/gpu_shader_extras.hlsl
View File

@ -201,18 +201,18 @@ template<typename T> u32 U32FromChar(in T c)
} }
#if GPU_DEBUG #if GPU_DEBUG
#define DebugPrint(fmt_cstr) do { \ #define DebugPrint(fmt_cstr) do { \
u32 __strlen = 0; \ u32 __strlen = 0; \
for (;;) { if (U32FromChar(fmt_cstr[__strlen]) == 0) { break; } ++__strlen; } \ for (;;) { if (U32FromChar(fmt_cstr[__strlen]) == 0) { break; } ++__strlen; } \
RWByteAddressBuffer __print_buff = RWByteAddressBufferFromHandle(GPU_ShaderPrintBufferHandle); \ RWByteAddressBuffer __print_buff = RWByteAddressBufferFromHandle(GPU_ShaderPrintBuffer); \
u32 __pos; \ u32 __pos; \
__print_buff.InterlockedAdd(0, __strlen, __pos); \ __print_buff.InterlockedAdd(0, __strlen, __pos); \
if (__pos < countof(__print_buff)) \ if (__pos < countof(__print_buff)) \
{ \ { \
for (u32 char_idx = 0; char_idx < __strlen; ++char_idx) \ for (u32 char_idx = 0; char_idx < __strlen; ++char_idx) \
{ \ { \
__print_buff.Store(__pos + char_idx, U32FromChar(fmt_cstr[char_idx])); \ __print_buff.Store(__pos + char_idx, U32FromChar(fmt_cstr[char_idx])); \
} \ } \
} \ } \
} while (0) } while (0)
#else #else

1
src/gpu/gpu_static_extras.h
View File

@ -1 +0,0 @@
/* This file contains shader resource handles

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

@ -583,7 +583,6 @@ void V_TickForever(WaveLaneCtx *lane)
params.target_size = draw_size; params.target_size = draw_size;
params.target_ro = draw_target_ro; params.target_ro = draw_target_ro;
params.target_rw = draw_target_rw; params.target_rw = draw_target_rw;
params.sampler = GPU_GetSharedPointSampler();
params.shape_verts = dverts_ro; params.shape_verts = dverts_ro;
params.world_to_draw_xf = world_to_draw_xf; params.world_to_draw_xf = world_to_draw_xf;
} }

1
src/pp/pp_vis/pp_vis_shaders.h
View File

@ -8,7 +8,6 @@ Struct(V_DParams)
Vec2I32 target_size; Vec2I32 target_size;
Texture2DHandle target_ro; Texture2DHandle target_ro;
RWTexture2DHandle target_rw; RWTexture2DHandle target_rw;
SamplerStateHandle sampler;
StructuredBufferHandle quads; StructuredBufferHandle quads;
StructuredBufferHandle shape_verts; StructuredBufferHandle shape_verts;
Xform world_to_draw_xf; Xform world_to_draw_xf;

1
src/ui/ui_core.c
View File

@ -1390,7 +1390,6 @@ void UI_EndFrame(UI_Frame *frame)
params.target_size = draw_size; params.target_size = draw_size;
params.target_ro = draw_target_ro; params.target_ro = draw_target_ro;
params.rects = rects_ro; params.rects = rects_ro;
params.sampler = GPU_GetSharedPointSampler();
} }
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); StructuredBufferHandle params_ro = GPU_PushStructuredBufferHandle(frame->gpu_arena, params_buff, UI_DParams);

1
src/ui/ui_shaders.h
View File

@ -9,7 +9,6 @@ Struct(UI_DParams)
Vec2I32 target_size; Vec2I32 target_size;
Texture2DHandle target_ro; Texture2DHandle target_ro;
StructuredBufferHandle rects; StructuredBufferHandle rects;
SamplerStateHandle sampler;
}; };
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////

30
src/ui/ui_shaders.hlsl
View File

@ -49,7 +49,7 @@ PixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input)
{ {
UI_DParams params = StructuredBufferFromHandle<UI_DParams>(UI_ShaderConst_Params)[0]; UI_DParams params = StructuredBufferFromHandle<UI_DParams>(UI_ShaderConst_Params)[0];
StructuredBuffer<UI_DRect> rects = StructuredBufferFromHandle<UI_DRect>(params.rects); StructuredBuffer<UI_DRect> rects = StructuredBufferFromHandle<UI_DRect>(params.rects);
SamplerState sampler = SamplerStateFromHandle(params.sampler); SamplerState sampler = SamplerStateFromHandle(GPU_BasicPointSampler);
UI_DRect rect = rects[input.rect_idx]; UI_DRect rect = rects[input.rect_idx];
@ -107,7 +107,7 @@ PixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input)
{ {
background_color = border_color; background_color = border_color;
} }
else if (!IsGpuHandleNil(rect.tex)) else if (!IsShaderHandleNil(rect.tex))
{ {
Texture2D<Vec4> tex = Texture2DFromHandle<Vec4>(rect.tex); Texture2D<Vec4> tex = Texture2DFromHandle<Vec4>(rect.tex);
background_color = tex.Sample(sampler, input.tex_uv); background_color = tex.Sample(sampler, input.tex_uv);
@ -166,38 +166,14 @@ 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 = StructuredBufferFromHandle<UI_DParams>(UI_ShaderConst_Params)[0];
SamplerState sampler = SamplerStateFromHandle(params.sampler);
Texture2D<Vec4> tex = Texture2DFromHandle<Vec4>(params.target_ro); Texture2D<Vec4> tex = Texture2DFromHandle<Vec4>(params.target_ro);
SamplerState sampler = SamplerStateFromHandle(GPU_BasicPointSampler);
Vec2 uv = input.src_uv; Vec2 uv = input.src_uv;
Vec4 result = tex.Sample(sampler, uv); Vec4 result = tex.Sample(sampler, uv);
u32 ints[] = {
1,
2,
3,
4
};
u32 count = countof(ints);
if (count == 4)
{
result.g = 1;
}
else
{
// result.b = 1;
}
DebugPrint("Hello there"); DebugPrint("Hello there");
UI_BlitPSOutput output; UI_BlitPSOutput output;
output.SV_Target0 = result; output.SV_Target0 = result;
return output; return output;