Code Violet (PPSA26528)

[erm14254]

Existing thread

• I searched this category for the title ID and no thread exists for this title on any platform.

Title

Code Violet (PPSA26528)

Content version tested

01.000.028

AnyPS5 commit

main d92a8da with these pull requests on top: #6258 (ordered count of a first active lane in the upper wave64 half), #PR2 (table calls through a constant descriptor address), #PR3 (system GPU page at 0xfe0040000), #PR4 (fault record function without DontInline)

System tested

Windows 11 (10.0.22631), NVIDIA RTX PRO 6000 Blackwell Workstation Edition, driver 597.16; built from source with MinGW-w64 GCC 15.2.0 (WinLibs x86_64-ucrt-posix-seh, r7)

Furthest point

Menu

What is shown

The title screen (logo, START prompt) and the main menu (Campaign, Options, Tutorials, OST, Extinction) render at the title's 3840x2160, with the music playing. Frame times are 0.5 to 0.7 s at the title screen with warm caches and 1.9 to 2.5 s at the main menu, so 0.4 to 1.8 frames per second. Controller input works once a button is held for longer than a frame, since the pad state is sampled once per frame. The picture is wrong: the crown in the title screen and the rock spires are drawn as blocky fragments and the scene is far darker than on the console, so the geometry and lighting passes of this Unreal Engine 5.5 title do not come through correctly.

How the game looks like on PS5:

How the game looks like when running on my PC with AnyPS5:

The main menu on AnyPS5, with the frame rate in the window title:

Current blocker

On current main the title aborts before its title screen even with the pull requests below, at a buffer descriptor check that d92a8da passes: #7051.

Performance: both queue workers are at 100% in the driver's resource tracking, see the performance report #6257. Per frame about 1,300 compute dispatches cost 1.2 to 1.6 s in resource lookups, of which the byte comparisons of imported guest memory on Windows are the largest part (202 s of a 300 s profile, 3.6 TB compared), and 4 GiB buffers the shaders declare are copied into device buffers per dispatch (508 copies of 4095 MiB in the profile, 80 to 440 ms each). Rendering correctness of the engine's geometry and lighting passes is the next blocker after that.

Pull requests and local changes the title needs, in order: #6258, #PR2, #PR3 (needs #PR2), #PR4 (NVIDIA driver 597.16 only), #6094 (by n-delic; without it one unaligned 32-bit atomic is dropped per frame, no visible change). With all five merged no local change is needed.

How it was run

Converted with the relinker as in docs/user/USAGE.md and started from its folder (.\app.exe), no environment variables set. The stops before the pull requests, in order: DISPATCH_DIRECT at DWORD 2549: dispatch modifiers 0x49 are not implemented (fixed by #5176 on main and #6258), FATAL: unhandled exception 0xc0000005 on thread 'queue worker 0x0' in nvgpucomp64.dll+0x28072a1 (#PR4; captured with APS5_DUMP_COMPUTE_PIPELINES and reduced with spirv-reduce), computed/data-dependent s_swappc_b64 call target at program counter 0x00000134 is not statically resolvable (#PR2; captured with APS5_DUMP_SHADERS), its call table descriptor at 0xfe0040000 + 0x10 is not readable (#PR3). The game writes a non-fatal deferred write-back failed: BDA access failed: ... instruction=0x7bc bytes=4 stage=4 reason=7 once per frame; what that unaligned atomic is has not been looked at.

[erm14254]

#6094 removes the per-frame fault; the blocky crown and spires are Nanite hardware-rasterized clusters that never draw.

#6094 (unaligned 32-bit buffer atomics act on their dword): with it the once-per-present BDA access failed: ... bytes=4 stage=4 reason=7 line is gone, the picture is unchanged. Added to the list above.

Where the crown disappears. Live dumps of the device images at flip settle it:

• The title renders its 3D view at 1152x483 (37.5 % dynamic resolution inside the 2.39:1 band) into 3072x1728 targets; TSR upscales 3.33x. The "32-texel tiles" of the holes are that upscale of cluster-shaped gaps.
• The crown is already missing in Nanite's visibility buffer (3072x1728 R32G32_UINT, low dword = visible cluster << 7 | triangle). Where its near parts should be, the sky and the background are rasterized instead, so post-processing is innocent.
• Classifying every written pixel by rasterizer (software clusters have indices 1..31232, hardware clusters are stored from the end as 4194304-1-i): the whole background and the far crown tips are software-rasterized and complete; the ground and exactly one crown spire are hardware-rasterized; 1259 of 2491 hardware cluster slots never produce a pixel, interleaved with present ones in no index, parity or prefix pattern, and the present clusters contain triangles 0..127 (no half-wave loss).
• Those draws are DRAW_INDIRECT (opcode 0x24, non-indexed, one record of count N, instances 1), about 193 per present, all resolved on the CPU because the GPU-side indirect draw exists only for vertex-shader pipelines (IndirectDraw.cpp non-vertex path; meshGpuSide needs an indexed draw). The reads are not stale: APS5_SYNC_DISPATCH=1 leaves the picture identical. APS5_FAST_LAUNCH_SINGLE_WAVE=1 leaves it identical too, with zero shader-cache misses, so no mesh shader's workgroup size changed.

Ruled out (each by a title-screen run with frame dumps, crown unchanged): storing pending storage-image results before every GPU label; keeping GPU results over changed guest bytes; every leading barrier recorded with the hazard tracker on (no skipped barrier reported); every sampled texture a snapshot instead of a storage-image view; write-backs widened to whole images; all 64 KiB blocks stored. The artifact is deterministic across runs and builds (1.4 to 2.6 % pixel difference between runs, particles only), so a race is unlikely. Disabling depth of field through uecommandline.txt was ignored by the shipping build.

Next step, for whoever picks it up: print the decoded configuration of the title-screen 0x24 draws once per distinct shape (input primitive, GE_CNTL vertices and primitives, max vertices, amplification, threads per group, wave size, count to groups) where VGT_SHADER_STAGES_EN, GE_CNTL and GE_NGG_SUBGRP_CNTL become MeshConfiguration (State.cpp mesh branch), meshGroups is computed (Draw.cpp mesh path) and the NGG mesh entry maps waves and lanes (InstructionTranslator.cpp), and compare with the RDNA2 NGG rule for Nanite: one wave64 per cluster emitting up to 128 vertices and 128 primitives, two per lane. A wrong group count or lane-to-cluster mapping that drops every other cluster is the expected finding.

The dark scene is a second symptom (lighting or exposure), not investigated.

The dump tooling (APS5_DUMP_STORAGE=<list>, APS5_DUMP_STORAGE_AFTER, APS5_DUMP_STORAGE_MAX, live image copies at flip) and the write-back switches used above are debug code on erm14254/AnyPS5 branches debug/live-image-dump and debug/storage-writeback-switches, not meant for merging. The visibility-buffer dump, draw-record traces and per-rasterizer maps are available on request.

AI-assisted: yes