reze-engine 0.61.3 → 0.61.5

package/src/graph/slots.ts

@@ -139,10 +139,18 @@ ${discard}
 ${gate}
   let l = -light.lights[0].direction.xyz;
   let sun = select(light.lights[0].color.xyz * light.lights[0].color.w, modelLight.sun.rgb, modelLight.sun.w > 0.5);
+  let shadow = sampleShadow(input.worldPos, n);
   // The world: flat colour, or the HDRI's irradiance at this normal — which
   // is what makes a loaded sky actually light her instead of only backing her.
-  let amb = rzWorldAmbient(n) + modelLight.fill.rgb;
-  let shadow = sampleShadow(input.worldPos, n);
+  // The model's fill is NOT here: see the epilogue.
+  //
+  // A model given a flat sky (setModelFlatSky - the cast, for an anime look)
+  // takes the sky's AVERAGE instead: its colour and brightness from every
+  // direction alike. The directional sky shaded a face like PBR - soft
+  // realistic gradients the toon ramp never drew - where the game gives its
+  // characters one flat base light. A flat World is its own average, so a
+  // scene without an HDRI renders exactly as before.
+  let amb = select(rzWorldAmbient(n), rzWorldAmbientAvg(), modelLight.opts.x > 0.5);
   let tex_color = tex_s.rgb;
   // The normal the lamps' diffuse layer is lit by, for a principled walk to
   // compute it on the way (rzLightsDiffuseOnce). n is final from here on.
@@ -186,7 +194,13 @@ function epilogue(renderClass: RenderClass, alphaMode: AlphaMode, hasOpacity: bo
   // painted sheet — is Blender's Emission shader, which no lamp reaches; adding
   // the lamps to it turned X340's floor shadow, a white-RGB picture at a soft
   // alpha, into a glowing disc under the spot above it.
-  const LIT = takesLight ? ` + rzLightsDiffuseOnce(input.worldPos, n) * albedo` : ""
+  //
+  // The model's fill (Engine.setModelFill) rides here too, as brightness: the
+  // surface colour times the fill, on every pixel of her alike. It used to
+  // enter the graph's ambient, where an NPR ramp read it as LIGHT — sliding it
+  // moved her shadows, and under a hard step flipped whole regions at once.
+  // After the graph it lifts her evenly and leaves every shadow where it is.
+  const LIT = takesLight ? ` + (rzLightsDiffuseOnce(input.worldPos, n) + modelLight.fill.rgb) * albedo` : ""
 
   const ALBEDO = `  let albedo = tex_color;
 `
@@ -206,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

@@ -189,11 +189,12 @@ fn _rzCastShadow(wp: vec3f) -> f32 {
 // binding(9) brdfLut is declared inside NODES_WGSL (nodes.ts).
 @group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
 // The light this model takes apart from the scene's — see Engine.setModelFill
-// and Engine.setModelSun. fill is added to its ambient, zero for a model
-// nobody gave one; sun replaces the scene's sun colour while its w is set,
+// and Engine.setModelSun. fill brightens it after its graph (fill ×
+// surface colour, graph/slots.ts), zero for a model nobody gave one; sun replaces the scene's sun colour while its w is set,
 // which is how a stage keeps the daylight its game lit it by while the cast
-// keeps the key the scene set for them.
-struct ModelLight { fill: vec4f, sun: vec4f }
+// keeps the key the scene set for them. opts.x (Engine.setModelFlatSky) gives
+// it the sky's average in place of its shape - see graph/slots.ts.
+struct ModelLight { fill: vec4f, sun: vec4f, opts: vec4f }
 @group(1) @binding(1) var<uniform> modelLight: ModelLight;
 @group(2) @binding(0) var diffuseTexture: texture_2d<f32>;
 @group(2) @binding(1) var<uniform> material: MaterialUniforms;
@@ -329,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);
+}
+`

package/src/shaders/scene-light-api.ts

@@ -37,6 +37,17 @@ fn rzWorldAmbient(n: vec3f) -> vec3f {
     + ${u}.sh[8].xyz * (x * x - y * y);
   return max(c, vec3f(0.0));
 }
+
+/**
+ * The world's light averaged over every direction: its colour and brightness,
+ * with no shape. Every term but sh[0] averages to zero over the sphere (x, xy,
+ * 3z²-1 ... all do), so the average is sh[0] itself; a flat world is its own.
+ * What an anime cast takes from a sky - see ModelLight.opts.
+ */
+fn rzWorldAmbientAvg() -> vec3f {
+  if (${u}.sh[0].w < 0.5) { return ${u}.ambientColor.xyz; }
+  return max(${u}.sh[0].xyz, vec3f(0.0));
+}
 `
 
 /**