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

typed gpu resource ids

Browse Source
This commit is contained in:
jacob 2025-09-24 17:50:33 -05:00
parent 7a7c6c2350
commit c61e30d3a4
10 changed files with 168 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
src/base/base.h
View File

@ -369,20 +369,6 @@ void __asan_unpoison_memory_region(void const volatile *add, size_t);
#define ColorOrange Rgb32(0xFF, 0xA5, 0x00)
#define ColorPurple Rgb32(0xFF, 0x00, 0XFF)
////////////////////////////////
//~ Gpu helpers
#if LanguageIsGpu
//- Resource heap index
# define GpuResourceFromUrid(urid) ResourceDescriptorHeap[(urid)]
# define GpuResourceFromNurid(nurid) ResourceDescriptorHeap[NonUniformResourceIndex((nurid))]
# define GpuSamplerFromUrid(urid) SamplerDescriptorHeap[(urid)]
# define GpuSamplerFromNurid(nurid) SamplerDescriptorHeap[NonUniformResourceIndex((nurid))]
//- Semantic declaration
# define Semantic(t, n) t n : n
#endif
////////////////////////////////
//~ Intrinsic headers
@ -695,6 +681,7 @@ Struct(Resource)
#if LanguageIsC
Struct(VertexShader) { Resource resource; };
Struct(PixelShader) { Resource resource; };
Struct(ComputeShader) { Resource resource; };
@ -703,8 +690,31 @@ Struct(ComputeShader) { Resource resource; };
# define PSDecl(name) extern PixelShader name;
# define CSDecl(name) extern ComputeShader name;
//- Resource descriptor index types
Struct(StructuredBufferRid) { u32 v; };
Struct(RWStructuredBufferRid) { u32 v; };
Struct(Texture1DRid) { u32 v; };
Struct(Texture2DRid) { u32 v; };
Struct(Texture3DRid) { u32 v; };
Struct(RWTexture1DRid) { u32 v; };
Struct(RWTexture2DRid) { u32 v; };
Struct(RWTexture3DRid) { u32 v; };
Struct(SamplerStateRid) { u32 v; };
#elif LanguageIsGpu
//- Resource descriptor index types
typedef uint StructuredBufferRid;
typedef uint RWStructuredBufferRid;
typedef uint Texture1DRid;
typedef uint Texture2DRid;
typedef uint Texture3DRid;
typedef uint RWTexture1DRid;
typedef uint RWTexture2DRid;
typedef uint RWTexture3DRid;
typedef uint SamplerStateRid;
//- Shader declaration
# define VSDecl(name)
# define PSDecl(name)
# define CSDecl(name)
@ -713,6 +723,15 @@ Struct(ComputeShader) { Resource resource; };
# define PSDef(name, ...) name(__VA_ARGS__)
# define CSDef(name, ...) name(__VA_ARGS__)
//- Semantic declaration
# define Semantic(t, n) t n : n
//- Descriptor heap index
# define UniformResourceFromRid(rid) ResourceDescriptorHeap[rid]
# define UniformSamplerFromRid(rid) SamplerDescriptorHeap[rid]
# define NonUniformResourceFromRid(rid) ResourceDescriptorHeap[NonUniformResourceIndex(rid)]
# define NonUniformSamplerFromRid(rid) SamplerDescriptorHeap[NonUniformResourceIndex(rid)]
#endif
////////////////////////////////

4
src/config.h
View File

