reze-engine 0.50.10 → 0.50.11

package/dist/graph/slots.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/graph/slots.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AA4K5D;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,EACd,oBAAoB,EAAE,OAAO,GAC5B,MAAM,CAgBR"}
+{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/graph/slots.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAkL5D;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,EACd,oBAAoB,EAAE,OAAO,GAC5B,MAAM,CAgBR"}

package/dist/graph/slots.js

@@ -105,7 +105,13 @@ ${discard}
   if (material.dissolve < 0.9995) {
     let rz_t = rz_dissolve_threshold(input.restPos);
     if (rz_t > material.dissolve) { discard; }
-    rz_burn = smoothstep(material.dissolve - RZ_DISSOLVE_EDGE, material.dissolve, rz_t);
+    // Put OUT as the last of her goes. Near zero the front is wider than what
+    // is left of the surface, so every surviving fragment sits inside it and
+    // the final scraps are pure glow — a body that ends as a handful of white
+    // specks rather than as a body. The taper costs nothing while she is mostly
+    // there, because it is already 1 by a fifth of the way in.
+    rz_burn = smoothstep(material.dissolve - RZ_DISSOLVE_EDGE, material.dissolve, rz_t)
+            * smoothstep(0.0, 0.22, material.dissolve);
   }
 
   var n = safe_normal(input.normal);

package/dist/shaders/materials/common.d.ts

@@ -19,6 +19,6 @@ export declare function commonFsOutWgsl(): string;
  * clumps of a few millimetres rather than as single-pixel snow, which at any
  * distance is just a fade.
  */
-export declare const DISSOLVE_WGSL = "\n/** Clump size, in object-space units \u2014 MMD's are roughly centimetres. */\nconst RZ_DISSOLVE_GRAIN: f32 = 0.42;\n/** Grit cell, as a fraction of a clump. See rz_dissolve_threshold: this is what\n *  keeps a material SMALLER than a clump from having one threshold for all of\n *  it. Seven millimetres or so on a normal model. */\nconst RZ_DISSOLVE_GRIT: f32 = 0.16;\n/** How wide the glowing front is, in threshold units. Thin: the front is a\n *  rim, and a wide one lights whole limbs at once. */\nconst RZ_DISSOLVE_EDGE: f32 = 0.11;\n/** What the front burns with. Emission, added after lighting and after the\n *  graph \u2014 a colour that ramps or takes a shadow reads as paint, not as heat.\n *  Above 1 on purpose: it is meant to reach the bloom pyramid. Blue-violet,\n *  the same light the motes leaving her are drawn and lit with. */\nconst RZ_BURN_COLOR: vec3f = vec3f(0.45, 0.62, 2.40);\n\nfn rz_dissolve_hash(p: vec3f) -> f32 {\n  let q = fract(p * 0.3183099 + vec3f(0.1, 0.2, 0.3));\n  let r = q * 17.0 * (q + 34.0);\n  return fract(r.x * r.y * r.z);\n}\n\n/** Value noise over that hash \u2014 smooth within a flake, uncorrelated between. */\nfn rz_dissolve_field(p: vec3f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  let c000 = rz_dissolve_hash(i);\n  let c100 = rz_dissolve_hash(i + vec3f(1.0, 0.0, 0.0));\n  let c010 = rz_dissolve_hash(i + vec3f(0.0, 1.0, 0.0));\n  let c110 = rz_dissolve_hash(i + vec3f(1.0, 1.0, 0.0));\n  let c001 = rz_dissolve_hash(i + vec3f(0.0, 0.0, 1.0));\n  let c101 = rz_dissolve_hash(i + vec3f(1.0, 0.0, 1.0));\n  let c011 = rz_dissolve_hash(i + vec3f(0.0, 1.0, 1.0));\n  let c111 = rz_dissolve_hash(i + vec3f(1.0, 1.0, 1.0));\n  let x00 = mix(c000, c100, u.x);\n  let x10 = mix(c010, c110, u.x);\n  let x01 = mix(c001, c101, u.x);\n  let x11 = mix(c011, c111, u.x);\n  return mix(mix(x00, x10, u.y), mix(x01, x11, u.y), u.z);\n}\n\n/**\n * The threshold this fragment is measured against.\n *\n * NOISE ALONE, so the whole body comes apart at once \u2014 a hand, a shoulder and\n * an ankle all thinning together rather than a line travelling up her. It was\n * tilted by height at first, on the argument that a sweep reads as something\n * happening TO her; what it actually reads as is a wipe, and a wipe has a\n * direction, an edge and a speed the rest of the effect knows nothing about.\n * Everywhere at once is also the honest match for what leaves: the motes are\n * shed from every limb in the same breath.\n *\n * TWO SCALES, and the second one is not decoration \u2014 it is the fix for a real\n * failure. Clumps alone meant every fragment of a material SMALLER than one\n * cell shared a single threshold: an eye highlight, a brow, a button, a hair\n * clip. All of it sat inside the glowing front at once, so the piece flashed\n * white as a whole and then popped out of existence \u2014 the two things a\n * disintegration must never do. The grit is a plain per-cell hash at a fraction\n * of the clump, so a part a few millimetres across still comes apart in pieces.\n *\n * Weighted toward the clumps, because they are the LOOK: flakes a centimetre\n * across, in an order fixed to the surface, so the same piece of sleeve goes at\n * the same moment every time she leaves. The grit only breaks ties.\n */\nfn rz_dissolve_threshold(restPos: vec3f) -> f32 {\n  let clump = rz_dissolve_field(restPos / RZ_DISSOLVE_GRAIN);\n  let grit = rz_dissolve_hash(floor(restPos / (RZ_DISSOLVE_GRAIN * RZ_DISSOLVE_GRIT)));\n  return clamp(clump * 0.7 + grit * 0.3, 0.0, 1.0);\n}\n";
+export declare const DISSOLVE_WGSL = "\n/** Clump size, in object-space units \u2014 MMD's are roughly centimetres. */\nconst RZ_DISSOLVE_GRAIN: f32 = 0.42;\n/** How much the clumps pull a fragment off its own grit value \u2014 the whole of\n *  the LOOK, and none of the rate. See rz_dissolve_threshold. */\nconst RZ_DISSOLVE_CLUMP: f32 = 0.6;\n/** Grit cell, as a fraction of a clump. See rz_dissolve_threshold: this is what\n *  keeps a material SMALLER than a clump from having one threshold for all of\n *  it, and it has to be smaller than the SMALLEST material a model carries \u2014\n *  an eye highlight, a button, a buckle \u2014 not merely small. Two and a half\n *  millimetres on a normal model, which is under all of them. */\nconst RZ_DISSOLVE_GRIT: f32 = 0.06;\n/** How wide the glowing front is, in threshold units. Thin: the front is a\n *  rim, and a wide one lights whole limbs at once. */\nconst RZ_DISSOLVE_EDGE: f32 = 0.11;\n/** What the front burns with. Emission, added after lighting and after the\n *  graph \u2014 a colour that ramps or takes a shadow reads as paint, not as heat.\n *  Above 1 on purpose: it is meant to reach the bloom pyramid. Blue-violet,\n *  the same light the motes leaving her are drawn and lit with. */\nconst RZ_BURN_COLOR: vec3f = vec3f(0.45, 0.62, 2.40);\n\nfn rz_dissolve_hash(p: vec3f) -> f32 {\n  // INTEGER, for exactly the reason _hash33 in nodes.ts is, and its comment\n  // says it: above 24 bits an f32 loses the low ones. The float hash this\n  // replaces multiplied three terms into the hundreds of millions and took\n  // fract() of the product \u2014 which past 2^24 is not noise, it is a quantised\n  // staircase, and wherever that staircase landed on zero the threshold was\n  // zero. A surface whose threshold is zero never crosses it: it stays behind\n  // while the rest of her leaves, and it sits inside the burning front the\n  // whole time she is gone. Those were the white pieces that would not go.\n  //\n  // Floored first, unlike _hash33: vec3i() truncates toward zero, so -0.5 and\n  // +0.5 are the same cell, and half this model is at negative x.\n  var h = vec3u(vec3i(floor(p)) + vec3i(32768));\n  h = h * vec3u(1664525u, 1013904223u, 2654435761u);\n  h = (h.yzx ^ h) * vec3u(2246822519u, 3266489917u, 668265263u);\n  h = h ^ (h >> vec3u(16u));\n  return f32((h.x ^ h.y ^ h.z) & 16777215u) * (1.0 / 16777216.0);\n}\n\n/** Value noise over that hash \u2014 smooth within a flake, uncorrelated between. */\nfn rz_dissolve_field(p: vec3f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  let c000 = rz_dissolve_hash(i);\n  let c100 = rz_dissolve_hash(i + vec3f(1.0, 0.0, 0.0));\n  let c010 = rz_dissolve_hash(i + vec3f(0.0, 1.0, 0.0));\n  let c110 = rz_dissolve_hash(i + vec3f(1.0, 1.0, 0.0));\n  let c001 = rz_dissolve_hash(i + vec3f(0.0, 0.0, 1.0));\n  let c101 = rz_dissolve_hash(i + vec3f(1.0, 0.0, 1.0));\n  let c011 = rz_dissolve_hash(i + vec3f(0.0, 1.0, 1.0));\n  let c111 = rz_dissolve_hash(i + vec3f(1.0, 1.0, 1.0));\n  let x00 = mix(c000, c100, u.x);\n  let x10 = mix(c010, c110, u.x);\n  let x01 = mix(c001, c101, u.x);\n  let x11 = mix(c011, c111, u.x);\n  return mix(mix(x00, x10, u.y), mix(x01, x11, u.y), u.z);\n}\n\n/**\n * The threshold this fragment is measured against.\n *\n * NOISE ALONE, so the whole body comes apart at once \u2014 a hand, a shoulder and\n * an ankle all thinning together rather than a line travelling up her. It was\n * tilted by height at first, on the argument that a sweep reads as something\n * happening TO her; what it actually reads as is a wipe, and a wipe has a\n * direction, an edge and a speed the rest of the effect knows nothing about.\n * Everywhere at once is also the honest match for what leaves: the motes are\n * shed from every limb in the same breath.\n *\n * TWO SCALES. Clumps alone meant every fragment of a material SMALLER than one\n * cell shared a single threshold: an eye highlight, a brow, a button, a hair\n * clip. All of it sat inside the glowing front at once, so the piece flashed\n * white as a whole and then popped \u2014 the two things a disintegration must never\n * do. The grit is a per-cell hash at a fraction of the clump, so a part a few\n * millimetres across still comes apart in pieces.\n *\n * THE GRIT IS THE BASE, though, and the clumps only push a fragment off it.\n * That ordering is what makes the dissolve smooth, and it is not obvious: the\n * two used to be WEIGHTED AND ADDED, and a sum is not uniformly distributed\n * however uniform each half is. It piles up in the middle, so most of the\n * surface had a threshold near a half \u2014 all of it went as the dissolve swept\n * through the middle, and what remained was the thin tail near zero. That tail\n * was the second stage everyone could see: a body that mostly vanished, then a\n * scatter of glowing scraps, then nothing.\n *\n * WRAPPED, not added. Offsetting a uniform value and taking fract() leaves it\n * EXACTLY uniform, where scaling a sum back into range only flattens the middle\n * \u2014 measured over four hundred thousand samples, the sum removed 12% of her per\n * step at the halfway mark and 0.1% at each end (a 110x swing), the scaled sum\n * still swung 89x, and the wrap is flat: 5.0% per step from the first flake to\n * the last, a ratio of 1.0.\n *\n * That flatness IS the smoothness. An uneven rate is what produced the two\n * stages you could see \u2014 a body that mostly vanished at once, then a scatter of\n * scraps that took as long again to follow.\n *\n * The clumping survives the wrap: neighbouring fragments share a clump value,\n * so the offset moves them together. What wraps past 1 comes back at 0 and goes\n * at the other end instead, which costs a little speckle in a region and buys\n * an even rate everywhere.\n */\nfn rz_dissolve_threshold(restPos: vec3f) -> f32 {\n  let grit = rz_dissolve_hash(floor(restPos / (RZ_DISSOLVE_GRAIN * RZ_DISSOLVE_GRIT)));\n  let clump = rz_dissolve_field(restPos / RZ_DISSOLVE_GRAIN) - 0.5;\n  return fract(grit + clump * RZ_DISSOLVE_CLUMP);\n}\n";
 export declare const COMMON_MATERIAL_PRELUDE_WGSL: string;
 //# sourceMappingURL=common.d.ts.map

package/dist/shaders/materials/common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/shaders/materials/common.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,oBAAoB,QAuHhC,CAAC;AAgIF,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAGD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,mgHAsEzB,CAAA;AAQD,eAAO,MAAM,4BAA4B,QAC0D,CAAA"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/shaders/materials/common.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,oBAAoB,QAuHhC,CAAC;AAgIF,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAGD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,k8LA4GzB,CAAA;AAQD,eAAO,MAAM,4BAA4B,QAC0D,CAAA"}

