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

backdrop shader

Browse Source
This commit is contained in:
jacob 2025-11-14 18:36:17 -06:00
parent b50aa36e4e
commit 4b0a12bc20
11 changed files with 139 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/base/base.h
View File

@ -767,10 +767,6 @@ Struct(VertexShader) { ResourceKey resource; };
Struct(PixelShader) { ResourceKey resource; };
Struct(ComputeShader) { ResourceKey resource; };
# define VSDecl(name) extern VertexShader name;
# define PSDecl(name) extern PixelShader name;
# define CSDecl(name) extern ComputeShader name;
//- Resource descriptor index types
Struct(StructuredBufferRid) { u32 v; };
Struct(RWStructuredBufferRid) { u32 v; };
@ -796,13 +792,9 @@ typedef uint RWTexture3DRid;
typedef uint SamplerStateRid;
//- Shader declaration
# define VSDecl(name)
# define PSDecl(name)
# define CSDecl(name)
# define VSDef(name, ...) name(__VA_ARGS__)
# define PSDef(name, ...) name(__VA_ARGS__)
# define CSDef(name, ...) name(__VA_ARGS__)
# define ComputeShader(name, x, y, z) [numthreads(x, y, z)] void name(Semantic(Vec3U32, SV_DispatchThreadID))
# define VertexShader(name, return_type) return_type name(Semantic(u32, SV_VertexID), Semantic(u32, SV_InstanceID))
# define PixelShader(name, return_type, ...) return_type name(__VA_ARGS__)
//- Semantic declaration
# define Semantic(t, n) t n : n

4
src/base/base_math_gpu.h
View File

@ -55,10 +55,10 @@ Vec2 RectUvFromVertexId(u32 id)
////////////////////////////////////////////////////////////
//~ Ndc helpers
Vec2 NdcFromViewport(Vec2 viewport_size, Vec2 viewport_coords)
Vec2 NdcFromPos(Vec2 pos, Vec2 size)
{
Vec2 result;
result = viewport_coords / viewport_size;
result = pos / size;
result *= Vec2(2, -2);
result += Vec2(-1, 1);
return result;

7
src/gpu/gpu_core.h
View File

@ -257,6 +257,7 @@ Enum(GPU_ResourceFlag)
GPU_ResourceFlag_Writable = (1 << 0),
GPU_ResourceFlag_Renderable = (1 << 1),
GPU_ResourceFlag_MaxMipLevels = (1 << 2),
GPU_ResourceFlag_Zeroed = (1 << 3),
};
Enum(GPU_HeapKind)
@ -439,7 +440,7 @@ void GPU_ClearRenderable(GPU_CommandList *cl, GPU_Resource *resource);
#define GPU_Rasterize(cl, sig_ptr, vs, ps, rts_count, viewport, scissor, instances_count, index_buffer, mode) \
GPU_Rasterize_((cl), sizeof(*(sig_ptr)), (sig_ptr), (vs), (ps), (rts_count), (viewport), (scissor), (instances_count), (index_buffer), (mode))
#define GPU_Compute(cl, sig_ptr, cs, x, y, z) GPU_Compute_((cl), sizeof(*(sig_ptr)), (sig_ptr), (cs), (x), (y), (z))
#define GPU_Compute(cl, sig_ptr, cs, threads) GPU_Compute_((cl), sizeof(*(sig_ptr)), (sig_ptr), (cs), (threads))
void GPU_Rasterize_(GPU_CommandList *cl,
u32 sig_size,
@ -457,9 +458,7 @@ void GPU_Compute_(GPU_CommandList *cl,
u32 sig_size,
void *sig,
ComputeShader cs,
u32 num_threads_x,
u32 num_threads_y,
u32 num_threads_z);
Vec3U32 threads);
////////////////////////////////////////////////////////////
//~ @hookdecl Resource copy operations

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

