@mml-io/3d-web-client-core 0.0.0-experimental-1601919-20250319 → 0.0.0-experimental-477fd64-20250417

package/build/character/LocalController.d.ts

@@ -50,7 +50,6 @@ export declare class LocalController {
     private vectorDown;
     private rotationOffset;
     private azimuthalAngle;
-    private tempMatrix;
     private tempSegment;
     private tempQuaternion;
     private tempEuler;

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.js

@@ -1533,7 +1533,7 @@ var Character = class extends Group {
 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 +1752,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();
@@ -1949,13 +1948,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;
@@ -5809,7 +5820,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 +5838,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 +5866,8 @@ var TimeManager = class {
     }
   }
 };
+_TimeManager.maxDeltaTime = 0.1;
+var TimeManager = _TimeManager;
 
 // src/collisions/CollisionsManager.ts
 import { MMLCollisionTrigger } from "@mml-io/mml-web";
@@ -5927,10 +5944,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 +5957,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 = [];