@onerjs/core 8.32.0 → 8.32.2

package/Physics/v2/characterController.d.ts

@@ -1,8 +1,9 @@
 import { Vector3, Matrix } from "../../Maths/math.vector.js";
 import type { Scene } from "../../scene.js";
 import type { DeepImmutableObject } from "../../types.js";
-import type { PhysicsBody } from "./physicsBody.js";
+import { PhysicsBody } from "./physicsBody.js";
 import { type PhysicsShape } from "./physicsShape.js";
+import { Observable } from "../../Misc/observable.js";
 /**
  * Shape properties for the character controller
  */
@@ -20,6 +21,27 @@ export interface CharacterShapeOptions {
      */
     capsuleRadius?: number;
 }
+/**
+ * Collision event data for the character controller
+ */
+export interface ICharacterControllerCollisionEvent {
+    /**
+     * The collider physics body
+     */
+    collider: PhysicsBody;
+    /**
+     *
+     */
+    colliderIndex: number;
+    /**
+     * Separation force applied to the collider
+     */
+    impulse: Vector3;
+    /**
+     * Position where the impulse is applied
+     */
+    impulsePosition: Vector3;
+}
 /**
  * State of the character on the surface
  */
@@ -158,6 +180,8 @@ export declare class PhysicsCharacterController {
     private _velocity;
     private _lastVelocity;
     private _shape;
+    private _body;
+    private _transformNode;
     private _ownShape;
     private _manifold;
     private _lastDisplacement;
@@ -229,8 +253,13 @@ export declare class PhysicsCharacterController {
      * default 0
      */
     characterMass: number;
+    /**
+     * Observable for trigger entered and trigger exited events
+     */
+    onTriggerCollisionObservable: Observable<ICharacterControllerCollisionEvent>;
     private _startCollector;
     private _castCollector;
+    private _displacementEps;
     /**
      * instanciate a new characterController
      * @param position Initial position
@@ -238,6 +267,10 @@ export declare class PhysicsCharacterController {
      * @param scene Scene
      */
     constructor(position: Vector3, characterShapeOptions: CharacterShapeOptions, scene: Scene);
+    /**
+     * Dispose the character controller
+     */
+    dispose(): void;
     /**
      * Get shape used for collision
      */
@@ -271,7 +304,8 @@ export declare class PhysicsCharacterController {
     protected _compareContacts(contactA: IContact, contactB: IContact): number;
     protected _findContact(referenceContact: IContact, contactList: IContact[], threshold: number): number;
     protected _updateManifold(startCollector: any, castCollector: any, castPath: Vector3): number;
-    protected _createSurfaceConstraint(contact: IContact, timeTravelled: number): ISurfaceConstraintInfo;
+    protected _bodyPositionTracking: Map<any, any>;
+    protected _createSurfaceConstraint(dt: number, contact: IContact, timeTravelled: number): ISurfaceConstraintInfo;
     protected _addMaxSlopePlane(maxSlopeCos: number, up: Vector3, index: number, constraints: ISurfaceConstraintInfo[], allowedPenetration: number): boolean;
     protected _resolveConstraintPenetration(constraint: ISurfaceConstraintInfo, penetrationRecoverySpeed: number): void;
     protected _createConstraintsFromManifold(dt: number, timeTravelled: number): ISurfaceConstraintInfo[];
@@ -310,6 +344,12 @@ export declare class PhysicsCharacterController {
         body: PhysicsBody;
         index: number;
     }): number;
+    protected _integrateManifolds(deltaTime: number, gravity: Vector3): void;
+    /**
+     * Move the character with collisions
+     * @param displacement defines the requested displacement vector
+     */
+    moveWithCollisions(displacement: Vector3): void;
     /**
      * Update internal state. Must be called once per frame
      * @param deltaTime frame delta time in seconds. When using scene.deltaTime divide by 1000.0

package/Physics/v2/characterController.js

@@ -1,6 +1,9 @@
 import { Vector3, Quaternion, Matrix, TmpVectors } from "../../Maths/math.vector.js";
+import { PhysicsBody } from "./physicsBody.js";
 import { PhysicsShapeCapsule } from "./physicsShape.js";
 import { BuildArray } from "../../Misc/arrayTools.js";
+import { TransformNode } from "../../Meshes/transformNode.js";
+import { Observable } from "../../Misc/observable.js";
 /**
  * State of the character on the surface
  */
@@ -72,7 +75,7 @@ export class PhysicsCharacterController {
         this._manifold = [];
         this._contactAngleSensitivity = 10.0;
         this._tmpMatrix = new Matrix();
-        this._tmpVecs = BuildArray(31, Vector3.Zero);
+        this._tmpVecs = BuildArray(32, Vector3.Zero);
         /**
          * minimum distance to make contact
          * default 0.05
@@ -136,6 +139,15 @@ export class PhysicsCharacterController {
          * default 0
          */
         this.characterMass = 0;
+        /**
+         * Observable for trigger entered and trigger exited events
+         */
+        this.onTriggerCollisionObservable = new Observable();
+        // If the difference between the cast displacement and the simplex solver output position is less than this
+        // value (per component), do not do a second cast to check if it's possible to reach the output position.
+        this._displacementEps = 1e-4;
+        // Store previous positions per body for velocity calculation
+        this._bodyPositionTracking = new Map();
         this._position = position.clone();
         this._velocity = Vector3.Zero();
         this._lastVelocity = Vector3.Zero();
@@ -145,6 +157,12 @@ export class PhysicsCharacterController {
         this._tmpVecs[1].set(0, -h * 0.5 + r, 0);
         this._ownShape = !characterShapeOptions.shape;
         this._shape = characterShapeOptions.shape ?? new PhysicsShapeCapsule(this._tmpVecs[0], this._tmpVecs[1], r, scene);
+        this._transformNode = new TransformNode("CCTransformNode", scene);
+        this._transformNode.position.copyFrom(this._position);
+        this._body = new PhysicsBody(this._transformNode, 1 /* PhysicsMotionType.ANIMATED */, false, scene);
+        this._body.setMassProperties({ inertia: Vector3.ZeroReadOnly });
+        this._body.shape = this._shape;
+        this._body.disablePreStep = false;
         this._lastInvDeltaTime = 1.0 / 60.0;
         this._lastDisplacement = Vector3.Zero();
         this._scene = scene;
@@ -153,6 +171,20 @@ export class PhysicsCharacterController {
         this._startCollector = hknp.HP_QueryCollector_Create(16)[1];
         this._castCollector = hknp.HP_QueryCollector_Create(16)[1];
     }
+    /**
+     * Dispose the character controller
+     */
+    dispose() {
+        if (this._ownShape) {
+            this._shape.dispose();
+        }
+        this._body.dispose();
+        this._transformNode.dispose();
+        const hk = this._scene.getPhysicsEngine().getPhysicsPlugin();
+        const hknp = hk._hknp;
+        hknp.HP_QueryCollector_Release(this._startCollector);
+        hknp.HP_QueryCollector_Release(this._castCollector);
+    }
     /**
      * Get shape used for collision
      */
@@ -163,6 +195,7 @@ export class PhysicsCharacterController {
      * Set shape used for collision
      */
     set shape(value) {
+        this._body.shape = this._shape;
         if (this._ownShape) {
             this._shape.dispose();
         }
@@ -182,6 +215,7 @@ export class PhysicsCharacterController {
      */
     setPosition(position) {
         this._position.copyFrom(position);
+        this._transformNode.position.copyFrom(this._position);
     }
     /**
      * Character velocity
@@ -333,7 +367,7 @@ export class PhysicsCharacterController {
         }
         return numHitBodies;
     }
-    _createSurfaceConstraint(contact, timeTravelled) {
+    _createSurfaceConstraint(dt, contact, timeTravelled) {
         const constraint = {
             //let distance = contact.distance - this.keepDistance;
             planeNormal: contact.normal.clone(),
@@ -369,7 +403,42 @@ export class PhysicsCharacterController {
             constraint.priority = 2;
         }
         else if (motionType == 1 /* PhysicsMotionType.ANIMATED */) {
-            constraint.priority = 1;
+            const bodyTransformNode = contact.bodyB.body.transformNode;
+            const bodyId = bodyTransformNode.uniqueId;
+            // Retrieve tracking data
+            let tracking = this._bodyPositionTracking.get(bodyId);
+            const currentFrameWorldMatrix = contact.bodyB.body.transformNode.getWorldMatrix();
+            const frameId = this._scene.getFrameId();
+            if (!tracking) {
+                // Initialize tracking
+                tracking = {
+                    prevWorldMatrix: currentFrameWorldMatrix.clone(),
+                    frameId: frameId,
+                };
+                this._bodyPositionTracking.set(bodyId, tracking);
+            }
+            else {
+                // Only calculate velocity if this contact existed in the previous frame
+                // This avoids huge delta spikes when first making contact or after gaps
+                if (tracking.frameId + 1 === frameId) {
+                    const previousFrameWorldMatrix = tracking.prevWorldMatrix;
+                    const currentFrameWorldMatrixInverse = TmpVectors.Matrix[1];
+                    currentFrameWorldMatrix.invertToRef(currentFrameWorldMatrixInverse);
+                    const characterPosition = this.getPosition();
+                    // compute characterPosition in body local space at previous frame
+                    const characterLocalPosition = this._tmpVecs[21];
+                    Vector3.TransformCoordinatesToRef(characterPosition, currentFrameWorldMatrixInverse, characterLocalPosition);
+                    const characterWorldPosition = this._tmpVecs[22];
+                    Vector3.TransformCoordinatesToRef(characterLocalPosition, previousFrameWorldMatrix, characterWorldPosition);
+                    const playerDeltaPosition = this._tmpVecs[23];
+                    characterPosition.subtractToRef(characterWorldPosition, playerDeltaPosition);
+                    constraint.velocity.copyFrom(playerDeltaPosition);
+                    constraint.velocity.scaleInPlace(1 / dt);
+                    constraint.priority = 1;
+                }
+                tracking.prevWorldMatrix.copyFrom(currentFrameWorldMatrix);
+                tracking.frameId = frameId;
+            }
         }
         return constraint;
     }
@@ -415,7 +484,7 @@ export class PhysicsCharacterController {
     _createConstraintsFromManifold(dt, timeTravelled) {
         const constraints = [];
         for (let i = 0; i < this._manifold.length; i++) {
-            const surfaceConstraint = this._createSurfaceConstraint(this._manifold[i], timeTravelled);
+            const surfaceConstraint = this._createSurfaceConstraint(dt, this._manifold[i], timeTravelled);
             constraints.push(surfaceConstraint);
             this._addMaxSlopePlane(this.maxSlopeCosine, this.up, i, constraints, this._manifold[i].allowedPenetration);
             this._resolveConstraintPenetration(surfaceConstraint, this.penetrationRecoverySpeed);
@@ -982,7 +1051,7 @@ export class PhysicsCharacterController {
                 orientation,
                 this.keepDistance + this.keepContactTolerance, // max distance
                 false, // should hit triggers
-                [BigInt(0)], // body to ignore //<todo allow for a proxy body!
+                [this._body._pluginData.hpBodyId[0]],
             ];
             hknp.HP_World_ShapeProximityWithCollector(hk.world, startCollector, query);
         }
@@ -993,7 +1062,7 @@ export class PhysicsCharacterController {
                 startNative,
                 [endPos.x, endPos.y, endPos.z],
                 false, // should hit triggers
-                [BigInt(0)], // body to ignore //<todo allow for proxy body
+                [this._body._pluginData.hpBodyId[0]],
             ];
             hknp.HP_World_ShapeCastWithCollector(hk.world, castCollector, query);
         }
@@ -1069,6 +1138,13 @@ export class PhysicsCharacterController {
                     }
                 }
                 //<todo Fire callback to allow user to change impulse + use the info / play sounds
+                const triggerCollisionInfo = {
+                    collider: bodyB.body,
+                    colliderIndex: bodyB.index,
+                    impulse: outputObjectImpulse,
+                    impulsePosition: outputImpulsePosition,
+                };
+                this.onTriggerCollisionObservable.notifyObservers(triggerCollisionInfo);
                 bodyB.body.applyImpulse(outputObjectImpulse, outputImpulsePosition, bodyB.index);
             }
         }
@@ -1096,47 +1172,11 @@ export class PhysicsCharacterController {
     _getInvMass(body) {
         return 1 / body.body.getMassProperties(body.index).mass;
     }
-    /**
-     * Update internal state. Must be called once per frame
-     * @param deltaTime frame delta time in seconds. When using scene.deltaTime divide by 1000.0
-     * @param surfaceInfo surface information returned by checkSupport
-     * @param gravity gravity applied to the character. Can be different that world gravity
-     */
-    integrate(deltaTime, surfaceInfo, gravity) {
+    _integrateManifolds(deltaTime, gravity) {
         const hk = this._scene.getPhysicsEngine().getPhysicsPlugin();
-        const invDeltaTime = 1 / deltaTime;
-        let remainingTime = deltaTime;
-        let newVelocity = Vector3.Zero();
-        // If the difference between the cast displacement and the simplex solver output position is less than this
-        // value (per component), do not do a second cast to check if it's possible to reach the output position.
-        const displacementEps = 1e-4;
         const epsSqrd = 1e-8;
-        // Choose the first cast direction.  If velocity hasn't changed from the previous integrate, guess that the
-        // displacement will be the same as last integrate, scaled by relative step length.  Otherwise, guess based
-        // on current velocity.
-        {
-            const tolerance = displacementEps * invDeltaTime;
-            if (this._velocity.equalsWithEpsilon(this._lastVelocity, tolerance)) {
-                this._lastDisplacement.scaleInPlace(remainingTime * this._lastInvDeltaTime);
-            }
-            else {
-                const displacementVelocity = this._velocity;
-                if (surfaceInfo.supportedState == 2 /* CharacterSupportedState.SUPPORTED */) {
-                    const relativeVelocity = this._tmpVecs[28];
-                    this._velocity.subtractToRef(surfaceInfo.averageSurfaceVelocity, relativeVelocity);
-                    const normalDotVelocity = surfaceInfo.averageSurfaceNormal.dot(relativeVelocity);
-                    if (normalDotVelocity < 0) {
-                        relativeVelocity.subtractInPlace(surfaceInfo.averageSurfaceNormal.scale(normalDotVelocity));
-                        displacementVelocity.copyFrom(relativeVelocity);
-                        displacementVelocity.addInPlace(surfaceInfo.averageSurfaceVelocity);
-                    }
-                }
-                this._lastDisplacement.copyFrom(displacementVelocity);
-                this._lastDisplacement.scaleInPlace(remainingTime);
-            }
-            this._lastVelocity.copyFrom(this._velocity);
-            this._lastInvDeltaTime = invDeltaTime;
-        }
+        let newVelocity = Vector3.Zero();
+        let remainingTime = deltaTime;
         // Make sure that contact with bodies that have been removed since the call to checkSupport() are removed from the
         // manifold
         this._validateManifold();
@@ -1158,7 +1198,7 @@ export class PhysicsCharacterController {
             // If castCollector had hits on different bodies (so we're not sure if some non-closest body could be in our way) OR
             // the simplex has given an output direction different from the cast guess
             // we re-cast to check we can move there. There is no need to get the start points again.
-            if (updateResult != 0 || (newDisplacement.lengthSquared() > epsSqrd && !this._lastDisplacement.equalsWithEpsilon(newDisplacement, displacementEps))) {
+            if (updateResult != 0 || (newDisplacement.lengthSquared() > epsSqrd && !this._lastDisplacement.equalsWithEpsilon(newDisplacement, this._displacementEps))) {
                 this._castWithCollectors(this._position, this._position.add(newDisplacement), this._castCollector, this._startCollector);
                 const hknp = hk._hknp;
                 const numCastHits = hknp.HP_QueryCollector_GetNumHits(this._castCollector)[1];
@@ -1198,6 +1238,60 @@ export class PhysicsCharacterController {
             this._lastDisplacement.copyFrom(newDisplacement);
         }
         this._velocity.copyFrom(newVelocity);
+        this._transformNode.position.copyFrom(this._position);
+    }
+    /**
+     * Move the character with collisions
+     * @param displacement defines the requested displacement vector
+     */
+    moveWithCollisions(displacement) {
+        if (this._scene.deltaTime == undefined) {
+            return;
+        }
+        const deltaTime = this._scene.deltaTime / 1000.0;
+        const invDeltaTime = 1 / deltaTime;
+        displacement.scaleToRef(1 / deltaTime, this._velocity);
+        this._lastDisplacement.copyFrom(displacement);
+        this._lastVelocity.copyFrom(this._velocity);
+        this._lastInvDeltaTime = invDeltaTime;
+        this._integrateManifolds(deltaTime, Vector3.ZeroReadOnly);
+    }
+    /**
+     * Update internal state. Must be called once per frame
+     * @param deltaTime frame delta time in seconds. When using scene.deltaTime divide by 1000.0
+     * @param surfaceInfo surface information returned by checkSupport
+     * @param gravity gravity applied to the character. Can be different that world gravity
+     */
+    integrate(deltaTime, surfaceInfo, gravity) {
+        const invDeltaTime = 1 / deltaTime;
+        const remainingTime = deltaTime;
+        // Choose the first cast direction.  If velocity hasn't changed from the previous integrate, guess that the
+        // displacement will be the same as last integrate, scaled by relative step length.  Otherwise, guess based
+        // on current velocity.
+        {
+            const tolerance = this._displacementEps * invDeltaTime;
+            if (this._velocity.equalsWithEpsilon(this._lastVelocity, tolerance)) {
+                this._lastDisplacement.scaleInPlace(remainingTime * this._lastInvDeltaTime);
+            }
+            else {
+                const displacementVelocity = this._velocity;
+                if (surfaceInfo.supportedState == 2 /* CharacterSupportedState.SUPPORTED */) {
+                    const relativeVelocity = this._tmpVecs[28];
+                    this._velocity.subtractToRef(surfaceInfo.averageSurfaceVelocity, relativeVelocity);
+                    const normalDotVelocity = surfaceInfo.averageSurfaceNormal.dot(relativeVelocity);
+                    if (normalDotVelocity < 0) {
+                        relativeVelocity.subtractInPlace(surfaceInfo.averageSurfaceNormal.scale(normalDotVelocity));
+                        displacementVelocity.copyFrom(relativeVelocity);
+                        displacementVelocity.addInPlace(surfaceInfo.averageSurfaceVelocity);
+                    }
+                }
+                this._lastDisplacement.copyFrom(displacementVelocity);
+                this._lastDisplacement.scaleInPlace(remainingTime);
+            }
+            this._lastVelocity.copyFrom(this._velocity);
+            this._lastInvDeltaTime = invDeltaTime;
+        }
+        this._integrateManifolds(deltaTime, gravity);
     }
     /**
      * Helper function to calculate velocity based on surface informations and current velocity state and target