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

wip

Browse Source
This commit is contained in:
jacob 2026-03-10 18:03:06 -05:00
parent 8d051b0324
commit 6af25419f1
13 changed files with 222 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/gpu/gpu_common.c
View File

@ -13,7 +13,7 @@ void G_BootstrapCommon(void)
// Init quad index buffer // Init quad index buffer
{ {
u16 quad_indices[6] = { 0, 1, 2, 0, 2, 3 }; u16 quad_indices[6] = { 0, 1, 2, 0, 2, 3 };
G.quad_indices = G_PushBufferFromCpu(cl, gpu_perm, quad_indices, u16, countof(quad_indices)); G.quad_indices = G_PushStructsFromCpu(cl, gpu_perm, quad_indices, countof(quad_indices));
} }
// Init blank texture // Init blank texture
@ -138,14 +138,6 @@ G_ArenaHandle G_PermArena(void)
return G_tl.gpu_perm; return G_tl.gpu_perm;
} }
//- Push resource from cpu
G_BufferRef G_PushBufferFromCpu_(G_CommandListHandle cl, G_ArenaHandle gpu_arena, void *src, G_BufferRef buffer)
{
G_CopyCpuToBuffer(cl, buffer, 0, src, RNGU64(0, G_CountBufferBytes(buffer)));
return buffer;
}
//- Mip //- Mip
i32 G_DimsFromMip1D(i32 mip0_dims, i32 mip) i32 G_DimsFromMip1D(i32 mip0_dims, i32 mip)

10
src/gpu/gpu_common.h
View File

@ -30,16 +30,6 @@ void G_BootstrapCommon(void);
G_ArenaHandle G_PermArena(void); G_ArenaHandle G_PermArena(void);
//- Push resource from cpu
G_BufferRef G_PushBufferFromCpu_(G_CommandListHandle cl, G_ArenaHandle gpu_arena, void *src, G_BufferRef buffer);
#define G_PushBufferFromCpu(_cl, _gpu_arena, _src, _type, _count, ...) \
G_PushBufferFromCpu_((_cl), (_gpu_arena), (_src), G_PushBuffer((_cl), (_gpu_arena), (_count), sizeof(_type), __VA_ARGS__))
#define G_PushBufferFromCpuArena(_cl, _gpu_arena, _cpu_arena, _type, ...) \
G_PushBufferFromCpu_((_cl), (_gpu_arena), ArenaFirst((_cpu_arena), _type), G_PushBuffer((_cl), (_gpu_arena), ArenaCount((_cpu_arena), _type), sizeof(_type), __VA_ARGS__))
//- Mip //- Mip
i32 G_DimsFromMip1D(i32 mip0_dims, i32 mip); i32 G_DimsFromMip1D(i32 mip0_dims, i32 mip);

29
src/gpu/gpu_core.h
View File

