How the captured games get their fidelity

Detail is relief and shadow, not paint

WebGL1 directsharpens plan

Need4Space's rock comment records a user correction: a 60 m tile "showed its dark blotches and pits as rows of dots ... it looks fake." The fix was a near-uniform albedo with only "gentle" variation. The detail moved into the normal map's relief: craters with parabolic bowls, raised rims, ejecta skirts, sparse fractures and grit. Craters cluster into heavily cratered regions next to smooth ground, because "an even spread read as polka dots".

For TR: this matches the speckle problem. It argues for pushing crater and fracture contrast into the normal and AO bakes, not into albedo, when the Blender gate builds split.

Hex-tiled triplanar at three scales

WebGL1 directnew to TR

One baked rock tile is projected from the three world axes at about 5x, 1x and 1/6 scale. Each projection blends three randomly rotated and shifted copies over a hex grid, weighted by height (Mikkelsen 2022), so the tile never visibly repeats. The smallest scale is dropped where its texels would be sub-pixel, and a broad drift adds weathered and fresher regions.

For TR: this gives one shared material for 6 to 10 instanced debris variants, with no UV unwrap and no visible repetition across thousands of instances. The cost is 9 texture taps per scale; Need4Space's laptop mode keeps only the middle scale.

Torn edges have thickness, and the plates around them bend

offline / Blendernew to TR

Need4Space builds each broken hull piece from one description: section shape, holes and torn ends. That description drives three things. The mesh is cut with marching squares, finer near an edge, and "the edge given its thickness and the plates round it bent outward". The sun is let inside only through the holes, in shafts with a penumbra. And the sky light reaches the interior through the same holes.

For TR: the split concept's "broad fracture faces catch warm light" read depends on the fracture having thickness and lifted lips, not a thin bright seam. It is a concrete brief for rockfield.py's rift: give the chasm walls depth, lift and bend the crust at the lips, and let the star light the interior faces.

Bake a macro shading band, and author each channel from its own field

offline / Blendersharpens plan

World of ClaudeCraft's hero mount stores a baked band in vertex colour: "cavity occlusion against the neighbouring parts, ground contact and grime, settled dust, thinned paint on up-facing bevels and seam darkening." The same doc lists "aliasing albedo into roughness or normal" as a must-avoid. Scacelith's limestone does the same in a shader: each feature has a physical cause (bedding, pits, dust on upward faces, recessed joints).

For TR: write the split body's material as a short geological story before baking. For example: basalt crust, darker fresh fracture faces, heat-reddened rim near the magma, dust settled in crater floors. Bake each as its own field. This is the 10-20 doc's "cracks, discoloration and relief should describe the same physical structures," made concrete.

Static shadow baked once from the star

WebGL1 directsharpens plan

Need4Space renders the meteorite's sun shadow once into a depth map, so "crater rims and boulders throw real shadows at any distance". Scacelith caches static cascades and re-renders them only when the sun moves.

For TR: TR already has 2048 shadow maps with 12-tap PCF. If the star does not move relative to the body during inspect, cache the body's self-shadow instead of re-rendering it. That helps the 57 ms inspect cost.

Distant hero as a pre-rendered picture, plus live debris in the break

offline / Blendernew; contradicts option E

Need4Space's colossus, "a capital ship broken in two above the planet", is built and lit in Blender from where the sky camera stands. It ships as an 8-bit picture on a plane, with a second picture holding its lights. The debris is about 110 torn plates and chunks drifting in the gap, each "turning on its own axis and catching the sun as it turns". All of it runs in one shader draw.

For TR: the 2026-10-14 research rejected impostors (option E) because of memory per variant. This is a different case: one picture of the whole body for the play view, where the planet is about 110 px. That limits it to a fixed viewing angle or a small set of baked rotations, so it fits the backdrop or play view, not inspect. It is offered for Scott's ruling, not adopted.

Debris that reads: light it only where the light falls, and let it glint

WebGL1 directnew to TR

