reze-engine 0.61.3 → 0.61.5

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,22 @@ 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();
         this.bloomBlitUniformData = new Float32Array(4);
         this.bloomUpsampleUniformData = new Float32Array(4);
         this.bloomMipCount = 0;
@@ -4764,6 +4781,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 +5921,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: {
@@ -5984,7 +6124,7 @@ export class Engine {
         this.device.queue.writeTexture({ texture: this.fallbackMaterialTexture }, new Uint8Array([255, 255, 255, 255]), { bytesPerRow: 4 }, [1, 1]);
         this.noFillBuffer = this.device.createBuffer({
             label: "model light (none)",
-            size: 32,
+            size: 48,
             usage: GPUBufferUsage.UNIFORM,
         });
         // Generic shared-toon ramp: lit white down to a soft cool shadow tone with
@@ -6195,7 +6335,7 @@ export class Engine {
                 depthCompare: this.depthAhead,
             },
         };
-        this.depthPrepassPipeline = this.device.createRenderPipeline({
+        this.depthPrepassPipeline = this.createModelPipeline({
             label: "opaque depth prepass",
             ...prepassDesc,
             fragment: {
@@ -6207,7 +6347,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 +6363,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 +7175,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 +8883,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.
@@ -9255,8 +9401,12 @@ export class Engine {
         this.modelInstances.set(newName, inst);
     }
     /**
-     * Light one model with more than the world gives it: a FILL, linear RGB added
-     * to its ambient everywhere on it. Null takes it away again.
+     * Light one model with more than the world gives it: a FILL, linear RGB times
+     * its surface colour, added after its material graph. Null takes it away again.
+     *
+     * After the graph, not in its ambient: an NPR ramp read an ambient fill as
+     * light, so sliding it moved her shadows and flipped whole regions across a
+     * hard step. Added after, it brightens her evenly and every shadow stays put.
      *
      * A game lights its stage and its characters apart. Aether Gazer's rooms are
      * lit by their lamps and a near-black ambient, while its characters take a
@@ -9281,16 +9431,31 @@ export class Engine {
     setModelSun(name, sun) {
         return this.writeModelLight(name, 4, sun);
     }
-    /** One half of a model's light, at `at` (0 the fill, 4 the sun) in its
-     *  ModelLight; w says whether that half is set. Both null releases the
-     *  buffer and the model takes the shared zero stand-in again. */
+    /**
+     * Light one model by the sky's AVERAGE rather than its shape: the world's
+     * colour and brightness from every direction alike. False gives it the
+     * directional sky back.
+     *
+     * For a cast under an anime look. An HDRI's sky is brighter and warmer one
+     * way than another, and taken at each normal it shades a face with soft
+     * realistic gradients that no toon ramp drew — PBR on an anime face. Aether
+     * Gazer gives its characters one flat base light instead. World strength and
+     * colour still reach her; only the shape is gone. A flat World is its own
+     * average, so without an HDRI this changes nothing.
+     */
+    setModelFlatSky(name, flat) {
+        return this.writeModelLight(name, 8, flat ? new Vec3(1, 0, 0) : null);
+    }
+    /** One part of a model's light, at `at` (0 the fill, 4 the sun, 8 its
+     *  options) in its ModelLight; w says whether that part is set. All unset
+     *  releases the buffer and the model takes the shared zero stand-in again. */
     writeModelLight(name, at, value) {
         const inst = this.modelInstances.get(name);
         if (!inst || !this.device)
             return false;
-        const light = inst.modelLight ?? new Float32Array(8);
+        const light = inst.modelLight ?? new Float32Array(12);
         light.set(value ? [value.x, value.y, value.z, 1] : [0, 0, 0, 0], at);
-        const any = light[3] > 0 || light[7] > 0;
+        const any = light[3] > 0 || light[7] > 0 || light[11] > 0;
         if (!any) {
             if (!inst.lightBuffer)
                 return true;
@@ -9307,7 +9472,7 @@ export class Engine {
         if (!inst.lightBuffer) {
             inst.lightBuffer = this.device.createBuffer({
                 label: `${name}: light`,
-                size: 32,
+                size: 48,
                 usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
             });
             inst.mainPerInstanceBindGroup = this.perInstanceBindGroup(name, inst.skinMatrixBuffer, inst.lightBuffer);
@@ -12430,6 +12595,7 @@ export class Engine {
                 groupId: null,
                 baseBindGroupEntries,
                 castsShadow,
+                doubleSided: inst.isPlane || (mat.edgeFlag & 0x01) !== 0,
                 outline,
                 bounds,
                 cullIndex: -1,
@@ -13727,7 +13893,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();
@@ -13927,6 +14096,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);
@@ -14711,11 +14883,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
@@ -14771,7 +14985,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;
@@ -14873,15 +15088,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);
@@ -14943,6 +15161,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.
@@ -14976,15 +15195,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);
@@ -15035,9 +15257,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);
@@ -15607,15 +15830,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.

package/dist/graph/presets/body.js

@@ -16,7 +16,7 @@ export const BODY_GRAPH = {
         { id: "tex_base", type: "mix/multiply", inputs: { fac: 1.0 } },
         { id: "geo", type: "geometry" },
         { id: "str", type: "shader_to_rgb_diffuse" },
-        { id: "toon", type: "ramp_constant", inputs: { pos0: 0.0, pos1: 0.2966 } },
+        { id: "toon", type: "ramp_cardinal", inputs: { pos0: 0.2466, pos1: 0.3466 } },
         { id: "shadow_tint", type: "hue_sat", inputs: { hue: 0.5, saturation: 2.0, value: 0.3499999940395355, fac: 1.0 } },
         { id: "lit_tint", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.5, value: 1.0, fac: 1.0 } },
         { id: "toon_color", type: "mix/blend" },

package/dist/graph/presets/cloth_rough.js

@@ -16,7 +16,7 @@ export const CLOTH_ROUGH_GRAPH = {
         { id: "tex_base", type: "mix/multiply", inputs: { fac: 1.0 } },
         { id: "geo", type: "geometry" },
         { id: "str", type: "shader_to_rgb_diffuse" },
-        { id: "ramp_008", type: "ramp_constant_aa", inputs: { edge: 0.2966 } },
+        { id: "ramp_008", type: "ramp_cardinal", inputs: { pos0: 0.2466, pos1: 0.3466 } },
         { id: "mix04_fac", type: "math/multiply", inputs: { b: 0.5 } },
         { id: "dark_tex", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.0, value: 0.19999998807907104, fac: 1.0 } },
         { id: "mix_004", type: "mix/blend" },

package/dist/graph/presets/cloth_smooth.js

@@ -16,7 +16,7 @@ export const CLOTH_SMOOTH_GRAPH = {
         { id: "tex_base", type: "mix/multiply", inputs: { fac: 1.0 } },
         { id: "geo", type: "geometry" },
         { id: "str", type: "shader_to_rgb_diffuse" },
-        { id: "ramp_008", type: "ramp_constant_aa", inputs: { edge: 0.2966 } },
+        { id: "ramp_008", type: "ramp_cardinal", inputs: { pos0: 0.2466, pos1: 0.3466 } },
         { id: "mix04_fac", type: "math/multiply", inputs: { b: 0.5 } },
         { id: "dark_tex", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.0, value: 0.19999998807907104, fac: 1.0 } },
         { id: "mix_004", type: "mix/blend" },

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

@@ -1 +1 @@
-{"version":3,"file":"eye.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/eye.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,eAAO,MAAM,SAAS,EAAE,WA6BvB,CAAA"}
+{"version":3,"file":"eye.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/eye.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,eAAO,MAAM,SAAS,EAAE,WAgDvB,CAAA"}

package/dist/graph/presets/eye.js

@@ -25,6 +25,17 @@ export const EYE_GRAPH = {
         },
         { id: "emission", type: "emission", inputs: { strength: 1.5 } },
         { id: "add", type: "add_shader" },
+        // The iris glow follows the key round her head: full (1.5) lit from the
+        // front, easing to 0.2 of it lit from behind - a fixed 1.5 left the eyes
+        // bright white in a backlit face. head_basis.forward · L, half-Lambert,
+        // times the sun's shadow at the eye, so an eye in a shadowed face dims too.
+        { id: "eye_hb", type: "head_basis" },
+        { id: "eye_lt", type: "light" },
+        { id: "eye_fl", type: "vector_math/dot" },
+        { id: "eye_half", type: "math/multiply_add", inputs: { b: 0.5, c: 0.5 } },
+        { id: "eye_lvl", type: "map_range", inputs: { from_min: 0.0, from_max: 1.0, to_min: 0.2, to_max: 1.0 } },
+        { id: "eye_sh", type: "math/multiply" },
+        { id: "eye_str", type: "math/multiply", inputs: { b: 1.5 } },
     ],
     links: [
         { from: { node: "tex", socket: "color" }, to: { node: "tex_base", socket: "a" } },
@@ -33,6 +44,14 @@ export const EYE_GRAPH = {
         { from: { node: "tex_base", socket: "color" }, to: { node: "emission", socket: "color" } },
         { from: { node: "principled", socket: "color" }, to: { node: "add", socket: "a" } },
         { from: { node: "emission", socket: "color" }, to: { node: "add", socket: "b" } },
+        { from: { node: "eye_hb", socket: "forward" }, to: { node: "eye_fl", socket: "a" } },
+        { from: { node: "eye_lt", socket: "direction" }, to: { node: "eye_fl", socket: "b" } },
+        { from: { node: "eye_fl", socket: "value" }, to: { node: "eye_half", socket: "a" } },
+        { from: { node: "eye_half", socket: "value" }, to: { node: "eye_sh", socket: "a" } },
+        { from: { node: "eye_lt", socket: "shadow" }, to: { node: "eye_sh", socket: "b" } },
+        { from: { node: "eye_sh", socket: "value" }, to: { node: "eye_lvl", socket: "value" } },
+        { from: { node: "eye_lvl", socket: "value" }, to: { node: "eye_str", socket: "a" } },
+        { from: { node: "eye_str", socket: "value" }, to: { node: "emission", socket: "strength" } },
     ],
     output: { node: "add", socket: "color" },
 };

package/dist/graph/presets/face.js

@@ -20,7 +20,7 @@ export const FACE_GRAPH = {
         { id: "geo", type: "geometry" },
         // ── toon shading ──
         { id: "str", type: "shader_to_rgb_diffuse" },
-        { id: "toon", type: "ramp_constant_aa", inputs: { edge: 0.2966 } },
+        { id: "toon", type: "ramp_cardinal", inputs: { pos0: 0.2466, pos1: 0.3466 } },
         { id: "shadow_tint", type: "hue_sat", inputs: { hue: 0.46000000834465027, saturation: 2.0, value: 0.3499999940395355, fac: 1.0 } },
         { id: "lit_tint", type: "hue_sat", inputs: { hue: 0.46000000834465027, saturation: 1.600000023841858, value: 1.5, fac: 1.0 } },
         { id: "toon_color", type: "mix/blend" },

package/dist/graph/presets/hair.js

@@ -26,7 +26,7 @@ export const HAIR_GRAPH = {
         { id: "hs_002", type: "hue_sat", inputs: { hue: 0.48, saturation: 1.2, value: 0.7, fac: 1.0 } },
         { id: "hs_001", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.5, value: 1.0, fac: 1.0 } },
         { id: "str", type: "shader_to_rgb_diffuse" },
-        { id: "ramp_008", type: "ramp_constant", inputs: { pos0: 0.0, color0: [0, 0, 0, 1], pos1: 0.2966, color1: [1, 1, 1, 1] } },
+        { id: "ramp_008", type: "ramp_cardinal", inputs: { pos0: 0.2466, color0: [0, 0, 0, 1], pos1: 0.3466, color1: [1, 1, 1, 1] } },
         { id: "mix_004", type: "mix/blend" },
         { id: "bc", type: "bright_contrast", inputs: { bright: 0.1, contrast: 0.2 } },
         { id: "sep_n", type: "separate_xyz" },

package/dist/graph/presets/metal.js

@@ -18,7 +18,7 @@ export const METAL_GRAPH = {
         { id: "geo", type: "geometry" },
         { id: "tex_tint", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.0, value: 0.800000011920929, fac: 1.0 } },
         { id: "str", type: "shader_to_rgb_diffuse" },
-        { id: "ramp_008", type: "ramp_constant_aa", inputs: { edge: 0.2966 } },
+        { id: "ramp_008", type: "ramp_cardinal", inputs: { pos0: 0.2466, pos1: 0.3466 } },
         { id: "mix04_fac", type: "math/multiply", inputs: { b: 0.5 } },
         { id: "dark_tex", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.0, value: 0.19999998807907104, fac: 1.0 } },
         { id: "mix_004", type: "mix/blend" },

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"}