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
{
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
@ -138,14 +138,6 @@ G_ArenaHandle G_PermArena(void)
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
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);
//- 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
i32 G_DimsFromMip1D(i32 mip0_dims, i32 mip);

49
src/gpu/gpu_core.h
View File

@ -4,11 +4,13 @@
Struct(G_ArenaHandle) { u64 v; };
Struct(G_CommandListHandle) { u64 v; };
Struct(G_SwapchainHandle) { u64 v; };
Struct(G_BackbufferHandle) { u64 v; };
#define G_IsArenaNil(h) ((h).v == 0)
#define G_IsCommandListNil(h) ((h).v == 0)
#define G_IsResourceNil(h) ((h).v == 0)
#define G_IsSwapchainNil(h) ((h).v == 0)
#define G_IsBackbufferNil(h) ((h).v == 0)
////////////////////////////////////////////////////////////
//~ Queue types
@ -322,6 +324,7 @@ Struct(G_BufferDesc)
u64 stride;
u64 count;
String name;
void *cpu_src;
};
Struct(G_TextureDesc)
@ -421,26 +424,42 @@ 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);
#define G_PushBuffer(_cl, _arena, _type, _count, ...) ((G_BufferRef) { .v = G_PushMemory((_cl), (_arena), \
(G_MemoryDesc) { \
.kind = G_MemoryKind_Buffer, \
.buffer = { \
.count = (_count), \
.stride = sizeof(_type), \
__VA_ARGS__ \
} \
} \
//- 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) { \
.kind = G_MemoryKind_Buffer, \
.buffer = { \
.count = (_count), \
.stride = sizeof(_type), \
__VA_ARGS__ \
} \
} \
)})
#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), \
(G_MemoryDesc) { \
.kind = G_MemoryKind_Texture1D, \
.texture = { \
.format = (_format), \
.dims = VEC3I32((_dims).x, 1, 1), \
.dims = VEC3I32((_dims).x, 1, 1), \
.initial_layout = (_initial_layout), \
__VA_ARGS__ \
} \
@ -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), \
(G_MemoryDesc) { \
@ -563,7 +582,7 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl, G_ArenaHandle gpu_are
//- 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
@ -729,6 +748,6 @@ void G_ReleaseSwapchain(G_SwapchainHandle swapchain);
// Waits until a new backbuffer is ready from the swapchain.
// 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);

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

@ -574,12 +574,12 @@ void G_Bootstrap(void)
{
G_ArenaHandle gpu_perm = G_PermArena();
queue->print_buffer_size = GPU_SHADER_PRINT_BUFFER_SIZE;
queue->print_buffer = G_PushBuffer(
queue->print_buffer = G_PushStructs(
cl, gpu_perm,
u8, queue->print_buffer_size,
.name = Lit("Debug print gpu buffer")
);
queue->print_readback_buffer = G_PushBuffer(
queue->print_readback_buffer = G_PushStructs(
cl, gpu_perm,
u8, queue->print_buffer_size,
.flags = G_MemoryFlag_HostCached,
@ -629,6 +629,11 @@ G_D12_Swapchain *G_D12_SwapchainFromHandle(G_SwapchainHandle handle)
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)
{
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;
@ -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 result;
return descriptor_idx;
}
@ -2491,7 +2504,7 @@ G_D12_StagingRegionNode *G_D12_PushStagingRegion(G_D12_CmdList *cl, u64 size)
G_ArenaHandle gpu_arena_handle = G_AcquireArena();
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,
u8, new_ring_size,
.flags = G_MemoryFlag_HostUncached
@ -4114,7 +4127,7 @@ void G_ReleaseSwapchain(G_SwapchainHandle swapchain_handle)
// 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);
TempArena scratch = BeginScratchNoConflict();
@ -4140,7 +4153,7 @@ G_TextureRef G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Format fo
desc.Height = size.y;
desc.SampleDesc.Count = 1;
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.Scaling = DXGI_SCALING_NONE;
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->backbuffers_format = format;
swapchain->backbuffers_resolution = size;
swapchain->format = format;
swapchain->resolution = size;
}
// Create waitable object
@ -4195,7 +4208,7 @@ G_TextureRef G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Format fo
}
// Resize backbuffers
if (!MatchVec2I32(swapchain->backbuffers_resolution, size) || swapchain->backbuffers_format != format)
if (!MatchVec2I32(swapchain->resolution, size) || swapchain->format != format)
{
HRESULT hr = 0;
@ -4208,7 +4221,7 @@ G_TextureRef G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Format fo
// Release backbuffers
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)
{
ID3D12Resource_Release(backbuffer->d3d_resource);
@ -4227,43 +4240,60 @@ G_TextureRef G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Format fo
// 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)
{
G_D12_Resource *backbuffer = &swapchain->backbuffers[backbuffer_idx];
G_D12_Backbuffer *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);
ZeroStruct(backbuffer);
HRESULT hr = IDXGISwapChain3_GetBuffer(swapchain->d3d_swapchain, backbuffer_idx, &IID_ID3D12Resource, (void **)&backbuffer->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);
Panic(Lit("Failed to retrieve backbuffer from D3D12 swapchain"));
}
G_D12_SetObjectName((ID3D12Object *)backbuffer->d3d_resource, StringF(scratch.arena, "Backbuffer [%F]", FmtUint(backbuffer_idx)));
}
}
swapchain->backbuffers_format = format;
swapchain->backbuffers_resolution = size;
swapchain->format = format;
swapchain->resolution = size;
}
// Wait for available backbuffer
@ -4278,22 +4308,47 @@ G_TextureRef G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Format fo
}
// Grab current backbuffer
G_D12_Resource *cur_backbuffer = 0;
G_D12_Backbuffer *cur_backbuffer = 0;
{
u32 backbuffer_idx = IDXGISwapChain3_GetCurrentBackBufferIndex(swapchain->d3d_swapchain);
cur_backbuffer = &swapchain->backbuffers[backbuffer_idx];
}
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_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;
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);
if (!G_IsResourceNil(queue->print_buffer))
{
u32 header = G_Deref(queue->print_readback_buffer, u32);
u32 attempted_print_bytes_count = header[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 overflows_count = header[2]; // The number of individual shader prints that could not fit in the buffer
u8 *start = &header[3];
u32 *base = G_Deref(queue->print_readback_buffer, u32);
u32 attempted_print_bytes_count = base[0]; // The number of bytes that shaders attempted to write
u32 prints_count = base[1]; // The number of individual shader prints that are in the buffer
u32 overflows_count = base[2]; // The number of individual shader prints that could not fit in the buffer
u8 *print_start = (u8 *)&base[3];
// Deserialize
if (GPU_SHADER_PRINT_LOG)
@ -4409,7 +4464,7 @@ void G_D12_CollectionWorkerEntryPoint(WaveLaneCtx *lane)
// FIXME: Remove this
TempArena scratch = BeginScratchNoConflict();
u8 *at = start;
u8 *at = print_start;
{
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
Struct(G_D12_Backbuffer)
{
struct G_D12_Swapchain *swapchain;
ID3D12Resource *d3d_resource;
};
Struct(G_D12_Swapchain)
{
@ -550,9 +556,9 @@ Struct(G_D12_Swapchain)
ID3D12Fence *present_fence;
u64 present_fence_target;
G_Format backbuffers_format;
Vec2I32 backbuffers_resolution;
G_D12_Resource backbuffers[G_D12_SwapchainBufferCount];
G_Format format;
Vec2I32 resolution;
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]; }
ByteAddressBuffer G_SDerefRaw(G_BufferRef r) { return ResourceDescriptorHeap[r.v + 2]; }
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> Texture2D<T> G_SDeref(G_Texture2DRef 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> RWTexture1D<T> G_SDerefRW(G_Texture1DRef 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> RWTexture3D<T> G_SDerefRW(G_Texture3DRef r, u32 mip=0) { return ResourceDescriptorHeap[r.v + (mip * 2) + 1]; }
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_SDeref2D(G_TextureRef 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_SDerefRW1D(G_TextureRef 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_SDerefRW3D(G_TextureRef r, u32 mip=0) { return ResourceDescriptorHeap[r.v + (mip * 2) + 1]; }
SamplerState G_SDeref(G_SamplerRef r) { return SamplerDescriptorHeap[r.v]; }
//- 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)]; }
ByteAddressBuffer G_VDerefRaw(G_BufferRef r) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + 2)]; }
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> Texture2D<T> G_VDeref(G_Texture2DRef 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> RWTexture1D<T> G_VDerefRW(G_Texture1DRef 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> RWTexture3D<T> G_VDerefRW(G_Texture3DRef r, u32 mip=0) { return ResourceDescriptorHeap[NonUniformResourceIndex(r.v + (mip * 2) + 1)]; }
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_VDeref2D(G_TextureRef 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_VDerefRW1D(G_TextureRef 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_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)]; }

78
src/proto/proto.c
View File

@ -1,11 +1,15 @@
void PT_RunForever(WaveLaneCtx *lane)
{
Arena *frame_arena = AcquireArena(Gibi(64));
G_ArenaHandle gpu_frame_arena = G_AcquireArena();
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);
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)
{
@ -18,56 +22,50 @@ void PT_RunForever(WaveLaneCtx *lane)
G_CommandListHandle cl = G_PrepareCommandList(G_QueueKind_Direct);
{
G_SyncLayout(cl, backbuffer, G_Layout_Exclusive);
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
// Gpu upload pass
{
G_SetConstant(cl, PT_ShaderConst_TestTarget, final_target);
G_SetConstant(cl, PT_ShaderConst_TestConst, 3.123);
G_SetConstant(cl, PT_ShaderConst_BlitSampler, G_BasicSamplerFromKind(G_BasicSamplerKind_PointClamp));
G_SetConstant(cl, PT_ShaderConst_BlitSrc, final_target);
G_SetConstant(cl, PT_ShaderConst_NoiseTex, G_BasicNoiseTexture());
G_ResetArena(cl, gpu_frame_arena);
frame->noise_tex = G_BasicNoise3D();
frame->sampler = G_BasicSamplerFromKind(G_BasicSamplerKind_PointClamp);
frame->compute_target = G_PushTexture2D(
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
{
G_Compute2D(cl, PT_TestCS, final_target_size);
G_Sync(cl);
G_Compute2D(cl, PT_TestCS, G_Count2D(frame->compute_target));
}
G_Sync(cl);
// Blit pass
{
G_Draw(
cl,
PT_BlitVS, PT_BlitPS,
1, G_QuadIndices(),
1, &G_Rt(backbuffer, G_BlendMode_CompositeStraightAlpha),
G_ViewportFromTexture(backbuffer), G_ScissorFromTexture(backbuffer),
G_DrawMode_TriangleList
);
}
// Reset
{
G_ResetArena(cl, gpu_frame_arena);
}
G_SyncLayout(cl, backbuffer, G_Layout_Common);
G_Draw(
cl,
PT_BlitVS, PT_BlitPS,
1, G_QuadIndices(),
1, &G_Rt(frame->screen, G_BlendMode_CompositeStraightAlpha),
G_ViewportFromTexture(frame->screen), G_ScissorFromTexture(frame->screen),
G_DrawMode_TriangleList
);
}
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)
{
StructuredBuffer<TestStruct> sb = G_SDeref<TestStruct>(PT_ShaderConst_TestBuff);
RWTexture2D<Vec4> target_tex = G_SDerefRW<Vec4>(PT_ShaderConst_TestTarget);
PT_SharedFrame frame = G_SDeref<PT_SharedFrame>(PT_ShaderConst_Frame)[0];
RWTexture2D<Vec4> target_tex = G_SDerefRW2D<Vec4>(frame.compute_target);
Vec2U32 target_tex_size = countof(target_tex);
@ -35,12 +35,13 @@ VertexShader(PT_BlitVS, PT_BlitPSInput)
PixelShader(PT_BlitPS, PT_BlitPSOutput, PT_BlitPSInput input)
{
SamplerState sampler = G_SDeref(PT_ShaderConst_BlitSampler);
Texture2D<Vec4> tex = G_SDeref<Vec4>(PT_ShaderConst_BlitSrc);
Texture3D<u32> noise = G_SDeref<u32>(PT_ShaderConst_NoiseTex);
PT_SharedFrame frame = G_SDeref<PT_SharedFrame>(PT_ShaderConst_Frame)[0];
SamplerState sampler = G_SDeref(frame.sampler);
Texture2D<Vec4> src = G_SDeref2D<Vec4>(frame.compute_target);
Texture3D<u32> noise = G_SDeref3D<u32>(frame.noise_tex);
Vec2 uv = input.src_uv;
Vec4 tex_col = tex.Sample(sampler, uv);
Vec4 tex_col = src.Sample(sampler, uv);
Vec3U32 noise_coord = 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

18
src/proto/proto_shared.cgh
View File

@ -1,13 +1,15 @@
////////////////////////////////////////////////////////////
//~ 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);
G_DeclConstant(G_StructuredBufferRef, PT_ShaderConst_TestBuff, 2);
G_DeclConstant(f32, PT_ShaderConst_TestConst, 3);
////////////////////////////////////////////////////////////
//~ State types
// Blit shader
G_DeclConstant(G_SamplerStateRef, PT_ShaderConst_BlitSampler, 4);
G_DeclConstant(G_Texture2DRef, PT_ShaderConst_BlitSrc, 5);
Struct(PT_SharedFrame)
{
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)
{
WND_Handle window;
G_ResourceHandle backbuffer;
G_BackbufferHandle backbuffer;
ControllerEventsArray controller_events;
@ -95,4 +95,4 @@ void WND_PushCmd_(WND_Frame frame, WND_Cmd desc);
//~ @hookdecl Frame
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;
}
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();
WND_W32_Window *window = WND_W32_WindowFromHandle(frame.window);
@ -830,7 +830,7 @@ void WND_EndFrame(WND_Frame frame, i32 vsync)
}
// Commit backbuffer
G_CommitBackbuffer(frame.backbuffer, vsync);
G_CommitBackbuffer(frame.backbuffer, backbuffer_pos, src, src_range, vsync);
++window->frame_gen;
EndScratch(scratch);

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

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