@ -4,11 +4,13 @@
Struct(G_ArenaHandle) { u64 v; }; Struct(G_ArenaHandle) { u64 v; };
Struct(G_CommandListHandle) { u64 v; }; Struct(G_CommandListHandle) { u64 v; };
Struct(G_SwapchainHandle) { u64 v; }; Struct(G_SwapchainHandle) { u64 v; };
Struct(G_BackbufferHandle) { u64 v; };
#define G_IsArenaNil(h) ((h).v == 0) #define G_IsArenaNil(h) ((h).v == 0)
#define G_IsCommandListNil(h) ((h).v == 0) #define G_IsCommandListNil(h) ((h).v == 0)
#define G_IsResourceNil(h) ((h).v == 0) #define G_IsResourceNil(h) ((h).v == 0)
#define G_IsSwapchainNil(h) ((h).v == 0) #define G_IsSwapchainNil(h) ((h).v == 0)
#define G_IsBackbufferNil(h) ((h).v == 0)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Queue types //~ Queue types
@ -322,6 +324,7 @@ Struct(G_BufferDesc)
u64 stride; u64 stride;
u64 count; u64 count;
String name; String name;
void *cpu_src;
}; };
Struct(G_TextureDesc) Struct(G_TextureDesc)
@ -421,7 +424,10 @@ void G_ResetArena(G_CommandListHandle cl_handle, G_ArenaHandle arena_handle);
G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl, G_ArenaHandle gpu_arena, G_MemoryDesc memory_desc); G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl, G_ArenaHandle gpu_arena, G_MemoryDesc memory_desc);
#define G_PushBuffer(_cl, _arena, _type, _count, ...) ((G_BufferRef) { .v = G_PushMemory((_cl), (_arena), \ //- Buffer memory
#define G_PushStruct(_cl, _arena, _type, ...) G_PushStructs((_cl), (_arena), (_type), 1, __VA_ARGS__)
#define G_PushStructs(_cl, _arena, _type, _count, ...) ((G_BufferRef) { .v = G_PushMemory((_cl), (_arena), \
(G_MemoryDesc) { \ (G_MemoryDesc) { \
.kind = G_MemoryKind_Buffer, \ .kind = G_MemoryKind_Buffer, \
.buffer = { \ .buffer = { \
@ -432,8 +438,21 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl, G_ArenaHandle gpu_are
} \ } \
)}) )})
#define G_PushStructFromCpu(_cl, _arena, _src, ...) G_PushStructsFromCpu((_cl), (_arena), (_src), 1, __VA_ARGS__)
#define G_PushStructsFromCpu(_cl, _arena, _src, _count, ...) ((G_BufferRef) { .v = G_PushMemory((_cl), (_arena), \
(G_MemoryDesc) { \
.kind = G_MemoryKind_Buffer, \
.buffer = { \
.count = (_count), \
.stride = sizeof(*_src), \
.cpu_src = (_src), \
__VA_ARGS__ \
} \
} \
)})
//- Texture memory
#define G_PushTexture1D(_cl, _arena, _initial_layout, _format, _dims, ...) ((G_TextureRef) { .v = G_PushMemory((_cl), (_arena), \ #define G_PushTexture1D(_cl, _arena, _initial_layout, _format, _dims, ...) ((G_TextureRef) { .v = G_PushMemory((_cl), (_arena), \
(G_MemoryDesc) { \ (G_MemoryDesc) { \
@ -478,7 +497,7 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl, G_ArenaHandle gpu_are
//- Sampler memory
#define G_PushSampler(_cl, _arena, ...) ((G_SamplerRef) { .v = G_PushMemory((_cl), (_arena), \ #define G_PushSampler(_cl, _arena, ...) ((G_SamplerRef) { .v = G_PushMemory((_cl), (_arena), \
(G_MemoryDesc) { \ (G_MemoryDesc) { \
@ -563,7 +582,7 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl, G_ArenaHandle gpu_are
//- Render target helpers //- Render target helpers
#define G_Rt(_res, _blend_mode) ((G_RenderTargetDesc) { .resource = (_res), .blend = (_blend_mode) }) #define G_Rt(_tex, _blend_mode) ((G_RenderTargetDesc) { .texture = (_tex), .blend = (_blend_mode) })
//- Count //- Count
@ -729,6 +748,6 @@ void G_ReleaseSwapchain(G_SwapchainHandle swapchain);
// Waits until a new backbuffer is ready from the swapchain. // Waits until a new backbuffer is ready from the swapchain.
// This should be called before rendering for minimum latency. // This should be called before rendering for minimum latency.
G_TextureRef G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Format format, Vec2I32 size); G_BackbufferHandle G_PrepareBackbuffer(G_SwapchainHandle swapchain, G_Format format, Vec2I32 size);
void G_CommitBackbuffer(G_TextureRef backbuffer, i32 vsync); void G_CommitBackbuffer(G_BackbufferHandle backbuffer, Vec2I32 dst_offset, G_TextureRef src, Rng2I32 src_range, i32 vsync);

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

@ -574,12 +574,12 @@ void G_Bootstrap(void)
{ {
G_ArenaHandle gpu_perm = G_PermArena(); G_ArenaHandle gpu_perm = G_PermArena();
queue->print_buffer_size = GPU_SHADER_PRINT_BUFFER_SIZE; queue->print_buffer_size = GPU_SHADER_PRINT_BUFFER_SIZE;
queue->print_buffer = G_PushBuffer( queue->print_buffer = G_PushStructs(
cl, gpu_perm, cl, gpu_perm,
u8, queue->print_buffer_size, u8, queue->print_buffer_size,
.name = Lit("Debug print gpu buffer") .name = Lit("Debug print gpu buffer")
); );
queue->print_readback_buffer = G_PushBuffer( queue->print_readback_buffer = G_PushStructs(
cl, gpu_perm, cl, gpu_perm,
u8, queue->print_buffer_size, u8, queue->print_buffer_size,
.flags = G_MemoryFlag_HostCached, .flags = G_MemoryFlag_HostCached,
@ -629,6 +629,11 @@ G_D12_Swapchain *G_D12_SwapchainFromHandle(G_SwapchainHandle handle)
return (G_D12_Swapchain *)handle.v; return (G_D12_Swapchain *)handle.v;
} }
G_D12_Backbuffer *G_D12_BackbufferFromHandle(G_BackbufferHandle handle)
{
return (G_D12_Backbuffer *)handle.v;
}
DXGI_FORMAT G_D12_DxgiFormatFromGpuFormat(G_Format format) DXGI_FORMAT G_D12_DxgiFormatFromGpuFormat(G_Format format)
{ {
return (DXGI_FORMAT)format; return (DXGI_FORMAT)format;
@ -1680,7 +1685,7 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
G_BaseDescriptorIndex result = 0; G_BaseDescriptorIndex descriptor_idx = 0;
// G_D12_RefBundle *bundle = 0; // G_D12_RefBundle *bundle = 0;
@ -1723,15 +1728,23 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
) )
{ {
G_SyncLayout(cl_handle, G_MakeTextureRef(result), G_TextureLayout_Common); G_SyncLayout(cl_handle, G_MakeTextureRef(descriptor_idx), G_TextureLayout_Common);
} }
//////////////////////////////
//- Upload initial data if present
if (is_buffer && memory_desc.buffer.cpu_src)
{
G_CopyCpuToBuffer(
cl_handle,
G_MakeBufferRef(descriptor_idx), 0,
memory_desc.buffer.cpu_src, RNGU64(0, memory_desc.buffer.stride * memory_desc.buffer.count)
);
}
return descriptor_idx;
return result;
} }
@ -2491,7 +2504,7 @@ G_D12_StagingRegionNode *G_D12_PushStagingRegion(G_D12_CmdList *cl, u64 size)
G_ArenaHandle gpu_arena_handle = G_AcquireArena(); G_ArenaHandle gpu_arena_handle = G_AcquireArena();
ring->gpu_arena = G_D12_ArenaFromHandle(gpu_arena_handle); ring->gpu_arena = G_D12_ArenaFromHandle(gpu_arena_handle);
ring->buffer = G_PushBuffer( ring->buffer = G_PushStructs(
G_D12_MakeHandle(G_CommandListHandle, cl), gpu_arena_handle, G_D12_MakeHandle(G_CommandListHandle, cl), gpu_arena_handle,
u8, new_ring_size, u8, new_ring_size,
.flags = G_MemoryFlag_HostUncached .flags = G_MemoryFlag_HostUncached
@ -4114,7 +4127,7 @@ void G_ReleaseSwapchain(G_SwapchainHandle swapchain_handle)
// TODO // TODO
} }
G_TextureRef G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Format format, Vec2I32 size) G_BackbufferHandle G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Format format, Vec2I32 size)
{ {
G_D12_Swapchain *swapchain = G_D12_SwapchainFromHandle(swapchain_handle); G_D12_Swapchain *swapchain = G_D12_SwapchainFromHandle(swapchain_handle);
TempArena scratch = BeginScratchNoConflict(); TempArena scratch = BeginScratchNoConflict();
@ -4140,7 +4153,7 @@ G_TextureRef G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Format fo
desc.Height = size.y; desc.Height = size.y;
desc.SampleDesc.Count = 1; desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0; desc.SampleDesc.Quality = 0;
desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT; // desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT;
desc.BufferCount = G_D12_SwapchainBufferCount; desc.BufferCount = G_D12_SwapchainBufferCount;
desc.Scaling = DXGI_SCALING_NONE; desc.Scaling = DXGI_SCALING_NONE;
desc.Flags = G_D12_SwapchainFlags; desc.Flags = G_D12_SwapchainFlags;
@ -4157,8 +4170,8 @@ G_TextureRef G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Format fo
} }
} }
swapchain->d3d_swapchain = swapchain3; swapchain->d3d_swapchain = swapchain3;
swapchain->backbuffers_format = format; swapchain->format = format;
swapchain->backbuffers_resolution = size; swapchain->resolution = size;
} }
// Create waitable object // Create waitable object
@ -4195,7 +4208,7 @@ G_TextureRef G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Format fo
} }
// Resize backbuffers // Resize backbuffers
if (!MatchVec2I32(swapchain->backbuffers_resolution, size) || swapchain->backbuffers_format != format) if (!MatchVec2I32(swapchain->resolution, size) || swapchain->format != format)
{ {
HRESULT hr = 0; HRESULT hr = 0;
@ -4208,7 +4221,7 @@ G_TextureRef G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Format fo
// Release backbuffers // Release backbuffers
for (u32 i = 0; i < countof(swapchain->backbuffers); ++i) for (u32 i = 0; i < countof(swapchain->backbuffers); ++i)
{ {
G_D12_Resource *backbuffer = &swapchain->backbuffers[i]; G_D12_Backbuffer *backbuffer = &swapchain->backbuffers[i];
if (backbuffer->d3d_resource) if (backbuffer->d3d_resource)
{ {
ID3D12Resource_Release(backbuffer->d3d_resource); ID3D12Resource_Release(backbuffer->d3d_resource);
@ -4227,43 +4240,60 @@ G_TextureRef G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Format fo
// Initialize backbuffers // Initialize backbuffers
{ {
// for (u32 backbuffer_idx = 0; backbuffer_idx < countof(swapchain->backbuffers); ++backbuffer_idx)
// {
// G_D12_Resource *backbuffer = &swapchain->backbuffers[backbuffer_idx];
// if (!backbuffer->d3d_resource)
// {
// ID3D12Resource *d3d_resource = 0;
// HRESULT hr = IDXGISwapChain3_GetBuffer(swapchain->d3d_swapchain, backbuffer_idx, &IID_ID3D12Resource, (void **)&d3d_resource);
// if (FAILED(hr))
// {
// // TODO: Don't panic
// Panic(Lit("Failed to retrieve swapchain buffer"));
// }
// ZeroStruct(backbuffer);
// // backbuffer->flags = G_MemoryFlag_AllowTextureDraw;
// backbuffer->uid = Atomic64FetchAdd(&G_D12.resource_creation_gen.v, 1) + 1;
// ID3D12Resource_GetDesc(d3d_resource, (D3D12_RESOURCE_DESC *)&backbuffer->d3d_desc);
// backbuffer->d3d_resource = d3d_resource;
// backbuffer->is_texture = 1;
// backbuffer->texture_format = format;
// backbuffer->texture_dims = VEC3I32(size.x, size.y, 1);
// backbuffer->texture_mips = 1;
// backbuffer->swapchain = swapchain;
// String name = StringF(scratch.arena, "Backbuffer [%F]", FmtUint(backbuffer_idx));
// name.len = MinU64(name.len, G_D12_MaxNameLen);
// {
// backbuffer->name_len = name.len;
// CopyBytes(backbuffer->name_cstr, name.text, name.len);
// backbuffer->name_cstr[name.len] = 0;
// G_D12_SetObjectName((ID3D12Object *)backbuffer->d3d_resource, name);
// }
// }
// }
for (u32 backbuffer_idx = 0; backbuffer_idx < countof(swapchain->backbuffers); ++backbuffer_idx) for (u32 backbuffer_idx = 0; backbuffer_idx < countof(swapchain->backbuffers); ++backbuffer_idx)
{ {
G_D12_Resource *backbuffer = &swapchain->backbuffers[backbuffer_idx]; G_D12_Backbuffer *backbuffer = &swapchain->backbuffers[backbuffer_idx];
if (!backbuffer->d3d_resource) if (!backbuffer->d3d_resource)
{ {
ID3D12Resource *d3d_resource = 0; ZeroStruct(backbuffer);
HRESULT hr = IDXGISwapChain3_GetBuffer(swapchain->d3d_swapchain, backbuffer_idx, &IID_ID3D12Resource, (void **)&d3d_resource); HRESULT hr = IDXGISwapChain3_GetBuffer(swapchain->d3d_swapchain, backbuffer_idx, &IID_ID3D12Resource, (void **)&backbuffer->d3d_resource);
if (FAILED(hr)) if (FAILED(hr))
{ {
// TODO: Don't panic // TODO: Don't panic
Panic(Lit("Failed to retrieve swapchain buffer")); Panic(Lit("Failed to retrieve backbuffer from D3D12 swapchain"));
}
G_D12_SetObjectName((ID3D12Object *)backbuffer->d3d_resource, StringF(scratch.arena, "Backbuffer [%F]", FmtUint(backbuffer_idx)));
}
} }
ZeroStruct(backbuffer);
backbuffer->flags = G_MemoryFlag_AllowTextureDraw;
backbuffer->uid = Atomic64FetchAdd(&G_D12.resource_creation_gen.v, 1) + 1;
ID3D12Resource_GetDesc(d3d_resource, (D3D12_RESOURCE_DESC *)&backbuffer->d3d_desc); swapchain->format = format;
backbuffer->d3d_resource = d3d_resource; swapchain->resolution = size;
backbuffer->is_texture = 1;
backbuffer->texture_format = format;
backbuffer->texture_dims = VEC3I32(size.x, size.y, 1);
backbuffer->texture_mips = 1;
backbuffer->swapchain = swapchain;
String name = StringF(scratch.arena, "Backbuffer [%F]", FmtUint(backbuffer_idx));
name.len = MinU64(name.len, G_D12_MaxNameLen);
{
backbuffer->name_len = name.len;
CopyBytes(backbuffer->name_cstr, name.text, name.len);
backbuffer->name_cstr[name.len] = 0;
G_D12_SetObjectName((ID3D12Object *)backbuffer->d3d_resource, name);
}
}
}
swapchain->backbuffers_format = format;
swapchain->backbuffers_resolution = size;
} }
// Wait for available backbuffer // Wait for available backbuffer
@ -4278,22 +4308,47 @@ G_TextureRef G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Format fo
} }
// Grab current backbuffer // Grab current backbuffer
G_D12_Resource *cur_backbuffer = 0; G_D12_Backbuffer *cur_backbuffer = 0;
{ {
u32 backbuffer_idx = IDXGISwapChain3_GetCurrentBackBufferIndex(swapchain->d3d_swapchain); u32 backbuffer_idx = IDXGISwapChain3_GetCurrentBackBufferIndex(swapchain->d3d_swapchain);
cur_backbuffer = &swapchain->backbuffers[backbuffer_idx]; cur_backbuffer = &swapchain->backbuffers[backbuffer_idx];
} }
EndScratch(scratch); EndScratch(scratch);
return G_D12_MakeHandle(G_ResourceHandle, cur_backbuffer); return G_D12_MakeHandle(G_BackbufferHandle, cur_backbuffer);
} }
void G_CommitBackbuffer(G_ResourceHandle backbuffer_handle, i32 vsync) void G_CommitBackbuffer(G_BackbufferHandle backbuffer_handle, Vec2I32 dst_offset, G_TextureRef src, Rng2I32 src_range, i32 vsync)
{ {
G_D12_Resource *backbuffer = G_D12_ResourceFromHandle(backbuffer_handle); G_D12_Backbuffer *backbuffer = G_D12_BackbufferFromHandle(backbuffer_handle);
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);
// FIXME: Copy to backbuffer here
Vec2I32 src_dims = G_Count2D(src);
src_range = IntersectRng2I32(src_range, RNG2I32(VEC2I32(0, 0), src_dims));
// if (!IsRng2I32Empty(src_range))
// {
// G_D12_RawCommandList *rcl = G_D12_PrepareRawCommandList(G_QueueKind_Direct);
// ID3D12GraphicsCommandList7 *d3d_cl = rcl->d3d_cl;
// {
// G_D12_InsertEvent(d3d_cl, G_D12_EventKind_Marker, Lit("Copy to backbuffer"));
// ID3D12GraphicsCommandList_CopyTextureRegion(d3d_cl, &dst_loc, dst_offset.x, dst_offset.y, dst_offset.z, &src_loc, src_box_ptr);
// }
// G_D12_CommitRawCommandList(rcl);
// }
u32 present_flags = 0; u32 present_flags = 0;
if (G_D12_TearingIsAllowed && vsync == 0) if (G_D12_TearingIsAllowed && vsync == 0)
{ {
@ -4388,11 +4443,11 @@ void G_D12_CollectionWorkerEntryPoint(WaveLaneCtx *lane)
G_D12_Queue *queue = G_D12_QueueFromKind(queue_kind); G_D12_Queue *queue = G_D12_QueueFromKind(queue_kind);
if (!G_IsResourceNil(queue->print_buffer)) if (!G_IsResourceNil(queue->print_buffer))
{ {
u32 header = G_Deref(queue->print_readback_buffer, u32); u32 *base = G_Deref(queue->print_readback_buffer, u32);
u32 attempted_print_bytes_count = header[0]; // The number of bytes that shaders attempted to write u32 attempted_print_bytes_count = base[0]; // The number of bytes that shaders attempted to write
u32 prints_count = header[1]; // The number of individual shader prints that are in the buffer u32 prints_count = base[1]; // The number of individual shader prints that are in the buffer
u32 overflows_count = header[2]; // The number of individual shader prints that could not fit in the buffer u32 overflows_count = base[2]; // The number of individual shader prints that could not fit in the buffer
u8 *start = &header[3]; u8 *print_start = (u8 *)&base[3];
// Deserialize // Deserialize
if (GPU_SHADER_PRINT_LOG) if (GPU_SHADER_PRINT_LOG)
@ -4409,7 +4464,7 @@ void G_D12_CollectionWorkerEntryPoint(WaveLaneCtx *lane)
// FIXME: Remove this // FIXME: Remove this
TempArena scratch = BeginScratchNoConflict(); TempArena scratch = BeginScratchNoConflict();
u8 *at = start; u8 *at = print_start;
{ {
for (u32 print_idx = 0; print_idx < prints_count; ++print_idx) for (u32 print_idx = 0; print_idx < prints_count; ++print_idx)
{ {

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

@ -539,6 +539,12 @@ Struct(G_D12_CmdBatch)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Swapchain types //~ Swapchain types
Struct(G_D12_Backbuffer)
{
struct G_D12_Swapchain *swapchain;
ID3D12Resource *d3d_resource;
};
Struct(G_D12_Swapchain) Struct(G_D12_Swapchain)
{ {
@ -550,9 +556,9 @@ Struct(G_D12_Swapchain)
ID3D12Fence *present_fence; ID3D12Fence *present_fence;
u64 present_fence_target; u64 present_fence_target;
G_Format backbuffers_format; G_Format format;
Vec2I32 backbuffers_resolution; Vec2I32 resolution;
G_D12_Resource backbuffers[G_D12_SwapchainBufferCount]; struct G_D12_Backbuffer backbuffers[G_D12_SwapchainBufferCount];
}; };
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////

24
src/gpu/gpu_shared.cgh
View File

@ -96,12 +96,12 @@ Enum(G_BasicSamplerKind)
template<typename T> RWStructuredBuffer<T> G_SDerefRW(G_BufferRef r) { return ResourceDescriptorHeap[r.v + 1]; } template<typename T> RWStructuredBuffer<T> G_SDerefRW(G_BufferRef r) { return ResourceDescriptorHeap[r.v + 1]; }
ByteAddressBuffer G_SDerefRaw(G_BufferRef r) { return ResourceDescriptorHeap[r.v + 2]; } ByteAddressBuffer G_SDerefRaw(G_BufferRef r) { return ResourceDescriptorHeap[r.v + 2]; }
RWByteAddressBuffer G_SDerefRawRW(G_BufferRef r) { return ResourceDescriptorHeap[r.v + 3]; } RWByteAddressBuffer G_SDerefRawRW(G_BufferRef r) { return ResourceDescriptorHeap[r.v + 3]; }
template<typename T> Texture1D<T> G_SDeref(G_Texture1DRef r, u32 mip=0) { return ResourceDescriptorHeap[r.v + (mip * 2) + 0]; } template<typename T> Texture1D<T> G_SDeref1D(G_TextureRef r, u32 mip=0) { return ResourceDescriptorHeap[r.v + (mip * 2) + 0]; }
template<typename T> Texture2D<T> G_SDeref(G_Texture2DRef r, u32 mip=0) { return ResourceDescriptorHeap[r.v + (mip * 2) + 0]; } template<typename T> Texture2D<T> G_SDeref2D(G_TextureRef r, u32 mip=0) { return ResourceDescriptorHeap[r.v + (mip * 2) + 0]; }
template<typename T> Texture3D<T> G_SDeref(G_Texture3DRef r, u32 mip=0) { return ResourceDescriptorHeap[r.v + (mip * 2) + 0]; } template<typename T> Texture3D<T> G_SDeref3D(G_TextureRef r, u32 mip=0) { return ResourceDescriptorHeap[r.v + (mip * 2) + 0]; }
template<typename T> RWTexture1D<T> G_SDerefRW(G_Texture1DRef r, u32 mip=0) { return ResourceDescriptorHeap[r.v + (mip * 2) + 1]; } template<typename T> RWTexture1D<T> G_SDerefRW1D(G_TextureRef r, u32 mip=0) { return ResourceDescriptorHeap[r.v + (mip * 2) + 1]; }
template<typename T> RWTexture2D<T> G_SDerefRW(G_Texture2DRef r, u32 mip=0) { return ResourceDescriptorHeap[r.v + (mip * 2) + 1]; } template<typename T> RWTexture2D<T> G_SDerefRW2D(G_TextureRef r, u32 mip=0) { return ResourceDescriptorHeap[r.v + (mip * 2) + 1]; }
template<typename T> RWTexture3D<T> G_SDerefRW(G_Texture3DRef r, u32 mip=0) { return ResourceDescriptorHeap[r.v + (mip * 2) + 1]; } template<typename T> RWTexture3D<T> G_SDerefRW3D(G_TextureRef r, u32 mip=0) { return ResourceDescriptorHeap[r.v + (mip * 2) + 1]; }
SamplerState G_SDeref(G_SamplerRef r) { return SamplerDescriptorHeap[r.v]; } SamplerState G_SDeref(G_SamplerRef r) { return SamplerDescriptorHeap[r.v]; }
//- Vector/Non-Uniform dereference //- Vector/Non-Uniform dereference
@ -109,12 +109,12 @@ Enum(G_BasicSamplerKind)
template<typename T> RWStructuredBuffer<T> G_VDerefRW(G_BufferRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + 1)]; } template<typename T> RWStructuredBuffer<T> G_VDerefRW(G_BufferRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + 1)]; }
ByteAddressBuffer G_VDerefRaw(G_BufferRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + 2)]; } ByteAddressBuffer G_VDerefRaw(G_BufferRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + 2)]; }
RWByteAddressBuffer G_VDerefRawRW(G_BufferRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + 3)]; } RWByteAddressBuffer G_VDerefRawRW(G_BufferRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + 3)]; }
template<typename T> Texture1D<T> G_VDeref(G_Texture1DRef r, u32 mip=0) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + (mip * 2) + 0)]; } template<typename T> Texture1D<T> G_VDeref1D(G_TextureRef r, u32 mip=0) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + (mip * 2) + 0)]; }
template<typename T> Texture2D<T> G_VDeref(G_Texture2DRef r, u32 mip=0) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + (mip * 2) + 0)]; } template<typename T> Texture2D<T> G_VDeref2D(G_TextureRef r, u32 mip=0) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + (mip * 2) + 0)]; }
template<typename T> Texture3D<T> G_VDeref(G_Texture3DRef r, u32 mip=0) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + (mip * 2) + 0)]; } template<typename T> Texture3D<T> G_VDeref3D(G_TextureRef r, u32 mip=0) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + (mip * 2) + 0)]; }
template<typename T> RWTexture1D<T> G_VDerefRW(G_Texture1DRef r, u32 mip=0) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + (mip * 2) + 1)]; } template<typename T> RWTexture1D<T> G_VDerefRW1D(G_TextureRef r, u32 mip=0) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + (mip * 2) + 1)]; }
template<typename T> RWTexture2D<T> G_VDerefRW(G_Texture2DRef r, u32 mip=0) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + (mip * 2) + 1)]; } template<typename T> RWTexture2D<T> G_VDerefRW2D(G_TextureRef r, u32 mip=0) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + (mip * 2) + 1)]; }
template<typename T> RWTexture3D<T> G_VDerefRW(G_Texture3DRef r, u32 mip=0) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + (mip * 2) + 1)]; } template<typename T> RWTexture3D<T> G_VDerefRW3D(G_TextureRef r, u32 mip=0) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + (mip * 2) + 1)]; }
SamplerState G_VDeref(G_SamplerRef r) { return SamplerDescriptorHeap[NonUniformResourceIndex(r.v)]; } SamplerState G_VDeref(G_SamplerRef r) { return SamplerDescriptorHeap[NonUniformResourceIndex(r.v)]; }

