groundAt(r: number, th: number) → void

Height of the stone under a polar point, and the radius the crater's warp actually put that ring at.

rng(seed: number) → void

Deterministic noise. The film must look the same on every run, so nothing here touches `math.random`. xorshift32 through `bit32`, NOT a plain LCG. A 32-bit LCG written in Lua arithmetic multiplies past 2^53 and loses its low bits to double rounding, so it degenerates into near-identical consecutive draws — which showed up here as pairs of plants sharing a position, a size and a phase.

lerp(a: number, b: number, x: number) → number

zoneSpan(zone: number) → void

Placement The radial span of a zone's flat. Zone 0 is the garden floor around the pool; zone `i` is terrace `i`, running from its own retaining wall out to the next.

flatPoint(zone: number, rand: () → void

A point on a zone's flat, taken off the crater's OWN surface so it sits on the stone rather than on the height a formula guessed.

wallPoint(zone: number, rand: () → void

A point on the retaining wall that holds terrace `zone` up: the vertical face standing at that terrace's inner radius, between the surface below and its own.

pickZone(rand: () → void

makeBeds( ) → void

bedPoint(bed: Bed, rand: () → void

A point inside a bed, denser at its middle.

anchorAt(name: string) → void

Seeding. Every plant gets a PHASE. It is the plant's place in time: when it emerges, when it opens, how its breath is offset. The array is sorted by phase, so the drawn instance count can simply climb with the growth curve and the plants that are not up yet cost nothing.

seedPopulation(spec: any) → void

makeAsset(kindName: string, name: string, opts: any) → any

Materials `asset.create`'s third argument is type-specific and the checker only knows one shape for it, so a material's own property table goes through a widened local rather than being written at the call site.

makeMaterials( ) → void

leafPair(nightMul: number) → void

gpuBuffer(name: string, ty: string, len: number, readback: boolean?) → void

Build

build( ) → void

Stand the whole garden: four meshes, four materials, three static seed buffers and two per-frame buffers per population, and one `drawInstanced` each. Safe to call again — it tears the previous populations down first.

teardown( ) → void

Drop every population, buffer and mesh this module stood. A hot-reload replaces this module's table, and the previous instance's populations are still registered with the renderer while nothing holds a handle to them — so the sweep goes by the buffer NAMES the draws were registered under rather than by what this table happens to remember.

apply(t: number) → void

The garden's whole animation for film time `t`: seven scalar params, one dispatch per population, one instance count per population.

report( ) → void

What the garden currently holds — one row per population, with the count it reserves and the count it is drawing this frame.

readLanes(name: string, first: number, count: number) → any

Start a readback of one population's lane buffer: `count` instances from `first`, four vec4 lanes each. Returns a pending handle — drain it with `:result()` a frame or two later. The read that answers whether every member of a population really is at its own moment.