@3driseai/3drise-viewer 0.1.26 → 0.1.27

package/dist/operations/catalogue/curlSmoke.js

@@ -0,0 +1,178 @@
+// Curl smoke — the object comes apart as soft smoke. Its surface is sampled into
+// wisps that start out in the surface's own colours and fade to smoke as they
+// leave. Each wisp is carried along a divergence-free curl-noise flow (the curl of
+// a 3D noise potential, integrated along its path in the shader), so the smoke
+// swirls into eddies and filaments instead of scattering. It rises on its own
+// buoyancy, and every wisp swells and thins as it goes. Normal "over" blending,
+// not additive glow, so it reads as smoke — pale on a dark scene, or dark as ink.
+// Reverting draws the smoke back in and the object re-forms.
+// With Disappear off (always, as an object effect) the whole object becomes
+// smoke in its own shape: as the front passes, the surface gives way to wisps
+// that stay on the shape — each one lifts a little off its spot on the curl flow,
+// fades and is re-emitted, so the silhouette reads as living smoke — while one in
+// ten curls off as a soft trail. Reverting gathers it back into the solid.
+import { Color, Vector3 } from 'three';
+import { defineOperation } from '../types.js';
+import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, hideMeshes, runProgress, setFieldParams, surfaceLayer, } from './transitionField.js';
+import { sampleSurfaceCached } from './surfaceSample.js';
+import { GLSL_POINT_SIZE, createFxPoints, disposeFxPoints } from './fxPoints.js';
+const P = 'Smk';
+/** Disappear off: the in / out run takes this share of the duration (it only goes to 1, not END). */
+const KEEP_SPEED = 0.6;
+const KEY = 'curlSmoke';
+const STATE = '__opCurlSmoke';
+/** A wisp lives LIFE progress units after the front passes it. */
+const LIFE = 1.0;
+const END = 1 + LIFE;
+/** Curl of a 3D noise potential, and a path integrated through it (GLSL). */
+const CURL = /* glsl */ `
+vec3 smkPot(vec3 p) { return vec3(fxNoise(p), fxNoise(p + vec3(31.4, 7.7, 19.1)), fxNoise(p + vec3(-11.3, 43.9, 5.2))); }
+vec3 smkCurl(vec3 p) {
+  const float e = 0.08;
+  vec3 dx = (smkPot(p + vec3(e, 0.0, 0.0)) - smkPot(p - vec3(e, 0.0, 0.0))) / (2.0 * e);
+  vec3 dy = (smkPot(p + vec3(0.0, e, 0.0)) - smkPot(p - vec3(0.0, e, 0.0))) / (2.0 * e);
+  vec3 dz = (smkPot(p + vec3(0.0, 0.0, e)) - smkPot(p - vec3(0.0, 0.0, e))) / (2.0 * e);
+  return vec3(dy.z - dz.y, dz.x - dx.z, dx.y - dy.x);
+}
+`;
+export default defineOperation({
+    value: 'curlSmoke',
+    label: 'Curl smoke',
+    description: 'Turn the targets into soft smoke that swirls away (or, Disappear off, keeps their shape) — reverting draws it back in',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action', 'object'],
+    params: {
+        direction: { type: 'select', label: 'Direction', default: 'up', options: DIRECTION_OPTIONS },
+        smoke: { type: 'color', label: 'Smoke', default: '#d4d8df', hint: 'Pale for a dark scene, dark for ink on a light one' },
+        wisps: { type: 'number', label: 'Wisps', default: 24000, min: 4000, max: 90000, step: 1000 },
+        puff: { type: 'number', label: 'Softness', default: 1, min: 0.3, max: 3, step: 0.05, unit: '×', hint: 'How far each wisp swells' },
+        rise: { type: 'number', label: 'Rise', default: 1, min: 0, max: 3, step: 0.05, unit: '×' },
+        swirl: { type: 'number', label: 'Swirl', default: 1, min: 0.2, max: 3, step: 0.05, unit: '×' },
+        scale: { type: 'number', label: 'Front pattern', default: 2.5, min: 0.5, max: 12, step: 0.1 },
+        duration: { type: 'number', label: 'Duration', default: 4.5, min: 0.3, max: 14, step: 0.1, unit: 's' },
+        disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the whole object becomes smoke in its own shape and stays' },
+    },
+    objectParams: { disappear: false },
+    apply(target, p, ctx) {
+        let st = target.userData[STATE];
+        if (!st) {
+            const field = createFieldState(target);
+            field.edgeWidth.value = 0.035;
+            const own = {
+                field, smoke: { value: new Color() }, up: { value: new Vector3(0, 1, 0) }, rise: { value: 1 }, swirl: { value: 1 }, puff: { value: 1 }, dens: { value: 1 },
+                keep: { value: 0 },
+                mats: new Set(),
+            };
+            const sample = sampleSurfaceCached(target, Math.round(Number(p.wisps)), 23);
+            own.points = createFxPoints(target, sample, {
+                additive: false,
+                uniforms: { ...fieldUniforms(P, field), uSmkSmoke: own.smoke, uSmkUp: own.up, uSmkRise: own.rise, uSmkSwirl: own.swirl, uSmkPuff: own.puff, uSmkDens: own.dens, uSmkKeep: own.keep },
+                vertexPars: fieldGlsl(P) + GLSL_POINT_SIZE + CURL,
+                vertexMain: /* glsl */ `
+                  float f = SmkField(SmkNorm(aP));
+                  float E = uSmkExtent;
+                  if (uSmkKeep > 0.5) {
+                    // smoke in the object's own shape: switched on as the front passes, then each
+                    // wisp cycles on its spot — lifts a little on the curl flow, fades, is re-emitted
+                    float w = clamp((uSmkProgress - SmkBirthOf(f)) / 0.12, 0.0, 1.0);
+                    if (w <= 0.0) { gl_Position = vec4(2.0, 2.0, 2.0, 1.0); gl_PointSize = 0.0; vColor = vec3(0.0); vAlpha = 0.0; return; }
+                    float trail = step(0.9, aR.w);                    // one in ten curls off as a soft trail
+                    float al = fract(uSmkTime * 0.2 * (0.7 + 0.6 * aR.y) + aR.x);
+                    vec3 kq = aP / E * (4.0 * uSmkSwirl) + aR.xyz * 0.15;
+                    vec3 kd = vec3(0.0);
+                    float kh = al * mix(0.12, 0.3, trail);
+                    for (int i = 0; i < 6; i++) {
+                      vec3 v = smkCurl(kq + vec3(0.0, uSmkTime * 0.05, 0.0));
+                      kd += v * kh;
+                      kq += v * kh * 1.4 + uSmkUp * kh * 0.9 * uSmkRise;
+                    }
+                    vec3 kl = aP + aN * (E * (0.004 + 0.012 * al))
+                            + kd * (E * mix(0.06, 0.45, trail) / uSmkSwirl)
+                            + uSmkUp * (E * uSmkRise * mix(0.012 * al, 0.35 * al * al, trail));
+                    vec4 kmv = modelViewMatrix * vec4(kl, 1.0);
+                    gl_Position = projectionMatrix * kmv;
+                    // smoke, with a hint of the surface's colours so the form still reads
+                    vColor = mix(uSmkSmoke * (0.8 + 0.3 * aR.z), aC, 0.18);
+                    float kg = 1.0 + mix(2.2, 9.0, trail) * uSmkPuff * al;
+                    vAlpha = w * smoothstep(0.0, 0.2, al) * (1.0 - smoothstep(0.55, 1.0, al)) * clamp(0.26 * uSmkDens / kg, 0.0, 0.5) * (0.5 + 0.5 * aR.z);
+                    gl_PointSize = clamp(fxPointPx(E * 0.0105 * kg, kmv), 1.0, 90.0);
+                    return;
+                  }
+                  float a = (uSmkProgress - SmkBirthOf(f)) / ${LIFE.toFixed(2)};
+                  if (a <= 0.0 || a >= 1.0) { gl_Position = vec4(2.0, 2.0, 2.0, 1.0); gl_PointSize = 0.0; vColor = vec3(0.0); vAlpha = 0.0; return; }
+                  // integrate the path through the curl flow; the step grows with age, so the
+                  // path is a smooth function of a (no state, same wisp every frame)
+                  vec3 q = aP / E * (4.0 * uSmkSwirl) + aR.xyz * 0.15;
+                  vec3 drift = vec3(0.0);
+                  float h = a * 0.26;
+                  for (int i = 0; i < 8; i++) {
+                    vec3 v = smkCurl(q + vec3(0.0, uSmkTime * 0.05, 0.0));
+                    drift += v * h;
+                    q += v * h * 1.4 + uSmkUp * h * 0.9 * uSmkRise;
+                  }
+                  float ease = a * (0.35 + 0.65 * a);
+                  vec3 local = aP + aN * (0.03 * E * sqrt(a))
+                             + drift * (0.5 * E / uSmkSwirl)
+                             + uSmkUp * (E * 0.55 * uSmkRise * ease * (0.6 + 0.8 * aR.y));
+                  vec4 mv = modelViewMatrix * vec4(local, 1.0);
+                  gl_Position = projectionMatrix * mv;
+                  // colour: the surface's own, turning to smoke as it leaves
+                  vColor = mix(aC, uSmkSmoke * (0.8 + 0.3 * aR.z), smoothstep(0.0, 0.35, a));
+                  // a wisp swells and thins: roughly constant "mass" as it spreads
+                  float grow = 1.0 + 12.0 * uSmkPuff * a * (0.6 + 0.8 * aR.z);
+                  vAlpha = smoothstep(0.0, 0.05, a) * (1.0 - smoothstep(0.45, 1.0, a)) * clamp(0.3 * uSmkDens / grow, 0.0, 0.7) * (0.5 + 0.5 * aR.w);
+                  gl_PointSize = clamp(fxPointPx(E * 0.0065 * grow, mv), 1.0, 90.0);`,
+            });
+            const layer = surfaceLayer(P, field, 'stain');
+            forEachMeshMaterial(target, (mat, mesh) => {
+                if (mesh.userData?.__opFxHelper)
+                    return;
+                if (addLayer(mat, KEY, layer))
+                    own.mats.add(mat);
+            });
+            st = own;
+            target.userData[STATE] = st;
+        }
+        const s = st;
+        setFieldParams(s.field, p, target, ctx);
+        s.smoke.value.set(String(p.smoke));
+        s.field.edgeColor.value.set(String(p.smoke));
+        s.rise.value = Number(p.rise);
+        s.swirl.value = Number(p.swirl);
+        s.puff.value = Number(p.puff);
+        // the smoke's overall density must not depend on how many wisps carry it
+        s.dens.value = 12000 / Math.max(1000, s.points.geometry.getAttribute('aP').count);
+        // world up in the target's own space (smoke rises whatever the object's rotation)
+        target.updateWorldMatrix(true, false);
+        s.up.value.set(0, 1, 0).transformDirection(target.matrixWorld.clone().invert());
+        s.points.visible = true;
+        s.keep.value = p.disappear === false ? 1 : 0;
+        if (s.keep.value) {
+            return runProgress(target, s.field, 1, { duration: Number(p.duration) * KEEP_SPEED, ease: 'none', hold: true });
+        }
+        return runProgress(target, s.field, END, {
+            duration: Number(p.duration), ease: 'none',
+            onComplete: () => { hideMeshes(target, KEY, true); s.points.visible = false; },
+        });
+    },
+    revert(target, p) {
+        const s = target.userData[STATE];
+        if (!s)
+            return;
+        hideMeshes(target, KEY, false);
+        s.points.visible = true;
+        // same speed back, from wherever it got to
+        const span = s.keep.value ? 1 / KEEP_SPEED : END;
+        return runProgress(target, s.field, 0, {
+            duration: Number(p.duration) * Math.min(1, Math.max(0.1, s.field.progress.value / span)), ease: 'none',
+            onComplete: () => {
+                s.mats.forEach(m => removeLayer(m, KEY));
+                disposeFxPoints(s.points);
+                delete target.userData[STATE];
+            },
+        });
+    },
+});

