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

working buffer copy

Browse Source
This commit is contained in:
jacob 2025-12-02 22:29:35 -06:00
parent f0f3da0bcd
commit 7bb5447abf
4 changed files with 661 additions and 499 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1143,7 +1143,7 @@ GPU_ArenaHandle GPU_AcquireArena(void)
} }
gpu_arena->arena = AcquireArena(Gibi(1)); gpu_arena->arena = AcquireArena(Gibi(1));
return GPU_D12_HandleFromPointer(GPU_ArenaHandle, gpu_arena); return GPU_D12_MakeHandle(GPU_ArenaHandle, gpu_arena);
} }
void GPU_ReleaseArena(GPU_ArenaHandle arena) void GPU_ReleaseArena(GPU_ArenaHandle arena)
@ -1239,10 +1239,86 @@ GPU_D12_Descriptor *GPU_D12_DescriptorFromIndex(GPU_D12_DescriptorHeapKind heap_
//- Resource creation //- Resource creation
GPU_ResourceHandle GPU_PushBufferEx(GPU_ArenaHandle arena, GPU_BufferDesc desc) GPU_ResourceHandle GPU_PushBufferEx(GPU_ArenaHandle arena_handle, GPU_BufferDesc desc)
{ {
/* TODO */ GPU_D12_SharedState *g = &GPU_D12_shared_state;
return GPU_D12_HandleFromPointer(GPU_ResourceHandle, 0); GPU_D12_Arena *gpu_arena = GPU_D12_ArenaFromHandle(arena_handle);
/* Create resource heap */
if (!gpu_arena->d3d_resource_heap)
{
/* FIXME: Dynamic size */
D3D12_HEAP_DESC d3d_desc = ZI;
d3d_desc.SizeInBytes = Mebi(64);
d3d_desc.Flags = D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES; /* TODO: Remove this and support tier 1 resource heaps */
d3d_desc.Properties.Type = D3D12_HEAP_TYPE_DEFAULT;
ID3D12Heap *heap = 0;
HRESULT hr = ID3D12Device_CreateHeap(g->device, &d3d_desc, &IID_ID3D12Heap, (void **)&heap);
if (!SUCCEEDED(hr))
{
/* TODO: Don't panic */
Panic(Lit("Failed to create D3D12 resource heap"));
}
gpu_arena->d3d_resource_heap = heap;
gpu_arena->heap_size = d3d_desc.SizeInBytes;
}
/* Create d3d resource */
ID3D12Resource *d3d_resource = 0;
{
D3D12_RESOURCE_DESC1 d3d_desc = ZI;
d3d_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
d3d_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
d3d_desc.Format = DXGI_FORMAT_UNKNOWN;
d3d_desc.Width = MaxI32(desc.size, 1);
d3d_desc.Height = 1;
d3d_desc.DepthOrArraySize = 1;
d3d_desc.MipLevels = 1;
d3d_desc.SampleDesc.Count = 1;
d3d_desc.SampleDesc.Quality = 0;
d3d_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS * AnyBit(desc.flags, GPU_ResourceFlag_AllowShaderReadWrite);
u64 alloc_size = 0;
u64 alloc_align = 0;
{
D3D12_RESOURCE_ALLOCATION_INFO alloc_info = ZI;
ID3D12Device_GetResourceAllocationInfo(g->device, &alloc_info, 0, 1, (D3D12_RESOURCE_DESC *)&d3d_desc);
alloc_size = alloc_info.SizeInBytes;
alloc_align = alloc_info.Alignment;
}
u64 alloc_pos = gpu_arena->heap_pos;
alloc_pos = AlignU64(alloc_pos, alloc_align);
gpu_arena->heap_pos = alloc_pos + alloc_size;
if (alloc_pos + alloc_size > gpu_arena->heap_size)
{
Panic(Lit("Gpu arena overflow"));
}
HRESULT hr = ID3D12Device10_CreatePlacedResource2(g->device,
gpu_arena->d3d_resource_heap,
alloc_pos,
&d3d_desc,
D3D12_BARRIER_LAYOUT_UNDEFINED,
0,
0,
0,
&IID_ID3D12Resource,
(void **)&d3d_resource);
}
GPU_D12_Resource *resource = PushStruct(gpu_arena->arena, GPU_D12_Resource);
resource->d3d_resource = d3d_resource;
resource->uid = Atomic64FetchAdd(&g->resource_creation_gen.v, 1) + 1;
resource->flags = desc.flags;
resource->buffer_size = desc.size;
resource->buffer_gpu_address = ID3D12Resource_GetGPUVirtualAddress(d3d_resource);
return GPU_D12_MakeHandle(GPU_ResourceHandle, resource);
} }
GPU_ResourceHandle GPU_PushTextureEx(GPU_ArenaHandle arena_handle, GPU_TextureDesc desc) GPU_ResourceHandle GPU_PushTextureEx(GPU_ArenaHandle arena_handle, GPU_TextureDesc desc)
@ -1272,17 +1348,18 @@ GPU_ResourceHandle GPU_PushTextureEx(GPU_ArenaHandle arena_handle, GPU_TextureDe
gpu_arena->heap_size = d3d_desc.SizeInBytes; gpu_arena->heap_size = d3d_desc.SizeInBytes;
} }
/* Create d3d resource */
ID3D12Resource *d3d_resource = 0; ID3D12Resource *d3d_resource = 0;
{ {
D3D12_RESOURCE_DESC1 d3d_desc = ZI; D3D12_RESOURCE_DESC1 d3d_desc = ZI;
d3d_desc.Dimension = desc.kind == GPU_TextureKind_1D ? D3D12_RESOURCE_DIMENSION_TEXTURE1D : d3d_desc.Dimension = desc.kind == GPU_TextureKind_1D ? D3D12_RESOURCE_DIMENSION_TEXTURE1D :
GPU_TextureKind_2D ? D3D12_RESOURCE_DIMENSION_TEXTURE2D : GPU_TextureKind_2D ? D3D12_RESOURCE_DIMENSION_TEXTURE2D :
D3D12_RESOURCE_DIMENSION_TEXTURE3D; D3D12_RESOURCE_DIMENSION_TEXTURE3D;
d3d_desc.Format = GPU_D12_DxgiFormatFromGpuFormat(desc.format);
d3d_desc.Width = MaxI32(desc.dims.x, 1); d3d_desc.Width = MaxI32(desc.dims.x, 1);
d3d_desc.Height = MaxI32(desc.dims.y, 1); d3d_desc.Height = MaxI32(desc.dims.y, 1);
d3d_desc.DepthOrArraySize = MaxI32(desc.dims.z, 1); d3d_desc.DepthOrArraySize = MaxI32(desc.dims.z, 1);
d3d_desc.MipLevels = MaxI32(desc.mip_levels, 1); d3d_desc.MipLevels = MaxI32(desc.mip_levels, 1);
d3d_desc.Format = GPU_D12_DxgiFormatFromGpuFormat(desc.format);
d3d_desc.SampleDesc.Count = 1; d3d_desc.SampleDesc.Count = 1;
d3d_desc.SampleDesc.Quality = 0; d3d_desc.SampleDesc.Quality = 0;
d3d_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS * AnyBit(desc.flags, GPU_ResourceFlag_AllowShaderReadWrite); d3d_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS * AnyBit(desc.flags, GPU_ResourceFlag_AllowShaderReadWrite);
@ -1338,13 +1415,19 @@ GPU_ResourceHandle GPU_PushTextureEx(GPU_ArenaHandle arena_handle, GPU_TextureDe
resource->texture_mip_levels = desc.mip_levels; resource->texture_mip_levels = desc.mip_levels;
resource->texture_layout = initial_layout; resource->texture_layout = initial_layout;
return GPU_D12_HandleFromPointer(GPU_ResourceHandle, resource); return GPU_D12_MakeHandle(GPU_ResourceHandle, resource);
} }
GPU_ResourceHandle GPU_PushSampler(GPU_ArenaHandle arena, GPU_SamplerDesc desc) GPU_ResourceHandle GPU_PushSampler(GPU_ArenaHandle arena_handle, GPU_SamplerDesc desc)
{ {
/* TODO */ GPU_D12_SharedState *g = &GPU_D12_shared_state;
return GPU_D12_HandleFromPointer(GPU_ResourceHandle, 0); GPU_D12_Arena *gpu_arena = GPU_D12_ArenaFromHandle(arena_handle);
GPU_D12_Resource *resource = PushStruct(gpu_arena->arena, GPU_D12_Resource);
resource->uid = Atomic64FetchAdd(&g->resource_creation_gen.v, 1) + 1;
resource->sampler_desc = desc;
return GPU_D12_MakeHandle(GPU_ResourceHandle, resource);
} }
b32 GPU_IsResourceNil(GPU_ResourceHandle handle) b32 GPU_IsResourceNil(GPU_ResourceHandle handle)
@ -1354,34 +1437,64 @@ b32 GPU_IsResourceNil(GPU_ResourceHandle handle)
//- Pointer creation //- Pointer creation
StructuredBufferHandle GPU_PushStructuredBufferHandleEx(GPU_ArenaHandle arena, GPU_ResourceHandle resource, u32 element_size, RngU32 element_range) StructuredBufferHandle GPU_PushStructuredBufferHandleEx(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle, u32 element_size, RngU32 element_range)
{ {
/* TODO */ GPU_D12_SharedState *g = &GPU_D12_shared_state;
return GPU_D12_HandleFromPointer(StructuredBufferHandle, 0); 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);
{
D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc = ZI;
srv_desc.Format = DXGI_FORMAT_UNKNOWN;
srv_desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
srv_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
srv_desc.Buffer.FirstElement = element_range.min;
srv_desc.Buffer.NumElements = element_range.max - element_range.min;
srv_desc.Buffer.StructureByteStride = element_size;
srv_desc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_NONE;
ID3D12Device_CreateShaderResourceView(g->device, resource->d3d_resource, &srv_desc, descriptor->handle);
}
return GPU_D12_MakeHandle(StructuredBufferHandle, descriptor->index);
} }
RWStructuredBufferHandle GPU_PushRWStructuredBufferHandleEx(GPU_ArenaHandle arena, GPU_ResourceHandle resource, u32 element_size, RngU32 element_range) RWStructuredBufferHandle GPU_PushRWStructuredBufferHandleEx(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle, u32 element_size, RngU32 element_range)
{ {
/* TODO */ GPU_D12_SharedState *g = &GPU_D12_shared_state;
return GPU_D12_HandleFromPointer(RWStructuredBufferHandle, 0); 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(RWStructuredBufferHandle, descriptor->index);
} }
Texture1DHandle GPU_PushTexture1DHandle(GPU_ArenaHandle arena, GPU_ResourceHandle resource) Texture1DHandle GPU_PushTexture1DHandle(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle)
{ {
/* TODO */ GPU_D12_SharedState *g = &GPU_D12_shared_state;
return GPU_D12_HandleFromPointer(Texture1DHandle, 0); 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, GPU_ResourceHandle resource) RWTexture1DHandle GPU_PushRWTexture1DHandle(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle)
{ {
/* TODO */ GPU_D12_SharedState *g = &GPU_D12_shared_state;
return GPU_D12_HandleFromPointer(RWTexture1DHandle, 0); 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, GPU_ResourceHandle resource) Texture2DHandle GPU_PushTexture2DHandle(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle)
{ {
/* TODO */ GPU_D12_SharedState *g = &GPU_D12_shared_state;
return GPU_D12_HandleFromPointer(Texture2DHandle, 0); 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);
} }
RWTexture2DHandle GPU_PushRWTexture2DHandle(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle) RWTexture2DHandle GPU_PushRWTexture2DHandle(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle)
@ -1391,25 +1504,65 @@ RWTexture2DHandle GPU_PushRWTexture2DHandle(GPU_ArenaHandle arena_handle, GPU_Re
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); GPU_D12_Descriptor *descriptor = GPU_D12_PushDescriptor(gpu_arena, GPU_D12_DescriptorHeapKind_CbvSrvUav);
ID3D12Device_CreateUnorderedAccessView(g->device, resource->d3d_resource, 0, 0, descriptor->handle); ID3D12Device_CreateUnorderedAccessView(g->device, resource->d3d_resource, 0, 0, descriptor->handle);
return GPU_D12_HandleFromPointer(RWTexture2DHandle, descriptor->index); return GPU_D12_MakeHandle(RWTexture2DHandle, descriptor->index);
} }
Texture3DHandle GPU_PushTexture3DHandle(GPU_ArenaHandle arena, GPU_ResourceHandle resource) Texture3DHandle GPU_PushTexture3DHandle(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle)
{ {
/* TODO */ GPU_D12_SharedState *g = &GPU_D12_shared_state;
return GPU_D12_HandleFromPointer(Texture3DHandle, 0); 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, GPU_ResourceHandle resource) RWTexture3DHandle GPU_PushRWTexture3DHandle(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle)
{ {
/* TODO */ GPU_D12_SharedState *g = &GPU_D12_shared_state;
return GPU_D12_HandleFromPointer(RWTexture3DHandle, 0); 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, GPU_ResourceHandle resource) SamplerStateHandle GPU_PushSamplerStateHandle(GPU_ArenaHandle arena_handle, GPU_ResourceHandle resource_handle)
{ {
/* TODO */ GPU_D12_SharedState *g = &GPU_D12_shared_state;
return GPU_D12_HandleFromPointer(SamplerStateHandle, 0); 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;
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 */
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;
if (d3d_desc.MaxLOD >= F32Infinity)
{
d3d_desc.MaxLOD = D3D12_FLOAT32_MAX;
}
ID3D12Device_CreateSampler(g->device, &d3d_desc, descriptor->handle);
}
return GPU_D12_MakeHandle(SamplerStateHandle, descriptor->index);
} }
//- Count //- Count
@ -1739,7 +1892,7 @@ GPU_CommandListHandle GPU_PrepareCommandList(GPU_QueueKind queue)
Unlock(&lock); Unlock(&lock);
cl->queue_kind = queue; cl->queue_kind = queue;
return GPU_D12_HandleFromPointer(GPU_CommandListHandle, cl); return GPU_D12_MakeHandle(GPU_CommandListHandle, cl);
} }
void GPU_CommitCommandListEx(GPU_CommandListHandle cl_handle, u64 fence_ops_count, GPU_FenceOp *fence_ops) void GPU_CommitCommandListEx(GPU_CommandListHandle cl_handle, u64 fence_ops_count, GPU_FenceOp *fence_ops)
@ -1837,11 +1990,6 @@ void GPU_CommitCommandListEx(GPU_CommandListHandle cl_handle, u64 fence_ops_coun
/* This barrier is part of new batch */ /* This barrier is part of new batch */
prev_barrier_cmd->barrier.is_end_of_batch = 1; prev_barrier_cmd->barrier.is_end_of_batch = 1;
} }
else
{
/* Barriers can be batched */
prev_barrier_cmd->skip = 1;
}
} }
cmd->barrier.batch_gen = batch_gen; cmd->barrier.batch_gen = batch_gen;
prev_barrier_cmd = cmd; prev_barrier_cmd = cmd;
@ -1865,12 +2013,6 @@ void GPU_CommitCommandListEx(GPU_CommandListHandle cl_handle, u64 fence_ops_coun
while (cmd_idx < cmds_count) while (cmd_idx < cmds_count)
{ {
GPU_D12_Cmd *cmd = &cmds[cmd_idx]; GPU_D12_Cmd *cmd = &cmds[cmd_idx];
if (cmd->skip)
{
cmd_idx += 1;
}
else
{
switch (cmd->kind) switch (cmd->kind)
{ {
default: default:
@ -1909,7 +2051,7 @@ void GPU_CommitCommandListEx(GPU_CommandListHandle cl_handle, u64 fence_ops_coun
for (u64 barrier_cmd_idx = batch_barrier_idx_start; barrier_cmd_idx < batch_barrier_idx_opl; ++barrier_cmd_idx) for (u64 barrier_cmd_idx = batch_barrier_idx_start; barrier_cmd_idx < batch_barrier_idx_opl; ++barrier_cmd_idx)
{ {
GPU_D12_Cmd *barrier_cmd = &cmds[barrier_cmd_idx]; GPU_D12_Cmd *barrier_cmd = &cmds[barrier_cmd_idx];
if (barrier_cmd->kind == GPU_D12_CmdKind_Barrier && !barrier_cmd->skip) if (barrier_cmd->kind == GPU_D12_CmdKind_Barrier)
{ {
GPU_BarrierDesc desc = barrier_cmd->barrier.desc; GPU_BarrierDesc desc = barrier_cmd->barrier.desc;
GPU_D12_Resource *resource = GPU_D12_ResourceFromHandle(desc.resource); GPU_D12_Resource *resource = GPU_D12_ResourceFromHandle(desc.resource);
@ -1920,11 +2062,10 @@ void GPU_CommitCommandListEx(GPU_CommandListHandle cl_handle, u64 fence_ops_coun
D3D12_BARRIER_SYNC sync_after = GPU_D12_BarrierSyncFromStages(desc.sync_next); D3D12_BARRIER_SYNC sync_after = GPU_D12_BarrierSyncFromStages(desc.sync_next);
D3D12_BARRIER_ACCESS access_before = GPU_D12_BarrierAccessFromAccesses(desc.access_prev); D3D12_BARRIER_ACCESS access_before = GPU_D12_BarrierAccessFromAccesses(desc.access_prev);
D3D12_BARRIER_ACCESS access_after = GPU_D12_BarrierAccessFromAccesses(desc.access_next); D3D12_BARRIER_ACCESS access_after = GPU_D12_BarrierAccessFromAccesses(desc.access_next);
D3D12_BARRIER_LAYOUT layout_before = D3D12_BARRIER_LAYOUT_UNDEFINED; D3D12_BARRIER_LAYOUT layout_before = resource->texture_layout;
D3D12_BARRIER_LAYOUT layout_after = D3D12_BARRIER_LAYOUT_UNDEFINED; D3D12_BARRIER_LAYOUT layout_after = resource->texture_layout;
if (desc.layout != GPU_Layout_NoChange) if (desc.layout != GPU_Layout_NoChange)
{ {
layout_before = resource->texture_layout;
layout_after = GPU_D12_BarrierLayoutFromLayout(desc.layout); layout_after = GPU_D12_BarrierLayoutFromLayout(desc.layout);
resource->texture_layout = layout_after; resource->texture_layout = layout_after;
} }
@ -2006,6 +2147,19 @@ void GPU_CommitCommandListEx(GPU_CommandListHandle cl_handle, u64 fence_ops_coun
cmd_idx += 1; cmd_idx += 1;
} break; } break;
//- Copy bytes
case GPU_D12_CmdKind_CopyBytes:
{
u64 copy_size = cmd->copy_bytes.src_copy_range.max - cmd->copy_bytes.src_copy_range.min;
ID3D12GraphicsCommandList_CopyBufferRegion(d3d_cl,
cmd->copy_bytes.dst->d3d_resource,
cmd->copy_bytes.dst_offset,
cmd->copy_bytes.src->d3d_resource,
cmd->copy_bytes.src_copy_range.min,
copy_size);
cmd_idx += 1;
} break;
//- Copy resource //- Copy resource
// case GPU_D12_CmdKind_Copy: // case GPU_D12_CmdKind_Copy:
@ -2355,7 +2509,6 @@ void GPU_CommitCommandListEx(GPU_CommandListHandle cl_handle, u64 fence_ops_coun
} }
} }
} }
}
/* End dx12 command list */ /* End dx12 command list */
GPU_D12_CommitRawCommandList(rcl); GPU_D12_CommitRawCommandList(rcl);
@ -2395,7 +2548,7 @@ void GPU_CopyCpuBytes(GPU_CommandListHandle cl_handle, GPU_ResourceHandle dst_ha
u64 size = src_copy_range.max - src_copy_range.min; u64 size = src_copy_range.max - src_copy_range.min;
GPU_D12_StagingRegionNode *region = GPU_D12_PushStagingRegion(cl, size); GPU_D12_StagingRegionNode *region = GPU_D12_PushStagingRegion(cl, size);
CopyBytes((u8 *)region->heap->mapped + region->pos, (u8 *)src + src_copy_range.min, size); CopyBytes((u8 *)region->heap->mapped + region->pos, (u8 *)src + src_copy_range.min, size);
GPU_CopyBytes(cl_handle, dst_handle, dst_offset, GPU_D12_HandleFromPointer(GPU_ResourceHandle, &region->heap->resource), RNGU64(region->pos, region->pos + size)); GPU_CopyBytes(cl_handle, dst_handle, dst_offset, GPU_D12_MakeHandle(GPU_ResourceHandle, &region->heap->resource), RNGU64(region->pos, region->pos + size));
} }
void GPU_CopyCpuTexels(GPU_CommandListHandle cl, GPU_ResourceHandle dst_handle, Vec3I32 dst_offset, void *cpu_src, Vec3I32 cpu_src_dims, Rng3I32 cpu_src_copy_range) void GPU_CopyCpuTexels(GPU_CommandListHandle cl, GPU_ResourceHandle dst_handle, Vec3I32 dst_offset, void *cpu_src, Vec3I32 cpu_src_dims, Rng3I32 cpu_src_copy_range)
@ -2465,12 +2618,18 @@ void GPU_CopyCpuTexels(GPU_CommandListHandle cl, GPU_ResourceHandle dst_handle,
//- Gpu <-> Gpu copy //- Gpu <-> Gpu copy
void GPU_CopyBytes(GPU_CommandListHandle cl, GPU_ResourceHandle dst, u64 dst_offset, GPU_ResourceHandle src, RngU64 src_copy_range) void GPU_CopyBytes(GPU_CommandListHandle cl_handle, GPU_ResourceHandle dst_handle, u64 dst_offset, GPU_ResourceHandle src_handle, RngU64 src_copy_range)
{ {
/* TODO */ GPU_D12_CmdList *cl = GPU_D12_CmdListFromHandle(cl_handle);
GPU_D12_Cmd *cmd = GPU_D12_PushCmd(cl);
cmd->kind = GPU_D12_CmdKind_CopyBytes;
cmd->copy_bytes.dst = GPU_D12_ResourceFromHandle(dst_handle);
cmd->copy_bytes.src = GPU_D12_ResourceFromHandle(src_handle);
cmd->copy_bytes.dst_offset = dst_offset;
cmd->copy_bytes.src_copy_range = src_copy_range;
} }
void GPU_CopyTexels(GPU_CommandListHandle cl, GPU_ResourceHandle dst, Vec3I32 dst_offset, GPU_ResourceHandle src, Rng3I32 src_copy_range) void GPU_CopyTexels(GPU_CommandListHandle cl, GPU_ResourceHandle dst_handle, Vec3I32 dst_offset, GPU_ResourceHandle src_handle, Rng3I32 src_copy_range)
{ {
/* TODO */ /* TODO */
} }
@ -2657,7 +2816,7 @@ GPU_SwapchainHandle GPU_AcquireSwapchain(WND_Handle window)
swapchain = PushStruct(perm, GPU_D12_Swapchain); swapchain = PushStruct(perm, GPU_D12_Swapchain);
} }
swapchain->window_hwnd = (HWND)WND_OsHandleFromWindow(window); swapchain->window_hwnd = (HWND)WND_OsHandleFromWindow(window);
return GPU_D12_HandleFromPointer(GPU_SwapchainHandle, swapchain); return GPU_D12_MakeHandle(GPU_SwapchainHandle, swapchain);
} }
void GPU_ReleaseSwapchain(GPU_SwapchainHandle swapchain_handle) void GPU_ReleaseSwapchain(GPU_SwapchainHandle swapchain_handle)
@ -2796,7 +2955,9 @@ GPU_ResourceHandle GPU_PrepareBackbuffer(GPU_SwapchainHandle swapchain_handle, G
backbuffer->d3d_resource = d3d_resource; backbuffer->d3d_resource = d3d_resource;
backbuffer->uid = Atomic64FetchAdd(&g->resource_creation_gen.v, 1) + 1; backbuffer->uid = Atomic64FetchAdd(&g->resource_creation_gen.v, 1) + 1;
backbuffer->flags = GPU_ResourceFlag_AllowRenderTarget; backbuffer->flags = GPU_ResourceFlag_AllowRenderTarget;
backbuffer->is_texture = 1; backbuffer->is_texture = 1;
backbuffer->texture_format = format;
backbuffer->texture_dims = VEC3I32(size.x, size.y, 1); backbuffer->texture_dims = VEC3I32(size.x, size.y, 1);
backbuffer->texture_mip_levels = 1; backbuffer->texture_mip_levels = 1;
backbuffer->texture_layout = D3D12_BARRIER_LAYOUT_PRESENT; backbuffer->texture_layout = D3D12_BARRIER_LAYOUT_PRESENT;
@ -2825,7 +2986,7 @@ GPU_ResourceHandle GPU_PrepareBackbuffer(GPU_SwapchainHandle swapchain_handle, G
cur_backbuffer = &swapchain->backbuffers[backbuffer_idx]; cur_backbuffer = &swapchain->backbuffers[backbuffer_idx];
} }
return GPU_D12_HandleFromPointer(GPU_ResourceHandle, cur_backbuffer); return GPU_D12_MakeHandle(GPU_ResourceHandle, cur_backbuffer);
} }
void GPU_CommitBackbuffer(GPU_ResourceHandle backbuffer_handle, i32 vsync) void GPU_CommitBackbuffer(GPU_ResourceHandle backbuffer_handle, i32 vsync)

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

