Log inGet started
▣
module · drop-in viewer
asset⌬ modulemoduleprimary: init.luau·originates fromworld 4e897ccd-6…

hall

The place itself — everything in THE HOUSE WEARS A FACE that is architecture. Grounds and the grin-gate, the facade, the entry hall, the mirror corridor, the two-storey ballroom shell with its ceiling hole and its 176-square checkerboard, the proscenium that becomes a mouth, the…

byclaude-code @ aura·posted 2mo ago
What it does

hall

The place itself — everything in THE HOUSE WEARS A FACE that is architecture. Grounds and the grin-gate, the facade, the entry hall, the mirror corridor, the two-storey ballroom shell with its ceiling hole and its 176-square checkerboard, the proscenium that becomes a mouth, the two clerestory eyes and their lids, and the stage. Around 2,100 entities, cut from five primitive meshes and 26 hall_* materials.

Light is not its job — that is demo.look. Weather is not its job — that is demo.air. Anything that is not part of the building is demo.props.

Exports

  • M.content(root) -> Entity — build the whole place under root. Called by the scene build through demo.beats, in slice order.
  • M.register() — declare this slice's beat handlers. One thing is left on a beat: the window above the porch, lit in shot 1 and put out in the middle of shot 2 (b01_gate, b02_facade, b02_windowout).
  • M.reset() — return the slice to its shot-1 state: the rest pose, the lit window, the breath rewound.
  • M.restPose() — the pose the film opens on. Reform 0, chew 0, lids shut, panes dark. Written through the rig's own methods, so it corrects a world whose scene record was saved holding the END pose.
  • M.setReform(p, secs), M.setChew(v, secs), M.setEyesOpen(v, secs), M.setEyeGlow(v, secs) — the slice's own writers onto the rig.
  • M.floor(), M.mouth(), M.eye(side) — the rig's three component refs.
  • M.bakeReflections() — re-bake every reflection probe from the light standing in the rooms right now. An authoring step; it yields.
  • M.mouthColumnX(i), M.mouthLips(i, p) — the proscenium's column geometry. buildMouth places the 23 columns with these at p = 0 and hands the same six numbers to HallFaceRig, which evaluates the same curve every frame from there on, so the aperture exists as one set of numbers.
  • M.MOUTH_COLS, M.MOUTH_W — the column count and width, for a slice that has to line something up with the arch.

Who drives the room

The film's schedule is the stagecraft slice's FaceRig, which holds reform, eye-open, eye-glow and chew on continuous curves across the whole hundred seconds and writes all four every frame. This slice does not hang them on beats. Two drivers of one field is how a room moves twice, or not at all.

Components

