From 61e0c66f61a3e526aa0ee95d25e8fc850d2691f3 Mon Sep 17 00:00:00 2001 From: Dejvino Date: Wed, 19 Aug 2026 17:24:28 +0200 Subject: [PATCH] Pylon Grid stands the song's object on its pylons MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The scene already had the depth axis the solid wants — near rows large, far rows small, converging on the track's horizon — which made the flat crown the one element in it drawn without perspective: a sticker facing the viewer on top of a receding structure. Each crown is now marched, and each pylon turns its own at its own angle, so a single field shows the form from a dozen sides at once. 12/12 on the gate, 7ms/frame at 4K against a 60ms ceiling. A hundred and sixty instances stay affordable on the two guards MIGRATION.md now documents, and here first-wins is the correct occlusion as well as the cheap one, because the rows are already walked near to far. IT MEASURES SLIGHTLY WORSE and the scene's header says so: 0.141 to 0.134 over 8 songs x 8 seeds, nearly all of it layout (0.156 to 0.126). Two candidate causes were tested and both came back flat — keeping the far rows stamped scored 0.132, and running the lit surface through inkPattern scored 0.132 here and moved Effigy by 0.0009. It is the solid itself: a body always fills its own silhouette, where a stamped cast form paints anywhere between an outline and a disc depending on whether the identity is hollow, and that swing was worth three hundredths of layout variety. Kept because the score does not measure what was wrong. A crown that ignores the perspective of the field it stands in is a defect no coverage variance reports, and the header records the number and the two-line revert for whoever disagrees. The inkPattern experiment is reverted rather than left in as a plausible-looking no-op, with its measurements written where the next person will look for them. Co-Authored-By: Claude Opus 5 --- flow-state/src/engine/shader-contract.js | 7 +++ flow-state/src/scenes/shader/pylon-grid.js | 56 ++++++++++++++++++++-- 2 files changed, 59 insertions(+), 4 deletions(-) diff --git a/flow-state/src/engine/shader-contract.js b/flow-state/src/engine/shader-contract.js index 6c8dd8b..d36414e 100644 --- a/flow-state/src/engine/shader-contract.js +++ b/flow-state/src/engine/shader-contract.js @@ -955,6 +955,13 @@ vec3 castLit(vec3 n, vec3 rd) { vec3 col = mix(pal(1) * 0.22, pal(2), diff); col += pal(0) * fill; col += pal(3) * rim * 0.55; + + // Tried and reverted: modulating this by inkPattern, on the theory that a + // lit solid is the one thing in the video ignoring the track's FILL. It + // reads well and measures nothing — Pylon Grid 0.1324 to 0.1322, Effigy + // 0.2382 to 0.2373, both inside the last digit that means anything. The + // fill is already carried by the outline every solid scene draws beside the + // body, and by inkValue below. return inkValue(col); } `; diff --git a/flow-state/src/scenes/shader/pylon-grid.js b/flow-state/src/scenes/shader/pylon-grid.js index 775e613..8ba2fd9 100644 --- a/flow-state/src/scenes/shader/pylon-grid.js +++ b/flow-state/src/scenes/shader/pylon-grid.js @@ -1,8 +1,32 @@ // Structural family: a field of standing pylons receding to the track's // horizon. The columns converge on a vanishing point, giving real perspective -// depth, and each column carries a crown in the signature form so a hexagonal +// depth, and each column carries the song's own object on top, so a hexagonal // track grows hexagonal pylons. The beat walks a pulse of light down the rows // rather than flashing the whole frame. +// +// The crowns are SOLID. This scene already had the one thing the 3D cast needs +// and most scenes lack — a real depth axis, with near rows large and far rows +// small — so a flat crown was the only part of it drawn without perspective: a +// sticker facing the viewer on top of a receding structure. Marching them puts +// the object in the same space as the field it stands in, and because each +// pylon turns its own crown at its own angle, one field shows the song's form +// from a dozen sides at once. See castSolid. +// +// IT MEASURES SLIGHTLY WORSE, and that is worth writing down rather than +// discovering again. Over 8 songs x 8 seeds the flat version scored 0.141 and +// this one scores 0.134, almost all of it in the LAYOUT block (0.156 to 0.126). +// The cause is not resolution, and not the ink: two candidate fixes were tried +// and both measured flat — a size threshold keeping the far rows stamped +// (0.132) and running the lit surface through inkPattern (0.132). It is the +// solid itself. A body always fills its own silhouette, where a stamped cast +// form paints anywhere between an outline and a disc depending on whether the +// song's identity is hollow or has an outline-only fill, and that swing was +// worth three hundredths of layout variety. +// +// Kept anyway, because the variety score does not measure the thing that was +// wrong: a flat crown on a receding pylon is the one element in this scene that +// does not obey its own perspective, and no amount of coverage variance fixes +// that. Reverting is a two-line change if the number matters more. export const pylonGrid = { name: 'Pylon Grid', @@ -13,7 +37,7 @@ export const pylonGrid = { // Personality: see look/Personality.js. // Takes the track's surface grain, but lightly — this is drawn, not filmed. texture: 0.4, - consumes: ['cast', 'ink'], + consumes: ['form', 'ink'], traits: ['shape', 'space', 'style'], params: { @@ -45,6 +69,11 @@ vec4 scene(vec2 uv, vec2 p) { float hy = sigHorizonY(); vec3 col = pal(0) * 0.05; + // Whether a crown already owns this pixel. Rows are walked near to far, so + // first-wins is the correct occlusion here rather than merely the cheap one + // — and it bounds a hundred and sixty instances to about one march. + float painted = 0.0; + for (int r = 0; r < 10; r++) { if (float(r) >= u_rows) break; float fr = float(r); @@ -72,10 +101,29 @@ vec4 scene(vec2 uv, vec2 p) { float w = 0.02 * scale + 0.006; col += pal(int(mod(fc, 4.0))) * strut(p, cx, y0, yTop, w) * inten; - // Crown stamped in the track's signature form. + // The song's object, standing on the pylon. vec2 crown = vec2(cx, yTop); float size = (0.06 + 0.2 * scale) * (1.0 + u_beat * 0.4); - col += pal(3) * castForm(p, crown, size) * inten * (0.6 + u_pulse); + vec2 local = (p - crown) / max(size, 1e-3); + + if (dot(local, local) < 1.6 && painted < 0.5) { + // Each crown at its own angle, so the field is one form seen + // from many sides rather than one silhouette repeated. The turn + // is slow and per-pylon; the row term keeps a receding line of + // them from presenting the same profile all the way back. + mat3 turn = castTurn(t * 0.6 + fc * 0.9 + fr * 0.4, 0.2 + sin(t + fr) * 0.2); + vec3 n; + float hit = castSolid(local, turn, n); + if (hit > 0.0) { + painted = 1.0; + col = mix(col, castLit(n, vec3(0.0, 0.0, 1.0)) * inten * (0.6 + u_pulse), 0.92); + } + // Its outline in the track's line weight, which is what carries + // the far rows: at twelve percent scale a crown is a few pixels + // and the lit faces are gone before the edge is. + float d = castSDF3(turn * vec3(local, 0.0)) * size; + col += pal(3) * inkStroke(d) * inten * (0.5 + u_pulse); + } col += pal(int(mod(fr, 4.0))) * exp(-dot(p - crown, p - crown) * 60.0) * u_pulse * depthShade; } }