The prize set. display_ps is the per-frame hot shader - every
frame goes through this on its way to the host display, so cold-
flip cost matters here more than anywhere else in the GPU
pipeline. This commit pre-bakes 54 variants covering the full
runtime configuration matrix and replaces the shadergen +
m_shader_cache.GetPixelShader path in GetDisplayPipeline with
indexed-lookup into two static arrays of D3D12_SHADER_BYTECODE.
Variant axes (4 axes, 54 unique blobs):
* DEPTH_24BIT (2 values): 16-bit framebuffer (the common case;
every game's standard scanout) vs 24-bit (FMV cutscenes,
games that opt into true-colour framebuffers).
* interlace_mode (3 values): InterlacedRenderMode enum from
gpu_hw.h. Mapped to a (INTERLACED, INTERLEAVED) bool pair
in the variant /D defines:
i=0 (None): (INTERLACED=0, INTERLEAVED=0)
i=1 (InterleavedFields): (INTERLACED=1, INTERLEAVED=1)
i=2 (SeparateFields): (INTERLACED=1, INTERLEAVED=0)
* SMOOTH_CHROMA (2 values): chroma-plane smoothing in the
24-bit path. Heavy when active - SampleVRAM24Smoothed runs
9 SampleVRAM24 calls per output pixel (1 centre + 4 x 2x2
averages), each of which is 2 LoadVRAM calls. Dead code
when DEPTH_24BIT=0; the variant table omits the c=1 entry
for d=0 (54 = 18 + 36, not 72 = 2 x 3 x 2 x 6).
* MULTISAMPLES (6 values: 1, 2, 4, 8, 16, 32): MSAA sample
count. Same cardinality axis as vram_read_ps (21f4623).
Composed multiplicatively with SMOOTH_CHROMA: at
/DSMOOTH_CHROMA=1 /DMULTISAMPLES=32 the inner loop unrolls
to 9 * 2 * 32 = 576 texture loads per pixel - the d1i?c1m32
blobs are correspondingly the largest in the set (99 kB
each).
Variant suffix convention: d{0,1}i{0,1,2}c{0,1}m{01,02,04,08,16,
32}. MULTISAMPLES padded to 2 digits so alphabetical .inc
filename ordering matches the natural nested-loop iteration
order. The d=0 set has 18 entries (one chroma value); d=1 has
36 (both chroma values).
Blob size distribution:
smallest: 1276 B d0i0c0m01 (16-bit, no interlace, no MSAA)
median: ~3500 B
largest: 99152 B d1i2c1m32 (24-bit, SeparateFields, smooth
chroma, 32x MSAA - 576 loads/px)
total: 942 kB of DXBC across 54 .inc files
on-disk: ~5.6 MB of .inc text (the hex-encoding overhead is
~6x vs the binary - "0xXX, " per byte - same shape
as the vram_read note in 21f4623)
Runtime selection in GetDisplayPipeline:
if (depth_24) -> k_display_d1[interlace_mode][chroma][ms_idx]
else -> k_display_d0[interlace_mode][ms_idx]
Two arrays rather than one ragged 4D, because the smooth_chroma
dimension is structurally absent on the d=0 path (SMOOTH_CHROMA
is dead code there; fxc /O3 would have produced identical DXBC
for c=0 and c=1 anyway, so we save 18 blobs / ~30 kB DXBC by
not baking them). ms_idx is log2(m_multisamples) computed by a
function-scope kMultisamplesIndex lambda - same predicate /
fallback shape as the vram_read pre-bake. The arrays are
function-scope static const so they initialise on first call
and the cost is amortised across the per-frame display PSO
stream for the rest of the session.
Files added:
* data/shaders/d3d12/display.ps.hlsl: standalone HLSL matching
GenerateDisplayFragmentShader's D3D12 output post-e64fc28
cbuffer routing. 24-byte cbuffer (u_vram_offset.xy,
u_crop_left, u_field_offset, u_resolution_scale, u_pad0)
layout-identical to the GPU_HW_D3D12::UpdateDisplay
SetGraphicsRoot32BitConstants push. RGBA8ToRGBA5551,
RGBToYUV, YUVToRGB, fixYCoord helpers all inlined.
SampleVRAM24, SampleVRAMAverage2x2, SampleVRAM24Smoothed
match the shadergen body byte-for-byte.
* src/common/d3d12/embedded_dxbc/display_ps_d{0,1}i{0,1,2}c{0,1}
m{01,02,04,08,16,32}.inc: 54 DXBC blobs (with the
smooth-chroma collapse on the d=0 path). All built with
Microsoft fxc; full RDEF/ISGN/OSGN/SHEX/STAT chunk set; all
54 stamped "Microsoft (R) HLSL Shader Compiler 10.1". Validator
(check_microsoft_creator in tools/regen_d3d12_dxbc.py)
passes all 54.
Files modified:
* tools/regen_d3d12_dxbc.py: TEMPLATE_VARIANTS gains the
display.ps.hlsl entry with 54 rows. Comment explains the
interlace_mode -> (INTERLACED, INTERLEAVED) mapping and the
d=0 chroma collapse.
* src/common/d3d12/embedded_shaders.h: 108 extern declarations
(54 array + 54 size_bytes). Header docblock explains the
variant axis breakdown, the suffix convention, and the
two-array runtime selection.
* src/common/d3d12/embedded_shaders.cpp: 54 #include lines for
the new .inc files, inside namespace D3D12::EmbeddedShaders.
* src/core/gpu_hw_d3d12.cpp GetDisplayPipeline: shadergen call
+ m_shader_cache.GetPixelShader path replaced with the
kMultisamplesIndex lambda + two static arrays + ternary
indexed-lookup. The m_shadergen-not-yet-built check is
dropped for this path since the embedded blobs are
statically linked. Pipeline build downstream is unchanged
(same root signature, RT format, blend/depth state).
Cost matrix delta (D3D12) for display_ps:
Cold-flip multisamples toggle: ~50 ms x 6 D3DCompile +
~10 ms x 6 PSO
-> ~10 ms x 6 PSO only.
(Multisamples rebuild touches the full 2x3 display PSO
matrix at the new sample count.)
Cold-flip smooth_chroma toggle: ~50 ms x 2 D3DCompile +
~10 ms x 2 PSO
-> ~10 ms x 2 PSO only.
(Only the 2 d=1 PSOs are affected; d=0 PSOs are
chroma-independent.)
Disk-cache-warm: ~1 ms each -> 0 ms.
Resolution scale toggle: 0 ms (cbuffer-routed via e64fc28).
Per-frame PSO selection: previously a shader_cache hash
lookup; now an array index. ~ns vs ~us delta - negligible.
The shadergen GenerateDisplayFragmentShader function is left
intact in gpu_hw_shadergen.cpp - the other three backends still
call it through their runtime shader-cache paths. Only D3D12
bypasses it now. This is the final shader on the non-batch
pre-bake roadmap.
Test:
- Build: D3D12 backend links without unresolved symbols
across all 54 new externs. Specific risk: a typo in any of
the 108 extern names or 54 includes would surface here.
- Runtime, default config (MSAA off, no chroma smoothing):
every game must continue to scanout correctly. Failure
modes if the d=0 path is wrong:
* Garbled framebuffer / wrong colours on the per-frame
display.
* Interlace fields rendered wrong - test signal: any PSX
game in interlaced output mode (most TV-target games).
Wrong interlace mapping would manifest as field
comb-tearing or half-height output.
- Runtime, 24-bit colour: trigger any FMV. Standard test
cases:
* Sony intro bookend FMV - leaves no doubt the 24-bit
path is hit.
* In-game cutscene FMVs (FF7, MGS, Resident Evil).
Failure mode if d=1 c=0 path wrong: FMV plays but colours
are wrong (off hue, mismatched chroma).
- Runtime, 24-bit + chroma smoothing: enable the "24-bit
Chroma Smoothing" core option, then play FMV. Failure mode
if d=1 c=1 path wrong: FMV plays with sharp chroma edges
(the smoothing isn't happening) or with garbled output
(variant table miswired).
- MSAA at each level (2x/4x/8x/16x/32x): same screenshot
tests at each. Failure mode for any individual blob:
visible MSAA averaging artefacts in the displayed image.
32x specifically validates that kMultisamplesIndex picks
ms_idx=5 - wrong-side switch would index m16 (4) instead
of m32 (5).
- All combinations: display_ps is selected freshly each
UpdateDisplay call, so the array indexing is exercised
every frame. Any mis-indexed combo would be visually
obvious.
- Chroma toggle: flip "24-bit Chroma Smoothing" mid-FMV. The
next display PSO selection picks blobs from k_display_d1
[interlace_mode][1] instead of [0]. Failure mode: chroma
smoothing doesn't toggle, or wrong PSO selected leading to
garbled output.
If everything works, the only remaining pre-bake target is the
batch matrix - the ~1 min cold-flip prize, hundreds of variants.
That's the final arc of this whole sequence.