reze-engine 0.50.6 → 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; }
 }
 `

package/src/vmd-writer.ts

@@ -103,10 +103,17 @@ export class VMDWriter {
       MODEL_NAME_SIZE +
       4 + totalBoneFrames * BONE_FRAME_SIZE +
       4 + totalMorphFrames * MORPH_FRAME_SIZE +
-      // Camera, light and self-shadow counts, then the IK block. Written only
-      // when there is IK state to carry: a plain motion stays byte-identical to
-      // what this writer produced before.
-      (ikFrames.length > 0 ? 4 * 4 + ikSize : 0)
+      // Camera, light, self-shadow and IK counts, ALWAYS — 16 bytes even when
+      // every one of them is zero.
+      //
+      // A VMD's sections are positional: a reader reaches each block by walking
+      // every count before it. Writing these only when there was IK state to
+      // carry left an ordinary motion ending right after the morph block, so
+      // anything looking for the sections that follow read past the end of the
+      // file and took whatever it found. MMD's own motion files carry all five
+      // counts unconditionally; so do ours now.
+      4 * 4 +
+      ikSize
 
     const buffer = new ArrayBuffer(size)
     const view = new DataView(buffer)
@@ -170,12 +177,14 @@ export class VMDWriter {
       }
     }
 
+    // Empty camera, light and self-shadow blocks, then the IK count — written
+    // whether or not there is IK state, so the file always ends on a complete
+    // section table.
+    for (let i = 0; i < 3; i++, offset += 4) view.setUint32(offset, 0, true)
+    view.setUint32(offset, ikFrames.length, true)
+    offset += 4
+
     if (ikFrames.length > 0) {
-      // Empty camera, light and self-shadow blocks — a reader walking the file
-      // in order has to pass through them to reach the IK block.
-      for (let i = 0; i < 3; i++, offset += 4) view.setUint32(offset, 0, true)
-      view.setUint32(offset, ikFrames.length, true)
-      offset += 4
       for (const [frame, states] of ikFrames) {
         view.setUint32(offset, frame, true)
         offset += 4
@@ -197,12 +206,17 @@ export class VMDWriter {
   /**
    * A camera VMD: the shot's own file, with no model motion in it.
    *
-   * Bone and morph counts are written as zero rather than omitted — the camera
-   * block sits after them in the format, so a reader walking the file in order
-   * (including this package's own parseCamera) has to pass through both to
-   * reach it. Light, self-shadow and IK blocks are left off entirely; every
-   * reader bounds-checks past the camera block, and MMD is happy with a file
-   * that simply ends there.
+   * Every section count is written, including the empty ones. The format is
+   * positional, so a reader reaches each block by walking the counts before it —
+   * bone and morph to arrive at the camera block, and light, self-shadow and IK
+   * to leave it cleanly.
+   *
+   * The trailing three used to be omitted, on the theory that every reader
+   * bounds-checks past the camera block. They do not. This file type is
+   * カメラ・照明 — camera AND lighting — so MMD looks for the light block exactly
+   * where the file used to stop, read past the end, and lit the scene from
+   * whatever it found there. It reached users as a stray coloured light on a
+   * camera-only export.
    *
    * `frames` is sorted by frame on the way out: CameraAnimation binary-searches
    * the track it loads, and an out-of-order file would sample wrong rather than
@@ -210,7 +224,8 @@ export class VMDWriter {
    */
   writeCamera(frames: CameraKeyframe[]): ArrayBuffer {
     const sorted = [...frames].sort((a, b) => a.frame - b.frame)
-    const size = HEADER_SIZE + MODEL_NAME_SIZE + 4 + 4 + 4 + sorted.length * CAMERA_FRAME_SIZE
+    const size =
+      HEADER_SIZE + MODEL_NAME_SIZE + 4 + 4 + 4 + sorted.length * CAMERA_FRAME_SIZE + 4 * 3
     const buffer = new ArrayBuffer(size)
     const view = new DataView(buffer)
     let offset = 0
@@ -249,6 +264,11 @@ export class VMDWriter {
       offset += 1
     }
 
+    // Light, self-shadow and IK/display counts. See the note above: the light
+    // block begins here, and leaving it off is what lit MMD from past the end
+    // of the file.
+    for (let i = 0; i < 3; i++, offset += 4) view.setUint32(offset, 0, true)
+
     return buffer
   }
 }

package/dist/physics/autofit.d.ts

@@ -1,147 +0,0 @@
-import { type Rigidbody } from "./types";
-import type { Skinning } from "../model";
-/**
- * Supplementary colliders fitted to the mesh a PMX rigid body fails to cover.
- *
- * PMX body proxies are bodies of revolution — 下半身 is a capsule lying
- * transversely across the hips, so its cross-section is a circle. A pelvis seen
- * from the side is not a circle, and across every rig measured the butt sits
- * 0.18–0.71 units OUTSIDE that capsule while the front is flush or inside. That
- * gap is where a skirt goes through a character: the cloth is resting correctly
- * on the collider it was given, and the collider stops half a unit short of the
- * skin.
- *
- * A rest offset cannot close it (see RigidBodyStore.restOffset) — it is one
- * scalar on a radially symmetric shape, and the error is asymmetric. Measured
- * on 托特's run cycle, the offset that clears the butt is 0.5, which is simply
- * the size of the missing geometry, and at that value the skirt stands off the
- * front and hips by the same 0.5.
- *
- * So fit the missing piece instead: take each bone-following body's own skinned
- * vertices, find the ones that escape its shape in a concentrated lobe, and fit
- * a capsule to that lobe. That is the fix riggers apply by hand, derived from
- * the mesh rather than guessed.
- *
- * Measured on 托特's run cycle, counting butt vertices swallowed by a cloth
- * body: 32.4 per frame with nothing, 30.9 with a 0.02 rest offset, 12.4 with
- * this pass, 10.4 with both.
- */
-export interface AutoFitOptions {
-    /** A vertex counts as protruding past this much (model units). Below it the
-     *  mesh is within authoring tolerance of the proxy and needs no help. */
-    minProtrusion?: number;
-    /**
-     * Ignore vertices further out than this multiple of the source shape's
-     * RADIUS (its smallest characteristic dimension).
-     *
-     * A coarse first cut at keeping hair and loose clothing out — anything
-     * standing further off the proxy than the proxy is wide is not skin. The
-     * discriminator that actually does the work is minConcentration.
-     */
-    maxProtrusionRatio?: number;
-    /** Fewer protruding vertices than this and it is a spike, not a region. */
-    minVertices?: number;
-    /**
-     * Per-axis quantile the fitted lobe's extent is clipped to, each end. A
-     * handful of stray vertices (a weight-painting slip, a seam) would otherwise
-     * stretch the capsule far past the surface everyone can see.
-     */
-    quantile?: number;
-    /** Skip the fit unless the capsule actually reaches this far past what is
-     *  already covered — otherwise it adds solver rows for nothing. */
-    minGain?: number;
-    /** How tightly the kept lobe's outward directions must agree, 0–1. A loose
-     *  sanity check; the real discriminator is minConcentration. */
-    minDirectionality?: number;
-    /** Vertices outside the dominant lobe, by this cosine, are not part of the
-     *  feature being fitted. */
-    lobeCos?: number;
-    /**
-     * How much deeper the fitted lobe must be than protrusion typically is on
-     * this body, averaged over the vertices that protrude at all.
-     *
-     * This is the guard that separates "the proxy is missing a lobe" from "the
-     * proxy is not a proxy for this mesh at all". A pelvis escapes its capsule by
-     * 0.53 at the back and 0.14 at the front, so the back lobe stands well clear
-     * of the average. Hair escapes the skull by a similar depth in every
-     * direction, so its deepest lobe is no deeper than typical and the ratio sits
-     * near 1. See the note at the meanProtrusion computation for what this
-     * deliberately refuses to fit.
-     *
-     * Without it the pass fits the hairstyle — measured on 托特, 頭 reports
-     * 3653 of 4669 vertices outside its capsule, and the fitted shape was a crate
-     * around the whole head. No threshold on depth or vertex count tells those
-     * two cases apart; concentration does.
-     */
-    minConcentration?: number;
-    /**
-     * How many capsules may be fitted to one body, each against what the previous
-     * ones already cover.
-     *
-     * One capsule inscribed in a lobe does not fill it — on 托特's butt a single
-     * fit removed 58% of the clipping and left the rest at the edges the capsule
-     * could not reach. Each further pass re-measures protrusion against the
-     * original shape UNION everything fitted so far, so it lands on whatever is
-     * still exposed instead of re-fitting the same bulge.
-     */
-    maxShapesPerBody?: number;
-    /**
-     * Quantile of the lobe's perpendicular spread used as the capsule radius.
-     *
-     * The clip-versus-float dial, and the one to reach for if a result looks
-     * wrong. Lower hugs the body: less standoff in idle, more clipping left. 1.0
-     * encloses the lobe entirely, which is what produced a visibly hovering
-     * skirt on 托特.
-     */
-    radiusQuantile?: number;
-    /**
-     * Fit only the deepest part of each lobe: points at least this fraction of
-     * the lobe's own maximum protrusion.
-     *
-     * A lobe tapers to nothing at its edges, and a capsule sized to span the
-     * whole thing has to be fat enough to reach the edges too. Fitting the deep
-     * core keeps each capsule small and lets a later pass handle the shallows
-     * with its own, which is both tighter and closer to what the surface is
-     * actually doing.
-     */
-    lobeDepthFraction?: number;
-}
-/** What the pass decided for one source body — surfaced so a rig can be
- *  inspected rather than silently rebuilt underneath its author. */
-export interface AutoFitResult {
-    /** Index of the body in the input array that this supplements. */
-    sourceIndex: number;
-    sourceName: string;
-    /** Vertices dominated by that body's bone, and how many were outside it. */
-    vertexCount: number;
-    protrudingCount: number;
-    /** Furthest any kept vertex sat outside the source shape. */
-    maxProtrusion: number;
-    /** How far the fitted capsule reaches past what was already covered. */
-    gain: number;
-    /** Length of the kept lobe's mean outward direction, 0–1. */
-    directionality: number;
-    /** Lobe depth over the body's average protrusion. See minConcentration. */
-    concentration: number;
-    /**
-     * Furthest the capsule's newly exposed surface sits from the skin it was
-     * fitted to — the amount cloth resting on it will stand off the body at the
-     * worst point, and the number to watch if a result looks puffy. Only the part
-     * reaching outside the source shape is measured; the rest is buried.
-     */
-    overshoot: number;
-    body: Rigidbody;
-}
-/**
- * Fit supplementary colliders for every bone-following body whose own mesh
- * escapes it.
- *
- * `vertices` is the model's interleaved vertex buffer (stride 8, position
- * first) and `skinning` its joints/weights — both in PMX bind pose, the same
- * space as `shapePosition` / `shapeRotation`, so nothing has to be skinned.
- *
- * Returns one entry per body it chose to supplement; the caller appends
- * `.body` to the rigid body list before constructing RezePhysics.
- */
-export declare function fitSupplementaryColliders(rigidbodies: Rigidbody[], vertices: Float32Array, skinning: Skinning, options?: AutoFitOptions): AutoFitResult[];
-//# sourceMappingURL=autofit.d.ts.map

package/dist/physics/autofit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"autofit.d.ts","sourceRoot":"","sources":["../../src/physics/autofit.ts"],"names":[],"mappings":"AACA,OAAO,EAAiC,KAAK,SAAS,EAAE,MAAM,SAAS,CAAA;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,cAAc;IAC7B;6EACyE;IACzE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,2EAA2E;IAC3E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;uEACmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;oEACgE;IAChE,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;gCAC4B;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;;;;;OASG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;;;;;;;;;OASG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AA2BD;oEACoE;AACpE,MAAM,WAAW,aAAa;IAC5B,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAA;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,6DAA6D;IAC7D,aAAa,EAAE,MAAM,CAAA;IACrB,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAA;IACZ,6DAA6D;IAC7D,cAAc,EAAE,MAAM,CAAA;IACtB,2EAA2E;IAC3E,aAAa,EAAE,MAAM,CAAA;IACrB;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,SAAS,CAAA;CAChB;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,SAAS,EAAE,EACxB,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,cAAmB,GAC3B,aAAa,EAAE,CA4CjB"}