reze-engine 0.61.4 → 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). */
@@ -2082,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.
@@ -2633,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)
@@ -6143,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.
     //
@@ -7210,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: {
@@ -7653,7 +7807,7 @@ export class Engine {
         depthCompare: this.depthAhead,
       },
     }
-    this.depthPrepassPipeline = this.device.createRenderPipeline({
+    this.depthPrepassPipeline = this.createModelPipeline({
       label: "opaque depth prepass",
       ...prepassDesc,
       fragment: {
@@ -7665,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: {
@@ -7681,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: {
@@ -8553,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
@@ -10403,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.
@@ -14479,6 +14639,7 @@ export class Engine {
         groupId: null,
         baseBindGroupEntries,
         castsShadow,
+        doubleSided: inst.isPlane || (mat.edgeFlag & 0x01) !== 0,
         outline,
         bounds,
         cullIndex: -1,
@@ -16063,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()
 
@@ -16261,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)
@@ -17081,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
@@ -17145,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
@@ -17268,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)
@@ -17338,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.
@@ -17375,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)
@@ -17442,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/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

package/src/graph/slots.ts

@@ -220,13 +220,13 @@ function epilogue(renderClass: RenderClass, alphaMode: AlphaMode, hasOpacity: bo
 
   var out: FSOut;
   out.color = vec4f(final_color${LIT}${BURN}, outAlpha);
-${FOG}  out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
+${FOG}  out.mask = vec4f(1.0, 1.0, _rzSubsurface, out.color.a);
 ${ID_WRITE}  return out;
 `
   }
   return `${ALBEDO}  var out: FSOut;
   out.color = vec4f(final_color${LIT}${BURN}, ${alphaBase});
-${FOG}  out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
+${FOG}  out.mask = vec4f(1.0, 1.0, _rzSubsurface, out.color.a);
 ${ID_WRITE}  return out;
 `
 }

package/src/shaders/materials/common.ts

@@ -330,17 +330,17 @@ const COMMON_VS_WGSL = /* wgsl */ `
 // Location 0: final radiance+alpha (blended into rg11b10ufloat; the HDR target
 // has no alpha channel, but the blend equation still uses the .a you write here
 // as the src-alpha factor that premultiplies rgb into the HDR target).
-// Location 1: auxiliary rg8unorm carrying
+// Location 1: auxiliary rgba8unorm carrying
 //   .r = bloom mask (1 = contributes to bloom, 0 = skip — e.g. ground).
 //   .g = accumulated canvas alpha — the channel that used to live in hdr.a
 //        before the switch to rg11b10ufloat. Sampled by composite to
 //        un-premultiply color for tonemap and to set the final drawable alpha
 //        (needed for the `premultiplied` canvas alphaMode that blends the
 //        WebGPU surface over the page background).
-// FS output at location 1 must be vec4f — the blend state references src.a, and
-// WebGPU requires the fragment output to provide an alpha component even though
-// the rg8unorm target only stores .r and .g (extra components are discarded).
-// Materials write mask = vec4f(1.0, 1.0, 0.0, color.a); ground writes
+//   .b = subsurface strength ÷ 4 — what a graph's `subsurface` node set, 0 for
+//        everything else. Read by the scattering pass (passes/subsurface.ts).
+// FS output at location 1 must be vec4f — the blend state references src.a.
+// Materials write mask = vec4f(1.0, 1.0, _rzSubsurface, color.a); ground writes
 // vec4f(0.0, 1.0, 0.0, edgeFade). With src.a coming from the 4th component and
 // src-alpha blending enabled:
 //   out.r = mask_r · src.a + dst.r · (1-src.a)   (bloom mask, weighted by alpha)

package/src/shaders/materials/nodes.ts

@@ -654,6 +654,18 @@ fn shader_to_rgb_diffuse(n: vec3f, l: vec3f, sun_rgb: vec3f, ambient_rgb: vec3f,
   return luminance_rec709_linear(shader_to_rgb_lit(n, l, sun_rgb, ambient_rgb, shadow));
 }
 
+// ─── SUBSURFACE node ────────────────────────────────────────────────
+// Marks this fragment for the screen-space scattering pass (passes/subsurface.ts)
+// and passes its colour through. The strength lands in the aux target's .b via
+// the epilogue, stored as a quarter so an 8-bit channel carries 0–4: 1 is
+// ray-mmd's skin width, 0 leaves the pixel out of the pass.
+var<private> _rzSubsurface: f32 = 0.0;
+
+fn rz_subsurface(strength: f32, color: vec3f) -> vec3f {
+  _rzSubsurface = clamp(strength, 0.0, 4.0) * 0.25;
+  return color;
+}
+
 // ─── BUMP node ──────────────────────────────────────────────────────
 // Screen-space bump from a scalar height field. Needs dFdx/dFdy which
 // WGSL provides as dpdx/dpdy.

package/src/shaders/passes/particles.ts

@@ -391,13 +391,13 @@ struct FSOut {
   // writes it; a blended one writes all four, which is what not declaring it
   // would have meant.
   @builtin(sample_mask) samples: u32,
-  // The scene's aux target: (bloom mask, coverage). Materials write it, so a
-  // particle that skipped it would punch a hole in the mask of whatever it drew
-  // over.
+  // The scene's aux target: (bloom mask, coverage, subsurface). Materials write
+  // it, so a particle that skipped it would punch a hole in the mask of whatever
+  // it drew over. A particle is never skin, so its .b is 0.
   //
-  // vec4f even though the target is rg8unorm and only .rg land: that target's
-  // blend factors reference SrcAlpha, and a fragment with no alpha channel is
-  // rejected outright — "reading alpha but it is missing from fragment output".
+  // vec4f because that target's blend factors reference SrcAlpha, and a fragment
+  // with no alpha channel is rejected outright — "reading alpha but it is
+  // missing from fragment output".
   // The material shaders declare vec4f here for the same reason.
   @location(1) mask: vec4f,
   // Declared whenever the pass carries the attachment, and padded rather than

package/src/shaders/passes/scene-contract.ts

@@ -127,7 +127,7 @@ const ADD_KEEP_ALPHA: GPUBlendState = {
   alpha: { srcFactor: "zero", dstFactor: "one", operation: "add" },
 }
 
-/** Both channels sum. rg8unorm clamps at 1, which is the saturation alpha-over
+/** Both channels sum. rgba8unorm clamps at 1, which is the saturation alpha-over
  *  would have reached anyway. */
 const ADD_BOTH: GPUBlendState = {
   color: { srcFactor: "one", dstFactor: "one", operation: "add" },

package/src/shaders/passes/subsurface.ts

@@ -0,0 +1,136 @@
+/**
+ * Screen-space subsurface scattering — ray-mmd's skin pass (PostProcessScattering.fxsub,
+ * SSSGaussBlurPS), ported constant for constant.
+ *
+ * A skin surface is not shaded by the light at its own pixel alone: light that
+ * enters a little way off comes back out here, red furthest. ray-mmd models that
+ * as a separable blur of the lit skin in screen space, one axis per pass, with a
+ * per-channel Gaussian (red widest) and a depth reject so light never crosses from
+ * a forearm onto the body behind it. The width is a length ON THE SURFACE, so it
+ * is divided by depth, and it narrows where the surface turns away from the view.
+ * Then a share of the unblurred picture is laid back over it — the "spike" that
+ * keeps pores, painted lines and the terminator from dissolving.
+ *
+ * What marks a pixel as skin is the scene pass's aux .b, written by the graph's
+ * `subsurface` node (0 everywhere else), as a quarter of its strength. The strength
+ * scales the radius, as ray-mmd's sssStrength does; 1 is ray-mmd's skin, 4 the most.
+ *
+ * One departure, and it is a routing one: ray-mmd blurs the lit colour BEFORE the
+ * albedo multiply and adds specular after. This engine resolves one HDR colour per
+ * pixel, so the blur runs over the finished colour. At this radius — a few pixels,
+ * with the spike keeping 14–20% of the original — the texture is not visibly
+ * softened; the lighting is.
+ *
+ * Two entry points share the module: X reads the HDR resolve and writes the
+ * scratch target, Y reads the scratch and writes back INTO the HDR resolve. The
+ * spike mix (lerp toward the original) is done by the Y pipeline's blend state,
+ * with the blend constant holding ray-mmd's per-channel spike: the destination IS
+ * the original, so no third copy of the frame is needed.
+ */
+
+/** ray-mmd, skin profile (index 1): profileSpikeRadArr[1].xyz × (1 − sssAmount),
+ *  with sssAmount = customA = 0.6 in Materials/Skin/material_skin.fx. */
+export const SSS_SPIKE: [number, number, number] = [0.35 * 0.4, 0.4 * 0.4, 0.5 * 0.4]
+
+export const SUBSURFACE_WGSL = /* wgsl */ `
+@group(0) @binding(0) var srcTex: texture_2d<f32>;
+@group(0) @binding(1) var maskTex: texture_2d<f32>;
+@group(0) @binding(2) var depthTex: texture_depth_multisampled_2d;
+// dofU[2] = (projA, projB): the same z-buffer inversion the composite uses.
+@group(0) @binding(3) var<uniform> dofU: array<vec4f, 3>;
+// sssU[0] = (direction.xy, radius, _); sssU[1] = (tanHalfFov·aspect, tanHalfFov, width, height).
+@group(0) @binding(4) var<uniform> sssU: array<vec4f, 2>;
+
+struct VsOut { @builtin(position) pos: vec4f };
+
+@vertex fn vs(@builtin(vertex_index) i: u32) -> VsOut {
+  let p = vec2f(f32((i << 1u) & 2u), f32(i & 2u));
+  var o: VsOut;
+  o.pos = vec4f(p * 2.0 - 1.0, 0.0, 1.0);
+  return o;
+}
+
+fn size() -> vec2i { return vec2i(sssU[1].zw); }
+
+fn texel(uv: vec2f) -> vec2i {
+  return clamp(vec2i(floor(uv * sssU[1].zw)), vec2i(0), size() - 1);
+}
+
+fn linearDepth(c: vec2i) -> f32 {
+  let z = textureLoad(depthTex, c, 0);
+  return clamp(dofU[2].y / (z - dofU[2].x), 0.05, 100000.0);
+}
+
+// View-space position of a texel centre — ray-mmd's GetViewPosition, with y up.
+fn viewPos(c: vec2i, d: f32) -> vec3f {
+  let uv = (vec2f(c) + 0.5) / sssU[1].zw;
+  let ndc = vec2f(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0);
+  return vec3f(ndc * sssU[1].xy * d, d);
+}
+
+fn skin(c: vec2i) -> f32 { return textureLoad(maskTex, c, 0).b; }
+
+fn blur(fragPos: vec4f) -> vec4f {
+  let c = vec2i(fragPos.xy);
+  let amount = skin(c) * 4.0;
+  let dir = sssU[0].xy;
+  let uv = (vec2f(c) + 0.5) / sssU[1].zw;
+  let centre = textureLoad(srcTex, c, 0);
+
+  // ray-mmd, verbatim: six offsets, and the skin variances per channel.
+  // A var, not a const: a const array cannot be indexed by the loop counter.
+  var offsets = array<f32, 6>(0.352, 0.719, 1.117, 1.579, 2.177, 3.213);
+  const profileVar = vec3f(9.6, 2.8, 2.2);
+  // mSSSSScale at the controller's default; it sets both the width and how hard
+  // a depth step rejects.
+  const SSSS_SCALE: f32 = 0.04;
+
+  let d = linearDepth(c);
+
+  // The surface's normal, rebuilt from depth (ray-mmd reads it from its G-buffer;
+  // this engine keeps none). Only its angle to the view matters: the blur narrows
+  // along an axis the surface is turning away on.
+  let s = size();
+  let cx = min(c + vec2i(1, 0), s - 1);
+  let cy = min(c + vec2i(0, 1), s - 1);
+  let P = viewPos(c, d);
+  let N = cross(viewPos(cx, linearDepth(cx)) - P, viewPos(cy, linearDepth(cy)) - P);
+  let nxz = select(vec2f(0.0, 1.0), normalize(N.xz), dot(N.xz, N.xz) > 1e-12);
+  let nyz = select(vec2f(0.0, 1.0), normalize(N.yz), dot(N.yz, N.yz) > 1e-12);
+  let scaleX = abs(dot(nxz, normalize(P.xz)));
+  let scaleY = abs(dot(nyz, normalize(P.yz)));
+  let perspectiveScale = max(dot(dir, vec2f(scaleX, scaleY)), 0.3);
+
+  let radius = 0.0055 * amount * perspectiveScale / SSSS_SCALE;
+  let step = dir * radius / d;
+
+  var weightSum = vec3f(1.0);
+  var colour = centre.rgb;
+  for (var i = 0; i < 6; i++) {
+    let o = offsets[i] / 5.5 * step;
+    for (var side = 0; side < 2; side++) {
+      let tc = texel(select(uv - o, uv + o, side == 0));
+      // Skin only: ray-mmd zeroes a non-skin pixel's depth so the depth term
+      // rejects it; the mask says the same thing directly.
+      let isSkin = select(0.0, 1.0, skin(tc) > 0.004);
+      let dd = (linearDepth(tc) - d) * 1000.0 * SSSS_SCALE;
+      let w = exp(-(offsets[i] * offsets[i] + dd * dd) / profileVar) * isSkin;
+      weightSum += w;
+      colour += w * textureLoad(srcTex, tc, 0).rgb;
+    }
+  }
+  return vec4f(colour / weightSum, centre.a);
+}
+
+@fragment fn fsX(@builtin(position) pos: vec4f) -> @location(0) vec4f {
+  // Nothing reads the scratch target off skin: the Y pass rejects those taps.
+  if (skin(vec2i(pos.xy)) <= 0.004) { return vec4f(0.0); }
+  return blur(pos);
+}
+
+@fragment fn fsY(@builtin(position) pos: vec4f) -> @location(0) vec4f {
+  // Off skin the HDR resolve must stay exactly as the scene left it.
+  if (skin(vec2i(pos.xy)) <= 0.004) { discard; }
+  return blur(pos);
+}
+`