@ -124,6 +124,7 @@ Struct(GPU_D12_Arena)
Struct(GPU_D12_Resource) Struct(GPU_D12_Resource)
{ {
GPU_D12_Resource *next_free; GPU_D12_Resource *next_free;
ID3D12Resource *d3d_resource; ID3D12Resource *d3d_resource;
u64 uid; u64 uid;
GPU_ResourceFlag flags; GPU_ResourceFlag flags;
@ -139,6 +140,9 @@ Struct(GPU_D12_Resource)
i32 texture_mip_levels; i32 texture_mip_levels;
D3D12_BARRIER_LAYOUT texture_layout; D3D12_BARRIER_LAYOUT texture_layout;
/* Sampler info */
GPU_SamplerDesc sampler_desc;
/* Backbuffer info */ /* Backbuffer info */
struct GPU_D12_Swapchain *swapchain; struct GPU_D12_Swapchain *swapchain;
}; };
@ -229,7 +233,8 @@ Enum(GPU_D12_CmdKind)
GPU_D12_CmdKind_None, GPU_D12_CmdKind_None,
GPU_D12_CmdKind_Barrier, GPU_D12_CmdKind_Barrier,
GPU_D12_CmdKind_Constant, GPU_D12_CmdKind_Constant,
GPU_D12_CmdKind_Copy, GPU_D12_CmdKind_CopyBytes,
GPU_D12_CmdKind_CopyTexels,
GPU_D12_CmdKind_Compute, GPU_D12_CmdKind_Compute,
GPU_D12_CmdKind_Rasterize, GPU_D12_CmdKind_Rasterize,
GPU_D12_CmdKind_ClearRtv, GPU_D12_CmdKind_ClearRtv,
@ -261,8 +266,7 @@ Struct(GPU_D12_Cmd)
GPU_D12_Resource *dst; GPU_D12_Resource *dst;
GPU_D12_Resource *src; GPU_D12_Resource *src;
u64 dst_offset; u64 dst_offset;
u64 src_offset; RngU64 src_copy_range;
u64 size;
} copy_bytes; } copy_bytes;
struct struct
@ -270,8 +274,7 @@ Struct(GPU_D12_Cmd)
GPU_D12_Resource *dst; GPU_D12_Resource *dst;
GPU_D12_Resource *src; GPU_D12_Resource *src;
Vec3I32 dst_offset; Vec3I32 dst_offset;
Vec3I32 src_offset; Rng3I32 src_copy_range;
Vec3I32 size;
} copy_texels; } copy_texels;
struct struct
@ -385,7 +388,7 @@ Struct(GPU_D12_SharedState)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Helpers //~ Helpers
#define GPU_D12_HandleFromPointer(type, ptr) (type) { .v = (u64)(ptr) } #define GPU_D12_MakeHandle(type, ptr) (type) { .v = (u64)(ptr) }
GPU_D12_Arena *GPU_D12_ArenaFromHandle(GPU_ArenaHandle handle); GPU_D12_Arena *GPU_D12_ArenaFromHandle(GPU_ArenaHandle handle);
GPU_D12_CmdList *GPU_D12_CmdListFromHandle(GPU_CommandListHandle handle); GPU_D12_CmdList *GPU_D12_CmdListFromHandle(GPU_CommandListHandle handle);

