CTR Decrypted

Level visibility

What decides which track faces, sky and kart wheels are drawn far away, and what the native version changes. Read this before touching level culling in game/MAIN/MainFrame.c, game/MAIN/MainFrame_RenderFrame.c, the level renderers (game/226 to game/229), game/DrawSky.c or game/DrawTires.c.

The stages

A level face is drawn only if it passes every stage, in this order:

  1. Visibility lists (PVS). Each quadblock can carry precomputed lists: the BSP leaves and quadblocks visible from it, nearby level instances, and the water and vertex-colour vertices to animate. The camera picks the lists of the quadblock under it (CAM.c, after CAM_FindClosestQuadblock), and MainFrame_VisMemFullFrame copies them into gGT->visMem1. Native ignores them for level geometry: MainFrame_VisMemFullFrame sets every leaf, quadblock, water vertex and vertex-colour vertex visible each frame (why). Instances keep their lists, because warp pads (AH_WarpPad.c) and cutscenes (CS_Instance.c) read them as gameplay state.
  2. Frustum. The BSP walk drops leaves outside the view. Widescreen widens it (Widescreen_ScaleFrustumX).
  3. Distance. Far leaves and quadblocks drop out, and textures and models change LOD by distance. increase_draw_distance moves all these limits out by the same factor, 4 (include/platform/native_draw_distance.h): the frustum's far clip (PushBuffer.c), the depth where a BSP leaf switches to the cheaper full-dynamic emitter (1P and split screen), a model's LOD distance, and the depths that pick a level texture's LOD and a quadblock's subdivision. The last two go together: a quadblock's full-resolution texture only loads in the deepest subdivision. One factor for all, because the nearest limit decides what the player sees disappear.
  4. Near clip. Faces crossing the near plane are clipped through clip records, but only when a corner is inside a box in front of the camera (DrawLevelOvr1P_SourceInsideClipRecordWindow); otherwise the face is dropped whole. The box widens with the aspect ratio.

Why the lists are off

The lists were baked for the retail view: 4:3, the retail draw distance and the camera positions the developers sampled. With widescreen, the far camera (L2) or increase_draw_distance, the camera sees past them, so stretches of far road and scenery vanish until the camera reaches a quadblock with other lists. A split-screen camera can even lose the floor under its kart.

They only saved PS1 time. Faces hidden behind nearer ones are still drawn, but the ordering table puts them first, so nearer faces paint over them. The cost is primitive-arena space and frame time:

The sky

The sky (game/DrawSky.c) is a dome of large gouraud triangles around the camera, in eight 45-degree slices. Retail draws the four slices facing the camera and drops a face whole when the GTE flags a corner too close to the camera plane, and the GPU drops any triangle 512 or more pixels tall (NativeGpu_HardwareSkipsTriangle). From the far camera and in widescreen, a face still covering a screen corner hits one of those, and the clear colour shows through.

Native draws all eight slices and sends every face through DrawSky_ClipFace: clipped in view space against the near plane and the screen edges (8 pixels outside), projected through the same view as the level (the precise one under PGXP), and drawn as a fan with colours interpolated at the cuts, so pieces stay within the GPU's limits. Every face goes this way, not only those retail would drop, so neighbours share bit-identical corners (mixing GTE-projected and clipped faces leaves hairline seams).

Distant wheels

A kart's tires are four camera-facing sprites (game/DrawTires.c), drawn only at the kart's top model LOD. Their centres are taken relative to the camera at 4 times world scale and go through the GTE's 16-bit vectors, which hold about 8,000 world units; with increase_draw_distance a top-LOD kart can be farther. Such a wheel keeps its full-width centre (the GTE's 32-bit MAC1 to MAC3, not the saturated IR1 to IR3), takes its facing from it, and has its corners projected by NativeGte_ProjectWide (platform/native_gte_core.c), an RTPS with a 32-bit input that advances the same registers and PGXP state. Wheels that fit keep the retail GTE path bit for bit. Packing an out-of-range corner into 16 bits would wrap it behind the camera and draw a long dark sliver across the screen.

Checking it