p_surf
Dawn breaks over an endless cloud sea and an ink-silhouette rider carves it to the roller: threading score rings, popping airs on the snare-drag fills, and outrunning cumulonimbus cells whose bolts hit on the hoover stabs.
p_surf — CLOUDSURF
Dawn breaks over an endless cloud sea and an ink-silhouette rider carves it to the roller: threading score rings, popping airs on the snare-drag fills, and outrunning cumulonimbus cells whose bolts hit on the hoover stabs.
The sea is the surf_cloud reactive field — a scrolling noise deck displaced
in the vertex stage and mirrored bit-exactly on the CPU, which decides where
the board rides; a 24-slot touch-point ring carves a healing wake behind the
carve, and touchdowns stamp deep splashes into it. The surf_sky dome is a
photographic dawn: soft sun with a layered halo over a perspective-projected
strata deck. surf_puff clusters fill the world — near cumulus towers, a
hazed horizon bank, translucent wisps streaming past the camera as the speed
cue, and the storm cells themselves, which flicker from inside before each
strike.
Choreography is entirely closed-form in part-local t — speed integral, organic three-sine carve weave, jump arcs, landing pulses — so director seeks land exactly and every beat stays on the music grid. The board is a procedural rockered deck (built once at module scope); the rider is the Synty character in silhouette, leaning into carves, switching to jump/land clips around each air, its feet planted by sinking the character origin. Five shots track the run — low chase, board-level side dolly, front three-quarter with the first storm, the big-air hero, and a crane rise into the handoff — with handheld micro-drift layered on top and a smoothed float over any swell the dolly lerps through.
Interface
What this asset declares: the schema it conforms to, what it exposes, and the rendered structured payload.
conforms to
zero/source-extract/v2preseed/parts/p_surf.module — CLOUDSURF: dawn breaks over an endless cloud sea and an ink-silhouette rider carves it to the roller, threading rings, popping airs on the fills, and outrunning storm cells. The reactive cloud-sea shader (scrolling noise field + healing wake) pairs with a dawn skydome, cumulus towers on the horizon, near-field wisps streaming past, and the ink/flow post. Everything is a closed-form function of part-local t (speed integral, carve weave, jump arcs), so seeks land exactly and the music grid lines up: jumps launch on the snare-drag fills and land on the next downbeat, rings ring out on their score chimes, storm bolts hit on the hoover stabs.
umul32(a: ?, b: ?) → void
| arg | type | description |
|---|---|---|
| a | ? | |
| b | ? |
hash2(px: ?, py: ?) → void
| arg | type | description |
|---|---|---|
| px | ? | |
| py | ? |
vnoise(px: ?, py: ?) → void
| arg | type | description |
|---|---|---|
| px | ? | |
| py | ? |
fbm(px: ?, py: ?) → void
| arg | type | description |
|---|---|---|
| px | ? | |
| py | ? |
sstep(e0: ?, e1: ?, x: ?) → void
| arg | type | description |
|---|---|---|
| e0 | ? | |
| e1 | ? | |
| x | ? |
puffCells(qx: ?, qy: ?) → void
| arg | type | description |
|---|---|---|
| qx | ? | |
| qy | ? |
deckHeight(x: ?, fieldZ: ?, t: ?) → void
| arg | type | description |
|---|---|---|
| x | ? | |
| fieldZ | ? | |
| t | ? |
speedAt(t: ?) → void
| arg | type | description |
|---|---|---|
| t | ? |
scrollAt(t: ?) → void
| arg | type | description |
|---|---|---|
| t | ? |
xAt(t: ?) → void
lateral carve weave: eases in over the intro, breathes between wide and tight cycles, then relaxes toward a straighter full-speed line for the final build
| arg | type | description |
|---|---|---|
| t | ? |
vxAt(t: ?) → void
smoothed carve velocity: wide-window derivative so heading and bank read the line of the carve, not lattice noise
| arg | type | description |
|---|---|---|
| t | ? |
airAt(t: ?) → void
| arg | type | description |
|---|---|---|
| t | ? |
deckAt(t: ?) → void
| arg | type | description |
|---|---|---|
| t | ? |
deckSmoothAt(t: ?) → void
| arg | type | description |
|---|---|---|
| t | ? |
boardYAt(t: ?) → void
board center height above the field origin at time t
| arg | type | description |
|---|---|---|
| t | ? |
landPulseAt(t: ?) → void
landing weight: unit pulse peaking as each jump touches down
| arg | type | description |
|---|---|---|
| t | ? |
quatMul(a: ?, b: ?) → void
| arg | type | description |
|---|---|---|
| a | ? | |
| b | ? |
eulerQuat(yaw: ?, pitch: ?, roll: ?) → void
| arg | type | description |
|---|---|---|
| yaw | ? | |
| pitch | ? | |
| roll | ? |
airRiseAt(t: ?) → void
`P.update` aims the lens at the board every frame, so a shot's job is the STATION and the LENS, never the aim: where the camera stands relative to the carve, how high it rides above the deck, and how much of an air it takes with the rider. Height above the aim point is what decides the composition here — the aim is welded to the board, so the horizon sits wherever the down-tilt from station to board puts it, and a station level with the board buries the horizon at the top of the frame and fills it with cloud. A station is sampled every eighth note across its shot rather than at the two ends, so the path rides the swell the deck puts under it instead of cutting the chord through it, and the lateral `follow` keeps the carve inside frame without welding the camera to it. how far the board stands above the smoothed deck while it is in the air
| arg | type | description |
|---|---|---|
| t | ? |
CAM(t: ?, s: ?) → void
s = { follow, dx, dy, dz, airK }: `follow` is the share of the carve's swing the camera takes with it, `dy` is metres above the board's GROUND height, and `airK` the share of an air the lens climbs with. A station that follows an air completely (airK = 1) holds the rider at the same angle all the way up, which is the one way to make a 4 m boost read as nothing at all.
| arg | type | description |
|---|---|---|
| t | ? | |
| s | ? |
shot(t0: ?, t1: ?, a: ?, b: ?, fov: ?) → void
| arg | type | description |
|---|---|---|
| t0 | ? | |
| t1 | ? | |
| a | ? | |
| b | ? | |
| fov | ? |
spawnModel(ctx: ?, name: ?, model: ?, mat: ?, parentId: ?) → void
| arg | type | description |
|---|---|---|
| ctx | ? | |
| name | ? | |
| model | ? | |
| mat | ? | |
| parentId | ? |
boardMesh( ) → void
halfW(u: ?) → void
| arg | type | description |
|---|---|---|
| u | ? |
rocker(u: ?) → void
| arg | type | description |
|---|---|---|
| u | ? |
applyLook( ) → void
The dawn this part is lit by, and the two passes it draws through. Both are scene-wide state, so they belong to `enter` and not to `build`: the director may build a part up to a second before its cut, under the outgoing part's fade, and a sky or a post pass installed there would land on the part still on screen.
applyPost( ) → void
post: ink outlines + the flow pass, between the scene chain and the fade. Both identities are spelled as literals: that is what pins the two shaders as dependencies of this part, so they travel with the world. Each pass's properties come from its shader's own properties.yaml.
build(ctx: ?) → void
| arg | type | description |
|---|---|---|
| ctx | ? |
put(key: ?, ok: ?, m: ?) → void
| arg | type | description |
|---|---|---|
| key | ? | |
| ok | ? | |
| m | ? |
enter(_ctx: ?) → void
| arg | type | description |
|---|---|---|
| _ctx | ? |
ensureRider(ctx: ?, dt: ?) → void
rider hookup: parent under the rig, silhouette material, clip management
| arg | type | description |
|---|---|---|
| ctx | ? | |
| dt | ? |
walk(e: ?, depth: ?) → void
| arg | type | description |
|---|---|---|
| e | ? | |
| depth | ? |
clipFor(t: ?) → void
the pose the moment calls for, straight from the clock: airborne, the fresh landing, or the carving crouch
| arg | type | description |
|---|---|---|
| t | ? |
clipValue(name: ?) → void
A clip named with dots is an asset identity and has to be resolved; a bare name is a builtin the ClipPlayer looks up itself.
| arg | type | description |
|---|---|---|
| name | ? |
ensureClip(ctx: ?, dt: ?) → void
| arg | type | description |
|---|---|---|
| ctx | ? | |
| dt | ? |
update(ctx: ?, t: ?, dt: ?) → void
| arg | type | description |
|---|---|---|
| ctx | ? | |
| t | ? | |
| dt | ? |
exit(_ctx: ?) → void
| arg | type | description |
|---|---|---|
| _ctx | ? |
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.
Problems
Everything affecting this asset right now: its own problems, anything wrong inside it, and problems on its direct dependencies.
agent_score is exposed.+ 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".
Scoped to this part · feeds back into the world's score.