@ -69,7 +69,7 @@
#define FLOOD_DEBUG 0
#define GPU_DEBUG 1
#define GPU_DEBUG 0
/* If virtual fibers are enabled, each fiber will get its own OS thread,
* and fiber suspend/resume will be emulated using OS thread primitives.
@ -96,4 +96,4 @@
#define VSYNC !RtcIsEnabled
#define AUDIO_ENABLED 0
#define FPS_LIMIT 300
#define FPS_LIMIT 0

16
src/gpu/gpu.h
View File

@ -380,13 +380,23 @@ GPU_Scissor GPU_ScissorFromRect(Rect rect);
GPU_Resource *GPU_AcquireResource(GPU_ResourceDesc desc);
void GPU_ReleaseResource(GPU_Resource *resource, GPU_ReleaseFlag flags);
u32 GPU_GetReadableId(GPU_Resource *resource);
u32 GPU_GetWritableId(GPU_Resource *resource);
u32 GPU_GetSamplerId(GPU_Resource *resource);
Vec2I32 GPU_GetTextureSize2D(GPU_Resource *resource);
Vec3I32 GPU_GetTextureSize3D(GPU_Resource *resource);
u64 GPU_GetFootprintSize(GPU_Resource *resource);
////////////////////////////////
//~ @hookdecl Resource index operations
StructuredBufferRid GPU_StructuredBufferRidFromResource(GPU_Resource *resource);
RWStructuredBufferRid GPU_RWStructuredBufferRidFromResource(GPU_Resource *resource);
Texture1DRid GPU_Texture1DRidFromResource(GPU_Resource *resource);
Texture2DRid GPU_Texture2DRidFromResource(GPU_Resource *resource);
Texture3DRid GPU_Texture3DRidFromResource(GPU_Resource *resource);
RWTexture1DRid GPU_RWTexture1DRidFromResource(GPU_Resource *resource);
RWTexture2DRid GPU_RWTexture2DRidFromResource(GPU_Resource *resource);
RWTexture3DRid GPU_RWTexture3DRidFromResource(GPU_Resource *resource);
SamplerStateRid GPU_SamplerStateRidFromResource(GPU_Resource *resource);
////////////////////////////////
//~ @hookdecl Command list operations

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

@ -147,7 +147,7 @@ void GPU_D12_InitDevice(void)
ID3D12Debug_EnableDebugLayer(debug_controller0);
/* FIXME: Enable this */
// ID3D12Debug1_SetEnableGPUBasedValidation(debug_controller1, 1);
ID3D12Debug1_SetEnableGPUBasedValidation(debug_controller1, 1);
ID3D12Debug_Release(debug_controller1);
ID3D12Debug_Release(debug_controller0);
@ -568,6 +568,7 @@ GPU_D12_Descriptor *GPU_D12_AcquireDescriptor(GPU_D12_DescriptorHeap *heap)
Unlock(&lock);
}
ZeroStruct(d);
d->valid = 1;
d->heap = heap;
d->handle = handle;
d->index = index;
@ -954,7 +955,7 @@ void GPU_Startup(void)
}
////////////////////////////////
//~ @hookdecl Fence hooks
//~ @hookdef Fence hooks
Fence *GPU_FenceFromQueue(GPU_QueueKind queue_kind)
{
@ -1150,12 +1151,17 @@ GPU_Resource *GPU_AcquireResource(GPU_ResourceDesc desc)
}
}
r->srv_descriptor = &GPU_D12_NilDescriptor;
r->uav_descriptor = &GPU_D12_NilDescriptor;
r->rtv_descriptor = &GPU_D12_NilDescriptor;
r->sampler_descriptor = &GPU_D12_NilDescriptor;
/* Create texture srv descriptor */
if (desc.kind == GPU_ResourceKind_Texture1D
|| desc.kind == GPU_ResourceKind_Texture2D
|| desc.kind == GPU_ResourceKind_Texture3D)
{
if (!r->srv_descriptor)
if (!r->srv_descriptor->valid)
{
r->srv_descriptor = GPU_D12_AcquireDescriptor(g->cbv_srv_uav_heap);
}
@ -1167,7 +1173,7 @@ GPU_Resource *GPU_AcquireResource(GPU_ResourceDesc desc)
&& desc.buffer.heap_kind != GPU_HeapKind_Download
&& desc.buffer.count > 0)
{
if (!r->srv_descriptor)
if (!r->srv_descriptor->valid)
{
r->srv_descriptor = GPU_D12_AcquireDescriptor(g->cbv_srv_uav_heap);
}
@ -1185,7 +1191,7 @@ GPU_Resource *GPU_AcquireResource(GPU_ResourceDesc desc)
/* Create uav descriptor */
if (desc.flags & GPU_ResourceFlag_Writable)
{
if (!r->uav_descriptor)
if (!r->uav_descriptor->valid)
{
r->uav_descriptor = GPU_D12_AcquireDescriptor(g->cbv_srv_uav_heap);
}
@ -1195,7 +1201,7 @@ GPU_Resource *GPU_AcquireResource(GPU_ResourceDesc desc)
/* Create rtv descriptor */
if (desc.flags & GPU_ResourceFlag_Renderable)
{
if (!r->rtv_descriptor)
if (!r->rtv_descriptor->valid)
{
r->rtv_descriptor = GPU_D12_AcquireDescriptor(g->rtv_heap);
}
@ -1205,7 +1211,7 @@ GPU_Resource *GPU_AcquireResource(GPU_ResourceDesc desc)
/* Create sampler descriptor */
if (desc.kind == GPU_ResourceKind_Sampler)
{
if (!r->sampler_descriptor)
if (!r->sampler_descriptor->valid)
{
r->sampler_descriptor = GPU_D12_AcquireDescriptor(g->sampler_heap);
}
@ -1246,25 +1252,21 @@ void GPU_ReleaseResource(GPU_Resource *gpu_resource, GPU_ReleaseFlag flags)
GPU_D12_SharedState *g = &GPU_D12_shared_state;
GPU_D12_Resource *r = (GPU_D12_Resource *)gpu_resource;
if (r->srv_descriptor)
if (r->srv_descriptor->valid)
{
GPU_D12_ReleaseDescriptor(r->srv_descriptor);
r->srv_descriptor = 0;
}
if (r->uav_descriptor)
if (r->uav_descriptor->valid)
{
GPU_D12_ReleaseDescriptor(r->uav_descriptor);
r->uav_descriptor = 0;
}
if (r->rtv_descriptor)
if (r->rtv_descriptor->valid)
{
GPU_D12_ReleaseDescriptor(r->rtv_descriptor);
r->rtv_descriptor = 0;
}
if (r->sampler_descriptor)
if (r->sampler_descriptor->valid)
{
GPU_D12_ReleaseDescriptor(r->sampler_descriptor);
r->sampler_descriptor = 0;
}
if (flags & GPU_ReleaseFlag_Reuse)
@ -1324,39 +1326,6 @@ void GPU_ReleaseResource(GPU_Resource *gpu_resource, GPU_ReleaseFlag flags)
}
u32 GPU_GetReadableId(GPU_Resource *gpu_resource)
{
u32 result = U32Max;
GPU_D12_Resource *r = (GPU_D12_Resource *)gpu_resource;
if (r && r->srv_descriptor)
{
result = r->srv_descriptor->index;
}
return result;
}
u32 GPU_GetWritableId(GPU_Resource *gpu_resource)
{
u32 result = U32Max;
GPU_D12_Resource *r = (GPU_D12_Resource *)gpu_resource;
if (r && r->uav_descriptor)
{
result = r->uav_descriptor->index;
}
return result;
}
u32 GPU_GetSamplerId(GPU_Resource *gpu_resource)
{
u32 result = U32Max;
GPU_D12_Resource *r = (GPU_D12_Resource *)gpu_resource;
if (r && r->sampler_descriptor)
{
result = r->sampler_descriptor->index;
}
return result;
}
Vec2I32 GPU_GetTextureSize2D(GPU_Resource *gpu_resource)
{
GPU_D12_Resource *resource = (GPU_D12_Resource *)gpu_resource;
@ -1382,6 +1351,19 @@ u64 GPU_GetFootprintSize(GPU_Resource *gpu_resource)
return footprint_size;
}
////////////////////////////////
//~ @hookdef Resource index hooks
StructuredBufferRid GPU_StructuredBufferRidFromResource(GPU_Resource *resource) { return (StructuredBufferRid) { ((GPU_D12_Resource *)resource)->srv_descriptor->index }; }
RWStructuredBufferRid GPU_RWStructuredBufferRidFromResource(GPU_Resource *resource) { return (RWStructuredBufferRid) { ((GPU_D12_Resource *)resource)->uav_descriptor->index }; }
Texture1DRid GPU_Texture1DRidFromResource(GPU_Resource *resource) { return (Texture1DRid) { ((GPU_D12_Resource *)resource)->srv_descriptor->index }; }
Texture2DRid GPU_Texture2DRidFromResource(GPU_Resource *resource) { return (Texture2DRid) { ((GPU_D12_Resource *)resource)->srv_descriptor->index }; }
Texture3DRid GPU_Texture3DRidFromResource(GPU_Resource *resource) { return (Texture3DRid) { ((GPU_D12_Resource *)resource)->srv_descriptor->index }; }
RWTexture1DRid GPU_RWTexture1DRidFromResource(GPU_Resource *resource) { return (RWTexture1DRid) { ((GPU_D12_Resource *)resource)->uav_descriptor->index }; }
RWTexture2DRid GPU_RWTexture2DRidFromResource(GPU_Resource *resource) { return (RWTexture2DRid) { ((GPU_D12_Resource *)resource)->uav_descriptor->index }; }
RWTexture3DRid GPU_RWTexture3DRidFromResource(GPU_Resource *resource) { return (RWTexture3DRid) { ((GPU_D12_Resource *)resource)->uav_descriptor->index }; }
SamplerStateRid GPU_SamplerStateRidFromResource(GPU_Resource *resource) { return (SamplerStateRid) { ((GPU_D12_Resource *)resource)->sampler_descriptor->index }; }
////////////////////////////////
//~ @hookdef Command list hooks

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

@ -61,8 +61,11 @@ Struct(GPU_D12_Descriptor)
GPU_D12_Descriptor *next_free;
struct GPU_D12_DescriptorHeap *heap;
b32 valid;
u32 index;
D3D12_CPU_DESCRIPTOR_HANDLE handle;
} extern Readonly GPU_D12_NilDescriptor = {
.index = U32Max
};
Struct(GPU_D12_DescriptorHeap)

4
src/meta/meta.c
View File

@ -952,8 +952,10 @@ JobDef(Build, _, __)
//- Dxc
{
PushStringToList(arena, &cp.flags_dxc, Lit("-O0"));
#if GPU_DEBUG
PushStringToList(arena, &cp.flags_dxc, Lit("-Od"));
PushStringToList(arena, &cp.flags_dxc, Lit("-Zi -Qembed_debug"));
#endif
// PushStringToList(arena, &cp.flags_dxc, Lit("-fno-caret-diagnostics"));
}
}

2
src/platform/platform_win32/platform_win32.c
View File

@ -1838,7 +1838,7 @@ String P_GetClipboardText(Arena *arena)
}
////////////////////////////////
//~ @hookdecl Timer hooks
//~ @hookdef Timer hooks
Fence *P_GetTimerFence()
{

44
src/pp/pp.c
View File

@ -1249,7 +1249,7 @@ void UpdateUser(P_Window *window)
MaterialInstance *mat = PushStruct(g->material_instances_arena, MaterialInstance);
*mat = DefaultMaterialInstance;
mat->xf = sprite_xform;
mat->tex_nurid = GPU_GetReadableId(texture->gpu_texture);
mat->tex = GPU_Texture2DRidFromResource(texture->gpu_texture);
mat->tint_srgb = tint;
mat->uv0 = frame.clip.p0;
mat->uv1 = frame.clip.p1;
@ -1284,7 +1284,7 @@ void UpdateUser(P_Window *window)
MaterialInstance *mat = PushStruct(g->material_instances_arena, MaterialInstance);
*mat = DefaultMaterialInstance;
mat->xf = tile_xf;
mat->tex_nurid = GPU_GetReadableId(tile_texture->gpu_texture);
mat->tex = GPU_Texture2DRidFromResource(tile_texture->gpu_texture);
mat->is_light = 1;
mat->light_emittance_srgb = VEC3(0, 0, 0);
}
@ -2311,10 +2311,10 @@ void UpdateUser(P_Window *window)
GPU_Scissor scissor = GPU_ScissorFromRect(render_viewport);
MaterialSig sig = ZI;
sig.tex_sampler_urid = GPU_GetSamplerId(g->pt_sampler);
sig.projection = world_to_render_vp_matrix;
sig.instances_urid = GPU_GetReadableId(material_instance_buffer);
sig.grids_urid = GPU_GetReadableId(grids_buffer);
sig.sampler = GPU_SamplerStateRidFromResource(g->pt_sampler);
sig.instances = GPU_StructuredBufferRidFromResource(material_instance_buffer);
sig.grids = GPU_StructuredBufferRidFromResource(grids_buffer);
GPU_Rasterize(cl,
&sig,
MaterialVS, MaterialPS,
@ -2353,9 +2353,9 @@ void UpdateUser(P_Window *window)
FloodSig sig = ZI;
sig.step_len = step_length;
sig.emittance_tex_urid = GPU_GetReadableId(g->emittance);
sig.read_flood_tex_urid = GPU_GetWritableId(g->emittance_flood_read);
sig.target_flood_tex_urid = GPU_GetWritableId(g->emittance_flood_target);
sig.emittance = GPU_Texture2DRidFromResource(g->emittance);
sig.read = GPU_RWTexture2DRidFromResource(g->emittance_flood_read);
sig.target = GPU_RWTexture2DRidFromResource(g->emittance_flood_target);
sig.tex_width = g->render_size.x;
sig.tex_height = g->render_size.y;
GPU_Compute(cl, &sig, FloodCS, (g->render_size.x + 7) / 8, (g->render_size.y + 7) / 8, 1);
@ -2411,12 +2411,12 @@ void UpdateUser(P_Window *window)
(u32)(RandU64FromState(&g->frame_rand) & 0xFFFFFFFF));
sig.frame_index = g->frame_index;
sig.camera_offset = g->world_to_render_xf.og;
sig.albedo_tex_urid = GPU_GetReadableId(g->albedo);
sig.emittance_tex_urid = GPU_GetReadableId(g->emittance);
sig.noise_tex_urid = GPU_GetReadableId(g->gpu_noise);
sig.emittance_flood_tex_urid = GPU_GetWritableId(g->emittance_flood_read);
sig.read_tex_urid = GPU_GetWritableId(g->shade_read);
sig.target_tex_urid = GPU_GetWritableId(g->shade_target);
sig.noise = GPU_Texture3DRidFromResource(g->gpu_noise);
sig.albedo = GPU_Texture2DRidFromResource(g->albedo);
sig.emittance = GPU_Texture2DRidFromResource(g->emittance);
sig.emittance_flood = GPU_Texture2DRidFromResource(g->emittance_flood_read);
sig.read = GPU_Texture2DRidFromResource(g->shade_read);
sig.target = GPU_RWTexture2DRidFromResource(g->shade_target);
sig.noise_tex_width = noise_size.x;
sig.noise_tex_height = noise_size.y;
sig.noise_tex_depth = noise_size.z;
@ -2446,12 +2446,12 @@ void UpdateUser(P_Window *window)
GPU_Scissor scissor = GPU_ScissorFromRect(ui_viewport);
UiBlitSig sig = ZI;
sig.tex_sampler_urid = GPU_GetSamplerId(g->pt_sampler);
sig.sampler = GPU_SamplerStateRidFromResource(g->pt_sampler);
sig.src = GPU_Texture2DRidFromResource(g->shade_read);
sig.projection = blit_vp_matrix;
sig.flags = UiBlitFlag_ToneMap | UiBlitFlag_GammaCorrect;
sig.exposure = 2.0;
sig.gamma = (f32)2.2;
sig.tex_urid = GPU_GetWritableId(g->shade_read);
GPU_Rasterize(cl,
&sig,
UiBlitVS, UiBlitPS,
@ -2471,10 +2471,10 @@ void UpdateUser(P_Window *window)
GPU_Viewport viewport = GPU_ViewportFromRect(ui_viewport);
GPU_Scissor scissor = GPU_ScissorFromRect(ui_viewport);
UiRectSig sig = ZI;
sig.projection = ui_vp_matrix;
sig.tex_sampler_urid = GPU_GetSamplerId(g->pt_sampler);
sig.instances_urid = GPU_GetReadableId(ui_rect_instance_buffer);
UiRectSig sig = ZI;
sig.projection = ui_vp_matrix;
sig.sampler = GPU_SamplerStateRidFromResource(g->pt_sampler);
sig.instances = GPU_StructuredBufferRidFromResource(ui_rect_instance_buffer);
GPU_Rasterize(cl,
&sig,
UiRectVS, UiRectPS,
@ -2496,7 +2496,7 @@ void UpdateUser(P_Window *window)
UiShapeSig sig = ZI;
sig.projection = ui_vp_matrix;
sig.verts_urid = GPU_GetReadableId(ui_shape_verts_buffer);
sig.verts = GPU_StructuredBufferRidFromResource(ui_shape_verts_buffer);
GPU_Rasterize(cl,
&sig,
UiShapeVS, UiShapePS,
@ -2564,11 +2564,13 @@ JobDef(UpdateUserOrSleep, UNUSED sig, UNUSED id)
__profn("Swapchain wait");
GPU_YieldOnSwapchain(g->swapchain);
}
#if FPS_LIMIT > 0
{
__profn("Frame limiter wait");
P_SleepFrame(time_ns, 1000000000 / FPS_LIMIT);
time_ns = TimeNs();
}
#endif
}
UpdateUser(window);
}

