@pmndrs/viverse 0.1.14 → 0.1.16

package/dist/physics/index.d.ts

@@ -38,6 +38,9 @@ export declare class BvhCharacterPhysics {
     private readonly stateVelocity;
     readonly inputVelocity: Vector3;
     private notGroundedSeconds;
+    private readonly segment;
+    private readonly aabbox;
+    private radius;
     get isGrounded(): boolean;
     constructor(character: Object3D, world: BvhPhysicsWorld);
     applyVelocity(velocity: Vector3): void;
@@ -45,6 +48,7 @@ export declare class BvhCharacterPhysics {
      * @param delta in seconds
      */
     update(fullDelta: number, options?: BvhCharacterPhysicsOptions): void;
+    private updateBoundingShapes;
     destroy(): void;
     shapecastCapsule(position: Vector3, maxGroundSlope: number, options: Exclude<BvhCharacterPhysicsOptions, boolean>): boolean;
 }

package/dist/physics/index.js

@@ -1,10 +1,8 @@
 import { Box3, Line3, Matrix4, Vector3 } from 'three';
 //for this is a kinematic character controller
-//helper variables
-const aabbox = new Box3();
-const segment = new Line3();
 const triPoint = new Vector3();
 const capsulePoint = new Vector3();
+const centerHelper = new Vector3();
 const collisionFreePosition = new Vector3();
 const position = new Vector3();
 const invertedParentMatrix = new Matrix4();
@@ -19,6 +17,9 @@ export class BvhCharacterPhysics {
     stateVelocity = new Vector3();
     inputVelocity = new Vector3();
     notGroundedSeconds = 0;
+    segment = new Line3();
+    aabbox = new Box3();
+    radius = 0;
     get isGrounded() {
         return this.notGroundedSeconds < 0.2;
     }
@@ -82,49 +83,56 @@ export class BvhCharacterPhysics {
                 this.stateVelocity.set(0, (options.gravity ?? -20) * 0.01, 0);
             }
         }
+        this.updateBoundingShapes(options);
+        centerHelper.addVectors(this.segment.start, this.segment.end).multiplyScalar(0.5);
+        this.world.updateSensors(centerHelper, (bounds) => bounds.intersectsBox(this.aabbox), (triangle) => triangle.closestPointToSegment(this.segment) < this.radius);
+    }
+    updateBoundingShapes(options) {
+        //compute the bounding capsule and bounding box
+        this.radius = options.capsuleRadius ?? 0.4;
+        const height = options.capsuleHeight ?? 1.7;
+        this.segment.start.copy(position);
+        this.segment.start.y += this.radius;
+        this.segment.end.copy(position);
+        this.segment.end.y += height - this.radius;
+        this.aabbox.makeEmpty();
+        this.aabbox.expandByPoint(this.segment.start);
+        this.aabbox.expandByPoint(this.segment.end);
+        this.aabbox.min.addScalar(-this.radius);
+        this.aabbox.max.addScalar(this.radius);
     }
     destroy() {
         this.destroyed = true;
     }
     shapecastCapsule(position, maxGroundSlope, options) {
-        const radius = options.capsuleRadius ?? 0.4;
-        const height = options.capsuleHeight ?? 1.7;
-        segment.start.copy(position);
-        segment.start.y += radius;
-        segment.end.copy(position);
-        segment.end.y += height - radius;
-        aabbox.makeEmpty();
-        aabbox.expandByPoint(segment.start);
-        aabbox.expandByPoint(segment.end);
-        aabbox.min.addScalar(-radius);
-        aabbox.max.addScalar(radius);
+        this.updateBoundingShapes(options);
         let grounded = false;
-        this.world.shapecast((bounds) => bounds.intersectsBox(aabbox), (tri) => {
+        this.world.shapecast((bounds) => bounds.intersectsBox(this.aabbox), (tri) => {
             // Use your existing triangle vs segment closestPointToSegment
-            const distance = tri.closestPointToSegment(segment, triPoint, capsulePoint);
+            const distance = tri.closestPointToSegment(this.segment, triPoint, capsulePoint);
             if (distance === 0) {
-                const isCloserToSegmentStart = capsulePoint.distanceTo(segment.start) < capsulePoint.distanceTo(segment.end);
+                const isCloserToSegmentStart = capsulePoint.distanceTo(this.segment.start) < capsulePoint.distanceTo(this.segment.end);
                 if (isCloserToSegmentStart) {
                     grounded = true;
                 }
-                const scaledDirection = capsulePoint.sub(isCloserToSegmentStart ? segment.start : segment.end);
-                scaledDirection.y += radius;
-                segment.start.add(scaledDirection);
-                segment.end.add(scaledDirection);
+                const scaledDirection = capsulePoint.sub(isCloserToSegmentStart ? this.segment.start : this.segment.end);
+                scaledDirection.y += this.radius;
+                this.segment.start.add(scaledDirection);
+                this.segment.end.add(scaledDirection);
             }
-            else if (distance < radius) {
-                const depthInsideCapsule = radius - distance;
+            else if (distance < this.radius) {
+                const depthInsideCapsule = this.radius - distance;
                 const direction = capsulePoint.sub(triPoint).divideScalar(distance);
                 const slope = Math.tan(Math.acos(direction.dot(YAxis)));
                 if (direction.y > 0 && slope <= maxGroundSlope) {
                     grounded = true;
                 }
-                segment.start.addScaledVector(direction, depthInsideCapsule);
-                segment.end.addScaledVector(direction, depthInsideCapsule);
+                this.segment.start.addScaledVector(direction, depthInsideCapsule);
+                this.segment.end.addScaledVector(direction, depthInsideCapsule);
             }
         });
-        position.copy(segment.start);
-        position.y -= radius;
+        position.copy(this.segment.start);
+        position.y -= this.radius;
         return grounded;
     }
 }

package/dist/physics/world.d.ts

@@ -1,14 +1,20 @@
-import { Box3, Object3D, Ray } from 'three';
+import { Box3, Object3D, Ray, Vector3 } from 'three';
 import { ExtendedTriangle } from 'three-mesh-bvh';
 export declare class BvhPhysicsWorld {
-    private map;
+    private bodies;
+    private sensors;
     /**
      * @deprecated use addBody(object, false) instead
      */
     addFixedBody(object: Object3D): void;
+    addSensor(object: Object3D, isStatic: boolean, onIntersectedChanged: (intersected: boolean) => void): void;
+    removeSensor(object: Object3D): void;
     addBody(object: Object3D, kinematic: boolean): void;
+    private computeBvhEntries;
     removeBody(object: Object3D): void;
     private computeMatrix;
+    updateSensors(playerCenter: Vector3, intersectsBounds: (box: Box3) => boolean, intersectsTriangle: (triangle: ExtendedTriangle) => boolean): void;
     shapecast(intersectsBounds: (box: Box3) => boolean, intersectsTriangle: (triangle: ExtendedTriangle) => void): void;
+    private shapecastEntry;
     raycast(ray: Ray, far: number): number | undefined;
 }

package/dist/physics/world.js

@@ -1,4 +1,4 @@
-import { Box3, InstancedMesh, Matrix4, Ray, Vector3 } from 'three';
+import { Box3, DoubleSide, InstancedMesh, Matrix4, Ray, Vector3 } from 'three';
 import { computeBoundsTree, StaticGeometryGenerator, ExtendedTriangle } from 'three-mesh-bvh';
 const rayHelper = new Ray();
 const farPointHelper = new Vector3();
@@ -6,47 +6,59 @@ const boxHelper = new Box3();
 const triangleHelper = new ExtendedTriangle();
 const matrixHelper = new Matrix4();
 export class BvhPhysicsWorld {
-    map = [];
+    bodies = [];
+    sensors = [];
     /**
      * @deprecated use addBody(object, false) instead
      */
     addFixedBody(object) {
         this.addBody(object, false);
     }
+    addSensor(object, isStatic, onIntersectedChanged) {
+        this.sensors.push(...this.computeBvhEntries(object, isStatic).map((entry) => ({
+            ...entry,
+            onIntersectedChanged,
+            intersected: false,
+        })));
+    }
+    removeSensor(object) {
+        this.sensors = this.sensors.filter((entry) => entry.object != object);
+    }
     addBody(object, kinematic) {
+        this.bodies.push(...this.computeBvhEntries(object, !kinematic));
+    }
+    computeBvhEntries(object, isStatic) {
         object.updateWorldMatrix(true, true);
         if (!(object instanceof InstancedMesh)) {
             const parent = object.parent;
-            if (kinematic) {
+            if (!isStatic) {
                 object.parent = null;
                 object.updateMatrixWorld(true);
             }
             const geometry = new StaticGeometryGenerator(object).generate();
-            this.map.push({ object, bvh: computeBoundsTree.apply(geometry), kinematic });
-            if (kinematic) {
+            const bvh = computeBoundsTree.apply(geometry);
+            if (!isStatic) {
                 object.parent = parent;
                 object.updateMatrixWorld(true);
             }
-            return;
+            return [{ object, bvh, isStatic }];
         }
         if (object.children.length > 0) {
             throw new Error(`cannot add InstancedMesh with children`);
         }
         const bvh = computeBoundsTree.apply(object.geometry);
-        for (let i = 0; i < object.instanceMatrix.count; i++) {
-            this.map.push({
-                object,
-                bvh,
-                instanceIndex: i,
-                kinematic,
-            });
-        }
+        return new Array(object.instanceMatrix).fill(undefined).map((_, i) => ({
+            object,
+            bvh,
+            instanceIndex: i,
+            isStatic,
+        }));
     }
     removeBody(object) {
-        this.map = this.map.filter((entry) => entry.object != object);
+        this.bodies = this.bodies.filter((entry) => entry.object != object);
     }
-    computeMatrix({ kinematic, object, instanceIndex }, target) {
-        if (!kinematic && instanceIndex == null) {
+    computeMatrix({ isStatic, object, instanceIndex }, target) {
+        if (isStatic && instanceIndex == null) {
             return false;
         }
         if (instanceIndex == null) {
@@ -58,31 +70,57 @@ export class BvhPhysicsWorld {
         target.premultiply(object.matrixWorld);
         return true;
     }
+    updateSensors(playerCenter, intersectsBounds, intersectsTriangle) {
+        for (const entry of this.sensors) {
+            //check surface intersection
+            let intersected = this.shapecastEntry(entry, intersectsBounds, intersectsTriangle);
+            if (!intersected) {
+                //check if we are entirely inside
+                rayHelper.origin.copy(playerCenter);
+                rayHelper.direction.set(0, -1, 0);
+                if (this.computeMatrix(entry, matrixHelper)) {
+                    matrixHelper.invert();
+                    rayHelper.applyMatrix4(matrixHelper);
+                }
+                intersected = entry.bvh.raycast(rayHelper, DoubleSide).length % 2 == 1;
+            }
+            if (entry.intersected === intersected) {
+                continue;
+            }
+            entry.onIntersectedChanged(intersected);
+            entry.intersected = intersected;
+        }
+    }
     shapecast(intersectsBounds, intersectsTriangle) {
-        for (const entry of this.map) {
-            entry.bvh.shapecast({
-                intersectsBounds: (box) => {
-                    boxHelper.copy(box);
-                    if (this.computeMatrix(entry, matrixHelper)) {
-                        boxHelper.applyMatrix4(matrixHelper);
-                    }
-                    return intersectsBounds(boxHelper);
-                },
-                intersectsTriangle: (triangle) => {
-                    triangleHelper.copy(triangle);
-                    if (this.computeMatrix(entry, matrixHelper)) {
-                        triangleHelper.a.applyMatrix4(matrixHelper);
-                        triangleHelper.b.applyMatrix4(matrixHelper);
-                        triangleHelper.c.applyMatrix4(matrixHelper);
-                    }
-                    intersectsTriangle(triangleHelper);
-                },
-            });
+        for (const entry of this.bodies) {
+            this.shapecastEntry(entry, intersectsBounds, intersectsTriangle);
         }
     }
+    shapecastEntry(entry, intersectsBounds, intersectsTriangle) {
+        return entry.bvh.shapecast({
+            intersectsBounds: (box) => {
+                boxHelper.copy(box);
+                if (this.computeMatrix(entry, matrixHelper)) {
+                    boxHelper.applyMatrix4(matrixHelper);
+                }
+                return intersectsBounds(boxHelper);
+            },
+            intersectsTriangle: (triangle) => {
+                triangleHelper.copy(triangle);
+                if (this.computeMatrix(entry, matrixHelper)) {
+                    triangleHelper.a.applyMatrix4(matrixHelper);
+                    triangleHelper.b.applyMatrix4(matrixHelper);
+                    triangleHelper.c.applyMatrix4(matrixHelper);
+                }
+                if (intersectsTriangle(triangleHelper) === true) {
+                    return true;
+                }
+            },
+        });
+    }
     raycast(ray, far) {
         let result;
-        for (const entry of this.map.values()) {
+        for (const entry of this.bodies.values()) {
             rayHelper.copy(ray);
             let farHelper = far;
             if (this.computeMatrix(entry, matrixHelper)) {

package/package.json

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