reze-engine 0.50.7 → 0.50.8

package/src/shaders/materials/common.ts

@@ -69,7 +69,16 @@ struct MaterialUniforms {
   // just empty. f32 because the buffer is written as floats; the shader casts.
   materialId: f32,
   objectId: f32,
-  _pad2: f32,
+  // How much of this material is still THERE: 1 whole, 0 gone. Rides the last
+  // of the padding this struct already carried, for the same reason the ids do
+  // — the buffer's size and layout are untouched, so the indirect-draw path and
+  // every existing pipeline keep working, and a material that never dissolves
+  // pays one float it was already paying.
+  //
+  // A material morph rebuilds this block from its base copy, which is why the
+  // engine writes the value into that copy as well as into the live buffer: a
+  // face morphing while she dissolves must not come back solid for those frames.
+  dissolve: f32,
 };
 
 struct VertexOutput {
@@ -267,6 +276,82 @@ export function commonFsOutWgsl(): string {
   return `\n\n${sceneFsOutWgsl()}\n`;
 }
 
+// ─── Dissolve ───────────────────────────────────────────────────────
+/**
+ * Whether a fragment survives the dissolve, and how close it is to the front.
+ *
+ * ONE implementation, shared by the colour pass and the depth prepass, and that
+ * is the whole reason it lives here rather than in either of them. The prepass
+ * claims depth for fragments the colour pass will shade; if the two disagreed
+ * about which flakes are gone, the model would keep writing depth where it no
+ * longer draws — holes that occlude the floor behind her and read as sky.
+ *
+ * OBJECT SPACE, off the bind-pose position, for the same reason the procedural
+ * texture nodes use restPos: a world-space field would let the flakes swim
+ * through her as she moves, and a screen-space one would leave them hanging in
+ * the air while she turns. In object space the pattern is painted ON the
+ * surface — the flakes stay where they were on her arm as the arm moves.
+ *
+ * The hash is value noise rather than a bare hash so the flakes come apart in
+ * clumps of a few millimetres rather than as single-pixel snow, which at any
+ * distance is just a fade.
+ */
+export const DISSOLVE_WGSL = /* wgsl */ `
+/** Flake size, in object-space units — MMD's are roughly centimetres. */
+const RZ_DISSOLVE_GRAIN: f32 = 0.55;
+/** How wide the glowing front is, in threshold units. */
+const RZ_DISSOLVE_EDGE: f32 = 0.16;
+/** What the front burns with. Emission, added after lighting and after the
+ *  graph — a colour that ramps or takes a shadow reads as paint, not as heat.
+ *  Above 1 on purpose: it is meant to reach the bloom pyramid. */
+const RZ_BURN_COLOR: vec3f = vec3f(0.55, 1.85, 2.60);
+
+fn rz_dissolve_hash(p: vec3f) -> f32 {
+  let q = fract(p * 0.3183099 + vec3f(0.1, 0.2, 0.3));
+  let r = q * 17.0 * (q + 34.0);
+  return fract(r.x * r.y * r.z);
+}
+
+/** Value noise over that hash — smooth within a flake, uncorrelated between. */
+fn rz_dissolve_field(p: vec3f) -> f32 {
+  let i = floor(p);
+  let f = fract(p);
+  let u = f * f * (3.0 - 2.0 * f);
+  let c000 = rz_dissolve_hash(i);
+  let c100 = rz_dissolve_hash(i + vec3f(1.0, 0.0, 0.0));
+  let c010 = rz_dissolve_hash(i + vec3f(0.0, 1.0, 0.0));
+  let c110 = rz_dissolve_hash(i + vec3f(1.0, 1.0, 0.0));
+  let c001 = rz_dissolve_hash(i + vec3f(0.0, 0.0, 1.0));
+  let c101 = rz_dissolve_hash(i + vec3f(1.0, 0.0, 1.0));
+  let c011 = rz_dissolve_hash(i + vec3f(0.0, 1.0, 1.0));
+  let c111 = rz_dissolve_hash(i + vec3f(1.0, 1.0, 1.0));
+  let x00 = mix(c000, c100, u.x);
+  let x10 = mix(c010, c110, u.x);
+  let x01 = mix(c001, c101, u.x);
+  let x11 = mix(c011, c111, u.x);
+  return mix(mix(x00, x10, u.y), mix(x01, x11, u.y), u.z);
+}
+
+/**
+ * The threshold this fragment is measured against.
+ *
+ * Tilted by HEIGHT so the dissolve sweeps up the body instead of arriving
+ * everywhere at once: a body that comes apart from the feet reads as something
+ * happening TO her, and one that fades uniformly reads as an opacity slider.
+ * The tilt is gentle — a third of the range — so the noise still decides which
+ * flake goes when, and the sweep only decides roughly where it is.
+ *
+ * FEET FIRST, head last: the face is the last thing to go and the first thing
+ * back, which is the order every disappearance in film is cut in. Object space
+ * puts the floor at y = 0 on any PMX, so the tilt needs no rig measurement.
+ */
+fn rz_dissolve_threshold(restPos: vec3f) -> f32 {
+  let n = rz_dissolve_field(restPos / RZ_DISSOLVE_GRAIN);
+  let low = 1.0 - clamp(restPos.y * 0.045, 0.0, 1.0);
+  return clamp(n * 0.68 + low * 0.32, 0.0, 1.0);
+}
+`
+
 // ─── Convenience: full shared prelude ───────────────────────────────
 // Material files compose this as `${NODES_WGSL}${COMMON_MATERIAL_PRELUDE_WGSL}` to
 // pull in everything structural. Each material then adds its own constants + fs().

package/src/shaders/passes/depth-prepass.ts

@@ -27,14 +27,25 @@
 // attachment, and that answer does not exist at import time. The constant could
 // not have taken the outputs at all, which is most of why it did not have them.
 
+import { DISSOLVE_WGSL } from "../materials/common"
 import { sceneFsOutWgsl, sceneIdPadWgsl } from "./scene-contract"
 
 export function transparentDepthPrepassWgsl(): string {
   return /* wgsl */ `
+${DISSOLVE_WGSL}
 struct CameraUniforms { view: mat4x4f, projection: mat4x4f, viewPos: vec3f, _p: f32, };
+// The head of the material block, plus the one field at its tail. The middle is
+// skipped rather than named: this pass shades nothing, and every field it
+// declares is a field that must stay in step with the real struct for no gain.
+// The padding is explicit so the offsets are checkable by eye — vec4 at 16 and
+// 32, vec3 at 48, and dissolve last at 60.
 struct MaterialUniforms {
   diffuseColor: vec3f,
   alpha: f32,
+  _skip0: vec4f,
+  _skip1: vec4f,
+  _skip2: vec3f,
+  dissolve: f32,
 };
 
 @group(0) @binding(0) var<uniform> camera: CameraUniforms;
@@ -48,6 +59,9 @@ struct VSOut {
   // must land on exactly the depths this wrote.
   @builtin(position) @invariant position: vec4f,
   @location(0) uv: vec2f,
+  // The bind-pose position, carried for one reason: the dissolve test below has
+  // to be the SAME test the colour pass runs, and that one is in object space.
+  @location(1) restPos: vec3f,
 };
 
 @vertex fn vs(
@@ -68,6 +82,7 @@ struct VSOut {
   var o: VSOut;
   o.position = camera.projection * camera.view * vec4f(skinned.xyz, 1.0);
   o.uv = uv;
+  o.restPos = position;
   return o;
 }
 
@@ -89,6 +104,12 @@ override CUTOFF: f32 = 0.5;
 @fragment fn fs(in: VSOut) -> PrepassOut {
   let a = material.alpha * textureSample(diffuseTexture, diffuseSampler, in.uv).a;
   if (a < CUTOFF) { discard; }
+  // The dissolve, run identically to the colour pass — shared code, not a
+  // second copy of the same idea. A prepass that kept claiming depth for flakes
+  // the colour pass throws away would punch holes that occlude the floor behind
+  // her: you would see sky through her, which is the failure this line exists
+  // to prevent.
+  if (material.dissolve < 0.9995 && rz_dissolve_threshold(in.restPos) > material.dissolve) { discard; }
   var out: PrepassOut;
   out.color = vec4f(0.0);
   out.mask = vec4f(0.0);

package/src/shaders/passes/shadow.ts

@@ -1,3 +1,5 @@
+import { DISSOLVE_WGSL } from "../materials/common"
+
 // Shadow map depth pass. Skinned VS + alpha-test FS (depth-only attachment, no
 // color targets): texels where diffuse-texture alpha × material alpha fall below
 // the cutoff are discarded, so lace casts lace-shaped shadows and a true veil
@@ -6,17 +8,29 @@
 // bindings 0/1 are declared here (a layout may carry bindings a shader ignores).
 
 export const SHADOW_DEPTH_SHADER_WGSL = /* wgsl */ `
+${DISSOLVE_WGSL}
 struct LightVP { viewProj: mat4x4f, };
 @group(0) @binding(0) var<uniform> lp: LightVP;
 @group(0) @binding(1) var<storage, read> skinMats: array<mat4x4f>;
 @group(0) @binding(2) var texSampler: sampler;
 @group(1) @binding(0) var diffuseTexture: texture_2d<f32>;
-struct MaterialDiffuse { diffuse: vec4f, };
+// The head of the material block and the one field at its tail — the same
+// reach the depth prepass takes, and for the same reason: a shadow cast by a
+// body that is no longer drawn is the tell that the vanishing is a trick.
+struct MaterialDiffuse {
+  diffuse: vec4f,
+  _skip0: vec4f,
+  _skip1: vec4f,
+  _skip2: vec3f,
+  dissolve: f32,
+};
 @group(1) @binding(1) var<uniform> material: MaterialDiffuse;
 
 struct VSOut {
   @builtin(position) position: vec4f,
   @location(0) uv: vec2f,
+  /** Bind-pose position, for the dissolve test — object space, as everywhere. */
+  @location(1) restPos: vec3f,
 };
 
 @vertex fn vs(@location(0) position: vec3f, @location(1) normal: vec3f, @location(2) uv: vec2f,
@@ -30,11 +44,16 @@ struct VSOut {
   var out: VSOut;
   out.position = lp.viewProj * vec4f(sp.xyz, 1.0);
   out.uv = uv;
+  out.restPos = position;
   return out;
 }
 
 @fragment fn fs(in: VSOut) {
   let alpha = textureSample(diffuseTexture, texSampler, in.uv).a * material.diffuse.a;
   if (alpha < 0.5) { discard; }
+  // The dissolve, run as the colour pass runs it. A flake that is gone stops
+  // casting: without this she leaves a whole shadow standing on the floor while
+  // her body is in the air.
+  if (material.dissolve < 0.9995 && rz_dissolve_threshold(in.restPos) > material.dissolve) { discard; }
 }
 `