Log inGet started
·
scene · drop-in viewer
asset⌬ scenescene·originates fromworld 4e897ccd-6…

main

No description provided.

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

No description provided yet.

Interface

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

This asset doesn't declare a schema or structured payload.

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 the 199 items nearest this part. It holds more than this page lists.

199+items
◇
component · born here
❒asset
# DemoEars The film's ears. The scene's `AudioListener` rides this entity, and this entity rides whichever camera is currently drawing the viewport. A cutscene builds its own camera each time it plays, so the listener cannot be authored onto it. It follows. Every source in the mix is spatial and stands where its sound is made, so most of the film's sound design is done by walking the camera through the building: the music box is audible in shot 4 because the camera is a metre and a half from it and inaudible everywhere else because it carries nine metres, and the calliope under the stage is plumbing from the dressing room and a fairground from the ballroom. None of that works unless the ears are where the lens is, which is what this does. ## What it attaches to One entity in the scene skeleton, carrying both this component and an `AudioListener`. **Do not add a second, and do not add another `AudioListener` anywhere**, because spatial audio is heard from here, and two listeners is not twice the sound, it is an argument about which one is the audience. It runs at `executionOrder = -60`, after the film clock and before the mix, so the position it writes is this frame's camera and not last frame's. ## Fields | Field | Meaning | |-------|---------| | `active` | Off leaves the ears wherever they last stood. | ## Methods | Call | Returns | |------|---------| | `ears:following()` | The id of the camera the ears are currently riding, which is the check that the listener is on the film's camera and not on the editor's. |
▲ 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
▣
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
# a_heavy_iron_cable_snapping_under_tensio Managed audio asset. Edit the `.metadata` `settings` block to change compression.
▲ 0↑ born
◇
component · born here
❒asset
# PropsStage Shot 9: the red curtain inhaling flat against the arch and releasing, the animatronic band twitching awake behind it, and the drum head thumping in time with the cloth. One instance, on `P_Stage`. ## The curtain is a runtime mesh No scene record can hold a cloth that changes every frame, so the component builds the geometry with `renderer.mesh.create` and puts the `Model` on `P_Curtain` itself. The surface is `stage.curtainPoint(u, v, suck, t)` — a pure function shared with the build, so neither side has to hold the other's state — lofted over `cols` x `rows` from `demo.props.stage`, which is where the cloth's tessellation is written once. Normals come from two finite differences of the same function rather than from the triangles, so the folds shade smoothly at any tessellation. ## Re-lofted on the film's frame grid `reloftHz` quantises the re-loft to 24 a second. At 24 it is a cloth; at 120 it is the same cloth and four times the GPU upload — and quantising on the FILM clock rather than the engine's is what makes two takes the same cloth. ## The two inhales `public:begin()` marks the shot. `breathA` and `breathB` seconds later the sheet is drawn flat over `drawIn`, held for `hold`, and released over `release`. `public:flatness()` reads how flat it is right now: 0 through the shot's opening, about 0.89 at the first peak and 1.0 at the second. ## The band Three automatons on stepped joints — `stepped()` snaps between held poses at a rate that climbs as `wake` ramps, which is machinery waking rather than a creature moving. The drum head takes the curtain's own `suck` plus a pulse under it, so the thump and the inhale are the same beat. ## Methods on the ref `begin`, `reset`, `flatness`.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◇
component · born here
❒asset
# PropsDressing Shot 8 and the 85 mm insert inside it: the bulb-lined mirror failing, the greasepaint handprints blooming on the glass, and the stool rocking itself still. One instance, on `P_Dressing`. ## Two clocks, on purpose The handprints and the stool are measured from `public:begin()`, which the `b08_dressing` beat calls — they are the shot's own eight seconds and mean nothing outside it. The BULBS are measured on the film clock, out of `K.DRESSING`. The look slice kills eight point lights around the mirror on that same table, so the glass and the light it held have to go out in the same instant or the frame shows a lit bulb throwing no light. `K.DRESSING` is the one place that schedule is written: `order[g]` is the slot practical `g` dies in, and it dies at `firstDeath + (slot - 1) * span / count`. ## Thirty bulbs, eight practicals The frame carries thirty glass bulbs and the rig carries eight lights, so each bulb is assigned the practical it stands under — its own angle on the ellipse the lights ring the glass with names the nearest of the eight. Inside one practical's arc the bulbs stagger by `arcStagger` around its second, so the fixture reads as failing rather than as switching, and the run around the frame is thirty small failures on eight beats instead of eight blocks. ## The tick Each of the eight deaths sounds `PropFilamentTick.soundClip` — a 52 ms synthesised break, crack and filament ring, baked PCM so nothing is lost off its head — from an `Audio` source on `P_DressingMirror`, pitched per practical. The glass is what ticks, so the source stands on the glass. A clock behind a death un-arms it, so a backward seek plays the run again. `public:tickReady()` answers whether the source and the clip both resolved. ## Methods on the ref `begin`, `reset`, `dark`, `tickReady`.
▲ 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
# 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
◇
component · born here
❒asset
# PropsDriver The props slice's clock, and the breathing of the dust sheets. One instance, on the slice's root `Props`, at `executionOrder = -80` so the clock is current before any other prop reads it. ## What it drives `kit.tick(dt)` once a frame, which advances the free-running fallback the film clock falls back to between takes. Every other prop component reads `kit.now()` and never accumulates a time of its own. Then the seven shrouds in the entry hall — shot 3. Each carries its own `breathPeriod` and `breathPhase` as entity attributes, so the sheets are out of phase with one another and the hall reads as a room of ribs rather than as one animation. The curve is not a sine: a second harmonic at 22% gives the catch at the top of the inhale, which is what makes it read as breathing. ## Both hooks, one tick `update` and `editorUpdate` both fire in both modes, so each names the mode it is the tick for. Without the guard the clock advances twice a frame and every prop in the slice runs at double speed. ## Methods on the ref `reset` (the sheets back to their shot-1 pose, and the free clock rewound) and `now` (the film's current time, as every prop component reads it).
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
# a_tiny_antique_music_box_playing_a_slow Managed audio asset. Edit the `.metadata` `settings` block to change compression.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◇
component · born here
❒asset
# FilmClock The film's own time, published once a frame to everything that moves, and the thing that fires the cues living inside a shot. One of these exists, on the `Stagecraft` entity. It runs at `executionOrder = -80`, before every other driver in the demo, so that by the time anything reads the clock it is already this frame's. ## What it does **Publishes the clock.** It reads `cutscene.status()` and writes the second and the playing flag onto `demo.stagecraft`. Nothing in the demo may read wall time: two takes have to be the same film, and a driver that accumulates `dt` stands somewhere different at 0:88 depending on how loaded the machine was on the way there. **Holds the viewport.** A cutscene builds a camera above every other camera's priority, but in edit mode the editor fly-camera keeps the screen anyway and the film runs where nobody can see it. So while the film plays this claims the viewport outright, and gives it straight back when the film stops. **Fires the in-shot cues.** A cue declared with `beats.extra(name, t)` comes from a slice's `register()`, which runs during `beats.bind()`, and by then `demo.film` is already in the require cache and its cue list is fixed, so such a cue can never reach the cutscene's own list. This fires them instead: off the film clock, once per crossing, and re-armed whenever the clock runs backwards, so a seek back over a cue arms it again. **Rebinds a registry that emptied.** A take can outlive the registrations it started with: a write to any file in the demo's module graph re-evaluates `demo.beats` and leaves the registry empty, and the film keeps running with every remaining cue firing into nothing. When that happens under a running film, this binds it again and says so in the log. ## Fields | Field | Meaning | |-------|---------| | `active` | Off stops the clock being published and the cues being fired. | ## Methods | Call | Returns | |------|---------| | `clock:clock()` | `{ t, playing }` as this component last read them. | | `clock:firedCues()` | The names of the in-shot cues that have fired in this take, sorted. |
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
# heavy_steady_rain_falling_on_slate_roof Managed audio asset. Edit the `.metadata` `settings` block to change compression.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◇
component · born here
❒asset
# FilmMix The hundred seconds, as a mix. One of these exists, on the `Stagecraft` entity. Every source in `demo.stagecraft.SOURCES` stands where its sound is made and is heard through the listener riding the camera, so most of the film's sound design is already done by walking the camera through the building. What this component adds is the part distance cannot say. ## What it carries **Source envelopes.** A list of `{ t, volume }` per source, read off the film clock and written to the `Audio` component every frame. Rain that GETS IN at shot 6 and not before. A music box that stops mid-phrase. A calliope that is inaudible for the first half of the film and is the only thing left in it at the end, and a second, short-ranged copy of the same tune under the dressing-room floor, which is where it is first heard. **Channel envelopes.** Three channels carry the act structure over the top of the sources: `weather` (outside, and what gets in), `room` (the building's own noises and the fall) and `music` (the box, and the calliope that does the laughing). The storm drops away for three seconds after the chandelier lands, because the ears are still ringing; it does not come all the way back; and it recedes for good under the last shot, so what is left when the light goes is one calliope in an empty building. Because both are functions of the film's time and nothing else, the same second of the film sounds the same in every take. ## Headroom Twelve spatial sources, four thunderclaps and the chandelier sum into one master. The film is mixed under a master trim set in `demo.stagecraft.reset()`; without it the loudest second pins the output at full scale and the impact reads as a broken take rather than a heavy one. ## Fields | Field | Meaning | |-------|---------| | `active` | Off freezes every source and channel where it stands. | ## Methods | Call | Returns | |------|---------| | `mix:report()` | What every source is SET to beside what the mixer says it is DOING: its volume, whether a voice for it is audible, and if not, the reason (`outOfRange`, `gainZero`, `noVoice`). Plus the channel levels, the audible count and the listener. The one call that separates "asked for" from "heard". |
▲ 0↑ born
△
mesh · born here
❒asset
# Mesh Mesh asset. `data.zmsh` is the engine-native geometry payload (`renderer.mesh.encode`); consumers reference the asset's guid.
▲ 0↑ born
◇
component · born here
❒asset
# PropsMaskWall Shot 10: a ripple crosses two hundred porcelain masks and each one turns to face the lens, the far ones first. One instance, on `P_MaskWall`. ## The lens is the shot's, not the camera's The masks turn to `K.shot(10).pos[1]` — the station the shot list puts the camera at — rather than to whatever camera happens to be drawing. That is what makes the ripple the same picture every take, and what makes it follow the shot when the station is restaged. Nothing here reads a live camera. ## The hero The ripple ends on one mask that is already facing, never turns, and wears `PropPorcelainWarm` — the one warm face on a wall of cold ones, so the last beat of the shot lands where the eye is already resting. It is the nearest mask the shot can SEE, not the nearest by distance. The wall runs PAST the station rather than in front of it, so the closest mask of the two hundred sits beside the lens and outside a 24 mm frame; `aim()` reads the shot's own look point and fov and bounds the candidates by the vertical half-angle, which is the narrow one at every aspect. A station that frames none of them falls back to the nearest of all. `markNearest` repaints only two masks — the new hero, and the one it replaces, which gets back the face `masks.module` built it with out of its own `coldMat` attribute. ## The latch Once every mask has arrived the component writes `private.t0 = -2` and both per-frame hooks return immediately: two hundred transforms a frame is a real cost and nothing moves again until a reset. `public:facing()` reads the latch as "all of them" rather than as "none". ## Methods on the ref `begin`, `reset`, `facing`, `nearest`.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◇
component · born here
❒asset
# LookDirector The one thing in the film that calls `demo.look.apply(t)`, once a frame, with the cutscene's own clock. One instance stands on `LK_Director` under the `Look` group; `demo.look.content()` puts it there. Everything the film's light and print does is a pure function of that second — the thirty-two lights, the eight mirror bulbs, the two clerestory discs, the lens, the film stock and the tone curve's exposure. So the director does not integrate anything and keeps no state of its own beyond whether the post chain is standing. Two takes are the same film because of that, and a still of any instant is the same picture as the frame the take delivers at it. ## Fields | field | what it does | |---|---| | `active` | Off stops the look being written at all — the lights hold whatever they last had. Used to freeze an instant while something else is measured. | | `previewTime` | `-1` follows the cutscene. `>= 0` pins the whole look to that film second, which is how a still of a shot is taken without playing the film. `demo.look.reset()` puts it back to `-1`, so a take never inherits somebody's scrub. | ## Methods - `ref:currentTime()` — the film second the look is holding right now. - `ref:reinstall()` — tear the post chain down and build it again, whatever state it is in. The call to make after editing the chain or the grade while the world is running; it answers whether the chain stands afterwards. ## When no film is playing The look holds **37.5 s** — the shot-6 station, the frame the film is about. A world page that opens without anyone pressing play therefore shows the ballroom printed at the density shot 6 is printed at, rather than at shot 1's exterior push, which is two and a half stops hotter and reads as a blown room. ## Two things this component is careful about **It ticks once a frame.** The film runs in edit mode with the simulation resumed, where `update` and `editorUpdate` both fire, so each routes to the tick only in the mode it belongs to. Applied twice a frame, the whole rig cost the frame a second pass and said nothing about it. **A failing install is not retried forever.** Three attempts, then the failure is logged once at error and the director stops asking. The chain is built from a fixed list; one that cannot be built on this frame will not build on the next, and retrying it every frame rebuilt a 32-entry colour cube twice a frame — most of the frame's time, and thousands of log lines a take.
▲ 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
# single_slow_water_drops_falling_into_a_s Managed audio asset. Edit the `.metadata` `settings` block to change compression.
▲ 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
◐
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
◐
material · born here
❒asset
▲ 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
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◇
component · born here
❒asset
# AirClock The one thing that drives the air in *The House Wears a Face*. One instance, on the `Air` group, execution order −105 so it settles the weather before anything reads it. Everything the air slice does over the hundred seconds is a pure function of one number, the second of the film: the storm's four strikes, the height fog thickening, the three raymarched shafts brightening and dimming, which rain is falling and at what rate, the water column, the dust, and the wetness ramp that turns the ballroom floor from grey dust into a black mirror. Because it is a pure function of `t`, two takes of the same second draw the same air. ## Where the second comes from The cutscene. While `demo.film` is playing, the air is drawn at `cutscene.status().time` — not at a clock of its own, and not at accumulated `dt`. The storm therefore cannot drift away from the cut by a frame however the frame rate moves, and it is the same number whether the film is running in edit or in play. When no film is playing, the air is held at `previewT`, so a slice capturing the room between takes sees a settled second rather than a film running away from it. A second clock, `driftT`, keeps running there and is what the shaft dust turns on, so the air is still alive to author against. ## Fields | field | what it is | |---|---| | `previewT` | the second the air is held at while no film is playing | | `gain` | master gain on everything this drives — `0` takes the weather off without deleting it, which is how a slice checks its own work against a clean frame | ## Methods - `ref:seek(t)` — move the air to an explicit second and settle it there. Every shot beat calls this, so a capture taken between takes settles at the shot the beat names. During a take the film's own clock wins on the next frame. - `ref:filmTime()` — the second the air is currently drawn at. During a take this equals `cutscene.status().time` exactly. - `ref:lightningAt(t)` — how bright the lightning is at a given second, for anything that has to agree with it: a thunder cue, an exposure allowed to be late. - `ref:resetFilm()` — back to zero, forgetting every pushed value so the next frame states the whole air again. `demo.air.reset()` calls it before a take. ## The strikes Four, at 4.5, 10.2, 39.4 and 74.8 seconds, at powers 1.00 / 0.72 / 0.55 / 0.85. Each is three flashes inside a third of a second over an afterglow the cloud keeps for about a second and a half. The pulse WIDTHS are read off the delivered film rather than off the curve: a film frame is a fortieth of a second, so a pulse narrower than that is a strike a frame either lands on or misses entirely, and the take that misses it has no lightning in it at all. The flash drives a `distant` light — a parallel row beside the scene's own sun, so it lands on everything at once without displacing the sun — and it also raises the fog's inscatter and the volumetric medium's sun term, which is what puts the strike in the air rather than only on the surfaces. ## Two hazards this component is shaped around **The shafts are driven through a per-instance lane, not through their material.** `AssetRef:setProperty` in edit mode writes through to the asset on disk, coalescing to one asset write every 250 ms, so driving three shafts from the film clock that way rewrites three `mat.yaml` files four times a second and leaves their authored resting values at the mercy of whichever frame closed the window. `renderer.instanceData.set(entity, 0, flow, gain, 0, 0)` reaches the same shader and touches no asset. Lane 0 is `x` = the clock the dust drifts on, `y` = added to the material's resting brightness. **`demo.constants` is resolved lazily.** It is a world module, and at engine boot this component's chunk can run before that module is resolvable: `require` raises once, the chunk dies with it, and the component then has no hooks at all for the rest of the session while the log carries a single line from start-up. ## Hooks `update` runs in edit mode as well as in play (OrigoZero/zero#2743 — the documented "play mode only" contract does not hold) and `editorUpdate` runs only in edit, so each hook takes the mode that is not the other's. That is one tick a frame whichever way that behaviour lands, and no wall clock is read to decide it.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◇
component · born here
❒asset
# PropsMusicBox Shot 4, the 85 mm insert: the pin-drum turning, the governor fan blurring, the comb teeth flicking, and the clown turning on its pin — then the whole movement running down and quitting mid-phrase. One instance, on `P_MusicBoxSet`. ## The comb is a tune, not a comb Each tooth is lifted by whichever pin is passing it. The drum carries `musicbox.PINS` rows; a tooth sees a row every 1/PINS of a turn, offset by its own place along the drum, and it flicks back in about a tenth of a rotation. The offset pattern is what makes the comb sound like a phrase rather than like a zip. ## The run-down integrates `public:begin()` marks the shot on the film clock. `stopAt` seconds later the movement lets go, and `rundown` seconds after that it has stopped. The drum's ANGLE is the integral of that linear run-down, not the angle scaled by it, so the comb and the clown stay in step with the drum as it dies rather than snapping back. ## Fields `drumRate` 0.62 turns/s, `clownRate` 0.30 turns/s, `stopAt` 4.35 s (t = 25.35 on the film, inside shot 4), `rundown` 0.62 s. ## Methods on the ref `begin`, `reset`, `tension` (1 while it plays, down to 0 once it has stopped).
▲ 0↑ born
# a_single_heavy_thunderclap_cracking_then Managed audio asset. Edit the `.metadata` `settings` block to change compression.
▲ 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
◇
component · born here
❒asset
# PropsChandelier The nose of the face, and the only thing in the film that falls. One instance, on `P_ChandelierPivot`. It drives four poses off the film clock, and which one it writes is decided by two private film-times rather than by an accumulating state machine, so a seek backwards is a seek backwards. | phase | when | what it writes | |---|---|---| | hanging | before the fall beat | the pivot on a slow ellipse — a 9 s long axis against a 6.4 s short one, so the silhouette from the station never repeats | | falling | `b11_chandelier_fall` .. impact | the cable sagging then parting, the body dropping under `g` and tumbling about a fixed axis, the cable whipping up into the dark | | wrecked | impact onward | the body hidden, the wreck on the boards, 96 shards thrown out across the checkerboard and left where they stop | | rising | `b13_reform` onward | the body lifted from the boards to nose height over `rehangFor` seconds | ## The landing is arithmetic The solver does not step in edit mode, and the film has to be the same hundred seconds twice, so the fall is a closed form: `cableGives` seconds of sag, then `½gt²` to the boards. `public:landingAge()` answers how long that takes for the drop the layout gives it — 1.749 s — which is what puts the impact at `K.IMPACT`, the second the light, the plaster and the sub all key off. Changing `landY` or the layout's `chandelier.rest` moves the landing, so read `landingAge()` back and move `K.IMPACT` with it. ## Visibility is read, not remembered `setShown` compares against the entity's own `active` before writing it. A module-level cache of what it last set cannot survive a hot reload, a scene rebuild, or a record saved while the wreck was showing — and when it drifts the wreck and the glass sit on the ballroom floor from the first frame of the film. ## Fields `swingPeriod` 9 s, `swingAmp` 0.14 rad (below about 0.1 the swing is under a pixel of travel from the station eighteen metres back), `cableGives` 0.26 s, `landY` 0.58 m, `glassFor` 0.95 s, `rehangFor` 5.2 s. ## Methods on the ref `fall`, `rehang`, `reset`, `phase`, `bodyY`, `landingAge` — all `public:`, all called from `demo.props`'s beat handlers and `status()`.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
# a_steam_calliope_fairground_waltz_heard Managed audio asset. Edit the `.metadata` `settings` block to change compression.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◇
component · born here
❒asset
# MothSwarm <!-- zero:scaffolded-readme --> <!-- Replace the line below with what this component provides and who consumes it, then delete both comment lines. --> TODO: describe this component.
▲ 0↑ born
# an_old_derelict_wooden_house_settling_at Managed audio asset. Edit the `.metadata` `settings` block to change compression.
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◐
material · born here
❒asset
▲ 0↑ born
◇
component · born here
❒asset
# FaceRig The schedule the room assembles itself on: when the mouth widens, when the lids open, when the light behind the eyes arrives, and when the floor starts chewing. One of these exists, on the `Stagecraft` entity. The hall slice builds the mechanism (a mouth on a reform rig, two clerestory eyes with lids and a pane that glows, a floor that chews and carries the smile line) and this component is the other half of it. It changes when the room moves, never how far. ## How it drives Four curves, each a list of `{ t, value, ease }` keys read off the film clock. Every frame it evaluates all four at the film's current second and writes them onto the hall's components with `secs = 0`, an immediate set. That is the difference between a room that assembles and a room that assembles the same way twice: a tween given a duration advances on the frame's own `dt`, so where it stands at 0:88 depends on how loaded the machine was on the way there, while a curve read off the cutscene's clock stands where the film says and nowhere else. | Curve | Shape | |-------|-------| | `REFORM` | Flat at 0 until 77.2, a third of the way by 83, whole by 91, arriving a beat before the cut into shot 14 so the match cut lands on a room that has stopped moving. | | `EYES_OPEN` | Shut for ninety per cent of the film. Open across shot 13, held through the match cut, and the last movement in the picture is the lids coming back down. | | `EYE_GLOW` | An ember from 77, 0.72 by 90, full inside shot 14, gone by 99.4. It arrives before the lids open, so the eyes are already alight when they show. | | `CHEW` | A tremor under the first full view of the ballroom, the whole floor chewing by the boot-level shot, and it never settles again. | ## Reaching the rig Each part is resolved to its own component and called with a COLON: `mouth:driveTo(v, 0)`, `eye:openTo(v, 0)`, `floor:chewTo(v, 0)`. A content component's method is on the component ref when it is declared `typed function public:name(...)`, and is called the same way a builtin component's is. A function declared at file scope is the component's own and is not on the ref at all. A value is recorded as applied only once the rig has taken it. If a call raises, the next frame tries the same value again: the room the curve asks for is where the room should stand, and a refusal the schedule treats as done leaves the room a whole shot behind the film. The complaint is made once per value, not once per frame. ## Fields | Field | Meaning | |-------|---------| | `active` | Off leaves the room wherever it stands. | ## Methods | Call | Returns | |------|---------| | `rig:report()` | The film's time, where each of the four curves stands at it, and `driving`, which says whether each of the four parts of the rig is answering. The one call that says whether shot 13 has anything to move. |
▲ 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 · scenes/main.scene

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.