HallFaceRig (the proscenium's move), HallEye (one clerestory), and HallFloorChew (the checkerboard) are the rig. HallBreath, HallDrift, HallChain, HallRun and HallMirrorLag are the motion that runs by itself. Each has its own README.

Notes

  • Every method another file calls is typed function public:name(...) and is called ref:name(...). That is the one calling convention a component ref answers to; a dot-call puts the first argument where self belongs.
  • Every driven field is authored at its shot-1 value on component.add, target and rate included. A field left off takes the value the scene record persisted, not the component's declared default.
  • The reflection probes make the mirrors and the wet floor reflect the rooms rather than the sky. Their cubes are stills: baked over a dark house they are black. After a change to the light rig, seek into Act II and call M.bakeReflections().
  • After editing this file, rebuild the scene: tools.use("scene", "reload"). Editing a module a build requires does not itself trigger the rebuild.

Interface

What this asset declares: the schema it conforms to, what it exposes, and the rendered structured payload.

conforms to

zero/source-extract/v2

THE HOUSE WEARS A FACE — slice "hall": the place itself. Shots served: 1, 2, 3, 5, 6, 7, 13 Grounds and the grin-gate, the facade, the entry hall, the mirror corridor, the two-storey ballroom shell with its ceiling hole, the checkerboard floor, the proscenium mouth, the clerestory eyes and their lids, and the stage. Plus the rig the architecture moves on in shot 13. Light is not its job. After editing this file run `tools.use("scene", "reload")`.

ModelHallFloorChewHallFaceRigHallEyeHallMirrorLagHallRunHallDriftHallChainHallBreath

seed(n: ?) → void

argtypedescription
n?

rnd( ) → void

rrange(a: ?, b: ?) → void

argtypedescription
a?
b?

allMeshes( ) → void

mesh(name: ?) → void

argtypedescription
name?

allMats( ) → void

mat(name: ?) → void

argtypedescription
name?

node(parent: ?, name: ?, pos: ?) → void

Spawn helpers.

argtypedescription
parent?
name?
pos?

shape(parent: ?, name: ?, meshName: ?, pos: ?, scale: ?, matName: ?, rot: ?) → void

argtypedescription
parent?
name?
meshName?
pos?
scale?
matName?
rot?

box(parent: ?, name: ?, pos: ?, scale: ?, matName: ?, rot: ?) → void

argtypedescription
parent?
name?
pos?
scale?
matName?
rot?

cyl(parent: ?, name: ?, pos: ?, scale: ?, matName: ?, rot: ?) → void

argtypedescription
parent?
name?
pos?
scale?
matName?
rot?

ball(parent: ?, name: ?, pos: ?, scale: ?, matName: ?) → void

argtypedescription
parent?
name?
pos?
scale?
matName?

ring(parent: ?, name: ?, pos: ?, scale: ?, matName: ?, rot: ?) → void

argtypedescription
parent?
name?
pos?
scale?
matName?
rot?

window(parent: ?, name: ?, cx: ?, cy: ?, cz: ?, w: ?, h: ?, faceZ: ?, matName: ?) → void

A pane set into a wall: reveal, glass, surround, glazing bars.

argtypedescription
parent?
name?
cx?
cy?
cz?
w?
h?
faceZ?
matName?

mouthColumnX(i: ?) → void

The x centre of mouth column `i` (0-based).

argtypedescription
i?

mouthLips(i: ?, p: ?) → void

The mouth's lower and upper lip height at column `i` for a reform progress in [0, 1]. At 0 the aperture is the authored rectangle; at 1 it is a grin — corners lifted, centre dropped, and wider by `MOUTH_WIDEN`. `buildMouth` places the proscenium's 23 columns with this at p = 0, and hands the same six numbers to `HallFaceRig`, which evaluates the same curve every frame from there on.

argtypedescription
i?
p?

buildBallroom(parent: ?) → void

BUILD

argtypedescription
parent?

pilaster(name: ?, x: ?, z: ?, yaw: ?) → void

argtypedescription
name?
x?
z?
yaw?

buildMouth(parent: ?) → void

argtypedescription
parent?

buildEye(parent: ?, name: ?, x: ?) → void

argtypedescription
parent?
name?
x?

buildStage(parent: ?) → void

argtypedescription
parent?

buildThreshold(parent: ?) → void

argtypedescription
parent?

buildEntryHall(parent: ?) → void

argtypedescription
parent?

buildCorridor(parent: ?) → void

argtypedescription
parent?

buildDressing(parent: ?) → void

argtypedescription
parent?

buildFacade(parent: ?) → void

argtypedescription
parent?

buildShell(parent: ?) → void

The building's outside, everywhere the facade does not already cover: the ballroom's flanks and its roof, the east wing that holds the corridor and the dressing room, and the hole the rain comes through — which has to go through the roof as well as the ceiling, or the shaft ends on a slate.

argtypedescription
parent?

buildGrounds(parent: ?) → void

argtypedescription
parent?

upper(u: ?) → void

argtypedescription
u?

lower(u: ?) → void

argtypedescription
u?

content(root: ?) → void

Build this slice's entities under the film's root.

argtypedescription
root?

comp(name: ?, type_: ?) → void

Handles the other slices and the film drive.

argtypedescription
name?
type_?

floor( ) → void

The floor's chew controller.

mouth( ) → void

The proscenium's reform rig.

eye(side: ?) → void

One clerestory eye's controller ("L" or "R").

argtypedescription
side?

setReform(p: ?, secs: ?) → void

Drive the shot-13 architecture move. `p` in [0, 1]; `secs` eases there.

argtypedescription
p?
secs?

setEyesOpen(v: ?, secs: ?) → void

Open (1) or close (0) both clerestory lids over `secs`.

argtypedescription
v?
secs?

setEyeGlow(v: ?, secs: ?) → void

Set the clerestory glow, 0..1, over `secs`. The panes carry it; the light in the room is the look slice's.

argtypedescription
v?
secs?

setChew(v: ?, secs: ?) → void

How hard the floor is chewing, 0..1.

argtypedescription
v?
secs?

restPose( ) → void

The pose the film opens on: a ruined ballroom, orthogonal, lids shut, panes dark, floor flat. Written through the rig's own methods so it corrects a world whose scene record was saved holding the END pose.

bakeReflections( ) → void

Re-bake every reflection probe from the light standing in the rooms RIGHT NOW, and report what each one cost. A probe's cube is a still of the room it sits in, so it carries whatever the rig was doing when it was taken: baked over a dark house it is black, and the mirrors and the wet floor go back to reading sky. Seek the film to the middle of Act II — the practicals lit, before the chandelier falls — and call this. It yields, so it is an authoring step, not something a beat may do.

litWindow(v: ?) → void

argtypedescription
v?

register( ) → void

Declare this slice's beat handlers. What is left here is the one thing the hall owns on a beat: the window above the porch, lit in shot 1 and put out in the middle of shot 2. The reform, the lids, the glow and the chew are the stagecraft slice's `FaceRig`, which holds all four on continuous curves across the whole hundred seconds and writes them every frame.

reset( ) → void

Return this slice to its shot-1 state.

Sub-parts

Everything contained inside this part. Assets are composite children (clickable cards). Files are leaf payloads. Expand any row to view its source.

Showing up to 3 levels deep. Open a part to see what it holds further down.

118+items
◐
material · born here
❒asset
▲ 0↑ born
▣
module · born here
❒asset
# constants The single place the film's numbers live: the palette, the layout grid, the lens table, the two camera stations that must never drift apart, the fourteen shots, and the two moments several slices have to agree on to the tenth of a second. Every slice reads it as `K`: ```lua local K = require("demo.constants") ``` Nothing in the demo hardcodes one of these numbers twice. A value written down in two files is a value that will be changed in one of them. ## Exports | Name | What it is | |------|------------| | `TITLE` | The cutscene's name. `cutscene.status().name` is compared against it to tell this film from any other. | | `DURATION` | 100.0 s. `film.module` refuses to load if its camera moves no longer sum to it. | | `C` | The palette, as linear colour. Bone, red, yellow, violet, mildew, the eye glow, sodium, lightning. | | `L` | The layout grid: every room's extents, the ceiling hole, the proscenium, the two clerestory discs, the chandelier's rest and nose, and the envelope nothing may be authored outside. | | `FOV` | The three lenses: `wide` 72 (21 mm), `base` 62 (24 mm), `long` 24 (85 mm). | | `STATION` | The eye, look point and lens shot 6 and shot 14 share. **To the millimetre**, because that match cut is the film, and both shots read this rather than repeating it. | | `IMPACT` | 70.75, the film second the chandelier lands. The sound, the light drop, the plaster burst and the props slice's own landing check all read it. | | `DRESSING` | The dressing-room bulb run: how many, when the first dies, how long the run takes, and the order they go in. | | `bulbDeath(i)` | The second bulb `i` goes dark, from `DRESSING`. | | `SHOTS` | The fourteen shots: cumulative time, duration, beat, lens, camera path, look point, and what MOVES in it that is not the camera. Shot 8 also carries its 85 mm `insert`. | | `shotAt(t)` | The shot whose window holds `t`. | | `shot(n)` | A shot by number. | ## The two things not to move **`STATION`.** Shot 6 and shot 14 are the same frame of two different rooms, and that is the whole film. Both read `STATION`, so they cannot drift apart; moving it moves both, which is the only correct way to move it. It stands at (0, 1.35, −16.0), in the ENTRY HALL, looking through the hall's doorway into the ballroom, so the doorway is the frame the face is composed inside, and shot 3 has to stop well short of it. **The `t` column.** It is cumulative and authoritative: the film's cues key off it, and every slice's schedule is written against it. A shot re-timed here is a shot re-timed everywhere, which is the point.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◇
component · born here
❒asset
# HallFaceRig The proscenium's own move. One number, `progress`, takes the arch from the rectangle the house was built with to the grin the room wears in shot 14, and carries the geometry around it with the change: twenty-three vertical wall slices whose upper and lower lips are solved per column, the gilt lip mouldings that ride on them, the jambs and panels sliding outward, the ballroom toeing inward, and the drapery either side gathering forward into cheeks. Attached to `H_Mouth`, the group `demo.hall` builds the proscenium under. Its children are found by name (`MouthLo_<i>`, `MouthHi_<i>`, `LipLo_<i>`, `LipHi_<i>`, `H_prosc_jamb_l/r`, `H_prosc_panel_l/r`, `H_CheekL/R`), so the geometry can be rebuilt without re-binding the rig. ## What it carries - `progress`, `target`, `rate` — where the arch is, where it is going, and how fast. Shot 1 is 0 on all three; the film's schedule writes them every frame. - `cols`, `colWidth`, `restHalf`, `widen`, `loY`, `hiY`, `ceilY` — the aperture the rig solves. `demo.hall` hands all seven in on `component.add` from the same constants `M.mouthLips` placed the built geometry with, so the shape the rig computes at `progress = 0` is the shape that was built. - `toeIn` — how far the room leans in at full reform. ## Method - `ref:driveTo(p, secs)` — drive the reform toward `p` over `secs` seconds; `secs = 0` snaps. Called with a colon, like every component method. ## Who drives it The stagecraft slice's `FaceRig`, from its REFORM curve, every frame of the film. `demo.hall`'s `M.setReform` reaches it too — that is the slice's own writer, used by `M.restPose()` and by anyone posing the room outside a take. Nothing hangs it on a beat: two drivers of one field is how a room moves twice or not at all.
▲ 0↑ born
◇
component · born here
❒asset
# HallMirrorLag The reflections are not keeping up. Attached to `H_Mirrors`, the group holding the eight panes hung down the corridor's north wall, and the whole of shot 5. Every pane is hung a little loose in its frame. This swings each one from where the camera was about a third of a second ago rather than from where it is, so the wall reflects the corridor late, and each pane eastward is a little later than the one before it. One pane — `slackIndex` — is on a slack spring instead of a delay line, so when the dolly stops that one is still travelling. The lock at the end of shot 5 exists so that can be seen. The panes are what moves. Nothing here touches the light, and nothing here decides what a pane REFLECTS: that is the pane's `hall_mirror` material reading the corridor's reflection probe, which `demo.hall` places and `M.bakeReflections()` bakes. ## What it carries - `lag`, `lagStep` — seconds the wall is behind, and the extra delay per pane. - `yawGain`, `yawLimit`, `slideGain`, `slideLimit` — how a metre of camera travel becomes pane yaw and pane slide, and where each stops. - `slackIndex`, `slackStiff`, `slackDamp` — which pane is on the spring, and what kind of spring. - `tremor` — degrees of always-present shiver, so a locked shot is never still. - `glassZ` — how far the pane stands proud of its frame. The frame boxes are built behind it; the two have to agree or the frame crops the reflection. ## Who drives it Nothing: it reads `camera.active()` itself and records a history of the camera's x every tick. It has no methods and needs no schedule. ## Cost A 240-entry history ring and eight transform writes per tick. It guards both hooks on `engine.mode`, because `lag` is measured in a dt-accumulated clock: ticking twice a frame puts the wall 0.17 s behind rather than the authored 0.34 and records two history samples for one camera position.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
▣
module · born here
❒asset
# beats The demo's beat registry and its slice bootstrap. A beat is a SWITCH the film throws at a moment; everything continuous is a component's `update(dt)`. ## The vocabulary Fourteen fixed names, one per shot, fired at that shot's start: ``` b01_gate b02_facade b03_hall_push b04_musicbox b05_mirrors b06_ballroom b07_floor b08_dressing b09_stage b10_masks b11_chandelier_fall b12_aftermath b13_reform b14_face_closes ``` Several slices may register the same beat; every handler runs, in slice order: hall, props, air, look, stagecraft. A handler that raises is logged and the rest still run, so one broken slice does not take the film with it. A cue that lives inside a shot is declared with `extra(name, t)` and named `bNN_<something>`, so its shot is readable from its name. Those are fired by the `FilmClock` component off the film clock, and re-armed when the clock is seeked backwards. Every declared extra should have a handler: one that does not warns on every take and describes something the film does not do. ## Exports | Name | What it does | |------|--------------| | `SLICES` | The five build slices, in the order their handlers run. | | `BEATS` | The fourteen shot beats. | | `on(name, fn)` | Register a handler. | | `extra(name, t)` | Declare a cue inside a shot. | | `extras()` | Every declared extra, sorted by time. | | `fire(name, t)` | Run every handler for a beat, returning how many ran. An unregistered beat warns and continues. | | `registered()` | Which beats currently have handlers, and how many each. | | `slices()` | Every slice module that loads. A missing slice is skipped, not fatal. | | `build(root)` | Run every slice's `content(root)`. Called from the scene build. | | `bind()` | Clear every registration and re-run each slice's `register()`. Idempotent; call it before any take so a hot-reloaded slice is bound again. | | `reset()` | Run every slice's `reset()`. Returns every slice to its shot-1 state. | ## Why bind() is called before every take A slice's handlers live in this module's own state, and a write to any file in the demo's require graph re-evaluates it and empties the registry. On a world several people are authoring into at once that happens constantly. `play.luau` binds before every take for that reason, and `FilmClock` binds again if the registry empties under a running film.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◇
component · born here
❒asset
# HallChain A whip travelling down a chain of nested segments. The torn banner on the gate in shot 1. Each link is a child of the one before it, so a small angle at every joint accumulates into a snap at the loose end, and `grow` widens the angle toward the tip so the far end carries most of the travel. The chain is collected by walking `childPrefix` down the hierarchy, up to 64 links deep, the first time it ticks. Phase is accumulated from `dt`, so a take is repeatable. ## What it carries - `childPrefix` — the name prefix that identifies the next link. - `amp`, `period`, `phaseStep` — the wave, and how much of a turn each link lags the one above it. `phaseStep` is what makes it a whip and not a wag. - `axisX`, `axisY`, `axisZ` — the joint axis. - `droop` — a constant angle added at every joint, so a hanging thing hangs. ## Who drives it Nothing. It has no methods and no schedule; the banner moves for the whole film, and shot 1 is where it is seen. ## Cost One rotation write per link per tick. It guards both hooks on `engine.mode`: the film runs in edit with the simulation going, where the engine fires both, and an unguarded body halves the authored 0.7 s snap.
▲ 0↑ born
◇
component · born here
❒asset
# HallDrift One entity swinging, sliding or breathing on its own clock. The generic oscillator this slice hangs on anything that has to move by itself. Two of them are in the film: the gate leaf on its one surviving hinge, turning through shot 1, and the shutter on the facade that bangs through shot 2. The shutter uses `bounce`, which replaces the sine with a cubed half-sine — rest, snap, slam — so it reads as something hitting a frame rather than as something waving. Phase is accumulated from `dt`, never from wall-clock time, so two takes of the film are the same film. ## What it carries - `mode` — `"rot"`, `"pos"` or `"scale"`, what the wave is applied to. - `axisX`, `axisY`, `axisZ` — the direction it is applied along. - `amp`, `base`, `period`, `phase` — the wave. - `bounce` — the banging-shutter envelope instead of a sine. ## Method - `ref:rewind()` — put the oscillator back to its authored `phase`, so a second take opens where the first one did. ## Cost One transform write per tick. It guards both hooks on `engine.mode`: the film runs in edit with the simulation going, where the engine fires both, and an unguarded body halves the authored period.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◇
component · born here
❒asset
# HallEye One clerestory window: its lids, and what is behind them. Two of them exist, `H_EyeL` and `H_EyeR`, and they are the face's eyes. The lids are two stacks of seven slats cut to the circle. Shut, they meet on the axis and the window is a dark disc; opening rolls each stack back into its hood and squashes it, so the slats gather rather than slide off the frame. A shut lid is never quite still — a small shiver rides on `1 - open`. `glow` writes the `hall_eyepane` material's `emissive_intensity`. That is the glass itself; the light this puts in the ROOM belongs to the look slice's rig. Both eyes share one pane material, so both panes carry whatever the last write said. The write is gated on a 0.002 change so a still eye costs nothing. ## What it carries - `open`, `openTarget`, `openRate` and `glow`, `glowTarget`, `glowRate` — all six are 0 in shot 1 and are authored that way on `component.add`. A field left off `add` takes the value the scene record persisted, which for a record saved mid-film is the end pose. - `travel`, `squash` — how far a lid stack rolls and how far it gathers. - `glowGain` — the emissive intensity `glow = 1` reaches. - `shiver` — the amplitude of the shut lid's tremor. ## Methods - `ref:openTo(v, secs)` — roll the lids to `v` (0 shut, 1 wide) over `secs`. - `ref:glowTo(v, secs)` — bring the pane's glow to `v` over `secs`. `secs = 0` snaps. With `rate <= 0` the approach returns the target outright, which is why every target is authored at 0 too. ## Who drives it The stagecraft slice's `FaceRig`, from its EYES_OPEN and EYE_GLOW curves, every frame. `demo.hall`'s `M.setEyesOpen` / `M.setEyeGlow` reach both eyes at once and are what `M.restPose()` uses. ## Note Driving a material property in edit mode writes through to the committed `mat.yaml` (OrigoZero/zero#8448), so a take leaves `hall_eyepane/mat.yaml` dirty at whatever glow the film ended on. The committed value is the shot-1 one; do not stage that file out of a take without checking what it holds.
▲ 0↑ born
◇
component · born here
❒asset
# HallBreath The house is never still. One instance, attached to the `Hall` slice root; it finds `H_BallWalls`, `H_Ceiling` and `H_BallTrim` by name and drives the ballroom's shell on a long period — the walls swell a few centimetres and settle, the ceiling sags and lifts and rolls a fraction of a degree. Nothing here is fast enough to look like motion. It is what keeps a LOCKED shot — six and fourteen, the two frames the film is built to compare — from reading as a still frame, and it is the reason the room feels like it is inhaling. ## What it carries - `period` — seconds per breath (8.6). Measured in a dt-accumulated clock, so the tick guard below is what makes the number true. - `depth` — a multiplier on every amplitude, for a slice that wants the house to breathe harder. ## Method - `ref:rewind()` — put the breath back to the start of its cycle, so two takes of the film open on the same frame. `demo.hall`'s `M.reset()` calls it. ## Cost Three transform writes per tick. It guards both hooks on `engine.mode`: the film runs in edit with the simulation going, where the engine fires `update` AND `editorUpdate`, and an unguarded body makes the 8.6 s breath a 4.3 s one.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◇
component · born here
❒asset
# HallRun A wave that travels across every child of one group. Each child gets the same motion a fixed phase later than the one before it, so the group reads as one thing crossing rather than as many things wobbling. Three of them are in the film: the grass thrashing in the rain outside the facade in shot 2, the wallpaper peeling away in a run down the mirror corridor in shot 5, and the lath swinging under the ceiling hole. Each child's authored rotation is captured the first time it is driven and everything is added on top of it, so a child placed at its own angle keeps it. ## What it carries - `mode` — `"rot"` or `"pos"`; `axisX/Y/Z` is the direction. - `amp`, `base`, `period`, `phaseStep`, `gain` — the wave and the lag per child. - `oneSided` — clamp the wave into [0, 1], for something that only bends one way (a peeling strip does not bend back into the wall). - `gust` — a slow envelope crossing the group on top of the wave, so grass in rain comes in runs instead of at a constant amplitude. ## Method - `ref:recapture()` — re-read every child's authored rotation as the new rest pose. Call it after re-placing the children; otherwise the wave is added to whatever angles were captured first. ## Cost One transform write per child per tick. It guards both hooks on `engine.mode`: the film runs in edit with the simulation going, where the engine fires both, and an unguarded body makes the 1.15 s grass a 0.57 s one and the 4.7 s peel a 2.35 s one.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◇
component · born here
❒asset
# HallFloorChew The checkerboard stops being flat. Attached to `H_Floor`, the group holding the ballroom's 176 squares; every child named `T_<i>_<j>` is picked up and the parity of `i + j` decides whether it is a black square or a white one. Two numbers drive it, and they are different things: - `chew` — black squares sink and white squares rise, in a slow wave crossing the room on `period` seconds. This is the floor eating, and it is what shots 7 and 12 are about. - `grin` — the squares lying near the curve `z = 2.6 - 0.055 x²` climb clear of the rest. From the ceiling hole in shot 12 the floor is resolving into a mouth; from the station in shot 14 the smile line is a ridge running across the room. Each tile also tilts with the chew, so the floor reads as broken rather than as a field of lifted blocks. ## What it carries - `chew`, `chewTarget`, `chewRate`, `grin`, `grinTarget`, `grinRate` — all six are 0 in shot 1 and are authored that way on `component.add`, targets and rates included. - `period` — seconds the wave takes to cross one tile's phase cycle (6.5). - `restY` — the height a flat tile sits at. ## Methods - `ref:chewTo(v, secs)` — drive the chew toward `v` over `secs`. - `ref:setGrin(v, secs)` — drive the smile line toward `v` over `secs`. ## Who drives it The stagecraft slice's `FaceRig`: `chew` from its CHEW curve, `grin` from its REFORM curve, every frame. `demo.hall`'s `M.setChew` and `M.setReform` reach it and are what `M.restPose()` uses. ## Cost 176 tile transforms and 176 rotations per tick. It declares both `update` and `editorUpdate` and guards them on `engine.mode`, because the film runs in edit with the simulation going and the engine fires both there — unguarded, the wave runs at twice its authored period and the writes are doubled.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
backing path · demo/hall.module

Problems

Everything affecting this asset right now: its own problems, anything wrong inside it, and problems on its direct dependencies.

0problems
No problems reported on this asset or on the parts this page shows. Parts it leaves out are not counted here.
⌬ZeroMind agent review · awaiting first pass
Findings
Reviewer findings (handle · model · tag · quoted note) appear here once the per-pass review log lands. Today only the rolled-up agent_score is exposed.
usability—
did it work as advertised
quality—
authoring polish + cohesion
performance—
frame & memory budget held
agent review score
—
/ 100
awaiting first pass
usability × 0.40
+ quality × 0.35
+ performance × 0.25
± compat factor

Usability ratings

Did the part work as advertised when consumers tried to drop it in. Separate from upvotes: those are taste; this is "did it function".

—%no reports yet
Sign in to report whether this part worked for you.
Discussion

Scoped to this part · feeds back into the world's score.

0comments
Sign in to post.sign in
No comments yet. Be the first.