79
src/pp/pp_draw.gpu
View File

@ -11,7 +11,7 @@ ConstantBuffer<UiShapeSig> ui_shape_sig : register (b0);
Struct(MaterialPS_Input)
{
Semantic(Vec4, sv_position);
Semantic(nointerpolation u32, tex_nurid);
Semantic(nointerpolation Texture2DRid, tex);
Semantic(nointerpolation u32, grid_id);
Semantic(Vec2, uv);
Semantic(Vec4, tint_lin);
@ -26,7 +26,7 @@ Struct(MaterialPS_Output)
//- Vertex shader
MaterialPS_Input VSDef(MaterialVS, Semantic(u32, SV_InstanceID), Semantic(u32, SV_VertexID))
MaterialPS_Input VSDef(MaterialVS, Semantic(u32, sv_instanceid), Semantic(u32, sv_vertexid))
{
ConstantBuffer<MaterialSig> sig = mat_sig;
static const Vec2 unit_quad_verts[4] = {
@ -35,16 +35,16 @@ MaterialPS_Input VSDef(MaterialVS, Semantic(u32, SV_InstanceID), Semantic(u32, S
Vec2(0.5f, 0.5f),
Vec2(-0.5f, 0.5f)
};
StructuredBuffer<MaterialInstance> instances = GpuResourceFromUrid(sig.instances_urid);
Vec2 vert = unit_quad_verts[SV_VertexID];
MaterialInstance instance = instances[SV_InstanceID];
StructuredBuffer<MaterialInstance> instances = UniformResourceFromRid(sig.instances);
Vec2 vert = unit_quad_verts[sv_vertexid];
MaterialInstance instance = instances[sv_instanceid];
Vec2 world_pos = mul(instance.xf, Vec3(vert, 1)).xy;
MaterialPS_Input output;
output.sv_position = mul(sig.projection, Vec4(world_pos, 0, 1));
output.tex_nurid = instance.tex_nurid;
output.tex = instance.tex;
output.grid_id = instance.grid_id;
output.uv = instance.uv0 + ((vert + 0.5) * (instance.uv1 - instance.uv0));
output.tint_lin = LinearFromSrgbU32(instance.tint_srgb);
@ -62,17 +62,18 @@ MaterialPS_Output PSDef(MaterialPS, MaterialPS_Input input)
Vec4 albedo = input.tint_lin;
/* Texture */
if (input.tex_nurid < 0xFFFFFFFF)
if (input.tex < 0xFFFFFFFF)
{
SamplerState sampler = GpuSamplerFromUrid(sig.tex_sampler_urid);
Texture2D<Vec4> tex = GpuResourceFromNurid(input.tex_nurid);
SamplerState sampler = UniformSamplerFromRid(sig.sampler);
Texture2D<Vec4> tex = NonUniformResourceFromRid(input.tex);
albedo *= tex.Sample(sampler, input.uv);
}
/* Grid */
if (input.grid_id < 0xFFFFFFFF)
{
StructuredBuffer<MaterialGrid> grids = GpuResourceFromUrid(sig.grids_urid);
// StructuredBuffer<MaterialGrid> grids = UniformResourceFromRid(sig.grids);
StructuredBuffer<MaterialGrid> grids = ResourceDescriptorHeap[sig.grids];
MaterialGrid grid = grids[input.grid_id];
Vec2 grid_pos = input.sv_position.xy + grid.offset;
f32 half_thickness = grid.line_thickness / 2;
@ -127,17 +128,17 @@ MaterialPS_Output PSDef(MaterialPS, MaterialPS_Input input)
//- Compute shader
[numthreads(8, 8, 1)]
void CSDef(FloodCS, Semantic(Vec3U32, SV_DispatchThreadID))
void CSDef(FloodCS, Semantic(Vec3U32, sv_dispatchthreadid))
{
ConstantBuffer<FloodSig> sig = flood_sig;
Vec2U32 id = SV_DispatchThreadID.xy;
Vec2U32 id = sv_dispatchthreadid.xy;
Vec2U32 tex_size = Vec2U32(sig.tex_width, sig.tex_height);
if (id.x < tex_size.x && id.y < tex_size.y)
{
Texture2D<Vec4> emittance_tex = GpuResourceFromUrid(sig.emittance_tex_urid);
RWTexture2D<Vec2U32> read_flood_tex = GpuResourceFromUrid(sig.read_flood_tex_urid);
RWTexture2D<Vec2U32> target_flood_tex = GpuResourceFromUrid(sig.target_flood_tex_urid);
Texture2D<Vec4> emittance_tex = UniformResourceFromRid(sig.emittance);
RWTexture2D<Vec2U32> read_flood_tex = UniformResourceFromRid(sig.read);
RWTexture2D<Vec2U32> target_flood_tex = UniformResourceFromRid(sig.target);
i32 step_len = sig.step_len;
if (step_len == -1)
{
@ -196,7 +197,7 @@ void CSDef(FloodCS, Semantic(Vec3U32, SV_DispatchThreadID))
f32 RandAngle(Vec2U32 pos, u32 ray_index)
{
ConstantBuffer<ShadeSig> sig = shade_sig;
Texture3D<u32> noise_tex = GpuResourceFromUrid(sig.noise_tex_urid);
Texture3D<u32> noise_tex = UniformResourceFromRid(sig.noise);
Vec3I32 noise_coord = Vec3U32(1, 1, 1);
noise_coord += Vec3I32(pos.xy, ray_index);
@ -210,8 +211,8 @@ f32 RandAngle(Vec2U32 pos, u32 ray_index)
Vec3 ColorFromDir(Vec2U32 ray_start, Vec2 ray_dir)
{
ConstantBuffer<ShadeSig> sig = shade_sig;
Texture2D<Vec2U32> flood_tex = GpuResourceFromUrid(sig.emittance_flood_tex_urid);
Texture2D<Vec4> emittance_tex = GpuResourceFromUrid(sig.emittance_tex_urid);
Texture2D<Vec2U32> flood_tex = UniformResourceFromRid(sig.emittance_flood);
Texture2D<Vec4> emittance_tex = UniformResourceFromRid(sig.emittance);
Vec3 result = Vec3(0, 0, 0);
Vec2 at_f32 = ray_start;
@ -261,16 +262,16 @@ Vec3 ColorFromPos(Vec2U32 pos)
//- Compute shader
[numthreads(8, 8, 1)]
void CSDef(ShadeCS, Semantic(Vec3U32, SV_DispatchThreadID))
void CSDef(ShadeCS, Semantic(Vec3U32, sv_dispatchthreadid))
{
ConstantBuffer<ShadeSig> sig = shade_sig;
Vec2U32 id = SV_DispatchThreadID.xy;
Vec2U32 id = sv_dispatchthreadid.xy;
if (id.x < sig.tex_width && id.y < sig.tex_height)
{
Texture2D<Vec4> albedo_tex = GpuResourceFromUrid(sig.albedo_tex_urid);
Texture2D<Vec4> read_tex = GpuResourceFromUrid(sig.read_tex_urid);
RWTexture2D<Vec4> target_tex = GpuResourceFromUrid(sig.target_tex_urid);
Texture2D<Vec4> albedo_tex = UniformResourceFromRid(sig.albedo);
Texture2D<Vec4> read_tex = UniformResourceFromRid(sig.read);
RWTexture2D<Vec4> target_tex = UniformResourceFromRid(sig.target);
Vec4 color = Vec4(1, 1, 1, 1);
/* Apply albedo */
@ -318,7 +319,7 @@ Vec3 ToneMap(Vec3 v)
//- Vertex shader
UiBlitPS_Input VSDef(UiBlitVS, Semantic(u32, SV_VertexID))
UiBlitPS_Input VSDef(UiBlitVS, Semantic(u32, sv_vertexid))
{
ConstantBuffer<UiBlitSig> sig = ui_blit_sig;
static const Vec2 unit_quad_verts[4] = {
@ -327,7 +328,7 @@ UiBlitPS_Input VSDef(UiBlitVS, Semantic(u32, SV_VertexID))
Vec2(0.5f, 0.5f),
Vec2(-0.5f, 0.5f)
};
Vec2 vert = unit_quad_verts[SV_VertexID];
Vec2 vert = unit_quad_verts[sv_vertexid];
UiBlitPS_Input output;
output.sv_position = mul(sig.projection, Vec4(vert, 0, 1));
@ -340,10 +341,10 @@ UiBlitPS_Input VSDef(UiBlitVS, Semantic(u32, SV_VertexID))
UiBlitPS_Output PSDef(UiBlitPS, UiBlitPS_Input input)
{
ConstantBuffer<UiBlitSig> sig = ui_blit_sig;
SamplerState sampler = GpuSamplerFromUrid(sig.tex_sampler_urid);
SamplerState sampler = UniformSamplerFromRid(sig.sampler);
UiBlitPS_Output output;
Texture2D<Vec4> tex = GpuResourceFromUrid(sig.tex_urid);
Texture2D<Vec4> tex = UniformResourceFromRid(sig.src);
Vec4 color = tex.Sample(sampler, input.uv);
/* Apply tone map */
@ -370,7 +371,7 @@ UiBlitPS_Output PSDef(UiBlitPS, UiBlitPS_Input input)
Struct(UiRectPS_Input)
{
Semantic(Vec4, sv_position);
Semantic(nointerpolation u32, tex_nurid);
Semantic(nointerpolation Texture2DRid, tex);
Semantic(Vec2, uv);
Semantic(Vec4, tint_srgb);
};
@ -382,7 +383,7 @@ Struct(UiRectPS_Output)
//- Vertex shader
UiRectPS_Input VSDef(UiRectVS, Semantic(u32, SV_InstanceID), Semantic(u32, SV_VertexID))
UiRectPS_Input VSDef(UiRectVS, Semantic(u32, sv_instanceid), Semantic(u32, sv_vertexid))
{
ConstantBuffer<UiRectSig> sig = ui_rect_sig;
static const Vec2 unit_quad_verts[4] = {
@ -392,14 +393,14 @@ UiRectPS_Input VSDef(UiRectVS, Semantic(u32, SV_InstanceID), Semantic(u32, SV_Ve
Vec2(-0.5f, 0.5f)
};
StructuredBuffer<UiRectInstance> instances = GpuResourceFromUrid(sig.instances_urid);
UiRectInstance instance = instances[SV_InstanceID];
Vec2 vert = unit_quad_verts[SV_VertexID];
StructuredBuffer<UiRectInstance> instances = UniformResourceFromRid(sig.instances);
UiRectInstance instance = instances[sv_instanceid];
Vec2 vert = unit_quad_verts[sv_vertexid];
Vec2 world_pos = mul(instance.xf, Vec3(vert, 1)).xy;
UiRectPS_Input output;
output.sv_position = mul(sig.projection, Vec4(world_pos, 0, 1));
output.tex_nurid = instance.tex_nurid;
output.tex = instance.tex;
output.uv = instance.uv0 + ((vert + 0.5) * (instance.uv1 - instance.uv0));
output.tint_srgb = Vec4NormFromU32(instance.tint_srgb);
return output;
@ -414,10 +415,10 @@ UiRectPS_Output PSDef(UiRectPS, UiRectPS_Input input)
Vec4 color = input.tint_srgb;
/* Texture */
if (input.tex_nurid < 0xFFFFFFFF)
if (input.tex < 0xFFFFFFFF)
{
Texture2D<Vec4> tex = GpuResourceFromNurid(input.tex_nurid);
SamplerState sampler = GpuSamplerFromUrid(sig.tex_sampler_urid);
Texture2D<Vec4> tex = NonUniformResourceFromRid(input.tex);
SamplerState sampler = UniformSamplerFromRid(sig.sampler);
color *= tex.Sample(sampler, input.uv);
}
@ -441,11 +442,11 @@ Struct(UiShapePS_Output)
//- Vertex shader
UiShapePS_Input VSDef(UiShapeVS, Semantic(u32, SV_VertexID))
UiShapePS_Input VSDef(UiShapeVS, Semantic(u32, sv_vertexid))
{
ConstantBuffer<UiShapeSig> sig = ui_shape_sig;
StructuredBuffer<UiShapeVert> verts = GpuResourceFromUrid(sig.verts_urid);
UiShapeVert vert = verts[SV_VertexID];
StructuredBuffer<UiShapeVert> verts = UniformResourceFromRid(sig.verts);
UiShapeVert vert = verts[sv_vertexid];
UiShapePS_Input output;
output.sv_position = mul(sig.projection, Vec4(vert.pos.xy, 0, 1));
output.color_srgb = Vec4NormFromU32(vert.color_srgb);

40
src/pp/pp_draw.h
View File

@ -6,9 +6,9 @@ Struct(MaterialSig)
/* ----------------------------------------------------- */
Mat4x4 projection; /* 16 consts */
/* ----------------------------------------------------- */
u32 tex_sampler_urid; /* 01 consts */
u32 instances_urid; /* 01 consts */
u32 grids_urid; /* 01 consts */
SamplerStateRid sampler; /* 01 consts */
StructuredBufferRid instances; /* 01 consts */
StructuredBufferRid grids; /* 01 consts */
u32 _pad0; /* 01 consts (padding) */
/* ----------------------------------------------------- */
};
@ -16,7 +16,7 @@ AssertRootConst(MaterialSig, 20);
Struct(MaterialInstance)
{
u32 tex_nurid;
Texture2DRid tex;
u32 grid_id;
Xform xf;
Vec2 uv0;
@ -26,7 +26,7 @@ Struct(MaterialInstance)
Vec3 light_emittance_srgb;
};
#define DefaultMaterialInstance (MaterialInstance) { \
.tex_nurid = U32Max, \
.tex = { U32Max }, \
.grid_id = U32Max, \
.xf = XformIdentity, \
.uv1 = VEC2(1, 1), \
@ -58,9 +58,9 @@ Struct(FloodSig)
{
/* ----------------------------------------------------- */
i32 step_len; /* 01 consts */
u32 emittance_tex_urid; /* 01 consts */
u32 read_flood_tex_urid; /* 01 consts */
u32 target_flood_tex_urid; /* 01 consts */
Texture2DRid emittance; /* 01 consts */
RWTexture2DRid read; /* 01 consts */
RWTexture2DRid target; /* 01 consts */
/* ----------------------------------------------------- */
u32 tex_width; /* 01 consts */
u32 tex_height; /* 01 consts */
@ -88,14 +88,14 @@ Struct(ShadeSig)
/* ----------------------------------------------------- */
Vec2 camera_offset; /* 02 consts */
u32 frame_index; /* 01 consts */
u32 albedo_tex_urid; /* 01 consts */
Texture2DRid albedo; /* 01 consts */
/* ----------------------------------------------------- */
u32 emittance_tex_urid; /* 01 consts */
u32 emittance_flood_tex_urid; /* 01 consts */
u32 read_tex_urid; /* 01 consts */
u32 target_tex_urid; /* 01 consts */
Texture2DRid emittance; /* 01 consts */
Texture2DRid emittance_flood; /* 01 consts */
Texture2DRid read; /* 01 consts */
RWTexture2DRid target; /* 01 consts */
/* ----------------------------------------------------- */
u32 noise_tex_urid; /* 01 consts */
Texture3DRid noise; /* 01 consts */
u32 noise_tex_width; /* 01 consts */
u32 noise_tex_height; /* 01 consts */
u32 noise_tex_depth; /* 01 consts */
@ -116,11 +116,11 @@ Struct(UiBlitSig)
Mat4x4 projection; /* 16 consts */
/* ----------------------------------------------------- */
u32 flags; /* 01 consts */
u32 tex_urid; /* 01 consts */
Texture2DRid src; /* 01 consts */
f32 exposure; /* 01 consts */
f32 gamma; /* 01 consts */
/* ----------------------------------------------------- */
u32 tex_sampler_urid; /* 01 consts */
SamplerStateRid sampler; /* 01 consts */
u32 _pad0; /* 01 consts (padding) */
u32 _pad1; /* 01 consts (padding) */
u32 _pad2; /* 01 consts (padding) */
@ -137,8 +137,8 @@ Struct(UiRectSig)
/* ----------------------------------------------------- */
Mat4x4 projection; /* 16 consts */
/* ----------------------------------------------------- */
u32 instances_urid; /* 01 consts */
u32 tex_sampler_urid; /* 01 consts */
StructuredBufferRid instances; /* 01 consts */
SamplerStateRid sampler; /* 01 consts */
u32 _pad0; /* 01 consts (padding) */
u32 _pad1; /* 01 consts (padding) */
/* ----------------------------------------------------- */
@ -147,7 +147,7 @@ AssertRootConst(UiRectSig, 20);
Struct(UiRectInstance)
{
u32 tex_nurid;
Texture2DRid tex;
Xform xf;
Vec2 uv0;
Vec2 uv1;
@ -162,7 +162,7 @@ Struct(UiShapeSig)
/* ----------------------------------------------------- */
Mat4x4 projection; /* 16 consts */
/* ----------------------------------------------------- */
u32 verts_urid; /* 01 consts */
StructuredBufferRid verts; /* 01 consts */
u32 _pad0; /* 01 consts (padding) */
u32 _pad1; /* 01 consts (padding) */
u32 _pad2; /* 01 consts (padding) */