@mml-io/3d-web-client-core 0.1.0

package/build/index.js

@@ -0,0 +1,1476 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/camera/CameraManager.ts
+import { PerspectiveCamera, Vector3 as Vector32 } from "three";
+
+// src/helpers/math-helpers.ts
+import { Vector3 } from "three";
+var getSpawnPositionInsideCircle = (radius, positions, id, yPos = 0) => {
+  if (id > 0)
+    id += 3;
+  const goldenAngle = Math.PI * (3 - Math.sqrt(5));
+  const theta = id * goldenAngle;
+  const scale = id / positions;
+  const scaledRadius = scale * radius;
+  const x = Math.cos(theta) * scaledRadius;
+  const z = Math.sin(theta) * scaledRadius;
+  return new Vector3(x, yPos, z);
+};
+var round = (n, digits) => {
+  return Number(n.toFixed(digits));
+};
+var ease = (target, n, factor) => {
+  return round((target - n) * factor, 5);
+};
+
+// src/camera/CameraManager.ts
+var CameraManager = class {
+  constructor() {
+    __publicField(this, "camera");
+    __publicField(this, "dragging", false);
+    __publicField(this, "target", new Vector32(0, 1.55, 0));
+    __publicField(this, "targetDistance");
+    __publicField(this, "maxTargetDistance", 20);
+    __publicField(this, "distance");
+    __publicField(this, "targetPhi", Math.PI / 2);
+    __publicField(this, "phi", Math.PI / 2);
+    __publicField(this, "targetTheta", -Math.PI / 2);
+    __publicField(this, "theta", -Math.PI / 2);
+    __publicField(this, "hadTarget", false);
+    this.camera = new PerspectiveCamera(80, window.innerWidth / window.innerHeight, 0.1, 2e3);
+    this.camera.position.set(0, 1.4, 3);
+    this.targetDistance = 2.5;
+    this.distance = this.targetDistance;
+    document.addEventListener("mousedown", this.onMouseDown.bind(this));
+    document.addEventListener("mouseup", this.onMouseUp.bind(this));
+    document.addEventListener("mousemove", this.onMouseMove.bind(this));
+    document.addEventListener("wheel", this.onMouseWheel.bind(this));
+    window.addEventListener("resize", this.onResize.bind(this));
+  }
+  onResize() {
+    const width = window.innerWidth;
+    const height = window.innerHeight;
+    this.camera.aspect = width / height;
+    this.camera.updateProjectionMatrix();
+  }
+  onMouseDown(_event) {
+    this.dragging = true;
+  }
+  onMouseUp(_event) {
+    this.dragging = false;
+  }
+  onMouseMove(event) {
+    if (!this.dragging) {
+      return;
+    }
+    if (this.targetTheta === null || this.targetPhi === null) {
+      return;
+    }
+    this.targetTheta += event.movementX * 0.01;
+    this.targetPhi -= event.movementY * 0.01;
+    this.targetPhi = Math.max(Math.PI * 0.1, Math.min(Math.PI - Math.PI * 0.1, this.targetPhi));
+    this.targetPhi = Math.min(Math.PI * 0.7, this.targetPhi);
+  }
+  onMouseWheel(event) {
+    const scrollAmount = event.deltaY * 0.01;
+    this.targetDistance += scrollAmount;
+    this.targetDistance = Math.max(0, this.targetDistance);
+    this.targetDistance = Math.min(this.targetDistance, this.maxTargetDistance);
+  }
+  setTarget(target) {
+    this.target.copy(target);
+    if (!this.hadTarget) {
+      this.hadTarget = true;
+      this.reverseUpdateFromPositions();
+    }
+  }
+  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.phi = this.targetPhi;
+    this.theta = this.targetTheta;
+    this.distance = this.targetDistance;
+  }
+  update() {
+    if (this.target === null) {
+      return;
+    }
+    if (this.phi !== null && this.targetPhi !== null && this.theta !== null && this.targetTheta !== null) {
+      this.distance += ease(this.targetDistance, this.distance, 0.02);
+      this.distance = Math.min(this.distance, this.maxTargetDistance);
+      this.phi += ease(this.targetPhi, this.phi, 0.07);
+      this.theta += ease(this.targetTheta, this.theta, 0.07);
+      const x = this.target.x + this.distance * Math.sin(this.phi) * Math.cos(this.theta);
+      const y = this.target.y + this.distance * Math.cos(this.phi);
+      const z = this.target.z + this.distance * Math.sin(this.phi) * Math.sin(this.theta);
+      this.camera.position.set(x, y, z);
+      this.camera.lookAt(this.target);
+    }
+  }
+};
+
+// src/character/Character.ts
+import { Color as Color2, Vector3 as Vector34 } from "three";
+
+// src/character/CharacterModel.ts
+import {
+  AnimationClip as AnimationClip2,
+  AnimationMixer,
+  LoopRepeat,
+  MeshStandardMaterial,
+  Object3D as Object3D2
+} from "three";
+
+// src/character/CharacterMaterial.ts
+import { Color, MeshPhysicalMaterial, UniformsUtils } from "three";
+
+// src/rendering/shaders/bayer-dither.ts
+var bayerDither = (
+  /* glsl */
+  `
+const mat4 bayertl = mat4( 
+  0.0 / 64.0, 32.0 / 64.0,  8.0 / 64.0, 40.0 / 64.0,
+  48.0 / 64.0, 16.0 / 64.0, 56.0 / 64.0, 24.0 / 64.0,
+  12.0 / 64.0, 44.0 / 64.0, 4.0 / 64.0, 36.0 / 64.0,
+  60.0 / 64.0, 28.0 / 64.0, 52.0 / 64.0, 20.0 / 64.0
+);
+
+const mat4 bayertr = mat4( 
+  2.0 / 64.0, 34.0 / 64.0, 10.0 / 64.0, 42.0 / 64.0,
+  50.0 / 64.0, 18.0 / 64.0, 58.0 / 64.0, 26.0 / 64.0,
+  14.0 / 64.0, 46.0 / 64.0, 6.0 / 64.0, 38.0 / 64.0,
+  62.0 / 64.0, 30.0 / 64.0, 54.0 / 64.0, 22.0 / 64.0
+);
+
+const mat4 bayerbl = mat4( 
+  3.0 / 64.0, 35.0 / 64.0, 11.0 / 64.0, 43.0 / 64.0,
+  51.0 / 64.0, 19.0 / 64.0, 59.0 / 64.0, 27.0 / 64.0,
+  15.0 / 64.0, 47.0 / 64.0, 7.0 / 64.0, 39.0 / 64.0,
+  63.0 / 64.0, 31.0 / 64.0, 55.0 / 64.0, 23.0 / 64.0
+);
+
+const mat4 bayerbr = mat4( 
+  1.0 / 64.0, 33.0 / 64.0, 9.0 / 64.0, 41.0 / 64.0,
+  49.0 / 64.0, 17.0 / 64.0, 57.0 / 64.0, 25.0 / 64.0,
+  13.0 / 64.0, 45.0 / 64.0, 5.0 / 64.0, 37.0 / 64.0,
+  61.0 / 64.0, 29.0 / 64.0, 53.0 / 64.0, 21.0 / 64.0
+);
+
+float bayerDither(mat4 m, ivec2 p) {
+  if (p.y == 0) {
+    if (p.x == 0) { return m[0][0]; }
+    else if (p.x == 1) { return m[1][0]; }
+    else if (p.x == 2) { return m[2][0]; }
+    else { return m[3][0]; }
+  } else if (p.y == 1) {
+    if (p.x == 0) { return m[0][1]; }
+    else if (p.x == 1) { return m[1][1]; }
+    else if (p.x == 2) { return m[2][1]; }
+    else { return m[3][1]; }
+  } else if (p.y == 2) {
+    if (p.x == 0) { return m[0][1]; }
+    else if (p.x == 1) { return m[1][2]; }
+    else if (p.x == 2) { return m[2][2]; }
+    else { return m[3][2]; }
+  } else {
+    if (p.x == 0) { return m[0][3]; }
+    else if (p.x == 1) { return m[1][3]; }
+    else if (p.x == 2) { return m[2][3]; }
+    else { return m[3][3]; }
+  }
+}
+`
+);
+
+// src/rendering/shaders/shader-helpers.ts
+function injectBeforeMain(shaderSource, codeToInject) {
+  return shaderSource.replace(
+    "void main() {",
+    `
+
+${codeToInject}
+
+void main() {`
+  );
+}
+function injectInsideMain(shaderSource, codeToInject) {
+  return shaderSource.replace(
+    "void main() {",
+    `void main() {
+
+${codeToInject}
+
+    `
+  );
+}
+function injectBefore(shaderSource, before, codeToInject) {
+  return shaderSource.replace(
+    before,
+    `
+${codeToInject}
+
+${before}
+    `
+  );
+}
+
+// src/character/CharacterMaterial.ts
+var CharacterMaterial = class extends MeshPhysicalMaterial {
+  constructor() {
+    super();
+    __publicField(this, "uniforms", {});
+    __publicField(this, "colorsCube216", []);
+    this.color = new Color(16777215);
+    this.transmission = 0.5;
+    this.metalness = 0.5;
+    this.roughness = 0.3;
+    this.ior = 2;
+    this.thickness = 0.1;
+    this.specularColor = new Color(30719);
+    this.specularIntensity = 0.1;
+    this.envMapIntensity = 1.8;
+    this.sheenColor = new Color(7798903);
+    this.sheen = 0.35;
+    this.onBeforeCompile = (shader) => {
+      this.uniforms = UniformsUtils.clone(shader.uniforms);
+      this.uniforms.nearClip = { value: 0.01 };
+      this.uniforms.farClip = { value: 1e3 };
+      this.uniforms.ditheringNear = { value: 0.25 };
+      this.uniforms.ditheringRange = { value: 0.5 };
+      this.uniforms.time = { value: 0 };
+      this.uniforms.diffuseRandomColor = { value: new Color() };
+      shader.uniforms = this.uniforms;
+      shader.vertexShader = injectBeforeMain(shader.vertexShader, "varying vec2 vUv;");
+      shader.vertexShader = injectInsideMain(shader.vertexShader, "vUv = uv;");
+      shader.fragmentShader = injectBeforeMain(
+        shader.fragmentShader,
+        /* glsl */
+        `
+          varying vec2 vUv;
+          uniform float nearClip;
+          uniform float farClip;
+          uniform float ditheringNear;
+          uniform float ditheringRange;
+          uniform float time;
+          uniform vec3 diffuseRandomColor;
+          ${bayerDither}
+        `
+      );
+      shader.fragmentShader = injectBefore(
+        shader.fragmentShader,
+        "#include <output_fragment>",
+        /* glsl */
+        `
+          float distance = length(vWorldPosition - cameraPosition);
+          float normalizedDistance = (distance - nearClip) / (farClip - nearClip);
+          ivec2 p = ivec2(mod(gl_FragCoord.xy, 8.0));
+          float d = 0.0;
+          if (p.x <= 3 && p.y <= 3) {
+            d = bayerDither(bayertl, p);
+          } else if (p.x > 3 && p.y <= 3) {
+            d = bayerDither(bayertr, p - ivec2(4, 0));
+          } else if (p.x <= 3 && p.y > 3) {
+            d = bayerDither(bayerbl, p - ivec2(0, 4));
+          } else if (p.x > 3 && p.y > 3) {
+            d = bayerDither(bayerbr, p - ivec2(4, 4));
+          }
+          if (distance <= ditheringNear + d * ditheringRange) discard;
+          vec2 suv = vUv;
+          float s = clamp(0.35 + 0.35 * sin(5.0 * -time + suv.y * 500.0), 0.0, 1.0);
+          float scanLines = pow(s, 1.33);
+          outgoingLight *= diffuseRandomColor;
+          outgoingLight += smoothstep(0.1, 0.0, scanLines) * 0.1;
+        `
+      );
+    };
+    this.generateColorCube();
+  }
+  generateColorCube() {
+    const saturation = 0.7;
+    const lightness = 0.8;
+    const goldenRatioConjugate = 0.618033988749895;
+    let hue = 0;
+    for (let i = 0; i < 216; i++) {
+      const color = new Color();
+      color.setHSL(hue, saturation, lightness);
+      this.colorsCube216.push(color);
+      hue = (hue + goldenRatioConjugate) % 1;
+    }
+  }
+};
+
+// src/character/CharacterState.ts
+var AnimationState = /* @__PURE__ */ ((AnimationState2) => {
+  AnimationState2[AnimationState2["idle"] = 0] = "idle";
+  AnimationState2[AnimationState2["walking"] = 1] = "walking";
+  AnimationState2[AnimationState2["running"] = 2] = "running";
+  AnimationState2[AnimationState2["jumpToAir"] = 3] = "jumpToAir";
+  AnimationState2[AnimationState2["air"] = 4] = "air";
+  AnimationState2[AnimationState2["airToGround"] = 5] = "airToGround";
+  return AnimationState2;
+})(AnimationState || {});
+
+// src/character/ModelLoader.ts
+import { LoadingManager } from "three";
+import { FBXLoader } from "three/examples/jsm/loaders/FBXLoader.js";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
+var ModelLoader = class {
+  constructor() {
+    __publicField(this, "debug", false);
+    __publicField(this, "loadingManager");
+    __publicField(this, "fbxLoader");
+    __publicField(this, "gltfLoader");
+    this.loadingManager = new LoadingManager();
+    this.fbxLoader = new FBXLoader(this.loadingManager);
+    this.gltfLoader = new GLTFLoader(this.loadingManager);
+  }
+  async load(fileUrl, fileType) {
+    const extension = fileUrl.split(".").pop();
+    if (typeof extension === "undefined") {
+      console.error(`Unable to identify model type from ${fileUrl}`);
+      return;
+    }
+    const name = fileUrl.split("/").pop().replace(`.${extension}`, "");
+    if (this.debug) {
+      console.log(`Loading ${extension} model ${name} from ${fileUrl}`);
+    }
+    if (["gltf", "glb"].includes(extension)) {
+      return new Promise((resolve, reject) => {
+        this.gltfLoader.load(
+          fileUrl,
+          (object) => {
+            if (fileType === "model") {
+              resolve(object.scene);
+            } else if (fileType === "animation") {
+              resolve(object.animations[0]);
+            } else {
+              const error = `Trying to load unknown ${fileType} type of element from file ${fileUrl}`;
+              console.error(error);
+              reject(error);
+            }
+          },
+          void 0,
+          (error) => {
+            console.error(`Error loading GL(B|TF) from ${fileUrl}: ${error}`);
+            reject(error);
+          }
+        );
+      });
+    } else if (extension === "fbx") {
+      return new Promise((resolve, reject) => {
+        this.fbxLoader.load(
+          fileUrl,
+          (object) => {
+            resolve(object);
+          },
+          void 0,
+          (error) => {
+            console.error(`Error loading FBX from ${fileUrl}: ${error}`);
+            reject(error);
+          }
+        );
+      });
+    }
+  }
+};
+
+// src/character/CharacterModel.ts
+var CharacterModel = class {
+  constructor(characterDescription) {
+    this.characterDescription = characterDescription;
+    __publicField(this, "modelLoader", new ModelLoader());
+    __publicField(this, "mesh", null);
+    __publicField(this, "material", new CharacterMaterial());
+    __publicField(this, "animations", {});
+    __publicField(this, "animationMixer", null);
+    __publicField(this, "currentAnimation", 0 /* idle */);
+  }
+  async init() {
+    await this.loadMainMesh();
+    await this.setAnimationFromFile(
+      this.characterDescription.idleAnimationFileUrl,
+      0 /* idle */
+    );
+    await this.setAnimationFromFile(
+      this.characterDescription.jogAnimationFileUrl,
+      1 /* walking */
+    );
+    await this.setAnimationFromFile(
+      this.characterDescription.sprintAnimationFileUrl,
+      2 /* running */
+    );
+    this.applyMaterialToAllSkinnedMeshes(this.material);
+  }
+  updateAnimation(targetAnimation, deltaTime) {
+    if (this.currentAnimation !== targetAnimation) {
+      this.transitionToAnimation(targetAnimation);
+    }
+    this.animationMixer?.update(deltaTime);
+  }
+  hideMaterialByMeshName(meshName) {
+    if (!this.mesh)
+      return;
+    this.mesh.traverse((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)
+      return;
+    this.mesh.traverse((child) => {
+      if (child.type === "SkinnedMesh") {
+        child.material = material;
+      }
+    });
+  }
+  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;
+    const extension = mainMeshUrl.split(".").pop();
+    const name = mainMeshUrl.split("/").pop().replace(`.${extension}`, "");
+    const mainMesh = await this.modelLoader.load(mainMeshUrl, "model");
+    if (typeof mainMesh !== "undefined") {
+      this.mesh = new Object3D2();
+      const model = mainMesh;
+      model.position.set(0, -0.35, 0);
+      this.mesh.add(model);
+      this.mesh.name = name;
+      this.mesh.scale.set(scale, scale, scale);
+      this.setShadows(this.mesh);
+    }
+  }
+  async setAnimationFromFile(animationFileUrl, animationType) {
+    return new Promise(async (resolve, reject) => {
+      this.initAnimationMixer();
+      const animation = await this.modelLoader.load(animationFileUrl, "animation");
+      if (typeof animation !== "undefined" && animation instanceof AnimationClip2) {
+        this.animations[animationType] = this.animationMixer.clipAction(animation);
+        this.animations[animationType].stop();
+        if (animationType === 0 /* idle */) {
+          this.animations[animationType].play();
+        }
+        resolve();
+      } else {
+        reject(`failed to load ${animationType} from ${animationFileUrl}`);
+      }
+    });
+  }
+  transitionToAnimation(targetAnimation, transitionDuration = 0.21) {
+    if (!this.mesh || this.currentAnimation === null)
+      return;
+    const currentAction = this.animations[this.currentAnimation];
+    const targetAction = this.animations[targetAnimation];
+    if (!targetAction)
+      return;
+    if (currentAction) {
+      currentAction.enabled = true;
+      currentAction.fadeOut(transitionDuration);
+    }
+    if (!targetAction.isRunning())
+      targetAction.play();
+    targetAction.setLoop(LoopRepeat, Infinity);
+    targetAction.enabled = true;
+    targetAction.fadeIn(transitionDuration);
+    this.currentAnimation = targetAnimation;
+  }
+};
+
+// src/character/LocalController.ts
+import { Box3, Line3, Matrix4, Quaternion, Vector3 as Vector33 } from "three";
+var LocalController = class {
+  constructor(model, id, collisionsManager, keyInputManager, cameraManager, timeManager) {
+    this.model = model;
+    this.id = id;
+    this.collisionsManager = collisionsManager;
+    this.keyInputManager = keyInputManager;
+    this.cameraManager = cameraManager;
+    this.timeManager = timeManager;
+    __publicField(this, "collisionDetectionSteps", 15);
+    __publicField(this, "capsuleInfo", {
+      radius: 0.4,
+      segment: new Line3(new Vector33(), new Vector33(0, 1.05, 0))
+    });
+    __publicField(this, "characterOnGround", false);
+    __publicField(this, "characterVelocity", new Vector33());
+    __publicField(this, "gravity", -20);
+    __publicField(this, "upVector", new Vector33(0, 1, 0));
+    __publicField(this, "rotationOffset", 0);
+    __publicField(this, "azimuthalAngle", 0);
+    __publicField(this, "tempBox", new Box3());
+    __publicField(this, "tempMatrix", new Matrix4());
+    __publicField(this, "tempSegment", new Line3());
+    __publicField(this, "tempVector", new Vector33());
+    __publicField(this, "tempVector2", new Vector33());
+    __publicField(this, "jumpInput", false);
+    __publicField(this, "jumpForce", 10);
+    __publicField(this, "canJump", true);
+    __publicField(this, "inputDirections", {
+      forward: false,
+      backward: false,
+      left: false,
+      right: false
+    });
+    __publicField(this, "runInput", false);
+    __publicField(this, "thirdPersonCamera", null);
+    __publicField(this, "speed", 0);
+    __publicField(this, "targetSpeed", 0);
+    __publicField(this, "networkState", {
+      id: 0,
+      position: { x: 0, y: 0, z: 0 },
+      rotation: { quaternionY: 0, quaternionW: 0 },
+      state: 0 /* idle */
+    });
+  }
+  update() {
+    if (!this.model?.mesh || !this.model?.animationMixer)
+      return;
+    if (!this.thirdPersonCamera)
+      this.thirdPersonCamera = this.cameraManager.camera;
+    const movementKeysPressed = this.keyInputManager.isMovementKeyPressed();
+    const forward = this.keyInputManager.isKeyPressed("w");
+    const backward = this.keyInputManager.isKeyPressed("s");
+    const left = this.keyInputManager.isKeyPressed("a");
+    const right = this.keyInputManager.isKeyPressed("d");
+    this.inputDirections = { forward, backward, left, right };
+    this.jumpInput = this.keyInputManager.isJumping();
+    this.runInput = this.keyInputManager.isShiftPressed();
+    if (movementKeysPressed) {
+      const targetAnimation = this.getTargetAnimation();
+      this.model.updateAnimation(targetAnimation, this.timeManager.deltaTime);
+    } else {
+      this.model.updateAnimation(0 /* idle */, this.timeManager.deltaTime);
+    }
+    if (Object.values(this.inputDirections).some((v) => v)) {
+      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) {
+      this.resetPosition();
+    }
+    this.updateNetworkState();
+  }
+  getTargetAnimation() {
+    const { forward, backward, left, right } = this.inputDirections;
+    const hasAnyDirection = forward || backward || left || right;
+    const isRunning = this.runInput && hasAnyDirection;
+    const conflictingDirections = forward && backward || left && right;
+    if (conflictingDirections)
+      return 0 /* idle */;
+    return hasAnyDirection ? isRunning ? 2 /* running */ : 1 /* walking */ : 0 /* idle */;
+  }
+  updateRotationOffset() {
+    const { forward, backward, left, right } = this.inputDirections;
+    if (left && right || forward && backward)
+      return;
+    if (forward) {
+      this.rotationOffset = Math.PI;
+      if (left)
+        this.rotationOffset = Math.PI + Math.PI / 4;
+      if (right)
+        this.rotationOffset = Math.PI - Math.PI / 4;
+    } else if (backward) {
+      this.rotationOffset = Math.PI * 2;
+      if (left)
+        this.rotationOffset = -Math.PI * 2 - Math.PI / 4;
+      if (right)
+        this.rotationOffset = Math.PI * 2 + Math.PI / 4;
+    } else if (left) {
+      this.rotationOffset = Math.PI * -0.5;
+    } else if (right) {
+      this.rotationOffset = Math.PI * 0.5;
+    }
+  }
+  updateAzimuthalAngle() {
+    if (!this.thirdPersonCamera || !this.model?.mesh)
+      return;
+    this.azimuthalAngle = Math.atan2(
+      this.thirdPersonCamera.position.x - this.model.mesh.position.x,
+      this.thirdPersonCamera.position.z - this.model.mesh.position.z
+    );
+  }
+  updateRotation() {
+    if (!this.thirdPersonCamera || !this.model?.mesh)
+      return;
+    this.updateRotationOffset();
+    this.updateAzimuthalAngle();
+    const rotationQuaternion = new Quaternion();
+    rotationQuaternion.setFromAxisAngle(this.upVector, this.azimuthalAngle + this.rotationOffset);
+    this.model.mesh.quaternion.rotateTowards(rotationQuaternion, 0.07);
+  }
+  addScaledVectorToCharacter(deltaTime) {
+    if (!this.model?.mesh)
+      return;
+    this.model.mesh.position.addScaledVector(this.tempVector, this.speed * deltaTime);
+  }
+  updatePosition(deltaTime, _iter) {
+    if (!this.model?.mesh)
+      return;
+    const { forward, backward, left, right } = this.inputDirections;
+    this.targetSpeed = this.runInput ? 14 : 8;
+    this.speed += ease(this.targetSpeed, this.speed, 0.07);
+    if (this.characterOnGround) {
+      this.canJump = true;
+      if (this.jumpInput && this.canJump) {
+        this.characterVelocity.y += this.jumpForce;
+        this.canJump = false;
+      } else {
+        this.characterVelocity.y = deltaTime * this.gravity;
+      }
+    } else {
+      this.characterVelocity.y += deltaTime * this.gravity;
+      this.canJump = false;
+    }
+    this.model.mesh.position.addScaledVector(this.characterVelocity, deltaTime);
+    if (forward) {
+      this.tempVector.set(0, 0, -1).applyAxisAngle(this.upVector, this.azimuthalAngle);
+      this.addScaledVectorToCharacter(deltaTime);
+    }
+    if (backward) {
+      this.tempVector.set(0, 0, 1).applyAxisAngle(this.upVector, this.azimuthalAngle);
+      this.addScaledVectorToCharacter(deltaTime);
+    }
+    if (left) {
+      this.tempVector.set(-1, 0, 0).applyAxisAngle(this.upVector, this.azimuthalAngle);
+      this.addScaledVectorToCharacter(deltaTime);
+    }
+    if (right) {
+      this.tempVector.set(1, 0, 0).applyAxisAngle(this.upVector, this.azimuthalAngle);
+      this.addScaledVectorToCharacter(deltaTime);
+    }
+    this.model.mesh.updateMatrixWorld();
+    this.tempBox.makeEmpty();
+    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.tempBox.expandByPoint(this.tempSegment.start);
+    this.tempBox.expandByPoint(this.tempSegment.end);
+    this.tempBox.min.subScalar(this.capsuleInfo.radius);
+    this.tempBox.max.addScalar(this.capsuleInfo.radius);
+    this.collisionsManager.applyColliders(this.tempSegment, this.capsuleInfo.radius, this.tempBox);
+    const newPosition = this.tempVector;
+    newPosition.copy(this.tempSegment.start);
+    const deltaVector = this.tempVector2;
+    deltaVector.subVectors(newPosition, this.model.mesh.position);
+    const offset = Math.max(0, deltaVector.length() - 1e-5);
+    deltaVector.normalize().multiplyScalar(offset);
+    this.model.mesh.position.add(deltaVector);
+    this.characterOnGround = deltaVector.y > Math.abs(deltaTime * this.characterVelocity.y * 0.25);
+    if (this.characterOnGround) {
+      this.characterVelocity.set(0, 0, 0);
+    } else {
+      deltaVector.normalize();
+      this.characterVelocity.addScaledVector(deltaVector, -deltaVector.dot(this.characterVelocity));
+    }
+  }
+  updateNetworkState() {
+    if (!this.model?.mesh)
+      return;
+    const characterQuaternion = this.model.mesh.getWorldQuaternion(new Quaternion());
+    const positionUpdate = new Vector33(
+      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
+    };
+  }
+  resetPosition() {
+    if (!this.model?.mesh)
+      return;
+    this.characterVelocity.y = 0;
+    this.model.mesh.position.y = 5;
+    this.characterOnGround = false;
+  }
+};
+
+// src/character/Character.ts
+var Character = class {
+  constructor(characterDescription, id, isLocal, modelLoadedCallback, collisionsManager, keyInputManager, cameraManager, timeManager) {
+    this.characterDescription = characterDescription;
+    this.id = id;
+    this.isLocal = isLocal;
+    this.modelLoadedCallback = modelLoadedCallback;
+    this.collisionsManager = collisionsManager;
+    this.keyInputManager = keyInputManager;
+    this.cameraManager = cameraManager;
+    this.timeManager = timeManager;
+    __publicField(this, "controller", null);
+    __publicField(this, "name", null);
+    __publicField(this, "model", null);
+    __publicField(this, "color", new Color2());
+    __publicField(this, "position", new Vector34());
+    this.load();
+  }
+  async load() {
+    this.model = new CharacterModel(this.characterDescription);
+    await this.model.init();
+    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) {
+    if (!this.model)
+      return;
+    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;
+    }
+  }
+};
+
+// src/character/CharacterManager.ts
+import { Group, Vector3 as Vector36 } from "three";
+
+// src/character/RemoteController.ts
+import {
+  AnimationMixer as AnimationMixer2,
+  LoadingManager as LoadingManager2,
+  Object3D as Object3D3,
+  Quaternion as Quaternion2,
+  Vector3 as Vector35
+} from "three";
+import { FBXLoader as FBXLoader2 } from "three/examples/jsm/loaders/FBXLoader.js";
+import { GLTFLoader as GLTFLoader2 } from "three/examples/jsm/loaders/GLTFLoader.js";
+var RemoteController = class {
+  constructor(character, id) {
+    this.character = character;
+    this.id = id;
+    __publicField(this, "characterModel", null);
+    __publicField(this, "loadManager", new LoadingManager2());
+    __publicField(this, "animationMixer", new AnimationMixer2(new Object3D3()));
+    __publicField(this, "animations", /* @__PURE__ */ new Map());
+    __publicField(this, "currentAnimation", 0 /* idle */);
+    __publicField(this, "fbxLoader", new FBXLoader2(this.loadManager));
+    __publicField(this, "gltfLoader", new GLTFLoader2(this.loadManager));
+    __publicField(this, "networkState", {
+      id: 0,
+      position: { x: 0, y: 0, z: 0 },
+      rotation: { quaternionY: 0, quaternionW: 0 },
+      state: this.currentAnimation
+    });
+    this.characterModel = this.character.model.mesh;
+    this.animationMixer = new AnimationMixer2(this.characterModel);
+  }
+  update(clientUpdate, time, deltaTime) {
+    if (!this.character)
+      return;
+    this.character.update(time);
+    this.updateFromNetwork(clientUpdate);
+    this.animationMixer.update(deltaTime);
+  }
+  setAnimationFromFile(animationType, fileName) {
+    const animationFile = `${fileName}`;
+    const extension = fileName.split(".").pop();
+    if (typeof extension !== "string") {
+      console.error(`Error: could not recognize extension of animation: ${animationFile}`);
+      return;
+    }
+    if (["gltf", "glb"].includes(extension)) {
+      this.gltfLoader.load(
+        animationFile,
+        (anim) => {
+          const animation = anim.animations[0];
+          const animationAction = this.animationMixer.clipAction(animation);
+          this.animations.set(animationType, animationAction);
+          if (animationType === 0 /* idle */) {
+            animationAction.play();
+          }
+        },
+        void 0,
+        (error) => console.error(`Error loading ${animationFile}: ${error}`)
+      );
+    } else if (["fbx"].includes(extension)) {
+      this.fbxLoader.load(
+        animationFile,
+        (anim) => {
+          const animation = anim.animations[0];
+          const animationAction = this.animationMixer.clipAction(animation);
+          this.animations.set(animationType, animationAction);
+          if (animationType === 0 /* idle */) {
+            animationAction.play();
+          }
+        },
+        void 0,
+        (error) => console.error(`Error loading ${animationFile}: ${error}`)
+      );
+    }
+  }
+  transitionToAnimation(targetAnimation, transitionDuration = 0.21) {
+    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;
+  }
+  updateFromNetwork(clientUpdate) {
+    if (!this.characterModel)
+      return;
+    const { position, rotation, state } = clientUpdate;
+    this.characterModel.position.lerp(new Vector35(position.x, position.y, position.z), 0.2);
+    const rotationQuaternion = new Quaternion2(0, rotation.quaternionY, 0, rotation.quaternionW);
+    this.characterModel.quaternion.slerp(rotationQuaternion, 0.2);
+    if (state !== this.currentAnimation) {
+      this.transitionToAnimation(state);
+    }
+  }
+};
+
+// src/character/CharacterManager.ts
+function encodeCharacterAndCamera(character, camera) {
+  return [
+    ...character.position.toArray(),
+    ...character.quaternion.toArray(),
+    ...camera.position.toArray(),
+    ...camera.quaternion.toArray()
+  ].join(",");
+}
+function decodeCharacterAndCamera(hash, character, camera) {
+  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));
+}
+var CharacterManager = class {
+  constructor(collisionsManager, cameraManager, timeManager, inputManager, clientStates, sendUpdate) {
+    this.collisionsManager = collisionsManager;
+    this.cameraManager = cameraManager;
+    this.timeManager = timeManager;
+    this.inputManager = inputManager;
+    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).
+    */
+    __publicField(this, "updateLocationHash", false);
+    __publicField(this, "loadingCharacters", /* @__PURE__ */ new Map());
+    __publicField(this, "remoteCharacters", /* @__PURE__ */ new Map());
+    __publicField(this, "remoteCharacterControllers", /* @__PURE__ */ new Map());
+    __publicField(this, "characterDescription", null);
+    __publicField(this, "character", null);
+    __publicField(this, "group");
+    this.group = new Group();
+  }
+  spawnCharacter(characterDescription, id, isLocal = false) {
+    this.characterDescription = characterDescription;
+    const characterLoadingPromise = new Promise((resolve) => {
+      const character = new Character(
+        characterDescription,
+        id,
+        isLocal,
+        () => {
+          if (window.location.hash && window.location.hash.length > 1) {
+            decodeCharacterAndCamera(
+              window.location.hash.substring(1),
+              character.model.mesh,
+              this.cameraManager.camera
+            );
+          } else {
+            const spawnPosition = getSpawnPositionInsideCircle(3, 30, id);
+            character.model.mesh.position.set(spawnPosition.x, spawnPosition.y, spawnPosition.z);
+            this.cameraManager.camera.position.set(
+              spawnPosition.x,
+              spawnPosition.y + 1.5,
+              spawnPosition.z + 3
+            );
+          }
+          character.model.hideMaterialByMeshName("SK_UE5Mannequin_1");
+          this.group.add(character.model.mesh);
+          if (isLocal) {
+            this.character = character;
+          } else {
+            this.remoteCharacters.set(id, character);
+            const remoteController = new RemoteController(character, id);
+            remoteController.setAnimationFromFile(
+              0 /* idle */,
+              characterDescription.idleAnimationFileUrl
+            );
+            remoteController.setAnimationFromFile(
+              1 /* walking */,
+              characterDescription.jogAnimationFileUrl
+            );
+            remoteController.setAnimationFromFile(
+              2 /* running */,
+              characterDescription.sprintAnimationFileUrl
+            );
+            this.remoteCharacterControllers.set(id, remoteController);
+          }
+          resolve(character);
+        },
+        this.collisionsManager,
+        this.inputManager,
+        this.cameraManager,
+        this.timeManager
+      );
+    });
+    this.loadingCharacters.set(id, characterLoadingPromise);
+    return characterLoadingPromise;
+  }
+  getLocalCharacterPositionAndRotation() {
+    if (this.character && this.character.model && this.character.model.mesh) {
+      return {
+        position: this.character.model.mesh.position,
+        rotation: this.character.model.mesh.rotation
+      };
+    }
+    return {
+      position: { x: 0, y: 0, z: 0 },
+      rotation: { x: 0, y: 0, z: 0 }
+    };
+  }
+  clear() {
+    for (const [id, character] of this.remoteCharacters) {
+      this.group.remove(character.model.mesh);
+      this.remoteCharacters.delete(id);
+      this.remoteCharacterControllers.delete(id);
+    }
+    if (this.character) {
+      this.group.remove(this.character.model.mesh);
+      this.character = null;
+    }
+    this.loadingCharacters.clear();
+  }
+  update() {
+    if (this.character) {
+      this.character.update(this.timeManager.time);
+      this.cameraManager.setTarget(this.character.position.add(new Vector36(0, 1.3, 0)));
+      if (this.character.controller) {
+        this.character.controller.update();
+        if (this.timeManager.frame % 2 === 0) {
+          this.sendUpdate(this.character.controller.networkState);
+        }
+      }
+      for (const [id, update] of this.clientStates) {
+        if (!this.remoteCharacters.has(id) && !this.loadingCharacters.has(id)) {
+          this.spawnCharacter(this.characterDescription, id).then(() => {
+            this.loadingCharacters.delete(id);
+          });
+        }
+        const characterController = this.remoteCharacterControllers.get(id);
+        if (characterController) {
+          characterController.update(update, this.timeManager.time, this.timeManager.deltaTime);
+        }
+      }
+      for (const [id, character] of this.remoteCharacters) {
+        if (!this.clientStates.has(id)) {
+          this.group.remove(character.model.mesh);
+          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.cameraManager.camera
+        );
+      }
+    }
+  }
+};
+
+// src/input/KeyInputManager.ts
+var KeyInputManager = class {
+  constructor() {
+    __publicField(this, "keys", /* @__PURE__ */ new Map());
+    document.addEventListener("keydown", this.onKeyDown.bind(this));
+    document.addEventListener("keyup", this.onKeyUp.bind(this));
+  }
+  onKeyDown(event) {
+    this.keys.set(event.key.toLowerCase(), true);
+  }
+  onKeyUp(event) {
+    this.keys.set(event.key.toLowerCase(), false);
+  }
+  isKeyPressed(key) {
+    return this.keys.get(key) || false;
+  }
+  isMovementKeyPressed() {
+    return ["w", "a", "s", "d"].some((key) => this.isKeyPressed(key));
+  }
+  isShiftPressed() {
+    return this.isKeyPressed("shift");
+  }
+  isJumping() {
+    return this.isKeyPressed(" ");
+  }
+  dispose() {
+    document.removeEventListener("keydown", this.onKeyDown.bind(this));
+    document.removeEventListener("keyup", this.onKeyDown.bind(this));
+  }
+};
+
+// src/mml/MMLCompositionScene.ts
+import {
+  InteractionManager,
+  MMLClickTrigger,
+  PromptManager,
+  registerCustomElementsToWindow,
+  setGlobalMScene
+} from "mml-web";
+import { Group as Group2 } from "three";
+var MMLCompositionScene = class {
+  constructor(renderer, scene, camera, audioListener, collisionsManager, getUserPositionAndRotation, documentAddresses) {
+    this.renderer = renderer;
+    this.scene = scene;
+    this.camera = camera;
+    this.audioListener = audioListener;
+    this.collisionsManager = collisionsManager;
+    this.getUserPositionAndRotation = getUserPositionAndRotation;
+    __publicField(this, "group");
+    __publicField(this, "debug", false);
+    __publicField(this, "mmlScene");
+    __publicField(this, "promptManager");
+    __publicField(this, "interactionListener");
+    __publicField(this, "clickTrigger");
+    this.group = new Group2();
+    this.promptManager = PromptManager.init(document.body);
+    const { interactionListener } = InteractionManager.init(document.body, this.camera, this.scene);
+    this.interactionListener = interactionListener;
+    this.mmlScene = {
+      getAudioListener: () => this.audioListener,
+      getRenderer: () => this.renderer,
+      getThreeScene: () => this.scene,
+      getRootContainer: () => this.group,
+      getCamera: () => this.camera,
+      addCollider: (object, mElement) => {
+        this.collisionsManager.addMeshesGroup(object, mElement);
+      },
+      updateCollider: (object) => {
+        this.collisionsManager.updateMeshesGroup(object);
+      },
+      removeCollider: (object) => {
+        this.collisionsManager.removeMeshesGroup(object);
+      },
+      getUserPositionAndRotation: this.getUserPositionAndRotation,
+      addInteraction: (interaction) => {
+        this.interactionListener.addInteraction(interaction);
+      },
+      updateInteraction: (interaction) => {
+        this.interactionListener.updateInteraction(interaction);
+      },
+      removeInteraction: (interaction) => {
+        this.interactionListener.removeInteraction(interaction);
+      },
+      prompt: (promptProps, callback) => {
+        this.promptManager.prompt(promptProps, callback);
+      }
+    };
+    setGlobalMScene(this.mmlScene);
+    registerCustomElementsToWindow(window);
+    this.clickTrigger = MMLClickTrigger.init(document, this.mmlScene);
+    if (this.debug) {
+      console.log(this.clickTrigger);
+    }
+    for (const address of documentAddresses) {
+      const frameElement = document.createElement("m-frame");
+      frameElement.setAttribute("src", address);
+      document.body.appendChild(frameElement);
+    }
+  }
+};
+
+// src/rendering/composer.ts
+import {
+  EffectComposer,
+  RenderPass,
+  EffectPass,
+  FXAAEffect,
+  ShaderPass,
+  BloomEffect
+} from "postprocessing";
+import {
+  ACESFilmicToneMapping,
+  PCFSoftShadowMap,
+  Vector2 as Vector22,
+  WebGLRenderer as WebGLRenderer2
+} from "three";
+
+// src/rendering/post-effects/gauss-grain.ts
+import { ShaderMaterial, Uniform, Vector2 } from "three";
+
+// src/rendering/shaders/vertex-shader.ts
+var vertexShader = (
+  /* glsl */
+  `
+    precision highp float;
+
+    out vec2 vUv;
+    void main() {
+      vUv = uv;
+      gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+    }
+  `
+);
+
+// src/rendering/post-effects/gauss-grain.ts
+var GaussGrainEffect = new ShaderMaterial({
+  uniforms: {
+    tDiffuse: new Uniform(null),
+    resolution: new Uniform(new Vector2()),
+    time: new Uniform(0),
+    amount: new Uniform(0),
+    alpha: new Uniform(0)
+  },
+  vertexShader,
+  fragmentShader: (
+    /* glsl */
+    `
+    precision highp float;
+    in vec2 vUv;
+
+    uniform sampler2D tDiffuse;
+    uniform vec2 resolution;
+    uniform float time;
+    uniform float amount;
+    uniform float alpha;
+
+    const float PI = acos(-1.0);
+    const float TAU = PI * 2.0;
+    const float SQRTAU = sqrt(TAU);
+
+    float gaussian(float z, float u, float o) {
+      return (
+        (1.0 / (o * SQRTAU)) *
+        (exp(-(((z - u) * (z - u)) / (2.0 * (o * o)))))
+      );
+    }
+
+    vec3 gaussgrain() {
+      vec2 ps = vec2(1.01) / resolution.xy;
+      vec2 uv = gl_FragCoord.xy * ps;
+      float t = time;
+      float seed = dot(uv, vec2(12.9898, 78.233));
+      float noise = fract(sin(seed) * 43758.5453123 + t);
+      noise = gaussian(noise, 0.0, 0.5);
+      return vec3(noise);
+    }
+
+    void main(void) {
+      vec2 uv = vUv;
+      vec4 originalColor = texture(tDiffuse, uv);
+      vec3 grain = gaussgrain();
+      vec3 col = originalColor.rgb + (grain * amount);
+      gl_FragColor = vec4(clamp(col, 0.0, 1.0), alpha);
+    }
+  `
+  )
+});
+
+// src/rendering/composer.ts
+var Composer = class {
+  constructor(scene, camera) {
+    __publicField(this, "width", window.innerWidth);
+    __publicField(this, "height", window.innerHeight);
+    __publicField(this, "resolution", new Vector22(this.width, this.height));
+    __publicField(this, "scene");
+    __publicField(this, "camera");
+    __publicField(this, "renderer");
+    __publicField(this, "composer");
+    __publicField(this, "renderPass");
+    __publicField(this, "fxaaEffect");
+    __publicField(this, "fxaaPass");
+    __publicField(this, "bloomEffect");
+    __publicField(this, "bloomPass");
+    __publicField(this, "gaussGrainEffect", GaussGrainEffect);
+    __publicField(this, "gaussGrainPass");
+    this.scene = scene;
+    this.camera = camera;
+    this.renderer = new WebGLRenderer2({
+      powerPreference: "high-performance",
+      antialias: false,
+      stencil: false,
+      depth: false
+    });
+    this.renderer.setSize(this.width, this.height);
+    this.renderer.shadowMap.enabled = true;
+    this.renderer.shadowMap.type = PCFSoftShadowMap;
+    this.renderer.toneMapping = ACESFilmicToneMapping;
+    this.renderer.toneMappingExposure = 0.5;
+    document.body.appendChild(this.renderer.domElement);
+    this.composer = new EffectComposer(this.renderer);
+    this.renderPass = new RenderPass(this.scene, this.camera);
+    this.fxaaEffect = new FXAAEffect();
+    this.fxaaPass = new EffectPass(this.camera, this.fxaaEffect);
+    this.bloomEffect = new BloomEffect();
+    this.bloomPass = new EffectPass(this.camera, this.bloomEffect);
+    this.gaussGrainPass = new ShaderPass(this.gaussGrainEffect, "tDiffuse");
+    this.composer.addPass(this.renderPass);
+    this.composer.addPass(this.fxaaPass);
+    this.composer.addPass(this.bloomPass);
+    this.composer.addPass(this.gaussGrainPass);
+    window.addEventListener("resize", () => {
+      this.updateProjection();
+    });
+    this.updateProjection();
+  }
+  updateProjection() {
+    this.width = window.innerWidth;
+    this.height = innerHeight;
+    this.resolution = new Vector22(this.width, this.height);
+    if (this.composer)
+      this.composer.setSize(this.width, this.height);
+    if (this.fxaaPass)
+      this.fxaaPass.setSize(this.width, this.height);
+    if (this.renderPass)
+      this.renderPass.setSize(this.width, this.height);
+    this.renderer.setSize(this.width, this.height);
+  }
+  render(time) {
+    this.composer.render();
+    this.gaussGrainEffect.uniforms.resolution.value = this.resolution;
+    this.gaussGrainEffect.uniforms.time.value = time;
+    this.gaussGrainEffect.uniforms.alpha.value = 1;
+    this.gaussGrainEffect.uniforms.amount.value = 0.035;
+    this.bloomEffect.intensity = 1;
+  }
+};
+
+// src/time/TimeManager.ts
+import { Clock } from "three";
+var TimeManager = class {
+  constructor() {
+    __publicField(this, "clock", new Clock());
+    __publicField(this, "roundMagnitude", 2e5);
+    __publicField(this, "maxAverageFrames", 300);
+    __publicField(this, "deltaTimes", []);
+    __publicField(this, "targetAverageDeltaTime", 0);
+    __publicField(this, "lerpedAverageMagDelta", 0);
+    __publicField(this, "fpsUpdateTime", 0);
+    __publicField(this, "framesSinceLastFPSUpdate", 0);
+    __publicField(this, "time", 0);
+    __publicField(this, "deltaTime", 0);
+    __publicField(this, "rawDeltaTime", 0);
+    __publicField(this, "frame", 0);
+    __publicField(this, "fps", 0);
+  }
+  update() {
+    this.rawDeltaTime = this.clock.getDelta();
+    this.frame++;
+    this.time += this.rawDeltaTime;
+    this.deltaTimes.push(this.rawDeltaTime);
+    if (this.deltaTimes.length > this.maxAverageFrames) {
+      this.deltaTimes.shift();
+    }
+    this.targetAverageDeltaTime = this.deltaTimes.reduce((prev, curr) => prev + curr, 0) / this.deltaTimes.length;
+    this.lerpedAverageMagDelta += ease(
+      this.targetAverageDeltaTime * this.roundMagnitude,
+      this.lerpedAverageMagDelta,
+      0.12
+    );
+    const revertMagnitude = this.lerpedAverageMagDelta / this.roundMagnitude;
+    const smoothDT = Math.round(revertMagnitude * this.roundMagnitude) / this.roundMagnitude;
+    this.deltaTime = smoothDT > this.rawDeltaTime * 1.75 ? this.rawDeltaTime : smoothDT;
+    this.framesSinceLastFPSUpdate++;
+    if (this.framesSinceLastFPSUpdate >= this.maxAverageFrames) {
+      this.fps = Math.round(this.framesSinceLastFPSUpdate / (this.time - this.fpsUpdateTime) * 100) / 100;
+      this.fpsUpdateTime = this.time;
+      this.framesSinceLastFPSUpdate = 0;
+    }
+  }
+};
+
+// src/collisions/CollisionsManager.ts
+import {
+  MMLCollisionTrigger,
+  getRelativePositionAndRotationRelativeToObject
+} from "mml-web";
+import {
+  Color as Color3,
+  Euler,
+  FrontSide,
+  Mesh as Mesh2,
+  MeshStandardMaterial as MeshStandardMaterial2,
+  Vector3 as Vector37
+} from "three";
+import * as BufferGeometryUtils from "three/examples/jsm/utils/BufferGeometryUtils.js";
+import { MeshBVH, MeshBVHVisualizer } from "three-mesh-bvh";
+var CollisionsManager = class {
+  constructor(scene) {
+    __publicField(this, "debug", false);
+    __publicField(this, "scene");
+    __publicField(this, "tempVector", new Vector37());
+    __publicField(this, "tempVector2", new Vector37());
+    __publicField(this, "collisionMeshState", /* @__PURE__ */ new Map());
+    __publicField(this, "collisionTrigger");
+    this.scene = scene;
+    this.collisionTrigger = MMLCollisionTrigger.init();
+  }
+  createCollisionMeshState(group) {
+    const geometries = [];
+    group.traverse((child) => {
+      if (child.type === "Mesh") {
+        const mesh = child;
+        mesh.localToWorld(new Vector37());
+        mesh.updateMatrixWorld();
+        const clonedGeometry = mesh.geometry.clone();
+        clonedGeometry.applyMatrix4(mesh.matrixWorld);
+        for (const key in clonedGeometry.attributes) {
+          if (key !== "position") {
+            clonedGeometry.deleteAttribute(key);
+          }
+        }
+        if (clonedGeometry.index) {
+          geometries.push(clonedGeometry.toNonIndexed());
+        } else {
+          geometries.push(clonedGeometry);
+        }
+      }
+    });
+    const newBufferGeometry = BufferGeometryUtils.mergeGeometries(geometries);
+    const meshBVH = new MeshBVH(newBufferGeometry);
+    if (!this.debug) {
+      return { source: group, visualizer: null, meshBVH };
+    }
+    const mergedMesh = new Mesh2(
+      newBufferGeometry,
+      new MeshStandardMaterial2({ color: 16711680, side: FrontSide, wireframe: true })
+    );
+    mergedMesh.geometry.boundsTree = meshBVH;
+    const visualizer = new MeshBVHVisualizer(mergedMesh, 3);
+    visualizer.edgeMaterial.color = new Color3(255);
+    visualizer.update();
+    return { source: group, visualizer, meshBVH };
+  }
+  addMeshesGroup(group, mElement) {
+    if (mElement) {
+      this.collisionTrigger.addCollider(group, mElement);
+    }
+    const meshState = this.createCollisionMeshState(group);
+    if (meshState.visualizer) {
+      this.scene.add(meshState.visualizer);
+    }
+    this.collisionMeshState.set(group, meshState);
+  }
+  updateMeshesGroup(group) {
+    const meshState = this.collisionMeshState.get(group);
+    if (meshState) {
+      const newMeshState = this.createCollisionMeshState(group);
+      if (meshState.visualizer) {
+        this.scene.remove(meshState.visualizer);
+      }
+      if (newMeshState.visualizer) {
+        this.scene.add(newMeshState.visualizer);
+      }
+      this.collisionMeshState.set(group, newMeshState);
+    }
+  }
+  removeMeshesGroup(group) {
+    this.collisionTrigger.removeCollider(group);
+    const meshState = this.collisionMeshState.get(group);
+    if (meshState) {
+      if (meshState.visualizer) {
+        this.scene.remove(meshState.visualizer);
+      }
+      this.collisionMeshState.delete(group);
+    }
+  }
+  applyCollider(tempSegment, radius, boundingBox, meshState) {
+    let collisionPosition = null;
+    meshState.meshBVH.shapecast({
+      intersectsBounds: (box) => box.intersectsBox(boundingBox),
+      intersectsTriangle: (tri) => {
+        const triPoint = this.tempVector;
+        const capsulePoint = this.tempVector2;
+        const distance = tri.closestPointToSegment(tempSegment, triPoint, capsulePoint);
+        if (distance < radius) {
+          const depth = radius - distance;
+          collisionPosition = new Vector37().copy(capsulePoint);
+          const direction = capsulePoint.sub(triPoint).normalize();
+          tempSegment.start.addScaledVector(direction, depth);
+          tempSegment.end.addScaledVector(direction, depth);
+        }
+      }
+    });
+    return collisionPosition;
+  }
+  applyColliders(tempSegment, radius, boundingBox) {
+    let collidedElements = null;
+    for (const meshState of this.collisionMeshState.values()) {
+      const collisionPosition = this.applyCollider(tempSegment, radius, boundingBox, meshState);
+      if (collisionPosition) {
+        if (collidedElements === null) {
+          collidedElements = /* @__PURE__ */ new Map();
+        }
+        const relativePosition = getRelativePositionAndRotationRelativeToObject(
+          {
+            position: collisionPosition,
+            rotation: new Euler()
+          },
+          meshState.source
+        );
+        collidedElements.set(meshState.source, {
+          position: relativePosition.position
+        });
+      }
+    }
+    this.collisionTrigger.setCurrentCollisions(collidedElements);
+  }
+};
+export {
+  AnimationState,
+  CameraManager,
+  CharacterManager,
+  CollisionsManager,
+  Composer,
+  KeyInputManager,
+  MMLCompositionScene,
+  TimeManager
+};
+//# sourceMappingURL=index.js.map