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

specify shader type in layer entry arguments

Browse Source
This commit is contained in:
jacob 2026-03-30 14:43:15 -05:00
parent 78f4677cdb
commit 5ef6a770cb
6 changed files with 110 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
src/meta/meta.c
View File

@ -713,62 +713,105 @@ void M_BuildEntryPoint(WaveLaneCtx *lane)
M_PushError(perm, &M.c_parse.errors, entry_tok, Lit("Expected resource store & directory name")); M_PushError(perm, &M.c_parse.errors, entry_tok, Lit("Expected resource store & directory name"));
} }
} break; } break;
case M_EntryKind_VertexShader: case M_EntryKind_Shader:
case M_EntryKind_PixelShader:
case M_EntryKind_ComputeShader:
{ {
String vs_pattern = Lit("Vertex");
String ps_pattern = Lit("Pixel");
b32 ok = 1;
M_Token *arg_err_tok = entry_tok;
if (arg0_tok->valid) if (arg0_tok->valid)
{ {
arg_err_tok = arg0_tok;
String shader_name = arg0_tok->s; String shader_name = arg0_tok->s;
Vec3U32 group_dims = Zi; M_ShaderEntryKind shader_kind = M_ShaderEntryKind_Unknown;
i32 group_dims_count = 1; i32 cs_rank = 0;
Vec3I32 cs_group_dims = Zi;
if (arg1_tok->valid)
{ {
StringList thread_count_args = Zi; arg_err_tok = arg1_tok;
String args_str = Zi;
{
StringList args_strlist = Zi;
for (i32 arg_idx = 1; arg_idx < countof(entry->arg_tokens); ++arg_idx) for (i32 arg_idx = 1; arg_idx < countof(entry->arg_tokens); ++arg_idx)
{ {
M_Token *arg_tok = entry->arg_tokens[arg_idx]; M_Token *arg_tok = entry->arg_tokens[arg_idx];
if (arg_tok->valid) if (arg_tok->valid)
{ {
PushStringToList(perm, &thread_count_args, arg_tok->s); PushStringToList(perm, &args_strlist, arg_tok->s);
} }
else else
{ {
break; break;
} }
} }
String group_dims_str = StringFromList(perm, thread_count_args, Lit(" ")); args_str = StringFromList(perm, args_strlist, Lit(" "));
Vec3 tmp = CR_Vec3FromString(group_dims_str); cs_group_dims = Vec3I32FromVec(CR_Vec3FromString(args_str));
group_dims.x = MaxI32(tmp.x, 1); }
group_dims.y = MaxI32(tmp.y, 1); if (MatchString(args_str, vs_pattern))
group_dims.z = MaxI32(tmp.z, 1);
// Determine compute shader dimensions type by counting comma-separated values in group size string
for (u64 char_idx = 0; char_idx < group_dims_str.len; ++char_idx)
{ {
u8 c = group_dims_str.text[char_idx]; shader_kind = M_ShaderEntryKind_Vs;
if (c == ',') }
else if (MatchString(args_str, ps_pattern))
{ {
group_dims_count += 1; shader_kind = M_ShaderEntryKind_Ps;
}
else
{
cs_rank += cs_group_dims.x > 0;
cs_rank += cs_group_dims.y > 0;
cs_rank += cs_group_dims.z > 0;
if (cs_rank > 0)
{
shader_kind = M_ShaderEntryKind_Cs;
}
cs_group_dims.x = MaxI32(cs_group_dims.x, 1);
cs_group_dims.y = MaxI32(cs_group_dims.y, 1);
cs_group_dims.z = MaxI32(cs_group_dims.z, 1);
} }
} }
group_dims_count = ClampI32(group_dims_count, 1, 3);
if (shader_kind == M_ShaderEntryKind_Unknown)
{
ok = 0;
M_PushError(
perm,
&M.c_parse.errors,
arg_err_tok,
StringF(
perm,
"Expected shader description ('%F', '%F', or thread group dimensions)",
FmtString(vs_pattern),
FmtString(ps_pattern)
)
);
} }
if (ok)
{
M_ShaderEntry *e = PushStruct(perm, M_ShaderEntry);
e->kind = shader_kind;
e->name = shader_name;
SllQueuePush(M.gpu_parse.first_shader_entry, M.gpu_parse.last_shader_entry, e);
++M.gpu_parse.shader_entries_count;
}
String decl_type = ( String decl_type = (
kind == M_EntryKind_VertexShader ? Lit("DeclVertexShader") : shader_kind == M_ShaderEntryKind_Vs ? Lit("DeclVertexShader") :
kind == M_EntryKind_PixelShader ? Lit("DeclPixelShader") : shader_kind == M_ShaderEntryKind_Ps ? Lit("DeclPixelShader") :
kind == M_EntryKind_ComputeShader ? Lit("DeclComputeShader") : shader_kind == M_ShaderEntryKind_Cs ? Lit("DeclComputeShader") :
Lit("") Lit("")
); );
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)));
// Dims type line // Dims type line
if (kind == M_EntryKind_ComputeShader) if (shader_kind == M_ShaderEntryKind_Cs)
{ {
String line = StringF( String line = StringF(
perm, perm,
"#define %F__ThreadDimsType %F", "#define %F__ThreadDimsType %F",
FmtString(shader_name), FmtString(shader_name),
FmtString( FmtString(
group_dims_count == 1 ? Lit("u32") : cs_rank == 1 ? Lit("u32") :
group_dims_count == 2 ? Lit("Vec2U32") : cs_rank == 2 ? Lit("Vec2U32") :
Lit("Vec3U32") Lit("Vec3U32")
) )
); );
@ -777,7 +820,7 @@ void M_BuildEntryPoint(WaveLaneCtx *lane)
// Shader line // Shader line
{ {
String line = Zi; String line = Zi;
if (kind == M_EntryKind_ComputeShader) if (shader_kind == M_ShaderEntryKind_Cs)
{ {
line = StringF( line = StringF(
perm, perm,
@ -785,9 +828,9 @@ void M_BuildEntryPoint(WaveLaneCtx *lane)
FmtString(decl_type), FmtString(decl_type),
FmtString(shader_name), FmtString(shader_name),
FmtHex(shader_resource_hash), FmtHex(shader_resource_hash),
FmtUint(group_dims.x), FmtUint(cs_group_dims.x),
FmtUint(group_dims.y), FmtUint(cs_group_dims.y),
FmtUint(group_dims.z) FmtUint(cs_group_dims.z)
); );
} }
else else
@ -982,28 +1025,6 @@ void M_BuildEntryPoint(WaveLaneCtx *lane)
M_PushError(perm, &M.gpu_parse.errors, entry_tok, Lit("Expected file name")); M_PushError(perm, &M.gpu_parse.errors, entry_tok, Lit("Expected file name"));
} }
} break; } break;
case M_EntryKind_VertexShader:
case M_EntryKind_PixelShader:
case M_EntryKind_ComputeShader:
{
if (arg0_tok->valid)
{
M_ShaderEntryKind shader_kind = kind == M_EntryKind_VertexShader ? ShaderEntryKind_VS
: kind == M_EntryKind_PixelShader ? ShaderEntryKind_PS
: kind == M_EntryKind_ComputeShader ? ShaderEntryKind_CS
: ShaderEntryKind_VS;
String shader_name = arg0_tok->s;
M_ShaderEntry *e = PushStruct(perm, M_ShaderEntry);
e->kind = shader_kind;
e->name = shader_name;
SllQueuePush(M.gpu_parse.first_shader_entry, M.gpu_parse.last_shader_entry, e);
++M.gpu_parse.shader_entries_count;
}
else
{
M_PushError(perm, &M.gpu_parse.errors, entry_tok, Lit("Expected shader name"));
}
} break;
} }
} }
} }
@ -1190,8 +1211,8 @@ void M_BuildEntryPoint(WaveLaneCtx *lane)
M_GpuObj *gpu_obj = &M.gpu_objs.array[gpu_obj_idx]; M_GpuObj *gpu_obj = &M.gpu_objs.array[gpu_obj_idx];
String out_file = StringF(perm, "%F/%F.dxil", FmtString(shader_store_name), FmtString(e->name)); String out_file = StringF(perm, "%F/%F.dxil", FmtString(shader_store_name), FmtString(e->name));
String target = ( String target = (
e->kind == ShaderEntryKind_VS ? Lit("vs_6_6") : e->kind == M_ShaderEntryKind_Vs ? Lit("vs_6_6") :
e->kind == ShaderEntryKind_PS ? Lit("ps_6_6") : e->kind == M_ShaderEntryKind_Ps ? Lit("ps_6_6") :
Lit("cs_6_6") Lit("cs_6_6")
); );