66
src/proto/proto.c
View File

@ -1,11 +1,15 @@
void PT_RunForever(WaveLaneCtx *lane) void PT_RunForever(WaveLaneCtx *lane)
{ {
Arena *frame_arena = AcquireArena(Gibi(64));
G_ArenaHandle gpu_frame_arena = G_AcquireArena(); G_ArenaHandle gpu_frame_arena = G_AcquireArena();
for (;;) for (;;)
{ {
ResetArena(frame_arena);
PT_SharedFrame *frame = PushStruct(frame_arena, PT_SharedFrame);
WND_Frame window_frame = WND_BeginFrame(G_Format_R16G16B16A16_Float, WND_BackbufferSizeMode_MatchWindow); WND_Frame window_frame = WND_BeginFrame(G_Format_R16G16B16A16_Float, WND_BackbufferSizeMode_MatchWindow);
G_ResourceHandle backbuffer = window_frame.backbuffer; G_BackbufferHandle backbuffer = window_frame.backbuffer;
for (u64 cev_idx = 0; cev_idx < window_frame.controller_events.count; ++cev_idx) for (u64 cev_idx = 0; cev_idx < window_frame.controller_events.count; ++cev_idx)
{ {
@ -18,56 +22,50 @@ void PT_RunForever(WaveLaneCtx *lane)
G_CommandListHandle cl = G_PrepareCommandList(G_QueueKind_Direct); G_CommandListHandle cl = G_PrepareCommandList(G_QueueKind_Direct);
{ {
G_SyncLayout(cl, backbuffer, G_Layout_Exclusive); // Gpu upload pass
Vec2I32 final_target_size = window_frame.draw_size;
G_ResourceHandle final_target_res = G_PushTexture2D(
gpu_frame_arena, cl,
G_Format_R16G16B16A16_Float,
final_target_size,
G_Layout_Exclusive,
.flags = G_ResourceFlag_AllowShaderReadWrite
);
G_Texture2DRef final_target = G_PushTexture2DRef(gpu_frame_arena, final_target_res);
// Prep test pass
{ {
G_SetConstant(cl, PT_ShaderConst_TestTarget, final_target); G_ResetArena(cl, gpu_frame_arena);
G_SetConstant(cl, PT_ShaderConst_TestConst, 3.123); frame->noise_tex = G_BasicNoise3D();
G_SetConstant(cl, PT_ShaderConst_BlitSampler, G_BasicSamplerFromKind(G_BasicSamplerKind_PointClamp)); frame->sampler = G_BasicSamplerFromKind(G_BasicSamplerKind_PointClamp);
G_SetConstant(cl, PT_ShaderConst_BlitSrc, final_target); frame->compute_target = G_PushTexture2D(
G_SetConstant(cl, PT_ShaderConst_NoiseTex, G_BasicNoiseTexture()); cl, gpu_frame_arena,
G_TextureLayout_Family,
G_Format_R16G16B16A16_Float,
window_frame.draw_size,
.flags = G_MemoryFlag_AllowTextureRW
);
frame->screen = G_PushTexture2D(
cl, gpu_frame_arena,
G_TextureLayout_Family,
G_Format_R16G16B16A16_Float,
window_frame.draw_size,
.flags = G_MemoryFlag_AllowTextureRW | G_MemoryFlag_AllowTextureDraw
);
G_SetConstant(cl, PT_ShaderConst_Frame, G_PushStructFromCpu(cl, gpu_frame_arena, frame));
} }
G_Sync(cl);
// Test pass // Test pass
{ {
G_Compute2D(cl, PT_TestCS, final_target_size); G_Compute2D(cl, PT_TestCS, G_Count2D(frame->compute_target));
G_Sync(cl);
} }
G_Sync(cl);
// Blit pass // Blit pass
{
G_Draw( G_Draw(
cl, cl,
PT_BlitVS, PT_BlitPS, PT_BlitVS, PT_BlitPS,
1, G_QuadIndices(), 1, G_QuadIndices(),
1, &G_Rt(backbuffer, G_BlendMode_CompositeStraightAlpha), 1, &G_Rt(frame->screen, G_BlendMode_CompositeStraightAlpha),
G_ViewportFromTexture(backbuffer), G_ScissorFromTexture(backbuffer), G_ViewportFromTexture(frame->screen), G_ScissorFromTexture(frame->screen),
G_DrawMode_TriangleList G_DrawMode_TriangleList
); );
} }
// Reset
{
G_ResetArena(cl, gpu_frame_arena);
}
G_SyncLayout(cl, backbuffer, G_Layout_Common);
}
G_CommitCommandList(cl); G_CommitCommandList(cl);
WND_EndFrame(window_frame, 1); WND_EndFrame(window_frame, VEC2I32(0, 0), frame->screen, RNG2I32(VEC2I32(0, 0), G_Count2D(frame->screen)), 1);
} }
} }

13
src/proto/proto_gpu.g
View File

@ -3,8 +3,8 @@
ComputeShader(PT_TestCS) ComputeShader(PT_TestCS)
{ {
StructuredBuffer<TestStruct> sb = G_SDeref<TestStruct>(PT_ShaderConst_TestBuff); PT_SharedFrame frame = G_SDeref<PT_SharedFrame>(PT_ShaderConst_Frame)[0];
RWTexture2D<Vec4> target_tex = G_SDerefRW<Vec4>(PT_ShaderConst_TestTarget); RWTexture2D<Vec4> target_tex = G_SDerefRW2D<Vec4>(frame.compute_target);
Vec2U32 target_tex_size = countof(target_tex); Vec2U32 target_tex_size = countof(target_tex);
@ -35,12 +35,13 @@ VertexShader(PT_BlitVS, PT_BlitPSInput)
PixelShader(PT_BlitPS, PT_BlitPSOutput, PT_BlitPSInput input) PixelShader(PT_BlitPS, PT_BlitPSOutput, PT_BlitPSInput input)
{ {
SamplerState sampler = G_SDeref(PT_ShaderConst_BlitSampler); PT_SharedFrame frame = G_SDeref<PT_SharedFrame>(PT_ShaderConst_Frame)[0];
Texture2D<Vec4> tex = G_SDeref<Vec4>(PT_ShaderConst_BlitSrc); SamplerState sampler = G_SDeref(frame.sampler);
Texture3D<u32> noise = G_SDeref<u32>(PT_ShaderConst_NoiseTex); Texture2D<Vec4> src = G_SDeref2D<Vec4>(frame.compute_target);
Texture3D<u32> noise = G_SDeref3D<u32>(frame.noise_tex);
Vec2 uv = input.src_uv; Vec2 uv = input.src_uv;
Vec4 tex_col = tex.Sample(sampler, uv); Vec4 tex_col = src.Sample(sampler, uv);
Vec3U32 noise_coord = 0; Vec3U32 noise_coord = 0;
noise_coord.x = uv.x * 128.0; noise_coord.x = uv.x * 128.0;

8
src/proto/proto_gpu.gh
View File

@ -1,11 +1,3 @@
////////////////////////////////////////////////////////////
//~ Test shader types
Struct(TestStruct)
{
i32 i;
};
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Blit shader types //~ Blit shader types

18
src/proto/proto_shared.cgh
View File

@ -1,13 +1,15 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Constants //~ Constants
G_DeclConstant(G_Texture3DRef, PT_ShaderConst_NoiseTex, 0); G_DeclConstant(G_BufferRef, PT_ShaderConst_Frame, 0);
// Test shader ////////////////////////////////////////////////////////////
G_DeclConstant(G_Texture2DRef, PT_ShaderConst_TestTarget, 1); //~ State types
G_DeclConstant(G_StructuredBufferRef, PT_ShaderConst_TestBuff, 2);
G_DeclConstant(f32, PT_ShaderConst_TestConst, 3);
// Blit shader Struct(PT_SharedFrame)
G_DeclConstant(G_SamplerStateRef, PT_ShaderConst_BlitSampler, 4); {
G_DeclConstant(G_Texture2DRef, PT_ShaderConst_BlitSrc, 5); G_TextureRef noise_tex;
G_TextureRef compute_target;
G_TextureRef screen;
G_SamplerRef sampler;
};

4
src/window/window.h
View File

@ -62,7 +62,7 @@ Enum(WND_BackbufferSizeMode)
Struct(WND_Frame) Struct(WND_Frame)
{ {
WND_Handle window; WND_Handle window;
G_ResourceHandle backbuffer; G_BackbufferHandle backbuffer;
ControllerEventsArray controller_events; ControllerEventsArray controller_events;
@ -95,4 +95,4 @@ void WND_PushCmd_(WND_Frame frame, WND_Cmd desc);
//~ @hookdecl Frame //~ @hookdecl Frame
WND_Frame WND_BeginFrame(G_Format backbuffer_format, WND_BackbufferSizeMode backbuffer_size_mode); WND_Frame WND_BeginFrame(G_Format backbuffer_format, WND_BackbufferSizeMode backbuffer_size_mode);
void WND_EndFrame(WND_Frame frame, i32 vsync); void WND_EndFrame(WND_Frame frame, Vec2I32 backbuffer_pos, G_TextureRef src, Rng2I32 src_range, i32 vsync);

4
src/window/window_win32/window_win32.c
View File

@ -585,7 +585,7 @@ WND_Frame WND_BeginFrame(G_Format backbuffer_format, WND_BackbufferSizeMode back
return result; return result;
} }
void WND_EndFrame(WND_Frame frame, i32 vsync) void WND_EndFrame(WND_Frame frame, Vec2I32 backbuffer_pos, G_TextureRef src, Rng2I32 src_range, i32 vsync)
{ {
TempArena scratch = BeginScratchNoConflict(); TempArena scratch = BeginScratchNoConflict();
WND_W32_Window *window = WND_W32_WindowFromHandle(frame.window); WND_W32_Window *window = WND_W32_WindowFromHandle(frame.window);
@ -830,7 +830,7 @@ void WND_EndFrame(WND_Frame frame, i32 vsync)
} }
// Commit backbuffer // Commit backbuffer
G_CommitBackbuffer(frame.backbuffer, vsync); G_CommitBackbuffer(frame.backbuffer, backbuffer_pos, src, src_range, vsync);
++window->frame_gen; ++window->frame_gen;
EndScratch(scratch); EndScratch(scratch);

2
src/window/window_win32/window_win32.h
View File

@ -5,7 +5,7 @@ Struct(WND_W32_Window)
{ {
HWND hwnd; HWND hwnd;
G_SwapchainHandle swapchain; G_SwapchainHandle swapchain;
G_ResourceHandle backbuffer; G_BackbufferHandle backbuffer;
Atomic32 is_ready; Atomic32 is_ready;
// Window proc state // Window proc state