diff --git a/src/base/base.h b/src/base/base.h index 5759d7d5..68e0d0cb 100644 --- a/src/base/base.h +++ b/src/base/base.h @@ -728,6 +728,21 @@ //- 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(RWStructuredBufferHandle) { u32 v; }; Struct(ByteAddressBufferHandle) { u32 v; }; @@ -739,7 +754,8 @@ Struct(RWTexture2DHandle) { u32 v; }; Struct(Texture3DHandle) { u32 v; }; Struct(RWTexture3DHandle) { u32 v; }; Struct(SamplerStateHandle) { u32 v; }; -#define IsGpuHandleNil(h) ((h).v == 0) + +#define IsShaderHandleNil(h) ((h).v == 0) //- Shader constants diff --git a/src/base/base_arena.h b/src/base/base_arena.h index d7a97a9f..ece49f67 100644 --- a/src/base/base_arena.h +++ b/src/base/base_arena.h @@ -57,8 +57,8 @@ void *ResetArena(Arena *arena); #define PopStructsNoCopy(a, type, n) PopBytesNoCopy((a), sizeof(type) * (n)) #define PopStructNoCopy(a, type) PopStructsNoCopy((a), type, 1) -#define ArenaFirst(arena, type) (type *)ArenaFirst_((arena), alignof(type)) -#define ArenaNext(arena, type) (type *)ArenaNext_((arena), alignof(type)) +#define ArenaFirst(arena, type) ((type *)ArenaFirst_((arena), alignof(type))) +#define ArenaNext(arena, type) ((type *)ArenaNext_((arena), alignof(type))) #define ArenaCount(arena, type) ((arena)->pos / sizeof(type)) void *PushBytesNoZero(Arena *arena, u64 size, u64 align); diff --git a/src/gpu/gpu.lay b/src/gpu/gpu.lay index 61f3b12b..8990059f 100644 --- a/src/gpu/gpu.lay +++ b/src/gpu/gpu.lay @@ -6,11 +6,11 @@ //- Api @IncludeC gpu_core.h @IncludeC gpu_shader_extras.h -@IncludeC gpu_extras.h +@IncludeC gpu_common.h @IncludeGpu gpu_shader_extras.h //- Impl -@IncludeC gpu_extras.c +@IncludeC gpu_common.c @IncludeGpu gpu_shader_extras.hlsl //- Dx12 impl diff --git a/src/gpu/gpu_extras.c b/src/gpu/gpu_common.c similarity index 67% rename from src/gpu/gpu_extras.c rename to src/gpu/gpu_common.c index 605dcfd2..370a9504 100644 --- a/src/gpu/gpu_extras.c +++ b/src/gpu/gpu_common.c @@ -10,23 +10,22 @@ void GPU_StartupExtra(void) 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); { /* Init quad index buffer */ + GPU_ResourceHandle quad_indices = ZI; { 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))); - 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"))); Vec3I32 noise_dims = VEC3I32(128, 128, 64); @@ -34,16 +33,19 @@ void GPU_StartupExtra(void) { Panic(Lit("Unexpected noise texture size")); } - GPU_ResourceHandle noise_tex = GPU_PushTexture3D(gpu_perm, - GPU_Format_R16_Uint, - noise_dims, - GPU_Layout_AnyQueue_ShaderRead_CopyRead_CopyWrite_Present); + noise_tex = GPU_PushTexture3D(gpu_perm, + GPU_Format_R16_Uint, + noise_dims, + GPU_Layout_AnyQueue_ShaderRead_CopyRead_CopyWrite_Present); GPU_CopyCpuToTexture(cl, noise_tex, VEC3I32(0, 0, 0), noise_data.text, 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); @@ -70,7 +72,7 @@ GPU_ArenaHandle GPU_PermArena(void) 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_MemorySync( cl, buffer, @@ -96,17 +98,7 @@ Rng2 GPU_ScissorFromTexture(GPU_ResourceHandle texture) //- Shared resources -SamplerStateHandle GPU_GetSharedPointSampler(void) -{ - return GPU_shared_util_state.pt_sampler; -} - GPU_IndexBufferDesc GPU_GetSharedQuadIndices(void) { return GPU_shared_util_state.quad_indices; } - -Texture3DHandle GPU_GetSharedNoise(void) -{ - return GPU_shared_util_state.noise_tex; -} diff --git a/src/gpu/gpu_extras.h b/src/gpu/gpu_common.h similarity index 83% rename from src/gpu/gpu_extras.h rename to src/gpu/gpu_common.h index 958a66d5..1fdb89be 100644 --- a/src/gpu/gpu_extras.h +++ b/src/gpu/gpu_common.h @@ -4,9 +4,7 @@ Struct(GPU_SharedUtilState) { /* Common shared resources */ - SamplerStateHandle pt_sampler; GPU_IndexBufferDesc quad_indices; - Texture3DHandle noise_tex; } extern GPU_shared_util_state; extern ThreadLocal GPU_ArenaHandle GPU_t_perm_arena; @@ -34,6 +32,4 @@ Rng2 GPU_ScissorFromTexture(GPU_ResourceHandle texture); //- Shared resources -SamplerStateHandle GPU_GetSharedPointSampler(void); GPU_IndexBufferDesc GPU_GetSharedQuadIndices(void); -Texture3DHandle GPU_GetSharedNoise(void); diff --git a/src/gpu/gpu_core.h b/src/gpu/gpu_core.h index 19cd7f16..432c53c4 100644 --- a/src/gpu/gpu_core.h +++ b/src/gpu/gpu_core.h @@ -303,7 +303,7 @@ Enum(GPU_ResourceFlag) //////////////////////////////////////////////////////////// //~ Buffer types -Struct(GPU_BufferDesc) +Struct(GPU_BufferResourceDesc) { u64 size; GPU_ResourceFlag flags; @@ -321,7 +321,7 @@ Enum(GPU_TextureKind) GPU_TextureKind_3D, }; -Struct(GPU_TextureDesc) +Struct(GPU_TextureResourceDesc) { GPU_TextureKind kind; GPU_ResourceFlag flags; @@ -411,7 +411,7 @@ Enum(GPU_ComparisonFunc) GPU_ComparisonFunc_Always = 8 }; -Struct(GPU_SamplerDesc) +Struct(GPU_SamplerResourceDesc) { GPU_Filter filter; GPU_AddressMode x; @@ -425,6 +425,23 @@ Struct(GPU_SamplerDesc) 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 @@ -500,68 +517,48 @@ void GPU_ReleaseArena(GPU_ArenaHandle arena); //- Resource creation -GPU_ResourceHandle GPU_PushBufferEx(GPU_ArenaHandle arena, GPU_BufferDesc desc); -GPU_ResourceHandle GPU_PushTextureEx(GPU_ArenaHandle arena, GPU_TextureDesc desc); -GPU_ResourceHandle GPU_PushSampler(GPU_ArenaHandle arena, GPU_SamplerDesc desc); +GPU_ResourceHandle GPU_PushBufferResource(GPU_ArenaHandle arena, GPU_BufferResourceDesc desc); +GPU_ResourceHandle GPU_PushTextureResource(GPU_ArenaHandle arena, GPU_TextureResourceDesc desc); +GPU_ResourceHandle GPU_PushSamplerResource(GPU_ArenaHandle arena, GPU_SamplerResourceDesc desc); -#define GPU_PushBuffer(arena, type, count, ...) GPU_PushBufferEx((arena), \ - (GPU_BufferDesc) { \ - .size = sizeof(type) * (count), \ - __VA_ARGS__ \ - } \ +#define GPU_PushBuffer(arena, type, count, ...) GPU_PushBufferResource((arena), \ + (GPU_BufferResourceDesc) { \ + .size = sizeof(type) * (count), \ + __VA_ARGS__ \ + } \ ) -#define GPU_PushTexture1D(arena, _format, _size, _initial_layout, ...) GPU_PushTextureEx((arena), \ - (GPU_TextureDesc) { \ - .kind = GPU_TextureKind_1D, \ - .format = (_format), \ - .dims = VEC3I32((_size), 1, 1), \ - .initial_layout = (_initial_layout), \ - __VA_ARGS__ \ - } \ +#define GPU_PushTexture1D(arena, _format, _size, _initial_layout, ...) GPU_PushTextureResource((arena), \ + (GPU_TextureResourceDesc) { \ + .kind = GPU_TextureKind_1D, \ + .format = (_format), \ + .dims = VEC3I32((_size), 1, 1), \ + .initial_layout = (_initial_layout), \ + __VA_ARGS__ \ + } \ ) -#define GPU_PushTexture2D(arena, _format, _size, _initial_layout, ...) GPU_PushTextureEx((arena), \ - (GPU_TextureDesc) { \ - .kind = GPU_TextureKind_2D, \ - .format = (_format), \ - .dims = VEC3I32((_size).x, (_size).y, 1), \ - .initial_layout = (_initial_layout), \ - __VA_ARGS__ \ - } \ +#define GPU_PushTexture2D(arena, _format, _size, _initial_layout, ...) GPU_PushTextureResource((arena), \ + (GPU_TextureResourceDesc) { \ + .kind = GPU_TextureKind_2D, \ + .format = (_format), \ + .dims = VEC3I32((_size).x, (_size).y, 1), \ + .initial_layout = (_initial_layout), \ + __VA_ARGS__ \ + } \ ) -#define GPU_PushTexture3D(arena, _format, _size, _initial_layout, ...) GPU_PushTextureEx((arena), \ - (GPU_TextureDesc) { \ - .kind = GPU_TextureKind_3D, \ - .format = (_format), \ - .dims = (_size), \ - .initial_layout = (_initial_layout), \ - __VA_ARGS__ \ - } \ +#define GPU_PushTexture3D(arena, _format, _size, _initial_layout, ...) GPU_PushTextureResource((arena), \ + (GPU_TextureResourceDesc) { \ + .kind = GPU_TextureKind_3D, \ + .format = (_format), \ + .dims = (_size), \ + .initial_layout = (_initial_layout), \ + __VA_ARGS__ \ + } \ ) -//- Shader handle creation - -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 +//- Index buffer helpers #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)) }) @@ -578,6 +575,66 @@ i32 GPU_CountDepth(GPU_ResourceHandle texture); #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 @@ -616,10 +673,10 @@ void GPU_SetConstant_(GPU_CommandListHandle cl, i32 slot, void *src_32bit, u32 s //- 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) \ - GPU_BarrierEx((_cl), (GPU_BarrierDesc) { \ + GPU_Sync((_cl), (GPU_BarrierDesc) { \ .resource = (_resource), \ .sync_prev = _sync_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) \ - GPU_BarrierEx((_cl), (GPU_BarrierDesc) { \ + GPU_Sync((_cl), (GPU_BarrierDesc) { \ .resource = (_resource), \ .sync_prev = _sync_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) \ - GPU_BarrierEx((_cl), (GPU_BarrierDesc) { \ + GPU_Sync((_cl), (GPU_BarrierDesc) { \ .is_global = 1, \ .sync_prev = _sync_prev, \ .access_prev = _access_prev, \ diff --git a/src/gpu/gpu_dx12/gpu_dx12.c b/src/gpu/gpu_dx12/gpu_dx12.c index 23918206..4f43239e 100644 --- a/src/gpu/gpu_dx12/gpu_dx12.c +++ b/src/gpu/gpu_dx12/gpu_dx12.c @@ -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 */ 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); } @@ -623,9 +623,9 @@ GPU_D12_RawCommandList *GPU_D12_PrepareRawCommandList(GPU_QueueKind queue_kind) GPU_D12_Arena *gpu_perm = GPU_D12_ArenaFromHandle(GPU_PermArena()); 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]; } -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_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; /* 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]; 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) { /* Descriptor no longer in use by gpu, reuse it */ - SllQueuePop(descriptors->first, descriptors->last); + DllQueueRemove(descriptors->first, descriptors->last, descriptor); } else { @@ -758,25 +758,79 @@ GPU_D12_Descriptor *GPU_D12_PushDescriptor(GPU_D12_Arena *gpu_arena, GPU_D12_Des } /* Allocate new descriptor from heap */ - u32 index = 0; + u32 index = forced; if (!descriptor) { Lock lock = LockE(&heap->mutex); { - if (heap->first_free) + if (index == 0) { - descriptor = heap->first_free; - SllStackPop(heap->first_free); - index = descriptor->index; + if (heap->first_free) + { + 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 { - index = ArenaCount(heap->descriptors_arena, GPU_D12_Descriptor); if (index >= heap->max_count) { 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); @@ -791,60 +845,12 @@ GPU_D12_Descriptor *GPU_D12_PushDescriptor(GPU_D12_Arena *gpu_arena, GPU_D12_Des 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 //- 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_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); } -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_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); } -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_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); } -//- 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_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, 0); - return GPU_D12_MakeHandle(StructuredBufferHandle, descriptor->index); -} + u32 result = 0; -RWStructuredBufferHandle GPU_PushRWStructuredBufferHandleEx(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle, u64 element_size, u64 element_offset) -{ - 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); -} + ShaderHandleKind kind = pointer_desc.kind; -ByteAddressBufferHandle GPU_PushByteAddressBufferHandleEx(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle, u64 u32_offset) -{ - 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, 0); - return GPU_D12_MakeHandle(ByteAddressBufferHandle, descriptor->index); -} + b32 is_buffer = kind == ShaderHandleKind_StructuredBuffer || + kind == ShaderHandleKind_RWStructuredBuffer || + kind == ShaderHandleKind_ByteAddressBuffer || + kind == ShaderHandleKind_RWByteAddressBuffer; -RWByteAddressBufferHandle GPU_PushRWByteAddressBufferHandleEx(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle, u64 u32_offset) -{ - 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); -} + b32 is_sampler = kind == ShaderHandleKind_SamplerState; -Texture1DHandle GPU_PushTexture1DHandle(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(Texture1DHandle, descriptor->index); -} + b32 is_texture = !is_buffer && !is_sampler; -RWTexture1DHandle GPU_PushRWTexture1DHandle(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(RWTexture1DHandle, descriptor->index); -} + b32 is_raw = kind == ShaderHandleKind_ByteAddressBuffer || + kind == ShaderHandleKind_RWByteAddressBuffer; -Texture2DHandle GPU_PushTexture2DHandle(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(Texture2DHandle, descriptor->index); -} + b32 is_uav = kind == ShaderHandleKind_RWStructuredBuffer || + kind == ShaderHandleKind_RWByteAddressBuffer || + kind == ShaderHandleKind_RWTexture1D || + kind == ShaderHandleKind_RWTexture2D || + kind == ShaderHandleKind_RWTexture3D; -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_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_D12_Descriptor *descriptor = 0; + if (is_buffer) { - 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; - d3d_desc.Filter = (D3D12_FILTER)sampler_desc.filter; - d3d_desc.AddressU = (D3D12_TEXTURE_ADDRESS_MODE)sampler_desc.x; - d3d_desc.AddressV = (D3D12_TEXTURE_ADDRESS_MODE)sampler_desc.y; - d3d_desc.AddressW = (D3D12_TEXTURE_ADDRESS_MODE)sampler_desc.z; - d3d_desc.MipLODBias = sampler_desc.mip_lod_bias; - d3d_desc.MaxAnisotropy = MaxU32(sampler_desc.max_anisotropy, 1); - d3d_desc.ComparisonFunc = (D3D12_COMPARISON_FUNC)sampler_desc.comparison; - d3d_desc.BorderColor[0] = sampler_desc.border_color.x; - d3d_desc.BorderColor[1] = sampler_desc.border_color.y; - d3d_desc.BorderColor[2] = sampler_desc.border_color.z; - d3d_desc.BorderColor[3] = sampler_desc.border_color.w; - d3d_desc.MinLOD = sampler_desc.min_lod; - d3d_desc.MaxLOD = sampler_desc.max_lod; - - /* Defaults */ + { + d3d_desc.Filter = (D3D12_FILTER)sampler_desc.filter; + d3d_desc.AddressU = (D3D12_TEXTURE_ADDRESS_MODE)sampler_desc.x; + d3d_desc.AddressV = (D3D12_TEXTURE_ADDRESS_MODE)sampler_desc.y; + d3d_desc.AddressW = (D3D12_TEXTURE_ADDRESS_MODE)sampler_desc.z; + d3d_desc.MipLODBias = sampler_desc.mip_lod_bias; + d3d_desc.MaxAnisotropy = MaxU32(sampler_desc.max_anisotropy, 1); + d3d_desc.ComparisonFunc = (D3D12_COMPARISON_FUNC)sampler_desc.comparison; + d3d_desc.BorderColor[0] = sampler_desc.border_color.x; + d3d_desc.BorderColor[1] = sampler_desc.border_color.y; + d3d_desc.BorderColor[2] = sampler_desc.border_color.z; + d3d_desc.BorderColor[3] = sampler_desc.border_color.w; + d3d_desc.MinLOD = sampler_desc.min_lod; + d3d_desc.MaxLOD = sampler_desc.max_lod; + } 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.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; } - ID3D12Device_CreateSampler(g->device, &d3d_desc, descriptor->handle); } - return GPU_D12_MakeHandle(SamplerStateHandle, descriptor->index); + + return descriptor->index; } //- Count @@ -2313,7 +2304,7 @@ void GPU_SetConstant_(GPU_CommandListHandle cl_handle, i32 slot, void *src_32bit //- 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_Cmd *cmd = GPU_D12_PushCmd(cl); diff --git a/src/gpu/gpu_dx12/gpu_dx12.h b/src/gpu/gpu_dx12/gpu_dx12.h index 4bdbafcc..1a8e243d 100644 --- a/src/gpu/gpu_dx12/gpu_dx12.h +++ b/src/gpu/gpu_dx12/gpu_dx12.h @@ -84,6 +84,7 @@ Struct(GPU_D12_DescriptorHeap) Struct(GPU_D12_Descriptor) { GPU_D12_Descriptor *next; + GPU_D12_Descriptor *prev; u64 queue_commit_target; GPU_D12_DescriptorHeap *heap; @@ -140,7 +141,7 @@ Struct(GPU_D12_Resource) D3D12_BARRIER_LAYOUT texture_layout; /* Sampler info */ - GPU_SamplerDesc sampler_desc; + GPU_SamplerResourceDesc sampler_desc; /* Backbuffer info */ struct GPU_D12_Swapchain *swapchain; @@ -412,8 +413,7 @@ GPU_D12_Queue *GPU_D12_QueueFromKind(GPU_QueueKind kind); //~ Resource helpers 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); -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_Descriptor *GPU_D12_PushDescriptor(GPU_D12_Arena *gpu_arena, GPU_D12_DescriptorHeapKind heap_kind, u32 forced); //////////////////////////////////////////////////////////// //~ Raw command list diff --git a/src/gpu/gpu_shader_extras.h b/src/gpu/gpu_shader_extras.h index f381dd6c..243cf727 100644 --- a/src/gpu/gpu_shader_extras.h +++ b/src/gpu/gpu_shader_extras.h @@ -1,12 +1,12 @@ //////////////////////////////////////////////////////////// -//~ Static handles (common resources available to all shaders) +//~ Shared static handles (common resources available to all shaders) #if IsLanguageC - #define GPU_StaticHandle(type, v) ((type) { (v) }) + #define GPU_SharedHandle(type, v) ((type) { (v) }) #elif IsLanguageHlsl - #define GPU_StaticHandle(type, v) (type(v)) + #define GPU_SharedHandle(type, v) (type(v)) #endif -#define GPU_ShaderPrintBufferHandle RWByteAddressBufferHandle (1) -#define GPU_BasicPointSamplerHandle SamplerStateHandle (2) -#define GPU_BasicNoiseTextureHandle Texture2DHandle (3) +#define GPU_ShaderPrintBuffer GPU_SharedHandle(RWByteAddressBufferHandle, 1) +#define GPU_BasicPointSampler GPU_SharedHandle(SamplerStateHandle, 2) +#define GPU_BasicNoiseTexture GPU_SharedHandle(Texture3DHandle, 3) diff --git a/src/gpu/gpu_shader_extras.hlsl b/src/gpu/gpu_shader_extras.hlsl index cb86ee60..5ed6e3d1 100644 --- a/src/gpu/gpu_shader_extras.hlsl +++ b/src/gpu/gpu_shader_extras.hlsl @@ -201,18 +201,18 @@ template u32 U32FromChar(in T c) } #if GPU_DEBUG - #define DebugPrint(fmt_cstr) do { \ - u32 __strlen = 0; \ - for (;;) { if (U32FromChar(fmt_cstr[__strlen]) == 0) { break; } ++__strlen; } \ - RWByteAddressBuffer __print_buff = RWByteAddressBufferFromHandle(GPU_ShaderPrintBufferHandle); \ - 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])); \ - } \ + #define DebugPrint(fmt_cstr) do { \ + u32 __strlen = 0; \ + for (;;) { if (U32FromChar(fmt_cstr[__strlen]) == 0) { break; } ++__strlen; } \ + RWByteAddressBuffer __print_buff = RWByteAddressBufferFromHandle(GPU_ShaderPrintBuffer); \ + 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 diff --git a/src/gpu/gpu_static_extras.h b/src/gpu/gpu_static_extras.h deleted file mode 100644 index 13103b6e..00000000 --- a/src/gpu/gpu_static_extras.h +++ /dev/null @@ -1 +0,0 @@ -/* This file contains shader resource handles diff --git a/src/pp/pp_vis/pp_vis_core.c b/src/pp/pp_vis/pp_vis_core.c index f902148a..97c6a34c 100644 --- a/src/pp/pp_vis/pp_vis_core.c +++ b/src/pp/pp_vis/pp_vis_core.c @@ -583,7 +583,6 @@ void V_TickForever(WaveLaneCtx *lane) params.target_size = draw_size; params.target_ro = draw_target_ro; params.target_rw = draw_target_rw; - params.sampler = GPU_GetSharedPointSampler(); params.shape_verts = dverts_ro; params.world_to_draw_xf = world_to_draw_xf; } diff --git a/src/pp/pp_vis/pp_vis_shaders.h b/src/pp/pp_vis/pp_vis_shaders.h index 9c5ddffd..b7ce8f0e 100644 --- a/src/pp/pp_vis/pp_vis_shaders.h +++ b/src/pp/pp_vis/pp_vis_shaders.h @@ -8,7 +8,6 @@ Struct(V_DParams) Vec2I32 target_size; Texture2DHandle target_ro; RWTexture2DHandle target_rw; - SamplerStateHandle sampler; StructuredBufferHandle quads; StructuredBufferHandle shape_verts; Xform world_to_draw_xf; diff --git a/src/ui/ui_core.c b/src/ui/ui_core.c index c7f5ad54..a0c98cab 100644 --- a/src/ui/ui_core.c +++ b/src/ui/ui_core.c @@ -1390,7 +1390,6 @@ void UI_EndFrame(UI_Frame *frame) params.target_size = draw_size; params.target_ro = draw_target_ro; params.rects = rects_ro; - params.sampler = GPU_GetSharedPointSampler(); } 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); diff --git a/src/ui/ui_shaders.h b/src/ui/ui_shaders.h index 72e8282e..501fb450 100644 --- a/src/ui/ui_shaders.h +++ b/src/ui/ui_shaders.h @@ -9,7 +9,6 @@ Struct(UI_DParams) Vec2I32 target_size; Texture2DHandle target_ro; StructuredBufferHandle rects; - SamplerStateHandle sampler; }; //////////////////////////////////////////////////////////// diff --git a/src/ui/ui_shaders.hlsl b/src/ui/ui_shaders.hlsl index 7108f7cf..f2762f76 100644 --- a/src/ui/ui_shaders.hlsl +++ b/src/ui/ui_shaders.hlsl @@ -49,7 +49,7 @@ PixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input) { UI_DParams params = StructuredBufferFromHandle(UI_ShaderConst_Params)[0]; StructuredBuffer rects = StructuredBufferFromHandle(params.rects); - SamplerState sampler = SamplerStateFromHandle(params.sampler); + SamplerState sampler = SamplerStateFromHandle(GPU_BasicPointSampler); UI_DRect rect = rects[input.rect_idx]; @@ -107,7 +107,7 @@ PixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input) { background_color = border_color; } - else if (!IsGpuHandleNil(rect.tex)) + else if (!IsShaderHandleNil(rect.tex)) { Texture2D tex = Texture2DFromHandle(rect.tex); 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) { UI_DParams params = StructuredBufferFromHandle(UI_ShaderConst_Params)[0]; - SamplerState sampler = SamplerStateFromHandle(params.sampler); Texture2D tex = Texture2DFromHandle(params.target_ro); + SamplerState sampler = SamplerStateFromHandle(GPU_BasicPointSampler); Vec2 uv = input.src_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"); - - - - UI_BlitPSOutput output; output.SV_Target0 = result; return output;