@mml-io/3d-web-client-core 0.0.0-experimental-751c031-20230804

package/build/index.js

@@ -0,0 +1,2544 @@
+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, Raycaster, 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);
+};
+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);
+};
+
+// src/tweakpane/tweakPaneActivity.ts
+var isTweakpaneActive = false;
+function setTweakpaneActive(status) {
+  isTweakpaneActive = status;
+}
+function getTweakpaneActive() {
+  return isTweakpaneActive;
+}
+
+// src/camera/CameraManager.ts
+var CameraManager = class {
+  constructor(collisionsManager) {
+    this.collisionsManager = collisionsManager;
+    __publicField(this, "camera");
+    __publicField(this, "initialDistance", 2.5);
+    __publicField(this, "minDistance", 0.1);
+    __publicField(this, "maxDistance", 6);
+    __publicField(this, "initialFOV", 80);
+    __publicField(this, "fov", this.initialFOV);
+    __publicField(this, "minFOV", 63);
+    __publicField(this, "maxFOV", 85);
+    __publicField(this, "targetFOV", this.initialFOV);
+    __publicField(this, "minPolarAngle", Math.PI * 0.25);
+    __publicField(this, "maxPolarAngle", Math.PI * 0.95);
+    __publicField(this, "dampingFactor", 0.091);
+    __publicField(this, "targetDistance", this.initialDistance);
+    __publicField(this, "distance", this.initialDistance);
+    __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, "dragging", false);
+    __publicField(this, "target", new Vector32(0, 1.55, 0));
+    __publicField(this, "hadTarget", false);
+    __publicField(this, "rayCaster");
+    this.camera = new PerspectiveCamera(this.fov, window.innerWidth / window.innerHeight, 0.1, 400);
+    this.camera.position.set(0, 1.4, -this.initialDistance);
+    this.rayCaster = new Raycaster();
+    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 || getTweakpaneActive() === true)
+      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(this.minPolarAngle, Math.min(this.maxPolarAngle, this.targetPhi));
+  }
+  onMouseWheel(event) {
+    const scrollAmount = event.deltaY * 1e-3;
+    this.targetDistance += scrollAmount;
+    this.targetDistance = Math.max(
+      this.minDistance,
+      Math.min(this.maxDistance, this.targetDistance)
+    );
+  }
+  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;
+  }
+  adjustCameraPosition() {
+    this.rayCaster.set(
+      this.camera.position,
+      this.target.clone().sub(this.camera.position).normalize()
+    );
+    const minimumDistance = this.collisionsManager.raycastFirstDistance(this.rayCaster.ray);
+    const cameraToPlayerDistance = this.camera.position.distanceTo(this.target);
+    if (minimumDistance !== null && minimumDistance <= cameraToPlayerDistance) {
+      this.targetDistance = cameraToPlayerDistance - minimumDistance;
+      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 += (this.targetDistance - this.distance) * this.dampingFactor * 0.21;
+      this.phi += (this.targetPhi - this.phi) * this.dampingFactor;
+      this.theta += (this.targetTheta - this.theta) * this.dampingFactor;
+      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.targetFOV = remap(
+        this.targetDistance,
+        this.minDistance,
+        this.maxDistance,
+        this.minFOV,
+        this.maxFOV
+      );
+      this.fov += ease(this.targetFOV, this.fov, 0.07);
+      this.camera.fov = this.fov;
+      this.camera.updateProjectionMatrix();
+      this.camera.updateMatrixWorld();
+      this.camera.position.set(x, clamp(y, 0.1, Infinity), z);
+      this.adjustCameraPosition();
+      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/tweakpane/characterSettings.ts
+var characterValues = {
+  material: {
+    transmission: 1,
+    metalness: 0.8,
+    roughness: 0.12,
+    ior: 1.5,
+    thickness: 0.1,
+    specularColor: { r: 1, g: 1, b: 1 },
+    specularIntensity: 0.1,
+    emissive: { r: 1, g: 1, b: 1 },
+    emissiveIntensity: 0.1,
+    envMapIntensity: 1,
+    sheenColor: { r: 1, g: 1, b: 1 },
+    sheen: 0.5,
+    clearcoat: 0,
+    clearcoatRoughness: 0
+  }
+};
+var characterOptions = {
+  material: {
+    transmission: { min: 0.01, max: 3, step: 0.01 },
+    metalness: { min: 0, max: 1, step: 0.01 },
+    roughness: { min: 0, max: 1, step: 0.01 },
+    ior: { min: 0, max: 5, step: 0.01 },
+    thickness: { min: 0, max: 1, step: 0.01 },
+    specularIntensity: { min: 0, max: 1, step: 0.01 },
+    emissiveIntensity: { min: 0, max: 1, step: 0.01 },
+    envMapIntensity: { min: 0, max: 1, step: 0.01 },
+    sheen: { min: 0, max: 1, step: 0.01 },
+    clearcoat: { min: 0, max: 1, step: 0.01 },
+    clearcoatRoughness: { min: 0, max: 1, step: 0.01 }
+  }
+};
+
+// src/character/CharacterMaterial.ts
+var CharacterMaterial = class extends MeshPhysicalMaterial {
+  constructor() {
+    super();
+    __publicField(this, "uniforms", {});
+    __publicField(this, "colorsCube216", []);
+    this.color = new Color(16777215);
+    this.transmission = characterValues.material.transmission;
+    this.metalness = characterValues.material.metalness;
+    this.roughness = characterValues.material.roughness;
+    this.ior = characterValues.material.ior;
+    this.thickness = characterValues.material.thickness;
+    this.specularColor = new Color().setRGB(
+      characterValues.material.specularColor.r,
+      characterValues.material.specularColor.g,
+      characterValues.material.specularColor.b
+    );
+    this.specularIntensity = characterValues.material.specularIntensity;
+    this.emissive = new Color().setRGB(
+      characterValues.material.emissive.r,
+      characterValues.material.emissive.g,
+      characterValues.material.emissive.b
+    );
+    this.emissiveIntensity = characterValues.material.emissiveIntensity;
+    this.envMapIntensity = characterValues.material.envMapIntensity;
+    this.sheenColor = new Color().setRGB(
+      characterValues.material.sheenColor.r,
+      characterValues.material.sheenColor.g,
+      characterValues.material.sheenColor.b
+    );
+    this.sheen = characterValues.material.sheen;
+    this.clearcoat = characterValues.material.clearcoat;
+    this.clearcoatRoughness = characterValues.material.clearcoatRoughness;
+    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 */
+        `
+          //#define showPattern
+          varying vec2 vUv;
+          uniform float nearClip;
+          uniform float farClip;
+          uniform float ditheringNear;
+          uniform float ditheringRange;
+          uniform float time;
+          uniform vec3 diffuseRandomColor;
+          ${bayerDither}
+
+          #ifdef showPattern
+          vec2 rand2(vec2 p) {
+            return fract(vec2(sin(p.x * 591.32 + p.y * 154.077), cos(p.x * 391.32 + p.y * 49.077)));
+          }
+          float voronoi(in vec2 x) {
+            vec2 p = floor(x);
+            vec2 f = fract(x);
+            float minDistance = 1.0;
+            for(int j = -1; j <= 1; j ++)
+            for(int i = -1; i <= 1; i ++) {
+              vec2 b = vec2(i, j);
+              vec2 rand = 0.5 + 0.5 * sin(time * 1.5 + 12.0 * rand2(p + b));
+              vec2 r = vec2(b) - f + rand;
+              minDistance = min(minDistance, length(r));
+            }
+            return minDistance;
+          }
+          #endif
+        `
+      );
+      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 uv = vUv;
+          float s = clamp(0.35 + 0.35 * sin(5.0 * -time + vUv.y * 600.0), 0.0, 1.0);
+          float scanLines = pow(s, 1.33);
+
+          outgoingLight *= diffuseRandomColor;
+
+          #ifdef showPattern
+          float val = pow(voronoi(uv * 8.0) * 1.2, 0.5);
+          float thickness = 1.0 / 500.0;
+          vec2 g = step(mod(uv, 0.015), vec2(thickness));
+          float a = 1.0 - clamp(val * (g.x + g.y), 0.0, 1.0);
+          vec3 grid = vec3(smoothstep(0.01, 0.0, a) * 1.15) * diffuseRandomColor;
+          outgoingLight += grid;
+          #endif
+
+          outgoingLight += smoothstep(0.1, 0.0, scanLines) * 0.1;
+        `
+      );
+    };
+    this.generateColorCube();
+  }
+  generateColorCube() {
+    const saturation = 0.4;
+    const lightness = 0.7;
+    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;
+    }
+  }
+  update() {
+    this.transmission = characterValues.material.transmission;
+    this.metalness = characterValues.material.metalness;
+    this.roughness = characterValues.material.roughness;
+    this.ior = characterValues.material.ior;
+    this.thickness = characterValues.material.thickness;
+    this.specularColor = new Color().setRGB(
+      characterValues.material.specularColor.r,
+      characterValues.material.specularColor.g,
+      characterValues.material.specularColor.b
+    );
+    this.specularIntensity = characterValues.material.specularIntensity;
+    this.emissive = new Color().setRGB(
+      characterValues.material.emissive.r,
+      characterValues.material.emissive.g,
+      characterValues.material.emissive.b
+    );
+    this.emissiveIntensity = characterValues.material.emissiveIntensity;
+    this.envMapIntensity = characterValues.material.envMapIntensity;
+    this.sheenColor = new Color().setRGB(
+      characterValues.material.sheenColor.r,
+      characterValues.material.sheenColor.g,
+      characterValues.material.sheenColor.b
+    );
+    this.sheen = characterValues.material.sheen;
+    this.clearcoat = characterValues.material.clearcoat;
+    this.clearcoatRoughness = characterValues.material.clearcoatRoughness;
+  }
+};
+
+// 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 { GLTFLoader as ThreeGLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
+var CachedGLTFLoader = class extends ThreeGLTFLoader {
+  constructor(manager) {
+    super(manager);
+    __publicField(this, "blobCache");
+    this.blobCache = /* @__PURE__ */ new Map();
+  }
+  setBlobUrl(originalUrl, blobUrl) {
+    this.blobCache.set(originalUrl, blobUrl);
+  }
+  getBlobUrl(originalUrl) {
+    return this.blobCache.get(originalUrl);
+  }
+  load(url, onLoad, onProgress, onError) {
+    const blobUrl = this.getBlobUrl(url);
+    if (blobUrl) {
+      console.log(`Loading cached ${url.split("/").pop()}`);
+      super.load(blobUrl, onLoad, onProgress, onError);
+    } else {
+      super.load(url, onLoad, onProgress, onError);
+    }
+  }
+};
+var LRUCache = class {
+  constructor(maxSize = 100) {
+    __publicField(this, "maxSize");
+    __publicField(this, "cache");
+    this.maxSize = maxSize;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    const item = this.cache.get(key);
+    if (item) {
+      this.cache.delete(key);
+      this.cache.set(key, item);
+    }
+    return item;
+  }
+  set(key, value) {
+    if (this.cache.size >= this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      this.cache.delete(oldestKey);
+    }
+    this.cache.set(key, value);
+  }
+};
+var _ModelLoader = class {
+  constructor(maxCacheSize = 100) {
+    __publicField(this, "loadingManager");
+    __publicField(this, "gltfLoader");
+    __publicField(this, "modelCache");
+    __publicField(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 (!_ModelLoader.instance) {
+      _ModelLoader.instance = new _ModelLoader();
+    }
+    return _ModelLoader.instance;
+  }
+  async load(fileUrl, fileType) {
+    const cachedModel = this.modelCache.get(fileUrl);
+    if (cachedModel) {
+      const blobURL = URL.createObjectURL(cachedModel.blob);
+      this.gltfLoader.setBlobUrl(fileUrl, blobURL);
+      return this.loadFromUrl(fileUrl, fileType, cachedModel.originalExtension);
+    } else {
+      console.log(`Loading ${fileUrl} from server`);
+      const ongoingLoad = this.ongoingLoads.get(fileUrl);
+      if (ongoingLoad)
+        return ongoingLoad;
+      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);
+        this.ongoingLoads.delete(fileUrl);
+        return this.loadFromUrl(blobURL, fileType, originalExtension);
+      });
+      this.ongoingLoads.set(fileUrl, loadPromise);
+      return loadPromise;
+    }
+  }
+  async loadFromUrl(url, fileType, extension) {
+    if (["gltf", "glb"].includes(extension)) {
+      return new Promise((resolve, reject) => {
+        this.gltfLoader.load(
+          url,
+          (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 ${url}`;
+              console.error(error);
+              reject(error);
+            }
+          },
+          void 0,
+          (error) => {
+            console.error(`Error loading GL(B|TF) from ${url}: ${error}`);
+            reject(error);
+          }
+        );
+      });
+    } else {
+      console.error(`Error: can't recognize ${url} extension: ${extension}`);
+    }
+  }
+};
+var ModelLoader = _ModelLoader;
+__publicField(ModelLoader, "instance", null);
+var MODEL_LOADER = ModelLoader.getInstance();
+var ModelLoader_default = MODEL_LOADER;
+
+// src/character/CharacterModel.ts
+var CharacterModel = class {
+  constructor(characterDescription) {
+    this.characterDescription = characterDescription;
+    /* TODO: pick between below eager instantiation or ModelLoader.getInstance() lazy one */
+    __publicField(this, "modelLoader", ModelLoader_default);
+    __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 */
+    );
+    await this.setAnimationFromFile(
+      this.characterDescription.airAnimationFileUrl,
+      4 /* air */
+    );
+    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.4, 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.15) {
+    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, Raycaster as Raycaster2, 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, "maxWalkSpeed", 6);
+    __publicField(this, "maxRunSpeed", 8.5);
+    __publicField(this, "gravity", -42);
+    __publicField(this, "jumpForce", 16);
+    __publicField(this, "coyoteTimeThreshold", 290);
+    __publicField(this, "coyoteTime", false);
+    __publicField(this, "canJump", true);
+    __publicField(this, "characterOnGround", false);
+    __publicField(this, "characterWasOnGround", false);
+    __publicField(this, "characterAirborneSince", 0);
+    __publicField(this, "currentHeight", 0);
+    __publicField(this, "characterVelocity", new Vector33());
+    __publicField(this, "vectorUp", new Vector33(0, 1, 0));
+    __publicField(this, "vectorDown", 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, "rayCaster", new Raycaster2());
+    __publicField(this, "forward");
+    __publicField(this, "backward");
+    __publicField(this, "left");
+    __publicField(this, "right");
+    __publicField(this, "run");
+    __publicField(this, "jump");
+    __publicField(this, "anyDirection");
+    __publicField(this, "conflictingDirections");
+    __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 */
+    });
+    setInterval(() => this.update.bind(this), 3e3);
+  }
+  update() {
+    if (!this.model?.mesh || !this.model?.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;
+    this.left = left;
+    this.right = right;
+    this.run = run;
+    this.jump = jump;
+    this.anyDirection = anyDirection;
+    this.conflictingDirections = conflictingDirection;
+    this.targetSpeed = this.run ? this.maxRunSpeed : this.maxWalkSpeed;
+    this.speed += ease(this.targetSpeed, this.speed, 0.07);
+    this.rayCaster.set(this.model.mesh.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);
+    } else {
+      this.model.updateAnimation(0 /* idle */, this.timeManager.deltaTime);
+    }
+    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)
+      this.resetPosition();
+    this.updateNetworkState();
+  }
+  getTargetAnimation() {
+    if (!this.model.mesh)
+      return 0 /* idle */;
+    if (this.conflictingDirections)
+      return 0 /* idle */;
+    const jumpHeight = this.characterVelocity.y > 0 ? 0.2 : 1.8;
+    if (this.currentHeight > jumpHeight && !this.characterOnGround) {
+      return 4 /* air */;
+    }
+    return this.run && this.anyDirection ? 2 /* running */ : this.anyDirection ? 1 /* walking */ : 0 /* idle */;
+  }
+  updateRotationOffset() {
+    if (this.conflictingDirections)
+      return;
+    if (this.forward) {
+      this.rotationOffset = Math.PI;
+      if (this.left)
+        this.rotationOffset = Math.PI + Math.PI / 4;
+      if (this.right)
+        this.rotationOffset = Math.PI - Math.PI / 4;
+    } else if (this.backward) {
+      this.rotationOffset = Math.PI * 2;
+      if (this.left)
+        this.rotationOffset = -Math.PI * 2 - Math.PI / 4;
+      if (this.right)
+        this.rotationOffset = Math.PI * 2 + Math.PI / 4;
+    } else if (this.left) {
+      this.rotationOffset = Math.PI * -0.5;
+    } else if (this.right) {
+      this.rotationOffset = Math.PI * 0.5;
+    }
+  }
+  updateAzimuthalAngle() {
+    if (!this.thirdPersonCamera || !this.model?.mesh)
+      return;
+    const camToModelDistance = this.thirdPersonCamera.position.distanceTo(this.model.mesh.position);
+    const isCameraFirstPerson = camToModelDistance < 2;
+    if (isCameraFirstPerson) {
+      const cameraForward = new Vector33(0, 0, 1).applyQuaternion(this.thirdPersonCamera.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
+      );
+    }
+  }
+  updateRotation() {
+    if (!this.thirdPersonCamera || !this.model?.mesh)
+      return;
+    this.updateRotationOffset();
+    this.updateAzimuthalAngle();
+    const rotationQuaternion = new Quaternion();
+    rotationQuaternion.setFromAxisAngle(this.vectorUp, 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;
+    if (this.characterOnGround) {
+      if (!this.jump)
+        this.canJump = true;
+      if (this.jump && this.canJump) {
+        this.characterVelocity.y += this.jumpForce;
+        this.canJump = false;
+      } else {
+        this.characterVelocity.y = deltaTime * this.gravity;
+      }
+    } else if (this.jump && this.coyoteTime) {
+      console.log("coyoteJump");
+      this.characterVelocity.y = this.jumpForce;
+      this.canJump = false;
+    } else {
+      this.characterVelocity.y += deltaTime * this.gravity;
+      this.canJump = false;
+    }
+    this.model.mesh.position.addScaledVector(this.characterVelocity, deltaTime);
+    this.tempVector.set(0, 0, 0);
+    if (this.forward) {
+      const forward = new Vector33(0, 0, -1).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
+      this.tempVector.add(forward);
+    }
+    if (this.backward) {
+      const backward = new Vector33(0, 0, 1).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
+      this.tempVector.add(backward);
+    }
+    if (this.left) {
+      const left = new Vector33(-1, 0, 0).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
+      this.tempVector.add(left);
+    }
+    if (this.right) {
+      const right = new Vector33(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.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.characterWasOnGround && !this.characterOnGround) {
+      this.characterAirborneSince = Date.now();
+    }
+    this.coyoteTime = this.characterVelocity.y < 0 && this.characterOnGround === false && Date.now() - this.characterAirborneSince < this.coyoteTimeThreshold;
+    this.characterWasOnGround = this.characterOnGround;
+    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 = 3;
+    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;
+      this.model.material.update();
+    }
+  }
+};
+
+// src/character/CharacterManager.ts
+import { Group, Vector3 as Vector36 } from "three";
+
+// src/character/RemoteController.ts
+import {
+  AnimationMixer as AnimationMixer2,
+  Object3D as Object3D3,
+  Quaternion as Quaternion2,
+  Vector3 as Vector35
+} from "three";
+var RemoteController = class {
+  constructor(character, id) {
+    this.character = character;
+    this.id = id;
+    __publicField(this, "modelLoader", ModelLoader_default);
+    __publicField(this, "characterModel", null);
+    __publicField(this, "animationMixer", new AnimationMixer2(new Object3D3()));
+    __publicField(this, "animations", /* @__PURE__ */ new Map());
+    __publicField(this, "currentAnimation", 0 /* idle */);
+    __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.characterModel.updateMatrixWorld();
+    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);
+  }
+  async setAnimationFromFile(animationType, fileName) {
+    const animation = await this.modelLoader.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;
+  }
+  updateFromNetwork(clientUpdate) {
+    if (!this.characterModel)
+      return;
+    const { position, rotation, state } = clientUpdate;
+    this.characterModel.position.lerp(new Vector35(position.x, position.y, position.z), 0.15);
+    const rotationQuaternion = new Quaternion2(0, rotation.quaternionY, 0, rotation.quaternionW);
+    this.characterModel.quaternion.slerp(rotationQuaternion, 0.6);
+    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, "cameraOffsetTarget", 0);
+    __publicField(this, "cameraOffset", 0);
+    __publicField(this, "group");
+    this.group = new Group();
+    setInterval(() => this.update.bind(this), 3e3);
+  }
+  /* 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 Vector36()) {
+    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 {
+            spawnPosition = getSpawnPositionInsideCircle(3, 30, id, 0.4);
+            character.model.mesh.position.set(spawnPosition.x, spawnPosition.y, spawnPosition.z);
+            character.model.mesh.updateMatrixWorld();
+            this.sendUpdate({
+              id,
+              position: {
+                x: spawnPosition.x,
+                y: spawnPosition.y,
+                z: spawnPosition.z
+              },
+              rotation: { quaternionY: 0, quaternionW: 0 },
+              state: 0 /* idle */
+            });
+          }
+          character.model.hideMaterialByMeshName("SK_Mannequin_2");
+          if (!isLocal) {
+            character.model?.mesh?.position.set(spawnPosition.x, spawnPosition.y, spawnPosition.z);
+            character.model?.mesh?.updateMatrixWorld();
+            character.position.set(spawnPosition.x, spawnPosition.y, spawnPosition.z);
+          }
+          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
+            );
+            remoteController.setAnimationFromFile(
+              4 /* air */,
+              characterDescription.airAnimationFileUrl
+            );
+            remoteController.characterModel?.position.set(
+              spawnPosition.x,
+              spawnPosition.y,
+              spawnPosition.z
+            );
+            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);
+      if (this.character.model?.mesh) {
+        this.cameraOffsetTarget = this.cameraManager.targetDistance <= 0.4 ? 0.6 : 0;
+        this.cameraOffset += ease(this.cameraOffsetTarget, this.cameraOffset, 0.1);
+        const targetOffset = new Vector36(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);
+        }
+      }
+      for (const [id, update] of this.clientStates) {
+        const { position } = update;
+        if (!this.remoteCharacters.has(id) && !this.loadingCharacters.has(id)) {
+          this.spawnCharacter(
+            this.characterDescription,
+            id,
+            false,
+            new Vector36(position.x, position.y, position.z)
+          ).then((_character) => {
+            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));
+    window.addEventListener("blur", this.handleUnfocus.bind(this));
+  }
+  handleUnfocus(_event) {
+    this.keys.clear();
+  }
+  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));
+  }
+  get forward() {
+    return this.isKeyPressed("w");
+  }
+  get backward() {
+    return this.isKeyPressed("s");
+  }
+  get left() {
+    return this.isKeyPressed("a");
+  }
+  get right() {
+    return this.isKeyPressed("d");
+  }
+  get run() {
+    return this.isKeyPressed("shift");
+  }
+  get jump() {
+    return this.isKeyPressed(" ");
+  }
+  get anyDirection() {
+    return this.isMovementKeyPressed();
+  }
+  get conflictingDirection() {
+    return this.isKeyPressed("w") && this.isKeyPressed("s") || this.isKeyPressed("a") && this.isKeyPressed("d");
+  }
+  dispose() {
+    document.removeEventListener("keydown", this.onKeyDown.bind(this));
+    document.removeEventListener("keyup", this.onKeyDown.bind(this));
+    window.removeEventListener("blur", this.handleUnfocus.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 as EffectComposer2,
+  RenderPass,
+  EffectPass as EffectPass2,
+  FXAAEffect,
+  ShaderPass,
+  BloomEffect as BloomEffect2,
+  SSAOEffect as SSAOEffect2,
+  BlendFunction as BlendFunction3,
+  TextureEffect,
+  ToneMappingEffect as ToneMappingEffect2,
+  SMAAEffect,
+  SMAAPreset,
+  EdgeDetectionMode,
+  PredicationMode,
+  NormalPass
+} from "postprocessing";
+import {
+  Color as Color4,
+  HalfFloatType,
+  LinearSRGBColorSpace,
+  LoadingManager as LoadingManager2,
+  PMREMGenerator,
+  Vector2 as Vector22,
+  WebGLRenderer as WebGLRenderer3
+} from "three";
+import { RGBELoader } from "three/examples/jsm/loaders/RGBELoader.js";
+
+// src/tweakpane/composerSettings.ts
+import { BlendFunction } from "postprocessing";
+var composerValues = {
+  renderer: {
+    shadowMap: 2,
+    toneMapping: 4,
+    exposure: 1,
+    bgIntensity: 0.6,
+    bgBlurriness: 0
+  },
+  ssao: {
+    blendFunction: BlendFunction.MULTIPLY,
+    distanceScaling: true,
+    depthAwareUpsampling: true,
+    samples: 17,
+    rings: 7,
+    luminanceInfluence: 0.7,
+    radius: 0.03,
+    intensity: 2.5,
+    bias: 0.05,
+    fade: 0.03,
+    resolutionScale: 0.75,
+    color: { r: 0, g: 0, b: 0 },
+    worldDistanceThreshold: 30,
+    worldDistanceFalloff: 7,
+    worldProximityThreshold: 0.5,
+    worldProximityFalloff: 0.3
+  },
+  toneMapping: {
+    mode: 2,
+    resolution: 512,
+    whitePoint: 32,
+    middleGrey: 21,
+    minLuminance: 0.01,
+    averageLuminance: 0.01,
+    adaptationRate: 2
+  },
+  brightness: -0.03,
+  contrast: 1.3,
+  saturation: 0.95,
+  grain: 0.055,
+  bloom: 0.4
+};
+var composerOptions = {
+  renderer: {
+    shadowMap: { min: 0, max: 2, step: 1 },
+    toneMapping: { min: 0, max: 5, step: 1 },
+    exposure: { min: 0, max: 3, step: 0.01 },
+    bgIntensity: { min: 0, max: 1, step: 0.01 },
+    bgBlurriness: { min: 0, max: 0.1, step: 1e-3 }
+  },
+  ssao: {
+    samples: { min: 1, max: 50, step: 1 },
+    rings: { min: 1, max: 50, step: 1 },
+    luminanceInfluence: { min: 0, max: 1, step: 0.01 },
+    radius: { min: 0, max: 0.1, step: 1e-3 },
+    intensity: { min: 0, max: 5, step: 0.1 },
+    bias: { min: 0, max: 0.1, step: 1e-3 },
+    fade: { min: 0, max: 0.1, step: 1e-3 },
+    resolutionScale: { min: 0.25, max: 2, step: 0.25 },
+    worldDistanceThreshold: { min: 0, max: 200, step: 1 },
+    worldDistanceFalloff: { min: 0, max: 200, step: 1 },
+    worldProximityThreshold: { min: 0, max: 2, step: 0.01 },
+    worldProximityFalloff: { min: 0, max: 2, step: 0.01 }
+  },
+  toneMapping: {
+    mode: { min: 0, max: 4, step: 1 },
+    resolution: { min: 64, max: 512, step: 64 },
+    whitePoint: { min: 0, max: 32, step: 0.01 },
+    middleGrey: { min: 0, max: 32, step: 0.01 },
+    minLuminance: { min: 0, max: 32, step: 1e-3 },
+    averageLuminance: { min: 1e-3, max: 0.2, step: 1e-3 },
+    adaptationRate: { min: 0.1, max: 2, step: 0.1 }
+  },
+  brightness: {
+    amount: { min: -1, max: 1, step: 0.01 }
+  },
+  contrast: {
+    amount: { min: 0, max: 2, step: 0.01 }
+  },
+  saturation: {
+    amount: { min: 0, max: 2, step: 0.01 }
+  },
+  grain: {
+    amount: { min: 0, max: 0.2, step: 2e-3 }
+  },
+  bloom: {
+    amount: { min: 0, max: 4, step: 0.1 }
+  }
+};
+var shadowMapTypes = {
+  0: "BasicShadowMap",
+  1: "PCFShadowMap",
+  2: "PCFSoftShadowMap"
+};
+var rendererToneMappingTypes = {
+  0: "NoToneMapping",
+  1: "LinearToneMapping",
+  2: "ReinhardToneMapping",
+  3: "CineonToneMapping",
+  4: "ACESFilmicToneMapping",
+  5: "CustomToneMapping"
+};
+var customToneMappingTypes = {
+  0: "REINHARD",
+  1: "REINHARD2",
+  2: "REINHARD2_ADAPTIVE",
+  3: "OPTIMIZED_CINEON",
+  4: "ACES_FILMIC"
+};
+var rendererBlades = {
+  shadowMapType: shadowMapTypes[composerValues.renderer.shadowMap],
+  toneMappingType: rendererToneMappingTypes[composerValues.renderer.toneMapping]
+};
+var setShadowMapType = (value) => {
+  rendererBlades.shadowMapType = shadowMapTypes[value];
+};
+var setToneMappingType = (value) => {
+  rendererBlades.toneMappingType = rendererToneMappingTypes[value];
+};
+var customToneMappingBlade = {
+  customToneMappingType: customToneMappingTypes[composerValues.toneMapping.mode]
+};
+var setCustomToneMappingType = (value) => {
+  customToneMappingBlade.customToneMappingType = customToneMappingTypes[value];
+};
+var ssaoMaterialParams = [
+  "fade",
+  "bias",
+  "minRadiusScale",
+  "worldDistanceThreshold",
+  "worldDistanceFalloff",
+  "worldProximityThreshold",
+  "worldProximityFalloff"
+];
+var statsData = {
+  triangles: "0",
+  geometries: "0",
+  textures: "0",
+  shaders: "0",
+  postPasses: "0",
+  drawCalls: "0",
+  rawDeltaTime: "0",
+  deltaTime: "0",
+  FPS: "0"
+};
+
+// src/tweakpane/TweakPane.ts
+import {
+  BlendFunction as BlendFunction2
+} from "postprocessing";
+import { Color as Color3 } from "three";
+import { Pane } from "tweakpane";
+var TweakPane = class {
+  constructor(renderer, scene, composer) {
+    __publicField(this, "renderer");
+    __publicField(this, "scene");
+    __publicField(this, "composer");
+    __publicField(this, "gui", new Pane());
+    __publicField(this, "render");
+    __publicField(this, "stats");
+    __publicField(this, "renderOptions");
+    __publicField(this, "ssao");
+    __publicField(this, "toneMapping");
+    __publicField(this, "post");
+    __publicField(this, "export");
+    __publicField(this, "characterMaterial");
+    __publicField(this, "saveVisibilityInLocalStorage", true);
+    __publicField(this, "guiVisible", false);
+    if (this.saveVisibilityInLocalStorage) {
+      const localStorageGuiVisible = localStorage.getItem("guiVisible");
+      if (localStorageGuiVisible !== null) {
+        if (localStorageGuiVisible === "true") {
+          this.guiVisible = true;
+        } else if (localStorageGuiVisible === "false") {
+          this.guiVisible = false;
+        }
+      }
+    }
+    this.renderer = renderer;
+    this.scene = scene;
+    this.composer = composer;
+    this.render = this.gui.addFolder({ title: "rendering", expanded: true });
+    this.stats = this.render.addFolder({ title: "stats", expanded: true });
+    this.renderOptions = this.render.addFolder({ title: "renderOptions", expanded: false });
+    this.toneMapping = this.render.addFolder({ title: "customToneMapping", expanded: false });
+    this.ssao = this.render.addFolder({ title: "ambientOcclusion", expanded: false });
+    this.post = this.render.addFolder({ title: "post", expanded: false });
+    this.toneMapping.hidden = composerValues.renderer.toneMapping === 5 ? false : true;
+    this.characterMaterial = this.gui.addFolder({ title: "characterMaterial", expanded: false });
+    this.characterMaterial.addInput(
+      characterValues.material,
+      "transmission",
+      characterOptions.material.transmission
+    );
+    this.characterMaterial.addInput(
+      characterValues.material,
+      "metalness",
+      characterOptions.material.metalness
+    );
+    this.characterMaterial.addInput(
+      characterValues.material,
+      "roughness",
+      characterOptions.material.roughness
+    );
+    this.characterMaterial.addInput(characterValues.material, "ior", characterOptions.material.ior);
+    this.characterMaterial.addInput(
+      characterValues.material,
+      "thickness",
+      characterOptions.material.thickness
+    );
+    this.characterMaterial.addInput(characterValues.material, "specularColor", {
+      color: { type: "float" }
+    });
+    this.characterMaterial.addInput(
+      characterValues.material,
+      "specularIntensity",
+      characterOptions.material.specularIntensity
+    );
+    this.characterMaterial.addInput(characterValues.material, "emissive", {
+      color: { type: "float" }
+    });
+    this.characterMaterial.addInput(
+      characterValues.material,
+      "emissiveIntensity",
+      characterOptions.material.emissiveIntensity
+    );
+    this.characterMaterial.addInput(
+      characterValues.material,
+      "envMapIntensity",
+      characterOptions.material.envMapIntensity
+    );
+    this.characterMaterial.addInput(characterValues.material, "sheenColor", {
+      color: { type: "float" }
+    });
+    this.characterMaterial.addInput(
+      characterValues.material,
+      "sheen",
+      characterOptions.material.sheen
+    );
+    this.characterMaterial.addInput(
+      characterValues.material,
+      "clearcoat",
+      characterOptions.material.clearcoat
+    );
+    this.characterMaterial.addInput(
+      characterValues.material,
+      "clearcoatRoughness",
+      characterOptions.material.clearcoatRoughness
+    );
+    this.characterMaterial.on("change", (e) => {
+      if (!e.presetKey) {
+        return;
+      }
+      if (e.presetKey === "specularColor") {
+        characterValues.material.specularColor = {
+          r: e.value.r,
+          g: e.value.g,
+          b: e.value.b
+        };
+        return;
+      }
+      if (e.presetKey === "emissive") {
+        characterValues.material.emissive = {
+          r: e.value.r,
+          g: e.value.g,
+          b: e.value.b
+        };
+        return;
+      }
+      if (e.presetKey === "sheenColor") {
+        characterValues.material.sheenColor = {
+          r: e.value.r,
+          g: e.value.g,
+          b: e.value.b
+        };
+        return;
+      }
+    });
+    this.export = this.gui.addFolder({ title: "import/export", expanded: false });
+    window.addEventListener("keydown", this.processKey.bind(this));
+    this.setupGUIListeners.bind(this)();
+    this.setupRenderPane = this.setupRenderPane.bind(this);
+  }
+  processKey(e) {
+    if (e.key === "p")
+      this.toggleGUI();
+  }
+  setupGUIListeners() {
+    const gui = this.gui;
+    const paneElement = gui.containerElem_;
+    paneElement.style.display = this.guiVisible ? "unset" : "none";
+    this.gui.element.addEventListener("mousedown", () => setTweakpaneActive(true));
+    this.gui.element.addEventListener("mouseup", () => setTweakpaneActive(false));
+    this.gui.element.addEventListener("mouseleave", () => setTweakpaneActive(false));
+  }
+  setupRenderPane(ssaoEffect, toneMappingEffect, toneMappingPass, brightnessContrastSaturation, bloomEffect, gaussGrainEffect) {
+    this.stats.addMonitor(statsData, "triangles");
+    this.stats.addMonitor(statsData, "geometries");
+    this.stats.addMonitor(statsData, "textures");
+    this.stats.addMonitor(statsData, "shaders");
+    this.stats.addMonitor(statsData, "postPasses");
+    this.stats.addMonitor(statsData, "drawCalls");
+    this.stats.addMonitor(statsData, "rawDeltaTime");
+    this.stats.addMonitor(statsData, "deltaTime");
+    this.stats.addMonitor(statsData, "FPS");
+    this.renderOptions.addInput(
+      composerValues.renderer,
+      "shadowMap",
+      composerOptions.renderer.shadowMap
+    );
+    this.renderOptions.addMonitor(rendererBlades, "shadowMapType");
+    this.renderOptions.addInput(
+      composerValues.renderer,
+      "toneMapping",
+      composerOptions.renderer.toneMapping
+    );
+    this.renderOptions.addMonitor(rendererBlades, "toneMappingType");
+    this.renderOptions.addInput(
+      composerValues.renderer,
+      "exposure",
+      composerOptions.renderer.exposure
+    );
+    this.renderOptions.addInput(
+      composerValues.renderer,
+      "bgIntensity",
+      composerOptions.renderer.bgIntensity
+    );
+    this.renderOptions.addInput(
+      composerValues.renderer,
+      "bgBlurriness",
+      composerOptions.renderer.bgBlurriness
+    );
+    this.renderOptions.on("change", (e) => {
+      const target = e.target;
+      switch (target.label) {
+        case "shadowMap":
+          this.renderer.shadowMap.type = e.value;
+          setShadowMapType(e.value);
+          break;
+        case "toneMapping":
+          this.renderer.toneMapping = e.value;
+          if (e.value !== 5 && e.value !== 0) {
+            this.toneMapping.hidden = true;
+          } else {
+            this.toneMapping.hidden = false;
+          }
+          toneMappingPass.enabled = e.value === 5 || e.value === 0 ? true : false;
+          setToneMappingType(e.value);
+          break;
+        case "exposure":
+          this.renderer.toneMappingExposure = e.value;
+          break;
+        case "bgIntensity":
+          this.scene.backgroundIntensity = e.value;
+          break;
+        case "bgBlurriness":
+          this.scene.backgroundBlurriness = e.value;
+          break;
+        default:
+          break;
+      }
+    });
+    this.ssao.addInput({ showEffectOnly: false }, "showEffectOnly");
+    this.ssao.addInput(composerValues.ssao, "samples", composerOptions.ssao.samples);
+    this.ssao.addInput(composerValues.ssao, "rings", composerOptions.ssao.rings);
+    this.ssao.addInput(
+      composerValues.ssao,
+      "luminanceInfluence",
+      composerOptions.ssao.luminanceInfluence
+    );
+    this.ssao.addInput(composerValues.ssao, "radius", composerOptions.ssao.radius);
+    this.ssao.addInput(composerValues.ssao, "intensity", composerOptions.ssao.intensity);
+    this.ssao.addInput(composerValues.ssao, "bias", composerOptions.ssao.bias);
+    this.ssao.addInput(composerValues.ssao, "fade", composerOptions.ssao.fade);
+    this.ssao.addInput(
+      composerValues.ssao,
+      "resolutionScale",
+      composerOptions.ssao.resolutionScale
+    );
+    this.ssao.addInput(
+      composerValues.ssao,
+      "worldDistanceThreshold",
+      composerOptions.ssao.worldDistanceThreshold
+    );
+    this.ssao.addInput(
+      composerValues.ssao,
+      "worldDistanceFalloff",
+      composerOptions.ssao.worldDistanceFalloff
+    );
+    this.ssao.addInput(
+      composerValues.ssao,
+      "worldProximityThreshold",
+      composerOptions.ssao.worldProximityThreshold
+    );
+    this.ssao.addInput(
+      composerValues.ssao,
+      "worldProximityFalloff",
+      composerOptions.ssao.worldProximityFalloff
+    );
+    this.ssao.addInput(composerValues.ssao, "color", {
+      color: { alpha: false, type: "float" }
+    });
+    this.ssao.on("change", (e) => {
+      if (!e.presetKey) {
+        return;
+      }
+      const preset = e.presetKey;
+      if (preset === "showEffectOnly") {
+        ssaoEffect.blendMode.blendFunction = e.value === true ? BlendFunction2.NORMAL : BlendFunction2.MULTIPLY;
+        return;
+      }
+      if (preset === "resolutionScale") {
+        ssaoEffect.resolution.scale = e.value;
+        return;
+      }
+      if (ssaoMaterialParams.includes(e.presetKey)) {
+        ssaoEffect.ssaoMaterial[preset] = e.value;
+        return;
+      }
+      if (e.presetKey === "color") {
+        ssaoEffect.color = new Color3().setRGB(e.value.r, e.value.g, e.value.b);
+        return;
+      }
+      ssaoEffect[preset] = e.value;
+    });
+    this.toneMapping.addInput(composerValues.toneMapping, "mode", composerOptions.toneMapping.mode);
+    this.toneMapping.addMonitor(customToneMappingBlade, "customToneMappingType");
+    this.toneMapping.addInput(
+      composerValues.toneMapping,
+      "whitePoint",
+      composerOptions.toneMapping.whitePoint
+    );
+    this.toneMapping.addInput(
+      composerValues.toneMapping,
+      "middleGrey",
+      composerOptions.toneMapping.middleGrey
+    );
+    const minLuminance = this.toneMapping.addInput(
+      composerValues.toneMapping,
+      "minLuminance",
+      composerOptions.toneMapping.minLuminance
+    );
+    minLuminance.hidden = composerValues.toneMapping.mode === 2 ? true : false;
+    const averageLuminance = this.toneMapping.addInput(
+      composerValues.toneMapping,
+      "averageLuminance",
+      composerOptions.toneMapping.averageLuminance
+    );
+    averageLuminance.hidden = composerValues.toneMapping.mode === 2 ? true : false;
+    this.toneMapping.addInput(
+      composerValues.toneMapping,
+      "adaptationRate",
+      composerOptions.toneMapping.adaptationRate
+    );
+    this.toneMapping.on("change", (e) => {
+      if (!e.presetKey) {
+        return;
+      }
+      const preset = e.presetKey;
+      if (preset === "mode") {
+        minLuminance.hidden = composerValues.toneMapping.mode === 2 ? true : false;
+        averageLuminance.hidden = composerValues.toneMapping.mode === 2 ? true : false;
+        setCustomToneMappingType(e.value);
+      }
+      toneMappingEffect[preset] = e.value;
+      return;
+    });
+    this.post.addInput(composerValues, "brightness", composerOptions.brightness.amount);
+    this.post.addInput(composerValues, "contrast", composerOptions.contrast.amount);
+    this.post.addInput(composerValues, "saturation", composerOptions.saturation.amount);
+    this.post.addInput(composerValues, "bloom", composerOptions.bloom.amount);
+    this.post.addInput(composerValues, "grain", composerOptions.grain.amount);
+    this.post.on("change", (e) => {
+      const target = e.presetKey;
+      switch (target) {
+        case "brightness":
+          brightnessContrastSaturation.uniforms.brightness.value = e.value;
+          break;
+        case "contrast":
+          brightnessContrastSaturation.uniforms.contrast.value = e.value;
+          break;
+        case "saturation":
+          brightnessContrastSaturation.uniforms.saturation.value = e.value;
+          break;
+        case "bloom":
+          bloomEffect.intensity = e.value;
+          break;
+        case "grain":
+          gaussGrainEffect.uniforms.amount.value = e.value;
+          break;
+        default:
+          break;
+      }
+    });
+    const exportButton = this.export.addButton({ title: "export" });
+    exportButton.on("click", () => {
+      this.downloadSettingsAsJSON(this.gui.exportPreset());
+    });
+    const importButton = this.export.addButton({ title: "import" });
+    importButton.on("click", () => {
+      this.importSettingsFromJSON((settings) => {
+        this.gui.importPreset(settings);
+      });
+    });
+  }
+  formatDateForFilename() {
+    const date = /* @__PURE__ */ new Date();
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    const hours = String(date.getHours()).padStart(2, "0");
+    const minutes = String(date.getMinutes()).padStart(2, "0");
+    const seconds = String(date.getSeconds()).padStart(2, "0");
+    return `${year}-${month}-${day} ${hours}-${minutes}-${seconds}`;
+  }
+  downloadSettingsAsJSON(settings) {
+    const jsonString = JSON.stringify(settings, null, 2);
+    const blob = new Blob([jsonString], { type: "application/json" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.download = `settings ${this.formatDateForFilename()}.json`;
+    a.href = url;
+    a.click();
+    URL.revokeObjectURL(url);
+  }
+  importSettingsFromJSON(callback) {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = ".json";
+    input.addEventListener("change", (event) => {
+      const file = event.target.files?.[0];
+      if (file) {
+        const reader = new FileReader();
+        reader.onload = (loadEvent) => {
+          try {
+            const settings = JSON.parse(loadEvent.target?.result);
+            callback(settings);
+          } catch (err) {
+            console.error("Error parsing JSON:", err);
+          }
+        };
+        reader.readAsText(file);
+      }
+    });
+    input.click();
+  }
+  updateStats(timeManager) {
+    const { geometries, textures } = this.renderer.info.memory;
+    const { triangles, calls } = this.renderer.info.render;
+    statsData.triangles = triangles.toString();
+    statsData.geometries = geometries.toString();
+    statsData.textures = textures.toString();
+    statsData.shaders = this.renderer.info.programs.length.toString();
+    statsData.postPasses = this.composer.passes.length.toString();
+    statsData.drawCalls = calls.toString();
+    statsData.rawDeltaTime = (Math.round(timeManager.rawDeltaTime * 1e5) / 1e5).toString();
+    statsData.deltaTime = (Math.round(timeManager.deltaTime * 1e5) / 1e5).toString();
+    statsData.FPS = timeManager.fps.toString();
+  }
+  toggleGUI() {
+    const gui = this.gui;
+    const paneElement = gui.containerElem_;
+    paneElement.style.display = this.guiVisible ? "none" : "unset";
+    this.guiVisible = !this.guiVisible;
+    if (this.saveVisibilityInLocalStorage) {
+      localStorage.setItem("guiVisible", this.guiVisible === true ? "true" : "false");
+    }
+  }
+};
+
+// src/rendering/post-effects/bright-contrast-sat.ts
+import { ShaderMaterial, Uniform } 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/bright-contrast-sat.ts
+var BrightnessContrastSaturation = new ShaderMaterial({
+  uniforms: {
+    tDiffuse: new Uniform(null),
+    brightness: new Uniform(0),
+    contrast: new Uniform(1),
+    saturation: new Uniform(1)
+  },
+  vertexShader,
+  fragmentShader: (
+    /* glsl */
+    `
+    precision highp float;
+    in vec2 vUv;
+
+    uniform sampler2D tDiffuse;
+    uniform float brightness;
+    uniform float contrast;
+    uniform float saturation;
+
+    mat4 brightnessMatrix(float brightness) {
+      return mat4(
+        1, 0, 0, 0,
+        0, 1, 0, 0,
+        0, 0, 1, 0,
+        brightness, brightness, brightness, 1
+      );
+    }
+
+    mat4 contrastMatrix(float contrast) {
+      float t = (1.0 - contrast) / 2.0;
+
+      return mat4(
+        contrast, 0, 0, 0,
+        0, contrast, 0, 0,
+        0, 0, contrast, 0,
+        t, t, t, 1
+      );
+    }
+
+    mat4 saturationMatrix(float saturation) {
+      vec3 luminance = vec3(0.3086, 0.6094, 0.0820);
+      float oneMinusSat = 1.0 - saturation;
+      vec3 red = vec3(luminance.x * oneMinusSat);
+      red += vec3(saturation, 0, 0);
+      vec3 green = vec3(luminance.y * oneMinusSat);
+      green += vec3(0, saturation, 0);
+      vec3 blue = vec3(luminance.z * oneMinusSat);
+      blue += vec3(0, 0, saturation);
+      return mat4(
+        red, 0,
+        green, 0,
+        blue, 0,
+        0, 0, 0, 1
+      );
+    }
+
+    void main(void) {
+      vec4 color = texture(tDiffuse, vUv);
+      gl_FragColor = (
+        brightnessMatrix(brightness) *
+        contrastMatrix(contrast) *
+        saturationMatrix(saturation) *
+        color
+      );
+    }
+  `
+  ),
+  dithering: true
+});
+
+// src/rendering/post-effects/gauss-grain.ts
+import { ShaderMaterial as ShaderMaterial2, Uniform as Uniform2, Vector2 } from "three";
+var GaussGrainEffect = new ShaderMaterial2({
+  uniforms: {
+    tDiffuse: new Uniform2(null),
+    resolution: new Uniform2(new Vector2()),
+    time: new Uniform2(0),
+    amount: new Uniform2(0),
+    alpha: new Uniform2(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.0) / 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);
+    }
+  `
+  ),
+  dithering: true
+});
+
+// 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, "isEnvHDRI", false);
+    __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, "toneMappingEffect");
+    __publicField(this, "smaaEffect");
+    __publicField(this, "normalPass");
+    __publicField(this, "normalTextureEffect");
+    __publicField(this, "ssaoEffect");
+    __publicField(this, "ssaoPass");
+    __publicField(this, "toneMappingPass");
+    __publicField(this, "smaaPass");
+    __publicField(this, "bcs", BrightnessContrastSaturation);
+    __publicField(this, "bcsPass");
+    __publicField(this, "gaussGrainEffect", GaussGrainEffect);
+    __publicField(this, "gaussGrainPass");
+    __publicField(this, "tweakPane");
+    this.scene = scene;
+    this.camera = camera;
+    this.renderer = new WebGLRenderer3({
+      powerPreference: "high-performance",
+      antialias: false,
+      stencil: false,
+      depth: false
+    });
+    this.renderer.info.autoReset = false;
+    this.renderer.setSize(this.width, this.height);
+    this.renderer.shadowMap.enabled = true;
+    this.renderer.shadowMap.type = composerValues.renderer.shadowMap;
+    this.renderer.toneMapping = composerValues.renderer.toneMapping;
+    this.renderer.toneMappingExposure = composerValues.renderer.exposure;
+    document.body.appendChild(this.renderer.domElement);
+    this.composer = new EffectComposer2(this.renderer, {
+      frameBufferType: HalfFloatType
+    });
+    this.tweakPane = new TweakPane(this.renderer, this.scene, this.composer);
+    this.renderPass = new RenderPass(this.scene, this.camera);
+    this.normalPass = new NormalPass(this.scene, this.camera);
+    this.normalTextureEffect = new TextureEffect({
+      blendFunction: BlendFunction3.SKIP,
+      texture: this.normalPass.texture
+    });
+    this.fxaaEffect = new FXAAEffect();
+    this.bloomEffect = new BloomEffect2({
+      intensity: composerValues.bloom
+    });
+    this.ssaoEffect = new SSAOEffect2(this.camera, this.normalPass.texture, {
+      blendFunction: composerValues.ssao.blendFunction,
+      distanceScaling: composerValues.ssao.distanceScaling,
+      depthAwareUpsampling: composerValues.ssao.depthAwareUpsampling,
+      samples: composerValues.ssao.samples,
+      rings: composerValues.ssao.rings,
+      luminanceInfluence: composerValues.ssao.luminanceInfluence,
+      radius: composerValues.ssao.radius,
+      intensity: composerValues.ssao.intensity,
+      bias: composerValues.ssao.bias,
+      fade: composerValues.ssao.fade,
+      resolutionScale: composerValues.ssao.resolutionScale,
+      color: new Color4().setRGB(composerValues.ssao.color.r, composerValues.ssao.color.g, composerValues.ssao.color.b),
+      worldDistanceThreshold: composerValues.ssao.worldDistanceThreshold,
+      worldDistanceFalloff: composerValues.ssao.worldDistanceFalloff,
+      worldProximityThreshold: composerValues.ssao.worldProximityThreshold,
+      worldProximityFalloff: composerValues.ssao.worldProximityFalloff
+    });
+    this.fxaaPass = new EffectPass2(this.camera, this.fxaaEffect);
+    this.bloomPass = new EffectPass2(this.camera, this.bloomEffect);
+    this.ssaoPass = new EffectPass2(this.camera, this.ssaoEffect, this.normalTextureEffect);
+    this.toneMappingEffect = new ToneMappingEffect2({
+      mode: composerValues.toneMapping.mode,
+      resolution: composerValues.toneMapping.resolution,
+      whitePoint: composerValues.toneMapping.whitePoint,
+      middleGrey: composerValues.toneMapping.middleGrey,
+      minLuminance: composerValues.toneMapping.minLuminance,
+      averageLuminance: composerValues.toneMapping.averageLuminance,
+      adaptationRate: composerValues.toneMapping.adaptationRate
+    });
+    this.smaaEffect = new SMAAEffect({
+      preset: SMAAPreset.ULTRA,
+      edgeDetectionMode: EdgeDetectionMode.COLOR,
+      predicationMode: PredicationMode.DEPTH
+    });
+    this.toneMappingPass = new EffectPass2(this.camera, this.toneMappingEffect);
+    this.toneMappingPass.enabled = composerValues.renderer.toneMapping === 5 || composerValues.renderer.toneMapping === 0 ? true : false;
+    this.bcsPass = new ShaderPass(this.bcs, "tDiffuse");
+    this.bcs.uniforms.brightness.value = composerValues.brightness;
+    this.bcs.uniforms.contrast.value = composerValues.contrast;
+    this.bcs.uniforms.saturation.value = composerValues.saturation;
+    this.gaussGrainPass = new ShaderPass(this.gaussGrainEffect, "tDiffuse");
+    this.smaaPass = new EffectPass2(this.camera, this.smaaEffect);
+    this.composer.addPass(this.renderPass);
+    this.composer.addPass(this.normalPass);
+    this.composer.addPass(this.ssaoPass);
+    this.composer.addPass(this.fxaaPass);
+    this.composer.addPass(this.smaaPass);
+    this.composer.addPass(this.bloomPass);
+    this.composer.addPass(this.toneMappingPass);
+    this.composer.addPass(this.bcsPass);
+    this.composer.addPass(this.gaussGrainPass);
+    this.tweakPane.setupRenderPane(
+      this.ssaoEffect,
+      this.toneMappingEffect,
+      this.toneMappingPass,
+      this.bcs,
+      this.bloomEffect,
+      this.gaussGrainEffect
+    );
+    window.addEventListener("resize", () => this.updateProjection());
+    this.updateProjection();
+  }
+  updateProjection() {
+    this.width = window.innerWidth;
+    this.height = innerHeight;
+    this.resolution = new Vector22(this.width, this.height);
+    this.composer.setSize(this.width, this.height);
+    this.renderPass.setSize(this.width, this.height);
+    this.normalPass.setSize(this.width, this.height);
+    this.ssaoPass.setSize(this.width, this.height);
+    this.fxaaPass.setSize(this.width, this.height);
+    this.smaaPass.setSize(this.width, this.height);
+    this.bloomPass.setSize(this.width, this.height);
+    this.toneMappingPass.setSize(this.width, this.height);
+    this.gaussGrainPass.setSize(this.width, this.height);
+    this.renderer.setSize(this.width, this.height);
+  }
+  isTweakPaneVisible() {
+    return this.tweakPane.guiVisible;
+  }
+  render(timeManager) {
+    this.renderer.info.reset();
+    this.normalPass.texture.needsUpdate = true;
+    this.gaussGrainEffect.uniforms.resolution.value = this.resolution;
+    this.gaussGrainEffect.uniforms.time.value = timeManager.time;
+    this.gaussGrainEffect.uniforms.alpha.value = 1;
+    this.composer.render();
+    if (this.tweakPane.guiVisible) {
+      this.tweakPane.updateStats(timeManager);
+    }
+  }
+  useHDRI(url) {
+    if (this.isEnvHDRI || !this.renderer)
+      return;
+    const pmremGenerator = new PMREMGenerator(this.renderer);
+    new RGBELoader(new LoadingManager2()).load(
+      url,
+      (texture) => {
+        const envMap = pmremGenerator.fromEquirectangular(texture).texture;
+        if (envMap) {
+          envMap.colorSpace = LinearSRGBColorSpace;
+          envMap.needsUpdate = true;
+          this.scene.environment = envMap;
+          this.scene.background = envMap;
+          this.scene.backgroundIntensity = composerValues.renderer.bgIntensity;
+          this.isEnvHDRI = true;
+          texture.dispose();
+          pmremGenerator.dispose();
+        }
+      },
+      () => {
+      },
+      (error) => {
+        console.error(`Can't load ${url}: ${JSON.stringify(error)}`);
+      }
+    );
+  }
+};
+
+// src/time/TimeManager.ts
+import { Clock } from "three";
+var TimeManager = class {
+  constructor() {
+    __publicField(this, "clock", new Clock());
+    __publicField(this, "roundMagnitude", 2e5);
+    __publicField(this, "maxAverageFrames", 150);
+    __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, "smoothDeltaTime", 0);
+    __publicField(this, "frame", 0);
+    __publicField(this, "fps", 0);
+    __publicField(this, "averageFPS", 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.smoothDeltaTime = smoothDT > this.rawDeltaTime * 1.75 ? this.rawDeltaTime : smoothDT;
+    this.deltaTime = this.smoothDeltaTime;
+    this.framesSinceLastFPSUpdate++;
+    if (this.framesSinceLastFPSUpdate >= 60) {
+      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 Color5,
+  DoubleSide,
+  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();
+  }
+  raycastFirstDistance(ray) {
+    let minimumDistance = Infinity;
+    for (const [, value] of this.collisionMeshState) {
+      const hit = value.meshBVH.raycast(ray, DoubleSide);
+      if (hit.length > 0) {
+        if (hit[0].distance < minimumDistance) {
+          minimumDistance = hit[0].distance;
+        }
+      }
+    }
+    return minimumDistance;
+  }
+  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 Color5(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