TsundereStation/data/shaders/vulkan/batch.vert.glsl

154 lines
6.4 KiB
Text
Raw Normal View History

common/vulkan, core: pre-bake batch VS (18-blob template, 2 spec consts) Patch 12 in the glslang-elimination series, and the first step into Bucket B (batch shaders). The batch VS state space has three SPIR-V- structurally-distinct axes that specialisation constants cannot fold: 1. Vertex attribute layout. 2 inputs (untextured), 4 (textured without UV limits) or 5 (textured with UV limits). The 'in <type> <name>' declarations are part of the SPIR-V module interface. 2. Output interpolation qualifier on the v_col0 / v_tex0 outputs. None / centroid / sample, selected per session by UsingMSAA() / UsingPerSampleShading(). These compile to OpMemberDecorate Centroid / Sample on the VertexData output block, which is not a spec-constant-controllable property of the SPIR-V module. 3. Color output perspective. m_disable_color_perspective toggles a 'noperspective' qualifier on v_col0, compiling to OpMemberDecorate NoPerspective. 3 x 3 x 2 = 18 structurally distinct blobs. Body-level knobs (RESOLUTION_SCALE, PGXP_DEPTH) are common-knob specialisation constants on every blob (constant_id = 0 and 3 per the project convention). To avoid maintaining 18 hand-edited .glsl files, the source is a single template (data/shaders/vulkan/batch.vert.glsl) with #if guards on TEXTURED, UV_LIMITS, INTERP_CENTROID / INTERP_SAMPLE, and NOPERSP. The regen tool (tools/regen_vulkan_spirv.py) is extended with a TEMPLATE_VARIANTS manifest that compiles the template once per variant with the corresponding -D flags. Build-time impact is zero - the script is still developer-only and the .inc files are checked in. The matching index encoding lives in src/common/vulkan/embedded_- shaders.cpp next to the lookup helper: attr = !textured ? 0 : (uv_limits ? 2 : 1) (0..2) interp = per_sample_shading ? 2 : (msaa ? 1 : 0) (0..2) persp = noperspective_color ? 1 : 0 (0..1) index = attr * 6 + interp * 2 + persp (0..17) The C++ side calls GetBatchVertexShaderBlob with the per-session state (m_using_uv_limits, m_multisamples > 1, m_per_sample_shading, m_disable_color_perspective) and the per-call 'textured' loop variable to pick the right blob in CompilePipelines. The existing m_batch_vertex_shaders[2] cache shape is preserved - the helper just selects which two of the 18 blobs to instantiate this session. Spec constants are applied at PIPELINE-create time inside GetBatchPipeline rather than at module-create time, matching the SpecConstants infrastructure laid down in patch 3. The values are session-constant, so they are the same for every batch pipeline in a session and the driver caches them keyed by (module + spec values) in the pipeline cache. Header-side ergonomics: instead of declaring 36 individual extern arrays (18 SPIR-V + 18 size), the .h declares a small EmbeddedShaderBlob struct and a single k_batch_vs_blobs[18] array, plus the GetBatchVertexShaderBlob helper. The same struct is intended to be reused for the eventual batch FS conversion (likely many more blobs given the texture filter state space). Smoke tests: - g++ -fsyntax-only on the touched common TU. - spirv-val --target-env vulkan1.0 on all 18 blobs - 18/18 valid. - Total .inc size: ~53 KiB across all 18 blobs. - --target-env vulkan1.0 vs un-flagged glslangValidator: byte- identical for every variant. The batch VS is filled in CompilePipelines for all three precompile modes (Enabled, Lazy, Disabled), so this conversion does not change the hot-path-pre-build pattern from the patch 10-fix. The two VS modules are present before any batch draw on every code path. Test priority: - Routine smoke under Enabled / Lazy / Disabled. Any rendering at all exercises both VS modules immediately, so visual regressions show up on the first frame of the first game booted. - SSAA / MSAA round-trip in Disabled mode (per the patch-5-fix protocol), specifically to confirm the structural-blob-pick flips through 'none' -> 'centroid' -> 'sample' interp variants cleanly as m_multisamples changes. - Toggle 'disable color perspective' core option (under Texture Correction) to flip the perspective axis; visual difference is subtle but the blob-pick change is real. - Toggle PGXP Geometry Correction (drives UV_LIMITS via m_using_uv_limits) and PGXP Depth Buffer (drives PGXP_DEPTH spec const) to flip the body and attribute-layout axes. After this lands, the only remaining runtime glslang consumer in the Vulkan backend is the batch FS (GenerateBatchFragmentShader at gpu_hw_shadergen.cpp line ~667). That is a far larger state space - six texture filters x ~14 boolean macros plus the structural USE_DUAL_SOURCE / PALETTE_* axes - and will need to land in several patches, one or two texture filters at a time.
2026-05-17 22:55:46 +00:00
// Pre-baked Vulkan source template for
// GPU_HW_ShaderGen::GenerateBatchVertexShader.
//
// Batch VS is the first of the two batch shaders, and its state space
// has THREE structurally distinct axes that SPIR-V decorations cannot
// be specialised across:
//
core/vulkan: drop the UV_LIMITS attribute-layout VS variant Follow-up to 8b43518 (UV_LIMITS routing for the C++ shadergen, D3D11 / D3D12 / OpenGL only). Vulkan has its own pre-baked SPIR-V pipeline rooted in data/shaders/vulkan/*.glsl, compiled via tools/regen_vulkan_spirv.py, and indexed by per-axis blob tables in src/common/vulkan/embedded_shaders.cpp. This commit parallels the C++ shadergen routing on the VS side: collapses the UV_LIMITS attribute-layout variant from the batch VS so that "textured" always means "textured with v_uv_limits", and the C++ Vulkan input layout binds ATTR4 unconditionally when textured. The FS-side UV_LIMITS axis (the Nearest filter's two-variant nouv / uv expansion) is NOT in this commit. Routing it through a UBO field requires extending the Vulkan batch FS UBO declaration with u_uv_limits, body-level runtime branches, and regenerating the 48 Nearest FS .inc blobs. That is the natural next commit; this one limits the blast radius to the VS side, which is a simpler structural change with fewer downstream touch points. What changes: data/shaders/vulkan/batch.vert.glsl - Drops the #if defined(UV_LIMITS) guards in three sites (a_uv_limits input declaration, v_uv_limits varying output declaration, v_uv_limits assignment in main()). When TEXTURED, a_uv_limits / v_uv_limits are always declared and v_uv_limits is always written. - Header comment updated from "3 attribute layouts" to "2 attribute layouts" and the total variant count from 18 to 12. tools/regen_vulkan_spirv.py - _batch_vs_variants(): drops the third attr_axes entry ("textured_uvlim", ["TEXTURED", "UV_LIMITS"]). The remaining "textured" entry's GLSL output now always includes the a_uv_limits / v_uv_limits declarations because the source-side #if guards are gone, so the single "textured" variant produces the same SPIR-V that "textured_uvlim" used to. Variant count drops from 18 to 12. - The Nearest FS variants table is unchanged (still has the UV_LIMITS axis); collapsing that side is the follow-up. src/common/vulkan/embedded_spirv/ - Six batch_vs_textured_uvlim_*.inc files DELETED (no longer in the regen output set). - Six batch_vs_textured_*.inc files REGENERATED with the new GLSL that always emits a_uv_limits / v_uv_limits. Content shape: same length / structure as the old "textured_uvlim" .inc files (since both correspond to the "textured + UV_LIMITS" build); the OLD plain "textured" .inc files (the smaller no-UV variant) are effectively replaced. - Other 169 blobs untouched. Total goes 181 -> 175. src/common/vulkan/embedded_shaders.{h,cpp} - k_batch_vs_blobs[18] -> k_batch_vs_blobs[12]. The table loses the "attr = 1 (textured, no UV limits)" block; the surviving "attr = 1" block is what used to be "attr = 2 (textured + UV limits)", just renamed for cleaner end state. - GetBatchVertexShaderBlob() drops the bool uv_limits parameter. Index encoding becomes attr = textured ? 1 : 0 (was: !textured ? 0 : (uv_limits ? 2 : 1)) Same interp / persp arithmetic. - Header docstring and #include block updated to match (six fewer #includes; the six uvlim ones). src/core/gpu_hw_vulkan.cpp - The single GetBatchVertexShaderBlob() call site at the CompilePipelines VS-fill loop drops its second argument (m_using_uv_limits) so the new four-arg signature is satisfied. - The input-layout builder at the per-pipeline gpbuilder.AddVertexAttribute(4, ...) site drops its `if (m_using_uv_limits)` guard. ATTR4 / a_uv_limits is now bound unconditionally when textured, matching the always-emitted shader input. BatchVertex carries the uv_limits field unconditionally (gpu_hw.h:47), so the binding always points at valid memory; the FS-side u_uv_limits scalar still decides whether the value is meaningful. What does NOT change in this commit: - The Vulkan batch FS Nearest variants still have UV_LIMITS as a build axis. m_using_uv_limits is still threaded to the FS blob lookup at gpu_hw_vulkan.cpp:2139 (now line ~2140 after the diff). The Nearest FS GLSL still has #if defined(UV_LIMITS) guards. The 48 nearest_uv / nearest_nouv blobs remain. Routing that side is the natural next commit; the delta there is much larger (48 blobs, FS UBO grows, runtime branch in the Nearest body). - m_using_uv_limits STAYS in shader_source_changed across backends. Vulkan still needs it to pick the right Nearest FS blob, so the rebuild trigger has to stay until the Nearest FS routing also lands. - m_using_uv_limits STAYS as a member field. Still drives the per-vertex ComputePolygonUVLimits decision (gpu_hw.cpp:740) and still passed into the FS variant lookup. The VS lookup no longer takes it. - Bilinear / JINC2 / xBR FS templates: untouched. They already assumed UV_LIMITS via the settings-layer ShouldUseUVLimits() coupling (TEXTURE_FILTERING != Nearest implies m_using_uv_limits = true), so they never had a UV_LIMITS variant axis to collapse. Variant-count delta: Batch VS: 18 -> 12 SPIR-V blobs. Pipeline cache footprint drops by 6 VS pipelines per (filter, render, texture) cell pair (filter side is per-FS so doesn't multiply VS directly, but the VkPipeline cache key combines them and 6 fewer VS blobs mean 6 fewer paths through the pipeline-create call). Disk SPIR-V footprint: Before: 181 .inc files, 13 MiB total. After: 175 .inc files, 13 MiB - ~120 KiB = ~12.9 MiB. (Six VS blobs at ~120 KiB each, ~2-2.5 KiB SPIR-V plus the C-array boilerplate.) Cost matrix delta (Vulkan): UV_LIMITS flip mid-session (in practice triggered by PGXP toggle or filter cross-Nearest transition, both of which separately trigger m_using_uv_limits flips): Pre-commit: VS pipeline-cache lookup picks a different blob from the 18-entry table on flip. Pipeline creation cost on cold cache: ~2 vkCreateGraphicsPipelines for the two new (textured, textured_uvlim) VS variants if both end up needed. Post-commit: VS pipeline-cache lookup is invariant under m_using_uv_limits at the VS axis; the FS axis still flips. Saves ~2 cold VS pipeline creates on the toggle. Symbolic (small absolute cost) but it unlocks the next Nearest-FS routing commit, which is the actual large win on the Vulkan side. Cold launch (precompile pass): 6 fewer VS pipelines to enumerate / create. Probably tens of ms on cold cache. Steady-state runtime cost: unchanged. The VS uniform always-emits-v_uv_limits adds one MUL per vertex and one vec4 of interpolant bandwidth, both sub-noise. Test: - Build: tools/regen_vulkan_spirv.py runs cleanly with glslangValidator from the Vulkan SDK / glslang-tools package, producing 175 blobs. The Vulkan backend builds and links against the smaller blob table. - Boot any PSX title with PGXP off + filter Nearest: untextured / textured paths render identically. The "textured" VS variant is now the always-UV blob; BatchVertex.uv_limits is zero on these vertices (no ComputePolygonUVLimits ran), v_uv_limits is propagated as zero, and the Nearest FS (still UV_LIMITS-keyed in this commit) picks its "nouv" variant. - Toggle PGXP on or filter to Bilinear: m_using_uv_limits flips to true, the Nearest FS picks its "uv" variant, the VS variant is still the same (post-commit there's only one textured VS variant). Output identical to pre-commit equivalent state. - Spec const flips (PGXP_DEPTH, RESOLUTION_SCALE) at pipeline-create time: still produce the right pipeline via the smaller blob table. Next: - Vulkan Nearest FS UV_LIMITS routing: extend Vulkan FS UBO with u_uv_limits, drop the #if defined(UV_LIMITS) guards from batch_textured_nearest.frag.glsl, runtime branch in the body, regen 48 -> 24 Nearest FS blobs, drop m_using_uv_limits from the FS lookup + shader_source_changed. After that, all backends have UV_LIMITS fully routed. - PGXP_DEPTH for the FS (always-emit SV_Depth / FragDepth perf measurement first). - Pre-bake commits once remaining axes are decided.
2026-05-19 00:48:57 +00:00
// - Vertex attribute layout. 2 input attributes (untextured) or 5
// (textured: pos, col, texcoord, texpage, uv_limits). UV_LIMITS
// used to be a third attribute-layout variant gating a_uv_limits;
// it is now routed via the FS-side u_uv_limits cbuffer scalar so
// the VS unconditionally emits a_uv_limits + v_uv_limits when
// textured. The 'in <type> <name>' declarations are part of the
// SPIR-V module interface, not a spec-constant-controlled knob.
common/vulkan, core: pre-bake batch VS (18-blob template, 2 spec consts) Patch 12 in the glslang-elimination series, and the first step into Bucket B (batch shaders). The batch VS state space has three SPIR-V- structurally-distinct axes that specialisation constants cannot fold: 1. Vertex attribute layout. 2 inputs (untextured), 4 (textured without UV limits) or 5 (textured with UV limits). The 'in <type> <name>' declarations are part of the SPIR-V module interface. 2. Output interpolation qualifier on the v_col0 / v_tex0 outputs. None / centroid / sample, selected per session by UsingMSAA() / UsingPerSampleShading(). These compile to OpMemberDecorate Centroid / Sample on the VertexData output block, which is not a spec-constant-controllable property of the SPIR-V module. 3. Color output perspective. m_disable_color_perspective toggles a 'noperspective' qualifier on v_col0, compiling to OpMemberDecorate NoPerspective. 3 x 3 x 2 = 18 structurally distinct blobs. Body-level knobs (RESOLUTION_SCALE, PGXP_DEPTH) are common-knob specialisation constants on every blob (constant_id = 0 and 3 per the project convention). To avoid maintaining 18 hand-edited .glsl files, the source is a single template (data/shaders/vulkan/batch.vert.glsl) with #if guards on TEXTURED, UV_LIMITS, INTERP_CENTROID / INTERP_SAMPLE, and NOPERSP. The regen tool (tools/regen_vulkan_spirv.py) is extended with a TEMPLATE_VARIANTS manifest that compiles the template once per variant with the corresponding -D flags. Build-time impact is zero - the script is still developer-only and the .inc files are checked in. The matching index encoding lives in src/common/vulkan/embedded_- shaders.cpp next to the lookup helper: attr = !textured ? 0 : (uv_limits ? 2 : 1) (0..2) interp = per_sample_shading ? 2 : (msaa ? 1 : 0) (0..2) persp = noperspective_color ? 1 : 0 (0..1) index = attr * 6 + interp * 2 + persp (0..17) The C++ side calls GetBatchVertexShaderBlob with the per-session state (m_using_uv_limits, m_multisamples > 1, m_per_sample_shading, m_disable_color_perspective) and the per-call 'textured' loop variable to pick the right blob in CompilePipelines. The existing m_batch_vertex_shaders[2] cache shape is preserved - the helper just selects which two of the 18 blobs to instantiate this session. Spec constants are applied at PIPELINE-create time inside GetBatchPipeline rather than at module-create time, matching the SpecConstants infrastructure laid down in patch 3. The values are session-constant, so they are the same for every batch pipeline in a session and the driver caches them keyed by (module + spec values) in the pipeline cache. Header-side ergonomics: instead of declaring 36 individual extern arrays (18 SPIR-V + 18 size), the .h declares a small EmbeddedShaderBlob struct and a single k_batch_vs_blobs[18] array, plus the GetBatchVertexShaderBlob helper. The same struct is intended to be reused for the eventual batch FS conversion (likely many more blobs given the texture filter state space). Smoke tests: - g++ -fsyntax-only on the touched common TU. - spirv-val --target-env vulkan1.0 on all 18 blobs - 18/18 valid. - Total .inc size: ~53 KiB across all 18 blobs. - --target-env vulkan1.0 vs un-flagged glslangValidator: byte- identical for every variant. The batch VS is filled in CompilePipelines for all three precompile modes (Enabled, Lazy, Disabled), so this conversion does not change the hot-path-pre-build pattern from the patch 10-fix. The two VS modules are present before any batch draw on every code path. Test priority: - Routine smoke under Enabled / Lazy / Disabled. Any rendering at all exercises both VS modules immediately, so visual regressions show up on the first frame of the first game booted. - SSAA / MSAA round-trip in Disabled mode (per the patch-5-fix protocol), specifically to confirm the structural-blob-pick flips through 'none' -> 'centroid' -> 'sample' interp variants cleanly as m_multisamples changes. - Toggle 'disable color perspective' core option (under Texture Correction) to flip the perspective axis; visual difference is subtle but the blob-pick change is real. - Toggle PGXP Geometry Correction (drives UV_LIMITS via m_using_uv_limits) and PGXP Depth Buffer (drives PGXP_DEPTH spec const) to flip the body and attribute-layout axes. After this lands, the only remaining runtime glslang consumer in the Vulkan backend is the batch FS (GenerateBatchFragmentShader at gpu_hw_shadergen.cpp line ~667). That is a far larger state space - six texture filters x ~14 boolean macros plus the structural USE_DUAL_SOURCE / PALETTE_* axes - and will need to land in several patches, one or two texture filters at a time.
2026-05-17 22:55:46 +00:00
//
// - Output interpolation qualifier. The fragment shader pairs with
// these and the qualifiers compile to OpMemberDecorate Sample /
// Centroid in the output VertexData block. There are three
// mutually exclusive states (no qualifier, centroid, sample),
// selected per session by UsingMSAA() and UsingPerSampleShading().
//
// - Color output perspective. The 'noperspective' qualifier on
// v_col0 compiles to OpMemberDecorate NoPerspective, again not
// spec-constant-controllable. Two states, selected per session by
// m_disable_color_perspective.
//
core/vulkan: drop the UV_LIMITS attribute-layout VS variant Follow-up to 8b43518 (UV_LIMITS routing for the C++ shadergen, D3D11 / D3D12 / OpenGL only). Vulkan has its own pre-baked SPIR-V pipeline rooted in data/shaders/vulkan/*.glsl, compiled via tools/regen_vulkan_spirv.py, and indexed by per-axis blob tables in src/common/vulkan/embedded_shaders.cpp. This commit parallels the C++ shadergen routing on the VS side: collapses the UV_LIMITS attribute-layout variant from the batch VS so that "textured" always means "textured with v_uv_limits", and the C++ Vulkan input layout binds ATTR4 unconditionally when textured. The FS-side UV_LIMITS axis (the Nearest filter's two-variant nouv / uv expansion) is NOT in this commit. Routing it through a UBO field requires extending the Vulkan batch FS UBO declaration with u_uv_limits, body-level runtime branches, and regenerating the 48 Nearest FS .inc blobs. That is the natural next commit; this one limits the blast radius to the VS side, which is a simpler structural change with fewer downstream touch points. What changes: data/shaders/vulkan/batch.vert.glsl - Drops the #if defined(UV_LIMITS) guards in three sites (a_uv_limits input declaration, v_uv_limits varying output declaration, v_uv_limits assignment in main()). When TEXTURED, a_uv_limits / v_uv_limits are always declared and v_uv_limits is always written. - Header comment updated from "3 attribute layouts" to "2 attribute layouts" and the total variant count from 18 to 12. tools/regen_vulkan_spirv.py - _batch_vs_variants(): drops the third attr_axes entry ("textured_uvlim", ["TEXTURED", "UV_LIMITS"]). The remaining "textured" entry's GLSL output now always includes the a_uv_limits / v_uv_limits declarations because the source-side #if guards are gone, so the single "textured" variant produces the same SPIR-V that "textured_uvlim" used to. Variant count drops from 18 to 12. - The Nearest FS variants table is unchanged (still has the UV_LIMITS axis); collapsing that side is the follow-up. src/common/vulkan/embedded_spirv/ - Six batch_vs_textured_uvlim_*.inc files DELETED (no longer in the regen output set). - Six batch_vs_textured_*.inc files REGENERATED with the new GLSL that always emits a_uv_limits / v_uv_limits. Content shape: same length / structure as the old "textured_uvlim" .inc files (since both correspond to the "textured + UV_LIMITS" build); the OLD plain "textured" .inc files (the smaller no-UV variant) are effectively replaced. - Other 169 blobs untouched. Total goes 181 -> 175. src/common/vulkan/embedded_shaders.{h,cpp} - k_batch_vs_blobs[18] -> k_batch_vs_blobs[12]. The table loses the "attr = 1 (textured, no UV limits)" block; the surviving "attr = 1" block is what used to be "attr = 2 (textured + UV limits)", just renamed for cleaner end state. - GetBatchVertexShaderBlob() drops the bool uv_limits parameter. Index encoding becomes attr = textured ? 1 : 0 (was: !textured ? 0 : (uv_limits ? 2 : 1)) Same interp / persp arithmetic. - Header docstring and #include block updated to match (six fewer #includes; the six uvlim ones). src/core/gpu_hw_vulkan.cpp - The single GetBatchVertexShaderBlob() call site at the CompilePipelines VS-fill loop drops its second argument (m_using_uv_limits) so the new four-arg signature is satisfied. - The input-layout builder at the per-pipeline gpbuilder.AddVertexAttribute(4, ...) site drops its `if (m_using_uv_limits)` guard. ATTR4 / a_uv_limits is now bound unconditionally when textured, matching the always-emitted shader input. BatchVertex carries the uv_limits field unconditionally (gpu_hw.h:47), so the binding always points at valid memory; the FS-side u_uv_limits scalar still decides whether the value is meaningful. What does NOT change in this commit: - The Vulkan batch FS Nearest variants still have UV_LIMITS as a build axis. m_using_uv_limits is still threaded to the FS blob lookup at gpu_hw_vulkan.cpp:2139 (now line ~2140 after the diff). The Nearest FS GLSL still has #if defined(UV_LIMITS) guards. The 48 nearest_uv / nearest_nouv blobs remain. Routing that side is the natural next commit; the delta there is much larger (48 blobs, FS UBO grows, runtime branch in the Nearest body). - m_using_uv_limits STAYS in shader_source_changed across backends. Vulkan still needs it to pick the right Nearest FS blob, so the rebuild trigger has to stay until the Nearest FS routing also lands. - m_using_uv_limits STAYS as a member field. Still drives the per-vertex ComputePolygonUVLimits decision (gpu_hw.cpp:740) and still passed into the FS variant lookup. The VS lookup no longer takes it. - Bilinear / JINC2 / xBR FS templates: untouched. They already assumed UV_LIMITS via the settings-layer ShouldUseUVLimits() coupling (TEXTURE_FILTERING != Nearest implies m_using_uv_limits = true), so they never had a UV_LIMITS variant axis to collapse. Variant-count delta: Batch VS: 18 -> 12 SPIR-V blobs. Pipeline cache footprint drops by 6 VS pipelines per (filter, render, texture) cell pair (filter side is per-FS so doesn't multiply VS directly, but the VkPipeline cache key combines them and 6 fewer VS blobs mean 6 fewer paths through the pipeline-create call). Disk SPIR-V footprint: Before: 181 .inc files, 13 MiB total. After: 175 .inc files, 13 MiB - ~120 KiB = ~12.9 MiB. (Six VS blobs at ~120 KiB each, ~2-2.5 KiB SPIR-V plus the C-array boilerplate.) Cost matrix delta (Vulkan): UV_LIMITS flip mid-session (in practice triggered by PGXP toggle or filter cross-Nearest transition, both of which separately trigger m_using_uv_limits flips): Pre-commit: VS pipeline-cache lookup picks a different blob from the 18-entry table on flip. Pipeline creation cost on cold cache: ~2 vkCreateGraphicsPipelines for the two new (textured, textured_uvlim) VS variants if both end up needed. Post-commit: VS pipeline-cache lookup is invariant under m_using_uv_limits at the VS axis; the FS axis still flips. Saves ~2 cold VS pipeline creates on the toggle. Symbolic (small absolute cost) but it unlocks the next Nearest-FS routing commit, which is the actual large win on the Vulkan side. Cold launch (precompile pass): 6 fewer VS pipelines to enumerate / create. Probably tens of ms on cold cache. Steady-state runtime cost: unchanged. The VS uniform always-emits-v_uv_limits adds one MUL per vertex and one vec4 of interpolant bandwidth, both sub-noise. Test: - Build: tools/regen_vulkan_spirv.py runs cleanly with glslangValidator from the Vulkan SDK / glslang-tools package, producing 175 blobs. The Vulkan backend builds and links against the smaller blob table. - Boot any PSX title with PGXP off + filter Nearest: untextured / textured paths render identically. The "textured" VS variant is now the always-UV blob; BatchVertex.uv_limits is zero on these vertices (no ComputePolygonUVLimits ran), v_uv_limits is propagated as zero, and the Nearest FS (still UV_LIMITS-keyed in this commit) picks its "nouv" variant. - Toggle PGXP on or filter to Bilinear: m_using_uv_limits flips to true, the Nearest FS picks its "uv" variant, the VS variant is still the same (post-commit there's only one textured VS variant). Output identical to pre-commit equivalent state. - Spec const flips (PGXP_DEPTH, RESOLUTION_SCALE) at pipeline-create time: still produce the right pipeline via the smaller blob table. Next: - Vulkan Nearest FS UV_LIMITS routing: extend Vulkan FS UBO with u_uv_limits, drop the #if defined(UV_LIMITS) guards from batch_textured_nearest.frag.glsl, runtime branch in the body, regen 48 -> 24 Nearest FS blobs, drop m_using_uv_limits from the FS lookup + shader_source_changed. After that, all backends have UV_LIMITS fully routed. - PGXP_DEPTH for the FS (always-emit SV_Depth / FragDepth perf measurement first). - Pre-bake commits once remaining axes are decided.
2026-05-19 00:48:57 +00:00
// Total structural variant count: 2 (attribute layouts) x 3
// (interpolation) x 2 (perspective) = 12. Body-level knobs that do
common/vulkan, core: pre-bake batch VS (18-blob template, 2 spec consts) Patch 12 in the glslang-elimination series, and the first step into Bucket B (batch shaders). The batch VS state space has three SPIR-V- structurally-distinct axes that specialisation constants cannot fold: 1. Vertex attribute layout. 2 inputs (untextured), 4 (textured without UV limits) or 5 (textured with UV limits). The 'in <type> <name>' declarations are part of the SPIR-V module interface. 2. Output interpolation qualifier on the v_col0 / v_tex0 outputs. None / centroid / sample, selected per session by UsingMSAA() / UsingPerSampleShading(). These compile to OpMemberDecorate Centroid / Sample on the VertexData output block, which is not a spec-constant-controllable property of the SPIR-V module. 3. Color output perspective. m_disable_color_perspective toggles a 'noperspective' qualifier on v_col0, compiling to OpMemberDecorate NoPerspective. 3 x 3 x 2 = 18 structurally distinct blobs. Body-level knobs (RESOLUTION_SCALE, PGXP_DEPTH) are common-knob specialisation constants on every blob (constant_id = 0 and 3 per the project convention). To avoid maintaining 18 hand-edited .glsl files, the source is a single template (data/shaders/vulkan/batch.vert.glsl) with #if guards on TEXTURED, UV_LIMITS, INTERP_CENTROID / INTERP_SAMPLE, and NOPERSP. The regen tool (tools/regen_vulkan_spirv.py) is extended with a TEMPLATE_VARIANTS manifest that compiles the template once per variant with the corresponding -D flags. Build-time impact is zero - the script is still developer-only and the .inc files are checked in. The matching index encoding lives in src/common/vulkan/embedded_- shaders.cpp next to the lookup helper: attr = !textured ? 0 : (uv_limits ? 2 : 1) (0..2) interp = per_sample_shading ? 2 : (msaa ? 1 : 0) (0..2) persp = noperspective_color ? 1 : 0 (0..1) index = attr * 6 + interp * 2 + persp (0..17) The C++ side calls GetBatchVertexShaderBlob with the per-session state (m_using_uv_limits, m_multisamples > 1, m_per_sample_shading, m_disable_color_perspective) and the per-call 'textured' loop variable to pick the right blob in CompilePipelines. The existing m_batch_vertex_shaders[2] cache shape is preserved - the helper just selects which two of the 18 blobs to instantiate this session. Spec constants are applied at PIPELINE-create time inside GetBatchPipeline rather than at module-create time, matching the SpecConstants infrastructure laid down in patch 3. The values are session-constant, so they are the same for every batch pipeline in a session and the driver caches them keyed by (module + spec values) in the pipeline cache. Header-side ergonomics: instead of declaring 36 individual extern arrays (18 SPIR-V + 18 size), the .h declares a small EmbeddedShaderBlob struct and a single k_batch_vs_blobs[18] array, plus the GetBatchVertexShaderBlob helper. The same struct is intended to be reused for the eventual batch FS conversion (likely many more blobs given the texture filter state space). Smoke tests: - g++ -fsyntax-only on the touched common TU. - spirv-val --target-env vulkan1.0 on all 18 blobs - 18/18 valid. - Total .inc size: ~53 KiB across all 18 blobs. - --target-env vulkan1.0 vs un-flagged glslangValidator: byte- identical for every variant. The batch VS is filled in CompilePipelines for all three precompile modes (Enabled, Lazy, Disabled), so this conversion does not change the hot-path-pre-build pattern from the patch 10-fix. The two VS modules are present before any batch draw on every code path. Test priority: - Routine smoke under Enabled / Lazy / Disabled. Any rendering at all exercises both VS modules immediately, so visual regressions show up on the first frame of the first game booted. - SSAA / MSAA round-trip in Disabled mode (per the patch-5-fix protocol), specifically to confirm the structural-blob-pick flips through 'none' -> 'centroid' -> 'sample' interp variants cleanly as m_multisamples changes. - Toggle 'disable color perspective' core option (under Texture Correction) to flip the perspective axis; visual difference is subtle but the blob-pick change is real. - Toggle PGXP Geometry Correction (drives UV_LIMITS via m_using_uv_limits) and PGXP Depth Buffer (drives PGXP_DEPTH spec const) to flip the body and attribute-layout axes. After this lands, the only remaining runtime glslang consumer in the Vulkan backend is the batch FS (GenerateBatchFragmentShader at gpu_hw_shadergen.cpp line ~667). That is a far larger state space - six texture filters x ~14 boolean macros plus the structural USE_DUAL_SOURCE / PALETTE_* axes - and will need to land in several patches, one or two texture filters at a time.
2026-05-17 22:55:46 +00:00
// not affect decorations (PGXP_DEPTH, RESOLUTION_SCALE) are handled
// as specialisation constants on every blob.
//
// This file is the SINGLE GLSL source. The regen tool compiles it
core/vulkan: drop the UV_LIMITS attribute-layout VS variant Follow-up to 8b43518 (UV_LIMITS routing for the C++ shadergen, D3D11 / D3D12 / OpenGL only). Vulkan has its own pre-baked SPIR-V pipeline rooted in data/shaders/vulkan/*.glsl, compiled via tools/regen_vulkan_spirv.py, and indexed by per-axis blob tables in src/common/vulkan/embedded_shaders.cpp. This commit parallels the C++ shadergen routing on the VS side: collapses the UV_LIMITS attribute-layout variant from the batch VS so that "textured" always means "textured with v_uv_limits", and the C++ Vulkan input layout binds ATTR4 unconditionally when textured. The FS-side UV_LIMITS axis (the Nearest filter's two-variant nouv / uv expansion) is NOT in this commit. Routing it through a UBO field requires extending the Vulkan batch FS UBO declaration with u_uv_limits, body-level runtime branches, and regenerating the 48 Nearest FS .inc blobs. That is the natural next commit; this one limits the blast radius to the VS side, which is a simpler structural change with fewer downstream touch points. What changes: data/shaders/vulkan/batch.vert.glsl - Drops the #if defined(UV_LIMITS) guards in three sites (a_uv_limits input declaration, v_uv_limits varying output declaration, v_uv_limits assignment in main()). When TEXTURED, a_uv_limits / v_uv_limits are always declared and v_uv_limits is always written. - Header comment updated from "3 attribute layouts" to "2 attribute layouts" and the total variant count from 18 to 12. tools/regen_vulkan_spirv.py - _batch_vs_variants(): drops the third attr_axes entry ("textured_uvlim", ["TEXTURED", "UV_LIMITS"]). The remaining "textured" entry's GLSL output now always includes the a_uv_limits / v_uv_limits declarations because the source-side #if guards are gone, so the single "textured" variant produces the same SPIR-V that "textured_uvlim" used to. Variant count drops from 18 to 12. - The Nearest FS variants table is unchanged (still has the UV_LIMITS axis); collapsing that side is the follow-up. src/common/vulkan/embedded_spirv/ - Six batch_vs_textured_uvlim_*.inc files DELETED (no longer in the regen output set). - Six batch_vs_textured_*.inc files REGENERATED with the new GLSL that always emits a_uv_limits / v_uv_limits. Content shape: same length / structure as the old "textured_uvlim" .inc files (since both correspond to the "textured + UV_LIMITS" build); the OLD plain "textured" .inc files (the smaller no-UV variant) are effectively replaced. - Other 169 blobs untouched. Total goes 181 -> 175. src/common/vulkan/embedded_shaders.{h,cpp} - k_batch_vs_blobs[18] -> k_batch_vs_blobs[12]. The table loses the "attr = 1 (textured, no UV limits)" block; the surviving "attr = 1" block is what used to be "attr = 2 (textured + UV limits)", just renamed for cleaner end state. - GetBatchVertexShaderBlob() drops the bool uv_limits parameter. Index encoding becomes attr = textured ? 1 : 0 (was: !textured ? 0 : (uv_limits ? 2 : 1)) Same interp / persp arithmetic. - Header docstring and #include block updated to match (six fewer #includes; the six uvlim ones). src/core/gpu_hw_vulkan.cpp - The single GetBatchVertexShaderBlob() call site at the CompilePipelines VS-fill loop drops its second argument (m_using_uv_limits) so the new four-arg signature is satisfied. - The input-layout builder at the per-pipeline gpbuilder.AddVertexAttribute(4, ...) site drops its `if (m_using_uv_limits)` guard. ATTR4 / a_uv_limits is now bound unconditionally when textured, matching the always-emitted shader input. BatchVertex carries the uv_limits field unconditionally (gpu_hw.h:47), so the binding always points at valid memory; the FS-side u_uv_limits scalar still decides whether the value is meaningful. What does NOT change in this commit: - The Vulkan batch FS Nearest variants still have UV_LIMITS as a build axis. m_using_uv_limits is still threaded to the FS blob lookup at gpu_hw_vulkan.cpp:2139 (now line ~2140 after the diff). The Nearest FS GLSL still has #if defined(UV_LIMITS) guards. The 48 nearest_uv / nearest_nouv blobs remain. Routing that side is the natural next commit; the delta there is much larger (48 blobs, FS UBO grows, runtime branch in the Nearest body). - m_using_uv_limits STAYS in shader_source_changed across backends. Vulkan still needs it to pick the right Nearest FS blob, so the rebuild trigger has to stay until the Nearest FS routing also lands. - m_using_uv_limits STAYS as a member field. Still drives the per-vertex ComputePolygonUVLimits decision (gpu_hw.cpp:740) and still passed into the FS variant lookup. The VS lookup no longer takes it. - Bilinear / JINC2 / xBR FS templates: untouched. They already assumed UV_LIMITS via the settings-layer ShouldUseUVLimits() coupling (TEXTURE_FILTERING != Nearest implies m_using_uv_limits = true), so they never had a UV_LIMITS variant axis to collapse. Variant-count delta: Batch VS: 18 -> 12 SPIR-V blobs. Pipeline cache footprint drops by 6 VS pipelines per (filter, render, texture) cell pair (filter side is per-FS so doesn't multiply VS directly, but the VkPipeline cache key combines them and 6 fewer VS blobs mean 6 fewer paths through the pipeline-create call). Disk SPIR-V footprint: Before: 181 .inc files, 13 MiB total. After: 175 .inc files, 13 MiB - ~120 KiB = ~12.9 MiB. (Six VS blobs at ~120 KiB each, ~2-2.5 KiB SPIR-V plus the C-array boilerplate.) Cost matrix delta (Vulkan): UV_LIMITS flip mid-session (in practice triggered by PGXP toggle or filter cross-Nearest transition, both of which separately trigger m_using_uv_limits flips): Pre-commit: VS pipeline-cache lookup picks a different blob from the 18-entry table on flip. Pipeline creation cost on cold cache: ~2 vkCreateGraphicsPipelines for the two new (textured, textured_uvlim) VS variants if both end up needed. Post-commit: VS pipeline-cache lookup is invariant under m_using_uv_limits at the VS axis; the FS axis still flips. Saves ~2 cold VS pipeline creates on the toggle. Symbolic (small absolute cost) but it unlocks the next Nearest-FS routing commit, which is the actual large win on the Vulkan side. Cold launch (precompile pass): 6 fewer VS pipelines to enumerate / create. Probably tens of ms on cold cache. Steady-state runtime cost: unchanged. The VS uniform always-emits-v_uv_limits adds one MUL per vertex and one vec4 of interpolant bandwidth, both sub-noise. Test: - Build: tools/regen_vulkan_spirv.py runs cleanly with glslangValidator from the Vulkan SDK / glslang-tools package, producing 175 blobs. The Vulkan backend builds and links against the smaller blob table. - Boot any PSX title with PGXP off + filter Nearest: untextured / textured paths render identically. The "textured" VS variant is now the always-UV blob; BatchVertex.uv_limits is zero on these vertices (no ComputePolygonUVLimits ran), v_uv_limits is propagated as zero, and the Nearest FS (still UV_LIMITS-keyed in this commit) picks its "nouv" variant. - Toggle PGXP on or filter to Bilinear: m_using_uv_limits flips to true, the Nearest FS picks its "uv" variant, the VS variant is still the same (post-commit there's only one textured VS variant). Output identical to pre-commit equivalent state. - Spec const flips (PGXP_DEPTH, RESOLUTION_SCALE) at pipeline-create time: still produce the right pipeline via the smaller blob table. Next: - Vulkan Nearest FS UV_LIMITS routing: extend Vulkan FS UBO with u_uv_limits, drop the #if defined(UV_LIMITS) guards from batch_textured_nearest.frag.glsl, runtime branch in the body, regen 48 -> 24 Nearest FS blobs, drop m_using_uv_limits from the FS lookup + shader_source_changed. After that, all backends have UV_LIMITS fully routed. - PGXP_DEPTH for the FS (always-emit SV_Depth / FragDepth perf measurement first). - Pre-bake commits once remaining axes are decided.
2026-05-19 00:48:57 +00:00
// twelve times with different -D combinations to produce the
common/vulkan, core: pre-bake batch VS (18-blob template, 2 spec consts) Patch 12 in the glslang-elimination series, and the first step into Bucket B (batch shaders). The batch VS state space has three SPIR-V- structurally-distinct axes that specialisation constants cannot fold: 1. Vertex attribute layout. 2 inputs (untextured), 4 (textured without UV limits) or 5 (textured with UV limits). The 'in <type> <name>' declarations are part of the SPIR-V module interface. 2. Output interpolation qualifier on the v_col0 / v_tex0 outputs. None / centroid / sample, selected per session by UsingMSAA() / UsingPerSampleShading(). These compile to OpMemberDecorate Centroid / Sample on the VertexData output block, which is not a spec-constant-controllable property of the SPIR-V module. 3. Color output perspective. m_disable_color_perspective toggles a 'noperspective' qualifier on v_col0, compiling to OpMemberDecorate NoPerspective. 3 x 3 x 2 = 18 structurally distinct blobs. Body-level knobs (RESOLUTION_SCALE, PGXP_DEPTH) are common-knob specialisation constants on every blob (constant_id = 0 and 3 per the project convention). To avoid maintaining 18 hand-edited .glsl files, the source is a single template (data/shaders/vulkan/batch.vert.glsl) with #if guards on TEXTURED, UV_LIMITS, INTERP_CENTROID / INTERP_SAMPLE, and NOPERSP. The regen tool (tools/regen_vulkan_spirv.py) is extended with a TEMPLATE_VARIANTS manifest that compiles the template once per variant with the corresponding -D flags. Build-time impact is zero - the script is still developer-only and the .inc files are checked in. The matching index encoding lives in src/common/vulkan/embedded_- shaders.cpp next to the lookup helper: attr = !textured ? 0 : (uv_limits ? 2 : 1) (0..2) interp = per_sample_shading ? 2 : (msaa ? 1 : 0) (0..2) persp = noperspective_color ? 1 : 0 (0..1) index = attr * 6 + interp * 2 + persp (0..17) The C++ side calls GetBatchVertexShaderBlob with the per-session state (m_using_uv_limits, m_multisamples > 1, m_per_sample_shading, m_disable_color_perspective) and the per-call 'textured' loop variable to pick the right blob in CompilePipelines. The existing m_batch_vertex_shaders[2] cache shape is preserved - the helper just selects which two of the 18 blobs to instantiate this session. Spec constants are applied at PIPELINE-create time inside GetBatchPipeline rather than at module-create time, matching the SpecConstants infrastructure laid down in patch 3. The values are session-constant, so they are the same for every batch pipeline in a session and the driver caches them keyed by (module + spec values) in the pipeline cache. Header-side ergonomics: instead of declaring 36 individual extern arrays (18 SPIR-V + 18 size), the .h declares a small EmbeddedShaderBlob struct and a single k_batch_vs_blobs[18] array, plus the GetBatchVertexShaderBlob helper. The same struct is intended to be reused for the eventual batch FS conversion (likely many more blobs given the texture filter state space). Smoke tests: - g++ -fsyntax-only on the touched common TU. - spirv-val --target-env vulkan1.0 on all 18 blobs - 18/18 valid. - Total .inc size: ~53 KiB across all 18 blobs. - --target-env vulkan1.0 vs un-flagged glslangValidator: byte- identical for every variant. The batch VS is filled in CompilePipelines for all three precompile modes (Enabled, Lazy, Disabled), so this conversion does not change the hot-path-pre-build pattern from the patch 10-fix. The two VS modules are present before any batch draw on every code path. Test priority: - Routine smoke under Enabled / Lazy / Disabled. Any rendering at all exercises both VS modules immediately, so visual regressions show up on the first frame of the first game booted. - SSAA / MSAA round-trip in Disabled mode (per the patch-5-fix protocol), specifically to confirm the structural-blob-pick flips through 'none' -> 'centroid' -> 'sample' interp variants cleanly as m_multisamples changes. - Toggle 'disable color perspective' core option (under Texture Correction) to flip the perspective axis; visual difference is subtle but the blob-pick change is real. - Toggle PGXP Geometry Correction (drives UV_LIMITS via m_using_uv_limits) and PGXP Depth Buffer (drives PGXP_DEPTH spec const) to flip the body and attribute-layout axes. After this lands, the only remaining runtime glslang consumer in the Vulkan backend is the batch FS (GenerateBatchFragmentShader at gpu_hw_shadergen.cpp line ~667). That is a far larger state space - six texture filters x ~14 boolean macros plus the structural USE_DUAL_SOURCE / PALETTE_* axes - and will need to land in several patches, one or two texture filters at a time.
2026-05-17 22:55:46 +00:00
// matching .inc blobs; the manifest of variants lives in
core/vulkan: drop the UV_LIMITS attribute-layout VS variant Follow-up to 8b43518 (UV_LIMITS routing for the C++ shadergen, D3D11 / D3D12 / OpenGL only). Vulkan has its own pre-baked SPIR-V pipeline rooted in data/shaders/vulkan/*.glsl, compiled via tools/regen_vulkan_spirv.py, and indexed by per-axis blob tables in src/common/vulkan/embedded_shaders.cpp. This commit parallels the C++ shadergen routing on the VS side: collapses the UV_LIMITS attribute-layout variant from the batch VS so that "textured" always means "textured with v_uv_limits", and the C++ Vulkan input layout binds ATTR4 unconditionally when textured. The FS-side UV_LIMITS axis (the Nearest filter's two-variant nouv / uv expansion) is NOT in this commit. Routing it through a UBO field requires extending the Vulkan batch FS UBO declaration with u_uv_limits, body-level runtime branches, and regenerating the 48 Nearest FS .inc blobs. That is the natural next commit; this one limits the blast radius to the VS side, which is a simpler structural change with fewer downstream touch points. What changes: data/shaders/vulkan/batch.vert.glsl - Drops the #if defined(UV_LIMITS) guards in three sites (a_uv_limits input declaration, v_uv_limits varying output declaration, v_uv_limits assignment in main()). When TEXTURED, a_uv_limits / v_uv_limits are always declared and v_uv_limits is always written. - Header comment updated from "3 attribute layouts" to "2 attribute layouts" and the total variant count from 18 to 12. tools/regen_vulkan_spirv.py - _batch_vs_variants(): drops the third attr_axes entry ("textured_uvlim", ["TEXTURED", "UV_LIMITS"]). The remaining "textured" entry's GLSL output now always includes the a_uv_limits / v_uv_limits declarations because the source-side #if guards are gone, so the single "textured" variant produces the same SPIR-V that "textured_uvlim" used to. Variant count drops from 18 to 12. - The Nearest FS variants table is unchanged (still has the UV_LIMITS axis); collapsing that side is the follow-up. src/common/vulkan/embedded_spirv/ - Six batch_vs_textured_uvlim_*.inc files DELETED (no longer in the regen output set). - Six batch_vs_textured_*.inc files REGENERATED with the new GLSL that always emits a_uv_limits / v_uv_limits. Content shape: same length / structure as the old "textured_uvlim" .inc files (since both correspond to the "textured + UV_LIMITS" build); the OLD plain "textured" .inc files (the smaller no-UV variant) are effectively replaced. - Other 169 blobs untouched. Total goes 181 -> 175. src/common/vulkan/embedded_shaders.{h,cpp} - k_batch_vs_blobs[18] -> k_batch_vs_blobs[12]. The table loses the "attr = 1 (textured, no UV limits)" block; the surviving "attr = 1" block is what used to be "attr = 2 (textured + UV limits)", just renamed for cleaner end state. - GetBatchVertexShaderBlob() drops the bool uv_limits parameter. Index encoding becomes attr = textured ? 1 : 0 (was: !textured ? 0 : (uv_limits ? 2 : 1)) Same interp / persp arithmetic. - Header docstring and #include block updated to match (six fewer #includes; the six uvlim ones). src/core/gpu_hw_vulkan.cpp - The single GetBatchVertexShaderBlob() call site at the CompilePipelines VS-fill loop drops its second argument (m_using_uv_limits) so the new four-arg signature is satisfied. - The input-layout builder at the per-pipeline gpbuilder.AddVertexAttribute(4, ...) site drops its `if (m_using_uv_limits)` guard. ATTR4 / a_uv_limits is now bound unconditionally when textured, matching the always-emitted shader input. BatchVertex carries the uv_limits field unconditionally (gpu_hw.h:47), so the binding always points at valid memory; the FS-side u_uv_limits scalar still decides whether the value is meaningful. What does NOT change in this commit: - The Vulkan batch FS Nearest variants still have UV_LIMITS as a build axis. m_using_uv_limits is still threaded to the FS blob lookup at gpu_hw_vulkan.cpp:2139 (now line ~2140 after the diff). The Nearest FS GLSL still has #if defined(UV_LIMITS) guards. The 48 nearest_uv / nearest_nouv blobs remain. Routing that side is the natural next commit; the delta there is much larger (48 blobs, FS UBO grows, runtime branch in the Nearest body). - m_using_uv_limits STAYS in shader_source_changed across backends. Vulkan still needs it to pick the right Nearest FS blob, so the rebuild trigger has to stay until the Nearest FS routing also lands. - m_using_uv_limits STAYS as a member field. Still drives the per-vertex ComputePolygonUVLimits decision (gpu_hw.cpp:740) and still passed into the FS variant lookup. The VS lookup no longer takes it. - Bilinear / JINC2 / xBR FS templates: untouched. They already assumed UV_LIMITS via the settings-layer ShouldUseUVLimits() coupling (TEXTURE_FILTERING != Nearest implies m_using_uv_limits = true), so they never had a UV_LIMITS variant axis to collapse. Variant-count delta: Batch VS: 18 -> 12 SPIR-V blobs. Pipeline cache footprint drops by 6 VS pipelines per (filter, render, texture) cell pair (filter side is per-FS so doesn't multiply VS directly, but the VkPipeline cache key combines them and 6 fewer VS blobs mean 6 fewer paths through the pipeline-create call). Disk SPIR-V footprint: Before: 181 .inc files, 13 MiB total. After: 175 .inc files, 13 MiB - ~120 KiB = ~12.9 MiB. (Six VS blobs at ~120 KiB each, ~2-2.5 KiB SPIR-V plus the C-array boilerplate.) Cost matrix delta (Vulkan): UV_LIMITS flip mid-session (in practice triggered by PGXP toggle or filter cross-Nearest transition, both of which separately trigger m_using_uv_limits flips): Pre-commit: VS pipeline-cache lookup picks a different blob from the 18-entry table on flip. Pipeline creation cost on cold cache: ~2 vkCreateGraphicsPipelines for the two new (textured, textured_uvlim) VS variants if both end up needed. Post-commit: VS pipeline-cache lookup is invariant under m_using_uv_limits at the VS axis; the FS axis still flips. Saves ~2 cold VS pipeline creates on the toggle. Symbolic (small absolute cost) but it unlocks the next Nearest-FS routing commit, which is the actual large win on the Vulkan side. Cold launch (precompile pass): 6 fewer VS pipelines to enumerate / create. Probably tens of ms on cold cache. Steady-state runtime cost: unchanged. The VS uniform always-emits-v_uv_limits adds one MUL per vertex and one vec4 of interpolant bandwidth, both sub-noise. Test: - Build: tools/regen_vulkan_spirv.py runs cleanly with glslangValidator from the Vulkan SDK / glslang-tools package, producing 175 blobs. The Vulkan backend builds and links against the smaller blob table. - Boot any PSX title with PGXP off + filter Nearest: untextured / textured paths render identically. The "textured" VS variant is now the always-UV blob; BatchVertex.uv_limits is zero on these vertices (no ComputePolygonUVLimits ran), v_uv_limits is propagated as zero, and the Nearest FS (still UV_LIMITS-keyed in this commit) picks its "nouv" variant. - Toggle PGXP on or filter to Bilinear: m_using_uv_limits flips to true, the Nearest FS picks its "uv" variant, the VS variant is still the same (post-commit there's only one textured VS variant). Output identical to pre-commit equivalent state. - Spec const flips (PGXP_DEPTH, RESOLUTION_SCALE) at pipeline-create time: still produce the right pipeline via the smaller blob table. Next: - Vulkan Nearest FS UV_LIMITS routing: extend Vulkan FS UBO with u_uv_limits, drop the #if defined(UV_LIMITS) guards from batch_textured_nearest.frag.glsl, runtime branch in the body, regen 48 -> 24 Nearest FS blobs, drop m_using_uv_limits from the FS lookup + shader_source_changed. After that, all backends have UV_LIMITS fully routed. - PGXP_DEPTH for the FS (always-emit SV_Depth / FragDepth perf measurement first). - Pre-bake commits once remaining axes are decided.
2026-05-19 00:48:57 +00:00
// tools/regen_vulkan_spirv.py. The C++ side picks one of the 12 at
common/vulkan, core: pre-bake batch VS (18-blob template, 2 spec consts) Patch 12 in the glslang-elimination series, and the first step into Bucket B (batch shaders). The batch VS state space has three SPIR-V- structurally-distinct axes that specialisation constants cannot fold: 1. Vertex attribute layout. 2 inputs (untextured), 4 (textured without UV limits) or 5 (textured with UV limits). The 'in <type> <name>' declarations are part of the SPIR-V module interface. 2. Output interpolation qualifier on the v_col0 / v_tex0 outputs. None / centroid / sample, selected per session by UsingMSAA() / UsingPerSampleShading(). These compile to OpMemberDecorate Centroid / Sample on the VertexData output block, which is not a spec-constant-controllable property of the SPIR-V module. 3. Color output perspective. m_disable_color_perspective toggles a 'noperspective' qualifier on v_col0, compiling to OpMemberDecorate NoPerspective. 3 x 3 x 2 = 18 structurally distinct blobs. Body-level knobs (RESOLUTION_SCALE, PGXP_DEPTH) are common-knob specialisation constants on every blob (constant_id = 0 and 3 per the project convention). To avoid maintaining 18 hand-edited .glsl files, the source is a single template (data/shaders/vulkan/batch.vert.glsl) with #if guards on TEXTURED, UV_LIMITS, INTERP_CENTROID / INTERP_SAMPLE, and NOPERSP. The regen tool (tools/regen_vulkan_spirv.py) is extended with a TEMPLATE_VARIANTS manifest that compiles the template once per variant with the corresponding -D flags. Build-time impact is zero - the script is still developer-only and the .inc files are checked in. The matching index encoding lives in src/common/vulkan/embedded_- shaders.cpp next to the lookup helper: attr = !textured ? 0 : (uv_limits ? 2 : 1) (0..2) interp = per_sample_shading ? 2 : (msaa ? 1 : 0) (0..2) persp = noperspective_color ? 1 : 0 (0..1) index = attr * 6 + interp * 2 + persp (0..17) The C++ side calls GetBatchVertexShaderBlob with the per-session state (m_using_uv_limits, m_multisamples > 1, m_per_sample_shading, m_disable_color_perspective) and the per-call 'textured' loop variable to pick the right blob in CompilePipelines. The existing m_batch_vertex_shaders[2] cache shape is preserved - the helper just selects which two of the 18 blobs to instantiate this session. Spec constants are applied at PIPELINE-create time inside GetBatchPipeline rather than at module-create time, matching the SpecConstants infrastructure laid down in patch 3. The values are session-constant, so they are the same for every batch pipeline in a session and the driver caches them keyed by (module + spec values) in the pipeline cache. Header-side ergonomics: instead of declaring 36 individual extern arrays (18 SPIR-V + 18 size), the .h declares a small EmbeddedShaderBlob struct and a single k_batch_vs_blobs[18] array, plus the GetBatchVertexShaderBlob helper. The same struct is intended to be reused for the eventual batch FS conversion (likely many more blobs given the texture filter state space). Smoke tests: - g++ -fsyntax-only on the touched common TU. - spirv-val --target-env vulkan1.0 on all 18 blobs - 18/18 valid. - Total .inc size: ~53 KiB across all 18 blobs. - --target-env vulkan1.0 vs un-flagged glslangValidator: byte- identical for every variant. The batch VS is filled in CompilePipelines for all three precompile modes (Enabled, Lazy, Disabled), so this conversion does not change the hot-path-pre-build pattern from the patch 10-fix. The two VS modules are present before any batch draw on every code path. Test priority: - Routine smoke under Enabled / Lazy / Disabled. Any rendering at all exercises both VS modules immediately, so visual regressions show up on the first frame of the first game booted. - SSAA / MSAA round-trip in Disabled mode (per the patch-5-fix protocol), specifically to confirm the structural-blob-pick flips through 'none' -> 'centroid' -> 'sample' interp variants cleanly as m_multisamples changes. - Toggle 'disable color perspective' core option (under Texture Correction) to flip the perspective axis; visual difference is subtle but the blob-pick change is real. - Toggle PGXP Geometry Correction (drives UV_LIMITS via m_using_uv_limits) and PGXP Depth Buffer (drives PGXP_DEPTH spec const) to flip the body and attribute-layout axes. After this lands, the only remaining runtime glslang consumer in the Vulkan backend is the batch FS (GenerateBatchFragmentShader at gpu_hw_shadergen.cpp line ~667). That is a far larger state space - six texture filters x ~14 boolean macros plus the structural USE_DUAL_SOURCE / PALETTE_* axes - and will need to land in several patches, one or two texture filters at a time.
2026-05-17 22:55:46 +00:00
// pipeline-create time via the helper in embedded_shaders.cpp.
//
// Spec constants (every blob):
// constant_id = 0 RESOLUTION_SCALE (uint, common-knob convention).
// Drives the 1x-resolution vertex-offset gate, the
// upscaled texcoord scaling, and the texpage
// base-coordinate scaling.
// constant_id = 3 PGXP_DEPTH (bool, common-knob convention).
// Selects between mask-bit Z (a_pos.z) and the
// PGXP-replayed perspective-correct depth
// (a_pos.w).
//
// Bindings: vertex inputs only - no descriptor sets, no push
// constants. The pipeline layout is m_batch_pipeline_layout which
// declares one UBO at set=0 binding=0 for the FS; the VS does not
// read it.
#version 450 core
// ---- Specialisation constants (body-level knobs) -------------------
layout(constant_id = 0) const uint RESOLUTION_SCALE = 1u;
layout(constant_id = 3) const bool PGXP_DEPTH = false;
// ---- Interpolation qualifier macros --------------------------------
#if defined(INTERP_SAMPLE)
# define INTERP sample
#elif defined(INTERP_CENTROID)
# define INTERP centroid
#else
# define INTERP
#endif
#if defined(NOPERSP)
# define COLOR_INTERP noperspective INTERP
#else
# define COLOR_INTERP INTERP
#endif
// ---- Vertex inputs (attribute layout axis) -------------------------
layout(location = 0) in vec4 a_pos;
layout(location = 1) in vec4 a_col0;
#if defined(TEXTURED)
layout(location = 2) in uint a_texcoord;
layout(location = 3) in uint a_texpage;
core/vulkan: drop the UV_LIMITS attribute-layout VS variant Follow-up to 8b43518 (UV_LIMITS routing for the C++ shadergen, D3D11 / D3D12 / OpenGL only). Vulkan has its own pre-baked SPIR-V pipeline rooted in data/shaders/vulkan/*.glsl, compiled via tools/regen_vulkan_spirv.py, and indexed by per-axis blob tables in src/common/vulkan/embedded_shaders.cpp. This commit parallels the C++ shadergen routing on the VS side: collapses the UV_LIMITS attribute-layout variant from the batch VS so that "textured" always means "textured with v_uv_limits", and the C++ Vulkan input layout binds ATTR4 unconditionally when textured. The FS-side UV_LIMITS axis (the Nearest filter's two-variant nouv / uv expansion) is NOT in this commit. Routing it through a UBO field requires extending the Vulkan batch FS UBO declaration with u_uv_limits, body-level runtime branches, and regenerating the 48 Nearest FS .inc blobs. That is the natural next commit; this one limits the blast radius to the VS side, which is a simpler structural change with fewer downstream touch points. What changes: data/shaders/vulkan/batch.vert.glsl - Drops the #if defined(UV_LIMITS) guards in three sites (a_uv_limits input declaration, v_uv_limits varying output declaration, v_uv_limits assignment in main()). When TEXTURED, a_uv_limits / v_uv_limits are always declared and v_uv_limits is always written. - Header comment updated from "3 attribute layouts" to "2 attribute layouts" and the total variant count from 18 to 12. tools/regen_vulkan_spirv.py - _batch_vs_variants(): drops the third attr_axes entry ("textured_uvlim", ["TEXTURED", "UV_LIMITS"]). The remaining "textured" entry's GLSL output now always includes the a_uv_limits / v_uv_limits declarations because the source-side #if guards are gone, so the single "textured" variant produces the same SPIR-V that "textured_uvlim" used to. Variant count drops from 18 to 12. - The Nearest FS variants table is unchanged (still has the UV_LIMITS axis); collapsing that side is the follow-up. src/common/vulkan/embedded_spirv/ - Six batch_vs_textured_uvlim_*.inc files DELETED (no longer in the regen output set). - Six batch_vs_textured_*.inc files REGENERATED with the new GLSL that always emits a_uv_limits / v_uv_limits. Content shape: same length / structure as the old "textured_uvlim" .inc files (since both correspond to the "textured + UV_LIMITS" build); the OLD plain "textured" .inc files (the smaller no-UV variant) are effectively replaced. - Other 169 blobs untouched. Total goes 181 -> 175. src/common/vulkan/embedded_shaders.{h,cpp} - k_batch_vs_blobs[18] -> k_batch_vs_blobs[12]. The table loses the "attr = 1 (textured, no UV limits)" block; the surviving "attr = 1" block is what used to be "attr = 2 (textured + UV limits)", just renamed for cleaner end state. - GetBatchVertexShaderBlob() drops the bool uv_limits parameter. Index encoding becomes attr = textured ? 1 : 0 (was: !textured ? 0 : (uv_limits ? 2 : 1)) Same interp / persp arithmetic. - Header docstring and #include block updated to match (six fewer #includes; the six uvlim ones). src/core/gpu_hw_vulkan.cpp - The single GetBatchVertexShaderBlob() call site at the CompilePipelines VS-fill loop drops its second argument (m_using_uv_limits) so the new four-arg signature is satisfied. - The input-layout builder at the per-pipeline gpbuilder.AddVertexAttribute(4, ...) site drops its `if (m_using_uv_limits)` guard. ATTR4 / a_uv_limits is now bound unconditionally when textured, matching the always-emitted shader input. BatchVertex carries the uv_limits field unconditionally (gpu_hw.h:47), so the binding always points at valid memory; the FS-side u_uv_limits scalar still decides whether the value is meaningful. What does NOT change in this commit: - The Vulkan batch FS Nearest variants still have UV_LIMITS as a build axis. m_using_uv_limits is still threaded to the FS blob lookup at gpu_hw_vulkan.cpp:2139 (now line ~2140 after the diff). The Nearest FS GLSL still has #if defined(UV_LIMITS) guards. The 48 nearest_uv / nearest_nouv blobs remain. Routing that side is the natural next commit; the delta there is much larger (48 blobs, FS UBO grows, runtime branch in the Nearest body). - m_using_uv_limits STAYS in shader_source_changed across backends. Vulkan still needs it to pick the right Nearest FS blob, so the rebuild trigger has to stay until the Nearest FS routing also lands. - m_using_uv_limits STAYS as a member field. Still drives the per-vertex ComputePolygonUVLimits decision (gpu_hw.cpp:740) and still passed into the FS variant lookup. The VS lookup no longer takes it. - Bilinear / JINC2 / xBR FS templates: untouched. They already assumed UV_LIMITS via the settings-layer ShouldUseUVLimits() coupling (TEXTURE_FILTERING != Nearest implies m_using_uv_limits = true), so they never had a UV_LIMITS variant axis to collapse. Variant-count delta: Batch VS: 18 -> 12 SPIR-V blobs. Pipeline cache footprint drops by 6 VS pipelines per (filter, render, texture) cell pair (filter side is per-FS so doesn't multiply VS directly, but the VkPipeline cache key combines them and 6 fewer VS blobs mean 6 fewer paths through the pipeline-create call). Disk SPIR-V footprint: Before: 181 .inc files, 13 MiB total. After: 175 .inc files, 13 MiB - ~120 KiB = ~12.9 MiB. (Six VS blobs at ~120 KiB each, ~2-2.5 KiB SPIR-V plus the C-array boilerplate.) Cost matrix delta (Vulkan): UV_LIMITS flip mid-session (in practice triggered by PGXP toggle or filter cross-Nearest transition, both of which separately trigger m_using_uv_limits flips): Pre-commit: VS pipeline-cache lookup picks a different blob from the 18-entry table on flip. Pipeline creation cost on cold cache: ~2 vkCreateGraphicsPipelines for the two new (textured, textured_uvlim) VS variants if both end up needed. Post-commit: VS pipeline-cache lookup is invariant under m_using_uv_limits at the VS axis; the FS axis still flips. Saves ~2 cold VS pipeline creates on the toggle. Symbolic (small absolute cost) but it unlocks the next Nearest-FS routing commit, which is the actual large win on the Vulkan side. Cold launch (precompile pass): 6 fewer VS pipelines to enumerate / create. Probably tens of ms on cold cache. Steady-state runtime cost: unchanged. The VS uniform always-emits-v_uv_limits adds one MUL per vertex and one vec4 of interpolant bandwidth, both sub-noise. Test: - Build: tools/regen_vulkan_spirv.py runs cleanly with glslangValidator from the Vulkan SDK / glslang-tools package, producing 175 blobs. The Vulkan backend builds and links against the smaller blob table. - Boot any PSX title with PGXP off + filter Nearest: untextured / textured paths render identically. The "textured" VS variant is now the always-UV blob; BatchVertex.uv_limits is zero on these vertices (no ComputePolygonUVLimits ran), v_uv_limits is propagated as zero, and the Nearest FS (still UV_LIMITS-keyed in this commit) picks its "nouv" variant. - Toggle PGXP on or filter to Bilinear: m_using_uv_limits flips to true, the Nearest FS picks its "uv" variant, the VS variant is still the same (post-commit there's only one textured VS variant). Output identical to pre-commit equivalent state. - Spec const flips (PGXP_DEPTH, RESOLUTION_SCALE) at pipeline-create time: still produce the right pipeline via the smaller blob table. Next: - Vulkan Nearest FS UV_LIMITS routing: extend Vulkan FS UBO with u_uv_limits, drop the #if defined(UV_LIMITS) guards from batch_textured_nearest.frag.glsl, runtime branch in the body, regen 48 -> 24 Nearest FS blobs, drop m_using_uv_limits from the FS lookup + shader_source_changed. After that, all backends have UV_LIMITS fully routed. - PGXP_DEPTH for the FS (always-emit SV_Depth / FragDepth perf measurement first). - Pre-bake commits once remaining axes are decided.
2026-05-19 00:48:57 +00:00
// a_uv_limits emitted unconditionally when TEXTURED. UV_LIMITS used
// to gate this declaration, matching a separate attribute layout
// variant; routed via the FS-side u_uv_limits cbuffer scalar now,
// so the VS just always passes the value through to v_uv_limits and
// the FS decides at runtime whether to consume it. BatchVertex
// always carries the uv_limits field (gpu_hw.h:47), so the C++
// input layout always has a valid offset to bind ATTR4 to - the
// values are zero when ComputePolygonUVLimits didn't run and the
// FS short-circuits on u_uv_limits in that case.
common/vulkan, core: pre-bake batch VS (18-blob template, 2 spec consts) Patch 12 in the glslang-elimination series, and the first step into Bucket B (batch shaders). The batch VS state space has three SPIR-V- structurally-distinct axes that specialisation constants cannot fold: 1. Vertex attribute layout. 2 inputs (untextured), 4 (textured without UV limits) or 5 (textured with UV limits). The 'in <type> <name>' declarations are part of the SPIR-V module interface. 2. Output interpolation qualifier on the v_col0 / v_tex0 outputs. None / centroid / sample, selected per session by UsingMSAA() / UsingPerSampleShading(). These compile to OpMemberDecorate Centroid / Sample on the VertexData output block, which is not a spec-constant-controllable property of the SPIR-V module. 3. Color output perspective. m_disable_color_perspective toggles a 'noperspective' qualifier on v_col0, compiling to OpMemberDecorate NoPerspective. 3 x 3 x 2 = 18 structurally distinct blobs. Body-level knobs (RESOLUTION_SCALE, PGXP_DEPTH) are common-knob specialisation constants on every blob (constant_id = 0 and 3 per the project convention). To avoid maintaining 18 hand-edited .glsl files, the source is a single template (data/shaders/vulkan/batch.vert.glsl) with #if guards on TEXTURED, UV_LIMITS, INTERP_CENTROID / INTERP_SAMPLE, and NOPERSP. The regen tool (tools/regen_vulkan_spirv.py) is extended with a TEMPLATE_VARIANTS manifest that compiles the template once per variant with the corresponding -D flags. Build-time impact is zero - the script is still developer-only and the .inc files are checked in. The matching index encoding lives in src/common/vulkan/embedded_- shaders.cpp next to the lookup helper: attr = !textured ? 0 : (uv_limits ? 2 : 1) (0..2) interp = per_sample_shading ? 2 : (msaa ? 1 : 0) (0..2) persp = noperspective_color ? 1 : 0 (0..1) index = attr * 6 + interp * 2 + persp (0..17) The C++ side calls GetBatchVertexShaderBlob with the per-session state (m_using_uv_limits, m_multisamples > 1, m_per_sample_shading, m_disable_color_perspective) and the per-call 'textured' loop variable to pick the right blob in CompilePipelines. The existing m_batch_vertex_shaders[2] cache shape is preserved - the helper just selects which two of the 18 blobs to instantiate this session. Spec constants are applied at PIPELINE-create time inside GetBatchPipeline rather than at module-create time, matching the SpecConstants infrastructure laid down in patch 3. The values are session-constant, so they are the same for every batch pipeline in a session and the driver caches them keyed by (module + spec values) in the pipeline cache. Header-side ergonomics: instead of declaring 36 individual extern arrays (18 SPIR-V + 18 size), the .h declares a small EmbeddedShaderBlob struct and a single k_batch_vs_blobs[18] array, plus the GetBatchVertexShaderBlob helper. The same struct is intended to be reused for the eventual batch FS conversion (likely many more blobs given the texture filter state space). Smoke tests: - g++ -fsyntax-only on the touched common TU. - spirv-val --target-env vulkan1.0 on all 18 blobs - 18/18 valid. - Total .inc size: ~53 KiB across all 18 blobs. - --target-env vulkan1.0 vs un-flagged glslangValidator: byte- identical for every variant. The batch VS is filled in CompilePipelines for all three precompile modes (Enabled, Lazy, Disabled), so this conversion does not change the hot-path-pre-build pattern from the patch 10-fix. The two VS modules are present before any batch draw on every code path. Test priority: - Routine smoke under Enabled / Lazy / Disabled. Any rendering at all exercises both VS modules immediately, so visual regressions show up on the first frame of the first game booted. - SSAA / MSAA round-trip in Disabled mode (per the patch-5-fix protocol), specifically to confirm the structural-blob-pick flips through 'none' -> 'centroid' -> 'sample' interp variants cleanly as m_multisamples changes. - Toggle 'disable color perspective' core option (under Texture Correction) to flip the perspective axis; visual difference is subtle but the blob-pick change is real. - Toggle PGXP Geometry Correction (drives UV_LIMITS via m_using_uv_limits) and PGXP Depth Buffer (drives PGXP_DEPTH spec const) to flip the body and attribute-layout axes. After this lands, the only remaining runtime glslang consumer in the Vulkan backend is the batch FS (GenerateBatchFragmentShader at gpu_hw_shadergen.cpp line ~667). That is a far larger state space - six texture filters x ~14 boolean macros plus the structural USE_DUAL_SOURCE / PALETTE_* axes - and will need to land in several patches, one or two texture filters at a time.
2026-05-17 22:55:46 +00:00
layout(location = 4) in vec4 a_uv_limits;
#endif
// ---- Vertex outputs (interpolation + perspective axis) -------------
layout(location = 0) out VertexData {
COLOR_INTERP vec4 v_col0;
#if defined(TEXTURED)
INTERP vec2 v_tex0;
flat uvec4 v_texpage;
flat vec4 v_uv_limits;
#endif
};
// --------------------------------------------------------------------
void main()
{
// 1x-resolution sub-pixel offset matches the shadergen original;
// the >1x case has the offset pre-applied in CPU-side vertex prep,
// so the shader uses 0 there.
float vertex_offset = (RESOLUTION_SCALE == 1u) ? 0.5 : 0.0;
// PSX VRAM addressing is 0..1023 horizontally, mapped to NDC -1..+1.
float pos_x = ((a_pos.x + vertex_offset) / 512.0) - 1.0;
float pos_y = ((a_pos.y + vertex_offset) / -256.0) + 1.0;
// Vulkan flips Y vs GL/D3D; shadergen does this unconditionally
// under #if API_VULKAN. We are Vulkan-only here so it is also
// unconditional.
pos_y = -pos_y;
// Depth source selection. With PGXP enabled and the depth-buffer
// option on, the PGXP path replays a perspective-correct depth in
// a_pos.w and the mask-bit Z slot (a_pos.z) is ignored. Otherwise
// use the conventional mask-bit Z.
float pos_z = PGXP_DEPTH ? a_pos.w : a_pos.z;
float pos_w = a_pos.w;
gl_Position = vec4(pos_x * pos_w, pos_y * pos_w, pos_z * pos_w, pos_w);
v_col0 = a_col0;
#if defined(TEXTURED)
// Texture coordinates are packed into a single uint per vertex
// (lower 16 bits = U, upper 16 bits = V) and scaled by the upscale
// factor to address into the upscaled VRAM atlas.
v_tex0 = vec2(float((a_texcoord & 0xFFFFu) * RESOLUTION_SCALE),
float((a_texcoord >> 16) * RESOLUTION_SCALE));
// a_texpage is similarly packed:
// bits 0..3 page base X (in 64-texel native units)
// bit 4 page base Y (256-texel native unit, 0 or 1)
// bits 16..21 CLUT X (in 16-texel native units)
// bits 22..30 CLUT Y (native rows)
v_texpage.x = ( a_texpage & 15u ) * 64u * RESOLUTION_SCALE;
v_texpage.y = ((a_texpage >> 4) & 1u ) * 256u * RESOLUTION_SCALE;
v_texpage.z = ((a_texpage >> 16) & 63u ) * 16u * RESOLUTION_SCALE;
v_texpage.w = ((a_texpage >> 22) & 511u) * RESOLUTION_SCALE;
// UV limits are sent normalised; expand to 0..255 PSX-native here.
core/vulkan: drop the UV_LIMITS attribute-layout VS variant Follow-up to 8b43518 (UV_LIMITS routing for the C++ shadergen, D3D11 / D3D12 / OpenGL only). Vulkan has its own pre-baked SPIR-V pipeline rooted in data/shaders/vulkan/*.glsl, compiled via tools/regen_vulkan_spirv.py, and indexed by per-axis blob tables in src/common/vulkan/embedded_shaders.cpp. This commit parallels the C++ shadergen routing on the VS side: collapses the UV_LIMITS attribute-layout variant from the batch VS so that "textured" always means "textured with v_uv_limits", and the C++ Vulkan input layout binds ATTR4 unconditionally when textured. The FS-side UV_LIMITS axis (the Nearest filter's two-variant nouv / uv expansion) is NOT in this commit. Routing it through a UBO field requires extending the Vulkan batch FS UBO declaration with u_uv_limits, body-level runtime branches, and regenerating the 48 Nearest FS .inc blobs. That is the natural next commit; this one limits the blast radius to the VS side, which is a simpler structural change with fewer downstream touch points. What changes: data/shaders/vulkan/batch.vert.glsl - Drops the #if defined(UV_LIMITS) guards in three sites (a_uv_limits input declaration, v_uv_limits varying output declaration, v_uv_limits assignment in main()). When TEXTURED, a_uv_limits / v_uv_limits are always declared and v_uv_limits is always written. - Header comment updated from "3 attribute layouts" to "2 attribute layouts" and the total variant count from 18 to 12. tools/regen_vulkan_spirv.py - _batch_vs_variants(): drops the third attr_axes entry ("textured_uvlim", ["TEXTURED", "UV_LIMITS"]). The remaining "textured" entry's GLSL output now always includes the a_uv_limits / v_uv_limits declarations because the source-side #if guards are gone, so the single "textured" variant produces the same SPIR-V that "textured_uvlim" used to. Variant count drops from 18 to 12. - The Nearest FS variants table is unchanged (still has the UV_LIMITS axis); collapsing that side is the follow-up. src/common/vulkan/embedded_spirv/ - Six batch_vs_textured_uvlim_*.inc files DELETED (no longer in the regen output set). - Six batch_vs_textured_*.inc files REGENERATED with the new GLSL that always emits a_uv_limits / v_uv_limits. Content shape: same length / structure as the old "textured_uvlim" .inc files (since both correspond to the "textured + UV_LIMITS" build); the OLD plain "textured" .inc files (the smaller no-UV variant) are effectively replaced. - Other 169 blobs untouched. Total goes 181 -> 175. src/common/vulkan/embedded_shaders.{h,cpp} - k_batch_vs_blobs[18] -> k_batch_vs_blobs[12]. The table loses the "attr = 1 (textured, no UV limits)" block; the surviving "attr = 1" block is what used to be "attr = 2 (textured + UV limits)", just renamed for cleaner end state. - GetBatchVertexShaderBlob() drops the bool uv_limits parameter. Index encoding becomes attr = textured ? 1 : 0 (was: !textured ? 0 : (uv_limits ? 2 : 1)) Same interp / persp arithmetic. - Header docstring and #include block updated to match (six fewer #includes; the six uvlim ones). src/core/gpu_hw_vulkan.cpp - The single GetBatchVertexShaderBlob() call site at the CompilePipelines VS-fill loop drops its second argument (m_using_uv_limits) so the new four-arg signature is satisfied. - The input-layout builder at the per-pipeline gpbuilder.AddVertexAttribute(4, ...) site drops its `if (m_using_uv_limits)` guard. ATTR4 / a_uv_limits is now bound unconditionally when textured, matching the always-emitted shader input. BatchVertex carries the uv_limits field unconditionally (gpu_hw.h:47), so the binding always points at valid memory; the FS-side u_uv_limits scalar still decides whether the value is meaningful. What does NOT change in this commit: - The Vulkan batch FS Nearest variants still have UV_LIMITS as a build axis. m_using_uv_limits is still threaded to the FS blob lookup at gpu_hw_vulkan.cpp:2139 (now line ~2140 after the diff). The Nearest FS GLSL still has #if defined(UV_LIMITS) guards. The 48 nearest_uv / nearest_nouv blobs remain. Routing that side is the natural next commit; the delta there is much larger (48 blobs, FS UBO grows, runtime branch in the Nearest body). - m_using_uv_limits STAYS in shader_source_changed across backends. Vulkan still needs it to pick the right Nearest FS blob, so the rebuild trigger has to stay until the Nearest FS routing also lands. - m_using_uv_limits STAYS as a member field. Still drives the per-vertex ComputePolygonUVLimits decision (gpu_hw.cpp:740) and still passed into the FS variant lookup. The VS lookup no longer takes it. - Bilinear / JINC2 / xBR FS templates: untouched. They already assumed UV_LIMITS via the settings-layer ShouldUseUVLimits() coupling (TEXTURE_FILTERING != Nearest implies m_using_uv_limits = true), so they never had a UV_LIMITS variant axis to collapse. Variant-count delta: Batch VS: 18 -> 12 SPIR-V blobs. Pipeline cache footprint drops by 6 VS pipelines per (filter, render, texture) cell pair (filter side is per-FS so doesn't multiply VS directly, but the VkPipeline cache key combines them and 6 fewer VS blobs mean 6 fewer paths through the pipeline-create call). Disk SPIR-V footprint: Before: 181 .inc files, 13 MiB total. After: 175 .inc files, 13 MiB - ~120 KiB = ~12.9 MiB. (Six VS blobs at ~120 KiB each, ~2-2.5 KiB SPIR-V plus the C-array boilerplate.) Cost matrix delta (Vulkan): UV_LIMITS flip mid-session (in practice triggered by PGXP toggle or filter cross-Nearest transition, both of which separately trigger m_using_uv_limits flips): Pre-commit: VS pipeline-cache lookup picks a different blob from the 18-entry table on flip. Pipeline creation cost on cold cache: ~2 vkCreateGraphicsPipelines for the two new (textured, textured_uvlim) VS variants if both end up needed. Post-commit: VS pipeline-cache lookup is invariant under m_using_uv_limits at the VS axis; the FS axis still flips. Saves ~2 cold VS pipeline creates on the toggle. Symbolic (small absolute cost) but it unlocks the next Nearest-FS routing commit, which is the actual large win on the Vulkan side. Cold launch (precompile pass): 6 fewer VS pipelines to enumerate / create. Probably tens of ms on cold cache. Steady-state runtime cost: unchanged. The VS uniform always-emits-v_uv_limits adds one MUL per vertex and one vec4 of interpolant bandwidth, both sub-noise. Test: - Build: tools/regen_vulkan_spirv.py runs cleanly with glslangValidator from the Vulkan SDK / glslang-tools package, producing 175 blobs. The Vulkan backend builds and links against the smaller blob table. - Boot any PSX title with PGXP off + filter Nearest: untextured / textured paths render identically. The "textured" VS variant is now the always-UV blob; BatchVertex.uv_limits is zero on these vertices (no ComputePolygonUVLimits ran), v_uv_limits is propagated as zero, and the Nearest FS (still UV_LIMITS-keyed in this commit) picks its "nouv" variant. - Toggle PGXP on or filter to Bilinear: m_using_uv_limits flips to true, the Nearest FS picks its "uv" variant, the VS variant is still the same (post-commit there's only one textured VS variant). Output identical to pre-commit equivalent state. - Spec const flips (PGXP_DEPTH, RESOLUTION_SCALE) at pipeline-create time: still produce the right pipeline via the smaller blob table. Next: - Vulkan Nearest FS UV_LIMITS routing: extend Vulkan FS UBO with u_uv_limits, drop the #if defined(UV_LIMITS) guards from batch_textured_nearest.frag.glsl, runtime branch in the body, regen 48 -> 24 Nearest FS blobs, drop m_using_uv_limits from the FS lookup + shader_source_changed. After that, all backends have UV_LIMITS fully routed. - PGXP_DEPTH for the FS (always-emit SV_Depth / FragDepth perf measurement first). - Pre-bake commits once remaining axes are decided.
2026-05-19 00:48:57 +00:00
// Always written when textured (UV_LIMITS guard dropped at the
// collapse commit); the FS-side u_uv_limits gates whether to
// consume the value.
common/vulkan, core: pre-bake batch VS (18-blob template, 2 spec consts) Patch 12 in the glslang-elimination series, and the first step into Bucket B (batch shaders). The batch VS state space has three SPIR-V- structurally-distinct axes that specialisation constants cannot fold: 1. Vertex attribute layout. 2 inputs (untextured), 4 (textured without UV limits) or 5 (textured with UV limits). The 'in <type> <name>' declarations are part of the SPIR-V module interface. 2. Output interpolation qualifier on the v_col0 / v_tex0 outputs. None / centroid / sample, selected per session by UsingMSAA() / UsingPerSampleShading(). These compile to OpMemberDecorate Centroid / Sample on the VertexData output block, which is not a spec-constant-controllable property of the SPIR-V module. 3. Color output perspective. m_disable_color_perspective toggles a 'noperspective' qualifier on v_col0, compiling to OpMemberDecorate NoPerspective. 3 x 3 x 2 = 18 structurally distinct blobs. Body-level knobs (RESOLUTION_SCALE, PGXP_DEPTH) are common-knob specialisation constants on every blob (constant_id = 0 and 3 per the project convention). To avoid maintaining 18 hand-edited .glsl files, the source is a single template (data/shaders/vulkan/batch.vert.glsl) with #if guards on TEXTURED, UV_LIMITS, INTERP_CENTROID / INTERP_SAMPLE, and NOPERSP. The regen tool (tools/regen_vulkan_spirv.py) is extended with a TEMPLATE_VARIANTS manifest that compiles the template once per variant with the corresponding -D flags. Build-time impact is zero - the script is still developer-only and the .inc files are checked in. The matching index encoding lives in src/common/vulkan/embedded_- shaders.cpp next to the lookup helper: attr = !textured ? 0 : (uv_limits ? 2 : 1) (0..2) interp = per_sample_shading ? 2 : (msaa ? 1 : 0) (0..2) persp = noperspective_color ? 1 : 0 (0..1) index = attr * 6 + interp * 2 + persp (0..17) The C++ side calls GetBatchVertexShaderBlob with the per-session state (m_using_uv_limits, m_multisamples > 1, m_per_sample_shading, m_disable_color_perspective) and the per-call 'textured' loop variable to pick the right blob in CompilePipelines. The existing m_batch_vertex_shaders[2] cache shape is preserved - the helper just selects which two of the 18 blobs to instantiate this session. Spec constants are applied at PIPELINE-create time inside GetBatchPipeline rather than at module-create time, matching the SpecConstants infrastructure laid down in patch 3. The values are session-constant, so they are the same for every batch pipeline in a session and the driver caches them keyed by (module + spec values) in the pipeline cache. Header-side ergonomics: instead of declaring 36 individual extern arrays (18 SPIR-V + 18 size), the .h declares a small EmbeddedShaderBlob struct and a single k_batch_vs_blobs[18] array, plus the GetBatchVertexShaderBlob helper. The same struct is intended to be reused for the eventual batch FS conversion (likely many more blobs given the texture filter state space). Smoke tests: - g++ -fsyntax-only on the touched common TU. - spirv-val --target-env vulkan1.0 on all 18 blobs - 18/18 valid. - Total .inc size: ~53 KiB across all 18 blobs. - --target-env vulkan1.0 vs un-flagged glslangValidator: byte- identical for every variant. The batch VS is filled in CompilePipelines for all three precompile modes (Enabled, Lazy, Disabled), so this conversion does not change the hot-path-pre-build pattern from the patch 10-fix. The two VS modules are present before any batch draw on every code path. Test priority: - Routine smoke under Enabled / Lazy / Disabled. Any rendering at all exercises both VS modules immediately, so visual regressions show up on the first frame of the first game booted. - SSAA / MSAA round-trip in Disabled mode (per the patch-5-fix protocol), specifically to confirm the structural-blob-pick flips through 'none' -> 'centroid' -> 'sample' interp variants cleanly as m_multisamples changes. - Toggle 'disable color perspective' core option (under Texture Correction) to flip the perspective axis; visual difference is subtle but the blob-pick change is real. - Toggle PGXP Geometry Correction (drives UV_LIMITS via m_using_uv_limits) and PGXP Depth Buffer (drives PGXP_DEPTH spec const) to flip the body and attribute-layout axes. After this lands, the only remaining runtime glslang consumer in the Vulkan backend is the batch FS (GenerateBatchFragmentShader at gpu_hw_shadergen.cpp line ~667). That is a far larger state space - six texture filters x ~14 boolean macros plus the structural USE_DUAL_SOURCE / PALETTE_* axes - and will need to land in several patches, one or two texture filters at a time.
2026-05-17 22:55:46 +00:00
v_uv_limits = a_uv_limits * vec4(255.0, 255.0, 255.0, 255.0);
#endif
}