7
src/meta/meta.h
View File

@ -88,9 +88,10 @@ Struct(M_CompilerParams)
Enum(M_ShaderEntryKind) Enum(M_ShaderEntryKind)
{ {
ShaderEntryKind_VS, M_ShaderEntryKind_Unknown,
ShaderEntryKind_PS, M_ShaderEntryKind_Vs,
ShaderEntryKind_CS, M_ShaderEntryKind_Ps,
M_ShaderEntryKind_Cs,
}; };
Struct(M_ShaderEntry) Struct(M_ShaderEntry)

8
src/meta/meta_lay.h
View File

@ -78,9 +78,7 @@ Enum(M_EntryKind)
M_EntryKind_IncludeG, M_EntryKind_IncludeG,
M_EntryKind_DefaultDownstream, M_EntryKind_DefaultDownstream,
M_EntryKind_Bootstrap, M_EntryKind_Bootstrap,
M_EntryKind_VertexShader, M_EntryKind_Shader,
M_EntryKind_PixelShader,
M_EntryKind_ComputeShader,
M_EntryKind_EmbedDir, M_EntryKind_EmbedDir,
}; };
@ -91,9 +89,7 @@ Global Readonly char *M_entry_kind_rules[] = {
[M_EntryKind_IncludeG] = "@IncludeG", [M_EntryKind_IncludeG] = "@IncludeG",
[M_EntryKind_DefaultDownstream] = "@DefaultDownstream", [M_EntryKind_DefaultDownstream] = "@DefaultDownstream",
[M_EntryKind_Bootstrap] = "@Bootstrap", [M_EntryKind_Bootstrap] = "@Bootstrap",
[M_EntryKind_VertexShader] = "@VertexShader", [M_EntryKind_Shader] = "@Shader",
[M_EntryKind_PixelShader] = "@PixelShader",
[M_EntryKind_ComputeShader] = "@ComputeShader",
[M_EntryKind_EmbedDir] = "@EmbedDir", [M_EntryKind_EmbedDir] = "@EmbedDir",
}; };

