@mml-io/3d-web-client-core 0.0.0-experimental-ec6e197-20231110 → 0.0.0-experimental-f92224e-20231121

package/build/index.js

@@ -34,6 +34,9 @@ var round = (n, digits) => {
 var ease = (target, n, factor) => {
   return round((target - n) * factor, 5);
 };
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
 var remap = (value, minValue, maxValue, minScaledValue, maxScaledValue) => {
   return minScaledValue + (maxScaledValue - minScaledValue) * (value - minValue) / (maxValue - minValue);
 };
@@ -106,6 +109,8 @@ var CameraManager = class {
     this.targetDistance = this.initialDistance;
     this.distance = this.initialDistance;
     this.desiredDistance = this.initialDistance;
+    this.phi = Math.PI / 2;
+    this.theta = Math.PI / 2;
     this.dragging = false;
     this.target = new Vector32(0, 1.55, 0);
     this.hadTarget = false;
@@ -174,17 +179,24 @@ var CameraManager = class {
     this.setTarget(target);
   }
   reverseUpdateFromPositions() {
-    if (this.phi === null || this.theta == null)
-      return;
     const dx = this.camera.position.x - this.target.x;
     const dy = this.camera.position.y - this.target.y;
     const dz = this.camera.position.z - this.target.z;
     this.targetDistance = Math.sqrt(dx * dx + dy * dy + dz * dz);
-    this.targetTheta = (this.theta + 2 * Math.PI) % (2 * Math.PI);
-    this.targetPhi = Math.max(0, Math.min(Math.PI, this.phi));
+    this.targetTheta = Math.atan2(dz, dx);
+    this.targetPhi = Math.acos(dy / this.targetDistance);
     this.phi = this.targetPhi;
     this.theta = this.targetTheta;
     this.distance = this.targetDistance;
+    this.desiredDistance = this.targetDistance;
+    this.targetFOV = remap(
+      this.targetDistance,
+      this.minDistance,
+      this.maxDistance,
+      this.minFOV,
+      this.maxFOV
+    );
+    this.fov = this.targetFOV;
   }
   adjustCameraPosition() {
     this.rayCaster.set(
@@ -244,14 +256,13 @@ var CameraManager = class {
 };
 
 // src/character/Character.ts
-import { Color as Color3, Vector3 as Vector35 } from "three";
+import { Color as Color3, Group, Vector3 as Vector34 } from "three";
 
 // src/character/CharacterModel.ts
 import {
   AnimationClip,
   AnimationMixer,
   LoopRepeat,
-  MeshStandardMaterial,
   Object3D
 } from "three";
 
@@ -659,36 +670,10 @@ var CharacterModel = class {
     );
     this.applyMaterialToAllSkinnedMeshes(this.material);
   }
-  updateAnimation(targetAnimation, deltaTime) {
-    var _a;
+  updateAnimation(targetAnimation) {
     if (this.currentAnimation !== targetAnimation) {
       this.transitionToAnimation(targetAnimation);
     }
-    (_a = this.animationMixer) == null ? void 0 : _a.update(deltaTime);
-  }
-  hideMaterialByMeshName(meshName) {
-    if (!this.mesh)
-      return;
-    this.mesh.traverse((child) => {
-      if (child.type === "Bone" && child.name === "mixamorigHeadTop_End") {
-        this.headBone = child;
-      }
-      if (child.type === "SkinnedMesh" && child.name === meshName) {
-        child.material = new MeshStandardMaterial({
-          color: 16711680,
-          transparent: true,
-          opacity: 0
-        });
-      }
-    });
-  }
-  setShadows(mesh, castShadow = true, receiveShadow = true) {
-    mesh.traverse((child) => {
-      if (child.type === "SkinnedMesh") {
-        child.castShadow = castShadow;
-        child.receiveShadow = receiveShadow;
-      }
-    });
   }
   applyMaterialToAllSkinnedMeshes(material) {
     if (!this.mesh)
@@ -699,11 +684,6 @@ var CharacterModel = class {
       }
     });
   }
-  initAnimationMixer() {
-    if (this.animationMixer !== null || this.mesh === null)
-      return;
-    this.animationMixer = new AnimationMixer(this.mesh);
-  }
   async loadMainMesh() {
     const mainMeshUrl = this.characterDescription.meshFileUrl;
     const scale = this.characterDescription.modelScale;
@@ -717,12 +697,17 @@ var CharacterModel = class {
       this.mesh.add(model);
       this.mesh.name = name;
       this.mesh.scale.set(scale, scale, scale);
-      this.setShadows(this.mesh);
+      this.mesh.traverse((child) => {
+        if (child.type === "SkinnedMesh") {
+          child.castShadow = true;
+          child.receiveShadow = true;
+        }
+      });
+      this.animationMixer = new AnimationMixer(this.mesh);
     }
   }
   async setAnimationFromFile(animationFileUrl, animationType) {
     return new Promise(async (resolve, reject) => {
-      this.initAnimationMixer();
       const animation = await this.characterModelLoader.load(animationFileUrl, "animation");
       if (typeof animation !== "undefined" && animation instanceof AnimationClip) {
         this.animations[animationType] = this.animationMixer.clipAction(animation);
@@ -737,9 +722,10 @@ var CharacterModel = class {
     });
   }
   transitionToAnimation(targetAnimation, transitionDuration = 0.15) {
-    if (!this.mesh || this.currentAnimation === null)
+    if (!this.mesh)
       return;
     const currentAction = this.animations[this.currentAnimation];
+    this.currentAnimation = targetAnimation;
     const targetAction = this.animations[targetAnimation];
     if (!targetAction)
       return;
@@ -752,7 +738,11 @@ var CharacterModel = class {
     targetAction.setLoop(LoopRepeat, Infinity);
     targetAction.enabled = true;
     targetAction.fadeIn(transitionDuration);
-    this.currentAnimation = targetAnimation;
+  }
+  update(time) {
+    if (this.animationMixer) {
+      this.animationMixer.update(time);
+    }
   }
 };
 
@@ -978,8 +968,10 @@ var defaultLabelPadding = 0;
 var defaultLabelWidth = 0.25;
 var defaultLabelHeight = 0.125;
 var defaultLabelCastShadows = true;
-var CharacterTooltip = class {
-  constructor(parentModel) {
+var tooltipGeometry = new PlaneGeometry(1, 1, 1, 1);
+var CharacterTooltip = class extends Mesh3 {
+  constructor() {
+    super(tooltipGeometry);
     this.visibleOpacity = 0.85;
     this.targetOpacity = 0;
     this.fadingSpeed = 0.02;
@@ -995,25 +987,22 @@ var CharacterTooltip = class {
       fontColor: defaultFontColor,
       castShadows: defaultLabelCastShadows
     };
-    this.setText = this.setText.bind(this);
-    this.material = new MeshBasicMaterial2({
+    this.tooltipMaterial = new MeshBasicMaterial2({
       map: null,
       transparent: true,
-      opacity: 0
+      opacity: 0,
+      side: FrontSide
     });
-    this.material.side = FrontSide;
-    this.geometry = new PlaneGeometry(1, 1, 1, 1);
-    this.mesh = new Mesh3(this.geometry, this.material);
-    this.mesh.position.set(0, 1.6, 0);
-    this.mesh.visible = false;
-    parentModel.add(this.mesh);
+    this.material = this.tooltipMaterial;
+    this.position.set(0, 1.6, 0);
+    this.visible = false;
   }
   redrawText(content) {
-    if (!this.material) {
+    if (!this.tooltipMaterial) {
       return;
     }
-    if (this.material.map) {
-      this.material.map.dispose();
+    if (this.tooltipMaterial.map) {
+      this.tooltipMaterial.map.dispose();
     }
     const { texture, width, height } = THREECanvasTextTexture(content, {
       bold: true,
@@ -1037,17 +1026,17 @@ var CharacterTooltip = class {
       },
       alignment: this.props.alignment
     });
-    this.material.map = texture;
-    this.material.map.magFilter = LinearFilter2;
-    this.material.map.minFilter = LinearFilter2;
-    this.material.needsUpdate = true;
-    this.mesh.scale.x = width / (100 * fontScale);
-    this.mesh.scale.y = height / (100 * fontScale);
-    this.mesh.position.y = 1.6;
+    this.tooltipMaterial.map = texture;
+    this.tooltipMaterial.map.magFilter = LinearFilter2;
+    this.tooltipMaterial.map.minFilter = LinearFilter2;
+    this.tooltipMaterial.needsUpdate = true;
+    this.scale.x = width / (100 * fontScale);
+    this.scale.y = height / (100 * fontScale);
+    this.position.y = 1.6;
   }
   setText(text, temporary = false) {
     this.redrawText(text);
-    this.mesh.visible = true;
+    this.visible = true;
     this.targetOpacity = this.visibleOpacity;
     if (temporary) {
       setTimeout(() => {
@@ -1059,37 +1048,101 @@ var CharacterTooltip = class {
     this.targetOpacity = 0;
   }
   update(camera) {
-    this.mesh.lookAt(camera.position);
-    const opacity = this.mesh.material.opacity;
+    this.lookAt(camera.position);
+    const opacity = this.tooltipMaterial.opacity;
     if (opacity < this.targetOpacity) {
-      this.mesh.material.opacity = Math.min(
-        this.mesh.material.opacity + this.fadingSpeed,
+      this.tooltipMaterial.opacity = Math.min(
+        this.tooltipMaterial.opacity + this.fadingSpeed,
         this.targetOpacity
       );
     } else if (opacity > this.targetOpacity) {
-      this.mesh.material.opacity = Math.max(
-        this.mesh.material.opacity - this.fadingSpeed,
+      this.tooltipMaterial.opacity = Math.max(
+        this.tooltipMaterial.opacity - this.fadingSpeed,
         this.targetOpacity
       );
-      if (opacity >= 1 && this.mesh.material.transparent === true) {
-        this.mesh.material.transparent = false;
-        this.mesh.material.needsUpdate = true;
-      } else if (opacity > 0 && opacity < 1 && this.mesh.material.transparent === false) {
-        this.mesh.material.transparent = true;
-        this.mesh.material.needsUpdate = true;
+      if (opacity >= 1 && this.tooltipMaterial.transparent) {
+        this.tooltipMaterial.transparent = false;
+        this.tooltipMaterial.needsUpdate = true;
+      } else if (opacity > 0 && opacity < 1 && !this.tooltipMaterial.transparent) {
+        this.tooltipMaterial.transparent = true;
+        this.tooltipMaterial.needsUpdate = true;
       }
-      if (this.mesh.material.opacity <= 0) {
-        this.mesh.visible = false;
+      if (this.tooltipMaterial.opacity <= 0) {
+        this.visible = false;
       }
     }
   }
 };
 
+// src/character/Character.ts
+var Character = class extends Group {
+  constructor(characterDescription, characterModelLoader, characterId, modelLoadedCallback, cameraManager, composer) {
+    super();
+    this.characterDescription = characterDescription;
+    this.characterModelLoader = characterModelLoader;
+    this.characterId = characterId;
+    this.modelLoadedCallback = modelLoadedCallback;
+    this.cameraManager = cameraManager;
+    this.composer = composer;
+    this.model = null;
+    this.color = new Color3();
+    this.tooltip = null;
+    this.speakingIndicator = null;
+    this.tooltip = new CharacterTooltip();
+    this.add(this.tooltip);
+    this.load();
+  }
+  async load() {
+    this.model = new CharacterModel(this.characterDescription, this.characterModelLoader);
+    await this.model.init();
+    this.add(this.model.mesh);
+    if (this.speakingIndicator === null) {
+      this.speakingIndicator = new CharacterSpeakingIndicator(this.composer.postPostScene);
+    }
+    this.color = this.model.material.colorsCube216[this.characterId];
+    this.modelLoadedCallback();
+  }
+  updateAnimation(targetAnimation) {
+    var _a;
+    (_a = this.model) == null ? void 0 : _a.updateAnimation(targetAnimation);
+  }
+  update(time, deltaTime) {
+    var _a;
+    if (!this.model)
+      return;
+    if (this.tooltip) {
+      this.tooltip.update(this.cameraManager.camera);
+    }
+    if (this.speakingIndicator) {
+      this.speakingIndicator.setTime(time);
+      if (this.model.mesh && this.model.headBone) {
+        this.speakingIndicator.setBillboarding(
+          (_a = this.model.headBone) == null ? void 0 : _a.getWorldPosition(new Vector34()),
+          this.cameraManager.camera
+        );
+      }
+    }
+    if (typeof this.model.material.uniforms.time !== "undefined") {
+      this.model.material.uniforms.time.value = time;
+      this.model.material.uniforms.diffuseRandomColor.value = this.color;
+      this.model.material.update();
+    }
+    this.model.update(deltaTime);
+  }
+  getCurrentAnimation() {
+    var _a;
+    return ((_a = this.model) == null ? void 0 : _a.currentAnimation) || 0 /* idle */;
+  }
+};
+
+// src/character/CharacterManager.ts
+import { Euler, 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 Vector34 } from "three";
+import { Line3, Matrix4, Quaternion as Quaternion2, Raycaster as Raycaster2, Vector3 as Vector35 } from "three";
 var LocalController = class {
-  constructor(model, id, collisionsManager, keyInputManager, cameraManager, timeManager) {
-    this.model = model;
+  constructor(character, id, collisionsManager, keyInputManager, cameraManager, timeManager) {
+    this.character = character;
     this.id = id;
     this.collisionsManager = collisionsManager;
     this.keyInputManager = keyInputManager;
@@ -1098,7 +1151,7 @@ var LocalController = class {
     this.collisionDetectionSteps = 15;
     this.capsuleInfo = {
       radius: 0.4,
-      segment: new Line3(new Vector34(), new Vector34(0, 1.05, 0))
+      segment: new Line3(new Vector35(), new Vector35(0, 1.05, 0))
     };
     this.maxWalkSpeed = 6;
     this.maxRunSpeed = 8.5;
@@ -1111,17 +1164,16 @@ var LocalController = class {
     this.characterWasOnGround = false;
     this.characterAirborneSince = 0;
     this.currentHeight = 0;
-    this.characterVelocity = new Vector34();
-    this.vectorUp = new Vector34(0, 1, 0);
-    this.vectorDown = new Vector34(0, -1, 0);
+    this.characterVelocity = new Vector35();
+    this.vectorUp = new Vector35(0, 1, 0);
+    this.vectorDown = new Vector35(0, -1, 0);
     this.rotationOffset = 0;
     this.azimuthalAngle = 0;
     this.tempMatrix = new Matrix4();
     this.tempSegment = new Line3();
-    this.tempVector = new Vector34();
-    this.tempVector2 = new Vector34();
+    this.tempVector = new Vector35();
+    this.tempVector2 = new Vector35();
     this.rayCaster = new Raycaster2();
-    this.thirdPersonCamera = null;
     this.speed = 0;
     this.targetSpeed = 0;
     this.networkState = {
@@ -1132,11 +1184,6 @@ var LocalController = class {
     };
   }
   update() {
-    var _a, _b;
-    if (!((_a = this.model) == null ? void 0 : _a.mesh) || !((_b = this.model) == null ? void 0 : _b.animationMixer))
-      return;
-    if (!this.thirdPersonCamera)
-      this.thirdPersonCamera = this.cameraManager.camera;
     const { forward, backward, left, right, run, jump, anyDirection, conflictingDirection } = this.keyInputManager;
     this.forward = forward;
     this.backward = backward;
@@ -1148,28 +1195,28 @@ var LocalController = class {
     this.conflictingDirections = conflictingDirection;
     this.targetSpeed = this.run ? this.maxRunSpeed : this.maxWalkSpeed;
     this.speed += ease(this.targetSpeed, this.speed, 0.07);
-    this.rayCaster.set(this.model.mesh.position, this.vectorDown);
+    this.rayCaster.set(this.character.position, this.vectorDown);
     const minimumDistance = this.collisionsManager.raycastFirstDistance(this.rayCaster.ray);
     if (minimumDistance !== null) {
       this.currentHeight = minimumDistance;
     }
     if (anyDirection || !this.characterOnGround) {
       const targetAnimation = this.getTargetAnimation();
-      this.model.updateAnimation(targetAnimation, this.timeManager.deltaTime);
+      this.character.updateAnimation(targetAnimation);
     } else {
-      this.model.updateAnimation(0 /* idle */, this.timeManager.deltaTime);
+      this.character.updateAnimation(0 /* idle */);
     }
     if (this.anyDirection)
       this.updateRotation();
     for (let i = 0; i < this.collisionDetectionSteps; i++) {
       this.updatePosition(this.timeManager.deltaTime / this.collisionDetectionSteps, i);
     }
-    if (this.model.mesh.position.y < 0)
+    if (this.character.position.y < 0)
       this.resetPosition();
     this.updateNetworkState();
   }
   getTargetAnimation() {
-    if (!this.model.mesh)
+    if (!this.character)
       return 0 /* idle */;
     if (this.conflictingDirections)
       return 0 /* idle */;
@@ -1201,31 +1248,26 @@ var LocalController = class {
     }
   }
   updateAzimuthalAngle() {
-    var _a;
-    if (!this.thirdPersonCamera || !((_a = this.model) == null ? void 0 : _a.mesh))
-      return;
-    const camToModelDistance = this.thirdPersonCamera.position.distanceTo(this.model.mesh.position);
+    const camToModelDistance = this.cameraManager.camera.position.distanceTo(
+      this.character.position
+    );
     const isCameraFirstPerson = camToModelDistance < 2;
     if (isCameraFirstPerson) {
-      const cameraForward = new Vector34(0, 0, 1).applyQuaternion(this.thirdPersonCamera.quaternion);
+      const cameraForward = new Vector35(0, 0, 1).applyQuaternion(
+        this.cameraManager.camera.quaternion
+      );
       this.azimuthalAngle = Math.atan2(cameraForward.x, cameraForward.z);
     } else {
       this.azimuthalAngle = Math.atan2(
-        this.thirdPersonCamera.position.x - this.model.mesh.position.x,
-        this.thirdPersonCamera.position.z - this.model.mesh.position.z
+        this.cameraManager.camera.position.x - this.character.position.x,
+        this.cameraManager.camera.position.z - this.character.position.z
       );
     }
   }
   computeAngularDifference(rotationQuaternion) {
-    var _a;
-    if (!((_a = this.model) == null ? void 0 : _a.mesh))
-      return 0;
-    return 2 * Math.acos(Math.abs(this.model.mesh.quaternion.dot(rotationQuaternion)));
+    return 2 * Math.acos(Math.abs(this.character.quaternion.dot(rotationQuaternion)));
   }
   updateRotation() {
-    var _a;
-    if (!this.thirdPersonCamera || !((_a = this.model) == null ? void 0 : _a.mesh))
-      return;
     this.updateRotationOffset();
     this.updateAzimuthalAngle();
     const rotationQuaternion = new Quaternion2();
@@ -1234,18 +1276,12 @@ var LocalController = class {
     const desiredTime = 0.07;
     const angularSpeed = angularDifference / desiredTime;
     const frameRotation = angularSpeed * this.timeManager.deltaTime;
-    this.model.mesh.quaternion.rotateTowards(rotationQuaternion, frameRotation);
+    this.character.quaternion.rotateTowards(rotationQuaternion, frameRotation);
   }
   addScaledVectorToCharacter(deltaTime) {
-    var _a;
-    if (!((_a = this.model) == null ? void 0 : _a.mesh))
-      return;
-    this.model.mesh.position.addScaledVector(this.tempVector, this.speed * deltaTime);
+    this.character.position.addScaledVector(this.tempVector, this.speed * deltaTime);
   }
   updatePosition(deltaTime, _iter) {
-    var _a;
-    if (!((_a = this.model) == null ? void 0 : _a.mesh))
-      return;
     if (this.characterOnGround) {
       if (!this.jump)
         this.canJump = true;
@@ -1262,45 +1298,45 @@ var LocalController = class {
       this.characterVelocity.y += deltaTime * this.gravity;
       this.canJump = false;
     }
-    this.model.mesh.position.addScaledVector(this.characterVelocity, deltaTime);
+    this.character.position.addScaledVector(this.characterVelocity, deltaTime);
     this.tempVector.set(0, 0, 0);
     if (this.forward) {
-      const forward = new Vector34(0, 0, -1).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
+      const forward = new Vector35(0, 0, -1).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
       this.tempVector.add(forward);
     }
     if (this.backward) {
-      const backward = new Vector34(0, 0, 1).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
+      const backward = new Vector35(0, 0, 1).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
       this.tempVector.add(backward);
     }
     if (this.left) {
-      const left = new Vector34(-1, 0, 0).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
+      const left = new Vector35(-1, 0, 0).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
       this.tempVector.add(left);
     }
     if (this.right) {
-      const right = new Vector34(1, 0, 0).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
+      const right = new Vector35(1, 0, 0).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
       this.tempVector.add(right);
     }
     if (this.tempVector.length() > 0) {
       this.tempVector.normalize();
       this.addScaledVectorToCharacter(deltaTime);
     }
-    this.model.mesh.updateMatrixWorld();
+    this.character.updateMatrixWorld();
     this.tempSegment.copy(this.capsuleInfo.segment);
-    this.tempSegment.start.applyMatrix4(this.model.mesh.matrixWorld).applyMatrix4(this.tempMatrix);
-    this.tempSegment.end.applyMatrix4(this.model.mesh.matrixWorld).applyMatrix4(this.tempMatrix);
+    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.model.mesh.position);
+    deltaVector.subVectors(newPosition, this.character.position);
     const offset = Math.max(0, deltaVector.length() - 1e-5);
     deltaVector.normalize().multiplyScalar(offset);
-    this.model.mesh.position.add(deltaVector);
+    this.character.position.add(deltaVector);
     this.characterOnGround = deltaVector.y > Math.abs(deltaTime * this.characterVelocity.y * 0.25);
     if (this.characterWasOnGround && !this.characterOnGround) {
       this.characterAirborneSince = Date.now();
     }
-    this.coyoteTime = this.characterVelocity.y < 0 && this.characterOnGround === false && Date.now() - this.characterAirborneSince < this.coyoteTimeThreshold;
+    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);
@@ -1310,130 +1346,33 @@ var LocalController = class {
     }
   }
   updateNetworkState() {
-    var _a;
-    if (!((_a = this.model) == null ? void 0 : _a.mesh)) {
-      this.networkState = {
-        id: this.id,
-        position: new Vector34(),
-        rotation: { quaternionY: 0, quaternionW: 1 },
-        state: 0 /* idle */
-      };
-    } else {
-      const characterQuaternion = this.model.mesh.getWorldQuaternion(new Quaternion2());
-      const positionUpdate = new Vector34(
-        this.model.mesh.position.x,
-        this.model.mesh.position.y,
-        this.model.mesh.position.z
-      );
-      this.networkState = {
-        id: this.id,
-        position: positionUpdate,
-        rotation: { quaternionY: characterQuaternion.y, quaternionW: characterQuaternion.w },
-        state: this.model.currentAnimation
-      };
-    }
+    const characterQuaternion = this.character.getWorldQuaternion(new Quaternion2());
+    const positionUpdate = new Vector35(
+      this.character.position.x,
+      this.character.position.y,
+      this.character.position.z
+    );
+    this.networkState = {
+      id: this.id,
+      position: positionUpdate,
+      rotation: { quaternionY: characterQuaternion.y, quaternionW: characterQuaternion.w },
+      state: this.character.getCurrentAnimation()
+    };
   }
   resetPosition() {
-    var _a;
-    if (!((_a = this.model) == null ? void 0 : _a.mesh))
-      return;
     this.characterVelocity.y = 0;
-    this.model.mesh.position.y = 3;
+    this.character.position.y = 3;
     this.characterOnGround = false;
   }
 };
 
-// src/character/Character.ts
-var Character = class {
-  constructor(characterDescription, characterModelLoader, id, isLocal, modelLoadedCallback, collisionsManager, keyInputManager, cameraManager, timeManager, composer) {
-    this.characterDescription = characterDescription;
-    this.characterModelLoader = characterModelLoader;
-    this.id = id;
-    this.isLocal = isLocal;
-    this.modelLoadedCallback = modelLoadedCallback;
-    this.collisionsManager = collisionsManager;
-    this.keyInputManager = keyInputManager;
-    this.cameraManager = cameraManager;
-    this.timeManager = timeManager;
-    this.composer = composer;
-    this.controller = null;
-    this.name = null;
-    this.model = null;
-    this.color = new Color3();
-    this.position = new Vector35();
-    this.tooltip = null;
-    this.speakingIndicator = null;
-    this.load();
-  }
-  async load() {
-    this.model = new CharacterModel(this.characterDescription, this.characterModelLoader);
-    await this.model.init();
-    if (this.tooltip === null) {
-      this.tooltip = new CharacterTooltip(this.model.mesh);
-    }
-    if (this.speakingIndicator === null) {
-      this.speakingIndicator = new CharacterSpeakingIndicator(this.composer.postPostScene);
-    }
-    this.color = this.model.material.colorsCube216[this.id];
-    if (this.isLocal) {
-      this.controller = new LocalController(
-        this.model,
-        this.id,
-        this.collisionsManager,
-        this.keyInputManager,
-        this.cameraManager,
-        this.timeManager
-      );
-    }
-    this.modelLoadedCallback();
-  }
-  update(time) {
-    var _a;
-    if (!this.model)
-      return;
-    if (this.tooltip) {
-      this.tooltip.update(this.cameraManager.camera);
-    }
-    if (this.speakingIndicator) {
-      this.speakingIndicator.setTime(time);
-      if (this.model.mesh && this.model.headBone) {
-        this.speakingIndicator.setBillboarding(
-          (_a = this.model.headBone) == null ? void 0 : _a.getWorldPosition(new Vector35()),
-          this.cameraManager.camera
-        );
-      }
-    }
-    this.model.mesh.getWorldPosition(this.position);
-    if (typeof this.model.material.uniforms.time !== "undefined") {
-      this.model.material.uniforms.time.value = time;
-      this.model.material.uniforms.diffuseRandomColor.value = this.color;
-      this.model.material.update();
-    }
-  }
-};
-
-// src/character/CharacterManager.ts
-import { Euler, Group, Quaternion as Quaternion4, Vector3 as Vector37 } from "three";
-
 // src/character/RemoteController.ts
-import {
-  AnimationMixer as AnimationMixer2,
-  Object3D as Object3D4,
-  Quaternion as Quaternion3,
-  Vector3 as Vector36
-} from "three";
+import { Quaternion as Quaternion3, Vector3 as Vector36 } from "three";
 var RemoteController = class {
-  constructor(character, characterModelLoader, id) {
+  constructor(character, id) {
     this.character = character;
-    this.characterModelLoader = characterModelLoader;
     this.id = id;
-    this.characterModel = null;
-    this.animationMixer = new AnimationMixer2(new Object3D4());
-    this.animations = /* @__PURE__ */ new Map();
     this.currentAnimation = 0 /* idle */;
-    this.characterModel = this.character.model.mesh;
-    this.characterModel.updateMatrixWorld();
-    this.animationMixer = new AnimationMixer2(this.characterModel);
     this.networkState = {
       id: this.id,
       position: { x: 0, y: 0, z: 0 },
@@ -1444,48 +1383,23 @@ var RemoteController = class {
   update(clientUpdate, time, deltaTime) {
     if (!this.character)
       return;
-    this.character.update(time);
     this.updateFromNetwork(clientUpdate);
-    this.animationMixer.update(deltaTime);
-  }
-  async setAnimationFromFile(animationType, fileName) {
-    const animation = await this.characterModelLoader.load(fileName, "animation");
-    const animationAction = this.animationMixer.clipAction(animation);
-    this.animations.set(animationType, animationAction);
-    if (animationType === 0 /* idle */) {
-      animationAction.play();
-    }
-  }
-  transitionToAnimation(targetAnimation, transitionDuration = 0.15) {
-    if (this.currentAnimation === targetAnimation)
-      return;
-    const currentAction = this.animations.get(this.currentAnimation);
-    const targetAction = this.animations.get(targetAnimation);
-    if (!targetAction)
-      return;
-    if (currentAction) {
-      currentAction.enabled = true;
-      targetAction.reset().setEffectiveTimeScale(1).setEffectiveWeight(1).fadeIn(transitionDuration).play();
-      currentAction.crossFadeTo(targetAction, transitionDuration, true);
-    } else {
-      targetAction.play();
-    }
-    this.currentAnimation = targetAnimation;
+    this.character.update(time, deltaTime);
   }
   updateFromNetwork(clientUpdate) {
-    if (!this.characterModel)
-      return;
     const { position, rotation, state } = clientUpdate;
-    this.characterModel.position.lerp(new Vector36(position.x, position.y, position.z), 0.15);
+    this.character.position.lerp(new Vector36(position.x, position.y, position.z), 0.15);
     const rotationQuaternion = new Quaternion3(0, rotation.quaternionY, 0, rotation.quaternionW);
-    this.characterModel.quaternion.slerp(rotationQuaternion, 0.6);
+    this.character.quaternion.slerp(rotationQuaternion, 0.6);
     if (state !== this.currentAnimation) {
-      this.transitionToAnimation(state);
+      this.currentAnimation = state;
+      this.character.updateAnimation(state);
     }
   }
 };
 
-// src/character/CharacterManager.ts
+// src/character/url-position.ts
+import { Quaternion as Quaternion4, Vector3 as Vector37 } from "three";
 function encodeCharacterAndCamera(character, camera) {
   return [
     ...toArray(character.position),
@@ -1494,135 +1408,96 @@ function encodeCharacterAndCamera(character, camera) {
     ...toArray(camera.quaternion)
   ].join(",");
 }
-function decodeCharacterAndCamera(hash, character, camera) {
+function decodeCharacterAndCamera(hash) {
   const values = hash.split(",").map(Number);
-  character.position.fromArray(values.slice(0, 3));
-  character.quaternion.fromArray(values.slice(3, 7));
-  camera.position.fromArray(values.slice(7, 10));
-  camera.quaternion.fromArray(values.slice(10, 14));
+  return {
+    character: {
+      position: new Vector37(values[0], values[1], values[2]),
+      quaternion: new Quaternion4(values[3], values[4], values[5], values[6])
+    },
+    camera: {
+      position: new Vector37(values[7], values[8], values[9]),
+      quaternion: new Quaternion4(values[10], values[11], values[12], values[13])
+    }
+  };
 }
+
+// src/character/CharacterManager.ts
 var CharacterManager = class {
-  constructor(composer, characterModelLoader, collisionsManager, cameraManager, timeManager, inputManager, clientStates, sendUpdate) {
+  constructor(composer, characterModelLoader, collisionsManager, cameraManager, timeManager, keyInputManager, clientStates, sendUpdate) {
     this.composer = composer;
     this.characterModelLoader = characterModelLoader;
     this.collisionsManager = collisionsManager;
     this.cameraManager = cameraManager;
     this.timeManager = timeManager;
-    this.inputManager = inputManager;
+    this.keyInputManager = keyInputManager;
     this.clientStates = clientStates;
     this.sendUpdate = sendUpdate;
-    /*
-     TODO - re-enable updating location hash when there is a solution that waits for models to load (currently if the 
-      character was standing on a model and the page is reloaded the character falls into the model before it loads and 
-      can be trapped).
-    */
-    this.updateLocationHash = false;
+    this.updateLocationHash = true;
+    this.headTargetOffset = new Vector38(0, 1.3, 0);
     this.id = 0;
-    this.loadingCharacters = /* @__PURE__ */ new Map();
     this.remoteCharacters = /* @__PURE__ */ new Map();
     this.remoteCharacterControllers = /* @__PURE__ */ new Map();
     this.characterDescription = null;
-    this.character = null;
+    this.localCharacter = null;
     this.cameraOffsetTarget = 0;
     this.cameraOffset = 0;
     this.speakingCharacters = /* @__PURE__ */ new Map();
-    this.group = new Group();
-  }
-  /* TODO: 
-    1) Separate this method into spawnLocalCharacter and spawnRemoteCharacter
-    2) Make this synchronous to avoid having loadingCharacters and instead manage
-      the mesh loading async (would allow us to show a nameplate where a remote
-      user is before the asset loads).
-  */
-  spawnCharacter(characterDescription, id, isLocal = false, spawnPosition = new Vector37(), spawnRotation = new Euler()) {
+    this.group = new Group2();
+  }
+  spawnCharacter(characterDescription, id, isLocal = false, spawnPosition = new Vector38(), spawnRotation = new Euler()) {
+    var _a;
     this.characterDescription = characterDescription;
-    const characterLoadingPromise = new Promise((resolve) => {
-      const character = new Character(
-        characterDescription,
-        this.characterModelLoader,
+    const character = new Character(
+      characterDescription,
+      this.characterModelLoader,
+      id,
+      () => {
+      },
+      this.cameraManager,
+      this.composer
+    );
+    if (isLocal) {
+      const quaternion = new Quaternion5().setFromEuler(character.rotation);
+      this.sendUpdate({
         id,
-        isLocal,
-        () => {
-          var _a, _b, _c, _d, _e, _f, _g;
-          if (window.location.hash && window.location.hash.length > 1) {
-            decodeCharacterAndCamera(
-              window.location.hash.substring(1),
-              character.model.mesh,
-              this.cameraManager.camera
-            );
-          } else {
-            spawnPosition = spawnPosition || getSpawnPositionInsideCircle(3, 30, id, 0.4);
-            character.model.mesh.position.set(spawnPosition.x, spawnPosition.y, spawnPosition.z);
-            character.model.mesh.rotation.set(spawnRotation.x, spawnRotation.y, spawnRotation.z);
-            character.position.set(spawnPosition.x, spawnPosition.y, spawnPosition.z);
-            character.model.mesh.updateMatrixWorld();
-            const quaternion = new Quaternion4().setFromEuler(character.model.mesh.rotation);
-            this.sendUpdate({
-              id,
-              position: {
-                x: spawnPosition.x,
-                y: spawnPosition.y,
-                z: spawnPosition.z
-              },
-              rotation: { quaternionY: quaternion.y, quaternionW: quaternion.w },
-              state: 0 /* idle */
-            });
-          }
-          character.model.hideMaterialByMeshName("SK_Mannequin_2");
-          if (!isLocal) {
-            (_b = (_a = character.model) == null ? void 0 : _a.mesh) == null ? void 0 : _b.position.set(spawnPosition.x, spawnPosition.y, spawnPosition.z);
-            (_d = (_c = character.model) == null ? void 0 : _c.mesh) == null ? void 0 : _d.updateMatrixWorld();
-            character.position.set(spawnPosition.x, spawnPosition.y, spawnPosition.z);
-          }
-          this.group.add(character.model.mesh);
-          if (isLocal) {
-            this.id = id;
-            this.character = character;
-            (_e = this.character.tooltip) == null ? void 0 : _e.setText(`${id}`);
-          } else {
-            this.remoteCharacters.set(id, character);
-            const remoteController = new RemoteController(character, this.characterModelLoader, id);
-            remoteController.setAnimationFromFile(
-              0 /* idle */,
-              characterDescription.idleAnimationFileUrl
-            );
-            remoteController.setAnimationFromFile(
-              1 /* walking */,
-              characterDescription.jogAnimationFileUrl
-            );
-            remoteController.setAnimationFromFile(
-              2 /* running */,
-              characterDescription.sprintAnimationFileUrl
-            );
-            remoteController.setAnimationFromFile(
-              4 /* air */,
-              characterDescription.airAnimationFileUrl
-            );
-            (_f = remoteController.characterModel) == null ? void 0 : _f.position.set(
-              spawnPosition.x,
-              spawnPosition.y,
-              spawnPosition.z
-            );
-            this.remoteCharacterControllers.set(id, remoteController);
-            (_g = character.tooltip) == null ? void 0 : _g.setText(`${id}`);
-          }
-          resolve(character);
+        position: {
+          x: spawnPosition.x,
+          y: spawnPosition.y,
+          z: spawnPosition.z
         },
+        rotation: { quaternionY: quaternion.y, quaternionW: quaternion.w },
+        state: 0 /* idle */
+      });
+    }
+    if (isLocal) {
+      this.id = id;
+      this.localCharacter = character;
+      this.localController = new LocalController(
+        this.localCharacter,
+        this.id,
         this.collisionsManager,
-        this.inputManager,
+        this.keyInputManager,
         this.cameraManager,
-        this.timeManager,
-        this.composer
+        this.timeManager
       );
-    });
-    this.loadingCharacters.set(id, characterLoadingPromise);
-    return characterLoadingPromise;
+      this.localCharacter.position.set(spawnPosition.x, spawnPosition.y, spawnPosition.z);
+      this.localCharacter.rotation.set(spawnRotation.x, spawnRotation.y, spawnRotation.z);
+    } else {
+      this.remoteCharacters.set(id, character);
+      const remoteController = new RemoteController(character, id);
+      remoteController.character.position.set(spawnPosition.x, spawnPosition.y, spawnPosition.z);
+      remoteController.character.rotation.set(spawnRotation.x, spawnRotation.y, spawnRotation.z);
+      this.remoteCharacterControllers.set(id, remoteController);
+    }
+    (_a = character.tooltip) == null ? void 0 : _a.setText(`${id}`);
+    this.group.add(character);
   }
   getLocalCharacterPositionAndRotation() {
-    if (this.character && this.character.model && this.character.model.mesh) {
+    if (this.localCharacter && this.localCharacter && this.localCharacter) {
       return {
-        position: this.character.model.mesh.position,
-        rotation: this.character.model.mesh.rotation
+        position: this.localCharacter.position,
+        rotation: this.localCharacter.rotation
       };
     }
     return {
@@ -1632,54 +1507,48 @@ var CharacterManager = class {
   }
   clear() {
     for (const [id, character] of this.remoteCharacters) {
-      this.group.remove(character.model.mesh);
+      this.group.remove(character);
       this.remoteCharacters.delete(id);
       this.remoteCharacterControllers.delete(id);
     }
-    if (this.character) {
-      this.group.remove(this.character.model.mesh);
-      this.character = null;
+    if (this.localCharacter) {
+      this.group.remove(this.localCharacter);
+      this.localCharacter = null;
     }
-    this.loadingCharacters.clear();
   }
   setSpeakingCharacter(id, value) {
     this.speakingCharacters.set(id, value);
   }
   update() {
-    var _a, _b, _c, _d;
-    if (this.character) {
-      this.character.update(this.timeManager.time);
+    var _a, _b, _c;
+    if (this.localCharacter) {
+      this.localCharacter.update(this.timeManager.time, this.timeManager.deltaTime);
       if (this.speakingCharacters.has(this.id)) {
-        (_a = this.character.speakingIndicator) == null ? void 0 : _a.setSpeaking(this.speakingCharacters.get(this.id));
+        (_a = this.localCharacter.speakingIndicator) == null ? void 0 : _a.setSpeaking(this.speakingCharacters.get(this.id));
       }
-      if ((_b = this.character.model) == null ? void 0 : _b.mesh) {
-        this.cameraOffsetTarget = this.cameraManager.targetDistance <= 0.4 ? 0.13 : 0;
-        this.cameraOffset += ease(this.cameraOffsetTarget, this.cameraOffset, 0.1);
-        const targetOffset = new Vector37(0, 1.3, this.cameraOffset);
-        targetOffset.applyQuaternion(this.character.model.mesh.quaternion);
-        this.cameraManager.setTarget(this.character.position.add(targetOffset));
-      }
-      if (this.character.controller) {
-        this.character.controller.update();
-        if (this.timeManager.frame % 2 === 0) {
-          this.sendUpdate(this.character.controller.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);
-          (_c = character == null ? void 0 : character.speakingIndicator) == null ? void 0 : _c.setSpeaking(this.speakingCharacters.get(id));
+          (_b = character == null ? void 0 : character.speakingIndicator) == null ? void 0 : _b.setSpeaking(this.speakingCharacters.get(id));
         }
         const { position } = update;
-        if (!this.remoteCharacters.has(id) && !this.loadingCharacters.has(id)) {
+        if (!this.remoteCharacters.has(id)) {
           this.spawnCharacter(
             this.characterDescription,
             id,
             false,
-            new Vector37(position.x, position.y, position.z)
-          ).then((_character) => {
-            this.loadingCharacters.delete(id);
-          });
+            new Vector38(position.x, position.y, position.z)
+          );
         }
         const characterController = this.remoteCharacterControllers.get(id);
         if (characterController) {
@@ -1688,15 +1557,15 @@ var CharacterManager = class {
       }
       for (const [id, character] of this.remoteCharacters) {
         if (!this.clientStates.has(id)) {
-          (_d = character.speakingIndicator) == null ? void 0 : _d.dispose();
-          this.group.remove(character.model.mesh);
+          (_c = character.speakingIndicator) == null ? void 0 : _c.dispose();
+          this.group.remove(character);
           this.remoteCharacters.delete(id);
           this.remoteCharacterControllers.delete(id);
         }
       }
       if (this.updateLocationHash && this.timeManager.frame % 60 === 0) {
         window.location.hash = encodeCharacterAndCamera(
-          this.character.model.mesh,
+          this.localCharacter,
           this.cameraManager.camera
         );
       }
@@ -1749,20 +1618,13 @@ var LRUCache = class {
     this.cache.set(key, value);
   }
 };
-var _CharacterModelLoader = class _CharacterModelLoader {
+var CharacterModelLoader = class {
   constructor(maxCacheSize = 100) {
     this.ongoingLoads = /* @__PURE__ */ new Map();
     this.loadingManager = new LoadingManager();
     this.gltfLoader = new CachedGLTFLoader(this.loadingManager);
     this.modelCache = new LRUCache(maxCacheSize);
   }
-  /* TODO: decide between below lazy initialization or eager on this file's bottom export */
-  static getInstance() {
-    if (!_CharacterModelLoader.instance) {
-      _CharacterModelLoader.instance = new _CharacterModelLoader();
-    }
-    return _CharacterModelLoader.instance;
-  }
   async load(fileUrl, fileType) {
     const cachedModel = this.modelCache.get(fileUrl);
     if (cachedModel) {
@@ -1773,16 +1635,22 @@ var _CharacterModelLoader = class _CharacterModelLoader {
       console.log(`Loading ${fileUrl} from server`);
       const ongoingLoad = this.ongoingLoads.get(fileUrl);
       if (ongoingLoad)
-        return ongoingLoad;
+        return ongoingLoad.then((loadedModel) => {
+          const blobURL = URL.createObjectURL(loadedModel.blob);
+          return this.loadFromUrl(blobURL, fileType, loadedModel.originalExtension);
+        });
       const loadPromise = fetch(fileUrl).then((response) => response.blob()).then((blob) => {
         const originalExtension = fileUrl.split(".").pop() || "";
-        this.modelCache.set(fileUrl, { blob, originalExtension });
-        const blobURL = URL.createObjectURL(blob);
+        const cached = { blob, originalExtension };
+        this.modelCache.set(fileUrl, cached);
         this.ongoingLoads.delete(fileUrl);
-        return this.loadFromUrl(blobURL, fileType, originalExtension);
+        return cached;
       });
       this.ongoingLoads.set(fileUrl, loadPromise);
-      return loadPromise;
+      return loadPromise.then((loadedModel) => {
+        const blobURL = URL.createObjectURL(loadedModel.blob);
+        return this.loadFromUrl(blobURL, fileType, loadedModel.originalExtension);
+      });
     }
   }
   async loadFromUrl(url, fileType, extension) {
@@ -1813,9 +1681,6 @@ var _CharacterModelLoader = class _CharacterModelLoader {
     }
   }
 };
-_CharacterModelLoader.instance = null;
-var CharacterModelLoader = _CharacterModelLoader;
-var MODEL_LOADER = CharacterModelLoader.getInstance();
 
 // src/input/KeyInputManager.ts
 var KeyInputManager = class {
@@ -1884,9 +1749,10 @@ var KeyInputManager = class {
 import {
   InteractionManager,
   MMLClickTrigger,
-  PromptManager
+  PromptManager,
+  LoadingProgressManager
 } from "mml-web";
-import { Group as Group2 } from "three";
+import { Group as Group3 } from "three";
 var MMLCompositionScene = class {
   constructor(targetElement, renderer, scene, camera, audioListener, collisionsManager, getUserPositionAndRotation) {
     this.renderer = renderer;
@@ -1896,7 +1762,7 @@ var MMLCompositionScene = class {
     this.collisionsManager = collisionsManager;
     this.getUserPositionAndRotation = getUserPositionAndRotation;
     this.chatProbes = /* @__PURE__ */ new Set();
-    this.group = new Group2();
+    this.group = new Group3();
     this.promptManager = PromptManager.init(targetElement);
     const { interactionListener, interactionManager } = InteractionManager.init(
       targetElement,
@@ -1905,6 +1771,7 @@ var MMLCompositionScene = class {
     );
     this.interactionManager = interactionManager;
     this.interactionListener = interactionListener;
+    this.loadingProgressManager = new LoadingProgressManager();
     this.mmlScene = {
       getAudioListener: () => this.audioListener,
       getRenderer: () => this.renderer,
@@ -1940,6 +1807,9 @@ var MMLCompositionScene = class {
       },
       prompt: (promptProps, callback) => {
         this.promptManager.prompt(promptProps, callback);
+      },
+      getLoadingProgressManager: () => {
+        return this.loadingProgressManager;
       }
     };
     this.clickTrigger = MMLClickTrigger.init(targetElement, this.mmlScene);
@@ -2888,12 +2758,12 @@ import {
 import { RGBELoader } from "three/examples/jsm/loaders/RGBELoader.js";
 
 // src/sun/Sun.ts
-import { CameraHelper, Color as Color5, DirectionalLight, Group as Group3, OrthographicCamera, Vector3 as Vector38 } from "three";
-var Sun = class extends Group3 {
+import { CameraHelper, Color as Color5, DirectionalLight, Group as Group4, OrthographicCamera, Vector3 as Vector39 } from "three";
+var Sun = class extends Group4 {
   constructor() {
     super();
     this.debug = false;
-    this.sunOffset = new Vector38(
+    this.sunOffset = new Vector39(
       39 * (Math.PI / 180),
       50 * (Math.PI / 180),
       100
@@ -2920,7 +2790,7 @@ var Sun = class extends Group3 {
     this.directionalLight.shadow.mapSize.set(this.shadowResolution, this.shadowResolution);
     this.directionalLight.castShadow = true;
     this.setColor();
-    this.updateCharacterPosition(new Vector38(0, 0, 0));
+    this.updateCharacterPosition(new Vector39(0, 0, 0));
     this.add(this.directionalLight);
     if (this.debug === true && this.camHelper instanceof CameraHelper) {
       this.add(this.camHelper);
@@ -2958,7 +2828,7 @@ var Sun = class extends Group3 {
     if (!this.target)
       return;
     const distance = this.sunOffset.z;
-    const sphericalPosition = new Vector38(
+    const sphericalPosition = new Vector39(
       distance * Math.sin(polarAngle) * Math.cos(azimuthalAngle),
       distance * Math.cos(polarAngle),
       distance * Math.sin(polarAngle) * Math.sin(azimuthalAngle)
@@ -3438,13 +3308,13 @@ import {
   Color as Color7,
   DoubleSide,
   Euler as Euler2,
-  Group as Group4,
+  Group as Group5,
   Line3 as Line32,
   Matrix4 as Matrix42,
   Mesh as Mesh4,
   MeshBasicMaterial as MeshBasicMaterial3,
   Ray,
-  Vector3 as Vector39
+  Vector3 as Vector310
 } from "three";
 import { VertexNormalsHelper } from "three/examples/jsm/helpers/VertexNormalsHelper.js";
 import * as BufferGeometryUtils from "three/examples/jsm/utils/BufferGeometryUtils.js";
@@ -3452,9 +3322,9 @@ import { MeshBVH, MeshBVHVisualizer } from "three-mesh-bvh";
 var CollisionsManager = class {
   constructor(scene) {
     this.debug = false;
-    this.tempVector = new Vector39();
-    this.tempVector2 = new Vector39();
-    this.tempVector3 = new Vector39();
+    this.tempVector = new Vector310();
+    this.tempVector2 = new Vector310();
+    this.tempVector3 = new Vector310();
     this.tempRay = new Ray();
     this.tempMatrix = new Matrix42();
     this.tempMatrix2 = new Matrix42();
@@ -3524,7 +3394,7 @@ var CollisionsManager = class {
       const normalsHelper = new VertexNormalsHelper(wireframeMesh, 0.25, 65280);
       const visualizer = new MeshBVHVisualizer(wireframeMesh, 4);
       visualizer.edgeMaterial.color = new Color7("blue");
-      const debugGroup = new Group4();
+      const debugGroup = new Group5();
       debugGroup.add(wireframeMesh, normalsHelper, visualizer);
       group.matrixWorld.decompose(debugGroup.position, debugGroup.quaternion, debugGroup.scale);
       visualizer.update();
@@ -3603,7 +3473,7 @@ var CollisionsManager = class {
         const realDistance = intersectionSegment.distance();
         if (realDistance < capsuleRadius) {
           if (!collisionPosition) {
-            collisionPosition = new Vector39().copy(closestPointOnSegment).applyMatrix4(meshState.matrix);
+            collisionPosition = new Vector310().copy(closestPointOnSegment).applyMatrix4(meshState.matrix);
           }
           const ratio = realDistance / modelReferenceDistance;
           const realDepth = capsuleRadius - realDistance;
@@ -3659,6 +3529,15 @@ export {
   MMLCompositionScene,
   Sun,
   TimeManager,
-  TweakPane
+  TweakPane,
+  clamp,
+  decodeCharacterAndCamera,
+  ease,
+  encodeCharacterAndCamera,
+  getSpawnPositionInsideCircle,
+  remap,
+  round,
+  roundToDecimalPlaces,
+  toArray
 };
 //# sourceMappingURL=index.js.map