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

specify compute shader group size in layer files

Browse Source
This commit is contained in:
jacob 2026-03-03 17:18:31 -06:00
parent af64a488c9
commit 35eb4e4839
15 changed files with 184 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
src/base/base.cgh
View File

@ -695,7 +695,6 @@ Inline b32 MatchU128(u128 a, u128 b) { return a.lo == b.lo && a.hi == b.hi; }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Resource types //~ Resource types
#if IsCpu
#define ResourceEmbeddedMagic 0xfc060937194f4406 #define ResourceEmbeddedMagic 0xfc060937194f4406
Struct(ResourceStore) Struct(ResourceStore)
@ -707,12 +706,10 @@ Inline b32 MatchU128(u128 a, u128 b) { return a.lo == b.lo && a.hi == b.hi; }
{ {
u64 v; u64 v;
}; };
#endif
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Cpu topology types //~ Cpu topology types
#if IsCpu
Struct(CpuTopologyInfo) Struct(CpuTopologyInfo)
{ {
i32 num_logical_cores; // Includes P cores, Non-P cores, SMT siblings i32 num_logical_cores; // Includes P cores, Non-P cores, SMT siblings
@ -720,7 +717,6 @@ Inline b32 MatchU128(u128 a, u128 b) { return a.lo == b.lo && a.hi == b.hi; }
i32 num_physical_performance_cores; // Includes P Cores i32 num_physical_performance_cores; // Includes P Cores
i32 num_physical_non_performance_cores; // Includes Non-P cores i32 num_physical_non_performance_cores; // Includes Non-P cores
}; };
#endif
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Debug types //~ Debug types
@ -736,22 +732,34 @@ Inline b32 MatchU128(u128 a, u128 b) { return a.lo == b.lo && a.hi == b.hi; }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Shader linkage types //~ Shader linkage types
#if IsCpu Struct(VertexShaderDesc) { ResourceKey resource; u32 x, y, z; };
Struct(VertexShader) { ResourceKey resource; }; Struct(PixelShaderDesc) { ResourceKey resource; u32 x, y, z; };
Struct(PixelShader) { ResourceKey resource; }; Struct(ComputeShaderDesc) { ResourceKey resource; u32 x, y, z; };
Struct(ComputeShader) { ResourceKey resource; };
#elif IsGpu #define GetGroupSize(name) VEC3U32(name##__GroupSize_X, name##__GroupSize_Y, name##__GroupSize_Z)
#if IsGpu
#define Semantic(name) name : name #define Semantic(name) name : name
#define DeclComputeShader(name, x) [numthreads(x, 1, 1)] ImplComputeShader(name) #define VertexShader(name, return_type) return_type name(u32 Semantic(SV_InstanceID), u32 Semantic(SV_VertexID))
#define DeclComputeShader2D(name, x, y) [numthreads(x, y, 1)] ImplComputeShader2D(name) #define PixelShader(name, return_type, ...) return_type name(__VA_ARGS__)
#define DeclComputeShader3D(name, x, y, z) [numthreads(x, y, z)] ImplComputeShader3D(name) #define ComputeShader(name) \
#define DeclVertexShader(name, return_type) ImplVertexShader(name, return_type) [numthreads(name##__GroupSize_X, name##__GroupSize_Y, name##__GroupSize_Z)] \
#define DeclPixelShader(name, return_type, ...) ImplPixelShader(name, return_type, __VA_ARGS__) void name( \
#define ImplComputeShader(name) void name(u32 Semantic(SV_DispatchThreadID), u32 Semantic(SV_GroupThreadID), u32 Semantic(SV_GroupIndex), u32 Semantic(SV_GroupID)) u32 Semantic(SV_GroupIndex), \
#define ImplComputeShader2D(name) void name(Vec2U32 Semantic(SV_DispatchThreadID), Vec2U32 Semantic(SV_GroupThreadID), u32 Semantic(SV_GroupIndex), Vec2U32 Semantic(SV_GroupID)) Vec3U32 Semantic(SV_GroupID), \
#define ImplComputeShader3D(name) void name(Vec3U32 Semantic(SV_DispatchThreadID), Vec3U32 Semantic(SV_GroupThreadID), u32 Semantic(SV_GroupIndex), Vec3U32 Semantic(SV_GroupID)) Vec3U32 Semantic(SV_GroupThreadID), \
#define ImplVertexShader(name, return_type) return_type name(u32 Semantic(SV_InstanceID), u32 Semantic(SV_VertexID)) Vec3U32 Semantic(SV_DispatchThreadID) \
#define ImplPixelShader(name, return_type, ...) return_type name(__VA_ARGS__) )
#endif
#if IsCpu
#define DeclComputeShader(name, resource_hash, x, y, z) enum { name##__GroupSize_X = x, name##__GroupSize_Y = y, name##__GroupSize_Z = z }; static ComputeShaderDesc name = { resource_hash, x, y, z }
#define DeclVertexShader(name, resource_hash) static VertexShaderDesc name = { resource_hash, 1, 1, 1 }
#define DeclPixelShader(name, resource_hash) static PixelShaderDesc name = { resource_hash, 1, 1, 1 }
#else
#define DeclComputeShader(name, resource_hash, x, y, z) enum { name##__GroupSize_X = x, name##__GroupSize_Y = y, name##__GroupSize_Z = z };
#define DeclVertexShader(name, resource_hash)
#define DeclPixelShader(name, resource_hash)
#endif #endif
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////