Cortiz's dust and Need4Space's debris share one rule: the contrast between lit and unlit is the effect. Metal plates in the break get "a tight glint toward the sun - the plates flash as they turn." Motes out of the beam are "barely there".

For TR: the 2026-10-14 captures complain about "bright rim outlines" on debris. The precedent says to drop the always-on rim and let only star-facing faces flare, briefly, as each fragment rotates.

Model the reference as named systems, and reject plausible output

processsharpens plan

World of ClaudeCraft does not turn an image straight into a mesh. It first writes a table of named visual systems: primary mass, surface rhythm, structure, focal hardware, secondary detail. The generic img2threejs scaffold "was not good enough to ship". The fix was "not a larger prompt" but a purpose-built procedural factory.

For TR: this is the 10-20 doc's "production interpretation" in table form. For split: primary mass (sphere with a missing wedge), structure (chasm walls, lifted lips), focal (magma glow zone), rhythm (slab-to-gravel ring), and secondary (craters, grit). Rank them, and judge them in that order.

The sun as a surface, kept inside display range

WebGL1 directnew to TR

Need4Space's sun is layered:

• warped flow noise that churns slowly;
• convection cells with bright middles and dark lanes;
• dark filaments, and a few sunspots in active regions ("not continents");
• limb darkening and reddening;
• a thin ragged red chromosphere, prominences that breathe on their own clocks, timed eruptions over about 12 s, and a faint corona.

The key line: "Kept inside the display range so the surface reads; only the hottest cores bloom."

For TR: a star that blooms everywhere loses its surface. Hold the photosphere just under the tone-map shoulder, and let only granule cores and prominences cross the bloom threshold.

AgX tone mapping, matched to Blender

WebGL1 directsharpens plan

Three projects use AgX, Blender's default view transform since 4.0. Need4Space ships Blender's "AgX - Punchy" look as a 65³ LUT (assets/agx_punchy_lut65.json). Scacelith runs AgX in Rec.2020 "so sunlit marble keeps its gradations". AgX desaturates highlights smoothly instead of skewing their hue.

For TR: TR's plan judges the look in Cycles first, then matches it in game. If Blender renders with AgX and the game with ACES, the two never quite match. An analytic AgX fit is a few lines of GLSL ES 1.00. A 65³ LUT would need a 2D-packed texture in WebGL1. Compare it against the current hue-preserving ACES on the same frame.

Physical units, and a three-light space rig

WebGL1 directsharpens plan

Scacelith keeps the sun in lux, the sky in nits and exposure as EV100, so values never need ad hoc gain. Need4Space's space scene has exactly three sources: "One hard sun, a faint warm planet-shine, starlight". The shadow penumbra is sized from the sun's disc (PCSS), so contact is sharp and distance is soft.

For TR: a fixed key/fill/ambient rig (star, nearby planet-shine, starlight) gives the 2026-10-16 "judge lighting as one environment" rule something concrete to hold constant across bodies.

Check value separation at the pixel level

processnew to TR

Berlin Walk's TV Tower existed, drew correctly and was invisible, because sunlit concrete matched the sky's brightness. The agent proved it drew, then zoomed into the pixels and rebalanced the light. Fog was tuned so the tower reads at 2.2 km.

For TR: make a "does the silhouette separate from the background" pixel check part of each contact sheet. It matters most for the dark body against space and for debris against the star.

Gas giant: one baked cloud texture plus a few live terms

WebGL1 directnew to TR

Need4Space paints the clouds once into an equirect texture:

• light zones and dark belts, each with its own shade;
• noise squeezed across the bands so features stretch along the flow;
• latitude bent by turbulence that is strongest at belt edges;
• fine streaks, white eddy ovals along belt edges, one great storm, and darker, mottled, bluish poles.

At runtime, the shader adds:

• a soft, slightly reddened terminator and limb darkening;
• the ring's shadow on the clouds, sampled from the ring texture itself;
• a thin atmosphere thread on the lit limb.

The rings have thousands of ringlets in a density texture, the planet's shadow and faint spokes. They backscatter on the lit face and transmit through thin parts, so they glow when you look toward the sun.

