# gs_pan_concrete The 1,800 m runway: 4.6 x 7.5 m poured slabs with 1.6 cm joints, aggregate speckle and slab-to-slab tone. Binds `pan_surface` in slab mode.

# film The clock, the shot table and the palettes of GREEN SKY. Every other slice talks to this module and to nothing else. ## The clock A fixed **1/24 s per rendered frame**, ignoring the real frame delta. The film is therefore byte-identical on every run whatever the frame rate, so it can be recorded a frame at a time and retimed on the host. Film.FPS 24 Film.FIXED_DT 1/24 Film.DURATION 122 seconds `scenes/main.scene`'s entrypoint calls `Film.build()` once on load and `Film.tick()` once per frame. There is no cutscene, no coroutine timeline and no `task.wait` chain anywhere in the demo. ## The shot table `Film.SHOTS` — eighteen entries, `{ n, seconds, act, name, brief }`. `seconds` is the only timing authority in the film; `greensky/camera` owns where each set-up stands. Shot numbers are stable and are never renumbered, because every slice keys off them. Film.shotAt(t) -> the shot on screen at t, and seconds into it Film.shotStart(n) -> when shot n begins ## Registering a slice local Film = require("greensky.film") local M = {} function M.build() end -- once, on scene load function M.update(c) end -- every frame Film.register("pan", M, 10) -- lower order ticks first The context `c` every update receives: | field | meaning | |---|---| | `t` / `u` | film seconds, and 0..1 across the whole film | | `dt` | always `FIXED_DT` | | `frame` | integer frame counter from 0 | | `shot` / `shotT` / `shotU` | the shot on screen, and progress through it | | `cut` | true on the first frame of a new shot | | `act` | 1, 2 or 3 | | `storm` / `flood` / `clear` | the three progressions, 0..1 | `Film.arcAt(t)` gives those last three at any time, so a slice can ask what act III looks like without waiting for it. ## Two palettes, and they are not the same thing **`Film.PALETTE`** is the **light** — what the sun, the sky and the ambient are doing in the world, per act, plus the discharge. `greensky/sky` reads it every frame. **`Film.PAL`** is the **photograph taken of that light** — the response of the camera's negative, per act. `greensky/camera` reads it every frame and writes it into the `gs_grade` post-process pass. Its fields are `ev` (exposure compensation in stops), `exposure`, `contrast`, `pivot`, `saturation`, `vignette`, `vigInner`, `grain`, and the ASC-CDL triplets `lift` (offset, moves the blacks), `gain` (slope, the whites) and `gamma` (power, the mids). Both carry `dry`, `storm`, `clear` and `flash`, and both are interpolated by the same `c.storm` / `c.clear` ramps, so the light and the photograph of it always agree about which act it is. `Film.mixGrade(a, b, x)` mixes two `Film.PAL` entries. Every `gain` in `Film.PAL` is at or below 1 on purpose: the post chain is display-referred and hard-clipped at 1.0, so a gain above 1 clips the image rather than opening it up. Level lives in `ev`, in stops. ## The site `Film.SITE` — the numbers more than one slice needs about the place: pan radius, runway length and width, hangar position, cloud base and top, the cloud volume's horizontal extent, where the storm enters and leaves, and how deep the flood gets. Everything must live inside 8 km of every camera station, because the far plane is hard-fixed at 8000. ## Curves Film.ramp(t, a, b) smoothstep, 0 before a and 1 after b Film.lerp(a, b, x) Film.mix3(a, b, x) mix two {r, g, b} Film.clamp01(x) ## Files film.module/init.luau this module ../design/spec.md read this before changing any of it ../design/shotlist.md the eighteen shots as written

# gs_pan_marker The 60 painted runway edge posts. Orange, grainy, no lattice — a post 22 cm across has no room for one.

# gs_pan_crust The salt crust the macro shots stand on: 62 cm polygons with dark cracks, a curled rim on every plate, plate-to-plate tone and salt glint. Binds `pan_surface` in voronoi mode. Carried from bleached ochre to soaked slate by the `wetness` the pan slice writes each frame.

