@mml-io/3d-web-client-core 0.21.5 → 0.22.0

package/build/camera/CameraManager.d.ts

@@ -59,6 +59,7 @@ export declare class CameraManager {
     private easeOutExpo;
     updateAspect(aspect: number): void;
     recomputeFoV(immediately?: boolean): void;
+    isFlyCameraOn(): boolean;
     toggleFlyCamera(): void;
     get activeCamera(): PerspectiveCamera;
     update(): void;

package/build/character/CharacterManager.d.ts

@@ -12,6 +12,38 @@ import { CharacterModelLoader } from "./CharacterModelLoader";
 import { CharacterState } from "./CharacterState";
 import { LocalController } from "./LocalController";
 import { RemoteController } from "./RemoteController";
+type SpawnPosition = {
+    x: number;
+    y: number;
+    z: number;
+};
+type SpawnPositionVariance = {
+    x: number;
+    y: number;
+    z: number;
+};
+type RespawnTrigger = {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+    minZ: number;
+    maxZ: number;
+};
+export type SpawnConfiguration = {
+    spawnPosition?: Partial<SpawnPosition>;
+    spawnPositionVariance?: Partial<SpawnPositionVariance>;
+    spawnYRotation?: number;
+    respawnTrigger?: Partial<RespawnTrigger>;
+    enableRespawnButton?: boolean;
+};
+export type SpawnConfigurationState = {
+    spawnPosition: SpawnPosition;
+    spawnPositionVariance: SpawnPositionVariance;
+    spawnYRotation: number;
+    respawnTrigger: RespawnTrigger;
+    enableRespawnButton: boolean;
+};
 export type CharacterManagerConfig = {
     composer: Composer;
     characterModelLoader: CharacterModelLoader;
@@ -23,6 +55,7 @@ export type CharacterManagerConfig = {
     remoteUserStates: Map<number, CharacterState>;
     sendUpdate: (update: CharacterState) => void;
     animationConfig: AnimationConfig;
+    spawnConfiguration: SpawnConfigurationState;
     characterResolve: (clientId: number) => {
         username: string;
         characterDescription: CharacterDescription;
@@ -43,6 +76,7 @@ export declare class CharacterManager {
     private lastUpdateSentTime;
     constructor(config: CharacterManagerConfig);
     spawnLocalCharacter(id: number, username: string, characterDescription: CharacterDescription, spawnPosition?: Vector3, spawnRotation?: Euler): void;
+    createRespawnButton(): HTMLDivElement;
     setupTweakPane(tweakPane: TweakPane): void;
     spawnRemoteCharacter(id: number, username: string, characterDescription: CharacterDescription, spawnPosition?: Vector3, spawnRotation?: Euler): void;
     getLocalCharacterPositionAndRotation(): PositionAndRotation;
@@ -53,3 +87,4 @@ export declare class CharacterManager {
     respawnIfPresent(id: number): void;
     update(): void;
 }
+export {};

package/build/character/LocalController.d.ts

@@ -5,6 +5,7 @@ import { KeyInputManager } from "../input/KeyInputManager";
 import { VirtualJoystick } from "../input/VirtualJoystick";
 import { TimeManager } from "../time/TimeManager";
 import { Character } from "./Character";
+import { SpawnConfigurationState } from "./CharacterManager";
 import { CharacterState } from "./CharacterState";
 export type LocalControllerConfig = {
     id: number;
@@ -14,6 +15,7 @@ export type LocalControllerConfig = {
     virtualJoystick?: VirtualJoystick;
     cameraManager: CameraManager;
     timeManager: TimeManager;
+    spawnConfiguration: SpawnConfigurationState;
 };
 export declare class LocalController {
     private config;
@@ -50,7 +52,6 @@ export declare class LocalController {
     private vectorDown;
     private rotationOffset;
     private azimuthalAngle;
-    private tempMatrix;
     private tempSegment;
     private tempQuaternion;
     private tempEuler;
@@ -71,7 +72,14 @@ export declare class LocalController {
     jumpReleased: boolean;
     networkState: CharacterState;
     private controlState;
+    private minimumX;
+    private maximumX;
+    private minimumY;
+    private maximumY;
+    private minimumZ;
+    private maximumZ;
     constructor(config: LocalControllerConfig);
+    updateSpawnConfig(spawnConfig: SpawnConfigurationState): void;
     update(): void;
     private getTargetAnimation;
     private updateRotationOffset;
@@ -86,5 +94,5 @@ export declare class LocalController {
         position: Vector3;
     } | null;
     private updateNetworkState;
-    private resetPosition;
+    resetPosition(): void;
 }

package/build/collisions/CollisionsManager.d.ts

@@ -26,7 +26,7 @@ export declare class CollisionsManager {
     private collisionTrigger;
     private previouslyCollidingElements;
     constructor(scene: Scene);
-    raycastFirst(ray: Ray): [number, Vector3, CollisionMeshState] | null;
+    raycastFirst(ray: Ray, maximumDistance?: number | null): [number, Vector3, CollisionMeshState, Vector3] | null;
     private createCollisionMeshState;
     addMeshesGroup(group: Group, mElement?: MElement): void;
     updateMeshesGroup(group: Group): void;

package/build/index.d.ts

@@ -1,6 +1,6 @@
 export { CameraManager } from "./camera/CameraManager";
 export { CharacterDescription, AnimationConfig } from "./character/Character";
-export { CharacterManager } from "./character/CharacterManager";
+export { CharacterManager, SpawnConfiguration, SpawnConfigurationState, } from "./character/CharacterManager";
 export * from "./character/url-position";
 export * from "./helpers/math-helpers";
 export { CharacterModelLoader } from "./character/CharacterModelLoader";

package/build/index.js

@@ -431,6 +431,9 @@ var CameraManager = class {
       this.fov = this.targetFOV;
     }
   }
+  isFlyCameraOn() {
+    return this.isMainCameraActive === false && this.orbitControls.enabled === true;
+  }
   toggleFlyCamera() {
     this.isMainCameraActive = !this.isMainCameraActive;
     this.orbitControls.enabled = !this.isMainCameraActive;
@@ -1530,10 +1533,11 @@ var Character = class extends Group {
 };
 
 // src/character/CharacterManager.ts
+import { radToDeg } from "@mml-io/mml-web";
 import { Euler as Euler2, Group as Group2, Quaternion as Quaternion5, Vector3 as Vector39 } from "three";
 
 // src/character/LocalController.ts
-import { Euler, Line3, Matrix4, Quaternion as Quaternion2, Ray, Raycaster as Raycaster2, Vector3 as Vector36 } from "three";
+import { Euler, Line3, Quaternion as Quaternion2, Ray, Raycaster as Raycaster2, Vector3 as Vector36 } from "three";
 
 // src/tweakpane/blades/characterControlsFolder.ts
 var characterControllerValues = {
@@ -1752,7 +1756,6 @@ var LocalController = class {
     this.vectorDown = new Vector36(0, -1, 0);
     this.rotationOffset = 0;
     this.azimuthalAngle = 0;
-    this.tempMatrix = new Matrix4();
     this.tempSegment = new Line3();
     this.tempQuaternion = new Quaternion2();
     this.tempEuler = new Euler();
@@ -1779,6 +1782,45 @@ var LocalController = class {
       rotation: { quaternionY: 0, quaternionW: 1 },
       state: 0 /* idle */
     };
+    this.minimumX = this.config.spawnConfiguration.respawnTrigger.minX;
+    this.maximumX = this.config.spawnConfiguration.respawnTrigger.maxX;
+    this.minimumY = this.config.spawnConfiguration.respawnTrigger.minY;
+    this.maximumY = this.config.spawnConfiguration.respawnTrigger.maxY;
+    this.minimumZ = this.config.spawnConfiguration.respawnTrigger.minZ;
+    this.maximumZ = this.config.spawnConfiguration.respawnTrigger.maxZ;
+    const maxAbsSpawnX = Math.abs(this.config.spawnConfiguration.spawnPosition.x) + Math.abs(this.config.spawnConfiguration.spawnPositionVariance.x);
+    const maxAbsSpawnY = Math.abs(this.config.spawnConfiguration.spawnPosition.y) + Math.abs(this.config.spawnConfiguration.spawnPositionVariance.y);
+    const maxAbsSpawnZ = Math.abs(this.config.spawnConfiguration.spawnPosition.z) + Math.abs(this.config.spawnConfiguration.spawnPositionVariance.z);
+    if (Math.abs(this.minimumX) < maxAbsSpawnX || Math.abs(this.maximumX) < maxAbsSpawnX) {
+      this.minimumX = -maxAbsSpawnX - 1;
+      this.maximumX = maxAbsSpawnX + 1;
+      console.warn(
+        "The respawnTrigger X values are out of the bounds of the spawnPosition + spawnPositionVariance. Please check your respawnTrigger config."
+      );
+    }
+    if (Math.abs(this.minimumY) < maxAbsSpawnY || Math.abs(this.maximumY) < maxAbsSpawnY) {
+      this.minimumY = -maxAbsSpawnY - 1;
+      this.maximumY = maxAbsSpawnY + 1;
+      console.warn(
+        "The respawnTrigger Y values are out of the bounds of the spawnPosition + spawnPositionVariance. Please check your respawnTrigger config."
+      );
+    }
+    if (Math.abs(this.minimumZ) < maxAbsSpawnZ) {
+      this.minimumZ = -maxAbsSpawnZ - 1;
+      this.maximumZ = maxAbsSpawnZ + 1;
+      console.warn(
+        "The respawnTrigger Z values are out of the bounds of the spawnPosition + spawnPositionVariance. Please check your respawnTrigger config."
+      );
+    }
+  }
+  updateSpawnConfig(spawnConfig) {
+    this.config.spawnConfiguration = spawnConfig;
+    this.minimumX = spawnConfig.respawnTrigger.minX;
+    this.maximumX = spawnConfig.respawnTrigger.maxX;
+    this.minimumY = spawnConfig.respawnTrigger.minY;
+    this.maximumY = spawnConfig.respawnTrigger.maxY;
+    this.minimumZ = spawnConfig.respawnTrigger.minZ;
+    this.maximumZ = spawnConfig.respawnTrigger.maxZ;
   }
   update() {
     var _a, _b;
@@ -1805,7 +1847,13 @@ var LocalController = class {
         i
       );
     }
-    if (this.config.character.position.y < -100) {
+    const outOfBounds = this.config.character.position.x < this.minimumX || // left
+    this.config.character.position.x > this.maximumX || // right
+    this.config.character.position.z < this.minimumZ || // back
+    this.config.character.position.z > this.maximumZ || // front
+    this.config.character.position.y < this.minimumY || // down
+    this.config.character.position.y > this.maximumY;
+    if (outOfBounds) {
       this.resetPosition();
     }
     this.updateNetworkState();
@@ -1949,13 +1997,25 @@ var LocalController = class {
         this.config.character.rotation.setFromQuaternion(asQuaternion);
       }
     }
-    this.config.character.updateMatrixWorld();
     const avatarSegment = this.tempSegment;
     avatarSegment.copy(this.capsuleInfo.segment);
-    avatarSegment.start.applyMatrix4(this.config.character.matrixWorld).applyMatrix4(this.tempMatrix);
-    avatarSegment.end.applyMatrix4(this.config.character.matrixWorld).applyMatrix4(this.tempMatrix);
+    avatarSegment.start.add(this.config.character.position);
+    avatarSegment.end.add(this.config.character.position);
     const positionBeforeCollisions = this.tempVector.copy(avatarSegment.start);
     this.config.collisionsManager.applyColliders(avatarSegment, this.capsuleInfo.radius);
+    const capsuleLength = this.capsuleInfo.segment.end.y - this.capsuleInfo.segment.start.y + this.capsuleInfo.radius * 2;
+    this.rayCaster.set(avatarSegment.start, this.vectorDown);
+    const endIgnoreLength = 0.1;
+    this.rayCaster.ray.origin.y += -this.capsuleInfo.radius + capsuleLength - endIgnoreLength;
+    const withinCapsuleRayHit = this.config.collisionsManager.raycastFirst(
+      this.rayCaster.ray,
+      capsuleLength - endIgnoreLength * 2
+    );
+    if (withinCapsuleRayHit !== null) {
+      const rayHitPosition = withinCapsuleRayHit[3];
+      avatarSegment.start.copy(rayHitPosition);
+      avatarSegment.start.y += this.capsuleInfo.radius;
+    }
     this.config.character.position.copy(avatarSegment.start);
     const deltaCollisionPosition = avatarSegment.start.sub(positionBeforeCollisions);
     this.characterOnGround = deltaCollisionPosition.y > 0;
@@ -2052,8 +2112,34 @@ var LocalController = class {
     };
   }
   resetPosition() {
+    const randomWithVariance = (value, variance) => {
+      const min = value - variance;
+      const max = value + variance;
+      return Math.random() * (max - min) + min;
+    };
+    this.characterVelocity.x = 0;
     this.characterVelocity.y = 0;
-    this.config.character.position.y = 3;
+    this.characterVelocity.z = 0;
+    this.config.character.position.set(
+      randomWithVariance(
+        this.config.spawnConfiguration.spawnPosition.x,
+        this.config.spawnConfiguration.spawnPositionVariance.x
+      ),
+      randomWithVariance(
+        this.config.spawnConfiguration.spawnPosition.y,
+        this.config.spawnConfiguration.spawnPositionVariance.y
+      ),
+      randomWithVariance(
+        this.config.spawnConfiguration.spawnPosition.z,
+        this.config.spawnConfiguration.spawnPositionVariance.z
+      )
+    );
+    const respawnRotation = new Euler(
+      0,
+      -this.config.spawnConfiguration.spawnYRotation * (Math.PI / 180),
+      0
+    );
+    this.config.character.rotation.set(respawnRotation.x, respawnRotation.y, respawnRotation.z);
     this.characterOnGround = false;
     this.doubleJumpUsed = false;
     this.jumpReleased = true;
@@ -2091,8 +2177,13 @@ var RemoteController = class {
   }
   updateFromNetwork(clientUpdate) {
     const { position, rotation, state } = clientUpdate;
-    this.config.character.position.lerp(new Vector37(position.x, position.y, position.z), 0.15);
-    const rotationQuaternion = new Quaternion3(0, rotation.quaternionY, 0, rotation.quaternionW);
+    const distanceSquared = this.config.character.position.distanceToSquared(position);
+    if (distanceSquared > 5 * 5) {
+      this.config.character.position.copy(position);
+    } else {
+      this.config.character.position.lerp(new Vector37(position.x, position.y, position.z), 0.15);
+    }
+    const rotationQuaternion = tempQuaternion.set(0, rotation.quaternionY, 0, rotation.quaternionW);
     this.config.character.quaternion.slerp(rotationQuaternion, 0.6);
     if (state !== this.currentAnimation) {
       this.currentAnimation = state;
@@ -2172,13 +2263,40 @@ var CharacterManager = class {
       keyInputManager: this.config.keyInputManager,
       virtualJoystick: this.config.virtualJoystick,
       cameraManager: this.config.cameraManager,
-      timeManager: this.config.timeManager
+      timeManager: this.config.timeManager,
+      spawnConfiguration: this.config.spawnConfiguration
     });
     this.localCharacter.position.set(spawnPosition.x, spawnPosition.y, spawnPosition.z);
     this.localCharacter.rotation.set(spawnRotation.x, spawnRotation.y, spawnRotation.z);
     this.group.add(character);
     this.localCharacterSpawned = true;
   }
+  createRespawnButton() {
+    const respawnButton = document.createElement("div");
+    respawnButton.className = "respawn-button";
+    respawnButton.textContent = "RESPAWN";
+    respawnButton.addEventListener("click", () => {
+      this.localController.resetPosition();
+    });
+    respawnButton.style.position = "absolute";
+    respawnButton.style.top = "14px";
+    respawnButton.style.left = "8px";
+    respawnButton.style.zIndex = "102";
+    respawnButton.style.backgroundColor = "rgba(0, 0, 0, 0.7)";
+    respawnButton.style.color = "#ffffff";
+    respawnButton.style.borderRadius = "8px";
+    respawnButton.style.border = "1px solid rgba(255, 255, 255, 0.21)";
+    respawnButton.style.height = "22px";
+    respawnButton.style.padding = "8px";
+    respawnButton.style.cursor = "pointer";
+    respawnButton.style.fontSize = "12px";
+    respawnButton.style.fontFamily = "Helvetica, sans-serif";
+    respawnButton.style.userSelect = "none";
+    respawnButton.style.display = "flex";
+    respawnButton.style.alignItems = "center";
+    respawnButton.style.justifyContent = "center";
+    return respawnButton;
+  }
   setupTweakPane(tweakPane) {
     tweakPane.setupCharacterController(this.localController);
   }
@@ -2204,9 +2322,14 @@ var CharacterManager = class {
   }
   getLocalCharacterPositionAndRotation() {
     if (this.localCharacter && this.localCharacter && this.localCharacter) {
+      const rotation = this.localCharacter.rotation;
       return {
         position: this.localCharacter.position,
-        rotation: this.localCharacter.rotation
+        rotation: {
+          x: radToDeg(rotation.x),
+          y: radToDeg(rotation.y),
+          z: radToDeg(rotation.z)
+        }
       };
     }
     return {
@@ -2442,8 +2565,17 @@ var KeyInputManager = class {
     return this.keys.get(key) || false;
   }
   createKeyBinding(key, callback) {
+    if (this.bindings.has(key)) {
+      return;
+    }
     this.bindings.set(key, callback);
   }
+  removeKeyBinding(key) {
+    if (!this.bindings.has(key)) {
+      return;
+    }
+    this.bindings.delete(key);
+  }
   isMovementKeyPressed() {
     return ["w" /* W */, "a" /* A */, "s" /* S */, "d" /* D */].some((key) => this.isKeyPressed(key));
   }
@@ -5395,9 +5527,6 @@ var Composer = class {
     this.renderer.toneMapping = rendererValues.toneMapping;
     this.renderer.toneMappingExposure = rendererValues.exposure;
     this.environmentConfiguration = environmentConfiguration;
-    this.updateSkyboxAndEnvValues();
-    this.updateAmbientLightValues();
-    this.setFog();
     this.effectComposer = new EffectComposer2(this.renderer, {
       frameBufferType: HalfFloatType2
     });
@@ -5436,6 +5565,9 @@ var Composer = class {
     if ((_a = environmentConfiguration == null ? void 0 : environmentConfiguration.postProcessing) == null ? void 0 : _a.bloomIntensity) {
       extrasValues.bloom = environmentConfiguration.postProcessing.bloomIntensity;
     }
+    this.updateSkyboxAndEnvValues();
+    this.updateAmbientLightValues();
+    this.updateFogValues();
     this.bloomEffect = new BloomEffect({
       intensity: extrasValues.bloom
     });
@@ -5525,7 +5657,9 @@ var Composer = class {
     }
     this.updateSkyboxAndEnvValues();
     this.updateAmbientLightValues();
+    this.updateBloomValues();
     this.updateSunValues();
+    this.updateFogValues();
   }
   setupTweakPane(tweakPane) {
     tweakPane.setupRenderPane(
@@ -5758,6 +5892,21 @@ var Composer = class {
       (_i = this.sun) == null ? void 0 : _i.setPolarAngle(this.environmentConfiguration.sun.polarAngle * (Math.PI / 180));
     }
   }
+  updateFogValues() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+    if (typeof ((_b = (_a = this.environmentConfiguration) == null ? void 0 : _a.fog) == null ? void 0 : _b.fogNear) === "number") {
+      envValues.fog.fogNear = this.environmentConfiguration.fog.fogNear;
+    }
+    if (typeof ((_d = (_c = this.environmentConfiguration) == null ? void 0 : _c.fog) == null ? void 0 : _d.fogFar) === "number") {
+      envValues.fog.fogFar = this.environmentConfiguration.fog.fogFar;
+    }
+    if (typeof ((_g = (_f = (_e = this.environmentConfiguration) == null ? void 0 : _e.fog) == null ? void 0 : _f.fogColor) == null ? void 0 : _g.r) === "number" && typeof ((_j = (_i = (_h = this.environmentConfiguration) == null ? void 0 : _h.fog) == null ? void 0 : _i.fogColor) == null ? void 0 : _j.g) === "number" && typeof ((_m = (_l = (_k = this.environmentConfiguration) == null ? void 0 : _k.fog) == null ? void 0 : _l.fogColor) == null ? void 0 : _m.b) === "number") {
+      envValues.fog.fogColor.r = this.environmentConfiguration.fog.fogColor.r;
+      envValues.fog.fogColor.g = this.environmentConfiguration.fog.fogColor.g;
+      envValues.fog.fogColor.b = this.environmentConfiguration.fog.fogColor.b;
+    }
+    this.setFog();
+  }
   updateSkyboxAndEnvValues() {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
     if (typeof ((_b = (_a = this.environmentConfiguration) == null ? void 0 : _a.envMap) == null ? void 0 : _b.intensity) === "number") {
@@ -5781,6 +5930,13 @@ var Composer = class {
       this.updateSkyboxRotation();
     }
   }
+  updateBloomValues() {
+    var _a, _b;
+    if (typeof ((_b = (_a = this.environmentConfiguration) == null ? void 0 : _a.postProcessing) == null ? void 0 : _b.bloomIntensity) === "number") {
+      extrasValues.bloom = this.environmentConfiguration.postProcessing.bloomIntensity;
+    }
+    this.bloomEffect.intensity = extrasValues.bloom;
+  }
   updateAmbientLightValues() {
     var _a, _b;
     if (typeof ((_b = (_a = this.environmentConfiguration) == null ? void 0 : _a.ambientLight) == null ? void 0 : _b.intensity) === "number") {
@@ -5809,7 +5965,7 @@ var Composer = class {
 
 // src/time/TimeManager.ts
 import { Clock } from "three";
-var TimeManager = class {
+var _TimeManager = class _TimeManager {
   constructor() {
     this.clock = new Clock();
     this.roundMagnitude = 2e5;
@@ -5827,8 +5983,12 @@ var TimeManager = class {
     this.fps = 0;
     this.averageFPS = 0;
   }
+  // 100ms
   update() {
     this.rawDeltaTime = this.clock.getDelta();
+    if (this.rawDeltaTime > _TimeManager.maxDeltaTime) {
+      this.rawDeltaTime = _TimeManager.maxDeltaTime;
+    }
     this.frame++;
     this.time += this.rawDeltaTime;
     this.deltaTimes.push(this.rawDeltaTime);
@@ -5851,6 +6011,8 @@ var TimeManager = class {
     }
   }
 };
+_TimeManager.maxDeltaTime = 0.1;
+var TimeManager = _TimeManager;
 
 // src/collisions/CollisionsManager.ts
 import { MMLCollisionTrigger } from "@mml-io/mml-web";
@@ -5927,10 +6089,11 @@ var CollisionsManager = class {
     this.scene = scene;
     this.collisionTrigger = MMLCollisionTrigger.init();
   }
-  raycastFirst(ray) {
+  raycastFirst(ray, maximumDistance = null) {
     let minimumDistance = null;
     let minimumHit = null;
-    let minimumNormal = new Vector316();
+    let minimumNormal = null;
+    let minimumPoint = null;
     for (const [, collisionMeshState] of this.collisionMeshState) {
       this.tempRay.copy(ray).applyMatrix4(this.tempMatrix.copy(collisionMeshState.matrix).invert());
       const hit = collisionMeshState.meshBVH.raycastFirst(this.tempRay, DoubleSide);
@@ -5939,17 +6102,24 @@ var CollisionsManager = class {
         this.tempSegment.end.copy(hit.point);
         this.tempSegment.applyMatrix4(collisionMeshState.matrix);
         const dist = this.tempSegment.distance();
-        if (minimumDistance === null || dist < minimumDistance) {
+        if ((maximumDistance === null || dist < maximumDistance) && (minimumDistance === null || dist < minimumDistance)) {
           minimumDistance = dist;
           minimumHit = collisionMeshState;
+          if (minimumNormal === null) {
+            minimumNormal = new Vector316();
+          }
+          if (minimumPoint === null) {
+            minimumPoint = new Vector316();
+          }
           minimumNormal = (hit.normal ? minimumNormal.copy(hit.normal) : minimumNormal).applyQuaternion(this.tempQuaternion.setFromRotationMatrix(collisionMeshState.matrix)).normalize();
+          minimumPoint = minimumPoint.copy(hit.point).applyMatrix4(collisionMeshState.matrix);
         }
       }
     }
-    if (minimumDistance === null || minimumNormal === null || minimumHit === null) {
+    if (minimumDistance === null || minimumNormal === null || minimumHit === null || minimumPoint === null) {
       return null;
     }
-    return [minimumDistance, minimumNormal, minimumHit];
+    return [minimumDistance, minimumNormal, minimumHit, minimumPoint];
   }
   createCollisionMeshState(group, trackCollisions) {
     const geometries = [];