package/dist/shaders/materials/common.js

@@ -288,10 +288,15 @@ export function commonFsOutWgsl() {
 export const DISSOLVE_WGSL = /* wgsl */ `
 /** Clump size, in object-space units — MMD's are roughly centimetres. */
 const RZ_DISSOLVE_GRAIN: f32 = 0.42;
+/** How much the clumps pull a fragment off its own grit value — the whole of
+ *  the LOOK, and none of the rate. See rz_dissolve_threshold. */
+const RZ_DISSOLVE_CLUMP: f32 = 0.6;
 /** Grit cell, as a fraction of a clump. See rz_dissolve_threshold: this is what
  *  keeps a material SMALLER than a clump from having one threshold for all of
- *  it. Seven millimetres or so on a normal model. */
-const RZ_DISSOLVE_GRIT: f32 = 0.16;
+ *  it, and it has to be smaller than the SMALLEST material a model carries —
+ *  an eye highlight, a button, a buckle — not merely small. Two and a half
+ *  millimetres on a normal model, which is under all of them. */
+const RZ_DISSOLVE_GRIT: f32 = 0.06;
 /** How wide the glowing front is, in threshold units. Thin: the front is a
  *  rim, and a wide one lights whole limbs at once. */
 const RZ_DISSOLVE_EDGE: f32 = 0.11;
@@ -302,9 +307,22 @@ const RZ_DISSOLVE_EDGE: f32 = 0.11;
 const RZ_BURN_COLOR: vec3f = vec3f(0.45, 0.62, 2.40);
 
 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);
+  // INTEGER, for exactly the reason _hash33 in nodes.ts is, and its comment
+  // says it: above 24 bits an f32 loses the low ones. The float hash this
+  // replaces multiplied three terms into the hundreds of millions and took
+  // fract() of the product — which past 2^24 is not noise, it is a quantised
+  // staircase, and wherever that staircase landed on zero the threshold was
+  // zero. A surface whose threshold is zero never crosses it: it stays behind
+  // while the rest of her leaves, and it sits inside the burning front the
+  // whole time she is gone. Those were the white pieces that would not go.
+  //
+  // Floored first, unlike _hash33: vec3i() truncates toward zero, so -0.5 and
+  // +0.5 are the same cell, and half this model is at negative x.
+  var h = vec3u(vec3i(floor(p)) + vec3i(32768));
+  h = h * vec3u(1664525u, 1013904223u, 2654435761u);
+  h = (h.yzx ^ h) * vec3u(2246822519u, 3266489917u, 668265263u);
+  h = h ^ (h >> vec3u(16u));
+  return f32((h.x ^ h.y ^ h.z) & 16777215u) * (1.0 / 16777216.0);
 }
 
 /** Value noise over that hash — smooth within a flake, uncorrelated between. */
@@ -338,22 +356,42 @@ fn rz_dissolve_field(p: vec3f) -> f32 {
  * Everywhere at once is also the honest match for what leaves: the motes are
  * shed from every limb in the same breath.
  *
- * TWO SCALES, and the second one is not decoration — it is the fix for a real
- * failure. Clumps alone meant every fragment of a material SMALLER than one
+ * TWO SCALES. Clumps alone meant every fragment of a material SMALLER than one
  * cell shared a single threshold: an eye highlight, a brow, a button, a hair
  * clip. All of it sat inside the glowing front at once, so the piece flashed
- * white as a whole and then popped out of existence — the two things a
- * disintegration must never do. The grit is a plain per-cell hash at a fraction
- * of the clump, so a part a few millimetres across still comes apart in pieces.
+ * white as a whole and then popped — the two things a disintegration must never
+ * do. The grit is a per-cell hash at a fraction of the clump, so a part a few
+ * millimetres across still comes apart in pieces.
+ *
+ * THE GRIT IS THE BASE, though, and the clumps only push a fragment off it.
+ * That ordering is what makes the dissolve smooth, and it is not obvious: the
+ * two used to be WEIGHTED AND ADDED, and a sum is not uniformly distributed
+ * however uniform each half is. It piles up in the middle, so most of the
+ * surface had a threshold near a half — all of it went as the dissolve swept
+ * through the middle, and what remained was the thin tail near zero. That tail
+ * was the second stage everyone could see: a body that mostly vanished, then a
+ * scatter of glowing scraps, then nothing.
+ *
+ * WRAPPED, not added. Offsetting a uniform value and taking fract() leaves it
+ * EXACTLY uniform, where scaling a sum back into range only flattens the middle
+ * — measured over four hundred thousand samples, the sum removed 12% of her per
+ * step at the halfway mark and 0.1% at each end (a 110x swing), the scaled sum
+ * still swung 89x, and the wrap is flat: 5.0% per step from the first flake to
+ * the last, a ratio of 1.0.
+ *
+ * That flatness IS the smoothness. An uneven rate is what produced the two
+ * stages you could see — a body that mostly vanished at once, then a scatter of
+ * scraps that took as long again to follow.
  *
- * Weighted toward the clumps, because they are the LOOK: flakes a centimetre
- * across, in an order fixed to the surface, so the same piece of sleeve goes at
- * the same moment every time she leaves. The grit only breaks ties.
+ * The clumping survives the wrap: neighbouring fragments share a clump value,
+ * so the offset moves them together. What wraps past 1 comes back at 0 and goes
+ * at the other end instead, which costs a little speckle in a region and buys
+ * an even rate everywhere.
  */
 fn rz_dissolve_threshold(restPos: vec3f) -> f32 {
-  let clump = rz_dissolve_field(restPos / RZ_DISSOLVE_GRAIN);
   let grit = rz_dissolve_hash(floor(restPos / (RZ_DISSOLVE_GRAIN * RZ_DISSOLVE_GRIT)));
-  return clamp(clump * 0.7 + grit * 0.3, 0.0, 1.0);
+  let clump = rz_dissolve_field(restPos / RZ_DISSOLVE_GRAIN) - 0.5;
+  return fract(grit + clump * RZ_DISSOLVE_CLUMP);
 }
 `;
 // ─── Convenience: full shared prelude ───────────────────────────────

package/dist/shaders/passes/shadow.d.ts

@@ -1,2 +1,2 @@
-export declare const SHADOW_DEPTH_SHADER_WGSL = "\n\n/** Clump size, in object-space units \u2014 MMD's are roughly centimetres. */\nconst RZ_DISSOLVE_GRAIN: f32 = 0.42;\n/** Grit cell, as a fraction of a clump. See rz_dissolve_threshold: this is what\n *  keeps a material SMALLER than a clump from having one threshold for all of\n *  it. Seven millimetres or so on a normal model. */\nconst RZ_DISSOLVE_GRIT: f32 = 0.16;\n/** How wide the glowing front is, in threshold units. Thin: the front is a\n *  rim, and a wide one lights whole limbs at once. */\nconst RZ_DISSOLVE_EDGE: f32 = 0.11;\n/** What the front burns with. Emission, added after lighting and after the\n *  graph \u2014 a colour that ramps or takes a shadow reads as paint, not as heat.\n *  Above 1 on purpose: it is meant to reach the bloom pyramid. Blue-violet,\n *  the same light the motes leaving her are drawn and lit with. */\nconst RZ_BURN_COLOR: vec3f = vec3f(0.45, 0.62, 2.40);\n\nfn rz_dissolve_hash(p: vec3f) -> f32 {\n  let q = fract(p * 0.3183099 + vec3f(0.1, 0.2, 0.3));\n  let r = q * 17.0 * (q + 34.0);\n  return fract(r.x * r.y * r.z);\n}\n\n/** Value noise over that hash \u2014 smooth within a flake, uncorrelated between. */\nfn rz_dissolve_field(p: vec3f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  let c000 = rz_dissolve_hash(i);\n  let c100 = rz_dissolve_hash(i + vec3f(1.0, 0.0, 0.0));\n  let c010 = rz_dissolve_hash(i + vec3f(0.0, 1.0, 0.0));\n  let c110 = rz_dissolve_hash(i + vec3f(1.0, 1.0, 0.0));\n  let c001 = rz_dissolve_hash(i + vec3f(0.0, 0.0, 1.0));\n  let c101 = rz_dissolve_hash(i + vec3f(1.0, 0.0, 1.0));\n  let c011 = rz_dissolve_hash(i + vec3f(0.0, 1.0, 1.0));\n  let c111 = rz_dissolve_hash(i + vec3f(1.0, 1.0, 1.0));\n  let x00 = mix(c000, c100, u.x);\n  let x10 = mix(c010, c110, u.x);\n  let x01 = mix(c001, c101, u.x);\n  let x11 = mix(c011, c111, u.x);\n  return mix(mix(x00, x10, u.y), mix(x01, x11, u.y), u.z);\n}\n\n/**\n * The threshold this fragment is measured against.\n *\n * NOISE ALONE, so the whole body comes apart at once \u2014 a hand, a shoulder and\n * an ankle all thinning together rather than a line travelling up her. It was\n * tilted by height at first, on the argument that a sweep reads as something\n * happening TO her; what it actually reads as is a wipe, and a wipe has a\n * direction, an edge and a speed the rest of the effect knows nothing about.\n * Everywhere at once is also the honest match for what leaves: the motes are\n * shed from every limb in the same breath.\n *\n * TWO SCALES, and the second one is not decoration \u2014 it is the fix for a real\n * failure. Clumps alone meant every fragment of a material SMALLER than one\n * cell shared a single threshold: an eye highlight, a brow, a button, a hair\n * clip. All of it sat inside the glowing front at once, so the piece flashed\n * white as a whole and then popped out of existence \u2014 the two things a\n * disintegration must never do. The grit is a plain per-cell hash at a fraction\n * of the clump, so a part a few millimetres across still comes apart in pieces.\n *\n * Weighted toward the clumps, because they are the LOOK: flakes a centimetre\n * across, in an order fixed to the surface, so the same piece of sleeve goes at\n * the same moment every time she leaves. The grit only breaks ties.\n */\nfn rz_dissolve_threshold(restPos: vec3f) -> f32 {\n  let clump = rz_dissolve_field(restPos / RZ_DISSOLVE_GRAIN);\n  let grit = rz_dissolve_hash(floor(restPos / (RZ_DISSOLVE_GRAIN * RZ_DISSOLVE_GRIT)));\n  return clamp(clump * 0.7 + grit * 0.3, 0.0, 1.0);\n}\n\nstruct LightVP { viewProj: mat4x4f, };\n@group(0) @binding(0) var<uniform> lp: LightVP;\n@group(0) @binding(1) var<storage, read> skinMats: array<mat4x4f>;\n@group(0) @binding(2) var texSampler: sampler;\n@group(1) @binding(0) var diffuseTexture: texture_2d<f32>;\n// The head of the material block and the one field at its tail \u2014 the same\n// reach the depth prepass takes, and for the same reason: a shadow cast by a\n// body that is no longer drawn is the tell that the vanishing is a trick.\nstruct MaterialDiffuse {\n  diffuse: vec4f,\n  _skip0: vec4f,\n  _skip1: vec4f,\n  _skip2: vec3f,\n  dissolve: f32,\n};\n@group(1) @binding(1) var<uniform> material: MaterialDiffuse;\n\nstruct VSOut {\n  @builtin(position) position: vec4f,\n  @location(0) uv: vec2f,\n  /** Bind-pose position, for the dissolve test \u2014 object space, as everywhere. */\n  @location(1) restPos: vec3f,\n};\n\n@vertex fn vs(@location(0) position: vec3f, @location(1) normal: vec3f, @location(2) uv: vec2f,\n  @location(3) joints0: vec4<u32>, @location(4) weights0: vec4<f32>) -> VSOut {\n  let pos4 = vec4f(position, 1.0);\n  let ws = weights0.x + weights0.y + weights0.z + weights0.w;\n  let inv = select(1.0, 1.0 / ws, ws > 0.0001);\n  let nw = select(vec4f(1.0,0.0,0.0,0.0), weights0 * inv, ws > 0.0001);\n  var sp = vec4f(0.0);\n  for (var i = 0u; i < 4u; i++) { sp += (skinMats[joints0[i]] * pos4) * nw[i]; }\n  var out: VSOut;\n  out.position = lp.viewProj * vec4f(sp.xyz, 1.0);\n  out.uv = uv;\n  out.restPos = position;\n  return out;\n}\n\n@fragment fn fs(in: VSOut) {\n  let alpha = textureSample(diffuseTexture, texSampler, in.uv).a * material.diffuse.a;\n  if (alpha < 0.5) { discard; }\n  // The dissolve, run as the colour pass runs it. A flake that is gone stops\n  // casting: without this she leaves a whole shadow standing on the floor while\n  // her body is in the air.\n  if (material.dissolve < 0.9995 && rz_dissolve_threshold(in.restPos) > material.dissolve) { discard; }\n}\n";
+export declare const SHADOW_DEPTH_SHADER_WGSL = "\n\n/** Clump size, in object-space units \u2014 MMD's are roughly centimetres. */\nconst RZ_DISSOLVE_GRAIN: f32 = 0.42;\n/** How much the clumps pull a fragment off its own grit value \u2014 the whole of\n *  the LOOK, and none of the rate. See rz_dissolve_threshold. */\nconst RZ_DISSOLVE_CLUMP: f32 = 0.6;\n/** Grit cell, as a fraction of a clump. See rz_dissolve_threshold: this is what\n *  keeps a material SMALLER than a clump from having one threshold for all of\n *  it, and it has to be smaller than the SMALLEST material a model carries \u2014\n *  an eye highlight, a button, a buckle \u2014 not merely small. Two and a half\n *  millimetres on a normal model, which is under all of them. */\nconst RZ_DISSOLVE_GRIT: f32 = 0.06;\n/** How wide the glowing front is, in threshold units. Thin: the front is a\n *  rim, and a wide one lights whole limbs at once. */\nconst RZ_DISSOLVE_EDGE: f32 = 0.11;\n/** What the front burns with. Emission, added after lighting and after the\n *  graph \u2014 a colour that ramps or takes a shadow reads as paint, not as heat.\n *  Above 1 on purpose: it is meant to reach the bloom pyramid. Blue-violet,\n *  the same light the motes leaving her are drawn and lit with. */\nconst RZ_BURN_COLOR: vec3f = vec3f(0.45, 0.62, 2.40);\n\nfn rz_dissolve_hash(p: vec3f) -> f32 {\n  // INTEGER, for exactly the reason _hash33 in nodes.ts is, and its comment\n  // says it: above 24 bits an f32 loses the low ones. The float hash this\n  // replaces multiplied three terms into the hundreds of millions and took\n  // fract() of the product \u2014 which past 2^24 is not noise, it is a quantised\n  // staircase, and wherever that staircase landed on zero the threshold was\n  // zero. A surface whose threshold is zero never crosses it: it stays behind\n  // while the rest of her leaves, and it sits inside the burning front the\n  // whole time she is gone. Those were the white pieces that would not go.\n  //\n  // Floored first, unlike _hash33: vec3i() truncates toward zero, so -0.5 and\n  // +0.5 are the same cell, and half this model is at negative x.\n  var h = vec3u(vec3i(floor(p)) + vec3i(32768));\n  h = h * vec3u(1664525u, 1013904223u, 2654435761u);\n  h = (h.yzx ^ h) * vec3u(2246822519u, 3266489917u, 668265263u);\n  h = h ^ (h >> vec3u(16u));\n  return f32((h.x ^ h.y ^ h.z) & 16777215u) * (1.0 / 16777216.0);\n}\n\n/** Value noise over that hash \u2014 smooth within a flake, uncorrelated between. */\nfn rz_dissolve_field(p: vec3f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  let c000 = rz_dissolve_hash(i);\n  let c100 = rz_dissolve_hash(i + vec3f(1.0, 0.0, 0.0));\n  let c010 = rz_dissolve_hash(i + vec3f(0.0, 1.0, 0.0));\n  let c110 = rz_dissolve_hash(i + vec3f(1.0, 1.0, 0.0));\n  let c001 = rz_dissolve_hash(i + vec3f(0.0, 0.0, 1.0));\n  let c101 = rz_dissolve_hash(i + vec3f(1.0, 0.0, 1.0));\n  let c011 = rz_dissolve_hash(i + vec3f(0.0, 1.0, 1.0));\n  let c111 = rz_dissolve_hash(i + vec3f(1.0, 1.0, 1.0));\n  let x00 = mix(c000, c100, u.x);\n  let x10 = mix(c010, c110, u.x);\n  let x01 = mix(c001, c101, u.x);\n  let x11 = mix(c011, c111, u.x);\n  return mix(mix(x00, x10, u.y), mix(x01, x11, u.y), u.z);\n}\n\n/**\n * The threshold this fragment is measured against.\n *\n * NOISE ALONE, so the whole body comes apart at once \u2014 a hand, a shoulder and\n * an ankle all thinning together rather than a line travelling up her. It was\n * tilted by height at first, on the argument that a sweep reads as something\n * happening TO her; what it actually reads as is a wipe, and a wipe has a\n * direction, an edge and a speed the rest of the effect knows nothing about.\n * Everywhere at once is also the honest match for what leaves: the motes are\n * shed from every limb in the same breath.\n *\n * TWO SCALES. Clumps alone meant every fragment of a material SMALLER than one\n * cell shared a single threshold: an eye highlight, a brow, a button, a hair\n * clip. All of it sat inside the glowing front at once, so the piece flashed\n * white as a whole and then popped \u2014 the two things a disintegration must never\n * do. The grit is a per-cell hash at a fraction of the clump, so a part a few\n * millimetres across still comes apart in pieces.\n *\n * THE GRIT IS THE BASE, though, and the clumps only push a fragment off it.\n * That ordering is what makes the dissolve smooth, and it is not obvious: the\n * two used to be WEIGHTED AND ADDED, and a sum is not uniformly distributed\n * however uniform each half is. It piles up in the middle, so most of the\n * surface had a threshold near a half \u2014 all of it went as the dissolve swept\n * through the middle, and what remained was the thin tail near zero. That tail\n * was the second stage everyone could see: a body that mostly vanished, then a\n * scatter of glowing scraps, then nothing.\n *\n * WRAPPED, not added. Offsetting a uniform value and taking fract() leaves it\n * EXACTLY uniform, where scaling a sum back into range only flattens the middle\n * \u2014 measured over four hundred thousand samples, the sum removed 12% of her per\n * step at the halfway mark and 0.1% at each end (a 110x swing), the scaled sum\n * still swung 89x, and the wrap is flat: 5.0% per step from the first flake to\n * the last, a ratio of 1.0.\n *\n * That flatness IS the smoothness. An uneven rate is what produced the two\n * stages you could see \u2014 a body that mostly vanished at once, then a scatter of\n * scraps that took as long again to follow.\n *\n * The clumping survives the wrap: neighbouring fragments share a clump value,\n * so the offset moves them together. What wraps past 1 comes back at 0 and goes\n * at the other end instead, which costs a little speckle in a region and buys\n * an even rate everywhere.\n */\nfn rz_dissolve_threshold(restPos: vec3f) -> f32 {\n  let grit = rz_dissolve_hash(floor(restPos / (RZ_DISSOLVE_GRAIN * RZ_DISSOLVE_GRIT)));\n  let clump = rz_dissolve_field(restPos / RZ_DISSOLVE_GRAIN) - 0.5;\n  return fract(grit + clump * RZ_DISSOLVE_CLUMP);\n}\n\nstruct LightVP { viewProj: mat4x4f, };\n@group(0) @binding(0) var<uniform> lp: LightVP;\n@group(0) @binding(1) var<storage, read> skinMats: array<mat4x4f>;\n@group(0) @binding(2) var texSampler: sampler;\n@group(1) @binding(0) var diffuseTexture: texture_2d<f32>;\n// The head of the material block and the one field at its tail \u2014 the same\n// reach the depth prepass takes, and for the same reason: a shadow cast by a\n// body that is no longer drawn is the tell that the vanishing is a trick.\nstruct MaterialDiffuse {\n  diffuse: vec4f,\n  _skip0: vec4f,\n  _skip1: vec4f,\n  _skip2: vec3f,\n  dissolve: f32,\n};\n@group(1) @binding(1) var<uniform> material: MaterialDiffuse;\n\nstruct VSOut {\n  @builtin(position) position: vec4f,\n  @location(0) uv: vec2f,\n  /** Bind-pose position, for the dissolve test \u2014 object space, as everywhere. */\n  @location(1) restPos: vec3f,\n};\n\n@vertex fn vs(@location(0) position: vec3f, @location(1) normal: vec3f, @location(2) uv: vec2f,\n  @location(3) joints0: vec4<u32>, @location(4) weights0: vec4<f32>) -> VSOut {\n  let pos4 = vec4f(position, 1.0);\n  let ws = weights0.x + weights0.y + weights0.z + weights0.w;\n  let inv = select(1.0, 1.0 / ws, ws > 0.0001);\n  let nw = select(vec4f(1.0,0.0,0.0,0.0), weights0 * inv, ws > 0.0001);\n  var sp = vec4f(0.0);\n  for (var i = 0u; i < 4u; i++) { sp += (skinMats[joints0[i]] * pos4) * nw[i]; }\n  var out: VSOut;\n  out.position = lp.viewProj * vec4f(sp.xyz, 1.0);\n  out.uv = uv;\n  out.restPos = position;\n  return out;\n}\n\n@fragment fn fs(in: VSOut) {\n  let alpha = textureSample(diffuseTexture, texSampler, in.uv).a * material.diffuse.a;\n  if (alpha < 0.5) { discard; }\n  // The dissolve, run as the colour pass runs it. A flake that is gone stops\n  // casting: without this she leaves a whole shadow standing on the floor while\n  // her body is in the air.\n  if (material.dissolve < 0.9995 && rz_dissolve_threshold(in.restPos) > material.dissolve) { discard; }\n}\n";
 //# sourceMappingURL=shadow.d.ts.map

package/dist/shaders/passes/shadow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shadow.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/shadow.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,wBAAwB,u8KAiDpC,CAAA"}
+{"version":3,"file":"shadow.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/shadow.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,wBAAwB,s4PAiDpC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reze-engine",
-  "version": "0.50.10",
+  "version": "0.50.11",
   "description": "A lightweight WebGPU engine for real-time 3D MMD/PMX model rendering",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/graph/slots.ts

@@ -117,7 +117,13 @@ ${discard}
   if (material.dissolve < 0.9995) {
     let rz_t = rz_dissolve_threshold(input.restPos);
     if (rz_t > material.dissolve) { discard; }
-    rz_burn = smoothstep(material.dissolve - RZ_DISSOLVE_EDGE, material.dissolve, rz_t);
+    // Put OUT as the last of her goes. Near zero the front is wider than what
+    // is left of the surface, so every surviving fragment sits inside it and
+    // the final scraps are pure glow — a body that ends as a handful of white
+    // specks rather than as a body. The taper costs nothing while she is mostly
+    // there, because it is already 1 by a fifth of the way in.
+    rz_burn = smoothstep(material.dissolve - RZ_DISSOLVE_EDGE, material.dissolve, rz_t)
+            * smoothstep(0.0, 0.22, material.dissolve);
   }
 
   var n = safe_normal(input.normal);

package/src/shaders/materials/common.ts

@@ -299,10 +299,15 @@ export function commonFsOutWgsl(): string {
 export const DISSOLVE_WGSL = /* wgsl */ `
 /** Clump size, in object-space units — MMD's are roughly centimetres. */
 const RZ_DISSOLVE_GRAIN: f32 = 0.42;
+/** How much the clumps pull a fragment off its own grit value — the whole of
+ *  the LOOK, and none of the rate. See rz_dissolve_threshold. */
+const RZ_DISSOLVE_CLUMP: f32 = 0.6;
 /** Grit cell, as a fraction of a clump. See rz_dissolve_threshold: this is what
  *  keeps a material SMALLER than a clump from having one threshold for all of
- *  it. Seven millimetres or so on a normal model. */
-const RZ_DISSOLVE_GRIT: f32 = 0.16;
+ *  it, and it has to be smaller than the SMALLEST material a model carries —
+ *  an eye highlight, a button, a buckle — not merely small. Two and a half
+ *  millimetres on a normal model, which is under all of them. */
+const RZ_DISSOLVE_GRIT: f32 = 0.06;
 /** How wide the glowing front is, in threshold units. Thin: the front is a
  *  rim, and a wide one lights whole limbs at once. */
 const RZ_DISSOLVE_EDGE: f32 = 0.11;
@@ -313,9 +318,22 @@ const RZ_DISSOLVE_EDGE: f32 = 0.11;
 const RZ_BURN_COLOR: vec3f = vec3f(0.45, 0.62, 2.40);
 
 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);
+  // INTEGER, for exactly the reason _hash33 in nodes.ts is, and its comment
+  // says it: above 24 bits an f32 loses the low ones. The float hash this
+  // replaces multiplied three terms into the hundreds of millions and took
+  // fract() of the product — which past 2^24 is not noise, it is a quantised
+  // staircase, and wherever that staircase landed on zero the threshold was
+  // zero. A surface whose threshold is zero never crosses it: it stays behind
+  // while the rest of her leaves, and it sits inside the burning front the
+  // whole time she is gone. Those were the white pieces that would not go.
+  //
+  // Floored first, unlike _hash33: vec3i() truncates toward zero, so -0.5 and
+  // +0.5 are the same cell, and half this model is at negative x.
+  var h = vec3u(vec3i(floor(p)) + vec3i(32768));
+  h = h * vec3u(1664525u, 1013904223u, 2654435761u);
+  h = (h.yzx ^ h) * vec3u(2246822519u, 3266489917u, 668265263u);
+  h = h ^ (h >> vec3u(16u));
+  return f32((h.x ^ h.y ^ h.z) & 16777215u) * (1.0 / 16777216.0);
 }
 
 /** Value noise over that hash — smooth within a flake, uncorrelated between. */
@@ -349,22 +367,42 @@ fn rz_dissolve_field(p: vec3f) -> f32 {
  * Everywhere at once is also the honest match for what leaves: the motes are
  * shed from every limb in the same breath.
  *
- * TWO SCALES, and the second one is not decoration — it is the fix for a real
- * failure. Clumps alone meant every fragment of a material SMALLER than one
+ * TWO SCALES. Clumps alone meant every fragment of a material SMALLER than one
  * cell shared a single threshold: an eye highlight, a brow, a button, a hair
  * clip. All of it sat inside the glowing front at once, so the piece flashed
- * white as a whole and then popped out of existence — the two things a
- * disintegration must never do. The grit is a plain per-cell hash at a fraction
- * of the clump, so a part a few millimetres across still comes apart in pieces.
+ * white as a whole and then popped — the two things a disintegration must never
+ * do. The grit is a per-cell hash at a fraction of the clump, so a part a few
+ * millimetres across still comes apart in pieces.
+ *
+ * THE GRIT IS THE BASE, though, and the clumps only push a fragment off it.
+ * That ordering is what makes the dissolve smooth, and it is not obvious: the
+ * two used to be WEIGHTED AND ADDED, and a sum is not uniformly distributed
+ * however uniform each half is. It piles up in the middle, so most of the
+ * surface had a threshold near a half — all of it went as the dissolve swept
+ * through the middle, and what remained was the thin tail near zero. That tail
+ * was the second stage everyone could see: a body that mostly vanished, then a
+ * scatter of glowing scraps, then nothing.
+ *
+ * WRAPPED, not added. Offsetting a uniform value and taking fract() leaves it
+ * EXACTLY uniform, where scaling a sum back into range only flattens the middle
+ * — measured over four hundred thousand samples, the sum removed 12% of her per
+ * step at the halfway mark and 0.1% at each end (a 110x swing), the scaled sum
+ * still swung 89x, and the wrap is flat: 5.0% per step from the first flake to
+ * the last, a ratio of 1.0.
+ *
+ * That flatness IS the smoothness. An uneven rate is what produced the two
+ * stages you could see — a body that mostly vanished at once, then a scatter of
+ * scraps that took as long again to follow.
  *
- * Weighted toward the clumps, because they are the LOOK: flakes a centimetre
- * across, in an order fixed to the surface, so the same piece of sleeve goes at
- * the same moment every time she leaves. The grit only breaks ties.
+ * The clumping survives the wrap: neighbouring fragments share a clump value,
+ * so the offset moves them together. What wraps past 1 comes back at 0 and goes
+ * at the other end instead, which costs a little speckle in a region and buys
+ * an even rate everywhere.
  */
 fn rz_dissolve_threshold(restPos: vec3f) -> f32 {
-  let clump = rz_dissolve_field(restPos / RZ_DISSOLVE_GRAIN);
   let grit = rz_dissolve_hash(floor(restPos / (RZ_DISSOLVE_GRAIN * RZ_DISSOLVE_GRIT)));
-  return clamp(clump * 0.7 + grit * 0.3, 0.0, 1.0);
+  let clump = rz_dissolve_field(restPos / RZ_DISSOLVE_GRAIN) - 0.5;
+  return fract(grit + clump * RZ_DISSOLVE_CLUMP);
 }
 `