1
src/proto/proto.c
View File

@ -68,7 +68,6 @@ JobImpl(PT_RunForever, _sig, _id)
PT_BlitVS, PT_BlitPS, PT_BlitVS, PT_BlitPS,
1, GPU_GetCommonQuadIndices(), 1, GPU_GetCommonQuadIndices(),
backbuffer, GPU_RasterMode_TriangleList); backbuffer, GPU_RasterMode_TriangleList);
GPU_ClearRenderTarget(cl, backbuffer, VEC4(1, 0, 0, 1));
} }
/* Finalize backbuffer layout */ /* Finalize backbuffer layout */

1
src/proto/proto_shaders.gpu
View File

@ -40,7 +40,6 @@ Struct(PT_BlitPSOutput)
VertexShader(PT_BlitVS, PT_BlitPSInput) VertexShader(PT_BlitVS, PT_BlitPSInput)
{ {
Vec2 uv = RectUvFromVertexId(SV_VertexID); Vec2 uv = RectUvFromVertexId(SV_VertexID);
PT_BlitPSInput result; PT_BlitPSInput result;
result.SV_Position = Vec4(NdcFromUv(uv).xy, 0, 1); result.SV_Position = Vec4(NdcFromUv(uv).xy, 0, 1);
result.src_uv = uv; result.src_uv = uv;