makepad/apps/vj/resources/effects/91_gale_grove.splash
Admin f44616b2a7 makepad-vj effects: the effect renderstack, with the shaders inside the documents
The VJ's EFFECT surface is a small renderer of its own. An effect is a
`.splash` DOCUMENT — engine choice, stages, fields, parameters and now the
SHADERS THEMSELVES live in the document rather than in Rust. That is the
shape this commit introduces (dev has never seen an intermediate one): a
document is the whole effect, and the Rust side is the engine families that
documents draw with.

The engine families: particles and emitters, GPU sim swarms and fluid, static
meshes (firefly synchrony, harmonograph loom, domino liturgy), tiles, flock,
clouds, city, pipes, stock charts, an SDF raymarcher with a subclassable
`scene_sdf`, and a mountain-jet endless range with a beat-pulsed fighter.

Three things make them a system rather than a demo reel:

  - SIM FIELDS — a float simulation-texture primitive, so an engine can carry
    GPU state across frames (wind, particles, fluid) instead of being a pure
    function of the clock.
  - CONTENT COUPLING — `content:` in a document and `input0` on every engine's
    tex0, so an effect can consume the program video: drapes, backdrops,
    mirrors, billboards, chrome, frescoes, canopy, glass, silk, wall, swarm,
    pen and mosaic families all take the picture playing behind them.
  - MUSIC BINDING — shaders read the beat, so the whole library moves with the
    track rather than on its own clock.

Roughly a hundred seeded preset documents ship with it, each with a lazily
rendered animated thumbnail (rendered 4x and box-downscaled, 16-tap SSAA);
the thumbnail pass went from four minutes to eleven seconds. CONTRACT.md is
the document contract and its verify recipe; IDEAS.md is the campaign tracker.
2026-08-23 01:35:44 +02:00

74 lines
2.4 KiB
Text

// GALE GROVE — the wind SIM FIELD driving L-SYSTEM trees: the same
// `wind_field:` opt-in as the meadow, on branching geometry. The field is
// sampled at each vertex's REST position, so parent and child branches
// read the same wind at their joint and can never tear; gusts light what
// they bend, so a kick sends a visible shudder traveling through the
// grove. Pattern taught here: one wind field, any mesh engine.
{
name: "Gale Grove"
engine: "lsystem"
seed: 23
axiom: "X"
rules: ["X=F[+X][-X][&X]FX", "F=FF"]
iterations: 5
angle: 24.0
angle_jitter: 5.0
step: 0.16
radius: 0.05
copies: 5
wind_field: "wind"
flow: 0.9
gust: "(2.0 + pulse * 1.8) * (0.2 + 1.6*p0)"
travel: 0.26
decay: 0.5
scale: 2.2
extent: 6.0
sway: 0.5
beat_pulse: "0.25 * (0.2 + 1.6*p1)"
beat_rate: 0.5
// PERFORMANCE DIALS — mid-knob = the stock look, exact.
p0: 0.5 p1: 0.5 p2: 0.5
dials: [
{name: "GUST", bind: "p0", default: 0.5},
{name: "PUMP", bind: "p1", default: 0.5},
{name: "GLOW", bind: "p2", default: 0.5}
]
color_bg: #x0a0c14
color_a: #x2a5a3a
color_b: #x9adf7a
color_c: #xeaffe0
cam_orbit: 0.07
fog: 0.05
glow: "1.05 * (0.25 + 1.5*p2)"
stages: [
{kind: "bloom", threshold: 0.55, strength: 1.1, levels: 3}
]
// THE LOOK LIVES HERE. This block is not a reference to the
// engine's shader — it IS the pixel math this effect runs.
// Rewrite it and the effect looks different; everything else
// (geometry, motion, the content coupling, the beat) keeps
// working, because the block SUBCLASSES the engine shader.
// Inputs: t = arc from the root 0..1, attr = (depth, arc, hue, tube radius).
// Signals: self.time_beat (time, beat, phase, pulse),
// self.sig (bar, bpm, energy, dt), self.user (p0..p3),
// self.col_a/b/c/bg, self.fog (density, glow, content, -).
shader: draw.DrawVjFxMeshField {
fx_displace: fn(pos: vec3, normal: vec3, attr: vec4) -> vec3 {
return vec3(0.0, 0.0, 0.0)
}
fx_color: fn(t: float, attr: vec4, normal: vec3, wpos: vec3) -> vec4 {
let base = self.col_a.mix(self.col_b, clamp(attr.z, 0.0, 1.0))
let tip = self.col_c * (clamp(t, 0.0, 1.0) * 0.35)
let flash = self.col_c * (self.time_beat.w * 0.5)
return vec4(base.xyz + tip.xyz + flash.xyz, 1.0)
}
}
}