34
src/pp/pp_vis/pp_vis.lay
View File

@ -15,23 +15,23 @@
////////////////////////////// //////////////////////////////
//- Resources //- Resources
@ComputeShader V_ProfilerGraphCS (128, 1) // Vertical group dims so that sample access is uniform @Shader V_BuildProfilerGraphCS (1, 128) // Vertical group shape so that profiler-sample access is uniform
@ComputeShader V_PrepareShadeCS (16, 16) @Shader V_PrepareShadeCS (16, 16)
@ComputeShader V_PrepareCellsCS (16, 16) @Shader V_PrepareCellsCS (16, 16)
@ComputeShader V_BackdropDownCS (16, 16) @Shader V_BackdropDownCS (16, 16)
@ComputeShader V_BackdropUpCS (16, 16) @Shader V_BackdropUpCS (16, 16)
@ComputeShader V_ClearParticlesCS (256) @Shader V_ClearParticlesCS (256)
@VertexShader V_QuadVS @Shader V_QuadVS Vertex
@PixelShader V_QuadPS @Shader V_QuadPS Pixel
@ComputeShader V_EmitParticlesCS (256) @Shader V_EmitParticlesCS (256)
@ComputeShader V_SimParticlesCS (256) @Shader V_SimParticlesCS (256)
@ComputeShader V_ShadeCS (16, 16) @Shader V_ShadeCS (16, 16)
@ComputeShader V_CompositeCS (16, 16) @Shader V_CompositeCS (16, 16)
@ComputeShader V_BloomDownCS (16, 16) @Shader V_BloomDownCS (16, 16)
@ComputeShader V_BloomUpCS (16, 16) @Shader V_BloomUpCS (16, 16)
@ComputeShader V_FinalizeCS (16, 16) @Shader V_FinalizeCS (16, 16)
@VertexShader V_DVertVS @Shader V_DVertVS Vertex
@PixelShader V_DVertPS @Shader V_DVertPS Pixel
////////////////////////////// //////////////////////////////
//- Api //- Api

6
src/proto/proto.lay
View File

@ -9,9 +9,9 @@
////////////////////////////// //////////////////////////////
//- Resources //- Resources
@ComputeShader PT_TestCS (8, 8) @Shader PT_TestCS (8, 8)
@VertexShader PT_BlitVS @Shader PT_BlitVS Vertex
@PixelShader PT_BlitPS @Shader PT_BlitPS Pixel
////////////////////////////// //////////////////////////////
//- Api //- Api

4
src/ui/ui.lay
View File

@ -12,8 +12,8 @@
@EmbedDir UI_Resources ui_res @EmbedDir UI_Resources ui_res
@VertexShader UI_DRectVS @Shader UI_DRectVS Vertex
@PixelShader UI_DRectPS @Shader UI_DRectPS Pixel
////////////////////////////// //////////////////////////////
//- Api //- Api