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

screwing with legacy barriers

Browse Source
This commit is contained in:
jacob 2026-02-21 03:04:17 -06:00
parent 110407a063
commit 7014b1f02e
8 changed files with 198 additions and 578 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/glyph_cache/glyph_cache.c
View File

@ -316,7 +316,6 @@ void GC_TickAsync(WaveLaneCtx *lane, AsyncFrameLaneCtx *base_async_lane_frame)
gpu_perm, cl, gpu_perm, cl,
G_Format_R8G8B8A8_Unorm_Srgb, G_Format_R8G8B8A8_Unorm_Srgb,
atlas->dims, atlas->dims,
G_Layout_AnyQueue_ShaderRead_CopyRead_CopyWrite_Present,
.name = Lit("Glyph atlas") .name = Lit("Glyph atlas")
); );
atlas->tex = G_PushTexture2DRef(gpu_perm, atlas->tex_res); atlas->tex = G_PushTexture2DRef(gpu_perm, atlas->tex_res);

4
src/gpu/gpu_common.c
View File

@ -25,7 +25,6 @@ void G_BootstrapCommon(void)
gpu_perm, cl, gpu_perm, cl,
G_Format_R8G8B8A8_Uint, G_Format_R8G8B8A8_Uint,
VEC2I32(8, 8), VEC2I32(8, 8),
G_Layout_AnyQueue_ShaderRead_CopyRead_CopyWrite_Present,
.flags = G_ResourceFlag_ZeroMemory .flags = G_ResourceFlag_ZeroMemory
); );
G.blank_tex = G_PushTexture2DRef(gpu_perm, blank_tex); G.blank_tex = G_PushTexture2DRef(gpu_perm, blank_tex);
@ -43,8 +42,7 @@ void G_BootstrapCommon(void)
noise_tex = G_PushTexture3D( noise_tex = G_PushTexture3D(
gpu_perm, cl, gpu_perm, cl,
G_Format_R16_Uint, G_Format_R16_Uint,
noise_dims, noise_dims
G_Layout_AnyQueue_ShaderRead_CopyRead_CopyWrite_Present
); );
G_CopyCpuToTexture( G_CopyCpuToTexture(
cl, cl,

181
src/gpu/gpu_core.h
View File

@ -188,132 +188,6 @@ Enum(G_Format)
G_Format_COUNT = 192 G_Format_COUNT = 192
}; };
////////////////////////////////////////////////////////////
//~ Memory sync types
Enum(G_Stage)
{
G_Stage_None = 0,
// Compute stages
G_Stage_ComputeShading = (1 << 1),
// Draw stages
G_Stage_IndexAssembly = (1 << 2),
G_Stage_VertexShading = (1 << 3),
G_Stage_PixelShading = (1 << 4),
G_Stage_DepthStencil = (1 << 5),
G_Stage_RenderTarget = (1 << 6),
// Copy stages
G_Stage_Copy = (1 << 7),
// Indirect stages
G_Stage_Indirect = (1 << 8),
// Aggregate stages
G_Stage_Drawing = G_Stage_IndexAssembly |
G_Stage_VertexShading |
G_Stage_PixelShading |
G_Stage_DepthStencil |
G_Stage_RenderTarget,
G_Stage_Shading = G_Stage_ComputeShading |
G_Stage_VertexShading |
G_Stage_PixelShading,
G_Stage_All = 0xFFFFFFFF
};
Enum(G_Access)
{
G_Access_None = 0,
G_Access_ShaderReadWrite = (1 << 1),
G_Access_ShaderRead = (1 << 2),
G_Access_CopyWrite = (1 << 3),
G_Access_CopyRead = (1 << 4),
G_Access_DepthStencilRead = (1 << 5),
G_Access_DepthStencilWrite = (1 << 6),
G_Access_RenderTargetWrite = (1 << 7),
G_Access_IndexBuffer = (1 << 8),
G_Access_IndirectArgument = (1 << 9),
G_Access_All = 0xFFFFFFFF // Represents all accesses relevant to the stage specified in the barrier
};
Enum(G_Layout)
{
G_Layout_NoChange,
// Simultaneous layout allows a resource to be used on any queue with any
// access type (except depth-stencil). Resources cannot transition to/from
// this layout, they must be created with it.
G_Layout_Simultaneous, // D3D12_BARRIER_LAYOUT_COMMON + D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS
G_Layout_Undefined, // D3D12_BARRIER_LAYOUT_UNDEFINED
//////////////////////////////
//- Queue-agnostic
G_Layout_AnyQueue_ShaderRead_CopyRead_CopyWrite_Present, // D3D12_BARRIER_LAYOUT_COMMON
//////////////////////////////
//- Direct & Compute queue
G_Layout_DirectComputeQueue_ShaderRead_CopyRead, // D3D12_BARRIER_LAYOUT_GENERIC_READ
G_Layout_DirectComputeQueue_ShaderReadWrite, // D3D12_BARRIER_LAYOUT_UNORDERED_ACCESS
G_Layout_DirectComputeQueue_ShaderRead, // D3D12_BARRIER_LAYOUT_SHADER_RESOURCE
G_Layout_DirectComputeQueue_CopyRead, // D3D12_BARRIER_LAYOUT_COPY_SOURCE
G_Layout_DirectComputeQueue_CopyWrite, // D3D12_BARRIER_LAYOUT_COPY_DEST
//////////////////////////////
//- Direct queue
G_Layout_DirectQueue_ShaderRead_ShaderReadWrite_CopyRead_CopyWrite, // D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COMMON
G_Layout_DirectQueue_ShaderRead_CopyRead_DepthStencilRead, // D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_GENERIC_READ
G_Layout_DirectQueue_ShaderReadWrite, // D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_UNORDERED_ACCESS
G_Layout_DirectQueue_ShaderRead, // D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_SHADER_RESOURCE
G_Layout_DirectQueue_CopyRead, // D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_SOURCE
G_Layout_DirectQueue_CopyWrite, // D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_DEST
G_Layout_DirectQueue_DepthStencilRead_DepthStencilWrite, // D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_WRITE
G_Layout_DirectQueue_DepthStencilRead, // D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_READ
G_Layout_DirectQueue_RenderTargetWrite, // D3D12_BARRIER_LAYOUT_RENDER_TARGET
//////////////////////////////
//- Compute queue
G_Layout_ComputeQueue_ShaderRead_ShaderReadWrite_CopyRead_CopyWrite, // D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COMMON
G_Layout_ComputeQueue_ShaderRead_CopyRead, // D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_GENERIC_READ
G_Layout_ComputeQueue_ShaderReadWrite, // D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_UNORDERED_ACCESS
G_Layout_ComputeQueue_ShaderRead, // D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_SHADER_RESOURCE
G_Layout_ComputeQueue_CopyRead, // D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_SOURCE
G_Layout_ComputeQueue_CopyWrite, // D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_DEST
};
// Barrier will execute after previous stages specified by `stage_prev`, and before next stages specified by `stage_next`.
// When barrier executes:
// - Necessary resource flushes will occur based on `access_prev` & `access_next`
// - Texture layout will transition based on `layout` (if specified)
Struct(G_MemoryBarrierDesc)
{
G_ResourceHandle resource;
b32 is_global;
G_Stage stage_prev;
G_Stage stage_next;
G_Access access_prev;
G_Access access_next;
G_Layout layout;
RngI32 mips; // Inclusive range of texture mip indices to sync
};
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Filter types //~ Filter types
@ -429,7 +303,6 @@ Struct(G_TextureDesc)
G_ResourceFlag flags; G_ResourceFlag flags;
G_Format format; G_Format format;
Vec3I32 dims; Vec3I32 dims;
G_Layout initial_layout;
Vec4 clear_color; Vec4 clear_color;
i32 max_mips; // Will be clamped to range [1, max mips] i32 max_mips; // Will be clamped to range [1, max mips]
String name; String name;
@ -551,37 +424,34 @@ G_ResourceHandle G_PushResource(G_ArenaHandle arena, G_CommandListHandle cl, G_R
} \ } \
) )
#define G_PushTexture1D(arena, cl, _format, _size, _initial_layout, ...) G_PushResource((arena), (cl), \ #define G_PushTexture1D(arena, cl, _format, _size, ...) G_PushResource((arena), (cl), \
(G_ResourceDesc) { \ (G_ResourceDesc) { \
.kind = G_ResourceKind_Texture1D, \ .kind = G_ResourceKind_Texture1D, \
.texture = { \ .texture = { \
.format = (_format), \ .format = (_format), \
.dims = VEC3I32((_size), 1, 1), \ .dims = VEC3I32((_size), 1, 1), \
.initial_layout = (_initial_layout), \
__VA_ARGS__ \ __VA_ARGS__ \
} \ } \
} \ } \
) )
#define G_PushTexture2D(arena, cl, _format, _size, _initial_layout, ...) G_PushResource((arena), (cl), \ #define G_PushTexture2D(arena, cl, _format, _size, ...) G_PushResource((arena), (cl), \
(G_ResourceDesc) { \ (G_ResourceDesc) { \
.kind = G_ResourceKind_Texture2D, \ .kind = G_ResourceKind_Texture2D, \
.texture = { \ .texture = { \
.format = (_format), \ .format = (_format), \
.dims = VEC3I32((_size).x, (_size).y, 1), \ .dims = VEC3I32((_size).x, (_size).y, 1), \
.initial_layout = (_initial_layout), \
__VA_ARGS__ \ __VA_ARGS__ \
} \ } \
} \ } \
) )
#define G_PushTexture3D(arena, cl, _format, _size, _initial_layout, ...) G_PushResource((arena), (cl), \ #define G_PushTexture3D(arena, cl, _format, _size, ...) G_PushResource((arena), (cl), \
(G_ResourceDesc) { \ (G_ResourceDesc) { \
.kind = G_ResourceKind_Texture3D, \ .kind = G_ResourceKind_Texture3D, \
.texture = { \ .texture = { \
.format = (_format), \ .format = (_format), \
.dims = (_size), \ .dims = (_size), \
.initial_layout = (_initial_layout), \
__VA_ARGS__ \ __VA_ARGS__ \
} \ } \
} \ } \
@ -738,50 +608,7 @@ void G_SetConstantEx(G_CommandListHandle cl, i32 slot, void *src_32bit, u32 size
//- Memory sync //- Memory sync
void G_MemorySyncEx(G_CommandListHandle cl, G_MemoryBarrierDesc desc); void G_Barrier(G_CommandListHandle cl);
#define G_MemorySync(_cl, _resource, _stage_prev, _access_prev, _stage_next, _access_next, ...) \
G_MemorySyncEx((_cl), (G_MemoryBarrierDesc) { \
.resource = (_resource), \
.stage_prev = _stage_prev, \
.access_prev = _access_prev, \
.stage_next = _stage_next, \
.access_next = _access_next, \
.mips.max = 64, \
__VA_ARGS__ \
})
#define G_MemoryLayoutSync(_cl, _resource, _stage_prev, _access_prev, _stage_next, _access_next, _layout, ...) \
G_MemorySyncEx((_cl), (G_MemoryBarrierDesc) { \
.resource = (_resource), \
.stage_prev = _stage_prev, \
.access_prev = _access_prev, \
.stage_next = _stage_next, \
.access_next = _access_next, \
.layout = _layout, \
.mips.max = 64, \
__VA_ARGS__ \
})
#define G_GlobalMemorySync(_cl, _stage_prev, _access_prev, _stage_next, _access_next, ...) \
G_MemorySyncEx((_cl), (G_MemoryBarrierDesc) { \
.is_global = 1, \
.stage_prev = _stage_prev, \
.access_prev = _access_prev, \
.stage_next = _stage_next, \
.access_next = _access_next, \
.mips.max = 64, \
__VA_ARGS__ \
})
#define G_DumbMemorySync(cl, resource, ...) \
G_MemorySync((cl), (resource), G_Stage_All, G_Access_All, G_Stage_All, G_Access_All, __VA_ARGS__)
#define G_DumbMemoryLayoutSync(cl, resource, layout, ...) \
G_MemoryLayoutSync((cl), (resource), G_Stage_All, G_Access_All, G_Stage_All, G_Access_All, (layout), __VA_ARGS__)
#define G_DumbGlobalMemorySync(cl, ...) \
G_GlobalMemorySync((cl), G_Stage_All, G_Access_All, G_Stage_All, G_Access_All, __VA_ARGS__)
//- Compute //- Compute

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

@ -57,7 +57,7 @@ void G_Bootstrap(void)
// Create device // Create device
{ {
IDXGIAdapter3 *adapter = 0; IDXGIAdapter3 *adapter = 0;
ID3D12Device10 *device = 0; ID3D12Device1 *device = 0;
String error = Lit("Could not initialize GPU device."); String error = Lit("Could not initialize GPU device.");
String first_gpu_name = Zi; String first_gpu_name = Zi;
u32 adapter_index = 0; u32 adapter_index = 0;
@ -80,7 +80,7 @@ void G_Bootstrap(void)
// - ResourceBindingTier >= D3D12_RESOURCE_BINDING_TIER_3 // - ResourceBindingTier >= D3D12_RESOURCE_BINDING_TIER_3
// - EnhancedBarriersSupported == 1 // - EnhancedBarriersSupported == 1
// - AtomicInt64OnDescriptorHeapResourceSupported == 1 // - AtomicInt64OnDescriptorHeapResourceSupported == 1
hr = D3D12CreateDevice((IUnknown *)adapter, D3D_FEATURE_LEVEL_12_0, &IID_ID3D12Device10, (void **)&device); hr = D3D12CreateDevice((IUnknown *)adapter, D3D_FEATURE_LEVEL_12_0, &IID_ID3D12Device1, (void **)&device);
} }
if (SUCCEEDED(hr) && skips <= 0) if (SUCCEEDED(hr) && skips <= 0)
{ {
@ -378,136 +378,6 @@ DXGI_FORMAT G_D12_DxgiFormatFromGpuFormat(G_Format format)
return (DXGI_FORMAT)format; return (DXGI_FORMAT)format;
} }
D3D12_BARRIER_SYNC G_D12_BarrierSyncFromStages(G_Stage stages)
{
D3D12_BARRIER_SYNC result = 0;
if (stages == G_Stage_All)
{
result = D3D12_BARRIER_SYNC_ALL;
}
else
{
result |= D3D12_BARRIER_SYNC_COMPUTE_SHADING * AnyBit(stages, G_Stage_ComputeShading);
result |= D3D12_BARRIER_SYNC_INDEX_INPUT * AnyBit(stages, G_Stage_IndexAssembly);
result |= D3D12_BARRIER_SYNC_VERTEX_SHADING * AnyBit(stages, G_Stage_VertexShading);
result |= D3D12_BARRIER_SYNC_PIXEL_SHADING * AnyBit(stages, G_Stage_PixelShading);
result |= D3D12_BARRIER_SYNC_DEPTH_STENCIL * AnyBit(stages, G_Stage_DepthStencil);
result |= D3D12_BARRIER_SYNC_RENDER_TARGET * AnyBit(stages, G_Stage_RenderTarget);
result |= D3D12_BARRIER_SYNC_COPY * AnyBit(stages, G_Stage_Copy);
result |= D3D12_BARRIER_SYNC_EXECUTE_INDIRECT * AnyBit(stages, G_Stage_Indirect);
}
return result;
}
D3D12_BARRIER_ACCESS G_D12_BarrierAccessFromAccesses(G_Access accesses)
{
D3D12_BARRIER_ACCESS result = 0;
if (accesses == 0)
{
result = D3D12_BARRIER_ACCESS_NO_ACCESS;
}
else if (accesses == G_Access_All)
{
result = D3D12_BARRIER_ACCESS_COMMON;
}
else
{
result |= D3D12_BARRIER_ACCESS_UNORDERED_ACCESS * AnyBit(accesses, G_Access_ShaderReadWrite);
result |= D3D12_BARRIER_ACCESS_SHADER_RESOURCE * AnyBit(accesses, G_Access_ShaderRead);
result |= D3D12_BARRIER_ACCESS_COPY_DEST * AnyBit(accesses, G_Access_CopyWrite);
result |= D3D12_BARRIER_ACCESS_COPY_SOURCE * AnyBit(accesses, G_Access_CopyRead);
result |= D3D12_BARRIER_ACCESS_INDEX_BUFFER * AnyBit(accesses, G_Access_IndexBuffer);
result |= D3D12_BARRIER_ACCESS_INDIRECT_ARGUMENT * AnyBit(accesses, G_Access_IndirectArgument);
result |= D3D12_BARRIER_ACCESS_DEPTH_STENCIL_READ * AnyBit(accesses, G_Access_DepthStencilRead);
result |= D3D12_BARRIER_ACCESS_DEPTH_STENCIL_WRITE * AnyBit(accesses, G_Access_DepthStencilWrite);
result |= D3D12_BARRIER_ACCESS_RENDER_TARGET * AnyBit(accesses, G_Access_RenderTargetWrite);
}
return result;
}
D3D12_BARRIER_LAYOUT G_D12_BarrierLayoutFromLayout(G_Layout layout)
{
PERSIST Readonly D3D12_BARRIER_LAYOUT translate[] = {
[G_Layout_Undefined] = D3D12_BARRIER_LAYOUT_UNDEFINED,
[G_Layout_Simultaneous] = D3D12_BARRIER_LAYOUT_COMMON,
[G_Layout_AnyQueue_ShaderRead_CopyRead_CopyWrite_Present] = D3D12_BARRIER_LAYOUT_COMMON,
[G_Layout_DirectComputeQueue_ShaderReadWrite] = D3D12_BARRIER_LAYOUT_UNORDERED_ACCESS,
[G_Layout_DirectComputeQueue_ShaderRead_CopyRead] = D3D12_BARRIER_LAYOUT_GENERIC_READ,
[G_Layout_DirectComputeQueue_ShaderRead] = D3D12_BARRIER_LAYOUT_SHADER_RESOURCE,
[G_Layout_DirectComputeQueue_CopyRead] = D3D12_BARRIER_LAYOUT_COPY_SOURCE,
[G_Layout_DirectComputeQueue_CopyWrite] = D3D12_BARRIER_LAYOUT_COPY_DEST,
[G_Layout_DirectQueue_ShaderRead_ShaderReadWrite_CopyRead_CopyWrite] = D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COMMON,
[G_Layout_DirectQueue_ShaderReadWrite] = D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_UNORDERED_ACCESS,
[G_Layout_DirectQueue_ShaderRead_CopyRead_DepthStencilRead] = D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_GENERIC_READ,
[G_Layout_DirectQueue_ShaderRead] = D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_SHADER_RESOURCE,
[G_Layout_DirectQueue_CopyRead] = D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_SOURCE,
[G_Layout_DirectQueue_CopyWrite] = D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_DEST,
[G_Layout_DirectQueue_DepthStencilRead_DepthStencilWrite] = D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_WRITE,
[G_Layout_DirectQueue_DepthStencilRead] = D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_READ,
[G_Layout_DirectQueue_RenderTargetWrite] = D3D12_BARRIER_LAYOUT_RENDER_TARGET,
[G_Layout_ComputeQueue_ShaderRead_ShaderReadWrite_CopyRead_CopyWrite] = D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COMMON,
[G_Layout_ComputeQueue_ShaderReadWrite] = D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_UNORDERED_ACCESS,
[G_Layout_ComputeQueue_ShaderRead_CopyRead] = D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_GENERIC_READ,
[G_Layout_ComputeQueue_ShaderRead] = D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_SHADER_RESOURCE,
[G_Layout_ComputeQueue_CopyRead] = D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_SOURCE,
[G_Layout_ComputeQueue_CopyWrite] = D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_DEST,
};
D3D12_BARRIER_LAYOUT result = D3D12_BARRIER_LAYOUT_UNDEFINED;
if (layout >= 0 && layout < countof(translate))
{
result = translate[layout];
}
return result;
};
String G_D12_NameFromBarrierLayout(D3D12_BARRIER_LAYOUT layout)
{
PERSIST Readonly String names[] = {
[D3D12_BARRIER_LAYOUT_COMMON] = CompLit("D3D12_BARRIER_LAYOUT_COMMON"),
[D3D12_BARRIER_LAYOUT_PRESENT] = CompLit("D3D12_BARRIER_LAYOUT_PRESENT"),
[D3D12_BARRIER_LAYOUT_GENERIC_READ] = CompLit("D3D12_BARRIER_LAYOUT_GENERIC_READ"),
[D3D12_BARRIER_LAYOUT_RENDER_TARGET] = CompLit("D3D12_BARRIER_LAYOUT_RENDER_TARGET"),
[D3D12_BARRIER_LAYOUT_UNORDERED_ACCESS] = CompLit("D3D12_BARRIER_LAYOUT_UNORDERED_ACCESS"),
[D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_WRITE] = CompLit("D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_WRITE"),
[D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_READ] = CompLit("D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_READ"),
[D3D12_BARRIER_LAYOUT_SHADER_RESOURCE] = CompLit("D3D12_BARRIER_LAYOUT_SHADER_RESOURCE"),
[D3D12_BARRIER_LAYOUT_COPY_SOURCE] = CompLit("D3D12_BARRIER_LAYOUT_COPY_SOURCE"),
[D3D12_BARRIER_LAYOUT_COPY_DEST] = CompLit("D3D12_BARRIER_LAYOUT_COPY_DEST"),
[D3D12_BARRIER_LAYOUT_RESOLVE_SOURCE] = CompLit("D3D12_BARRIER_LAYOUT_RESOLVE_SOURCE"),
[D3D12_BARRIER_LAYOUT_RESOLVE_DEST] = CompLit("D3D12_BARRIER_LAYOUT_RESOLVE_DEST"),
[D3D12_BARRIER_LAYOUT_SHADING_RATE_SOURCE] = CompLit("D3D12_BARRIER_LAYOUT_SHADING_RATE_SOURCE"),
[D3D12_BARRIER_LAYOUT_VIDEO_DECODE_READ] = CompLit("D3D12_BARRIER_LAYOUT_VIDEO_DECODE_READ"),
[D3D12_BARRIER_LAYOUT_VIDEO_DECODE_WRITE] = CompLit("D3D12_BARRIER_LAYOUT_VIDEO_DECODE_WRITE"),
[D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_READ] = CompLit("D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_READ"),
[D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_WRITE] = CompLit("D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_WRITE"),
[D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_READ] = CompLit("D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_READ"),
[D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_WRITE] = CompLit("D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_WRITE"),
[D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COMMON] = CompLit("D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COMMON"),
[D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_GENERIC_READ] = CompLit("D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_GENERIC_READ"),
[D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_UNORDERED_ACCESS] = CompLit("D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_UNORDERED_ACCESS"),
[D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_SHADER_RESOURCE] = CompLit("D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_SHADER_RESOURCE"),
[D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_SOURCE] = CompLit("D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_SOURCE"),
[D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_DEST] = CompLit("D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_DEST"),
[D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COMMON] = CompLit("D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COMMON"),
[D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_GENERIC_READ] = CompLit("D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_GENERIC_READ"),
[D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_UNORDERED_ACCESS] = CompLit("D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_UNORDERED_ACCESS"),
[D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_SHADER_RESOURCE] = CompLit("D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_SHADER_RESOURCE"),
[D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_SOURCE] = CompLit("D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_SOURCE"),
[D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_DEST] = CompLit("D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_DEST"),
[D3D12_BARRIER_LAYOUT_VIDEO_QUEUE_COMMON] = CompLit("D3D12_BARRIER_LAYOUT_VIDEO_QUEUE_COMMON")
};
String result = Zi;
if (layout >= 0 && layout < countof(names))
{
result = names[layout];
}
else if (layout == D3D12_BARRIER_LAYOUT_UNDEFINED)
{
result = Lit("D3D12_BARRIER_LAYOUT_UNDEFINED");
}
return result;
}
void G_D12_InitRtv(G_D12_Resource *resource, D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle, i32 mip) void G_D12_InitRtv(G_D12_Resource *resource, D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle, i32 mip)
{ {
DXGI_FORMAT format = G_D12_DxgiFormatFromGpuFormat(resource->texture_format); DXGI_FORMAT format = G_D12_DxgiFormatFromGpuFormat(resource->texture_format);
@ -871,7 +741,7 @@ G_D12_RawCommandList *G_D12_PrepareRawCommandList(G_QueueKind queue_kind)
if (SUCCEEDED(hr)) if (SUCCEEDED(hr))
{ {
hr = ID3D12Device_CreateCommandList(G_D12.device, 0, queue->desc.type, cl->d3d_ca, 0, &IID_ID3D12GraphicsCommandList7, (void **)&cl->d3d_cl); hr = ID3D12Device_CreateCommandList(G_D12.device, 0, queue->desc.type, cl->d3d_ca, 0, &IID_ID3D12GraphicsCommandList, (void **)&cl->d3d_cl);
} }
if (SUCCEEDED(hr)) if (SUCCEEDED(hr))
@ -1115,9 +985,9 @@ G_ResourceHandle G_PushResource(G_ArenaHandle arena_handle, G_CommandListHandle
////////////////////////////// //////////////////////////////
//- Initialize d3d resource desc //- Initialize d3d resource desc
D3D12_BARRIER_LAYOUT d3d_initial_layout = D3D12_BARRIER_LAYOUT_UNDEFINED; D3D12_RESOURCE_STATES d3d_initial_state = D3D12_RESOURCE_STATE_COMMON;
D3D12_CLEAR_VALUE clear_value = Zi; D3D12_CLEAR_VALUE clear_value = Zi;
D3D12_RESOURCE_DESC1 d3d_desc = Zi; D3D12_RESOURCE_DESC d3d_desc = Zi;
if (is_buffer) if (is_buffer)
{ {
u64 min_buffer_size = 1024; u64 min_buffer_size = 1024;
@ -1136,7 +1006,6 @@ G_ResourceHandle G_PushResource(G_ArenaHandle arena_handle, G_CommandListHandle
{ {
i32 largest_dim = MaxI32(MaxI32(desc.texture.dims.x, desc.texture.dims.y), desc.texture.dims.z); i32 largest_dim = MaxI32(MaxI32(desc.texture.dims.x, desc.texture.dims.y), desc.texture.dims.z);
i32 max_mips = MinI32(FloorF32(Log2F32(largest_dim)) + 1, G_MaxMips); i32 max_mips = MinI32(FloorF32(Log2F32(largest_dim)) + 1, G_MaxMips);
d3d_initial_layout = G_D12_BarrierLayoutFromLayout(desc.texture.initial_layout);
d3d_desc.Dimension = ( d3d_desc.Dimension = (
desc.kind == G_ResourceKind_Texture1D ? D3D12_RESOURCE_DIMENSION_TEXTURE1D : desc.kind == G_ResourceKind_Texture1D ? D3D12_RESOURCE_DIMENSION_TEXTURE1D :
desc.kind == G_ResourceKind_Texture2D ? D3D12_RESOURCE_DIMENSION_TEXTURE2D : desc.kind == G_ResourceKind_Texture2D ? D3D12_RESOURCE_DIMENSION_TEXTURE2D :
@ -1153,7 +1022,10 @@ G_ResourceHandle G_PushResource(G_ArenaHandle arena_handle, G_CommandListHandle
d3d_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS * AnyBit(flags, G_ResourceFlag_AllowShaderReadWrite); d3d_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS * AnyBit(flags, G_ResourceFlag_AllowShaderReadWrite);
d3d_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET * AnyBit(flags, G_ResourceFlag_AllowRenderTarget); d3d_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET * AnyBit(flags, G_ResourceFlag_AllowRenderTarget);
d3d_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL * AnyBit(flags, G_ResourceFlag_AllowDepthStencil); d3d_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL * AnyBit(flags, G_ResourceFlag_AllowDepthStencil);
d3d_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS * (desc.texture.initial_layout == G_Layout_Simultaneous); if (!AnyBit(d3d_desc.Flags, D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL))
{
d3d_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS;
}
clear_value.Color[0] = desc.texture.clear_color.x, clear_value.Color[0] = desc.texture.clear_color.x,
clear_value.Color[1] = desc.texture.clear_color.y, clear_value.Color[1] = desc.texture.clear_color.y,
clear_value.Color[2] = desc.texture.clear_color.z, clear_value.Color[2] = desc.texture.clear_color.z,
@ -1171,8 +1043,8 @@ G_ResourceHandle G_PushResource(G_ArenaHandle arena_handle, G_CommandListHandle
DllQueueRemove(gpu_arena->reset_resources.first, gpu_arena->reset_resources.last, resource); DllQueueRemove(gpu_arena->reset_resources.first, gpu_arena->reset_resources.last, resource);
--gpu_arena->reset_resources.count; --gpu_arena->reset_resources.count;
D3D12_RESOURCE_DESC1 reset_d3d_desc = Zi; D3D12_RESOURCE_DESC reset_d3d_desc = Zi;
D3D12_RESOURCE_DESC1 compare_d3d_desc = Zi; D3D12_RESOURCE_DESC compare_d3d_desc = Zi;
CopyStruct(&reset_d3d_desc, &resource->d3d_desc); CopyStruct(&reset_d3d_desc, &resource->d3d_desc);
CopyStruct(&compare_d3d_desc, &reset_d3d_desc); CopyStruct(&compare_d3d_desc, &reset_d3d_desc);
@ -1269,26 +1141,18 @@ G_ResourceHandle G_PushResource(G_ArenaHandle arena_handle, G_CommandListHandle
{ {
clear_value_arg = &clear_value; clear_value_arg = &clear_value;
} }
HRESULT hr = ID3D12Device10_CreateCommittedResource3( HRESULT hr = ID3D12Device_CreateCommittedResource(
G_D12.device, G_D12.device,
&heap_props, &heap_props,
heap_flags, heap_flags,
&resource->d3d_desc, &resource->d3d_desc,
d3d_initial_layout, d3d_initial_state,
clear_value_arg, clear_value_arg,
0, // pProtectedSession
0, // NumCastableFormats
0, // pCastableFormats
&IID_ID3D12Resource, &IID_ID3D12Resource,
(void **)&resource->d3d_resource (void **)&resource->d3d_resource
); );
Atomic64FetchAdd(&G_D12.cumulative_nonreuse_count, 1); Atomic64FetchAdd(&G_D12.cumulative_nonreuse_count, 1);
for (i32 mip_idx = 0; mip_idx < resource->texture_mips; ++mip_idx)
{
resource->cmdlist_texture_layouts[mip_idx] = d3d_initial_layout;
}
if (!SUCCEEDED(hr)) if (!SUCCEEDED(hr))
{ {
// TODO: Don't panic // TODO: Don't panic
@ -1339,14 +1203,8 @@ G_ResourceHandle G_PushResource(G_ArenaHandle arena_handle, G_CommandListHandle
if (can_reuse) if (can_reuse)
{ {
if (is_buffer) // FIXME: Remove this
{ G_Barrier(cl_handle);
G_DumbMemorySync(cl_handle, G_D12_MakeHandle(G_ResourceHandle, resource));
}
else if (is_texture)
{
G_DumbMemoryLayoutSync(cl_handle, G_D12_MakeHandle(G_ResourceHandle, resource), desc.texture.initial_layout);
}
} }
return G_D12_MakeHandle(G_ResourceHandle, resource); return G_D12_MakeHandle(G_ResourceHandle, resource);
@ -1960,7 +1818,7 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
// Begin dx12 command list // Begin dx12 command list
G_D12_RawCommandList *rcl = G_D12_PrepareRawCommandList(queue_kind); G_D12_RawCommandList *rcl = G_D12_PrepareRawCommandList(queue_kind);
ID3D12GraphicsCommandList7 *d3d_cl = rcl->d3d_cl; ID3D12GraphicsCommandList *d3d_cl = rcl->d3d_cl;
// Pipeline state // Pipeline state
b32 graphics_rootsig_set = 0; b32 graphics_rootsig_set = 0;
@ -2027,9 +1885,7 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
} }
// Batch barrier cmds // Batch barrier cmds
i64 max_buffer_barriers = 0; i64 max_barriers = 0;
i64 max_texture_barriers = 0;
i64 max_global_barriers = 0;
{ {
u64 cmd_idx = 0; u64 cmd_idx = 0;
u64 batch_gen = 0; u64 batch_gen = 0;
@ -2060,31 +1916,12 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
if (prev_barrier_cmd->barrier.batch_gen != batch_gen) if (prev_barrier_cmd->barrier.batch_gen != batch_gen)
{ {
// 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.should_commit = 1;
} }
} }
cmd->barrier.batch_gen = batch_gen; cmd->barrier.batch_gen = batch_gen;
prev_barrier_cmd = cmd; prev_barrier_cmd = cmd;
max_barriers += 1;
if (cmd->barrier.desc.is_global)
{
max_global_barriers += 1;
}
else
{
G_D12_Resource *resource = G_D12_ResourceFromHandle(cmd->barrier.desc.resource);
if (resource->is_texture)
{
RngI32 mips = cmd->barrier.desc.mips;
mips.min = ClampI32(mips.min, 0, resource->texture_mips - 1);
mips.max = ClampI32(mips.max, mips.min, resource->texture_mips - 1);
max_texture_barriers += mips.max - mips.min + 1;
}
else
{
max_buffer_barriers += 1;
}
}
cmd_idx += 1; cmd_idx += 1;
} break; } break;
@ -2093,15 +1930,12 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
if (prev_barrier_cmd) if (prev_barrier_cmd)
{ {
prev_barrier_cmd->barrier.is_end_of_batch = 1; prev_barrier_cmd->barrier.should_commit = 1;
} }
} }
// Build d3d commands // Build d3d commands
{ {
u64 batch_barrier_idx_start = 0;
u64 batch_barrier_idx_opl = 0; // One past last
u64 cmd_idx = 0; u64 cmd_idx = 0;
while (cmd_idx < cmds_count) while (cmd_idx < cmds_count)
{ {
@ -2130,133 +1964,11 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
case G_D12_CmdKind_Barrier: case G_D12_CmdKind_Barrier:
{ {
batch_barrier_idx_opl = cmd_idx + 1; if (cmd->barrier.should_commit)
// Submit batched barriers
if (cmd->barrier.is_end_of_batch)
{ {
// Build barriers D3D12_RESOURCE_BARRIER barrier = Zi;
u64 buffer_barriers_count = 0; barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV;
u64 texture_barriers_count = 0; ID3D12GraphicsCommandList_ResourceBarrier(d3d_cl, 1, &barrier);
u64 global_barriers_count = 0;
D3D12_BUFFER_BARRIER *buffer_barriers = PushStructs(scratch.arena, D3D12_BUFFER_BARRIER, max_buffer_barriers);
D3D12_TEXTURE_BARRIER *texture_barriers = PushStructs(scratch.arena, D3D12_TEXTURE_BARRIER, max_texture_barriers);
D3D12_GLOBAL_BARRIER *global_barriers = PushStructs(scratch.arena, D3D12_GLOBAL_BARRIER, max_global_barriers);
for (u64 barrier_cmd_idx = batch_barrier_idx_start; barrier_cmd_idx < batch_barrier_idx_opl; ++barrier_cmd_idx)
{
G_D12_Cmd *barrier_cmd = &cmds[barrier_cmd_idx];
if (barrier_cmd->kind == G_D12_CmdKind_Barrier)
{
G_MemoryBarrierDesc desc = barrier_cmd->barrier.desc;
// Translate gpu barrier kind -> d3d barrier fields
D3D12_BARRIER_SYNC sync_before = G_D12_BarrierSyncFromStages(desc.stage_prev);
D3D12_BARRIER_SYNC sync_after = G_D12_BarrierSyncFromStages(desc.stage_next);
D3D12_BARRIER_ACCESS access_before = G_D12_BarrierAccessFromAccesses(desc.access_prev);
D3D12_BARRIER_ACCESS access_after = G_D12_BarrierAccessFromAccesses(desc.access_next);
D3D12_BARRIER_TYPE barrier_type = D3D12_BARRIER_TYPE_GLOBAL;
if (!desc.is_global)
{
G_D12_Resource *resource = G_D12_ResourceFromHandle(desc.resource);
barrier_type = resource->is_texture ? D3D12_BARRIER_TYPE_TEXTURE : D3D12_BARRIER_TYPE_BUFFER;
}
// Build barrier
switch (barrier_type)
{
case D3D12_BARRIER_TYPE_BUFFER:
{
G_D12_Resource *resource = G_D12_ResourceFromHandle(desc.resource);
D3D12_BUFFER_BARRIER *barrier = &buffer_barriers[buffer_barriers_count++];
barrier->SyncBefore = sync_before;
barrier->SyncAfter = sync_after;
barrier->AccessBefore = access_before;
barrier->AccessAfter = access_after;
barrier->pResource = resource->d3d_resource;
barrier->Offset = 0;
barrier->Size = U64Max;
} break;
case D3D12_BARRIER_TYPE_TEXTURE:
{
G_D12_Resource *resource = G_D12_ResourceFromHandle(desc.resource);
RngI32 mips = barrier_cmd->barrier.desc.mips;
{
mips.min = ClampI32(mips.min, 0, resource->texture_mips - 1);
mips.max = ClampI32(mips.max, mips.min, resource->texture_mips - 1);
}
// Create a barrier for each contiguous span of mips with matching layout
D3D12_TEXTURE_BARRIER *barrier = 0;
for (i32 mip_idx = mips.min; mip_idx <= mips.max; ++mip_idx)
{
D3D12_BARRIER_LAYOUT layout_before = resource->cmdlist_texture_layouts[mip_idx];
D3D12_BARRIER_LAYOUT layout_after = layout_before;
if (desc.layout != G_Layout_NoChange)
{
layout_after = G_D12_BarrierLayoutFromLayout(desc.layout);
}
if (barrier == 0 || barrier->LayoutBefore != layout_before)
{
barrier = &texture_barriers[texture_barriers_count++];
barrier->SyncBefore = sync_before;
barrier->SyncAfter = sync_after;
barrier->AccessBefore = access_before;
barrier->AccessAfter = access_after;
barrier->LayoutBefore = layout_before;
barrier->LayoutAfter = layout_after;
barrier->pResource = resource->d3d_resource;
barrier->Subresources.IndexOrFirstMipLevel = mip_idx;
barrier->Subresources.NumArraySlices = 1;
barrier->Subresources.NumPlanes = 1;
}
barrier->Subresources.NumMipLevels += 1;
resource->cmdlist_texture_layouts[mip_idx] = layout_after;
}
} break;
case D3D12_BARRIER_TYPE_GLOBAL:
{
D3D12_GLOBAL_BARRIER *barrier = &global_barriers[global_barriers_count++];
barrier->SyncBefore = sync_before;
barrier->SyncAfter = sync_after;
barrier->AccessBefore = access_before;
barrier->AccessAfter = access_after;
} break;
}
}
}
// Dispatch barriers
{
u32 barrier_groups_count = 0;
D3D12_BARRIER_GROUP barrier_groups[3] = Zi;
if (buffer_barriers_count > 0)
{
D3D12_BARRIER_GROUP *group = &barrier_groups[barrier_groups_count++];
group->Type = D3D12_BARRIER_TYPE_BUFFER;
group->NumBarriers = buffer_barriers_count;
group->pBufferBarriers = buffer_barriers;
}
if (texture_barriers_count > 0)
{
D3D12_BARRIER_GROUP *group = &barrier_groups[barrier_groups_count++];
group->Type = D3D12_BARRIER_TYPE_TEXTURE;
group->NumBarriers = texture_barriers_count;
group->pTextureBarriers = texture_barriers;
}
if (global_barriers_count > 0)
{
D3D12_BARRIER_GROUP *group = &barrier_groups[barrier_groups_count++];
group->Type = D3D12_BARRIER_TYPE_GLOBAL;
group->NumBarriers = global_barriers_count;
group->pGlobalBarriers = global_barriers;
}
if (barrier_groups_count > 0)
{
ID3D12GraphicsCommandList7_Barrier(d3d_cl, barrier_groups_count, barrier_groups);
}
}
batch_barrier_idx_start = cmd_idx + 1;
} }
cmd_idx += 1; cmd_idx += 1;
@ -2277,6 +1989,32 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
copy_size copy_size
); );
cmd_idx += 1; cmd_idx += 1;
// FIXME: Remove this (only apply during Barrier command on any implicit resource transitions that occured)
D3D12_RESOURCE_BARRIER barriers[2] = Zi;
{
D3D12_RESOURCE_BARRIER *barrier = &barriers[0];
barrier->Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier->Transition.pResource = cmd->copy_bytes.dst->d3d_resource;
barrier->Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
barrier->Transition.StateBefore = D3D12_RESOURCE_STATE_COPY_DEST;
barrier->Transition.StateAfter = D3D12_RESOURCE_STATE_COMMON;
}
{
D3D12_RESOURCE_BARRIER *barrier = &barriers[1];
barrier->Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier->Transition.pResource = cmd->copy_bytes.src->d3d_resource;
barrier->Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
barrier->Transition.StateBefore = D3D12_RESOURCE_STATE_COPY_SOURCE;
barrier->Transition.StateAfter = D3D12_RESOURCE_STATE_COMMON;
}
ID3D12GraphicsCommandList_ResourceBarrier(d3d_cl, 2, barriers);
} break; } break;
//- Copy texels //- Copy texels
@ -2316,6 +2054,28 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
ID3D12GraphicsCommandList_CopyTextureRegion(d3d_cl, &dst_loc, dst_offset.x, dst_offset.y, dst_offset.z, &src_loc, src_box_ptr); ID3D12GraphicsCommandList_CopyTextureRegion(d3d_cl, &dst_loc, dst_offset.x, dst_offset.y, dst_offset.z, &src_loc, src_box_ptr);
} }
// FIXME: Remove this (only apply during Barrier command on any implicit resource transitions that occured)
D3D12_RESOURCE_BARRIER barriers[2] = Zi;
{
D3D12_RESOURCE_BARRIER *barrier = &barriers[0];
barrier->Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier->Transition.pResource = dst->d3d_resource;
barrier->Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
barrier->Transition.StateBefore = D3D12_RESOURCE_STATE_COPY_DEST;
barrier->Transition.StateAfter = D3D12_RESOURCE_STATE_COMMON;
}
{
D3D12_RESOURCE_BARRIER *barrier = &barriers[1];
barrier->Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier->Transition.pResource = src->d3d_resource;
barrier->Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
barrier->Transition.StateBefore = D3D12_RESOURCE_STATE_COPY_SOURCE;
barrier->Transition.StateAfter = D3D12_RESOURCE_STATE_COMMON;
}
ID3D12GraphicsCommandList_ResourceBarrier(d3d_cl, 2, barriers);
cmd_idx += 1; cmd_idx += 1;
} break; } break;
@ -2549,20 +2309,31 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
} }
// Bind render targets // Bind render targets
u32 barriers_count = 0;
D3D12_RESOURCE_BARRIER barriers[G_MaxRenderTargets] = Zi;
{ {
b32 om_dirty = 0;
u32 rtvs_count = 0; u32 rtvs_count = 0;
for (u32 i = 0; i < countof(cmd->rasterize.render_target_descs); ++i) b32 om_dirty = 0;
for (u32 rtv_idx = 0; rtv_idx < countof(cmd->rasterize.render_target_descs); ++rtv_idx)
{ {
G_RenderTargetDesc desc = cmd->rasterize.render_target_descs[i]; G_RenderTargetDesc desc = cmd->rasterize.render_target_descs[rtv_idx];
G_D12_Resource *rt = G_D12_ResourceFromHandle(desc.resource); G_D12_Resource *rt = G_D12_ResourceFromHandle(desc.resource);
if (rt) if (rt)
{ {
if (bound_render_target_uids[i] != rt->uid + desc.mip)
{ {
G_D12_Descriptor *rtv_descriptor = rcl->rtv_descriptors[i]; D3D12_RESOURCE_BARRIER *barrier = &barriers[barriers_count];
barrier->Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier->Transition.pResource = rt->d3d_resource;
barrier->Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
barrier->Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
barrier->Transition.StateAfter = D3D12_RESOURCE_STATE_COMMON;
++barriers_count;
}
if (bound_render_target_uids[rtv_idx] != rt->uid + desc.mip)
{
G_D12_Descriptor *rtv_descriptor = rcl->rtv_descriptors[rtv_idx];
G_D12_InitRtv(rt, rtv_descriptor->handle, desc.mip); G_D12_InitRtv(rt, rtv_descriptor->handle, desc.mip);
bound_render_target_uids[i] = rt->uid + desc.mip; bound_render_target_uids[rtv_idx] = rt->uid + desc.mip;
om_dirty = 1; om_dirty = 1;
} }
++rtvs_count; ++rtvs_count;
@ -2575,9 +2346,9 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
if (om_dirty) if (om_dirty)
{ {
D3D12_CPU_DESCRIPTOR_HANDLE rtv_handles[G_MaxRenderTargets] = Zi; D3D12_CPU_DESCRIPTOR_HANDLE rtv_handles[G_MaxRenderTargets] = Zi;
for (u32 i = 0; i < rtvs_count; ++i) for (u32 rtv_idx = 0; rtv_idx < rtvs_count; ++rtv_idx)
{ {
rtv_handles[i] = rcl->rtv_descriptors[i]->handle; rtv_handles[rtv_idx] = rcl->rtv_descriptors[rtv_idx]->handle;
} }
ID3D12GraphicsCommandList_OMSetRenderTargets(d3d_cl, rtvs_count, rtv_handles, 0, 0); ID3D12GraphicsCommandList_OMSetRenderTargets(d3d_cl, rtvs_count, rtv_handles, 0, 0);
} }
@ -2585,6 +2356,10 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
// Dispatch // Dispatch
ID3D12GraphicsCommandList_DrawIndexedInstanced(d3d_cl, indices_count, cmd->rasterize.instances_count, 0, 0, 0); ID3D12GraphicsCommandList_DrawIndexedInstanced(d3d_cl, indices_count, cmd->rasterize.instances_count, 0, 0, 0);
// FIXME: Remove this (only apply during Barrier command on any implicit resource transitions that occured)
// FIXME: Does the implicit promotion happen during Draw? Or during OMSetRenderTargets?
ID3D12GraphicsCommandList_ResourceBarrier(d3d_cl, barriers_count, barriers);
} }
cmd_idx += 1; cmd_idx += 1;
@ -2610,6 +2385,17 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
} }
ID3D12GraphicsCommandList_ClearRenderTargetView(d3d_cl, rtv_handle, clear_color, 0, 0); ID3D12GraphicsCommandList_ClearRenderTargetView(d3d_cl, rtv_handle, clear_color, 0, 0);
cmd_idx += 1; cmd_idx += 1;
// FIXME: Remove this (only apply during Barrier command on any implicit resource transitions that occured)
D3D12_RESOURCE_BARRIER barrier = Zi;
{
barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier.Transition.pResource = rt->d3d_resource;
barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_COMMON;
}
ID3D12GraphicsCommandList_ResourceBarrier(d3d_cl, 1, &barrier);
} break; } break;
//- Discard rtv //- Discard rtv
@ -2622,35 +2408,49 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
G_D12_Resource *resource = cmd->discard_rtv.render_target; G_D12_Resource *resource = cmd->discard_rtv.render_target;
ID3D12GraphicsCommandList_DiscardResource(d3d_cl, resource->d3d_resource, 0); ID3D12GraphicsCommandList_DiscardResource(d3d_cl, resource->d3d_resource, 0);
cmd_idx += 1; cmd_idx += 1;
// FIXME: Remove this (only apply during Barrier command on any implicit resource transitions that occured)
D3D12_RESOURCE_BARRIER barrier = Zi;
{
barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier.Transition.pResource = resource->d3d_resource;
barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_COMMON;
}
ID3D12GraphicsCommandList_ResourceBarrier(d3d_cl, 1, &barrier);
} break; } break;
//- Log //- Log
case G_D12_CmdKind_Log: case G_D12_CmdKind_Log:
{ {
G_D12_Resource *resource = cmd->log.resource; // FIXME
String resource_name = STRING(resource->name_len, resource->name_text);
String layouts_str = Zi; // G_D12_Resource *resource = cmd->log.resource;
{ // String resource_name = STRING(resource->name_len, resource->name_text);
StringList layout_names = Zi;
for (i32 mip_idx = 0; mip_idx < resource->texture_mips; ++mip_idx) // String layouts_str = Zi;
{ // {
String layout_name = G_D12_NameFromBarrierLayout(resource->cmdlist_texture_layouts[mip_idx]); // StringList layout_names = Zi;
String layout_str = StringF(scratch.arena, "[%F] %F", FmtSint(mip_idx), FmtString(layout_name)); // for (i32 mip_idx = 0; mip_idx < resource->texture_mips; ++mip_idx)
PushStringToList(scratch.arena, &layout_names, layout_str); // {
} // String layout_name = G_D12_NameFromBarrierLayout(resource->cmdlist_texture_layouts[mip_idx]);
layouts_str = StringFromList(scratch.arena, layout_names, Lit(", ")); // String layout_str = StringF(scratch.arena, "[%F] %F", FmtSint(mip_idx), FmtString(layout_name));
} // PushStringToList(scratch.arena, &layout_names, layout_str);
// }
// layouts_str = StringFromList(scratch.arena, layout_names, Lit(", "));
// }
// String msg = StringF(
// scratch.arena,
// "[Gpu command list resource log] uid: %F, name: \"%F\", layouts: { %F }",
// FmtUint(resource->uid),
// FmtString(resource_name),
// FmtString(layouts_str)
// );
// LogDebug(msg);
String msg = StringF(
scratch.arena,
"[Gpu command list resource log] uid: %F, name: \"%F\", layouts: { %F }",
FmtUint(resource->uid),
FmtString(resource_name),
FmtString(layouts_str)
);
LogDebug(msg);
cmd_idx += 1; cmd_idx += 1;
} break; } break;
} }
@ -2963,12 +2763,11 @@ void G_SetConstantEx(G_CommandListHandle cl_handle, i32 slot, void *src_32bit, u
//- Memory sync //- Memory sync
void G_MemorySyncEx(G_CommandListHandle cl_handle, G_MemoryBarrierDesc desc) void G_Barrier(G_CommandListHandle cl_handle)
{ {
G_D12_CmdList *cl = G_D12_CmdListFromHandle(cl_handle); G_D12_CmdList *cl = G_D12_CmdListFromHandle(cl_handle);
G_D12_Cmd *cmd = G_D12_PushCmd(cl); G_D12_Cmd *cmd = G_D12_PushCmd(cl);
cmd->kind = G_D12_CmdKind_Barrier; cmd->kind = G_D12_CmdKind_Barrier;
cmd->barrier.desc = desc;
} }
//- Compute //- Compute
@ -3325,14 +3124,13 @@ G_ResourceHandle G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Forma
backbuffer->flags = G_ResourceFlag_AllowRenderTarget; backbuffer->flags = G_ResourceFlag_AllowRenderTarget;
backbuffer->uid = Atomic64FetchAdd(&G_D12.resource_creation_gen.v, 1) + 1; backbuffer->uid = Atomic64FetchAdd(&G_D12.resource_creation_gen.v, 1) + 1;
ID3D12Resource_GetDesc(d3d_resource, (D3D12_RESOURCE_DESC *)&backbuffer->d3d_desc); ID3D12Resource_GetDesc(d3d_resource, &backbuffer->d3d_desc);
backbuffer->d3d_resource = d3d_resource; backbuffer->d3d_resource = d3d_resource;
backbuffer->is_texture = 1; backbuffer->is_texture = 1;
backbuffer->texture_format = format; backbuffer->texture_format = format;
backbuffer->texture_dims = VEC3I32(size.x, size.y, 1); backbuffer->texture_dims = VEC3I32(size.x, size.y, 1);
backbuffer->texture_mips = 1; backbuffer->texture_mips = 1;
backbuffer->cmdlist_texture_layouts[0] = D3D12_BARRIER_LAYOUT_PRESENT;
backbuffer->swapchain = swapchain; backbuffer->swapchain = swapchain;
} }
} }
@ -3358,6 +3156,21 @@ G_ResourceHandle G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Forma
cur_backbuffer = &swapchain->backbuffers[backbuffer_idx]; cur_backbuffer = &swapchain->backbuffers[backbuffer_idx];
} }
// Transition backbuffer to render target
{
G_D12_RawCommandList *rcl = G_D12_PrepareRawCommandList(G_QueueKind_Direct);
{
D3D12_RESOURCE_BARRIER barrier = Zi;
barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier.Transition.pResource = cur_backbuffer->d3d_resource;
barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_COMMON;
barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET;
ID3D12GraphicsCommandList_ResourceBarrier(rcl->d3d_cl, 1, &barrier);
}
G_D12_CommitRawCommandList(rcl);
}
return G_D12_MakeHandle(G_ResourceHandle, cur_backbuffer); return G_D12_MakeHandle(G_ResourceHandle, cur_backbuffer);
} }
@ -3367,6 +3180,21 @@ void G_CommitBackbuffer(G_ResourceHandle backbuffer_handle, i32 vsync)
G_D12_Swapchain *swapchain = backbuffer->swapchain; G_D12_Swapchain *swapchain = backbuffer->swapchain;
G_D12_Queue *direct_queue = G_D12_QueueFromKind(G_QueueKind_Direct); G_D12_Queue *direct_queue = G_D12_QueueFromKind(G_QueueKind_Direct);
// Transition backbuffer to presentable
{
G_D12_RawCommandList *rcl = G_D12_PrepareRawCommandList(G_QueueKind_Direct);
{
D3D12_RESOURCE_BARRIER barrier = Zi;
barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier.Transition.pResource = backbuffer->d3d_resource;
barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PRESENT;
ID3D12GraphicsCommandList_ResourceBarrier(rcl->d3d_cl, 1, &barrier);
}
G_D12_CommitRawCommandList(rcl);
}
u32 present_flags = 0; u32 present_flags = 0;
if (G_D12_TearingIsAllowed && vsync == 0) if (G_D12_TearingIsAllowed && vsync == 0)
{ {
@ -3417,12 +3245,8 @@ void G_D12_CollectionWorkerEntryPoint(WaveLaneCtx *lane)
{ {
// Copy print buffer to readback buffer // Copy print buffer to readback buffer
G_CopyBufferToBuffer(cl, queue->print_readback_buffer, 0, queue->print_buffer, RNGU64(0, queue->print_buffer_size)); G_CopyBufferToBuffer(cl, queue->print_readback_buffer, 0, queue->print_buffer, RNGU64(0, queue->print_buffer_size));
G_Barrier(cl);
// Reset counters to 0 // Reset counters to 0
G_MemorySync(
cl, queue->print_buffer,
G_Stage_Copy, G_Access_CopyRead,
G_Stage_Copy, G_Access_CopyWrite
);
u8 zero[12] = Zi; u8 zero[12] = Zi;
G_CopyCpuToBuffer(cl, queue->print_buffer, 0, zero, RNGU64(0, sizeof(zero))); G_CopyCpuToBuffer(cl, queue->print_buffer, 0, zero, RNGU64(0, sizeof(zero)));
} }

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

@ -72,7 +72,7 @@ Struct(G_D12_Resource)
u64 uid; u64 uid;
// D3D12 resource // D3D12 resource
D3D12_RESOURCE_DESC1 d3d_desc; D3D12_RESOURCE_DESC d3d_desc;
ID3D12Resource *d3d_resource; ID3D12Resource *d3d_resource;
D3D12_GPU_VIRTUAL_ADDRESS buffer_gpu_address; D3D12_GPU_VIRTUAL_ADDRESS buffer_gpu_address;
void *mapped; void *mapped;
@ -86,7 +86,6 @@ Struct(G_D12_Resource)
G_Format texture_format; G_Format texture_format;
Vec3I32 texture_dims; Vec3I32 texture_dims;
i32 texture_mips; i32 texture_mips;
D3D12_BARRIER_LAYOUT cmdlist_texture_layouts[G_D12_MaxMips];
// Sampler info // Sampler info
G_SamplerDesc sampler_desc; G_SamplerDesc sampler_desc;
@ -262,7 +261,7 @@ Struct(G_D12_RawCommandList)
u64 commit_fence_target; u64 commit_fence_target;
ID3D12CommandAllocator *d3d_ca; ID3D12CommandAllocator *d3d_ca;
ID3D12GraphicsCommandList7 *d3d_cl; ID3D12GraphicsCommandList *d3d_cl;
// Direct queue command lists keep a constant list of CPU-only descriptors // Direct queue command lists keep a constant list of CPU-only descriptors
G_D12_Descriptor *rtv_descriptors[G_MaxRenderTargets]; G_D12_Descriptor *rtv_descriptors[G_MaxRenderTargets];
@ -324,10 +323,8 @@ Struct(G_D12_Cmd)
struct struct
{ {
G_MemoryBarrierDesc desc;
// Post-batch data // Post-batch data
b32 is_end_of_batch; b32 should_commit;
u64 batch_gen; u64 batch_gen;
} barrier; } barrier;
@ -478,7 +475,7 @@ Struct(G_D12_Ctx)
// Device // Device
IDXGIFactory6 *factory; IDXGIFactory6 *factory;
IDXGIAdapter3 *adapter; IDXGIAdapter3 *adapter;
ID3D12Device10 *device; ID3D12Device1 *device;
// Release-queue // Release-queue
Mutex pending_releases_mutex; Mutex pending_releases_mutex;
@ -509,10 +506,6 @@ G_D12_Resource *G_D12_ResourceFromHandle(G_ResourceHandle handle);
G_D12_Swapchain *G_D12_SwapchainFromHandle(G_SwapchainHandle handle); G_D12_Swapchain *G_D12_SwapchainFromHandle(G_SwapchainHandle handle);
DXGI_FORMAT G_D12_DxgiFormatFromGpuFormat(G_Format format); DXGI_FORMAT G_D12_DxgiFormatFromGpuFormat(G_Format format);
D3D12_BARRIER_SYNC G_D12_BarrierSyncFromStages(G_Stage stages);
D3D12_BARRIER_ACCESS G_D12_BarrierAccessFromAccesses(G_Access accesses);
D3D12_BARRIER_LAYOUT G_D12_BarrierLayoutFromLayout(G_Layout layout);
String G_D12_NameFromBarrierLayout(D3D12_BARRIER_LAYOUT layout);
void G_D12_InitRtv(G_D12_Resource *resource, D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle, i32 mip); void G_D12_InitRtv(G_D12_Resource *resource, D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle, i32 mip);

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

@ -416,7 +416,6 @@ void V_TickForever(WaveLaneCtx *lane)
gpu_perm, cl, gpu_perm, cl,
G_Format_R8_Uint, G_Format_R8_Uint,
tiles_dims, tiles_dims,
G_Layout_DirectQueue_ShaderRead_ShaderReadWrite_CopyRead_CopyWrite,
.flags = G_ResourceFlag_ZeroMemory, .flags = G_ResourceFlag_ZeroMemory,
.name = Lit("Tiles") .name = Lit("Tiles")
); );
@ -441,7 +440,6 @@ void V_TickForever(WaveLaneCtx *lane)
gpu_perm, cl, gpu_perm, cl,
G_Format_R32_Uint, G_Format_R32_Uint,
cells_dims, cells_dims,
G_Layout_DirectQueue_ShaderRead_ShaderReadWrite_CopyRead_CopyWrite,
.flags = G_ResourceFlag_ZeroMemory | G_ResourceFlag_AllowShaderReadWrite, .flags = G_ResourceFlag_ZeroMemory | G_ResourceFlag_AllowShaderReadWrite,
.name = StringF(perm, "Particle cells - layer %F", FmtSint(layer)) .name = StringF(perm, "Particle cells - layer %F", FmtSint(layer))
); );
@ -454,7 +452,6 @@ void V_TickForever(WaveLaneCtx *lane)
gpu_perm, cl, gpu_perm, cl,
G_Format_R32_Uint, G_Format_R32_Uint,
cells_dims, cells_dims,
G_Layout_DirectQueue_ShaderRead_ShaderReadWrite_CopyRead_CopyWrite,
.flags = G_ResourceFlag_ZeroMemory | G_ResourceFlag_AllowShaderReadWrite, .flags = G_ResourceFlag_ZeroMemory | G_ResourceFlag_AllowShaderReadWrite,
.name = StringF(perm, "Particle densities - layer %F", FmtSint(layer)) .name = StringF(perm, "Particle densities - layer %F", FmtSint(layer))
); );
@ -469,7 +466,6 @@ void V_TickForever(WaveLaneCtx *lane)
gpu_perm, cl, gpu_perm, cl,
G_Format_R16G16B16A16_Float, G_Format_R16G16B16A16_Float,
cells_dims, cells_dims,
G_Layout_DirectQueue_ShaderRead_ShaderReadWrite_CopyRead_CopyWrite,
.flags = G_ResourceFlag_ZeroMemory | G_ResourceFlag_AllowShaderReadWrite, .flags = G_ResourceFlag_ZeroMemory | G_ResourceFlag_AllowShaderReadWrite,
.name = Lit("Stains") .name = Lit("Stains")
); );
@ -481,7 +477,6 @@ void V_TickForever(WaveLaneCtx *lane)
gpu_perm, cl, gpu_perm, cl,
G_Format_R16G16B16A16_Float, G_Format_R16G16B16A16_Float,
cells_dims, cells_dims,
G_Layout_DirectQueue_ShaderRead_ShaderReadWrite_CopyRead_CopyWrite,
.flags = G_ResourceFlag_ZeroMemory | G_ResourceFlag_AllowShaderReadWrite, .flags = G_ResourceFlag_ZeroMemory | G_ResourceFlag_AllowShaderReadWrite,
.name = Lit("Dry stains") .name = Lit("Dry stains")
); );
@ -493,7 +488,6 @@ void V_TickForever(WaveLaneCtx *lane)
gpu_perm, cl, gpu_perm, cl,
G_Format_R32_Float, G_Format_R32_Float,
cells_dims, cells_dims,
G_Layout_DirectQueue_ShaderRead_ShaderReadWrite_CopyRead_CopyWrite,
.flags = G_ResourceFlag_ZeroMemory | G_ResourceFlag_AllowShaderReadWrite, .flags = G_ResourceFlag_ZeroMemory | G_ResourceFlag_AllowShaderReadWrite,
.name = Lit("Drynesses") .name = Lit("Drynesses")
); );
@ -505,7 +499,6 @@ void V_TickForever(WaveLaneCtx *lane)
gpu_perm, cl, gpu_perm, cl,
G_Format_R32_Uint, G_Format_R32_Uint,
cells_dims, cells_dims,
G_Layout_DirectQueue_ShaderRead_ShaderReadWrite_CopyRead_CopyWrite,
.flags = G_ResourceFlag_ZeroMemory | G_ResourceFlag_AllowShaderReadWrite, .flags = G_ResourceFlag_ZeroMemory | G_ResourceFlag_AllowShaderReadWrite,
.name = Lit("Occluders cells") .name = Lit("Occluders cells")
); );
@ -2501,9 +2494,9 @@ void V_TickForever(WaveLaneCtx *lane)
////////////////////////////// //////////////////////////////
//- Push test emitter //- Push test emitter
// if (frame->held_buttons[Button_F]) if (frame->held_buttons[Button_F])
// if (frame->held_buttons[Button_F] && !prev_frame->held_buttons[Button_F]) // if (frame->held_buttons[Button_F] && !prev_frame->held_buttons[Button_F])
if (0) // if (0)
{ {
{ {
V_Emitter emitter = Zi; V_Emitter emitter = Zi;
@ -2563,9 +2556,9 @@ void V_TickForever(WaveLaneCtx *lane)
////////////////////////////// //////////////////////////////
//- Push test explosion //- Push test explosion
// if (frame->held_buttons[Button_G]) if (frame->held_buttons[Button_G])
// if (frame->held_buttons[Button_G] && !prev_frame->held_buttons[Button_G]) // if (frame->held_buttons[Button_G] && !prev_frame->held_buttons[Button_G])
if (0) // if (0)
{ {
// Fire // Fire
{ {
@ -4791,7 +4784,6 @@ void V_TickForever(WaveLaneCtx *lane)
frame->gpu_arena, frame->cl, frame->gpu_arena, frame->cl,
G_Format_R16G16B16A16_Float, G_Format_R16G16B16A16_Float,
frame->screen_dims, frame->screen_dims,
G_Layout_DirectQueue_ShaderRead_ShaderReadWrite_CopyRead_CopyWrite,
.flags = G_ResourceFlag_AllowShaderReadWrite | G_ResourceFlag_AllowRenderTarget, .flags = G_ResourceFlag_AllowShaderReadWrite | G_ResourceFlag_AllowRenderTarget,
.name = StringF(frame->arena, "Screen target [%F]", FmtSint(frame->tick)) .name = StringF(frame->arena, "Screen target [%F]", FmtSint(frame->tick))
); );
@ -4805,7 +4797,6 @@ void V_TickForever(WaveLaneCtx *lane)
frame->gpu_arena, frame->cl, frame->gpu_arena, frame->cl,
G_Format_R16G16B16A16_Float, G_Format_R16G16B16A16_Float,
G_DimsFromMip2D(G_Count2D(screen_target), 1), G_DimsFromMip2D(G_Count2D(screen_target), 1),
G_Layout_DirectQueue_ShaderRead_ShaderReadWrite_CopyRead_CopyWrite,
.flags = G_ResourceFlag_AllowShaderReadWrite | G_ResourceFlag_AllowRenderTarget, .flags = G_ResourceFlag_AllowShaderReadWrite | G_ResourceFlag_AllowRenderTarget,
.name = StringF(frame->arena, "Bloom target [%F]", FmtSint(frame->tick)), .name = StringF(frame->arena, "Bloom target [%F]", FmtSint(frame->tick)),
.max_mips = 64 .max_mips = 64
@ -4821,7 +4812,6 @@ void V_TickForever(WaveLaneCtx *lane)
frame->gpu_arena, frame->cl, frame->gpu_arena, frame->cl,
G_Format_R16G16B16A16_Float, G_Format_R16G16B16A16_Float,
frame->screen_dims, frame->screen_dims,
G_Layout_DirectQueue_RenderTargetWrite,
.flags = G_ResourceFlag_AllowRenderTarget, .flags = G_ResourceFlag_AllowRenderTarget,
.name = StringF(frame->arena, "Albedo target [%F]", FmtSint(frame->tick)) .name = StringF(frame->arena, "Albedo target [%F]", FmtSint(frame->tick))
); );
@ -4832,7 +4822,6 @@ void V_TickForever(WaveLaneCtx *lane)
frame->gpu_arena, frame->cl, frame->gpu_arena, frame->cl,
G_Format_R16G16B16A16_Float, G_Format_R16G16B16A16_Float,
frame->shade_dims, frame->shade_dims,
G_Layout_DirectQueue_ShaderRead_ShaderReadWrite_CopyRead_CopyWrite,
.flags = G_ResourceFlag_AllowShaderReadWrite, .flags = G_ResourceFlag_AllowShaderReadWrite,
.name = StringF(frame->arena, "Shade target [%F]", FmtSint(frame->tick)) .name = StringF(frame->arena, "Shade target [%F]", FmtSint(frame->tick))
); );
@ -4899,7 +4888,7 @@ void V_TickForever(WaveLaneCtx *lane)
G_SetConstant(frame->cl, V_GpuConst_NoiseTex, G_BasicNoiseTexture()); G_SetConstant(frame->cl, V_GpuConst_NoiseTex, G_BasicNoiseTexture());
// Sync // Sync
G_DumbGlobalMemorySync(frame->cl); G_Barrier(frame->cl);
////////////////////////////// //////////////////////////////
//- Initialization pass //- Initialization pass
@ -4923,7 +4912,7 @@ void V_TickForever(WaveLaneCtx *lane)
} }
// Sync // Sync
G_DumbGlobalMemorySync(frame->cl); G_Barrier(frame->cl);
////////////////////////////// //////////////////////////////
//- Quads & emitters pass //- Quads & emitters pass
@ -4943,10 +4932,7 @@ void V_TickForever(WaveLaneCtx *lane)
G_Compute(frame->cl, V_EmitParticlesCS, V_ThreadGroupSizeFromBufferSize(frame->emitters_count)); G_Compute(frame->cl, V_EmitParticlesCS, V_ThreadGroupSizeFromBufferSize(frame->emitters_count));
// Sync particles & occluders // Sync particles & occluders
G_DumbGlobalMemorySync(frame->cl); G_Barrier(frame->cl);
// Transition albedo
G_DumbMemoryLayoutSync(frame->cl, albedo_target, G_Layout_DirectQueue_ShaderRead_ShaderReadWrite_CopyRead_CopyWrite);
} }
////////////////////////////// //////////////////////////////
@ -4957,7 +4943,7 @@ void V_TickForever(WaveLaneCtx *lane)
G_Compute(frame->cl, V_SimParticlesCS, V_ThreadGroupSizeFromBufferSize(V_ParticlesCap)); G_Compute(frame->cl, V_SimParticlesCS, V_ThreadGroupSizeFromBufferSize(V_ParticlesCap));
// Sync cells // Sync cells
G_DumbGlobalMemorySync(frame->cl); G_Barrier(frame->cl);
} }
////////////////////////////// //////////////////////////////
@ -4976,7 +4962,7 @@ void V_TickForever(WaveLaneCtx *lane)
G_Compute(frame->cl, V_CompositeCS, V_ThreadGroupSizeFromTexSize(frame->screen_dims)); G_Compute(frame->cl, V_CompositeCS, V_ThreadGroupSizeFromTexSize(frame->screen_dims));
// Sync screen tex // Sync screen tex
G_DumbGlobalMemorySync(frame->cl); G_Barrier(frame->cl);
} }
////////////////////////////// //////////////////////////////
@ -4998,7 +4984,7 @@ void V_TickForever(WaveLaneCtx *lane)
G_SetConstant(frame->cl, V_GpuConst_MipIdx, mip_idx); G_SetConstant(frame->cl, V_GpuConst_MipIdx, mip_idx);
G_Compute(frame->cl, V_BloomDownCS, V_ThreadGroupSizeFromTexSize(down_dims)); G_Compute(frame->cl, V_BloomDownCS, V_ThreadGroupSizeFromTexSize(down_dims));
G_DumbGlobalMemorySync(frame->cl); G_Barrier(frame->cl);
} }
//- Upsample passes //- Upsample passes
@ -5009,7 +4995,7 @@ void V_TickForever(WaveLaneCtx *lane)
G_SetConstant(frame->cl, V_GpuConst_MipIdx, mip_idx); G_SetConstant(frame->cl, V_GpuConst_MipIdx, mip_idx);
G_Compute(frame->cl, V_BloomUpCS, V_ThreadGroupSizeFromTexSize(up_dims)); G_Compute(frame->cl, V_BloomUpCS, V_ThreadGroupSizeFromTexSize(up_dims));
G_DumbGlobalMemorySync(frame->cl); G_Barrier(frame->cl);
} }
} }
@ -5019,15 +5005,13 @@ void V_TickForever(WaveLaneCtx *lane)
{ {
G_Compute(frame->cl, V_FinalizeCS, V_ThreadGroupSizeFromTexSize(frame->screen_dims)); G_Compute(frame->cl, V_FinalizeCS, V_ThreadGroupSizeFromTexSize(frame->screen_dims));
G_DumbGlobalMemorySync(frame->cl); G_Barrier(frame->cl);
} }
////////////////////////////// //////////////////////////////
//- Debug shapes pass //- Debug shapes pass
{ {
G_DumbMemoryLayoutSync(frame->cl, screen_target, G_Layout_DirectQueue_RenderTargetWrite);
G_Rasterize( G_Rasterize(
frame->cl, frame->cl,
V_DVertVS, V_DVertPS, V_DVertVS, V_DVertPS,
@ -5037,7 +5021,7 @@ void V_TickForever(WaveLaneCtx *lane)
G_RasterMode_TriangleList G_RasterMode_TriangleList
); );
G_DumbMemoryLayoutSync(frame->cl, screen_target, G_Layout_DirectQueue_ShaderRead_ShaderReadWrite_CopyRead_CopyWrite); G_Barrier(frame->cl);
} }
////////////////////////////// //////////////////////////////

