@onerjs/core 8.41.6 → 8.41.8

package/Physics/v2/Plugins/havokPlugin.d.ts

@@ -82,7 +82,6 @@ export declare class HavokPlugin implements IPhysicsEnginePluginV2 {
     private _tmpVec3;
     private _bodies;
     private _shapes;
-    private _bodyBuffer;
     private _bodyCollisionObservable;
     private _constraintToBodyIdPair;
     private _bodyCollisionEndedObservable;
@@ -112,6 +111,20 @@ export declare class HavokPlugin implements IPhysicsEnginePluginV2 {
      * @returns The world region to use for this body
      */
     private _getOrCreateWorldRegion;
+    /**
+     * Checks if a body's world position has left its current region and, if so,
+     * moves it to the correct region (existing or newly created).
+     * This preserves linear and angular velocity across the transition.
+     *
+     * @param pluginData - The plugin data for the body (or instance) to check
+     */
+    private _reRegionBodyPluginData;
+    /**
+     * Searches existing world regions for one that contains the given position.
+     * @param worldPosition - The world position to find a region for
+     * @returns null if no existing region contains it (does NOT create a new one).
+     */
+    private _findExistingRegion;
     /**
      * Observable for collision started and collision continued events
      */

package/Physics/v2/Plugins/havokPlugin.js

@@ -250,6 +250,98 @@ export class HavokPlugin {
         this._worldRegions.push(newRegion);
         return newRegion;
     }
+    /**
+     * Checks if a body's world position has left its current region and, if so,
+     * moves it to the correct region (existing or newly created).
+     * This preserves linear and angular velocity across the transition.
+     *
+     * @param pluginData - The plugin data for the body (or instance) to check
+     */
+    _reRegionBodyPluginData(pluginData) {
+        const currentRegion = pluginData.worldRegion;
+        if (!currentRegion) {
+            return;
+        }
+        // Read the body's current local transform from Havok
+        const bodyTransform = this._hknp.HP_Body_GetQTransform(pluginData.hpBodyId)[1];
+        const localPos = bodyTransform[0];
+        const orientation = bodyTransform[1];
+        // Compute world position = local position + floating origin
+        const worldPos = TmpVectors.Vector3[2];
+        worldPos.set(localPos[0] + currentRegion.floatingOrigin._x, localPos[1] + currentRegion.floatingOrigin._y, localPos[2] + currentRegion.floatingOrigin._z);
+        // Check if still within the current region.
+        // Use a 20% hysteresis margin so that bodies near the boundary
+        // don't oscillate between regions every frame.
+        const distToCurrent = Vector3.Distance(worldPos, currentRegion.floatingOrigin);
+        if (distToCurrent <= this._floatingOriginWorldRadius * 1.2) {
+            return; // still in region (with hysteresis), nothing to do
+        }
+        // Body has left its region. Use velocity to look ahead and find the best
+        // region to join. This prevents creating throwaway intermediate regions
+        // when a fast body is heading toward an existing region (e.g. a target).
+        const linVel = this._hknp.HP_Body_GetLinearVelocity(pluginData.hpBodyId)[1];
+        const angVel = this._hknp.HP_Body_GetAngularVelocity(pluginData.hpBodyId)[1];
+        // Project position forward by one second of travel to find a suitable existing region.
+        // This is purely for region selection — the body's actual position is not changed.
+        const lookAheadPos = TmpVectors.Vector3[3];
+        lookAheadPos.set(worldPos._x + linVel[0], worldPos._y + linVel[1], worldPos._z + linVel[2]);
+        // Try to find the best region: first check if look-ahead position falls in an existing region
+        let newRegion = this._findExistingRegion(lookAheadPos);
+        if (!newRegion || newRegion === currentRegion) {
+            // Fall back to current position
+            newRegion = this._findExistingRegion(worldPos);
+        }
+        if (!newRegion || newRegion === currentRegion) {
+            // No existing region works — create one at the current position
+            newRegion = this._getOrCreateWorldRegion(worldPos);
+        }
+        if (newRegion === currentRegion) {
+            return;
+        }
+        // Remove from old world
+        this._hknp.HP_World_RemoveBody(currentRegion.world, pluginData.hpBodyId);
+        // Set transform relative to the new region's floating origin
+        const newOffset = newRegion.floatingOrigin;
+        const newLocalPos = [worldPos._x - newOffset._x, worldPos._y - newOffset._y, worldPos._z - newOffset._z];
+        this._hknp.HP_Body_SetQTransform(pluginData.hpBodyId, [newLocalPos, orientation]);
+        // Add to new world
+        this._hknp.HP_World_AddBody(newRegion.world, pluginData.hpBodyId, false);
+        // Restore velocity
+        this._hknp.HP_Body_SetLinearVelocity(pluginData.hpBodyId, linVel);
+        this._hknp.HP_Body_SetAngularVelocity(pluginData.hpBodyId, angVel);
+        // Update the region reference and world transform offset
+        pluginData.worldRegion = newRegion;
+        pluginData.worldTransformOffset = this._hknp.HP_Body_GetWorldTransformOffset(pluginData.hpBodyId)[1];
+        // Garbage-collect the old region if it has no bodies left and it's not the default world
+        if (currentRegion !== this._worldRegions[0]) {
+            const bodyCount = this._hknp.HP_World_GetNumBodies(currentRegion.world)[1];
+            if (bodyCount === 0) {
+                this._hknp.HP_World_Release(currentRegion.world);
+                const idx = this._worldRegions.indexOf(currentRegion);
+                if (idx > 0) {
+                    this._worldRegions.splice(idx, 1);
+                }
+            }
+        }
+    }
+    /**
+     * Searches existing world regions for one that contains the given position.
+     * @param worldPosition - The world position to find a region for
+     * @returns null if no existing region contains it (does NOT create a new one).
+     */
+    _findExistingRegion(worldPosition) {
+        const scene = FloatingOriginCurrentScene.getScene();
+        if (!scene?.floatingOriginMode) {
+            return this._worldRegions[0];
+        }
+        for (const region of this._worldRegions) {
+            const distance = Vector3.Distance(worldPosition, region.floatingOrigin);
+            if (distance <= this._floatingOriginWorldRadius) {
+                return region;
+            }
+        }
+        return null;
+    }
     constructor(_useDeltaForWorldStep = true, hpInjection = HK, parameters = {}) {
         this._useDeltaForWorldStep = _useDeltaForWorldStep;
         /**
@@ -419,6 +511,21 @@ export class HavokPlugin {
      * to accurately simulate the physics bodies in the world.
      */
     executeStep(delta, physicsBodies) {
+        // Re-region bodies that have moved outside their current world region
+        // BEFORE pre-step and stepping, so the body participates in the correct
+        // world's step and its body buffer transform is valid when sync reads it.
+        if (this._worldRegions.length > 1 || FloatingOriginCurrentScene.getScene()?.floatingOriginMode) {
+            for (const physicsBody of physicsBodies) {
+                if (physicsBody._pluginDataInstances.length > 0) {
+                    for (const instance of physicsBody._pluginDataInstances) {
+                        this._reRegionBodyPluginData(instance);
+                    }
+                }
+                else if (physicsBody._pluginData) {
+                    this._reRegionBodyPluginData(physicsBody._pluginData);
+                }
+            }
+        }
         for (const physicsBody of physicsBodies) {
             if (physicsBody.disablePreStep) {
                 continue;
@@ -431,8 +538,6 @@ export class HavokPlugin {
             this._hknp.HP_World_SetIdealStepTime(region.world, deltaTime);
             this._hknp.HP_World_Step(region.world, deltaTime);
         }
-        // Get body buffer from the default world (first region)
-        this._bodyBuffer = this._hknp.HP_World_GetBodyBuffer(this.world)[1];
         for (const physicsBody of physicsBodies) {
             if (!physicsBody.disableSync) {
                 this.sync(physicsBody);
@@ -665,7 +770,8 @@ export class HavokPlugin {
                 const pluginData = body._pluginDataInstances[i];
                 // Use instance's world region offset
                 const instanceOffset = pluginData.worldRegion.floatingOrigin;
-                const bodyBuffer = this._bodyBuffer;
+                // Get body buffer from the instance's own world region (not always the default world)
+                const bodyBuffer = this._hknp.HP_World_GetBodyBuffer(pluginData.worldRegion.world)[1];
                 const bufOffset = pluginData.worldTransformOffset;
                 const transformBuffer = new Float32Array(this._hknp.HEAPU8.buffer, bodyBuffer + bufOffset, 16);
                 const index = i * 16;
@@ -1169,7 +1275,43 @@ export class HavokPlugin {
                 this._createOrUpdateBodyInstances(body, body.getMotionType(), matrixData, 0, instancesCount, true);
             }
             else {
-                // regular - use body's world region offset
+                // Check if the node's new world position requires a region change.
+                // This ensures teleports (e.g. toggling disablePreStep after moving
+                // the transform node) immediately land in the correct region with
+                // correct local coordinates, avoiding a one-frame precision glitch.
+                const pluginData = body._pluginData;
+                if (pluginData.worldRegion && (this._worldRegions.length > 1 || FloatingOriginCurrentScene.getScene()?.floatingOriginMode)) {
+                    // Get world position of the node
+                    const worldPos = TmpVectors.Vector3[3];
+                    if (node.parent) {
+                        node.computeWorldMatrix(true);
+                        worldPos.copyFrom(node.absolutePosition);
+                    }
+                    else {
+                        worldPos.copyFrom(node.position);
+                    }
+                    const currentRegion = pluginData.worldRegion;
+                    const distToCurrent = Vector3.Distance(worldPos, currentRegion.floatingOrigin);
+                    if (distToCurrent > this._floatingOriginWorldRadius * 1.2) {
+                        // Teleporting outside current region - re-region before setting transform
+                        const newRegion = this._getOrCreateWorldRegion(worldPos);
+                        if (newRegion !== currentRegion) {
+                            // Save velocity before removing from old world
+                            const linVel = this._hknp.HP_Body_GetLinearVelocity(pluginData.hpBodyId)[1];
+                            const angVel = this._hknp.HP_Body_GetAngularVelocity(pluginData.hpBodyId)[1];
+                            // Remove from old world, add to new world
+                            this._hknp.HP_World_RemoveBody(currentRegion.world, pluginData.hpBodyId);
+                            this._hknp.HP_World_AddBody(newRegion.world, pluginData.hpBodyId, false);
+                            // Restore velocity
+                            this._hknp.HP_Body_SetLinearVelocity(pluginData.hpBodyId, linVel);
+                            this._hknp.HP_Body_SetAngularVelocity(pluginData.hpBodyId, angVel);
+                            // Update region reference and cached world transform offset
+                            pluginData.worldRegion = newRegion;
+                            pluginData.worldTransformOffset = this._hknp.HP_Body_GetWorldTransformOffset(pluginData.hpBodyId)[1];
+                        }
+                    }
+                }
+                // Set transform using the (possibly updated) region offset
                 const offset = body._pluginData.worldRegion.floatingOrigin;
                 this._hknp.HP_Body_SetQTransform(body._pluginData.hpBodyId, this._getTransformInfos(node, offset));
             }
@@ -2289,16 +2431,18 @@ export class HavokPlugin {
         let eventAddress = this._hknp.HP_World_GetCollisionEvents(targetWorld)[1];
         const event = new CollisionEvent();
         const worldAddr = Number(targetWorld);
+        // Find the region for this world to get the correct floating origin offset.
+        // All bodies in a collision share the same world, so use one offset for both.
+        const region = this._worldRegions.find((r) => Number(r.world) === worldAddr) ?? this._worldRegions[0];
+        const regionOffset = region.floatingOrigin;
         while (eventAddress) {
             CollisionEvent.readToRef(this._hknp.HEAPU8.buffer, eventAddress, event);
             const bodyInfoA = this._bodies.get(event.contactOnA.bodyId);
             const bodyInfoB = this._bodies.get(event.contactOnB.bodyId);
-            // Add floating origin offset back to collision contact positions using the body's world region offset
-            // If body doesn't exist, use default region's offset (zero)
-            const offsetA = bodyInfoA?.body?._pluginData?.worldRegion?.floatingOrigin ?? this._worldRegions[0].floatingOrigin;
-            event.contactOnA.position.addInPlace(offsetA);
-            const offsetB = bodyInfoB?.body?._pluginData?.worldRegion?.floatingOrigin ?? this._worldRegions[0].floatingOrigin;
-            event.contactOnB.position.addInPlace(offsetB);
+            // Add floating origin offset back to collision contact positions.
+            // Both contacts are in the same world, so use the region's floating origin.
+            event.contactOnA.position.addInPlace(regionOffset);
+            event.contactOnB.position.addInPlace(regionOffset);
             // Bodies may have been disposed between events. Check both still exist.
             if (bodyInfoA && bodyInfoB) {
                 const collisionInfo = {