package/dist/operations/catalogue/displayImage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"displayImage.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/displayImage.ts"],"names":[],"mappings":";AAGA,wBA4BG"}
+{"version":3,"file":"displayImage.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/displayImage.ts"],"names":[],"mappings":";AAGA,wBA6BG"}

package/dist/operations/catalogue/displayImage.js

@@ -4,6 +4,7 @@ export default defineOperation({
     value: 'displayImage',
     label: 'Show image',
     description: "Show the clicked frame's image on the target",
+    channel: 'visual',
     multi: false,
     toggles: false,
     usableIn: ['interaction'],

package/dist/operations/catalogue/dissolve.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("..").OperationDefinition;
+export default _default;
+//# sourceMappingURL=dissolve.d.ts.map

package/dist/operations/catalogue/dissolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dissolve.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/dissolve.ts"],"names":[],"mappings":";AAcA,wBA2CG"}

package/dist/operations/catalogue/dissolve.js

@@ -0,0 +1,57 @@
+// Dissolve — the targets burn away along a calm noise front with a glowing edge;
+// reverting grows them back. Built on the shared transition field, so it has the
+// same directions as every other transition (including screen left/right) and
+// shares its root-space pattern (no swimming, multi-mesh models dissolve as one).
+import { defineOperation } from '../types.js';
+import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
+import { DIRECTION_OPTIONS, createFieldState, hideMeshes, runProgress, setFieldParams, surfaceLayer } from './transitionField.js';
+const P = 'Dis';
+const KEY = 'dissolve';
+const STATE = '__opDissolve';
+export default defineOperation({
+    value: 'dissolve',
+    label: 'Dissolve',
+    description: 'Burn the targets away along a glowing edge — reverting grows them back',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action'],
+    params: {
+        direction: { type: 'select', label: 'Direction', default: 'noise', options: DIRECTION_OPTIONS },
+        edgeColor: { type: 'color', label: 'Edge colour', default: '#ff7a2e' },
+        edgeWidth: { type: 'number', label: 'Edge width', default: 0.08, min: 0.01, max: 0.3, step: 0.01 },
+        scale: { type: 'number', label: 'Grain', default: 3, min: 0.5, max: 12, step: 0.1, hint: 'Size of the burn pattern — higher = finer' },
+        duration: { type: 'number', label: 'Duration', default: 1.6, min: 0.1, max: 10, step: 0.05, unit: 's' },
+    },
+    apply(target, p, ctx) {
+        let st = target.userData[STATE];
+        if (!st) {
+            st = { field: createFieldState(target), mats: new Set() };
+            const own = st;
+            const layer = surfaceLayer(P, own.field, 'ember');
+            forEachMeshMaterial(target, (mat, mesh) => {
+                if (mesh.userData?.__opFxHelper)
+                    return;
+                if (addLayer(mat, KEY, layer))
+                    own.mats.add(mat);
+            });
+            target.userData[STATE] = st;
+        }
+        const s = st;
+        setFieldParams(s.field, p, target, ctx);
+        return runProgress(target, s.field, 1, {
+            duration: Number(p.duration), ease: 'power1.in',
+            onComplete: () => hideMeshes(target, KEY, true),
+        });
+    },
+    revert(target, p) {
+        const s = target.userData[STATE];
+        if (!s)
+            return;
+        hideMeshes(target, KEY, false);
+        return runProgress(target, s.field, 0, {
+            duration: Number(p.duration), ease: 'power1.out',
+            onComplete: () => { s.mats.forEach(m => removeLayer(m, KEY)); delete target.userData[STATE]; },
+        });
+    },
+});

package/dist/operations/catalogue/emberAsh.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("..").OperationDefinition;
+export default _default;
+//# sourceMappingURL=emberAsh.d.ts.map

package/dist/operations/catalogue/emberAsh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emberAsh.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/emberAsh.ts"],"names":[],"mappings":";AAoFA,wBA0FG"}

package/dist/operations/catalogue/emberAsh.js

@@ -0,0 +1,171 @@
+// Ember ash — the object burns the way wood and paper do, not the way a dissolve
+// does: a dull-red front chars the surface to charcoal, glowing embers breathe
+// in the cracks just behind it, the charcoal pales to powdery grey ash, and the
+// ash comes away in flakes that a wind carries off — tumbling, curling in
+// turbulence, rising on the heat, a few still glowing as they cool.
+// Reverting runs the fire backwards: the flakes blow back and the object un-burns.
+import { Color, Vector3 } from 'three';
+import { defineOperation } from '../types.js';
+import { GLSL_WORLEY, addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, hideMeshes, runProgress, screenRight, setFieldParams, } from './transitionField.js';
+import { sampleSurfaceCached } from './surfaceSample.js';
+import { GLSL_POINT_SIZE, createFxPoints, disposeFxPoints } from './fxPoints.js';
+const P = 'Ash';
+const KEY = 'emberAsh';
+const STATE = '__opEmberAsh';
+/** The ash front trails the char front by LAG; flakes fly for LIFE (progress units). */
+const LAG = 0.3;
+const LIFE = 0.7;
+const END = 1 + LAG + LIFE;
+/** Shared GLSL: the char front, the ash front, and where a point stands between them. */
+const FRONTS = /* glsl */ `
+float ashChar(float f) { return smoothstep(0.0, 0.12, AshThreshold() - f); }
+float ashAshT() {
+  float pa = clamp((uAshProgress - ${LAG.toFixed(2)}) / 1.0, 0.0, 1.0);
+  return pa * (1.0 + 2.0 * uAshEdgeWidth) - uAshEdgeWidth;
+}
+`;
+function surfaceLayerFor(st) {
+    return {
+        uniforms: { ...fieldUniforms(P, st.field), uAshEmber: st.ember },
+        common: `varying vec3 vAshQ;\nvarying vec3 vAshR;\n${fieldGlsl(P)}\n${GLSL_WORLEY}\n${FRONTS}`,
+        vertex: /* glsl */ `
+        vAshR = (uAshRootInv * modelMatrix * vec4(transformed, 1.0)).xyz;
+        vAshQ = AshNorm(vAshR);`,
+        diffuse: /* glsl */ `
+        {
+          float f = AshField(vAshQ);
+          float ta = ashAshT();
+          if (f < ta) discard;                                           // gone to the wind
+          float ch = ashChar(f);
+          float toAsh = 1.0 - smoothstep(0.0, 0.14, f - ta);            // pales just before it flakes
+          vec3 charcoal = vec3(0.045, 0.04, 0.036) * (0.7 + 0.6 * fxNoise(vAshR / uAshExtent * 60.0));
+          vec3 ash = vec3(0.58, 0.56, 0.53) * (0.8 + 0.3 * fxNoise(vAshR / uAshExtent * 90.0));
+          diffuseColor.rgb = mix(diffuseColor.rgb, charcoal, ch * 0.96);
+          diffuseColor.rgb = mix(diffuseColor.rgb, ash, toAsh);
+        }`,
+        material: /* glsl */ `
+        {
+          float ch = ashChar(AshField(vAshQ));
+          roughnessFactor = mix(roughnessFactor, 0.95, ch);
+          metalnessFactor = mix(metalnessFactor, 0.0, ch);
+        }`,
+        fragment: /* glsl */ `
+        {
+          float f = AshField(vAshQ);
+          float tc = AshThreshold();
+          float ch = ashChar(f);
+          float ta = ashAshT();
+          float toAsh = 1.0 - smoothstep(0.0, 0.14, f - ta);
+          // embers live in the cracks just behind the char front, and die as it turns to ash
+          vec3 cell = fxWorley(vAshR / uAshExtent * 22.0);
+          float crack = 1.0 - smoothstep(0.0, 0.08, cell.y - cell.x);
+          float speck = step(0.78, fxNoise(vAshR / uAshExtent * 75.0));
+          float heat = ch * (1.0 - toAsh) * exp(-max(tc - f, 0.0) / 0.12);
+          float breathe = 0.7 + 0.3 * sin(uAshTime * 2.1 + cell.z * 6.2832);
+          float glow = heat * breathe * (crack * 0.9 + speck * 0.6);
+          vec3 emberC = mix(uAshEmber * vec3(0.5, 0.12, 0.02), uAshEmber, glow);
+          // the front itself: a dull red line, never white-hot
+          float front = exp(-abs(tc - f) / 0.018) * step(0.0001, uAshProgress) * step(uAshProgress, 0.9999);
+          outgoingLight += emberC * glow * 1.5 + uAshEmber * vec3(0.9, 0.35, 0.12) * front * 0.7;
+        }`,
+    };
+}
+export default defineOperation({
+    value: 'emberAsh',
+    label: 'Ember ash',
+    description: 'Char the targets to glowing charcoal, then pale ash that the wind blows away — reverting un-burns them',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action'],
+    params: {
+        direction: { type: 'select', label: 'Burn direction', default: 'up', options: DIRECTION_OPTIONS },
+        wind: { type: 'select', label: 'Wind', default: 'left', options: [{ value: 'left', label: 'Left → right' }, { value: 'right', label: 'Right → left' }, { value: 'up', label: 'Rising' }] },
+        windStrength: { type: 'number', label: 'Wind strength', default: 1, min: 0, max: 4, step: 0.05, unit: '×' },
+        ember: { type: 'color', label: 'Ember colour', default: '#ff6a1f' },
+        flakes: { type: 'number', label: 'Ash flakes', default: 16000, min: 2000, max: 80000, step: 1000 },
+        flakeSize: { type: 'number', label: 'Flake size', default: 1, min: 0.2, max: 4, step: 0.1, unit: '×' },
+        scale: { type: 'number', label: 'Burn pattern', default: 2.5, min: 0.5, max: 12, step: 0.1 },
+        duration: { type: 'number', label: 'Duration', default: 4, min: 0.3, max: 14, step: 0.1, unit: 's' },
+    },
+    apply(target, p, ctx) {
+        let st = target.userData[STATE];
+        if (!st) {
+            const field = createFieldState(target);
+            field.edgeWidth.value = 0.05;
+            const own = { field, wind: { value: new Vector3(1, 0, 0) }, windStrength: { value: 1 }, ember: { value: new Color() }, flake: { value: 1 }, mats: new Set() };
+            const sample = sampleSurfaceCached(target, Math.round(Number(p.flakes)), 7);
+            own.points = createFxPoints(target, sample, {
+                additive: false,
+                uniforms: { ...fieldUniforms(P, field), uAshWind: own.wind, uAshWindK: own.windStrength, uAshEmber: own.ember, uAshFlake: own.flake },
+                vertexPars: fieldGlsl(P) + GLSL_POINT_SIZE + FRONTS,
+                vertexMain: /* glsl */ `
+                  float f = AshField(AshNorm(aP));
+                  // a flake leaves when the ash front reaches it
+                  float born = ${LAG.toFixed(2)} + AshBirthOf(f);
+                  float a = (uAshProgress - born) / ${LIFE.toFixed(2)};
+                  if (a <= 0.0 || a >= 1.0) { gl_Position = vec4(2.0, 2.0, 2.0, 1.0); gl_PointSize = 0.0; vColor = vec3(0.0); vAlpha = 0.0; return; }
+                  float E = uAshExtent;
+                  // wind: accelerating along the wind, curling in slow turbulence, lifted by the heat
+                  vec3 np = aP / E * 2.2 + aR.xyz * 5.0;
+                  vec3 turb = vec3(fxNoise(np + vec3(a * 1.6, 0.0, 0.0)), fxNoise(np + vec3(17.0, a * 1.6, 3.0)), fxNoise(np + vec3(5.0, 11.0, a * 1.6))) - 0.5;
+                  vec3 local = aP + aN * (0.02 * E * sqrt(a))
+                             + uAshWind * (E * uAshWindK * (0.5 * a + 1.3 * a * a) * (0.7 + 0.6 * aR.x))
+                             + turb * (0.5 * E * a)
+                             + vec3(0.0, 0.22 * E * a * (0.5 + aR.y), 0.0);
+                  vec4 mv = modelViewMatrix * vec4(local, 1.0);
+                  gl_Position = projectionMatrix * mv;
+                  // most flakes are grey ash; one in six still glows, cooling as it flies
+                  float glowing = step(0.83, aR.w);
+                  vec3 ash = mix(vec3(0.66, 0.64, 0.6), vec3(0.24, 0.23, 0.22), aR.z);
+                  vec3 hot = mix(uAshEmber * 1.8, uAshEmber * vec3(0.35, 0.08, 0.02), a);
+                  vColor = mix(ash, hot, glowing);
+                  vAlpha = smoothstep(0.0, 0.05, a) * (1.0 - smoothstep(0.7, 1.0, a));
+                  // a tumbling flake shows its face, then its edge
+                  float tumble = 0.35 + 0.65 * abs(sin(a * (9.0 + 12.0 * aR.y) + aR.x * 6.28));
+                  gl_PointSize = clamp(fxPointPx(E * 0.0055 * uAshFlake * (0.5 + aR.z) * tumble, mv), 1.0, 14.0);`,
+            });
+            const layer = surfaceLayerFor(own);
+            forEachMeshMaterial(target, (mat, mesh) => {
+                if (mesh.userData?.__opFxHelper)
+                    return;
+                if (addLayer(mat, KEY, layer))
+                    own.mats.add(mat);
+            });
+            st = own;
+            target.userData[STATE] = st;
+        }
+        const s = st;
+        setFieldParams(s.field, p, target, ctx);
+        s.ember.value.set(String(p.ember));
+        s.windStrength.value = Number(p.windStrength);
+        s.flake.value = Number(p.flakeSize);
+        if (p.wind === 'up')
+            s.wind.value.set(0, 1, 0);
+        else {
+            const r = screenRight(target, ctx);
+            s.wind.value.copy(p.wind === 'right' ? r.negate() : r);
+        }
+        s.points.visible = true;
+        return runProgress(target, s.field, END, {
+            duration: Number(p.duration), ease: 'none',
+            onComplete: () => { hideMeshes(target, KEY, true); s.points.visible = false; },
+        });
+    },
+    revert(target, p) {
+        const s = target.userData[STATE];
+        if (!s)
+            return;
+        hideMeshes(target, KEY, false);
+        s.points.visible = true;
+        return runProgress(target, s.field, 0, {
+            duration: Number(p.duration), ease: 'none',
+            onComplete: () => {
+                s.mats.forEach(m => removeLayer(m, KEY));
+                disposeFxPoints(s.points);
+                delete target.userData[STATE];
+            },
+        });
+    },
+});

package/dist/operations/catalogue/fade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fade.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/fade.ts"],"names":[],"mappings":";AAMA,wBAoCG"}
+{"version":3,"file":"fade.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/fade.ts"],"names":[],"mappings":";AAMA,wBAqCG"}

package/dist/operations/catalogue/fade.js

@@ -6,6 +6,7 @@ export default defineOperation({
     value: 'fade',
     label: 'Fade out',
     description: 'Fade the targets away (to a set opacity)',
+    channel: 'visual',
     multi: true,
     toggles: true,
     usableIn: ['interaction', 'action'],

package/dist/operations/catalogue/flip.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("..").OperationDefinition;
+export default _default;
+//# sourceMappingURL=flip.d.ts.map

package/dist/operations/catalogue/flip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flip.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/flip.ts"],"names":[],"mappings":";AAaA,wBAoDG"}

package/dist/operations/catalogue/flip.js

@@ -0,0 +1,69 @@
+// Flip — a proper little jump: crouch (anticipation), spring up, a full flip in
+// the air about the object's centre, and a squash on landing. One-shot, lands
+// exactly on the rest pose.
+import { gsap } from 'gsap';
+import { Quaternion, Vector3 } from 'three';
+import { defineOperation } from '../types.js';
+import { acquireRest, poseAbout, releaseRest } from './restPose.js';
+const KEY = '__opFlip';
+const AXES = { x: new Vector3(1, 0, 0), z: new Vector3(0, 0, 1), y: new Vector3(0, 1, 0) };
+const NO_TURN = new Quaternion();
+const smooth = (x) => x * x * (3 - 2 * x);
+export default defineOperation({
+    value: 'flip',
+    label: 'Flip',
+    description: 'Crouch, jump and flip in the air, landing with a squash',
+    channel: 'transform',
+    multi: true,
+    toggles: false,
+    usableIn: ['interaction', 'action'],
+    params: {
+        axis: { type: 'select', label: 'Flip', default: 'x', options: [{ value: 'x', label: 'Forward (X)' }, { value: 'z', label: 'Sideways (Z)' }, { value: 'y', label: 'Twist (Y)' }] },
+        height: { type: 'number', label: 'Jump height', default: 0.45, min: 0.1, max: 4, step: 0.05, hint: 'A fraction of the object’s own height' },
+        reverse: { type: 'boolean', label: 'Backwards', default: false },
+        duration: { type: 'number', label: 'Duration', default: 1.3, min: 0.3, max: 5, step: 0.05, unit: 's' },
+    },
+    apply(target, p) {
+        const running = target.userData[KEY];
+        if (running) {
+            gsap.killTweensOf(running.proxy);
+            releaseRest(target);
+        }
+        const rest = acquireRest(target);
+        const proxy = { u: 0 };
+        target.userData[KEY] = { proxy };
+        const axis = AXES[String(p.axis)] ?? AXES.x;
+        const dir = p.reverse ? -1 : 1;
+        const h = rest.size.y * Number(p.height);
+        const q = new Quaternion(), s = new Vector3(), off = new Vector3();
+        const CROUCH = 0.18, LAND = 0.82;
+        gsap.to(proxy, {
+            u: 1, duration: Number(p.duration), ease: 'none',
+            onUpdate: () => {
+                const u = proxy.u;
+                if (u < CROUCH) {
+                    // anticipation: squash down and release, about the base
+                    const v = u / CROUCH;
+                    const sy = 1 - 0.16 * Math.sin(Math.PI * v);
+                    const sxz = 1 / Math.sqrt(sy);
+                    poseAbout(target, rest, rest.bottomLocal, NO_TURN, s.set(sxz, sy, sxz));
+                }
+                else if (u < LAND) {
+                    // ballistic hop + a full turn about the centre, eased so it hangs at the top
+                    const v = (u - CROUCH) / (LAND - CROUCH);
+                    off.set(0, 4 * h * v * (1 - v), 0);
+                    q.setFromAxisAngle(axis, dir * 2 * Math.PI * smooth(v));
+                    poseAbout(target, rest, rest.centerLocal, q, s.set(1, 1, 1), off);
+                }
+                else {
+                    // landing: squash that rings out once
+                    const v = (u - LAND) / (1 - LAND);
+                    const sy = 1 - 0.14 * Math.sin(Math.PI * v) * (1 - v * 0.4);
+                    const sxz = 1 / Math.sqrt(sy);
+                    poseAbout(target, rest, rest.bottomLocal, NO_TURN, s.set(sxz, sy, sxz));
+                }
+            },
+            onComplete: () => { delete target.userData[KEY]; releaseRest(target); },
+        });
+    },
+});

package/dist/operations/catalogue/flock.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("..").OperationDefinition;
+export default _default;
+//# sourceMappingURL=flock.d.ts.map

package/dist/operations/catalogue/flock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flock.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/flock.ts"],"names":[],"mappings":";AA6CA,wBAwHG"}