1
src/sprite/sprite.c
View File

@ -439,7 +439,6 @@ void SPR_TickAsync(WaveLaneCtx *lane, AsyncFrameLaneCtx *base_async_lane_frame)
gpu_perm, cl, gpu_perm, cl,
G_Format_R8G8B8A8_Unorm_Srgb, G_Format_R8G8B8A8_Unorm_Srgb,
atlas->dims, atlas->dims,
G_Layout_AnyQueue_ShaderRead_CopyRead_CopyWrite_Present,
.name = Lit("Sprite atlas") .name = Lit("Sprite atlas")
); );
atlas->tex = G_PushTexture2DRef(gpu_perm, atlas->tex_res); atlas->tex = G_PushTexture2DRef(gpu_perm, atlas->tex_res);

8
src/ui/ui_core.c
View File

@ -1703,7 +1703,6 @@ void UI_EndFrame(UI_Frame *frame, i32 vsync)
frame->gpu_arena, frame->cl, frame->gpu_arena, frame->cl,
G_Format_R16G16B16A16_Float, G_Format_R16G16B16A16_Float,
monitor_size, monitor_size,
G_Layout_DirectQueue_RenderTargetWrite,
.flags = G_ResourceFlag_AllowRenderTarget, .flags = G_ResourceFlag_AllowRenderTarget,
.name = Lit("UI draw target") .name = Lit("UI draw target")
); );
@ -1739,7 +1738,7 @@ void UI_EndFrame(UI_Frame *frame, i32 vsync)
G_SetConstant(frame->cl, UI_GpuConst_Params, params_ro); G_SetConstant(frame->cl, UI_GpuConst_Params, params_ro);
// Sync // Sync
G_DumbGlobalMemorySync(frame->cl); G_Barrier(frame->cl);
////////////////////////////// //////////////////////////////
//- Dispatch shaders //- Dispatch shaders
@ -1781,8 +1780,7 @@ void UI_EndFrame(UI_Frame *frame, i32 vsync)
//- Backbuffer blit pass //- Backbuffer blit pass
G_DumbMemoryLayoutSync(frame->cl, draw_target, G_Layout_DirectQueue_ShaderRead); G_Barrier(frame->cl);
G_DumbMemoryLayoutSync(frame->cl, backbuffer, G_Layout_DirectQueue_RenderTargetWrite);
{ {
G_Rasterize( G_Rasterize(
@ -1794,8 +1792,6 @@ void UI_EndFrame(UI_Frame *frame, i32 vsync)
G_RasterMode_TriangleList G_RasterMode_TriangleList
); );
} }
G_DumbMemoryLayoutSync(frame->cl, backbuffer, G_Layout_AnyQueue_ShaderRead_CopyRead_CopyWrite_Present);
} }
////////////////////////////// //////////////////////////////