4
src/gpu/gpu_core.h
View File

@ -733,13 +733,13 @@ void G_MemorySyncEx(G_CommandListHandle cl, G_MemoryBarrierDesc desc);
//- Compute //- Compute
void G_Compute(G_CommandListHandle cl, ComputeShader cs, Vec3I32 groups); void G_Compute(G_CommandListHandle cl, ComputeShaderDesc cs, Vec3I32 groups);
//- Rasterize //- Rasterize
void G_Rasterize( void G_Rasterize(
G_CommandListHandle cl, G_CommandListHandle cl,
VertexShader vs, PixelShader ps, VertexShaderDesc vs, PixelShaderDesc ps,
u32 instances_count, G_IndexBufferDesc index_buffer, u32 instances_count, G_IndexBufferDesc index_buffer,
u32 render_targets_count, G_RenderTargetDesc *render_targets, u32 render_targets_count, G_RenderTargetDesc *render_targets,
Rng3 viewport, Rng2 scissor, Rng3 viewport, Rng2 scissor,

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

@ -3240,7 +3240,7 @@ void G_MemorySyncEx(G_CommandListHandle cl_handle, G_MemoryBarrierDesc desc)
//- Compute //- Compute
void G_Compute(G_CommandListHandle cl_handle, ComputeShader cs, Vec3I32 groups) void G_Compute(G_CommandListHandle cl_handle, ComputeShaderDesc cs, Vec3I32 groups)
{ {
if (groups.x > 0 && groups.y > 0 && groups.z > 0) if (groups.x > 0 && groups.y > 0 && groups.z > 0)
{ {
@ -3256,7 +3256,7 @@ void G_Compute(G_CommandListHandle cl_handle, ComputeShader cs, Vec3I32 groups)
void G_Rasterize( void G_Rasterize(
G_CommandListHandle cl_handle, G_CommandListHandle cl_handle,
VertexShader vs, PixelShader ps, VertexShaderDesc vs, PixelShaderDesc ps,
u32 instances_count, G_IndexBufferDesc index_buffer, u32 instances_count, G_IndexBufferDesc index_buffer,
u32 render_targets_count, G_RenderTargetDesc *render_targets, u32 render_targets_count, G_RenderTargetDesc *render_targets,
Rng3 viewport, Rng2 scissor, Rng3 viewport, Rng2 scissor,

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

@ -34,9 +34,9 @@
// NOTE: Must be zero initialized (including padding bits) for hashing // NOTE: Must be zero initialized (including padding bits) for hashing
Struct(G_D12_PipelineDesc) Struct(G_D12_PipelineDesc)
{ {
VertexShader vs; VertexShaderDesc vs;
PixelShader ps; PixelShaderDesc ps;
ComputeShader cs; ComputeShaderDesc cs;
b32 is_wireframe; b32 is_wireframe;
D3D12_PRIMITIVE_TOPOLOGY_TYPE topology_type; D3D12_PRIMITIVE_TOPOLOGY_TYPE topology_type;
G_Format render_target_formats[G_MaxRenderTargets]; G_Format render_target_formats[G_MaxRenderTargets];
@ -353,14 +353,14 @@ Struct(G_D12_Cmd)
struct struct
{ {
ComputeShader cs; ComputeShaderDesc cs;
Vec3I32 groups; Vec3I32 groups;
} compute; } compute;
struct struct
{ {
VertexShader vs; VertexShaderDesc vs;
PixelShader ps; PixelShaderDesc ps;
u32 instances_count; u32 instances_count;
G_IndexBufferDesc index_buffer_desc; G_IndexBufferDesc index_buffer_desc;
G_RenderTargetDesc render_target_descs[G_MaxRenderTargets]; G_RenderTargetDesc render_target_descs[G_MaxRenderTargets];

74
src/meta/meta.c
View File

@ -614,9 +614,9 @@ void M_BuildEntryPoint(WaveLaneCtx *lane)
} }
//- Generate C file //- Generate C file
StringList shader_lines = Zi;
{ {
StringList c_store_lines = Zi; StringList c_store_lines = Zi;
StringList c_shader_lines = Zi;
StringList c_include_lines = Zi; StringList c_include_lines = Zi;
StringList c_bootstrap_lines = Zi; StringList c_bootstrap_lines = Zi;
{ {
@ -661,14 +661,60 @@ void M_BuildEntryPoint(WaveLaneCtx *lane)
{ {
if (arg0_tok->valid) if (arg0_tok->valid)
{ {
String shader_type = kind == M_EntryKind_VertexShader ? Lit("VertexShader") String decl_type = (
: kind == M_EntryKind_PixelShader ? Lit("PixelShader") kind == M_EntryKind_VertexShader ? Lit("DeclVertexShader") :
: kind == M_EntryKind_ComputeShader ? Lit("ComputeShader") kind == M_EntryKind_PixelShader ? Lit("DeclPixelShader") :
: Lit(""); kind == M_EntryKind_ComputeShader ? Lit("DeclComputeShader") :
Lit("")
);
String shader_name = arg0_tok->s; String shader_name = arg0_tok->s;
Vec3U32 thread_count = Zi;
{
StringList thread_count_args = Zi;
for (i32 arg_idx = 1; arg_idx < countof(entry->arg_tokens); ++arg_idx)
{
M_Token *arg_tok = entry->arg_tokens[arg_idx];
if (arg_tok->valid)
{
PushStringToList(perm, &thread_count_args, arg_tok->s);
}
else
{
break;
}
}
String thread_count_str = StringFromList(perm, thread_count_args, Lit(" "));
Vec3 tmp = CR_Vec3FromString(thread_count_str);
thread_count.x = MaxI32(tmp.x, 1);
thread_count.y = MaxI32(tmp.y, 1);
thread_count.z = MaxI32(tmp.z, 1);
}
u64 shader_resource_hash = HashStringEx(shader_store_hash, StringF(perm, "%F.dxil", FmtString(shader_name))); u64 shader_resource_hash = HashStringEx(shader_store_hash, StringF(perm, "%F.dxil", FmtString(shader_name)));
String line = StringF(perm, "%F %F = { 0x%F };", FmtString(shader_type), FmtString(shader_name), FmtHex(shader_resource_hash)); String lines = Zi;
PushStringToList(perm, &c_shader_lines, line); if (kind == M_EntryKind_ComputeShader)
{
lines = StringF(
perm,
"%F(%F, 0x%F, %F, %F, %F);",
FmtString(decl_type),
FmtString(shader_name),
FmtHex(shader_resource_hash),
FmtUint(thread_count.x),
FmtUint(thread_count.y),
FmtUint(thread_count.z)
);
}
else
{
lines = StringF(
perm,
"%F(%F, 0x%F);",
FmtString(decl_type),
FmtString(shader_name),
FmtHex(shader_resource_hash)
);
}
PushStringToList(perm, &shader_lines, lines);
} }
else else
{ {
@ -737,11 +783,11 @@ void M_BuildEntryPoint(WaveLaneCtx *lane)
} }
} }
// Define shaders // Define shaders
if (c_shader_lines.count > 0) if (shader_lines.count > 0)
{ {
PushStringToList(perm, &c_out_lines, Lit("")); PushStringToList(perm, &c_out_lines, Lit(""));
PushStringToList(perm, &c_out_lines, Lit("//- Shaders")); PushStringToList(perm, &c_out_lines, Lit("//- Shaders"));
for (StringListNode *n = c_shader_lines.first; n; n = n->next) for (StringListNode *n = shader_lines.first; n; n = n->next)
{ {
PushStringToList(perm, &c_out_lines, n->s); PushStringToList(perm, &c_out_lines, n->s);
} }
@ -875,6 +921,16 @@ void M_BuildEntryPoint(WaveLaneCtx *lane)
PushStringToList(perm, &gpu_out_lines, Lit("//- Base layer includes")); PushStringToList(perm, &gpu_out_lines, Lit("//- Base layer includes"));
PushStringToList(perm, &gpu_out_lines, StringF(perm, "#include \"%F\"", FmtString(base_inc_path))); PushStringToList(perm, &gpu_out_lines, StringF(perm, "#include \"%F\"", FmtString(base_inc_path)));
} }
// Define shaders
if (shader_lines.count > 0)
{
PushStringToList(perm, &gpu_out_lines, Lit(""));
PushStringToList(perm, &gpu_out_lines, Lit("//- Shaders"));
for (StringListNode *n = shader_lines.first; n; n = n->next)
{
PushStringToList(perm, &gpu_out_lines, n->s);
}
}
// Include dependency layers // Include dependency layers
if (gpu_out_lines.count > 0) if (gpu_out_lines.count > 0)
{ {

8
src/meta/meta_lay.c
View File

@ -14,8 +14,14 @@ Readonly M_Entry M_NilEntry = {
.name_token = &M_NilToken, .name_token = &M_NilToken,
.arg_tokens[0] = &M_NilToken, .arg_tokens[0] = &M_NilToken,
.arg_tokens[1] = &M_NilToken, .arg_tokens[1] = &M_NilToken,
.arg_tokens[2] = &M_NilToken,
.arg_tokens[3] = &M_NilToken,
.arg_tokens[4] = &M_NilToken,
.arg_tokens[5] = &M_NilToken,
.arg_tokens[6] = &M_NilToken,
.arg_tokens[7] = &M_NilToken,
}; };
StaticAssert(countof(M_NilEntry.arg_tokens) == 2); // NilEntry must point args to nil tokens StaticAssert(countof(M_NilEntry.arg_tokens) == 8); // NilEntry must point args to nil tokens
Readonly M_Layer M_NilLayer = { Readonly M_Layer M_NilLayer = {
.next = &M_NilLayer, .next = &M_NilLayer,

2
src/meta/meta_lay.h
View File

@ -105,7 +105,7 @@ Struct(M_Entry)
M_EntryKind kind; M_EntryKind kind;
M_Token *name_token; M_Token *name_token;
M_Token *arg_tokens[2]; M_Token *arg_tokens[8];
u64 args_count; u64 args_count;
}; };

24
src/pp/pp_vis/pp_vis.lay generated
View File

@ -15,20 +15,20 @@
////////////////////////////// //////////////////////////////
//- Resources //- Resources
@ComputeShader V_PrepareShadeCS @ComputeShader V_PrepareShadeCS (16, 16)
@ComputeShader V_PrepareCellsCS @ComputeShader V_PrepareCellsCS (16, 16)
@ComputeShader V_BackdropDownCS @ComputeShader V_BackdropDownCS (16, 16)
@ComputeShader V_BackdropUpCS @ComputeShader V_BackdropUpCS (16, 16)
@ComputeShader V_ClearParticlesCS @ComputeShader V_ClearParticlesCS (256)
@VertexShader V_QuadVS @VertexShader V_QuadVS
@PixelShader V_QuadPS @PixelShader V_QuadPS
@ComputeShader V_EmitParticlesCS @ComputeShader V_EmitParticlesCS (256)
@ComputeShader V_SimParticlesCS @ComputeShader V_SimParticlesCS (256)
@ComputeShader V_ShadeCS @ComputeShader V_ShadeCS (16, 16)
@ComputeShader V_CompositeCS @ComputeShader V_CompositeCS (16, 16)
@ComputeShader V_BloomDownCS @ComputeShader V_BloomDownCS (16, 16)
@ComputeShader V_BloomUpCS @ComputeShader V_BloomUpCS (16, 16)
@ComputeShader V_FinalizeCS @ComputeShader V_FinalizeCS (16, 16)
@VertexShader V_DVertVS @VertexShader V_DVertVS
@PixelShader V_DVertPS @PixelShader V_DVertPS

34
src/pp/pp_vis/pp_vis_gpu.g
View File

@ -56,7 +56,7 @@ Vec4 V_ColorFromParticle(V_ParticleDesc desc, u32 particle_idx, u32 density)
//~ Prepare frame //~ Prepare frame
//- Prepare shade //- Prepare shade
ImplComputeShader2D(V_PrepareShadeCS) ComputeShader(V_PrepareShadeCS)
{ {
V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0]; V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0];
RWTexture2D<Vec4> shade = G_SDerefRW<Vec4>(frame.shade); RWTexture2D<Vec4> shade = G_SDerefRW<Vec4>(frame.shade);
@ -69,7 +69,7 @@ ImplComputeShader2D(V_PrepareShadeCS)
} }
//- Prepare cells //- Prepare cells
ImplComputeShader2D(V_PrepareCellsCS) ComputeShader(V_PrepareCellsCS)
{ {
V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0]; V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0];
Texture2D<P_TileKind> tiles = G_SDeref<P_TileKind>(frame.tiles); Texture2D<P_TileKind> tiles = G_SDeref<P_TileKind>(frame.tiles);
@ -158,7 +158,7 @@ ImplComputeShader2D(V_PrepareCellsCS)
} }
//- Clear particles //- Clear particles
ImplComputeShader(V_ClearParticlesCS) ComputeShader(V_ClearParticlesCS)
{ {
V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0]; V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0];
RWStructuredBuffer<V_Particle> particles = G_SDerefRW<V_Particle>(frame.particles); RWStructuredBuffer<V_Particle> particles = G_SDerefRW<V_Particle>(frame.particles);
@ -175,7 +175,7 @@ ImplComputeShader(V_ClearParticlesCS)
////////////////////////////// //////////////////////////////
//- Downsample //- Downsample
ImplComputeShader2D(V_BackdropDownCS) ComputeShader(V_BackdropDownCS)
{ {
i32 mip_idx = V_GpuConst_MipIdx; i32 mip_idx = V_GpuConst_MipIdx;
b32 is_first_pass = mip_idx == 0; b32 is_first_pass = mip_idx == 0;
@ -241,7 +241,7 @@ ImplComputeShader2D(V_BackdropDownCS)
////////////////////////////// //////////////////////////////
//- Upsample //- Upsample
ImplComputeShader2D(V_BackdropUpCS) ComputeShader(V_BackdropUpCS)
{ {
i32 mip_idx = V_GpuConst_MipIdx; i32 mip_idx = V_GpuConst_MipIdx;
@ -301,7 +301,7 @@ ImplComputeShader2D(V_BackdropUpCS)
////////////////////////////// //////////////////////////////
//- Vertex shader //- Vertex shader
ImplVertexShader(V_QuadVS, V_QuadPSInput) VertexShader(V_QuadVS, V_QuadPSInput)
{ {
V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0]; V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0];
StructuredBuffer<V_Quad> quads = G_SDeref<V_Quad>(frame.quads); StructuredBuffer<V_Quad> quads = G_SDeref<V_Quad>(frame.quads);
@ -325,7 +325,7 @@ ImplVertexShader(V_QuadVS, V_QuadPSInput)
////////////////////////////// //////////////////////////////
//- Pixel shader //- Pixel shader
ImplPixelShader(V_QuadPS, V_QuadPSOutput, V_QuadPSInput input) PixelShader(V_QuadPS, V_QuadPSOutput, V_QuadPSInput input)
{ {
V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0]; V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0];
SamplerState sampler = G_SDeref(frame.basic_samplers[G_BasicSamplerKind_PointClamp]); SamplerState sampler = G_SDeref(frame.basic_samplers[G_BasicSamplerKind_PointClamp]);
@ -361,7 +361,7 @@ ImplPixelShader(V_QuadPS, V_QuadPSOutput, V_QuadPSInput input)
////////////////////////////// //////////////////////////////
//- Particle emitter shader //- Particle emitter shader
ImplComputeShader(V_EmitParticlesCS) ComputeShader(V_EmitParticlesCS)
{ {
V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0]; V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0];
StructuredBuffer<V_Emitter> emitters = G_SDeref<V_Emitter>(frame.emitters); StructuredBuffer<V_Emitter> emitters = G_SDeref<V_Emitter>(frame.emitters);
@ -392,7 +392,7 @@ ImplComputeShader(V_EmitParticlesCS)
////////////////////////////// //////////////////////////////
//- Particle sim shader //- Particle sim shader
ImplComputeShader(V_SimParticlesCS) ComputeShader(V_SimParticlesCS)
{ {
V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0]; V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0];
Texture2D<P_TileKind> tiles = G_SDeref<P_TileKind>(frame.tiles); Texture2D<P_TileKind> tiles = G_SDeref<P_TileKind>(frame.tiles);
@ -669,7 +669,7 @@ ImplComputeShader(V_SimParticlesCS)
// TODO: Remove this // TODO: Remove this
ImplComputeShader2D(V_ShadeCS) ComputeShader(V_ShadeCS)
{ {
V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0]; V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0];
SamplerState sampler = G_SDeref(frame.basic_samplers[G_BasicSamplerKind_PointClamp]); SamplerState sampler = G_SDeref(frame.basic_samplers[G_BasicSamplerKind_PointClamp]);
@ -705,7 +705,7 @@ ImplComputeShader2D(V_ShadeCS)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Composite //~ Composite
ImplComputeShader2D(V_CompositeCS) ComputeShader(V_CompositeCS)
{ {
V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0]; V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0];
// Texture2D<Vec4> shade_tex = G_SDeref<Vec4>(frame.shade); // Texture2D<Vec4> shade_tex = G_SDeref<Vec4>(frame.shade);
@ -720,7 +720,7 @@ ImplComputeShader2D(V_CompositeCS)
Texture2D<Vec4> backdrop = G_SDeref<Vec4>(frame.backdrop_mips[0]); Texture2D<Vec4> backdrop = G_SDeref<Vec4>(frame.backdrop_mips[0]);
StructuredBuffer<V_Particle> particles = G_SDeref<V_Particle>(frame.particles); StructuredBuffer<V_Particle> particles = G_SDeref<V_Particle>(frame.particles);
Vec2 screen_pos = SV_DispatchThreadID.xy + 0.5; Vec2 screen_pos = SV_DispatchThreadID + 0.5;
Vec2 world_pos = mul(frame.af.screen_to_world, Vec3(screen_pos, 1)); Vec2 world_pos = mul(frame.af.screen_to_world, Vec3(screen_pos, 1));
Vec2 cell_pos = mul(frame.af.world_to_cell, Vec3(world_pos, 1)); Vec2 cell_pos = mul(frame.af.world_to_cell, Vec3(world_pos, 1));
Vec2 shade_pos = mul(frame.af.screen_to_shade, Vec3(screen_pos.xy, 1)); Vec2 shade_pos = mul(frame.af.screen_to_shade, Vec3(screen_pos.xy, 1));
@ -1106,7 +1106,7 @@ ImplComputeShader2D(V_CompositeCS)
////////////////////////////// //////////////////////////////
//- Downsample //- Downsample
ImplComputeShader2D(V_BloomDownCS) ComputeShader(V_BloomDownCS)
{ {
i32 mip_idx = V_GpuConst_MipIdx; i32 mip_idx = V_GpuConst_MipIdx;
@ -1181,7 +1181,7 @@ ImplComputeShader2D(V_BloomDownCS)
////////////////////////////// //////////////////////////////
//- Upsample //- Upsample
ImplComputeShader2D(V_BloomUpCS) ComputeShader(V_BloomUpCS)
{ {
i32 mip_idx = V_GpuConst_MipIdx; i32 mip_idx = V_GpuConst_MipIdx;
@ -1248,7 +1248,7 @@ ImplComputeShader2D(V_BloomUpCS)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Finalize //~ Finalize
ImplComputeShader2D(V_FinalizeCS) ComputeShader(V_FinalizeCS)
{ {
V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0]; V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0];
SamplerState bilinear_sampler = G_SDeref(frame.basic_samplers[G_BasicSamplerKind_BilinearClamp]); SamplerState bilinear_sampler = G_SDeref(frame.basic_samplers[G_BasicSamplerKind_BilinearClamp]);
@ -1281,7 +1281,7 @@ ImplComputeShader2D(V_FinalizeCS)
////////////////////////////// //////////////////////////////
//- Vertex shader //- Vertex shader
ImplVertexShader(V_DVertVS, V_DVertPSInput) VertexShader(V_DVertVS, V_DVertPSInput)
{ {
V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0]; V_SharedFrame frame = G_SDeref<V_SharedFrame>(V_GpuConst_Frame)[0];
StructuredBuffer<V_DVert> verts = G_SDeref<V_DVert>(frame.dverts); StructuredBuffer<V_DVert> verts = G_SDeref<V_DVert>(frame.dverts);
@ -1299,7 +1299,7 @@ ImplVertexShader(V_DVertVS, V_DVertPSInput)
////////////////////////////// //////////////////////////////
//- Pixel shader //- Pixel shader
ImplPixelShader(V_DVertPS, V_DVertPSOutput, V_DVertPSInput input) PixelShader(V_DVertPS, V_DVertPSOutput, V_DVertPSInput input)
{ {
V_DVertPSOutput output; V_DVertPSOutput output;
output.sv_target0 = input.color_lin; output.sv_target0 = input.color_lin;

32
src/pp/pp_vis/pp_vis_gpu.gh
View File

@ -51,35 +51,35 @@ Vec4 V_ColorFromParticle(V_ParticleDesc desc, u32 particle_idx, u32 density);
//~ Shaders //~ Shaders
//- Prepare frame //- Prepare frame
DeclComputeShader2D(V_PrepareShadeCS, 16, 16); ComputeShader(V_PrepareShadeCS);
DeclComputeShader2D(V_PrepareCellsCS, 16, 16); ComputeShader(V_PrepareCellsCS);
DeclComputeShader(V_ClearParticlesCS, 256); ComputeShader(V_ClearParticlesCS);
//- Backdrop //- Backdrop
DeclComputeShader2D(V_BackdropDownCS, 16, 16); ComputeShader(V_BackdropDownCS);
DeclComputeShader2D(V_BackdropUpCS, 16, 16); ComputeShader(V_BackdropUpCS);
//- Quads //- Quads
DeclVertexShader(V_QuadVS, V_QuadPSInput); VertexShader(V_QuadVS, V_QuadPSInput);
DeclPixelShader(V_QuadPS, V_QuadPSOutput, V_QuadPSInput input); PixelShader(V_QuadPS, V_QuadPSOutput, V_QuadPSInput input);
//- Particle simulation //- Particle simulation
DeclComputeShader(V_EmitParticlesCS, 256); ComputeShader(V_EmitParticlesCS);
DeclComputeShader(V_SimParticlesCS, 256); ComputeShader(V_SimParticlesCS);
//- Shade //- Shade
DeclComputeShader2D(V_ShadeCS, 16, 16); ComputeShader(V_ShadeCS);
//- Composite //- Composite
DeclComputeShader2D(V_CompositeCS, 16, 16); ComputeShader(V_CompositeCS);
//- Bloom //- Bloom
DeclComputeShader2D(V_BloomDownCS, 16, 16); ComputeShader(V_BloomDownCS);
DeclComputeShader2D(V_BloomUpCS, 16, 16); ComputeShader(V_BloomUpCS);
//- Finalize //- Finalize
DeclComputeShader2D(V_FinalizeCS, 16, 16); ComputeShader(V_FinalizeCS);
//- Debug shapes //- Debug shapes
DeclVertexShader(V_DVertVS, V_DVertPSInput); VertexShader(V_DVertVS, V_DVertPSInput);
DeclPixelShader(V_DVertPS, V_DVertPSOutput, V_DVertPSInput input); PixelShader(V_DVertPS, V_DVertPSOutput, V_DVertPSInput input);

2
src/proto/proto.lay generated
View File

@ -9,7 +9,7 @@
////////////////////////////// //////////////////////////////
//- Resources //- Resources
@ComputeShader PT_TestCS @ComputeShader PT_TestCS (8, 8)
@VertexShader PT_BlitVS @VertexShader PT_BlitVS
@PixelShader PT_BlitPS @PixelShader PT_BlitPS

6
src/proto/proto_gpu.g
View File

@ -1,7 +1,7 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
//~ Test shader //~ Test shader
ImplComputeShader2D(PT_TestCS) ComputeShader(PT_TestCS)
{ {
StructuredBuffer<TestStruct> sb = G_SDeref<TestStruct>(PT_ShaderConst_TestBuff); StructuredBuffer<TestStruct> sb = G_SDeref<TestStruct>(PT_ShaderConst_TestBuff);
RWTexture2D<Vec4> target_tex = G_SDerefRW<Vec4>(PT_ShaderConst_TestTarget); RWTexture2D<Vec4> target_tex = G_SDerefRW<Vec4>(PT_ShaderConst_TestTarget);
@ -21,7 +21,7 @@ ImplComputeShader2D(PT_TestCS)
////////////////////////////// //////////////////////////////
//- Vertex shader //- Vertex shader
ImplVertexShader(PT_BlitVS, PT_BlitPSInput) VertexShader(PT_BlitVS, PT_BlitPSInput)
{ {
Vec2 uv = RectUvFromIdx(SV_VertexID); Vec2 uv = RectUvFromIdx(SV_VertexID);
PT_BlitPSInput result; PT_BlitPSInput result;
@ -33,7 +33,7 @@ ImplVertexShader(PT_BlitVS, PT_BlitPSInput)
////////////////////////////// //////////////////////////////
//- Pixel shader //- Pixel shader
ImplPixelShader(PT_BlitPS, PT_BlitPSOutput, PT_BlitPSInput input) PixelShader(PT_BlitPS, PT_BlitPSOutput, PT_BlitPSInput input)
{ {
SamplerState sampler = G_SDeref(PT_ShaderConst_BlitSampler); SamplerState sampler = G_SDeref(PT_ShaderConst_BlitSampler);
Texture2D<Vec4> tex = G_SDeref<Vec4>(PT_ShaderConst_BlitSrc); Texture2D<Vec4> tex = G_SDeref<Vec4>(PT_ShaderConst_BlitSrc);

2
src/proto/proto_gpu.gh
View File

@ -24,7 +24,7 @@ Struct(PT_BlitPSOutput)
//~ Shaders //~ Shaders
//- Test //- Test
DeclComputeShader2D(PT_TestCS, 8, 8); ComputeShader(PT_TestCS);
//- Blit //- Blit
DeclVertexShader(PT_BlitVS, PT_BlitPSInput); DeclVertexShader(PT_BlitVS, PT_BlitPSInput);

8
src/ui/ui_gpu.g
View File

@ -4,7 +4,7 @@
////////////////////////////// //////////////////////////////
//- Vertex shader //- Vertex shader
ImplVertexShader(UI_DRectVS, UI_DRectPSInput) VertexShader(UI_DRectVS, UI_DRectPSInput)
{ {
UI_GpuParams params = G_SDeref<UI_GpuParams>(UI_GpuConst_Params)[0]; UI_GpuParams params = G_SDeref<UI_GpuParams>(UI_GpuConst_Params)[0];
StructuredBuffer<UI_GpuRect> rects = G_SDeref<UI_GpuRect>(params.rects); StructuredBuffer<UI_GpuRect> rects = G_SDeref<UI_GpuRect>(params.rects);
@ -31,7 +31,7 @@ ImplVertexShader(UI_DRectVS, UI_DRectPSInput)
////////////////////////////// //////////////////////////////
//- Pixel shader //- Pixel shader
ImplPixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input) PixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input)
{ {
UI_GpuParams params = G_SDeref<UI_GpuParams>(UI_GpuConst_Params)[0]; UI_GpuParams params = G_SDeref<UI_GpuParams>(UI_GpuConst_Params)[0];
SamplerState sampler = G_SDeref(params.sampler); SamplerState sampler = G_SDeref(params.sampler);
@ -116,7 +116,7 @@ ImplPixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input)
////////////////////////////// //////////////////////////////
//- Vertex shader //- Vertex shader
ImplVertexShader(UI_BlitVS, UI_BlitPSInput) VertexShader(UI_BlitVS, UI_BlitPSInput)
{ {
Vec2 uv = RectUvFromIdx(SV_VertexID); Vec2 uv = RectUvFromIdx(SV_VertexID);
UI_BlitPSInput result; UI_BlitPSInput result;
@ -129,7 +129,7 @@ ImplVertexShader(UI_BlitVS, UI_BlitPSInput)
////////////////////////////// //////////////////////////////
//- Pixel shader //- Pixel shader
ImplPixelShader(UI_BlitPS, UI_BlitPSOutput, UI_BlitPSInput input) PixelShader(UI_BlitPS, UI_BlitPSOutput, UI_BlitPSInput input)
{ {
UI_GpuParams params = G_SDeref<UI_GpuParams>(UI_GpuConst_Params)[0]; UI_GpuParams params = G_SDeref<UI_GpuParams>(UI_GpuConst_Params)[0];
Texture2D<Vec4> tex = G_SDeref<Vec4>(params.target_ro); Texture2D<Vec4> tex = G_SDeref<Vec4>(params.target_ro);

8
src/ui/ui_gpu.gh
View File

@ -36,9 +36,9 @@ Struct(UI_BlitPSOutput)
//~ Shaders //~ Shaders
//- Rects //- Rects
DeclVertexShader(UI_DRectVS, UI_DRectPSInput); VertexShader(UI_DRectVS, UI_DRectPSInput);
DeclPixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input); PixelShader(UI_DRectPS, UI_DRectPSOutput, UI_DRectPSInput input);
//- Blit //- Blit
DeclVertexShader(UI_BlitVS, UI_BlitPSInput); VertexShader(UI_BlitVS, UI_BlitPSInput);
DeclPixelShader(UI_BlitPS, UI_BlitPSOutput, UI_BlitPSInput input); PixelShader(UI_BlitPS, UI_BlitPSOutput, UI_BlitPSInput input);