reze-engine 0.61.4 → 0.61.6

package/dist/engine.js

@@ -42,6 +42,7 @@ import { boneOverlay, boneMarkerPositions, buildOverlayShapes, jointOverlay, lin
 import { BLOOM_BLIT_SHADER_WGSL, BLOOM_DOWNSAMPLE_SHADER_WGSL, BLOOM_UPSAMPLE_SHADER_WGSL, } from "./shaders/passes/bloom";
 import { AGX_LUT_GZ, AGX_LUT_SIZE } from "./shaders/agx-lut";
 import { buildCompositeShader, EFFECT_SCENE_API, buildFieldShader, EFFECT_ANCHORS, EFFECT_SUBJECTS, EFFECT_TRAIL_BASE, EFFECT_TRAIL_SAMPLES, } from "./shaders/passes/composite";
+import { SUBSURFACE_WGSL, SSS_SPIKE } from "./shaders/passes/subsurface";
 import { buildParticleComputeShader, buildParticleRenderShader, PARTICLE_LIGHT_BINDING, PARTICLE_POINTS_BINDING, particleEntryPoints, PARTICLE_INDIRECT_BINDING, PARTICLE_INDIRECT_BYTES, PARTICLE_INDIRECT_DRAW_OFFSET, PARTICLE_STRIDE, } from "./shaders/passes/particles";
 import { MAX_EFFECT_POINTS, POINTS_FLOATS } from "./shaders/points-api";
 import { bonesWithPrefix, pointsData, writeBonePoint } from "./effect-points";
@@ -1139,6 +1140,28 @@ export class Engine {
         /** Scene-clock reading when the current effect was installed. The effect's
          *  `time` is measured from here — see where it is written. */
         this.compositeBloomView = null;
+        // Screen-space subsurface scattering (passes/subsurface.ts). The scratch target
+        // is the X pass's output and lives with the canvas size; the bind groups name
+        // it and the HDR resolve, so a resize drops them and the next frame rebuilds.
+        this.sssPipelineX = null;
+        this.sssPipelineY = null;
+        this.sssScratch = null;
+        this.sssBindGroupX = null;
+        this.sssBindGroupY = null;
+        this.sssUniformX = null;
+        this.sssUniformY = null;
+        this.sssUniformData = new Float32Array(8);
+        // Model pipelines' descriptors, and the single-sided twins built from them —
+        // one per pipeline per view (see sidedPipeline).
+        this.pipelineDescs = new WeakMap();
+        this.singleSided = new WeakMap();
+        this.singleSidedMirror = new WeakMap();
+        // Stepped motion (#stepped). The models whose pose is being HELD this frame —
+        // their skinning and morph uploads wait for the stepped clock's next tick —
+        // and the tick each was last shown at. Empty while no effect declares it.
+        this.steppedHeld = new Set();
+        this.steppedTick = new Map();
+        this.steppedLastClock = -1;
         this.bloomBlitUniformData = new Float32Array(4);
         this.bloomUpsampleUniformData = new Float32Array(4);
         this.bloomMipCount = 0;
@@ -2113,18 +2136,51 @@ export class Engine {
         return slot ? fx.paramsData[slot.offset] : fallback;
     }
     /**
-     * Drive the mirror from whichever effect declares one.
+     * Decide which models hold their pose this frame.
      *
-     * Runs before reflectionActive is read, because the answer to "is there a
-     * mirror" is this function's output. FIRST match wins and the rest are
-     * ignored: there is one reflection target, so a second mirror is not a second
-     * mirror, it is a fight over the same plane — and a scene that quietly
-     * reflected the wrong one would be far harder to understand than one where
-     * the second mirror does nothing.
+     * Nothing underneath is slowed: animation and physics run every frame as they
+     * always do, so the pose that lands on each tick is the true one for that
+     * moment and a hold never drifts behind the music. What steps is only when it
+     * reaches the GPU — the skinning upload and the morph dispatch wait for the
+     * next tick of a clock running at FPS on the scene clock, which is what an
+     * export steps.
      *
-     * Gated on `weight`, so a scheduled mirror appears and leaves with its strip
-     * and a faded-out one costs no reflection pass at all.
+     * FIRST match wins, and only the models it is aimed at hold: a stage, a prop
+     * and every effect keep moving on ones, which is what makes the cast read as
+     * animated rather than the playback as broken.
      */
+    syncSteppedFromEffects() {
+        this.steppedHeld.clear();
+        let fx = null;
+        for (const e of this.effects) {
+            if (e.stepped && e.weight > 0) {
+                fx = e;
+                break;
+            }
+        }
+        if (!fx) {
+            this.steppedTick.clear();
+            return;
+        }
+        // Paused, nothing holds: time is not moving, so there is nothing to step,
+        // and a pose edited on a stopped timeline has to show as it is edited.
+        const paused = this.sceneClock === this.steppedLastClock;
+        this.steppedLastClock = this.sceneClock;
+        if (paused)
+            return;
+        const D = Engine.STEPPED_DIALS;
+        const fps = Math.max(this.effectDial(fx, D.fps, 6), 1);
+        const tick = Math.floor(this.sceneClock * fps + 1e-6);
+        this.forEachInstance((inst) => {
+            const slot = this.castSlotOf.get(inst.name);
+            if (slot === undefined || !(fx.subjectMask & (1 << slot)))
+                return;
+            if (this.steppedTick.get(inst.name) === tick)
+                this.steppedHeld.add(inst.name);
+            else
+                this.steppedTick.set(inst.name, tick);
+        });
+    }
     syncMirrorFromEffects() {
         let fx = null;
         for (const e of this.effects) {
@@ -3430,14 +3486,15 @@ export class Engine {
         // #mirror is a mount on the same footing, and for the same reason: a
         // reflection re-renders the scene from a folded camera, which is a pass and
         // not a shader, so the effect declares it and draws nothing itself.
-        if (!hasBackground && !hasForeground && !wantsParticles && !wantsTrails && !hasLightEmit(wgsl) && !d.mirror) {
+        // #stepped too: it decides when a pose reaches the screen, not what is drawn.
+        if (!hasBackground && !hasForeground && !wantsParticles && !wantsTrails && !hasLightEmit(wgsl) && !d.mirror && !d.stepped) {
             return { ok: false, diagnostics: [
                     "an effect must define fn background(ray: vec3f, uv: vec2f, time: f32) -> vec4f, " +
                         "fn foreground(ray: vec3f, uv: vec2f, time: f32, depth: f32) -> vec4f, " +
                         "the particle trio (particleInit/particleStep/particleShade), " +
                         "the ribbon pair (trailWidth/trailShade), " +
                         "fn lightEmit(i: u32) -> RzLight with #lights <n>, " +
-                        "or #mirror",
+                        "#mirror, or #stepped",
                 ], mounts: noMounts, params: [], duration: 0, readsCast: false };
         }
         const mounts = { background: hasBackground, foreground: hasForeground };
@@ -3743,6 +3800,7 @@ export class Engine {
             paramsBuffer,
             paramsData,
             hasMirror: d.mirror,
+            stepped: d.stepped,
             hasBackground,
             hasForeground,
             // The author's OWN source, not the assembled module: the assembled one
@@ -4764,6 +4822,129 @@ export class Engine {
     /** The user's field mounts, drawn at half resolution for the composite to
      *  upsample. Runs the whole quad — uniform control flow, so effects may use
      *  derivatives freely, which the old inline path had to forbid. */
+    /** Whether any installed style group routes through a `subsurface` node —
+     *  the scattering pass, and the depth it reads, cost nothing otherwise. */
+    subsurfaceInUse() {
+        for (const inst of this.modelInstances.values()) {
+            for (const g of inst.styleGroups.values()) {
+                if (g.group.materials.length && g.group.graph.nodes.some((n) => n.type === "subsurface"))
+                    return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * ray-mmd's skin scattering: a horizontal then a vertical depth-aware blur of
+     * the pixels the scene pass marked as skin (aux .b), the second written back
+     * into the HDR resolve through a blend that keeps ray-mmd's per-channel share
+     * of the unblurred picture. See passes/subsurface.ts.
+     */
+    renderSubsurface(encoder) {
+        if (!this.device || !this.subsurfaceInUse())
+            return;
+        if (!this.hdrResolveTexture || !this.maskResolveView || !this.depthReadView || !this.dofUniformBuffer)
+            return;
+        const w = this.hdrResolveTexture.width;
+        const h = this.hdrResolveTexture.height;
+        if (!this.sssPipelineX || !this.sssPipelineY) {
+            const module = this.device.createShaderModule({ label: "subsurface scattering", code: SUBSURFACE_WGSL });
+            this.sssPipelineX = this.device.createRenderPipeline({
+                label: "subsurface blur x",
+                layout: "auto",
+                vertex: { module, entryPoint: "vs" },
+                fragment: { module, entryPoint: "fsX", targets: [{ format: this.hdrFormat }] },
+                primitive: { topology: "triangle-list" },
+            });
+            // result = blurred·(1 − spike) + original·spike, per channel: the
+            // destination is the original, and the blend constant holds the spike.
+            this.sssPipelineY = this.device.createRenderPipeline({
+                label: "subsurface blur y",
+                layout: "auto",
+                vertex: { module, entryPoint: "vs" },
+                fragment: {
+                    module,
+                    entryPoint: "fsY",
+                    targets: [
+                        {
+                            format: this.hdrFormat,
+                            blend: {
+                                color: { srcFactor: "one-minus-constant", dstFactor: "constant", operation: "add" },
+                                alpha: { srcFactor: "zero", dstFactor: "one", operation: "add" },
+                            },
+                        },
+                    ],
+                },
+                primitive: { topology: "triangle-list" },
+            });
+            this.sssBindGroupX = null;
+            this.sssBindGroupY = null;
+        }
+        if (!this.sssUniformX || !this.sssUniformY) {
+            const make = (label) => this.device.createBuffer({ label, size: 32, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+            this.sssUniformX = make("subsurface uniforms x");
+            this.sssUniformY = make("subsurface uniforms y");
+        }
+        if (!this.sssScratch || this.sssScratch.width !== w || this.sssScratch.height !== h) {
+            this.sssScratch?.destroy();
+            this.sssScratch = this.device.createTexture({
+                label: "subsurface scratch",
+                size: [w, h],
+                format: this.hdrFormat,
+                usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
+            });
+            this.sssBindGroupX = null;
+            this.sssBindGroupY = null;
+        }
+        if (!this.sssBindGroupX || !this.sssBindGroupY) {
+            const mask = this.maskResolveView;
+            const depth = this.depthReadView;
+            const dof = this.dofUniformBuffer;
+            const group = (pipeline, src, uniforms, label) => this.device.createBindGroup({
+                label,
+                layout: pipeline.getBindGroupLayout(0),
+                entries: [
+                    { binding: 0, resource: src.createView() },
+                    { binding: 1, resource: mask },
+                    { binding: 2, resource: depth },
+                    { binding: 3, resource: { buffer: dof } },
+                    { binding: 4, resource: { buffer: uniforms } },
+                ],
+            });
+            this.sssBindGroupX = group(this.sssPipelineX, this.hdrResolveTexture, this.sssUniformX, "subsurface x");
+            this.sssBindGroupY = group(this.sssPipelineY, this.sssScratch, this.sssUniformY, "subsurface y");
+        }
+        const tanY = Math.tan(this.camera.fov * 0.5);
+        const u = this.sssUniformData;
+        u[2] = 0;
+        u[3] = 0;
+        u[4] = tanY * this.camera.aspect;
+        u[5] = tanY;
+        u[6] = w;
+        u[7] = h;
+        u[0] = 1;
+        u[1] = 0;
+        this.device.queue.writeBuffer(this.sssUniformX, 0, u);
+        u[0] = 0;
+        u[1] = 1;
+        this.device.queue.writeBuffer(this.sssUniformY, 0, u);
+        const px = encoder.beginRenderPass({
+            label: "subsurface blur x",
+            colorAttachments: [{ view: this.sssScratch.createView(), loadOp: "clear", clearValue: [0, 0, 0, 0], storeOp: "store" }],
+        });
+        px.setPipeline(this.sssPipelineX);
+        px.setBindGroup(0, this.sssBindGroupX);
+        px.draw(3);
+        px.end();
+        const py = encoder.beginRenderPass({
+            label: "subsurface blur y",
+            colorAttachments: [{ view: this.hdrResolveTexture.createView(), loadOp: "load", storeOp: "store" }],
+        });
+        py.setPipeline(this.sssPipelineY);
+        py.setBindGroup(0, this.sssBindGroupY);
+        py.setBlendConstant({ r: SSS_SPIKE[0], g: SSS_SPIKE[1], b: SSS_SPIKE[2], a: 0 });
+        py.draw(3);
+        py.end();
+    }
     renderFieldPass(encoder) {
         // TWO PREDICATES, deliberately, and they are not interchangeable.
         //
@@ -5781,7 +5962,7 @@ export class Engine {
     }
     createRenderPipeline(config) {
         const targets = config.fragmentTargets ?? (config.fragmentTarget ? [config.fragmentTarget] : undefined);
-        return this.device.createRenderPipeline({
+        return this.createModelPipeline({
             label: config.label,
             layout: config.layout,
             vertex: {
@@ -6195,7 +6376,7 @@ export class Engine {
                 depthCompare: this.depthAhead,
             },
         };
-        this.depthPrepassPipeline = this.device.createRenderPipeline({
+        this.depthPrepassPipeline = this.createModelPipeline({
             label: "opaque depth prepass",
             ...prepassDesc,
             fragment: {
@@ -6207,7 +6388,7 @@ export class Engine {
         // The SOLID prime: same module, cutoff forced to exactly 1.0. Only texels
         // whose blend ignores the destination may pre-claim depth in the
         // transparent phase — see the override's note in depth-prepass.ts.
-        this.solidPrepassPipeline = this.device.createRenderPipeline({
+        this.solidPrepassPipeline = this.createModelPipeline({
             label: "transparent solid prepass",
             ...prepassDesc,
             fragment: {
@@ -6223,7 +6404,7 @@ export class Engine {
         // hair depth from ever claiming the pixels the see-through-hair pass needs
         // the eye to survive on. (Bundle draws use the PASS's stencil reference;
         // only pipeline/bind/vertex state resets across executeBundles.)
-        this.hairPrimePipeline = this.device.createRenderPipeline({
+        this.hairPrimePipeline = this.createModelPipeline({
             label: "hair depth prime",
             ...prepassDesc,
             depthStencil: {
@@ -7035,6 +7216,10 @@ export class Engine {
                 usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
             });
             this.maskResolveView = this.maskResolveTexture.createView();
+            this.sssScratch?.destroy();
+            this.sssScratch = null;
+            this.sssBindGroupX = null;
+            this.sssBindGroupY = null;
             // The floor mirror's targets — FULL resolution, the same attachment
             // contract and sample count as the scene pass, which is what lets the
             // mirror bundles reuse every scene pipeline unchanged. Half res was the
@@ -8739,6 +8924,8 @@ export class Engine {
             bindGroup: this.groundShadowBindGroup,
             materialName: "Ground",
             groupId: null,
+            // The ground's own pipeline decides its culling.
+            doubleSided: true,
             // The ground belongs to no model instance, so it is not in the cull list —
             // cullIndex -1 leaves renderGround unconditional. Its box is filled in
             // anyway rather than left a lie for whoever reads this next.
@@ -10697,6 +10884,9 @@ export class Engine {
             const gm = inst.gpuMorph;
             if (!gm || !gm.dispatchNeeded)
                 continue;
+            // The face holds with the body (see syncSteppedFromEffects).
+            if (this.steppedHeld.has(inst.name))
+                continue;
             if (!pass) {
                 pass = encoder.beginComputePass({ label: "morph compute", timestampWrites: this.stamps("morph") });
                 pass.setPipeline(this.morphComputePipeline);
@@ -12449,6 +12639,7 @@ export class Engine {
                 groupId: null,
                 baseBindGroupEntries,
                 castsShadow,
+                doubleSided: inst.isPlane || (mat.edgeFlag & 0x01) !== 0,
                 outline,
                 bounds,
                 cullIndex: -1,
@@ -13649,6 +13840,7 @@ export class Engine {
             this.handleResize();
         }
         const hasModels = this.modelInstances.size > 0;
+        this.syncSteppedFromEffects();
         if (hasModels) {
             this.updateInstances(deltaTime);
             this.updateSkinMatrices();
@@ -13746,7 +13938,10 @@ export class Engine {
         // The two real readers are both in the composite and both have their own
         // flag above: linearDepth() feeds the DoF gather and the depth handed to a
         // foreground mount. Nothing else binds depthTex at all.
-        const depthRead = dofOn || this.effects.some((e) => e.hasForeground);
+        // The scattering pass is the third reader: it rejects taps across a depth
+        // step and scales its width by distance, so a scene wearing a subsurface
+        // look stores depth for as long as it does.
+        const depthRead = dofOn || this.effects.some((e) => e.hasForeground) || this.subsurfaceInUse();
         this.renderPassDescriptor.depthStencilAttachment.depthStoreOp = depthRead ? "store" : "discard";
         if (depthRead)
             this.writeDepthOfFieldUniforms();
@@ -13946,6 +14141,9 @@ export class Engine {
         // kept ribbons out of bloom.
         this.drawTrails(pass, "camera");
         pass.end();
+        // Skin scattering, on the resolved scene and before anything reads it:
+        // bloom should bleed the scattered skin, not the raw one.
+        this.renderSubsurface(encoder);
         // The field mounts, likewise: after the scene so foregrounds can read its
         // depth, before the composite that samples both layers.
         this.renderFieldPass(encoder);
@@ -14730,11 +14928,53 @@ export class Engine {
                 stencilWriteMask: 0xff,
             };
         }
-        return this.device.createRenderPipelineAsync({
+        const desc = {
             ...base,
             fragment: { module, constants, targets: blend === "additive" ? this.sceneTargetsAdditive : this.sceneTargets },
             depthStencil,
-        });
+        };
+        return this.device.createRenderPipelineAsync(desc).then((pipeline) => {
+            this.pipelineDescs.set(pipeline, desc);
+            return pipeline;
+        });
+    }
+    /** A pipeline whose descriptor is kept, so a single-sided twin can be built
+     *  from it on demand (see sidedPipeline). */
+    createModelPipeline(desc) {
+        const pipeline = this.device.createRenderPipeline(desc);
+        this.pipelineDescs.set(pipeline, desc);
+        return pipeline;
+    }
+    /**
+     * The pipeline a draw should use once its double-sided flag is honoured.
+     *
+     * A single-sided material culls its back faces, as MMD does. PMX winds a front
+     * face clockwise, which this engine sees as a BACK face — the eye's front cull
+     * and the outline hull's back cull are the same fact — so the cull is "front"
+     * for the camera and "back" in the mirror, whose reflection flips winding.
+     *
+     * Every pipeline that draws a material's surface goes through here, depth
+     * primes included: a prime that kept a culled face would write depth for a
+     * surface nobody sees and hide what is behind it. A pipeline that already
+     * culls (the eye) is returned as it is.
+     */
+    sidedPipeline(pipeline, draw, mirrored) {
+        if (draw.doubleSided)
+            return pipeline;
+        const desc = this.pipelineDescs.get(pipeline);
+        if (!desc || (desc.primitive?.cullMode ?? "none") !== "none")
+            return pipeline;
+        const cache = mirrored ? this.singleSidedMirror : this.singleSided;
+        let twin = cache.get(pipeline);
+        if (!twin) {
+            twin = this.device.createRenderPipeline({
+                ...desc,
+                label: `${desc.label ?? "pipeline"} (single-sided${mirrored ? ", mirror" : ""})`,
+                primitive: { ...desc.primitive, cullMode: mirrored ? "back" : "front" },
+            });
+            cache.set(pipeline, twin);
+        }
+        return twin;
     }
     // Pipeline for a material draw call: its group's compiled pipeline when grouped, else
     // the neutral base (ungrouped materials render the default graph). Transparent-bucket
@@ -14790,7 +15030,8 @@ export class Engine {
                 pass.setBindGroup(1, inst.mainPerInstanceBindGroup);
                 bound = true;
             }
-            const pipeline = this.pipelineForDrawCall(inst, draw, view.args === "mirror");
+            const mirrored = view.args === "mirror";
+            const pipeline = this.sidedPipeline(this.pipelineForDrawCall(inst, draw, mirrored), draw, mirrored);
             if (pipeline !== currentPipeline) {
                 pass.setPipeline(pipeline);
                 currentPipeline = pipeline;
@@ -14892,15 +15133,18 @@ export class Engine {
     /** Depth-only prime of the hair's alpha-1 texels, stencil-fenced off the eye
      *  silhouette. See the note at its call site and hairPrimePipeline. */
     drawHairDepthPrime(pass, inst, view) {
-        let bound = false;
+        let bound = null;
         for (const draw of inst.drawCalls) {
             if (draw.type !== "opaque" || !this.isHairDraw(inst, draw))
                 continue;
-            if (!bound) {
-                pass.setPipeline(this.hairPrimePipeline);
-                pass.setBindGroup(0, view.perFrame);
-                pass.setBindGroup(1, inst.mainPerInstanceBindGroup);
-                bound = true;
+            const pipeline = this.sidedPipeline(this.hairPrimePipeline, draw, view.args === "mirror");
+            if (bound !== pipeline) {
+                pass.setPipeline(pipeline);
+                if (!bound) {
+                    pass.setBindGroup(0, view.perFrame);
+                    pass.setBindGroup(1, inst.mainPerInstanceBindGroup);
+                }
+                bound = pipeline;
             }
             pass.setBindGroup(2, draw.bindGroup);
             this.issueDraw(pass, draw, view.args);
@@ -14962,6 +15206,7 @@ export class Engine {
                 else if (install && install.alphaMode !== "opaque")
                     continue;
             }
+            pipeline = this.sidedPipeline(pipeline, draw, view.args === "mirror");
             if (bound !== pipeline) {
                 pass.setPipeline(pipeline);
                 // One layout for both prepass pipelines, so groups 0 and 1 carry over.
@@ -14995,15 +15240,18 @@ export class Engine {
     drawTransparentSolidPrepass(pass, inst, view) {
         if (inst.isStage)
             return;
-        let bound = false;
+        let bound = null;
         for (const draw of inst.drawCalls) {
             if (draw.type !== "transparent")
                 continue;
-            if (!bound) {
-                pass.setPipeline(this.solidPrepassPipeline);
-                pass.setBindGroup(0, view.perFrame);
-                pass.setBindGroup(1, inst.mainPerInstanceBindGroup);
-                bound = true;
+            const pipeline = this.sidedPipeline(this.solidPrepassPipeline, draw, view.args === "mirror");
+            if (bound !== pipeline) {
+                pass.setPipeline(pipeline);
+                if (!bound) {
+                    pass.setBindGroup(0, view.perFrame);
+                    pass.setBindGroup(1, inst.mainPerInstanceBindGroup);
+                }
+                bound = pipeline;
             }
             pass.setBindGroup(2, draw.bindGroup);
             this.issueDraw(pass, draw, view.args);
@@ -15054,9 +15302,10 @@ export class Engine {
         for (const draw of inst.drawCalls) {
             if (draw.type !== "opaque")
                 continue;
-            const overEyes = this.overEyesPipelineFor(inst, draw);
-            if (!overEyes)
+            const hairOverEyes = this.overEyesPipelineFor(inst, draw);
+            if (!hairOverEyes)
                 continue;
+            const overEyes = this.sidedPipeline(hairOverEyes, draw, view.args === "mirror");
             if (!bound) {
                 pass.setBindGroup(0, view.perFrame);
                 pass.setBindGroup(1, inst.mainPerInstanceBindGroup);
@@ -15512,6 +15761,10 @@ export class Engine {
             // per-frame cost a stage would otherwise still pay in full.
             if (!inst.skinMatricesDirty)
                 return;
+            // Held on a stepped effect's tick: stays dirty, so the pose that is current
+            // when the next tick comes is the one uploaded.
+            if (this.steppedHeld.has(inst.name))
+                return;
             const skinMatrices = inst.model.getSkinMatrices();
             this.device.queue.writeBuffer(inst.skinMatrixBuffer, 0, skinMatrices.buffer, skinMatrices.byteOffset, skinMatrices.byteLength);
             inst.skinMatricesDirty = false;
@@ -15626,15 +15879,18 @@ Engine.HDR_FORMAT_OVERRIDE = null;
 /** Stencil value stamped by eye draws so hair can stencil-test against it and
  *  alpha-blend a second pass over eye silhouette pixels (see-through-hair effect). */
 Engine.STENCIL_EYE_VALUE = 1;
-/** Aux MRT alongside HDR color. Two channels:
+/** Aux MRT alongside HDR color. Three channels:
  *   .r — bloom mask (1 = model geometry, 0 = ground; sampled by bloom blit to gate prefilter).
  *   .g — accumulated alpha (the channel that used to live in hdr.a before the HDR format
  *        switched to rg11b10ufloat, which has no alpha). Sampled by composite/bloom to
  *        un-premultiply color for tonemap and to produce the canvas-drawable alpha used by
  *        the premultiplied alphaMode compositor (so the page background still shows through
  *        cleared / edge-faded regions like before).
- *  rg8unorm at 4× MSAA is 8 bytes/texel — still fits Apple TBDR tile memory comfortably. */
-Engine.BLOOM_MASK_FORMAT = "rg8unorm";
+ *   .b — subsurface strength, set by a graph's `subsurface` node and 0 everywhere
+ *        else; the scattering pass reads it to find skin (passes/subsurface.ts).
+ *  rgba8unorm at 4× MSAA is 16 bytes/texel; it never leaves tile memory (storeOp
+ *  discard), only its single-sample resolve does. */
+Engine.BLOOM_MASK_FORMAT = "rgba8unorm";
 /**
  * The master switch for the id attachment. OFF — and off having been proven
  * to work, not off because it was never finished.
@@ -15786,6 +16042,24 @@ Engine.MIRROR_DIALS = {
     frame: "FRAME",
     frameColor: "FRAME_COLOR",
 };
+/**
+ * Drive the mirror from whichever effect declares one.
+ *
+ * Runs before reflectionActive is read, because the answer to "is there a
+ * mirror" is this function's output. FIRST match wins and the rest are
+ * ignored: there is one reflection target, so a second mirror is not a second
+ * mirror, it is a fight over the same plane — and a scene that quietly
+ * reflected the wrong one would be far harder to understand than one where
+ * the second mirror does nothing.
+ *
+ * Gated on `weight`, so a scheduled mirror appears and leaves with its strip
+ * and a faded-out one costs no reflection pass at all.
+ */
+/** The dials a stepped effect is read by, by name — MIRROR_DIALS' pattern. */
+Engine.STEPPED_DIALS = {
+    /** Poses per second of scene time: 12 is 24fps animation on twos, 6 on fours. */
+    fps: "FPS",
+};
 /** Opaque red — a selection is a working state, not a material property,
  *  so it reads as unmistakably distinct from anything a model's own
  *  colours could be. */

package/dist/graph/presets/pool_floor.d.ts

@@ -0,0 +1,3 @@
+import type { ShaderGraph } from "../schema";
+export declare const POOL_FLOOR_GRAPH: ShaderGraph;
+//# sourceMappingURL=pool_floor.d.ts.map

package/dist/graph/presets/pool_floor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool_floor.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/pool_floor.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,eAAO,MAAM,gBAAgB,EAAE,WA6B9B,CAAA"}

package/dist/graph/presets/pool_floor.js

@@ -0,0 +1,42 @@
+// Pool floor — the tiled bottom seen through water, with caustics on it.
+//
+// The other half of a pool, and the half that does most of the work. A water
+// surface can be tuned for a long time without the shot reading as a pool;
+// putting the focused-light web on the FLOOR is what settles it, because that
+// is the cue a photograph actually carries. It is a floor material, so it is
+// applied to the tile under the water rather than to the water itself.
+//
+// Caustics land between the albedo and the shading deliberately: they are
+// light, so they should still be dimmed by the floor's own shadow rather than
+// glowing through it. That is the difference between water-focused sun and a
+// decal.
+export const POOL_FLOOR_GRAPH = {
+    version: 1,
+    name: "Pool floor",
+    tags: ["stage", "water", "pool"],
+    nodes: [
+        { id: "tex", type: "texture" },
+        { id: "mat", type: "material_diffuse" },
+        { id: "base", type: "mix/multiply", inputs: { fac: 1.0 } },
+        { id: "caust", type: "caustics" },
+        {
+            id: "principled",
+            type: "principled",
+            inputs: { metallic: 0.0, specular_ior_level: 0.4, roughness: 0.45, spec_clamp: 10.0, sheen_weight: 0.0, sheen_tint: 0.0 },
+        },
+    ],
+    links: [
+        { from: { node: "tex", socket: "color" }, to: { node: "base", socket: "a" } },
+        { from: { node: "mat", socket: "color" }, to: { node: "base", socket: "b" } },
+        { from: { node: "base", socket: "color" }, to: { node: "caust", socket: "color" } },
+        { from: { node: "caust", socket: "color" }, to: { node: "principled", socket: "base_color" } },
+    ],
+    output: { node: "principled", socket: "color" },
+    params: [
+        { id: "tint", label: "Light tint", target: { node: "caust", socket: "tint" }, kind: "color", default: [1.0, 1.0, 1.0] },
+        { id: "scale", label: "Caustic scale", target: { node: "caust", socket: "scale" }, kind: "float", min: 0.01, max: 1, default: 0.12 },
+        { id: "speed", label: "Caustic speed", target: { node: "caust", socket: "speed" }, kind: "float", min: 0, max: 1, default: 0.15 },
+        { id: "strength", label: "Caustic strength", target: { node: "caust", socket: "strength" }, kind: "float", min: 0, max: 3, default: 0.6 },
+        { id: "fade", label: "Depth fade", target: { node: "caust", socket: "fade" }, kind: "float", min: 1, max: 200, default: 30 },
+    ],
+};

package/dist/graph/presets/water.d.ts

@@ -0,0 +1,3 @@
+import type { ShaderGraph } from "../schema";
+export declare const WATER_GRAPH: ShaderGraph;
+//# sourceMappingURL=water.d.ts.map

package/dist/graph/presets/water.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"water.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/water.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,eAAO,MAAM,WAAW,EAAE,WAgBzB,CAAA"}

package/dist/graph/presets/water.js

@@ -0,0 +1,31 @@
+// Water — a planar reflection, rippled, seen through Fresnel.
+//
+// Put a stage's water materials in a style group carrying this graph and the
+// pool starts reflecting. The reflection itself is the engine's mirror pass,
+// which this is the only graph to read; everything else here is the shaping
+// that keeps it from reading as a mirror laid flat in the floor.
+//
+// The exposed params are the ones worth a slider while judging a shot. Scale
+// and speed are the ripple; a real pool's surface is slow and broad, so both
+// defaults sit low. Tint is the water's own colour — a game rip carries that
+// in its material, and the converter hands it straight over.
+//
+// How see-through the water is belongs to the MATERIAL's alpha, not to this
+// graph, which is where every other group's coverage comes from too.
+export const WATER_GRAPH = {
+    version: 1,
+    name: "Water",
+    tags: ["water", "stage"],
+    nodes: [{ id: "water", type: "water" }],
+    links: [],
+    output: { node: "water", socket: "color" },
+    params: [
+        { id: "tint", label: "Tint", target: { node: "water", socket: "tint" }, kind: "color", default: [0.04, 0.62, 0.66] },
+        { id: "scale", label: "Ripple scale", target: { node: "water", socket: "scale" }, kind: "float", min: 0.01, max: 1, default: 0.18 },
+        { id: "speed", label: "Ripple speed", target: { node: "water", socket: "speed" }, kind: "float", min: 0, max: 1, default: 0.12 },
+        { id: "strength", label: "Ripple depth", target: { node: "water", socket: "strength" }, kind: "float", min: 0, max: 2, default: 0.7 },
+        { id: "blur", label: "Reflection blur", target: { node: "water", socket: "blur" }, kind: "float", min: 0, max: 1, default: 0.25 },
+        { id: "mirroring", label: "Mirroring", target: { node: "water", socket: "mirroring" }, kind: "float", min: 0, max: 1, default: 0.20 },
+        { id: "sparkle", label: "Sparkle", target: { node: "water", socket: "sparkle" }, kind: "float", min: 0, max: 4, default: 1.0 },
+    ],
+};

package/dist/graph/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/graph/registry.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3C,MAAM,MAAM,KAAK,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAA;AAEzD,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,KAAK,CAAA;IACX,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB,4FAA4F;IAC5F,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,yFAAyF;IACzF,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IAC9B,2FAA2F;IAC3F,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAA;IAC/C,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvC,gFAAgF;IAChF,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACtC,CAAA;AAYD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,GAAG,MAAM,CAoBhE;AAED,wFAAwF;AACxF,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAIpE;AAMD,wBAAgB,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAM1D;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKpE;AAyCD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAsuBlD,CAAA"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/graph/registry.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3C,MAAM,MAAM,KAAK,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAA;AAEzD,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,KAAK,CAAA;IACX,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB,4FAA4F;IAC5F,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,yFAAyF;IACzF,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IAC9B,2FAA2F;IAC3F,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAA;IAC/C,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvC,gFAAgF;IAChF,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACtC,CAAA;AAYD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,GAAG,MAAM,CAoBhE;AAED,wFAAwF;AACxF,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAIpE;AAMD,wBAAgB,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAM1D;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKpE;AAyCD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAivBlD,CAAA"}