reze-engine 0.55.1 → 0.55.3

package/dist/model.js

@@ -70,6 +70,35 @@ export class Model {
     setVisible(visible) {
         this._visible = visible;
     }
+    /** Hang the rig's root bones from `matrix` (model space, column-major 16
+     *  floats), or from nothing. The engine drives this every frame for an
+     *  attached model; the matrix is read at the next world pass, not copied. */
+    setRootParent(matrix) {
+        this.rootParent = matrix;
+        if (matrix) {
+            const root = this.skeleton.bones.find((b) => b.parentIndex < 0);
+            this.primaryRootBind = root ? [root.bindTranslation[0], root.bindTranslation[1], root.bindTranslation[2]] : [0, 0, 0];
+        }
+    }
+    getRootParent() {
+        return this.rootParent;
+    }
+    /** The placement matrix (position · rotation · scale) the skin bake composes
+     *  onto every bone. Rebuilt lazily, the way getSkinMatrices does it. */
+    getRootMatrix() {
+        this.refreshRootMatrix();
+        return this.rootMatrixValues;
+    }
+    refreshRootMatrix() {
+        if (!this.rootMatrixDirty)
+            return;
+        const p = this._position, r = this._rotation, s = this._scale;
+        Mat4.fromPositionRotationScaleInto(p.x, p.y, p.z, r.x, r.y, r.z, r.w, s, this.rootMatrixValues);
+        this.rootIsIdentity =
+            p.x === 0 && p.y === 0 && p.z === 0 &&
+                r.x === 0 && r.y === 0 && r.z === 0 && r.w === 1 && s === 1;
+        this.rootMatrixDirty = false;
+    }
     /** Called by Engine when registering the model; enables loadVmd to resolve relative paths for folder uploads. */
     setAssetContext(reader, basePath) {
         this.assetReader = reader;
@@ -122,6 +151,21 @@ export class Model {
         this.rootMatrixValues = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
         this.rootMatrixDirty = false;
         this.rootIsIdentity = true;
+        /** What every parentless bone hangs from — MMD's 外部親 (outside parent).
+         *  Model space, so the pose pipeline, IK and physics all see it: a prop bound
+         *  to a hand is moved by its BONES, and gravity keeps pointing down while the
+         *  hand tilts. Null is the ordinary rig, rooted at the model's own origin.
+         *  Written per frame by the engine from the parent's posed bone; see
+         *  Engine.setModelParent. */
+        this.rootParent = null;
+        /** The bind position of the PRIMARY root — the first parentless bone, 全ての親
+         *  by convention. Under a root parent that bone sits exactly ON the parent
+         *  bone, as MMD's 外部親 does, so its bind position is taken off every root's
+         *  local matrix: the primary lands at the parent, the other roots keep their
+         *  layout relative to it. Without this the MODEL ORIGIN went to the parent
+         *  bone, and a prop rigged with its one bone at the mesh's centre hung that
+         *  far away from the hand. */
+        this.primaryRootBind = [0, 0, 0];
         /** 1 where the simulation overwrites the bone's world matrix. See setPhysicsDrivenBones. */
         this.physicsDriven = null;
         /** Bones to recompute after a step, in deform order — null when no rig needs it. */
@@ -652,6 +696,14 @@ export class Model {
     isClipApplySuspended() {
         return this.clipApplySuspended;
     }
+    /** A bone's posed matrix — model space, column-major, the live array rather
+     *  than a copy. Null for a name this rig does not have. */
+    getBoneWorldMatrix(boneName) {
+        const idx = this.runtimeSkeleton.nameIndex[boneName];
+        if (idx === undefined || idx < 0)
+            return null;
+        return this.runtimeSkeleton.worldMatrices[idx].values;
+    }
     // World bone origin (world matrix col3); unknown name → null
     getBoneWorldPosition(boneName) {
         const idx = this.runtimeSkeleton.nameIndex[boneName];
@@ -879,14 +931,7 @@ export class Model {
         }
         const skinMatrices = this.skinMatricesArray;
         // Rebuild root matrix + cache identity-shortcut flag only when pos/rot changed.
-        if (this.rootMatrixDirty) {
-            const p = this._position, r = this._rotation, s = this._scale;
-            Mat4.fromPositionRotationScaleInto(p.x, p.y, p.z, r.x, r.y, r.z, r.w, s, this.rootMatrixValues);
-            this.rootIsIdentity =
-                p.x === 0 && p.y === 0 && p.z === 0 &&
-                    r.x === 0 && r.y === 0 && r.z === 0 && r.w === 1 && s === 1;
-            this.rootMatrixDirty = false;
-        }
+        this.refreshRootMatrix();
         if (this.rootIsIdentity) {
             // skinMatrix = worldMatrix × inverseBindMatrix
             for (let i = 0; i < boneCount; i++) {
@@ -2209,6 +2254,13 @@ export class Model {
             const parentMat = worldMats[b.parentIndex];
             Mat4.multiplyArrays(parentMat.values, 0, localMVals, 0, worldMat.values, 0);
         }
+        else if (this.rootParent) {
+            const pr = this.primaryRootBind;
+            localMVals[12] -= pr[0];
+            localMVals[13] -= pr[1];
+            localMVals[14] -= pr[2];
+            Mat4.multiplyArrays(this.rootParent, 0, localMVals, 0, worldMat.values, 0);
+        }
         else {
             worldMat.values.set(localMVals);
         }
@@ -2362,6 +2414,8 @@ export class Model {
         // leaving every other bone — the simulated ones above all — untouched.
         const order = subset ?? this.deformOrder;
         const count = subset ? subset.length : boneCount;
+        const rootParent = this.rootParent;
+        const primaryRootBind = this.primaryRootBind;
         const override = this.appendRotOverride;
         const overrideSet = this.appendRotOverrideSet;
         for (let k = 0; k < count; k++) {
@@ -2427,6 +2481,14 @@ export class Model {
                 const parentMat = worldMats[b.parentIndex];
                 Mat4.multiplyArrays(parentMat.values, 0, localMVals, 0, worldMat.values, 0);
             }
+            else if (rootParent) {
+                // The primary root's bind position comes off every root, so the primary
+                // sits ON the parent bone. See primaryRootBind.
+                localMVals[12] -= primaryRootBind[0];
+                localMVals[13] -= primaryRootBind[1];
+                localMVals[14] -= primaryRootBind[2];
+                Mat4.multiplyArrays(rootParent, 0, localMVals, 0, worldMat.values, 0);
+            }
             else {
                 worldMat.values.set(localMVals);
             }

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

@@ -1,4 +1,8 @@
-export declare function groundShaderWgsl(): string;
+/**
+ * The ground's shader. `soft` selects the shadow-edge variant — see pcfWgsl for
+ * why this is a compiled flag and not a uniform the shader branches on.
+ */
+export declare function groundShaderWgsl(soft?: boolean): string;
 /**
  * The ground belongs to no model instance, so it takes ids of its own — at the
  * TOP of the u16 range, not at the bottom.

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

@@ -1 +1 @@
-{"version":3,"file":"ground.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/ground.ts"],"names":[],"mappings":"AAmEA,wBAAgB,gBAAgB,IAAI,MAAM,CA2TzC;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,QAAS,CAAA;AACxC,eAAO,MAAM,gBAAgB,QAAS,CAAA;AAEtC;;;oEAGoE;AACpE,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,+oCAiClC,CAAA"}
+{"version":3,"file":"ground.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/ground.ts"],"names":[],"mappings":"AAgFA;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,UAAQ,GAAG,MAAM,CA+TrD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,QAAS,CAAA;AACxC,eAAO,MAAM,gBAAgB,QAAS,CAAA;AAEtC;;;oEAGoE;AACpE,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,+oCAiClC,CAAA"}

package/dist/shaders/passes/ground.js

@@ -32,36 +32,53 @@ const SOFT_MAX_SPREAD = 14;
  * `acc` must already be declared and zeroed; the caller reads it back
  * normalised, so there is no `/ 9.0` left at the call site.
  */
-function pcfWgsl(map, uv, texel, z, acc, pad) {
+function pcfWgsl(map, uv, texel, z, acc, pad, soft) {
     const golden = 2.39996323;
-    return [
-        `if (material.shadowSoftness <= 0.0) {`,
-        `  let st = ${texel} * 2.0;`,
-        `  for (var y = -1; y <= 1; y++) {`,
-        `    for (var x = -1; x <= 1; x++) {`,
+    // ONE BRANCH IS COMPILED, NOT BOTH.
+    //
+    // A runtime `if` on the softness uniform was the first cut, and it costs a
+    // scene that never softens a shadow. Both bodies land in the module, the wide
+    // one needs more live registers than the narrow one, and occupancy on this
+    // draw is set by the worst of them — so the frame gets slower whether or not
+    // the branch is ever taken. That is expensive HERE in particular: this file
+    // already records that the ground is a full-coverage draw costing tens of
+    // millions of shadow fetches, and that bisection on a slow device pinned the
+    // whole cost to it.
+    //
+    // So the flag is the COMPILED VARIANT, which is the idiom the composite pass
+    // already uses for its effects. A scene at softness 0 gets byte-for-byte the
+    // shader it had before any of this existed, and cannot pay for a feature it
+    // is not using.
+    const sharp = [
+        `let st = ${texel} * 2.0;`,
+        `for (var y = -1; y <= 1; y++) {`,
+        `  for (var x = -1; x <= 1; x++) {`,
         // ...Level, not the implicit-derivative form: identical on a single-mip
         // shadow map, and legal inside a branch.
-        `      ${acc} += textureSampleCompareLevel(${map}, shadowSampler, ${uv} + vec2f(f32(x), f32(y)) * st, ${z});`,
-        `    }`,
+        `    ${acc} += textureSampleCompareLevel(${map}, shadowSampler, ${uv} + vec2f(f32(x), f32(y)) * st, ${z});`,
         `  }`,
-        `  ${acc} *= ${1 / 9};`,
-        `} else {`,
-        `  let radius = ${texel} * 2.0 * (1.0 + material.shadowSoftness * ${SOFT_MAX_SPREAD}.0);`,
-        `  for (var s = 0; s < ${SOFT_TAPS}; s++) {`,
-        `    let fs = f32(s);`,
+        `}`,
+        `${acc} *= ${1 / 9};`,
+    ];
+    const wide = [
+        `let radius = ${texel} * 2.0 * (1.0 + material.shadowSoftness * ${SOFT_MAX_SPREAD}.0);`,
+        `for (var s = 0; s < ${SOFT_TAPS}; s++) {`,
+        `  let fs = f32(s);`,
         // sqrt of the index spaces the ring radii evenly by AREA; the golden angle
         // keeps successive taps from lining up into spokes.
-        `    let r = sqrt((fs + 0.5) * ${1 / SOFT_TAPS});`,
-        `    let a = fs * ${golden} + rot;`,
-        `    ${acc} += textureSampleCompareLevel(${map}, shadowSampler, ${uv} + vec2f(cos(a), sin(a)) * (r * radius), ${z});`,
-        `  }`,
-        `  ${acc} *= ${1 / SOFT_TAPS};`,
+        `  let r = sqrt((fs + 0.5) * ${1 / SOFT_TAPS});`,
+        `  let a = fs * ${golden} + rot;`,
+        `  ${acc} += textureSampleCompareLevel(${map}, shadowSampler, ${uv} + vec2f(cos(a), sin(a)) * (r * radius), ${z});`,
         `}`,
-    ]
-        .map((l) => pad + l)
-        .join("\n");
+        `${acc} *= ${1 / SOFT_TAPS};`,
+    ];
+    return (soft ? wide : sharp).map((l) => pad + l).join("\n");
 }
-export function groundShaderWgsl() {
+/**
+ * The ground's shader. `soft` selects the shadow-edge variant — see pcfWgsl for
+ * why this is a compiled flag and not a uniform the shader branches on.
+ */
+export function groundShaderWgsl(soft = false) {
     return /* wgsl */ `
 struct CameraUniforms { view: mat4x4f, projection: mat4x4f, viewPos: vec3f, _p: f32, };
 struct Light { direction: vec4f, color: vec4f, };
@@ -203,11 +220,13 @@ ${sceneFsOutWgsl()}@fragment fn fs(i: VO) -> FSOut {
   // The same reasoning the noise tint below already got, applied to the term
   // that costs a hundred times more.
   if (material.shadowStrength > 0.0 && shadowPossible) {
-  // Per-pixel rotation for the soft disk, so its rings break up into fine noise
-  // rather than banding. Interleaved gradient noise: a function of the pixel
-  // alone, so a still camera gives a still shadow — the sharp path ignores it.
+${soft
+        ? `  // Per-pixel rotation for the soft disk, so its rings break up into fine
+  // noise rather than banding. Interleaved gradient noise: a function of the
+  // pixel alone, so a still camera gives a still shadow.
   let ign = fract(52.9829189 * fract(dot(i.position.xy, vec2f(0.06711056, 0.00583715))));
-  let rot = ign * 6.28318530718;
+  let rot = ign * 6.28318530718;`
+        : ""}
   // The far cascade's taps, skipped entirely when nothing ever drew into it.
   //
   // This branch is the expensive one on a wide floor: it runs wherever the NEAR
@@ -223,7 +242,7 @@ ${sceneFsOutWgsl()}@fragment fn fs(i: VO) -> FSOut {
     let suv1_c = clamp(suv1, vec2f(0.02), vec2f(0.98));
     let compareZ1 = ndc1.z - 0.0035;
     var acc1 = 0.0;
-${pcfWgsl("shadowMapFar", "suv1_c", `${1 / SHADOW_CASCADES[SHADOW_CASCADES.length - 1].mapSize}`, "compareZ1", "acc1", "    ")}
+${pcfWgsl("shadowMapFar", "suv1_c", `${1 / SHADOW_CASCADES[SHADOW_CASCADES.length - 1].mapSize}`, "compareZ1", "acc1", "    ", soft)}
     vis = mix(1.0, acc1, frustum1);
   }
   if (frustum > 0.0) {
@@ -231,7 +250,7 @@ ${pcfWgsl("shadowMapFar", "suv1_c", `${1 / SHADOW_CASCADES[SHADOW_CASCADES.lengt
     let suv_c = clamp(suv, vec2f(0.02), vec2f(0.98));
     let compareZ = ndc.z - 0.0035;
     var acc = 0.0;
-${pcfWgsl("shadowMap", "suv_c", "material.pcfTexel", "compareZ", "acc", "    ")}
+${pcfWgsl("shadowMap", "suv_c", "material.pcfTexel", "compareZ", "acc", "    ", soft)}
     // The base is whatever the far cascade decided, so the near border blends
     // cascade to cascade rather than snapping to lit mid-floor.
     vis = mix(vis, acc, frustum);

package/package.json

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