@pmndrs/viverse 0.2.23 → 0.2.25

package/dist/model/index.d.ts

@@ -31,6 +31,17 @@ export type CharacterModel = {
     scene: Object3D;
     currentAnimations: Map<string | undefined, AnimationAction>;
     boneRotationOffset?: Quaternion;
+    /**
+     * The character's real height in world units, measured once from the loaded mesh in its
+     * bind pose. Use this to size things to the character (nameplates, hitboxes, scale
+     * normalization) instead of `new Box3().setFromObject(scene)` — that includes the skeleton
+     * bones and the internal rest-pose reference copy and changes as the animation plays, so it
+     * returns a height several times the visible body.
+     *
+     * Always set by `loadCharacterModel`; optional only so hand-built `CharacterModel` objects
+     * (e.g. cloned NPC instances) stay valid — copy it across when you clone.
+     */
+    height?: number;
 };
 export declare function loadCharacterModel(url?: string, type?: Exclude<CharacterModelOptions, boolean>['type'], boneRotationOffset?: Quaternion, castShadow?: boolean, receiveShadow?: boolean, boneMap?: BoneMap, useDraco?: boolean): Promise<CharacterModel>;
 export declare function getBone(model: CharacterModel, name: VRMHumanBoneName): Object3D | undefined;

package/dist/model/index.js

@@ -1,5 +1,5 @@
 import { VRM } from '@pixiv/three-vrm';
-import { AnimationMixer, Euler, Quaternion } from 'three';
+import { AnimationMixer, Box3, Euler, Quaternion, Vector3 } from 'three';
 import { loadGltfCharacterModel } from './gltf.js';
 import { loadVrmCharacterModel } from './vrm.js';
 export { VRMHumanBoneName } from '@pixiv/three-vrm';
@@ -56,11 +56,15 @@ export async function loadCharacterModel(url, type, boneRotationOffset, castShad
             obj.receiveShadow = true;
         }
     });
+    // Measure the real height here: the scene is still in its bind pose, the mixer has not run,
+    // and the rest-pose clone below has not been added yet — so the bounding box is just the
+    // visible mesh and is stable. Measuring later (after the clone, once animating) inflates it.
+    const height = new Box3().setFromObject(result.scene).getSize(new Vector3()).y;
     const restPose = result.scene.clone();
     restPose.visible = false;
     restPose.traverse((object) => (object.name = `rest_${object.name}`));
     result.scene.add(restPose);
-    return Object.assign(result, { mixer: new AnimationMixer(result.scene), currentAnimations: new Map() });
+    return Object.assign(result, { mixer: new AnimationMixer(result.scene), currentAnimations: new Map(), height });
 }
 export function getBone(model, name) {
     return model instanceof VRM ? (model.humanoid.getRawBoneNode(name) ?? undefined) : model.scene.getObjectByName(name);

package/dist/physics/world.js

@@ -1,10 +1,19 @@
-import { Box3, DoubleSide, InstancedMesh, Matrix4, Mesh, Ray, Vector3 } from 'three';
+import { Box3, DoubleSide, InstancedMesh, Matrix4, Mesh, Ray, Vector3, } from 'three';
 import { computeBoundsTree, StaticGeometryGenerator, ExtendedTriangle } from 'three-mesh-bvh';
 const rayHelper = new Ray();
 const farPointHelper = new Vector3();
 const boxHelper = new Box3();
 const triangleHelper = new ExtendedTriangle();
 const matrixHelper = new Matrix4();
+/**
+ * Identifies which geometries StaticGeometryGenerator can merge together. Geometries are mergeable when they share
+ * the same set of attributes and agree on whether they are indexed, so two geometries with an equal signature are
+ * guaranteed not to trigger the "Make sure all geometries have the same number of attributes." error.
+ */
+function geometryAttributeSignature(geometry) {
+    const attributeNames = Object.keys(geometry.attributes).sort().join(',');
+    return `${geometry.index == null ? 'non-indexed' : 'indexed'}:${attributeNames}`;
+}
 export class BvhPhysicsWorld {
     bodies = [];
     sensors = [];
@@ -30,35 +39,45 @@ export class BvhPhysicsWorld {
     computeBvhEntries(object, isStatic) {
         object.updateWorldMatrix(true, true);
         const result = [];
-        let hasNonInstancedMeshes = false;
+        //StaticGeometryGenerator merges all meshes into a single geometry and throws if they don't all expose
+        //the same attributes ("Make sure all geometries have the same number of attributes."). Group the meshes by
+        //their attribute signature so every merge only ever sees compatible geometries and generate one bvh per group.
+        const meshGroups = new Map();
         object.traverse((entry) => {
             if (entry instanceof InstancedMesh) {
                 const bvh = computeBoundsTree.apply(entry.geometry);
-                result.push(...new Array(entry.instanceMatrix.count).fill(undefined).map((_, i) => ({
+                result.push(...Array.from({ length: entry.instanceMatrix.count }, (_, instanceIndex) => ({
                     object: entry,
                     bvh,
-                    instanceIndex: i,
+                    instanceIndex,
                     isStatic,
                 })));
                 return;
             }
             if (entry instanceof Mesh) {
-                hasNonInstancedMeshes = true;
+                const signature = geometryAttributeSignature(entry.geometry);
+                let group = meshGroups.get(signature);
+                if (group == null) {
+                    meshGroups.set(signature, (group = []));
+                }
+                group.push(entry);
             }
         });
-        if (hasNonInstancedMeshes) {
+        if (meshGroups.size > 0) {
             const parent = object.parent;
             if (!isStatic) {
                 object.parent = null;
                 object.updateMatrixWorld(true);
             }
-            const geometry = new StaticGeometryGenerator(object).generate();
-            const bvh = computeBoundsTree.apply(geometry);
+            for (const meshes of meshGroups.values()) {
+                const geometry = new StaticGeometryGenerator(meshes).generate();
+                const bvh = computeBoundsTree.apply(geometry);
+                result.push({ object, bvh, isStatic });
+            }
             if (!isStatic) {
                 object.parent = parent;
                 object.updateMatrixWorld(true);
             }
-            result.push({ object, bvh, isStatic });
         }
         return result;
     }

package/package.json

@@ -21,7 +21,7 @@
   "peerDependencies": {
     "three": "*"
   },
-  "version": "0.2.23",
+  "version": "0.2.25",
   "type": "module",
   "dependencies": {
     "@pixiv/three-vrm": "^3.4.2",