# greensky/pan/water The standing water: `pan_flood` (a 420 m wind-chopped sheet over the ground the low cameras stand on) and `pan_flood_far` (the flat disc carrying it to the horizon), both drawing with `gs_water.material`. `build(anchor, Geom)` stands the two surfaces up. `update(c, waterY)` moves them — the sheet's `localScale.y` is the sea state and its `localPosition` is the wind carrying the wave pattern across the pan — and then writes this frame's sky into the material. That second half is the point of the module. `gs_water` has no baked look: it evaluates the sky analytically along the reflected ray, because with no reflection probe in this world the PBR environment term is exactly black. The horizon and zenith colours, the storm deck's lid, the discharge level and the rainbow's strength therefore have to be handed to it, and they are computed here from the same palette and the same two arc curves the sky slice uses — so the water holds the sky that is actually above it, on the same frame. `look(c)` returns that whole set as a plain table without touching the scene, so a check can ask what the water is at any instant; `report()` says where the two surfaces are standing right now.

# gs_pan_ring The 30 tie-down rings on the apron. Dark pitted steel.

# gs_pan_hangar The hangar and the windsock pole: corrugated steel sheet with 42 cm ribs, panel seams every 3.1 m and weathering running down. The rib fades out with its screen-space footprint, so a roof seen from a kilometre is a smooth sheet rather than moire.

# greensky/pan/geom — mesh building for the pan An accumulator you push faces into, and the shapes the salt flat is made of. Everything here is pure geometry: it produces flat position / index / normal / uv arrays, and `Geom.upload` hands them to `renderer.mesh.create`. Used only by `greensky/pan`. ## Winding `renderer.mesh.create` reads a triangle's front face as the one where `cross(v1 - v0, v2 - v0)` points out of it. `Geom.quad` takes its four corners in that order and emits `(0,1,2)` + `(0,2,3)`, so every builder below states its corners front-face-first and no face needs `cull = "none"`. ## The surface ```luau local Geom = require("greensky.pan.geom") local a = Geom.acc() -- an empty accumulator Geom.vert(a, x,y,z, nx,ny,nz, u,v) -- one vertex, returns its index Geom.tri(a, i0, i1, i2) Geom.quad(a, p0, p1, p2, p3, nx, ny, nz, uvScale) -- a flat quad, planar UVs Geom.box(a, x0,y0,z0, x1,y1,z1, uvScale, skipBottom?) -- an axis-aligned box Geom.disc(a, cx, y, cz, radii, segs, uvScale) -- a horizontal disc, ring radii inner to outer Geom.plate(a, cx, cz, r, y, sides, rot, yBase?, uvScale) -- a flat polygon with an optional skirt Geom.field(a, cx, cz, sizeX, sizeZ, nx, nz, fn, uvScale) -- a height field, fn(x, z) in world space Geom.upload(a) -- -> MeshHandle Geom.stats(a) -- { verts, tris } Geom.rng(seed) -- :next() 0..1, :range(lo, hi) ``` `uvScale` is metres per UV unit. `Geom.field` takes its normal from four neighbouring samples of `fn`, so a wave shades correctly without the caller differentiating it. `Geom.rng` is a plain LCG. The film has to be byte-identical run to run, so nothing in the pan may reach for `math.random`. ## Note on runtime meshes A mesh made by `renderer.mesh.create` from raw geometry is not CPU-resident, so `renderer.mesh.setVertices` refuses it — `renderer.mesh.update` with whole geometry is the way to change one after the fact, and it costs about 5 ms for 9,400 vertices. The pan builds static geometry once and animates it by moving and scaling the entity instead.

# gs_pan_apron The concrete in front of the hangar and the taxiway joining it to the strip. Larger, dirtier, more stained slabs than the runway.

# gs_pan_paint The runway centreline dashes, edge lines and threshold bars. Carries the concrete lattice underneath it so the slab joints run through the paint, plus heavy wear mottling.

# gs_pan_ground The salt flat itself, from under the crust plates out to the horizon. The same voronoi network as `gs_pan_crust` at a coarser second scale, plus a macro mottle that never fades so the far pan is not one flat tone.