@pmndrs/viverse 0.2.25 → 0.2.27

package/dist/animation/bvh-bone-map.d.ts

@@ -0,0 +1,11 @@
+import type { VRMHumanBoneName } from '@pixiv/three-vrm';
+/**
+ * Maps standard BVH bone names to VRM humanoid bone names.
+ *
+ * Kept as a `.ts` module rather than a `.json` import on purpose: importing JSON requires
+ * import attributes (`with { type: 'json' }`), which survive into the published ESM build and
+ * break in-browser bundlers like the docs' Sandpack (Babel: "experimental syntax
+ * 'moduleAttributes' isn't currently enabled").
+ */
+declare const bvhBoneMap: Record<string, VRMHumanBoneName>;
+export default bvhBoneMap;

package/dist/animation/bvh-bone-map.js

@@ -0,0 +1,33 @@
+/**
+ * Maps standard BVH bone names to VRM humanoid bone names.
+ *
+ * Kept as a `.ts` module rather than a `.json` import on purpose: importing JSON requires
+ * import attributes (`with { type: 'json' }`), which survive into the published ESM build and
+ * break in-browser bundlers like the docs' Sandpack (Babel: "experimental syntax
+ * 'moduleAttributes' isn't currently enabled").
+ */
+const bvhBoneMap = {
+    Hips: 'hips',
+    Spine: 'spine',
+    Spine1: 'chest',
+    Spine2: 'upperChest',
+    Neck: 'neck',
+    Head: 'head',
+    LeftShoulder: 'leftShoulder',
+    LeftArm: 'leftUpperArm',
+    LeftForeArm: 'leftLowerArm',
+    LeftHand: 'leftHand',
+    RightShoulder: 'rightShoulder',
+    RightArm: 'rightUpperArm',
+    RightForeArm: 'rightLowerArm',
+    RightHand: 'rightHand',
+    LeftUpLeg: 'leftUpperLeg',
+    LeftLeg: 'leftLowerLeg',
+    LeftFoot: 'leftFoot',
+    LeftToe: 'leftToes',
+    RightUpLeg: 'rightUpperLeg',
+    RightLeg: 'rightLowerLeg',
+    RightFoot: 'rightFoot',
+    RightToe: 'rightToes',
+};
+export default bvhBoneMap;

package/dist/animation/index.d.ts