For TR: every term is ES 1.00-friendly. The bake is a one-time render-to-texture, and TR already has half-float targets. Bake in strips, as Need4Space does, to avoid the watchdog.

Ocean: what makes web-ocean read as real

FFT needs WebGPU/WebGL2shading ideas portnew to TR

The FFT cascades need compute or float render-target ping-pong at scale, so they don't fit TR's WebGL1 directly. For a water world seen from orbit, the parts that matter port:

• LEAN mapping (Olano and Baker 2010): mipmapped first and second slope moments give the correct roughness at every distance, so sun glitter widens into a sheen instead of aliasing. From orbit, this is the look: a broad sun glint on the sea.
• A turbid body colour lit by the whole sky hemisphere, with subsurface glow on backlit crests.
• Reflections tilted at grazing angles toward the wave facets the viewer can actually see.

Tidewright's cheaper route, a Gerstner sum whose wave function the simulation also uses, is the WebGL-scale fallback. The spectral theory is in Tessendorf's notes.

Cheapest credible atmosphere: two rim shells and a twilight band

WebGL1 directnew to TR

Earth, Moon & Solar System draws its atmosphere as two additive spheres just outside the surface. The inner shell is front-faced with rim pow(1 - |N·V|, 5); the outer one is back-faced with a softer power of 4. Both are tinted from deep to bright blue by a smoothstep of N·L, and add an orange term exp(-(4·N·L)²) that lives only at the terminator. It is about ten lines of GLSL with no textures.

For TR: this is the step before any LUT work. It is enough to test whether a thin limb and a warm terminator make the water world and the rock world read as planets with air, or as bare spheres.

Expose the night side on purpose

WebGL1 directnew to TR

The same project lights the dark hemisphere with a cool, desaturated copy of the surface (about 45% toward luminance, tinted blue) that fades out across the terminator. The comment gives the reason: "keeps geography readable". Need4Space's three-light rig does the same job with planet-shine and starlight.

For TR: a body that is half black loses its silhouette against space. A small, cool, deliberate fill on the night side keeps the shape readable without fighting the star's key light.

Atmosphere: LUTs, not raymarching per pixel

WebGL1 with half-float RTnew to TR

web-ocean and Scacelith both use Hillaire 2020. A transmittance LUT, a multiple-scattering LUT and a per-frame sky-view LUT replace per-pixel raymarching, and the method scales from mobile to high-end PC. Tidewright does a simpler raymarch into one lat-long LUT per frame.

For TR: the 10-08 analysis noted TR has no atmosphere model. For a planet seen from space, the limb glow and terminator colour come from the transmittance LUT alone, which is a small half-float texture TR can already render to. Need4Space's gas giant gets a credible limb from a thin analytic term; that is the cheap first step.

Fade detail before it gets smaller than a pixel

needs OES_standard_derivativessharpens plan

web-ocean's cloud fbm fades each octave "well before they reach pixel size ... no shimmer in motion". Cloud silhouettes are anti-aliased by the fwidth of their edge function, spread over about 1.5 pixels. Need4Space drops its smallest rock scale "only where its texels can show".

For TR: this is the direct fix for the speckled 110 px disc, for any procedural term left in the shader. sun.html does not request OES_standard_derivatives today. It is a universally available WebGL1 extension, but adding it is a renderer change.

Give the backdrop its own scene, camera and depth range

WebGL1 directcheck against TR

Need4Space renders the nebula, Milky Way band, stars, gas giant and sun in a separate scene with its own camera and depth range, then draws the circuit over it. Precision is never shared between 2 m and 2,000 km. Its nebula's four 6-octave noise fields are baked once into a 1024-per-face cube map; live, they cost about 0.4 ms per 1440p frame.

Near-space depth from drifting motes

WebGL1 directnew to TR

"Dust drifting round the camera: a box of motes that wraps with it, so near space has depth." Combined with Cortiz's rule, the motes stay barely visible except in the star's light, where they flare. This is a cheap parallax cue that makes camera moves read as travel through a volume.

