reze-engine 0.61.3 → 0.61.5

package/src/engine.ts

@@ -112,6 +112,7 @@ import {
   EFFECT_TRAIL_BASE,
   EFFECT_TRAIL_SAMPLES,
 } from "./shaders/passes/composite"
+import { SUBSURFACE_WGSL, SSS_SPIKE } from "./shaders/passes/subsurface"
 import {
   buildParticleComputeShader,
   buildParticleRenderShader,
@@ -761,6 +762,12 @@ interface DrawCall {
   /** Material draws only: false = excluded from the shadow map (PMX cast-shadow
    *  flag off). Sheer texels are cut per fragment by the shadow pass's alpha test. */
   castsShadow?: boolean
+  /** The PMX author's double-sided flag (bit 0x01). Off means MMD draws the
+   *  material's front faces only — an inner lining authored as a flipped copy
+   *  of the outer layer is invisible from outside, which is what the author
+   *  built it around. Media planes stay double-sided: they build their own
+   *  index list and say so there. */
+  doubleSided: boolean
   /** Edge-flagged materials: interleaved inverted-hull outline drawn right after
    *  this material with the outline pipeline. Shares this call's index range;
    *  own bind group (edge uniforms + diffuse texture for the alpha test). */
@@ -896,8 +903,9 @@ interface ModelInstance {
   shadowDrawCalls: DrawCall[]
   shadowBindGroups: GPUBindGroup[]
   mainPerInstanceBindGroup: GPUBindGroup
-  /** Its own light — fill and sun — when setModelFill or setModelSun gave it
-   *  one: a 32-byte ModelLight, and the CPU copy it is written from. */
+  /** Its own light — fill, sun and options — when setModelFill, setModelSun or
+   *  setModelFlatSky gave it one: a 48-byte ModelLight, and the CPU copy it is
+   *  written from. */
   lightBuffer: GPUBuffer | null
   modelLight: Float32Array | null
   pickPerInstanceBindGroup: GPUBindGroup
@@ -2081,15 +2089,18 @@ export class Engine {
   /** 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). */
   private static readonly 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. */
-  private static readonly BLOOM_MASK_FORMAT: GPUTextureFormat = "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. */
+  private static readonly BLOOM_MASK_FORMAT: GPUTextureFormat = "rgba8unorm"
   /**
    * The master switch for the id attachment. OFF — and off having been proven
    * to work, not off because it was never finished.
@@ -2632,6 +2643,22 @@ export class Engine {
   //   composite adds bloomUp mip 0 × (color × intensity) to HDR before Filmic.
   // Matches EEVEE energy: tint/intensity applied at composite, not prefilter.
   private bloomSampler!: GPUSampler
+  // 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.
+  private sssPipelineX: GPURenderPipeline | null = null
+  private sssPipelineY: GPURenderPipeline | null = null
+  private sssScratch: GPUTexture | null = null
+  private sssBindGroupX: GPUBindGroup | null = null
+  private sssBindGroupY: GPUBindGroup | null = null
+  private sssUniformX: GPUBuffer | null = null
+  private sssUniformY: GPUBuffer | null = null
+  private readonly sssUniformData = new Float32Array(8)
+  // Model pipelines' descriptors, and the single-sided twins built from them —
+  // one per pipeline per view (see sidedPipeline).
+  private readonly pipelineDescs = new WeakMap<GPURenderPipeline, GPURenderPipelineDescriptor>()
+  private readonly singleSided = new WeakMap<GPURenderPipeline, GPURenderPipeline>()
+  private readonly singleSidedMirror = new WeakMap<GPURenderPipeline, GPURenderPipeline>()
   private bloomBlitUniformBuffer!: GPUBuffer
   private bloomUpsampleUniformBuffer!: GPUBuffer
   private readonly bloomBlitUniformData = new Float32Array(4)
@@ -6142,6 +6169,134 @@ 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. */
+  private subsurfaceInUse(): boolean {
+    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.
+   */
+  private renderSubsurface(encoder: GPUCommandEncoder): void {
+    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: string) =>
+        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: GPURenderPipeline, src: GPUTexture, uniforms: GPUBuffer, label: string) =>
+        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()
+  }
+
   private renderFieldPass(encoder: GPUCommandEncoder): void {
     // TWO PREDICATES, deliberately, and they are not interchangeable.
     //
@@ -7209,7 +7364,7 @@ export class Engine {
     multisample?: GPUMultisampleState
   }): GPURenderPipeline {
     const targets = config.fragmentTargets ?? (config.fragmentTarget ? [config.fragmentTarget] : undefined)
-    return this.device.createRenderPipeline({
+    return this.createModelPipeline({
       label: config.label,
       layout: config.layout,
       vertex: {
@@ -7433,7 +7588,7 @@ export class Engine {
 
     this.noFillBuffer = this.device.createBuffer({
       label: "model light (none)",
-      size: 32,
+      size: 48,
       usage: GPUBufferUsage.UNIFORM,
     })
 
@@ -7652,7 +7807,7 @@ export class Engine {
         depthCompare: this.depthAhead,
       },
     }
-    this.depthPrepassPipeline = this.device.createRenderPipeline({
+    this.depthPrepassPipeline = this.createModelPipeline({
       label: "opaque depth prepass",
       ...prepassDesc,
       fragment: {
@@ -7664,7 +7819,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: {
@@ -7680,7 +7835,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: {
@@ -8552,6 +8707,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
@@ -10402,6 +10561,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.
@@ -11020,8 +11181,12 @@ export class Engine {
   }
 
   /**
-   * 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
@@ -11048,15 +11213,31 @@ export class Engine {
     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. */
-  private writeModelLight(name: string, at: 0 | 4, value: Vec3 | null): boolean {
+  /**
+   * 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: string, flat: boolean): boolean {
+    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. */
+  private writeModelLight(name: string, at: 0 | 4 | 8, value: Vec3 | null): boolean {
     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
       const retired = inst.lightBuffer
@@ -11072,7 +11253,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)
@@ -14458,6 +14639,7 @@ export class Engine {
         groupId: null,
         baseBindGroupEntries,
         castsShadow,
+        doubleSided: inst.isPlane || (mat.edgeFlag & 0x01) !== 0,
         outline,
         bounds,
         cullIndex: -1,
@@ -16042,7 +16224,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()
 
@@ -16240,6 +16425,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)
@@ -17060,13 +17248,55 @@ export class Engine {
         stencilWriteMask: 0xff,
       }
     }
-    return this.device.createRenderPipelineAsync({
+    const desc: GPURenderPipelineDescriptor = {
       ...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). */
+  private createModelPipeline(desc: GPURenderPipelineDescriptor): GPURenderPipeline {
+    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.
+   */
+  private sidedPipeline(pipeline: GPURenderPipeline, draw: DrawCall, mirrored: boolean): GPURenderPipeline {
+    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
   // draws on the CAST use the SAME depth-write-on pipeline — babylon-mmd's
@@ -17124,7 +17354,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
@@ -17247,14 +17478,17 @@ export class Engine {
     inst: ModelInstance,
     view: { perFrame: GPUBindGroup; args: "camera" | "mirror"; outlines: boolean },
   ): void {
-    let bound = false
+    let bound: GPURenderPipeline | null = 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)
@@ -17317,6 +17551,7 @@ export class Engine {
         if (install?.alphaMode === "hashed") pipeline = this.solidPrepassPipeline
         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.
@@ -17354,14 +17589,17 @@ export class Engine {
     view: { perFrame: GPUBindGroup; args: "camera" | "mirror"; outlines: boolean },
   ): void {
     if (inst.isStage) return
-    let bound = false
+    let bound: GPURenderPipeline | null = 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)
@@ -17421,8 +17659,9 @@ export class Engine {
     let currentPipeline: GPURenderPipeline | null = null
     for (const draw of inst.drawCalls) {
       if (draw.type !== "opaque") continue
-      const overEyes = this.overEyesPipelineFor(inst, draw)
-      if (!overEyes) continue
+      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)

package/src/graph/presets/body.ts

@@ -19,7 +19,7 @@ export const BODY_GRAPH: ShaderGraph = {
     { 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/src/graph/presets/cloth_rough.ts

@@ -19,7 +19,7 @@ export const CLOTH_ROUGH_GRAPH: ShaderGraph = {
     { 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/src/graph/presets/cloth_smooth.ts

@@ -19,7 +19,7 @@ export const CLOTH_SMOOTH_GRAPH: ShaderGraph = {
     { 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/src/graph/presets/eye.ts

@@ -28,6 +28,17 @@ export const EYE_GRAPH: ShaderGraph = {
     },
     { 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" } },
@@ -36,6 +47,14 @@ export const EYE_GRAPH: ShaderGraph = {
     { 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/src/graph/presets/face.ts

@@ -24,7 +24,7 @@ export const FACE_GRAPH: ShaderGraph = {
 
     // ── 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/src/graph/presets/hair.ts

@@ -29,7 +29,7 @@ export const HAIR_GRAPH: ShaderGraph = {
     { 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/src/graph/presets/metal.ts

@@ -21,7 +21,7 @@ export const METAL_GRAPH: ShaderGraph = {
     { 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/src/graph/registry.ts

@@ -724,6 +724,17 @@ export const NODE_REGISTRY: Record<string, NodeSpec> = {
     outputs: { value: "float" },
     emit: () => `shader_to_rgb_diffuse(n, l, sun, amb, shadow)`,
   },
+  /**
+   * Hands this surface to the screen-space scattering pass: the colour passes
+   * through, and the pixel is blurred afterwards the way ray-mmd blurs skin —
+   * red furthest, never across a depth step. Strength scales the width; 1 is
+   * ray-mmd's skin, up to 4. It has to lie on the path to the output to take effect.
+   */
+  subsurface: {
+    inputs: { color: C([1, 1, 1], true), strength: F(1) },
+    outputs: { color: "color" },
+    emit: (a) => `rz_subsurface(${a.strength}, ${a.color})`,
+  },
 
   /**
    * The same closure as a COLOUR, which is what Blender's Shader to RGB