@@ -25,4 +25,4 @@ export declare function flattenCharacterAnimationOptions(options: Exclude<Charac
 export declare function loadCharacterAnimation(model: CharacterModel, url: string | DefaultUrl, type?: CharacterAnimationOptions['type'], removeXZMovement?: boolean, trimStartTime?: number | undefined, trimEndTime?: number | undefined, boneMap?: Record<string, VRMHumanBoneName> | undefined, scaleTime?: number | undefined, mask?: CharacterAnimationMask): Promise<AnimationClip>;
 export declare const mixamoBoneMap: Record<string, VRMHumanBoneName>;
 export declare const bvhBoneMap: Record<string, VRMHumanBoneName>;
-export declare const allBoneNames: string[];
+export declare const allBoneNames: Array<string>;

package/dist/animation/index.js

@@ -4,10 +4,10 @@ import { BVHLoader } from 'three/examples/jsm/loaders/BVHLoader.js';
 import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader.js';
 import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
 import { applyAnimationBoneMap } from './bone-map.js';
-import _bvhBoneMap from './bvh-bone-map.json' with { type: 'json' };
+import _bvhBoneMap from './bvh-bone-map.js';
 import { resolveDefaultCharacterAnimationUrl } from './default.js';
 import { applyMask } from './mask.js';
-import _mixamoBoneMap from './mixamo-bone-map.json' with { type: 'json' };
+import _mixamoBoneMap from './mixamo-bone-map.js';
 import { scaleAnimationClipTime, trimAnimationClip } from './utils.js';
 import { vrmaLoader } from '../model/index.js';
 //helper variables for the quaternion retargeting

package/dist/animation/mixamo-bone-map.d.ts

@@ -0,0 +1,11 @@
+import type { VRMHumanBoneName } from '@pixiv/three-vrm';
+/**
+ * Maps Mixamo bone names (`mixamorig*`) to VRM humanoid bone names.
+ *
+ * Kept as a `.ts` module rather than a `.json` import on purpose: importing JSON requires
+ * import attributes (`with { type: 'json' }`), which survive into the published ESM build and
+ * break in-browser bundlers like the docs' Sandpack (Babel: "experimental syntax
+ * 'moduleAttributes' isn't currently enabled").
+ */
+declare const mixamoBoneMap: Record<string, VRMHumanBoneName>;
+export default mixamoBoneMap;

package/dist/animation/mixamo-bone-map.js

@@ -0,0 +1,63 @@
+/**
+ * Maps Mixamo bone names (`mixamorig*`) to VRM humanoid bone names.
+ *
+ * Kept as a `.ts` module rather than a `.json` import on purpose: importing JSON requires
+ * import attributes (`with { type: 'json' }`), which survive into the published ESM build and
+ * break in-browser bundlers like the docs' Sandpack (Babel: "experimental syntax
+ * 'moduleAttributes' isn't currently enabled").
+ */
+const mixamoBoneMap = {
+    mixamorigHips: 'hips',
+    mixamorigSpine: 'spine',
+    mixamorigSpine1: 'chest',
+    mixamorigSpine2: 'upperChest',
+    mixamorigNeck: 'neck',
+    mixamorigHead: 'head',
+    mixamorigLeftShoulder: 'leftShoulder',
+    mixamorigLeftArm: 'leftUpperArm',
+    mixamorigLeftForeArm: 'leftLowerArm',
+    mixamorigLeftHand: 'leftHand',
+    mixamorigLeftHandThumb1: 'leftThumbMetacarpal',
+    mixamorigLeftHandThumb2: 'leftThumbProximal',
+    mixamorigLeftHandThumb3: 'leftThumbDistal',
+    mixamorigLeftHandIndex1: 'leftIndexProximal',
+    mixamorigLeftHandIndex2: 'leftIndexIntermediate',
+    mixamorigLeftHandIndex3: 'leftIndexDistal',
+    mixamorigLeftHandMiddle1: 'leftMiddleProximal',
+    mixamorigLeftHandMiddle2: 'leftMiddleIntermediate',
+    mixamorigLeftHandMiddle3: 'leftMiddleDistal',
+    mixamorigLeftHandRing1: 'leftRingProximal',
+    mixamorigLeftHandRing2: 'leftRingIntermediate',
+    mixamorigLeftHandRing3: 'leftRingDistal',
+    mixamorigLeftHandPinky1: 'leftLittleProximal',
+    mixamorigLeftHandPinky2: 'leftLittleIntermediate',
+    mixamorigLeftHandPinky3: 'leftLittleDistal',
+    mixamorigRightShoulder: 'rightShoulder',
+    mixamorigRightArm: 'rightUpperArm',
+    mixamorigRightForeArm: 'rightLowerArm',
+    mixamorigRightHand: 'rightHand',
+    mixamorigRightHandPinky1: 'rightLittleProximal',
+    mixamorigRightHandPinky2: 'rightLittleIntermediate',
+    mixamorigRightHandPinky3: 'rightLittleDistal',
+    mixamorigRightHandRing1: 'rightRingProximal',
+    mixamorigRightHandRing2: 'rightRingIntermediate',
+    mixamorigRightHandRing3: 'rightRingDistal',
+    mixamorigRightHandMiddle1: 'rightMiddleProximal',
+    mixamorigRightHandMiddle2: 'rightMiddleIntermediate',
+    mixamorigRightHandMiddle3: 'rightMiddleDistal',
+    mixamorigRightHandIndex1: 'rightIndexProximal',
+    mixamorigRightHandIndex2: 'rightIndexIntermediate',
+    mixamorigRightHandIndex3: 'rightIndexDistal',
+    mixamorigRightHandThumb1: 'rightThumbMetacarpal',
+    mixamorigRightHandThumb2: 'rightThumbProximal',
+    mixamorigRightHandThumb3: 'rightThumbDistal',
+    mixamorigLeftUpLeg: 'leftUpperLeg',
+    mixamorigLeftLeg: 'leftLowerLeg',
+    mixamorigLeftFoot: 'leftFoot',
+    mixamorigLeftToeBase: 'leftToes',
+    mixamorigRightUpLeg: 'rightUpperLeg',
+    mixamorigRightLeg: 'rightLowerLeg',
+    mixamorigRightFoot: 'rightFoot',
+    mixamorigRightToeBase: 'rightToes',
+};
+export default mixamoBoneMap;

package/dist/physics/world.js

@@ -1,18 +1,62 @@
-import { Box3, DoubleSide, InstancedMesh, Matrix4, Mesh, Ray, Vector3, } from 'three';
-import { computeBoundsTree, StaticGeometryGenerator, ExtendedTriangle } from 'three-mesh-bvh';
+import { BatchedMesh, Box3, BufferAttribute, BufferGeometry, DoubleSide, InstancedMesh, Matrix4, Mesh, Ray, SkinnedMesh, Vector3, } from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { computeBoundsTree, 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.
+ * Bakes a mesh's collision geometry into `matrix` space. A bvh only needs positions and (optionally) an index, so
+ * everything else is dropped - this keeps the merge below trivial and sidesteps three's "geometries must have the
+ * same attributes" restriction that a body mixing meshes with different attribute sets (e.g. gltf primitives) hits.
+ * Positions are read into a fresh float buffer so interleaved or quantized (e.g. meshopt/draco int) source
+ * attributes are de-interleaved and de-quantized - otherwise applyMatrix4 would overflow the source storage and
+ * mergeGeometries would reject the mismatching layouts.
  */
-function geometryAttributeSignature(geometry) {
-    const attributeNames = Object.keys(geometry.attributes).sort().join(',');
-    return `${geometry.index == null ? 'non-indexed' : 'indexed'}:${attributeNames}`;
+function bakeCollisionGeometry(mesh, matrix) {
+    const source = mesh.geometry.getAttribute('position');
+    const position = new BufferAttribute(new Float32Array(source.count * 3), 3);
+    for (let i = 0; i < source.count; i++) {
+        position.setXYZ(i, source.getX(i), source.getY(i), source.getZ(i));
+    }
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', position);
+    if (mesh.geometry.index != null) {
+        geometry.setIndex(mesh.geometry.index.clone());
+    }
+    return geometry.applyMatrix4(matrix);
+}
+/**
+ * A mesh whose positions are actively displaced by morph targets - its resting geometry doesn't match what's drawn,
+ * so (like a skinned mesh) it is skipped rather than baked into a wrong-shaped collider.
+ */
+function isMorphDeformed(mesh) {
+    return (mesh.geometry.morphAttributes.position != null &&
+        (mesh.morphTargetInfluences?.some((influence) => influence !== 0) ?? false));
+}
+/**
+ * Extracts one geometry of a BatchedMesh into a standalone geometry in its local space. A BatchedMesh packs every
+ * geometry into one shared buffer, so a single bvh over that buffer would collide against all of them at once -
+ * instead each geometry gets its own bvh, referenced per instance with the instance's matrix at query time.
+ */
+function extractBatchedCollisionGeometry(mesh, geometryId) {
+    const range = mesh.getGeometryRangeAt(geometryId);
+    if (range == null) {
+        throw new Error(`BvhPhysicsWorld: BatchedMesh has no geometry ${geometryId}`);
+    }
+    const source = mesh.geometry.getAttribute('position');
+    const index = mesh.geometry.index;
+    const start = index != null ? range.indexStart : range.vertexStart;
+    const count = index != null ? range.indexCount : range.vertexCount;
+    const position = new BufferAttribute(new Float32Array(count * 3), 3);
+    for (let i = 0; i < count; i++) {
+        const vertexIndex = index != null ? index.getX(start + i) : start + i;
+        position.setXYZ(i, source.getX(vertexIndex), source.getY(vertexIndex), source.getZ(vertexIndex));
+    }
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', position);
+    return geometry;
 }
 export class BvhPhysicsWorld {
     bodies = [];
@@ -38,15 +82,23 @@ export class BvhPhysicsWorld {
     }
     computeBvhEntries(object, isStatic) {
         object.updateWorldMatrix(true, true);
+        //Static bodies are baked in world space; kinematic bodies are baked in the body's local space so that its
+        //(changing) world matrix can be applied at query time instead (see computeMatrix), hence the inverse here.
+        const worldToBakeSpace = isStatic ? undefined : new Matrix4().copy(object.matrixWorld).invert();
+        const bakeMatrix = new Matrix4();
         const result = [];
-        //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) => {
+        //A merge of collision geometries only works when they agree on being indexed, so keep indexed and
+        //non-indexed meshes apart and turn each group into its own bvh.
+        const indexedGeometries = [];
+        const nonIndexedGeometries = [];
+        //traverseVisible so hidden meshes (toggled decorations, LODs) don't silently become colliders.
+        object.traverseVisible((entry) => {
             if (entry instanceof InstancedMesh) {
                 const bvh = computeBoundsTree.apply(entry.geometry);
-                result.push(...Array.from({ length: entry.instanceMatrix.count }, (_, instanceIndex) => ({
+                result.push(
+                //entry.count (active instances), not instanceMatrix.count (allocated capacity), to avoid phantom
+                //colliders at the stale matrices of unused instance slots.
+                ...Array.from({ length: entry.count }, (_, instanceIndex) => ({
                     object: entry,
                     bvh,
                     instanceIndex,
@@ -54,30 +106,47 @@ export class BvhPhysicsWorld {
                 })));
                 return;
             }
-            if (entry instanceof Mesh) {
-                const signature = geometryAttributeSignature(entry.geometry);
-                let group = meshGroups.get(signature);
-                if (group == null) {
-                    meshGroups.set(signature, (group = []));
+            if (entry instanceof BatchedMesh) {
+                //Each geometry in the batch gets its own bvh, referenced once per visible instance with the instance's
+                //matrix applied at query time (like InstancedMesh). Instances deleted before addBody aren't handled -
+                //three offers no way to enumerate active instances across the gaps a deletion leaves.
+                const geometryBvhs = new Map();
+                for (let instanceIndex = 0; instanceIndex < entry.instanceCount; instanceIndex++) {
+                    if (!entry.getVisibleAt(instanceIndex)) {
+                        continue;
+                    }
+                    const geometryId = entry.getGeometryIdAt(instanceIndex);
+                    let bvh = geometryBvhs.get(geometryId);
+                    if (bvh == null) {
+                        bvh = computeBoundsTree.apply(extractBatchedCollisionGeometry(entry, geometryId));
+                        geometryBvhs.set(geometryId, bvh);
+                    }
+                    result.push({ object: entry, bvh, instanceIndex, isStatic });
                 }
-                group.push(entry);
+                return;
             }
-        });
-        if (meshGroups.size > 0) {
-            const parent = object.parent;
-            if (!isStatic) {
-                object.parent = null;
-                object.updateMatrixWorld(true);
+            //skip skinned and morph-deformed meshes (their shape comes from per-vertex deformation a single baked
+            //matrix can't capture - use a primitive collider) and meshes that have no positions to collide against.
+            if (!(entry instanceof Mesh) ||
+                entry instanceof SkinnedMesh ||
+                isMorphDeformed(entry) ||
+                entry.geometry.getAttribute('position') == null) {
+                return;
             }
-            for (const meshes of meshGroups.values()) {
-                const geometry = new StaticGeometryGenerator(meshes).generate();
-                const bvh = computeBoundsTree.apply(geometry);
-                result.push({ object, bvh, isStatic });
+            bakeMatrix.copy(entry.matrixWorld);
+            if (worldToBakeSpace != null) {
+                bakeMatrix.premultiply(worldToBakeSpace);
             }
-            if (!isStatic) {
-                object.parent = parent;
-                object.updateMatrixWorld(true);
+            const geometry = bakeCollisionGeometry(entry, bakeMatrix);
+            (geometry.index == null ? nonIndexedGeometries : indexedGeometries).push(geometry);
+        });
+        for (const geometries of [indexedGeometries, nonIndexedGeometries]) {
+            if (geometries.length === 0) {
+                continue;
             }
+            const geometry = geometries.length === 1 ? geometries[0] : mergeGeometries(geometries);
+            const bvh = computeBoundsTree.apply(geometry);
+            result.push({ object, bvh, isStatic });
         }
         return result;
     }

package/package.json

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

package/dist/animation/bvh-bone-map.json

@@ -1,24 +0,0 @@
-{
-    "Hips": "hips",
-    "Spine": "spine",
-    "Spine1": "chest",
-    "Spine2": "upperChest",
-    "Neck": "neck",
-    "Head": "head",
-    "LeftShoulder": "leftShoulder",
-    "LeftArm": "leftUpperArm",
-    "LeftForeArm": "leftLowerArm",
-    "LeftHand": "leftHand",
-    "RightShoulder": "rightShoulder",
-    "RightArm": "rightUpperArm",
-    "RightForeArm": "rightLowerArm",
-    "RightHand": "rightHand",
-    "LeftUpLeg": "leftUpperLeg",
-    "LeftLeg": "leftLowerLeg",
-    "LeftFoot": "leftFoot",
-    "LeftToe": "leftToes",
-    "RightUpLeg": "rightUpperLeg",
-    "RightLeg": "rightLowerLeg",
-    "RightFoot": "rightFoot",
-    "RightToe": "rightToes"
-}

package/dist/animation/mixamo-bone-map.json

@@ -1,54 +0,0 @@
-{
-    "mixamorigHips": "hips",
-    "mixamorigSpine": "spine",
-    "mixamorigSpine1": "chest",
-    "mixamorigSpine2": "upperChest",
-    "mixamorigNeck": "neck",
-    "mixamorigHead": "head",
-    "mixamorigLeftShoulder": "leftShoulder",
-    "mixamorigLeftArm": "leftUpperArm",
-    "mixamorigLeftForeArm": "leftLowerArm",
-    "mixamorigLeftHand": "leftHand",
-    "mixamorigLeftHandThumb1": "leftThumbMetacarpal",
-    "mixamorigLeftHandThumb2": "leftThumbProximal",
-    "mixamorigLeftHandThumb3": "leftThumbDistal",
-    "mixamorigLeftHandIndex1": "leftIndexProximal",
-    "mixamorigLeftHandIndex2": "leftIndexIntermediate",
-    "mixamorigLeftHandIndex3": "leftIndexDistal",
-    "mixamorigLeftHandMiddle1": "leftMiddleProximal",
-    "mixamorigLeftHandMiddle2": "leftMiddleIntermediate",
-    "mixamorigLeftHandMiddle3": "leftMiddleDistal",
-    "mixamorigLeftHandRing1": "leftRingProximal",
-    "mixamorigLeftHandRing2": "leftRingIntermediate",
-    "mixamorigLeftHandRing3": "leftRingDistal",
-    "mixamorigLeftHandPinky1": "leftLittleProximal",
-    "mixamorigLeftHandPinky2": "leftLittleIntermediate",
-    "mixamorigLeftHandPinky3": "leftLittleDistal",
-    "mixamorigRightShoulder": "rightShoulder",
-    "mixamorigRightArm": "rightUpperArm",
-    "mixamorigRightForeArm": "rightLowerArm",
-    "mixamorigRightHand": "rightHand",
-    "mixamorigRightHandPinky1": "rightLittleProximal",
-    "mixamorigRightHandPinky2": "rightLittleIntermediate",
-    "mixamorigRightHandPinky3": "rightLittleDistal",
-    "mixamorigRightHandRing1": "rightRingProximal",
-    "mixamorigRightHandRing2": "rightRingIntermediate",
-    "mixamorigRightHandRing3": "rightRingDistal",
-    "mixamorigRightHandMiddle1": "rightMiddleProximal",
-    "mixamorigRightHandMiddle2": "rightMiddleIntermediate",
-    "mixamorigRightHandMiddle3": "rightMiddleDistal",
-    "mixamorigRightHandIndex1": "rightIndexProximal",
-    "mixamorigRightHandIndex2": "rightIndexIntermediate",
-    "mixamorigRightHandIndex3": "rightIndexDistal",
-    "mixamorigRightHandThumb1": "rightThumbMetacarpal",
-    "mixamorigRightHandThumb2": "rightThumbProximal",
-    "mixamorigRightHandThumb3": "rightThumbDistal",
-    "mixamorigLeftUpLeg": "leftUpperLeg",
-    "mixamorigLeftLeg": "leftLowerLeg",
-    "mixamorigLeftFoot": "leftFoot",
-    "mixamorigLeftToeBase": "leftToes",
-    "mixamorigRightUpLeg": "rightUpperLeg",
-    "mixamorigRightLeg": "rightLowerLeg",
-    "mixamorigRightFoot": "rightFoot",
-    "mixamorigRightToeBase": "rightToes"
-}