@ -879,7 +879,12 @@ GPU_Resource *GPU_AcquireResource(GPU_ResourceDesc desc)
/* Buffer */
case GPU_ResourceKind_Buffer:
{
D3D12_HEAP_FLAGS heap_flags = D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;
D3D12_HEAP_FLAGS heap_flags = 0;
if (!(desc.flags & GPU_ResourceFlag_Zeroed))
{
heap_flags |= D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;
}
D3D12_HEAP_PROPERTIES heap_props = {
.Type = desc.buffer.heap_kind == GPU_HeapKind_Upload ? D3D12_HEAP_TYPE_UPLOAD
: desc.buffer.heap_kind == GPU_HeapKind_Download ? D3D12_HEAP_TYPE_READBACK
@ -914,7 +919,12 @@ GPU_Resource *GPU_AcquireResource(GPU_ResourceDesc desc)
case GPU_ResourceKind_Texture2D:
case GPU_ResourceKind_Texture3D:
{
D3D12_HEAP_FLAGS heap_flags = D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;
D3D12_HEAP_FLAGS heap_flags = 0;
if (!(desc.flags & GPU_ResourceFlag_Zeroed))
{
heap_flags |= D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;
}
D3D12_HEAP_PROPERTIES heap_props = { .Type = D3D12_HEAP_TYPE_DEFAULT };
D3D12_RESOURCE_DESC d3d_desc = ZI;
d3d_desc.Dimension = desc.kind == GPU_ResourceKind_Texture1D ? D3D12_RESOURCE_DIMENSION_TEXTURE1D
@ -1762,9 +1772,7 @@ void GPU_Compute_(GPU_CommandList *gpu_cl,
u32 sig_size,
void *sig,
ComputeShader cs,
u32 num_threads_x,
u32 num_threads_y,
u32 num_threads_z)
Vec3U32 threads_count)
{
GPU_D12_CommandList *cl = (GPU_D12_CommandList *)gpu_cl;
GPU_D12_Command *cmd = GPU_D12_PushCmd(cl);
@ -1773,9 +1781,9 @@ void GPU_Compute_(GPU_CommandList *gpu_cl,
cmd->compute.sig_size = MinU32(sizeof(cmd->compute.sig), sig_size);
CopyBytes(cmd->compute.sig, sig, cmd->compute.sig_size);
cmd->compute.cs = cs;
cmd->compute.num_threads_x = num_threads_x;
cmd->compute.num_threads_y = num_threads_y;
cmd->compute.num_threads_z = num_threads_z;
cmd->compute.num_threads_x = threads_count.x;
cmd->compute.num_threads_y = threads_count.y;
cmd->compute.num_threads_z = threads_count.z;
}
////////////////////////////////////////////////////////////

1
src/proto/pp_vis/pp_vis.lay
View File

@ -26,6 +26,7 @@
@EmbedDir V_Resources pp_vis_res
//- Shaders
@ComputeShader V_BackdropCS
@VertexShader V_DQuadVS
@PixelShader V_DQuadPS
@VertexShader V_DVertVS

19
src/proto/pp_vis/pp_vis_core.c
View File

@ -544,7 +544,7 @@ JobDef(V_VisWorker, _, __)
{
GPU_ResourceDesc desc = ZI;
desc.kind = GPU_ResourceKind_Texture2D;
desc.flags = GPU_ResourceFlag_Writable | GPU_ResourceFlag_Renderable;
desc.flags = GPU_ResourceFlag_Writable | GPU_ResourceFlag_Renderable | GPU_ResourceFlag_Zeroed;
desc.texture.format = GPU_Format_R16G16B16A16_Float;
desc.texture.size = VEC3I32(draw_size.x, draw_size.y, 1);
desc.clear_color = LinearFromSrgb(swapchain_color);
@ -563,21 +563,28 @@ JobDef(V_VisWorker, _, __)
GPU_CommandList *cl = GPU_BeginCommandList(GPU_QueueKind_Direct);
{
/* Prep draw target */
/* Prep background pass */
{
GPU_TransitionToRenderable(cl, draw_target, 0);
GPU_ClearRenderable(cl, draw_target);
GPU_TransitionToWritable(cl, draw_target);
}
/* Backdrop pass */
{
V_BackdropSig sig = ZI;
sig.target_tex = GPU_RWTexture2DRidFromResource(draw_target);
sig.target_size = draw_size;
GPU_Compute(cl, &sig, V_BackdropCS, V_BackdropCSThreadSizeFromTexSize(draw_size));
}
/* Prep shapes pass */
{
GPU_TransitionToRenderable(cl, draw_target, 0);
}
/* Shapes pass */
{
V_DVertSig sig = ZI;
sig.viewport_size = draw_size;
sig.target_size = draw_size;
sig.sampler = GPU_SamplerStateRidFromResource(GPU_GetCommonPointSampler());
sig.verts = GPU_StructuredBufferRidFromResource(dverts_buffer);
GPU_Rasterize(cl,

81
src/proto/pp_vis/pp_vis_gpu.gpu
View File

@ -1,42 +1,62 @@
ConstantBuffer<V_BackdropSig> V_backdrop_sig : register (b0);
ConstantBuffer<V_DQuadSig> V_dquad_sig : register (b0);
ConstantBuffer<V_DVertSig> V_dvert_sig : register (b0);
////////////////////////////////////////////////////////////
//~ Quad
//~ Backdrop shader
Struct(V_DQuadPS_Input)
ComputeShader(V_BackdropCS, 8, 8, 1)
{
ConstantBuffer<V_BackdropSig> sig = V_backdrop_sig;
Vec2U32 target_pos = SV_DispatchThreadID.xy;
Vec2I32 target_size = sig.target_size;
if (target_pos.x < target_size.x && target_pos.y < target_size.y)
{
RWTexture2D<Vec4> target_tex = UniformResourceFromRid(sig.target_tex);
Vec4 result = Color_Blue;
target_tex[target_pos] = result;
}
}
////////////////////////////////////////////////////////////
//~ Quad shader
Struct(V_DQuadPSInput)
{
Semantic(Vec4, sv_position);
Semantic(Vec4, SV_Position);
Semantic(nointerpolation u32, quad_idx);
};
Struct(V_DQuadPS_Output)
Struct(V_DQuadPSOutput)
{
Semantic(Vec4, sv_target0);
Semantic(Vec4, SV_Target0);
};
//////////////////////////////
//- Vertex shader
V_DQuadPS_Input VSDef(V_DQuadVS, Semantic(u32, sv_instanceid), Semantic(u32, sv_vertexid))
VertexShader(V_DQuadVS, V_DQuadPSInput)
{
ConstantBuffer<V_DQuadSig> sig = V_dquad_sig;
StructuredBuffer<V_DQuad> quads = UniformResourceFromRid(sig.quads);
V_DQuad quad = quads[sv_instanceid];
V_DQuad quad = quads[SV_InstanceID];
Vec2 rect_uv = RectUvFromVertexId(sv_vertexid);
Vec2 rect_uv = RectUvFromVertexId(SV_VertexID);
// Vec2 tex_uv = lerp(quad.tex_uv0, quad.tex_uv1, rect_uv);
// Vec2 screen_vert = lerp(quad.p0, quad.p1, rect_uv);
Vec2 screen_vert = 0;
// Vec2 target_pos = lerp(quad.p0, quad.p1, rect_uv);
Vec2 target_pos = 0;
V_DQuadPS_Input result;
result.sv_position = Vec4(NdcFromViewport(sig.viewport_size, screen_vert).xy, 0, 1);
result.quad_idx = sv_instanceid;
V_DQuadPSInput result;
result.SV_Position = Vec4(NdcFromPos(target_pos, sig.target_size).xy, 0, 1);
result.quad_idx = SV_InstanceID;
return result;
}
//////////////////////////////
//- Pixel shader
V_DQuadPS_Output PSDef(V_DQuadPS, V_DQuadPS_Input input)
PixelShader(V_DQuadPS, V_DQuadPSOutput, V_DQuadPSInput input)
{
ConstantBuffer<V_DQuadSig> sig = V_dquad_sig;
StructuredBuffer<V_DQuad> quads = UniformResourceFromRid(sig.quads);
@ -44,46 +64,49 @@ V_DQuadPS_Output PSDef(V_DQuadPS, V_DQuadPS_Input input)
Vec4 final_color = 0;
V_DQuadPS_Output output;
output.sv_target0 = final_color;
V_DQuadPSOutput output;
output.SV_Target0 = final_color;
return output;
}
////////////////////////////////////////////////////////////
//~ Shape
//~ Shape shader
Struct(V_DVertPS_Input)
Struct(V_DVertPSInput)
{
Semantic(Vec4, sv_position);
Semantic(Vec4, SV_Position);
Semantic(Vec4, color_lin);
};
Struct(V_DVertPS_Output)
Struct(V_DVertPSOutput)
{
Semantic(Vec4, sv_target0);
Semantic(Vec4, SV_Target0);
};
//////////////////////////////
//- Vertex shader
V_DVertPS_Input VSDef(V_DVertVS, Semantic(u32, sv_vertexid))
VertexShader(V_DVertVS, V_DVertPSInput)
{
ConstantBuffer<V_DVertSig> sig = V_dvert_sig;
StructuredBuffer<V_DVert> verts = UniformResourceFromRid(sig.verts);
V_DVert vert = verts[sv_vertexid];
V_DVert vert = verts[SV_VertexID];
Vec2 screen_vert = vert.pos;
Vec2 target_pos = vert.pos;
V_DVertPS_Input result;
result.sv_position = Vec4(NdcFromViewport(sig.viewport_size, screen_vert).xy, 0, 1);
V_DVertPSInput result;
result.SV_Position = Vec4(NdcFromPos(target_pos, sig.target_size).xy, 0, 1);
result.color_lin = vert.color_lin;
return result;
}
//////////////////////////////
//- Pixel shader
V_DVertPS_Output PSDef(V_DVertPS, V_DVertPS_Input input)
PixelShader(V_DVertPS, V_DVertPSOutput, V_DVertPSInput input)
{
V_DVertPS_Output output;
output.sv_target0 = input.color_lin;
V_DVertPSOutput output;
output.SV_Target0 = input.color_lin;
return output;
}

28
src/proto/pp_vis/pp_vis_gpu.h
View File

@ -1,10 +1,30 @@
////////////////////////////////////////////////////////////
//~ Quad types
//~ Backdrop shader types
Struct(V_BackdropSig)
{
/* ----------------------------------------------------- */
Vec2I32 target_size; /* 02 consts */
RWTexture2DRid target_tex; /* 01 consts */
SamplerStateRid sampler; /* 01 consts */
/* ----------------------------------------------------- */
u32 _pad0; /* 01 consts (padding) */
u32 _pad1; /* 01 consts (padding) */
u32 _pad2; /* 01 consts (padding) */
u32 _pad3; /* 01 consts (padding) */
/* ----------------------------------------------------- */
};
AssertRootConst(V_BackdropSig, 8);
#define V_BackdropCSThreadSizeFromTexSize(tex_size) VEC3U32((tex_size.x + 7) / 8, (tex_size.y + 7) / 8, 1)
////////////////////////////////////////////////////////////
//~ Quad shader types
Struct(V_DQuadSig)
{
/* ----------------------------------------------------- */
Vec2I32 viewport_size; /* 02 consts */
Vec2I32 target_size; /* 02 consts */
StructuredBufferRid quads; /* 01 consts */
SamplerStateRid sampler; /* 01 consts */
/* ----------------------------------------------------- */
@ -28,12 +48,12 @@ Struct(V_DQuad)
};
////////////////////////////////////////////////////////////
//~ Shape types
//~ Shape shader types
Struct(V_DVertSig)
{
/* ----------------------------------------------------- */
Vec2I32 viewport_size; /* 02 consts */
Vec2I32 target_size; /* 02 consts */
StructuredBufferRid verts; /* 01 consts */
SamplerStateRid sampler; /* 01 consts */
/* ----------------------------------------------------- */

4
src/ui/ui_core.c
View File

@ -1455,7 +1455,7 @@ i64 UI_EndFrame(UI_Frame frame)
/* Render rects */
{
UI_DRectSig sig = ZI;
sig.viewport_size = draw_size;
sig.target_size = draw_size;
sig.sampler = GPU_SamplerStateRidFromResource(GPU_GetCommonPointSampler());
sig.rects = GPU_StructuredBufferRidFromResource(draw_rects_buffer);
GPU_Rasterize(cl,
@ -1473,7 +1473,7 @@ i64 UI_EndFrame(UI_Frame frame)
if (AnyBit(g->bframe.frame_flags, UI_FrameFlag_Debug))
{
UI_DRectSig sig = ZI;
sig.viewport_size = draw_size;
sig.target_size = draw_size;
sig.sampler = GPU_SamplerStateRidFromResource(GPU_GetCommonPointSampler());
sig.rects = GPU_StructuredBufferRidFromResource(draw_rects_buffer);
sig.debug_enabled = 1;

27
src/ui/ui_gpu.gpu
View File

@ -1,9 +1,9 @@
ConstantBuffer<UI_DRectSig> UI_drect_sig : register (b0);
////////////////////////////////////////////////////////////
//~ Rect
//~ Rect shader
Struct(UI_DRectPS_Input)
Struct(UI_DRectPSInput)
{
Semantic(Vec4, sv_position);
@ -15,37 +15,40 @@ Struct(UI_DRectPS_Input)
Semantic(Vec2, tex_uv);
};
Struct(UI_DRectPS_Output)
Struct(UI_DRectPSOutput)
{
Semantic(Vec4, sv_target0);
};
//////////////////////////////
//- Vertex shader
UI_DRectPS_Input VSDef(UI_DRectVS, Semantic(u32, sv_instanceid), Semantic(u32, sv_vertexid))
VertexShader(UI_DRectVS, UI_DRectPSInput)
{
ConstantBuffer<UI_DRectSig> sig = UI_drect_sig;
StructuredBuffer<UI_DRect> rects = UniformResourceFromRid(sig.rects);
UI_DRect rect = rects[sv_instanceid];
UI_DRect rect = rects[SV_InstanceID];
Vec2 rect_uv = RectUvFromVertexId(sv_vertexid);
Vec2 rect_uv = RectUvFromVertexId(SV_VertexID);
Vec2 tex_uv = lerp(rect.tex_uv0, rect.tex_uv1, rect_uv);
Vec2 screen_vert = lerp(rect.p0, rect.p1, rect_uv);
Vec2 target_pos = lerp(rect.p0, rect.p1, rect_uv);
UI_DRectPS_Input result;
result.sv_position = Vec4(NdcFromViewport(sig.viewport_size, screen_vert).xy, 0, 1);
UI_DRectPSInput result;
result.sv_position = Vec4(NdcFromPos(target_pos, sig.target_size).xy, 0, 1);
result.background_lin = rect.background_lin;
result.border_lin = rect.border_lin;
result.tint_lin = rect.tint_lin;
result.rect_idx = sv_instanceid;
result.rect_idx = SV_InstanceID;
result.rect_uv = rect_uv;
result.tex_uv = tex_uv;
return result;
}
//////////////////////////////
//- Pixel shader
UI_DRectPS_Output PSDef(UI_DRectPS, UI_DRectPS_Input input)
PixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input)
{
ConstantBuffer<UI_DRectSig> sig = UI_drect_sig;
StructuredBuffer<UI_DRect> rects = UniformResourceFromRid(sig.rects);
@ -128,7 +131,7 @@ UI_DRectPS_Output PSDef(UI_DRectPS, UI_DRectPS_Input input)
final_color = rect.debug_lin;
}
UI_DRectPS_Output output;
UI_DRectPSOutput output;
output.sv_target0 = final_color;
return output;
}

4
src/ui/ui_gpu.h
View File

@ -1,10 +1,10 @@
////////////////////////////////////////////////////////////
//~ Rect types
//~ Rect shader types
Struct(UI_DRectSig)
{
/* ----------------------------------------------------- */
Vec2I32 viewport_size; /* 02 consts */
Vec2I32 target_size; /* 02 consts */
StructuredBufferRid rects; /* 01 consts */
SamplerStateRid sampler; /* 01 consts */
/* ----------------------------------------------------- */