[columna1]

I spent some time vibe coding a nintendo-switch port. This is a huge PR and may be a burden to maintain so feel free to let this PR rot but I figured I'd PR in case anyone is interested.

This is the engine half of Chronicle's Nintendo Switch port (homebrew, NVK on the Tegra X1). It adds a Horizon platform layer, renderer changes that the Switch's GPU and driver need, recording on one thread while another renders, and a few small interfaces so that a renderer other than the Vulkan one (Chronicle's port/gl) can sit behind the gfx API.

Without __SWITCH__ / NINTENDO_SWITCH, behaviour is unchanged apart from the shared changes listed below.

Chronicle side: columna1/Chronicle-nintendo-switch switch-port (separate PR).

Platform (Horizon)

• File commits on Horizon. It cannot open a directory as a file, so there is no directory sync, and its rename never replaces a file. A replacing commit therefore moves the old file aside first, removing it once the new one is in place.
• libnx's absolute device paths (sdmc:/…) accepted as absolute.
• The pipeline cache written with FilesWrite, so it is committed like any other save file.

Renderer

• draw.frag without per-draw branches. NVK's compiler (NAK) puts a sync at each uniform branch, and on the Tegra X1 a fragment costs about its instruction count. Per-draw choices are now values the shader selects between.
• RendererConfig::expand_palettes. Palette textures are expanded to RGBA on the CPU and filtered by the sampler, instead of being looked up four times a pixel.
• DrawState::premultiplied, so an effect can composite in one draw where the GS needed two.
• Frames in flight: 4 on the Switch, 3 on Android and 2 elsewhere. A tick submits twice, so two slots kept only one tick in flight and the CPU waited for the GPU.
• Depth queries answered when their frame is done (kAsyncDepthQueries, on for the Switch). The renderer no longer waits for the whole frame on the GPU; the answer arrives a tick or two later.
• RendererConfig::target_scale. This keeps the old meaning of render_scale: render targets' pixels per logical texel. The Android merge turned render_scale into a multiplier on the main targets' size, so a caller that set it to 1.5 got 1920x1080 main targets. target_scale defaults to 0, the old rounding of window height over logical height. render_scale still multiplies it.
• KZ_PORT_INTERPOLATION_TINT (CMake option). It builds the smooth-motion debugging tint into draw.frag. It is on by default except for NINTENDO_SWITCH, where the tint's selects, which run for every pixel of every draw, made a busy town's frames about 3 ms slower.
• DrawState::depth_coverage. A 2D draw that reads the main depth buffer instead of testing it: its colour and alpha are scaled by the fraction of up to 8 given depths at or nearer than the depth at each pixel. It draws in one pass what a stack of depth-tested additive draws would. Chronicle's heat haze uses it for the 8 blended full-screen passes it drew per image; in Muska Lacka on the Switch that took the haze from 13 ms of GPU a frame to about 3, and the town from about 40 fps to 60. The pass leaves the depth buffer unattached, samples it in a read-only layout, and puts it back afterwards. It's one extra pipeline, built only where the device can sample its depth format (RendererFeatures::depth_coverage). Two texture slots are now reserved for the depth buffers, so kFirstUserSlot is 5.

Threads

One thread records while another renders (db656fe; gfx README, "Threads"):

• recording state, frame markers and the published main size are atomics;
• the renderer lock is recursive, with LockUnlessRecording() for calls that are recorded rather than run;
• the texture and mesh tables are reserved up front so lookups never see a reallocation;
• a texture or mesh doomed during a recording stays visible to that recording (RecordingList()) and to replays on their own thread (ReplayingHere()).

ThreadSanitizer is clean over the game's test scenes, and pictures match single-threaded rendering exactly.

For other renderers

• WindowConfig::opengl: an OpenGL window, for a GL renderer.
• CanRecordBinding checks through GetTextureInfo, which every renderer has, instead of LookupTexture, which returns the Vulkan renderer's own records.

Also on this branch

• Upstream merge: a merge of Chronicle's current Kazarov pin, 611182d from the Android fork, which brings the src/cpp layout and the Android platform.
• Cherry-pick: dee2dbc, the TextureDesc logical size change (gfx: TextureDesc logical size, for a texture with more pixels than th… #7). Chronicle's texture overrides need it, and 611182d does not contain it.
• Reverted experiment: efbd047 (a shadow volume's two passes share their vertices) is reverted by 6c7281e. The sharing clashed with the new interpolation code, which reads every immediate mesh's own vertices. They can be squashed away.

The branch merges rather than rebases. I can squash or rebase it if you prefer.

Testing

• Chronicle's PC test suite: 511 of 516 pass. The 5 failures are the same ones Chronicle's master fails on its own.
• Played on Switch hardware with Chronicle's switch-port. Norune holds 60 fps handheld at 1280x720.
• Chronicle's GL renderer builds against these headers, and its pictures match the Vulkan renderer's.

[Adubbz]

Partially integrated into master in 25e8594: the Switch button glyphs for every pad on the Switch. The rest is already on master in its own form (Horizon file commits, sdmc: paths, pipeline cache through FilesWrite, four frames in flight, the render thread, TextureDesc logical size), and the other renderer interfaces need consumer code no project has yet. Thank you!