Reveal size through partial silhouette and an uncluttered stage

designsharpens plan

Zephyria introduces its giant serpent as rings moving through clouds, "a glimpse of its size without revealing exactly what you're fighting". It also keeps the arena empty so the creature stays the focus. Barad-dûr's 60-second continuous ascent is the same idea in a camera move. TR already treats the camera journey as a candidate moment (10-08 item 25). The new part is partial reveal: let the body or ring cross the frame before it is ever shown whole.

Draw layers by reach

WebGL1 directsharpens plan

Need4Space's derelict draws in layers by distance:

• shell: from anywhere;
• skin relief: within 2.6 km;
• frames, decks and machinery: within 1.8 km;
• small parts: within 500 m.

Repeated objects are instanced, each group with its own reach. "From further off only the hull's shape counts." This is TR's "pay for what is visible" (2026-10-16), with concrete distances to copy the shape of.

Separate the judge from the author

web-ocean's agent "took screenshots of its own output and had separate subagents critique the screenshots, so it wasn't judging its own work". Berlin Walk's agent wrote its own DevTools-protocol screenshot harness after --screenshot failed against a render loop, and took about 30 screenshots in one session. Scacelith has --shot out.png --frames N headless capture in CI. The Lofoten island author used a different model family for critiques. TR already has Playwright captures and reviewer scores. The addition is that the critic never sees the code or the author's reasoning, only the frame and the target, and ideally comes from another model family.

Stage the Blender work, and light it last

The Blender MCP hospital corridor was built in four prompts:

1. Architectural blockout only, then "pause for approval".
2. Props, dressing and composition across foreground, midground and background.
3. A camera move, "without altering any existing geometry".
4. Relighting with AgX and subtle volumetric haze, "stopping after three lighting test frames are rendered for review".

Each stage freezes the one before it. This is the shape TR's Blender gate needs. Judge form in grey first, then material, then camera, then light, with Scott's verdict between stages. It also matches the 10-20 doc's "judge large forms with simple materials".

Write the style down, then rebuild to it

Formula Minus One wrote a design and style guide ("semi-low poly characters and duotone as design signature") and then threw away and rebuilt every level to match it. The cozy-game author reuses one sketch-derived style prompt for every asset. Judgement Day keeps its city as a plain grey architect's model on purpose. A short written look (palette, contrast, what is never shown) stops each round from drifting toward a generic AI look.

Name a reference frame and a quality bar

Road Rash x DiRT: "a screenshot of a benchmark visual ... reach at least 90% of that quality", then 3 to 4 hours of autonomous iteration per map. That is a machine-usable target where "make it look better" is not. It fits the 10-20 doc's "choose a concrete visual benchmark", and gives the agent a stopping rule.

Expose every visual number as a live dial

The Last Admiral has 100+ live editors; web-ocean has an H panel plus URL parameters for every setting and camera; Cortiz uses Leva; Tidewright puts nine looks behind one uniform. Scott's role in TR is judging. Dials let Scott tune between agent rounds instead of waiting a full round per reaction. URL-param camera poses also make every capture reproducible.

One source of truth per shape

Tidewright's moulds are one GLSL function used by both the simulation and the cursor preview. Its sea is one wave function used by both erosion and rendering. Berlin Walk's memorial ground is one function used by both mesh generation and the character controller. Need4Space's hull description drives the mesh, the interior sunlight and the sky light. TR's 2026-10-16 "one geometric authority" note already points this way.

Quality tiers from measurement, never hiding what matters

Berlin Walk picks its tier from measured frame time in the first 3 seconds. World of ClaudeCraft's fairness doc says presets may shed "COSMETIC richness" but "must never change ACTIONABLE information". For TR, a fracture or a route the player has to read must survive the low tier.

Don't mine a painting for PBR maps

World of ClaudeCraft: generated references "carry baked studio lighting, so their pixels cannot yield honest albedo, roughness, normal, or AO maps." The same reasoning explains why TR's 2026-10-02 Flux projection "paints generic fantasy". Use the concept for palette and form, then derive the maps from geometry.