@mml-io/3d-web-client-core 0.0.0-experimental-1e55576-20240116 → 0.0.0-experimental-79fca4a-20240117

package/build/character/LocalController.d.ts

@@ -1,4 +1,4 @@
-import { Line3 } from "three";
+import { Line3, Quaternion, Vector3 } from "three";
 import { CameraManager } from "../camera/CameraManager";
 import { CollisionsManager } from "../collisions/CollisionsManager";
 import { KeyInputManager } from "../input/KeyInputManager";
@@ -12,13 +12,10 @@ export declare class LocalController {
     private readonly keyInputManager;
     private readonly cameraManager;
     private readonly timeManager;
-    private collisionDetectionSteps;
     capsuleInfo: {
         radius: number;
         segment: Line3;
     };
-    private maxWalkSpeed;
-    private maxRunSpeed;
     private gravity;
     private jumpForce;
     private coyoteTimeThreshold;
@@ -28,6 +25,7 @@ export declare class LocalController {
     private characterWasOnGround;
     private characterAirborneSince;
     private currentHeight;
+    private currentSurfaceAngle;
     private characterVelocity;
     private vectorUp;
     private vectorDown;
@@ -35,9 +33,21 @@ export declare class LocalController {
     private azimuthalAngle;
     private tempMatrix;
     private tempSegment;
+    private tempQuaternion;
+    private tempEuler;
     private tempVector;
     private tempVector2;
+    private tempVector3;
     private rayCaster;
+    private surfaceTempQuaternion;
+    private surfaceTempQuaternion2;
+    private surfaceTempVector1;
+    private surfaceTempVector2;
+    private surfaceTempVector3;
+    private surfaceTempVector4;
+    private surfaceTempVector5;
+    private surfaceTempRay;
+    private lastFrameSurfaceState;
     private forward;
     private backward;
     private left;
@@ -46,18 +56,21 @@ export declare class LocalController {
     private jump;
     private anyDirection;
     private conflictingDirections;
-    private speed;
-    private targetSpeed;
     networkState: CharacterState;
     constructor(character: Character, id: number, collisionsManager: CollisionsManager, keyInputManager: KeyInputManager, cameraManager: CameraManager, timeManager: TimeManager);
+    private updateControllerState;
     update(): void;
     private getTargetAnimation;
     private updateRotationOffset;
     private updateAzimuthalAngle;
     private computeAngularDifference;
     private updateRotation;
-    private addScaledVectorToCharacter;
+    private applyControls;
     private updatePosition;
+    getMovementFromSurfaces(userPosition: Vector3, deltaTime: number): {
+        rotation: Quaternion;
+        position: Vector3;
+    } | null;
     private updateNetworkState;
     private resetPosition;
 }

package/build/collisions/CollisionsManager.d.ts

@@ -1,7 +1,7 @@
 import { MElement } from "mml-web";
-import { Group, Line3, Matrix4, Ray, Scene } from "three";
+import { Group, Line3, Matrix4, Ray, Scene, Vector3 } from "three";
 import { MeshBVH } from "three-mesh-bvh";
-type CollisionMeshState = {
+export type CollisionMeshState = {
     matrix: Matrix4;
     source: Group;
     meshBVH: MeshBVH;
@@ -14,6 +14,7 @@ export declare class CollisionsManager {
     private tempVector;
     private tempVector2;
     private tempVector3;
+    private tempQuaternion;
     private tempRay;
     private tempMatrix;
     private tempMatrix2;
@@ -24,7 +25,7 @@ export declare class CollisionsManager {
     collisionMeshState: Map<Group, CollisionMeshState>;
     private collisionTrigger;
     constructor(scene: Scene);
-    raycastFirstDistance(ray: Ray): number | null;
+    raycastFirst(ray: Ray): [number, Vector3, CollisionMeshState] | null;
     private createCollisionMeshState;
     addMeshesGroup(group: Group, mElement?: MElement): void;
     updateMeshesGroup(group: Group): void;
@@ -32,4 +33,3 @@ export declare class CollisionsManager {
     private applyCollider;
     applyColliders(tempSegment: Line3, radius: number): void;
 }
-export {};

package/build/index.js

@@ -203,10 +203,10 @@ var CameraManager = class {
       this.camera.position,
       this.target.clone().sub(this.camera.position).normalize()
     );
-    const minimumDistance = this.collisionsManager.raycastFirstDistance(this.rayCaster.ray);
+    const firstRaycastHit = this.collisionsManager.raycastFirst(this.rayCaster.ray);
     const cameraToPlayerDistance = this.camera.position.distanceTo(this.target);
-    if (minimumDistance !== null && minimumDistance <= cameraToPlayerDistance) {
-      this.targetDistance = cameraToPlayerDistance - minimumDistance;
+    if (firstRaycastHit !== null && firstRaycastHit[0] <= cameraToPlayerDistance) {
+      this.targetDistance = cameraToPlayerDistance - firstRaycastHit[0];
       this.distance = this.targetDistance;
     } else {
       this.targetDistance += (this.desiredDistance - this.targetDistance) * this.dampingFactor * 4;
@@ -1136,10 +1136,19 @@ var Character = class extends Group {
 };
 
 // src/character/CharacterManager.ts
-import { Euler, Group as Group2, Quaternion as Quaternion5, Vector3 as Vector38 } from "three";
+import { Euler as Euler2, Group as Group2, Quaternion as Quaternion5, Vector3 as Vector38 } from "three";
 
 // src/character/LocalController.ts
-import { Line3, Matrix4, Quaternion as Quaternion2, Raycaster as Raycaster2, Vector3 as Vector35 } from "three";
+import { Euler, Line3, Matrix4, Quaternion as Quaternion2, Ray, Raycaster as Raycaster2, Vector3 as Vector35 } from "three";
+var downVector = new Vector35(0, -1, 0);
+var airResistance = 0.5;
+var groundResistance = 0.99999999;
+var airControlModifier = 0.05;
+var groundWalkControl = 0.75;
+var groundRunControl = 1;
+var baseControl = 200;
+var collisionDetectionSteps = 15;
+var minimumSurfaceAngle = 0.9;
 var LocalController = class {
   constructor(character, id, collisionsManager, keyInputManager, cameraManager, timeManager) {
     this.character = character;
@@ -1148,15 +1157,12 @@ var LocalController = class {
     this.keyInputManager = keyInputManager;
     this.cameraManager = cameraManager;
     this.timeManager = timeManager;
-    this.collisionDetectionSteps = 15;
     this.capsuleInfo = {
       radius: 0.4,
       segment: new Line3(new Vector35(), new Vector35(0, 1.05, 0))
     };
-    this.maxWalkSpeed = 6;
-    this.maxRunSpeed = 8.5;
     this.gravity = -42;
-    this.jumpForce = 16;
+    this.jumpForce = 20;
     this.coyoteTimeThreshold = 70;
     this.coyoteTime = false;
     this.canJump = true;
@@ -1164,6 +1170,7 @@ var LocalController = class {
     this.characterWasOnGround = false;
     this.characterAirborneSince = 0;
     this.currentHeight = 0;
+    this.currentSurfaceAngle = new Vector35();
     this.characterVelocity = new Vector35();
     this.vectorUp = new Vector35(0, 1, 0);
     this.vectorDown = new Vector35(0, -1, 0);
@@ -1171,11 +1178,21 @@ var LocalController = class {
     this.azimuthalAngle = 0;
     this.tempMatrix = new Matrix4();
     this.tempSegment = new Line3();
+    this.tempQuaternion = new Quaternion2();
+    this.tempEuler = new Euler();
     this.tempVector = new Vector35();
     this.tempVector2 = new Vector35();
+    this.tempVector3 = new Vector35();
     this.rayCaster = new Raycaster2();
-    this.speed = 0;
-    this.targetSpeed = 0;
+    this.surfaceTempQuaternion = new Quaternion2();
+    this.surfaceTempQuaternion2 = new Quaternion2();
+    this.surfaceTempVector1 = new Vector35();
+    this.surfaceTempVector2 = new Vector35();
+    this.surfaceTempVector3 = new Vector35();
+    this.surfaceTempVector4 = new Vector35();
+    this.surfaceTempVector5 = new Vector35();
+    this.surfaceTempRay = new Ray();
+    this.lastFrameSurfaceState = null;
     this.networkState = {
       id: this.id,
       position: { x: 0, y: 0, z: 0 },
@@ -1183,47 +1200,55 @@ var LocalController = class {
       state: 0 /* idle */
     };
   }
+  updateControllerState() {
+    this.forward = this.keyInputManager.forward;
+    this.backward = this.keyInputManager.backward;
+    this.left = this.keyInputManager.left;
+    this.right = this.keyInputManager.right;
+    this.run = this.keyInputManager.run;
+    this.jump = this.keyInputManager.jump;
+    this.anyDirection = this.keyInputManager.anyDirection;
+    this.conflictingDirections = this.keyInputManager.conflictingDirection;
+  }
   update() {
-    const { forward, backward, left, right, run, jump, anyDirection, conflictingDirection } = this.keyInputManager;
-    this.forward = forward;
-    this.backward = backward;
-    this.left = left;
-    this.right = right;
-    this.run = run;
-    this.jump = jump;
-    this.anyDirection = anyDirection;
-    this.conflictingDirections = conflictingDirection;
-    this.targetSpeed = this.run ? this.maxRunSpeed : this.maxWalkSpeed;
-    this.speed += ease(this.targetSpeed, this.speed, 0.07);
+    this.updateControllerState();
     this.rayCaster.set(this.character.position, this.vectorDown);
-    const minimumDistance = this.collisionsManager.raycastFirstDistance(this.rayCaster.ray);
-    if (minimumDistance !== null) {
-      this.currentHeight = minimumDistance;
+    const firstRaycastHit = this.collisionsManager.raycastFirst(this.rayCaster.ray);
+    if (firstRaycastHit !== null) {
+      this.currentHeight = firstRaycastHit[0];
+      this.currentSurfaceAngle.copy(firstRaycastHit[1]);
     }
-    if (anyDirection || !this.characterOnGround) {
+    if (this.anyDirection || !this.characterOnGround) {
       const targetAnimation = this.getTargetAnimation();
       this.character.updateAnimation(targetAnimation);
     } else {
       this.character.updateAnimation(0 /* idle */);
     }
-    if (this.anyDirection)
+    if (this.anyDirection) {
       this.updateRotation();
-    for (let i = 0; i < this.collisionDetectionSteps; i++) {
-      this.updatePosition(this.timeManager.deltaTime / this.collisionDetectionSteps, i);
     }
-    if (this.character.position.y < 0)
+    for (let i = 0; i < collisionDetectionSteps; i++) {
+      this.updatePosition(
+        this.timeManager.deltaTime,
+        this.timeManager.deltaTime / collisionDetectionSteps,
+        i
+      );
+    }
+    if (this.character.position.y < 0) {
       this.resetPosition();
+    }
     this.updateNetworkState();
   }
   getTargetAnimation() {
     if (!this.character)
       return 0 /* idle */;
-    if (this.conflictingDirections)
-      return 0 /* idle */;
     const jumpHeight = this.characterVelocity.y > 0 ? 0.2 : 1.8;
     if (this.currentHeight > jumpHeight && !this.characterOnGround) {
       return 4 /* air */;
     }
+    if (this.conflictingDirections) {
+      return 0 /* idle */;
+    }
     return this.run && this.anyDirection ? 2 /* running */ : this.anyDirection ? 1 /* walking */ : 0 /* idle */;
   }
   updateRotationOffset() {
@@ -1253,9 +1278,7 @@ var LocalController = class {
     );
     const isCameraFirstPerson = camToModelDistance < 2;
     if (isCameraFirstPerson) {
-      const cameraForward = new Vector35(0, 0, 1).applyQuaternion(
-        this.cameraManager.camera.quaternion
-      );
+      const cameraForward = this.tempVector.set(0, 0, 1).applyQuaternion(this.cameraManager.camera.quaternion);
       this.azimuthalAngle = Math.atan2(cameraForward.x, cameraForward.z);
     } else {
       this.azimuthalAngle = Math.atan2(
@@ -1270,91 +1293,162 @@ var LocalController = class {
   updateRotation() {
     this.updateRotationOffset();
     this.updateAzimuthalAngle();
-    const rotationQuaternion = new Quaternion2();
-    rotationQuaternion.setFromAxisAngle(this.vectorUp, this.azimuthalAngle + this.rotationOffset);
+    const rotationQuaternion = this.tempQuaternion.setFromAxisAngle(
+      this.vectorUp,
+      this.azimuthalAngle + this.rotationOffset
+    );
     const angularDifference = this.computeAngularDifference(rotationQuaternion);
     const desiredTime = 0.07;
     const angularSpeed = angularDifference / desiredTime;
     const frameRotation = angularSpeed * this.timeManager.deltaTime;
     this.character.quaternion.rotateTowards(rotationQuaternion, frameRotation);
   }
-  addScaledVectorToCharacter(deltaTime) {
-    this.character.position.addScaledVector(this.tempVector, this.speed * deltaTime);
-  }
-  updatePosition(deltaTime, _iter) {
+  applyControls(deltaTime) {
+    const resistance = this.characterOnGround ? groundResistance : airResistance;
+    const speedFactor = Math.pow(1 - resistance, deltaTime);
+    this.characterVelocity.multiplyScalar(speedFactor);
+    const acceleration = this.tempVector.set(0, 0, 0);
     if (this.characterOnGround) {
-      if (!this.jump)
+      if (!this.jump) {
         this.canJump = true;
+      }
       if (this.jump && this.canJump) {
-        this.characterVelocity.y += this.jumpForce;
+        acceleration.y += this.jumpForce / deltaTime;
         this.canJump = false;
       } else {
-        this.characterVelocity.y = deltaTime * this.gravity;
+        if (this.currentSurfaceAngle.y < minimumSurfaceAngle) {
+          acceleration.y += this.gravity;
+        }
       }
     } else if (this.jump && this.coyoteTime) {
-      this.characterVelocity.y = this.jumpForce;
+      acceleration.y += this.jumpForce / deltaTime;
       this.canJump = false;
     } else {
-      this.characterVelocity.y += deltaTime * this.gravity;
+      acceleration.y += this.gravity;
       this.canJump = false;
     }
-    this.character.position.addScaledVector(this.characterVelocity, deltaTime);
-    this.tempVector.set(0, 0, 0);
-    if (this.forward) {
-      const forward = new Vector35(0, 0, -1).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
-      this.tempVector.add(forward);
-    }
-    if (this.backward) {
-      const backward = new Vector35(0, 0, 1).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
-      this.tempVector.add(backward);
-    }
-    if (this.left) {
-      const left = new Vector35(-1, 0, 0).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
-      this.tempVector.add(left);
+    const control = (this.characterOnGround ? this.run ? groundRunControl : groundWalkControl : airControlModifier) * baseControl;
+    const controlAcceleration = this.tempVector2.set(0, 0, 0);
+    if (!this.conflictingDirections) {
+      if (this.forward) {
+        const forward = this.tempVector3.set(0, 0, -1).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
+        controlAcceleration.add(forward);
+      }
+      if (this.backward) {
+        const backward = this.tempVector3.set(0, 0, 1).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
+        controlAcceleration.add(backward);
+      }
+      if (this.left) {
+        const left = this.tempVector3.set(-1, 0, 0).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
+        controlAcceleration.add(left);
+      }
+      if (this.right) {
+        const right = this.tempVector3.set(1, 0, 0).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
+        controlAcceleration.add(right);
+      }
     }
-    if (this.right) {
-      const right = new Vector35(1, 0, 0).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
-      this.tempVector.add(right);
+    if (controlAcceleration.length() > 0) {
+      controlAcceleration.normalize();
+      controlAcceleration.multiplyScalar(control);
     }
-    if (this.tempVector.length() > 0) {
-      this.tempVector.normalize();
-      this.addScaledVectorToCharacter(deltaTime);
+    acceleration.add(controlAcceleration);
+    this.characterVelocity.addScaledVector(acceleration, deltaTime);
+    this.character.position.addScaledVector(this.characterVelocity, deltaTime);
+  }
+  updatePosition(deltaTime, stepDeltaTime, iter) {
+    this.applyControls(stepDeltaTime);
+    if (iter === 0) {
+      const lastMovement = this.getMovementFromSurfaces(this.character.position, deltaTime);
+      if (lastMovement) {
+        this.character.position.add(lastMovement.position);
+        const asQuaternion = this.tempQuaternion.setFromEuler(this.character.rotation);
+        const lastMovementEuler = this.tempEuler.setFromQuaternion(lastMovement.rotation);
+        lastMovementEuler.x = 0;
+        lastMovementEuler.z = 0;
+        lastMovement.rotation.setFromEuler(lastMovementEuler);
+        asQuaternion.multiply(lastMovement.rotation);
+        this.character.rotation.setFromQuaternion(asQuaternion);
+      }
     }
     this.character.updateMatrixWorld();
-    this.tempSegment.copy(this.capsuleInfo.segment);
-    this.tempSegment.start.applyMatrix4(this.character.matrixWorld).applyMatrix4(this.tempMatrix);
-    this.tempSegment.end.applyMatrix4(this.character.matrixWorld).applyMatrix4(this.tempMatrix);
-    this.collisionsManager.applyColliders(this.tempSegment, this.capsuleInfo.radius);
-    const newPosition = this.tempVector;
-    newPosition.copy(this.tempSegment.start);
-    const deltaVector = this.tempVector2;
-    deltaVector.subVectors(newPosition, this.character.position);
-    const offset = Math.max(0, deltaVector.length() - 1e-5);
-    deltaVector.normalize().multiplyScalar(offset);
-    this.character.position.add(deltaVector);
-    this.characterOnGround = deltaVector.y > Math.abs(deltaTime * this.characterVelocity.y * 0.25);
+    const avatarSegment = this.tempSegment;
+    avatarSegment.copy(this.capsuleInfo.segment);
+    avatarSegment.start.applyMatrix4(this.character.matrixWorld).applyMatrix4(this.tempMatrix);
+    avatarSegment.end.applyMatrix4(this.character.matrixWorld).applyMatrix4(this.tempMatrix);
+    const positionBeforeCollisions = this.tempVector.copy(avatarSegment.start);
+    this.collisionsManager.applyColliders(avatarSegment, this.capsuleInfo.radius);
+    this.character.position.copy(avatarSegment.start);
+    const deltaCollisionPosition = avatarSegment.start.sub(positionBeforeCollisions);
+    this.characterOnGround = deltaCollisionPosition.y > 0;
     if (this.characterWasOnGround && !this.characterOnGround) {
       this.characterAirborneSince = Date.now();
     }
     this.coyoteTime = this.characterVelocity.y < 0 && !this.characterOnGround && Date.now() - this.characterAirborneSince < this.coyoteTimeThreshold;
     this.characterWasOnGround = this.characterOnGround;
-    if (this.characterOnGround) {
-      this.characterVelocity.set(0, 0, 0);
+  }
+  getMovementFromSurfaces(userPosition, deltaTime) {
+    let lastMovement = null;
+    if (this.lastFrameSurfaceState !== null) {
+      const meshState = this.lastFrameSurfaceState[0];
+      const currentFrameMatrix = meshState.matrix;
+      const lastFrameMatrix = this.lastFrameSurfaceState[1].lastMatrix;
+      if (lastFrameMatrix.equals(currentFrameMatrix)) {
+      } else {
+        const lastMeshPosition = this.surfaceTempVector1;
+        const lastMeshRotation = this.surfaceTempQuaternion;
+        lastFrameMatrix.decompose(lastMeshPosition, lastMeshRotation, this.surfaceTempVector3);
+        const currentMeshPosition = this.surfaceTempVector2;
+        const currentMeshRotation = this.surfaceTempQuaternion2;
+        currentFrameMatrix.decompose(
+          currentMeshPosition,
+          currentMeshRotation,
+          this.surfaceTempVector3
+        );
+        const meshTranslationDelta = this.surfaceTempVector5.copy(currentMeshPosition).sub(lastMeshPosition);
+        const lastFrameRelativeUserPosition = this.surfaceTempVector3.copy(userPosition).sub(lastMeshPosition);
+        const meshRotationDelta = lastMeshRotation.invert().multiply(currentMeshRotation);
+        const translationDueToRotation = this.surfaceTempVector4.copy(lastFrameRelativeUserPosition).applyQuaternion(meshRotationDelta).sub(lastFrameRelativeUserPosition);
+        const translationAndRotationPositionDelta = this.surfaceTempVector1.copy(meshTranslationDelta).add(translationDueToRotation);
+        lastMovement = {
+          position: translationAndRotationPositionDelta,
+          rotation: meshRotationDelta
+        };
+        lastFrameMatrix.copy(currentFrameMatrix);
+      }
+    }
+    const newPosition = this.surfaceTempVector3.copy(userPosition);
+    if (lastMovement) {
+      newPosition.add(lastMovement.position);
+    }
+    newPosition.setY(newPosition.y + 0.05);
+    const ray = this.surfaceTempRay.set(newPosition, downVector);
+    const hit = this.collisionsManager.raycastFirst(ray);
+    if (hit && hit[0] < 0.8) {
+      const currentCollisionMeshState = hit[2];
+      this.lastFrameSurfaceState = [
+        currentCollisionMeshState,
+        { lastMatrix: currentCollisionMeshState.matrix.clone() }
+      ];
     } else {
-      deltaVector.normalize();
-      this.characterVelocity.addScaledVector(deltaVector, -deltaVector.dot(this.characterVelocity));
+      if (this.lastFrameSurfaceState !== null && lastMovement) {
+        this.characterVelocity.add(
+          lastMovement.position.clone().divideScalar(deltaTime)
+          // The position delta is the result of one tick which is deltaTime seconds, so we need to divide by deltaTime to get the velocity per second
+        );
+      }
+      this.lastFrameSurfaceState = null;
     }
+    return lastMovement;
   }
   updateNetworkState() {
-    const characterQuaternion = this.character.getWorldQuaternion(new Quaternion2());
-    const positionUpdate = new Vector35(
-      this.character.position.x,
-      this.character.position.y,
-      this.character.position.z
-    );
+    const characterQuaternion = this.character.getWorldQuaternion(this.tempQuaternion);
     this.networkState = {
       id: this.id,
-      position: positionUpdate,
+      position: {
+        x: this.character.position.x,
+        y: this.character.position.y,
+        z: this.character.position.z
+      },
       rotation: { quaternionY: characterQuaternion.y, quaternionW: characterQuaternion.w },
       state: this.character.getCurrentAnimation()
     };
@@ -1445,7 +1539,7 @@ var CharacterManager = class {
     this.speakingCharacters = /* @__PURE__ */ new Map();
     this.group = new Group2();
   }
-  spawnCharacter(characterDescription, id, isLocal = false, spawnPosition = new Vector38(), spawnRotation = new Euler()) {
+  spawnCharacter(characterDescription, id, isLocal = false, spawnPosition = new Vector38(), spawnRotation = new Euler2()) {
     var _a;
     this.characterDescription = characterDescription;
     const character = new Character(
@@ -1526,16 +1620,16 @@ var CharacterManager = class {
       if (this.speakingCharacters.has(this.id)) {
         (_a = this.localCharacter.speakingIndicator) == null ? void 0 : _a.setSpeaking(this.speakingCharacters.get(this.id));
       }
+      this.localController.update();
+      if (this.timeManager.frame % 2 === 0) {
+        this.sendUpdate(this.localController.networkState);
+      }
       this.cameraOffsetTarget = this.cameraManager.targetDistance <= 0.4 ? 0.13 : 0;
       this.cameraOffset += ease(this.cameraOffsetTarget, this.cameraOffset, 0.1);
       const targetOffset = new Vector38(0, 0, this.cameraOffset);
       targetOffset.add(this.headTargetOffset);
       targetOffset.applyQuaternion(this.localCharacter.quaternion);
       this.cameraManager.setTarget(targetOffset.add(this.localCharacter.position));
-      this.localController.update();
-      if (this.timeManager.frame % 2 === 0) {
-        this.sendUpdate(this.localController.networkState);
-      }
       for (const [id, update] of this.clientStates) {
         if (this.remoteCharacters.has(id) && this.speakingCharacters.has(id)) {
           const character = this.remoteCharacters.get(id);
@@ -4621,13 +4715,14 @@ import {
   Box3,
   Color as Color8,
   DoubleSide,
-  Euler as Euler2,
+  Euler as Euler3,
   Group as Group5,
   Line3 as Line32,
   Matrix4 as Matrix46,
   Mesh as Mesh5,
   MeshBasicMaterial as MeshBasicMaterial3,
-  Ray,
+  Quaternion as Quaternion6,
+  Ray as Ray2,
   Vector3 as Vector314
 } from "three";
 import { VertexNormalsHelper } from "three/examples/jsm/helpers/VertexNormalsHelper.js";
@@ -4639,33 +4734,41 @@ var CollisionsManager = class {
     this.tempVector = new Vector314();
     this.tempVector2 = new Vector314();
     this.tempVector3 = new Vector314();
-    this.tempRay = new Ray();
+    this.tempQuaternion = new Quaternion6();
+    this.tempRay = new Ray2();
     this.tempMatrix = new Matrix46();
     this.tempMatrix2 = new Matrix46();
     this.tempBox = new Box3();
-    this.tempEuler = new Euler2();
+    this.tempEuler = new Euler3();
     this.tempSegment = new Line32();
     this.tempSegment2 = new Line32();
     this.collisionMeshState = /* @__PURE__ */ new Map();
     this.scene = scene;
     this.collisionTrigger = MMLCollisionTrigger.init();
   }
-  raycastFirstDistance(ray) {
+  raycastFirst(ray) {
     let minimumDistance = null;
-    for (const [, value] of this.collisionMeshState) {
-      this.tempRay.copy(ray).applyMatrix4(this.tempMatrix.copy(value.matrix).invert());
-      const hit = value.meshBVH.raycastFirst(this.tempRay, DoubleSide);
+    let minimumHit = null;
+    let minimumNormal = new Vector314();
+    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);
       if (hit) {
         this.tempSegment.start.copy(this.tempRay.origin);
         this.tempSegment.end.copy(hit.point);
-        this.tempSegment.applyMatrix4(value.matrix);
+        this.tempSegment.applyMatrix4(collisionMeshState.matrix);
         const dist = this.tempSegment.distance();
         if (minimumDistance === null || dist < minimumDistance) {
           minimumDistance = dist;
+          minimumHit = collisionMeshState;
+          minimumNormal = (hit.normal ? minimumNormal.copy(hit.normal) : minimumNormal).applyQuaternion(this.tempQuaternion.setFromRotationMatrix(collisionMeshState.matrix)).normalize();
         }
       }
     }
-    return minimumDistance;
+    if (minimumDistance === null || minimumNormal === null || minimumHit === null) {
+      return null;
+    }
+    return [minimumDistance, minimumNormal, minimumHit];
   }
   createCollisionMeshState(group, trackCollisions) {
     const geometries = [];