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

package/build/index.js

@@ -27,25 +27,53 @@ var round = (n, digits) => {
 var ease = (target, n, factor) => {
   return round((target - n) * factor, 5);
 };
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+var remap = (value, minValue, maxValue, minScaledValue, maxScaledValue) => {
+  return minScaledValue + (maxScaledValue - minScaledValue) * (value - minValue) / (maxValue - minValue);
+};
+
+// src/rendering/tweakPaneActivity.ts
+var isTweakpaneActive = false;
+function setTweakpaneActive(status) {
+  isTweakpaneActive = status;
+}
+function getTweakpaneActive() {
+  return isTweakpaneActive;
+}
 
 // src/camera/CameraManager.ts
 var CameraManager = class {
   constructor() {
     __publicField(this, "camera");
-    __publicField(this, "dragging", false);
-    __publicField(this, "target", new Vector32(0, 1.55, 0));
-    __publicField(this, "targetDistance");
-    __publicField(this, "maxTargetDistance", 20);
-    __publicField(this, "distance");
+    __publicField(this, "initialDistance", 2.5);
+    __publicField(this, "minDistance", 0.1);
+    __publicField(this, "maxDistance", 6);
+    __publicField(this, "initialFOV", 80);
+    __publicField(this, "fov", this.initialFOV);
+    __publicField(this, "minFOV", 65);
+    __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);
-    this.camera = new PerspectiveCamera(80, window.innerWidth / window.innerHeight, 0.1, 2e3);
-    this.camera.position.set(0, 1.4, 3);
-    this.targetDistance = 2.5;
-    this.distance = this.targetDistance;
+    this.camera = new PerspectiveCamera(
+      this.fov,
+      window.innerWidth / window.innerHeight,
+      0.1,
+      2e3
+    );
+    this.camera.position.set(0, 1.4, -this.initialDistance);
     document.addEventListener("mousedown", this.onMouseDown.bind(this));
     document.addEventListener("mouseup", this.onMouseUp.bind(this));
     document.addEventListener("mousemove", this.onMouseMove.bind(this));
@@ -65,22 +93,21 @@ var CameraManager = class {
     this.dragging = false;
   }
   onMouseMove(event) {
-    if (!this.dragging) {
+    if (!this.dragging || getTweakpaneActive() === true)
       return;
-    }
-    if (this.targetTheta === null || this.targetPhi === null) {
+    if (this.targetTheta === null || this.targetPhi === null)
       return;
-    }
     this.targetTheta += event.movementX * 0.01;
     this.targetPhi -= event.movementY * 0.01;
-    this.targetPhi = Math.max(Math.PI * 0.1, Math.min(Math.PI - Math.PI * 0.1, this.targetPhi));
-    this.targetPhi = Math.min(Math.PI * 0.7, this.targetPhi);
+    this.targetPhi = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, this.targetPhi));
   }
   onMouseWheel(event) {
-    const scrollAmount = event.deltaY * 0.01;
+    const scrollAmount = event.deltaY * 1e-3;
     this.targetDistance += scrollAmount;
-    this.targetDistance = Math.max(0, this.targetDistance);
-    this.targetDistance = Math.min(this.targetDistance, this.maxTargetDistance);
+    this.targetDistance = Math.max(
+      this.minDistance,
+      Math.min(this.maxDistance, this.targetDistance)
+    );
   }
   setTarget(target) {
     this.target.copy(target);
@@ -103,18 +130,26 @@ var CameraManager = class {
     this.distance = this.targetDistance;
   }
   update() {
-    if (this.target === null) {
+    if (this.target === null)
       return;
-    }
     if (this.phi !== null && this.targetPhi !== null && this.theta !== null && this.targetTheta !== null) {
-      this.distance += ease(this.targetDistance, this.distance, 0.02);
-      this.distance = Math.min(this.distance, this.maxTargetDistance);
-      this.phi += ease(this.targetPhi, this.phi, 0.07);
-      this.theta += ease(this.targetTheta, this.theta, 0.07);
+      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.camera.position.set(x, y, z);
+      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.position.set(x, clamp(y, 0.1, Infinity), z);
       this.camera.lookAt(this.target);
     }
   }
@@ -233,15 +268,17 @@ var CharacterMaterial = class extends MeshPhysicalMaterial {
     __publicField(this, "colorsCube216", []);
     this.color = new Color(16777215);
     this.transmission = 0.5;
-    this.metalness = 0.5;
-    this.roughness = 0.3;
-    this.ior = 2;
+    this.metalness = 0.9;
+    this.roughness = 0.1;
+    this.ior = 1.2;
     this.thickness = 0.1;
     this.specularColor = new Color(30719);
     this.specularIntensity = 0.1;
+    this.emissive = new Color(16777215);
+    this.emissiveIntensity = 0.1;
     this.envMapIntensity = 1.8;
-    this.sheenColor = new Color(7798903);
-    this.sheen = 0.35;
+    this.sheenColor = new Color(16777215);
+    this.sheen = 0.5;
     this.onBeforeCompile = (shader) => {
       this.uniforms = UniformsUtils.clone(shader.uniforms);
       this.uniforms.nearClip = { value: 0.01 };
@@ -257,6 +294,7 @@ var CharacterMaterial = class extends MeshPhysicalMaterial {
         shader.fragmentShader,
         /* glsl */
         `
+          //#define showPattern
           varying vec2 vUv;
           uniform float nearClip;
           uniform float farClip;
@@ -265,6 +303,25 @@ var CharacterMaterial = class extends MeshPhysicalMaterial {
           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(
@@ -286,10 +343,22 @@ var CharacterMaterial = class extends MeshPhysicalMaterial {
             d = bayerDither(bayerbr, p - ivec2(4, 4));
           }
           if (distance <= ditheringNear + d * ditheringRange) discard;
-          vec2 suv = vUv;
-          float s = clamp(0.35 + 0.35 * sin(5.0 * -time + suv.y * 500.0), 0.0, 1.0);
+
+          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;
         `
       );
@@ -297,8 +366,8 @@ var CharacterMaterial = class extends MeshPhysicalMaterial {
     this.generateColorCube();
   }
   generateColorCube() {
-    const saturation = 0.7;
-    const lightness = 0.8;
+    const saturation = 0.4;
+    const lightness = 0.7;
     const goldenRatioConjugate = 0.618033988749895;
     let hue = 0;
     for (let i = 0; i < 216; i++) {
@@ -323,73 +392,130 @@ var AnimationState = /* @__PURE__ */ ((AnimationState2) => {
 
 // src/character/ModelLoader.ts
 import { LoadingManager } from "three";
-import { FBXLoader } from "three/examples/jsm/loaders/FBXLoader.js";
-import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
-var ModelLoader = class {
-  constructor() {
-    __publicField(this, "debug", false);
+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, "fbxLoader");
     __publicField(this, "gltfLoader");
+    __publicField(this, "modelCache");
+    __publicField(this, "ongoingLoads", /* @__PURE__ */ new Map());
     this.loadingManager = new LoadingManager();
-    this.fbxLoader = new FBXLoader(this.loadingManager);
-    this.gltfLoader = new GLTFLoader(this.loadingManager);
+    this.gltfLoader = new CachedGLTFLoader(this.loadingManager);
+    this.modelCache = new LRUCache(maxCacheSize);
   }
-  async load(fileUrl, fileType) {
-    const extension = fileUrl.split(".").pop();
-    if (typeof extension === "undefined") {
-      console.error(`Unable to identify model type from ${fileUrl}`);
-      return;
+  /* TODO: decide between below lazy initialization or eager on this file's bottom export */
+  static getInstance() {
+    if (!_ModelLoader.instance) {
+      _ModelLoader.instance = new _ModelLoader();
     }
-    const name = fileUrl.split("/").pop().replace(`.${extension}`, "");
-    if (this.debug) {
-      console.log(`Loading ${extension} model ${name} from ${fileUrl}`);
+    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(
-          fileUrl,
+          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 ${fileUrl}`;
+              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 ${fileUrl}: ${error}`);
-            reject(error);
-          }
-        );
-      });
-    } else if (extension === "fbx") {
-      return new Promise((resolve, reject) => {
-        this.fbxLoader.load(
-          fileUrl,
-          (object) => {
-            resolve(object);
-          },
-          void 0,
-          (error) => {
-            console.error(`Error loading FBX from ${fileUrl}: ${error}`);
+            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;
-    __publicField(this, "modelLoader", new ModelLoader());
+    /* 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", {});
@@ -410,6 +536,10 @@ var CharacterModel = class {
       this.characterDescription.sprintAnimationFileUrl,
       2 /* running */
     );
+    await this.setAnimationFromFile(
+      this.characterDescription.airAnimationFileUrl,
+      4 /* air */
+    );
     this.applyMaterialToAllSkinnedMeshes(this.material);
   }
   updateAnimation(targetAnimation, deltaTime) {
@@ -462,7 +592,7 @@ var CharacterModel = class {
     if (typeof mainMesh !== "undefined") {
       this.mesh = new Object3D2();
       const model = mainMesh;
-      model.position.set(0, -0.35, 0);
+      model.position.set(0, -0.4, 0);
       this.mesh.add(model);
       this.mesh.name = name;
       this.mesh.scale.set(scale, scale, scale);
@@ -485,7 +615,7 @@ var CharacterModel = class {
       }
     });
   }
-  transitionToAnimation(targetAnimation, transitionDuration = 0.21) {
+  transitionToAnimation(targetAnimation, transitionDuration = 0.15) {
     if (!this.mesh || this.currentAnimation === null)
       return;
     const currentAction = this.animations[this.currentAnimation];
@@ -506,7 +636,7 @@ var CharacterModel = class {
 };
 
 // src/character/LocalController.ts
-import { Box3, Line3, Matrix4, Quaternion, Vector3 as Vector33 } from "three";
+import { Box3, Line3, Matrix4, Quaternion, Raycaster, Vector3 as Vector33 } from "three";
 var LocalController = class {
   constructor(model, id, collisionsManager, keyInputManager, cameraManager, timeManager) {
     this.model = model;
@@ -520,10 +650,20 @@ var LocalController = class {
       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, "gravity", -20);
-    __publicField(this, "upVector", new Vector33(0, 1, 0));
+    __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());
@@ -531,16 +671,15 @@ var LocalController = class {
     __publicField(this, "tempSegment", new Line3());
     __publicField(this, "tempVector", new Vector33());
     __publicField(this, "tempVector2", new Vector33());
-    __publicField(this, "jumpInput", false);
-    __publicField(this, "jumpForce", 10);
-    __publicField(this, "canJump", true);
-    __publicField(this, "inputDirections", {
-      forward: false,
-      backward: false,
-      left: false,
-      right: false
-    });
-    __publicField(this, "runInput", false);
+    __publicField(this, "rayCaster", new Raycaster());
+    __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);
@@ -550,65 +689,72 @@ var LocalController = class {
       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 movementKeysPressed = this.keyInputManager.isMovementKeyPressed();
-    const forward = this.keyInputManager.isKeyPressed("w");
-    const backward = this.keyInputManager.isKeyPressed("s");
-    const left = this.keyInputManager.isKeyPressed("a");
-    const right = this.keyInputManager.isKeyPressed("d");
-    this.inputDirections = { forward, backward, left, right };
-    this.jumpInput = this.keyInputManager.isJumping();
-    this.runInput = this.keyInputManager.isShiftPressed();
-    if (movementKeysPressed) {
+    const { 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 hit = this.rayCaster.intersectObjects([this.collisionsManager.colliders]);
+    if (hit.length > 0)
+      this.currentHeight = hit[0].distance;
+    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 (Object.values(this.inputDirections).some((v) => v)) {
+    if (this.anyDirection)
       this.updateRotation();
-    }
     for (let i = 0; i < this.collisionDetectionSteps; i++) {
       this.updatePosition(this.timeManager.deltaTime / this.collisionDetectionSteps, i);
     }
-    if (this.model.mesh.position.y < 0) {
+    if (this.model.mesh.position.y < 0)
       this.resetPosition();
-    }
     this.updateNetworkState();
   }
   getTargetAnimation() {
-    const { forward, backward, left, right } = this.inputDirections;
-    const hasAnyDirection = forward || backward || left || right;
-    const isRunning = this.runInput && hasAnyDirection;
-    const conflictingDirections = forward && backward || left && right;
-    if (conflictingDirections)
+    if (!this.model.mesh)
+      return 0 /* idle */;
+    if (this.conflictingDirections)
       return 0 /* idle */;
-    return hasAnyDirection ? isRunning ? 2 /* running */ : 1 /* walking */ : 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() {
-    const { forward, backward, left, right } = this.inputDirections;
-    if (left && right || forward && backward)
+    if (this.conflictingDirections)
       return;
-    if (forward) {
+    if (this.forward) {
       this.rotationOffset = Math.PI;
-      if (left)
+      if (this.left)
         this.rotationOffset = Math.PI + Math.PI / 4;
-      if (right)
+      if (this.right)
         this.rotationOffset = Math.PI - Math.PI / 4;
-    } else if (backward) {
+    } else if (this.backward) {
       this.rotationOffset = Math.PI * 2;
-      if (left)
+      if (this.left)
         this.rotationOffset = -Math.PI * 2 - Math.PI / 4;
-      if (right)
+      if (this.right)
         this.rotationOffset = Math.PI * 2 + Math.PI / 4;
-    } else if (left) {
+    } else if (this.left) {
       this.rotationOffset = Math.PI * -0.5;
-    } else if (right) {
+    } else if (this.right) {
       this.rotationOffset = Math.PI * 0.5;
     }
   }
@@ -626,7 +772,7 @@ var LocalController = class {
     this.updateRotationOffset();
     this.updateAzimuthalAngle();
     const rotationQuaternion = new Quaternion();
-    rotationQuaternion.setFromAxisAngle(this.upVector, this.azimuthalAngle + this.rotationOffset);
+    rotationQuaternion.setFromAxisAngle(this.vectorUp, this.azimuthalAngle + this.rotationOffset);
     this.model.mesh.quaternion.rotateTowards(rotationQuaternion, 0.07);
   }
   addScaledVectorToCharacter(deltaTime) {
@@ -637,36 +783,43 @@ var LocalController = class {
   updatePosition(deltaTime, _iter) {
     if (!this.model?.mesh)
       return;
-    const { forward, backward, left, right } = this.inputDirections;
-    this.targetSpeed = this.runInput ? 14 : 8;
-    this.speed += ease(this.targetSpeed, this.speed, 0.07);
     if (this.characterOnGround) {
-      this.canJump = true;
-      if (this.jumpInput && this.canJump) {
+      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);
-    if (forward) {
-      this.tempVector.set(0, 0, -1).applyAxisAngle(this.upVector, this.azimuthalAngle);
-      this.addScaledVectorToCharacter(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 (backward) {
-      this.tempVector.set(0, 0, 1).applyAxisAngle(this.upVector, this.azimuthalAngle);
-      this.addScaledVectorToCharacter(deltaTime);
+    if (this.backward) {
+      const backward = new Vector33(0, 0, 1).applyAxisAngle(this.vectorUp, this.azimuthalAngle);
+      this.tempVector.add(backward);
     }
-    if (left) {
-      this.tempVector.set(-1, 0, 0).applyAxisAngle(this.upVector, this.azimuthalAngle);
-      this.addScaledVectorToCharacter(deltaTime);
+    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 (right) {
-      this.tempVector.set(1, 0, 0).applyAxisAngle(this.upVector, this.azimuthalAngle);
+    if (this.tempVector.length() > 0) {
+      this.tempVector.normalize();
       this.addScaledVectorToCharacter(deltaTime);
     }
     this.model.mesh.updateMatrixWorld();
@@ -687,6 +840,11 @@ var LocalController = class {
     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 {
@@ -714,7 +872,7 @@ var LocalController = class {
     if (!this.model?.mesh)
       return;
     this.characterVelocity.y = 0;
-    this.model.mesh.position.y = 5;
+    this.model.mesh.position.y = 3;
     this.characterOnGround = false;
   }
 };
@@ -770,24 +928,19 @@ import { Group, Vector3 as Vector36 } from "three";
 // src/character/RemoteController.ts
 import {
   AnimationMixer as AnimationMixer2,
-  LoadingManager as LoadingManager2,
   Object3D as Object3D3,
   Quaternion as Quaternion2,
   Vector3 as Vector35
 } from "three";
-import { FBXLoader as FBXLoader2 } from "three/examples/jsm/loaders/FBXLoader.js";
-import { GLTFLoader as GLTFLoader2 } from "three/examples/jsm/loaders/GLTFLoader.js";
 var RemoteController = class {
   constructor(character, id) {
     this.character = character;
     this.id = id;
+    __publicField(this, "modelLoader", ModelLoader_default);
     __publicField(this, "characterModel", null);
-    __publicField(this, "loadManager", new LoadingManager2());
     __publicField(this, "animationMixer", new AnimationMixer2(new Object3D3()));
     __publicField(this, "animations", /* @__PURE__ */ new Map());
     __publicField(this, "currentAnimation", 0 /* idle */);
-    __publicField(this, "fbxLoader", new FBXLoader2(this.loadManager));
-    __publicField(this, "gltfLoader", new GLTFLoader2(this.loadManager));
     __publicField(this, "networkState", {
       id: 0,
       position: { x: 0, y: 0, z: 0 },
@@ -795,6 +948,7 @@ var RemoteController = class {
       state: this.currentAnimation
     });
     this.characterModel = this.character.model.mesh;
+    this.characterModel.updateMatrixWorld();
     this.animationMixer = new AnimationMixer2(this.characterModel);
   }
   update(clientUpdate, time, deltaTime) {
@@ -804,44 +958,15 @@ var RemoteController = class {
     this.updateFromNetwork(clientUpdate);
     this.animationMixer.update(deltaTime);
   }
-  setAnimationFromFile(animationType, fileName) {
-    const animationFile = `${fileName}`;
-    const extension = fileName.split(".").pop();
-    if (typeof extension !== "string") {
-      console.error(`Error: could not recognize extension of animation: ${animationFile}`);
-      return;
-    }
-    if (["gltf", "glb"].includes(extension)) {
-      this.gltfLoader.load(
-        animationFile,
-        (anim) => {
-          const animation = anim.animations[0];
-          const animationAction = this.animationMixer.clipAction(animation);
-          this.animations.set(animationType, animationAction);
-          if (animationType === 0 /* idle */) {
-            animationAction.play();
-          }
-        },
-        void 0,
-        (error) => console.error(`Error loading ${animationFile}: ${error}`)
-      );
-    } else if (["fbx"].includes(extension)) {
-      this.fbxLoader.load(
-        animationFile,
-        (anim) => {
-          const animation = anim.animations[0];
-          const animationAction = this.animationMixer.clipAction(animation);
-          this.animations.set(animationType, animationAction);
-          if (animationType === 0 /* idle */) {
-            animationAction.play();
-          }
-        },
-        void 0,
-        (error) => console.error(`Error loading ${animationFile}: ${error}`)
-      );
+  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.21) {
+  transitionToAnimation(targetAnimation, transitionDuration = 0.15) {
     if (this.currentAnimation === targetAnimation)
       return;
     const currentAction = this.animations.get(this.currentAnimation);
@@ -861,9 +986,9 @@ var RemoteController = class {
     if (!this.characterModel)
       return;
     const { position, rotation, state } = clientUpdate;
-    this.characterModel.position.lerp(new Vector35(position.x, position.y, position.z), 0.2);
+    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.2);
+    this.characterModel.quaternion.slerp(rotationQuaternion, 0.6);
     if (state !== this.currentAnimation) {
       this.transitionToAnimation(state);
     }
@@ -907,8 +1032,15 @@ var CharacterManager = class {
     __publicField(this, "character", null);
     __publicField(this, "group");
     this.group = new Group();
-  }
-  spawnCharacter(characterDescription, id, isLocal = false) {
+    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(
@@ -923,15 +1055,26 @@ var CharacterManager = class {
               this.cameraManager.camera
             );
           } else {
-            const spawnPosition = getSpawnPositionInsideCircle(3, 30, id);
+            spawnPosition = getSpawnPositionInsideCircle(3, 30, id, 0.4);
             character.model.mesh.position.set(spawnPosition.x, spawnPosition.y, spawnPosition.z);
-            this.cameraManager.camera.position.set(
-              spawnPosition.x,
-              spawnPosition.y + 1.5,
-              spawnPosition.z + 3
-            );
+            character.model.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);
           }
-          character.model.hideMaterialByMeshName("SK_UE5Mannequin_1");
           this.group.add(character.model.mesh);
           if (isLocal) {
             this.character = character;
@@ -950,6 +1093,15 @@ var CharacterManager = class {
               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);
@@ -998,8 +1150,14 @@ var CharacterManager = class {
         }
       }
       for (const [id, update] of this.clientStates) {
+        const { position } = update;
         if (!this.remoteCharacters.has(id) && !this.loadingCharacters.has(id)) {
-          this.spawnCharacter(this.characterDescription, id).then(() => {
+          this.spawnCharacter(
+            this.characterDescription,
+            id,
+            false,
+            new Vector36(position.x, position.y, position.z)
+          ).then((_character) => {
             this.loadingCharacters.delete(id);
           });
         }
@@ -1031,6 +1189,10 @@ var KeyInputManager = class {
     __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);
@@ -1044,15 +1206,34 @@ var KeyInputManager = class {
   isMovementKeyPressed() {
     return ["w", "a", "s", "d"].some((key) => this.isKeyPressed(key));
   }
-  isShiftPressed() {
+  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");
   }
-  isJumping() {
+  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));
   }
 };
 
@@ -1133,14 +1314,125 @@ import {
   EffectPass,
   FXAAEffect,
   ShaderPass,
-  BloomEffect
+  BloomEffect,
+  SSAOEffect,
+  NormalPass,
+  BlendFunction as BlendFunction2,
+  TextureEffect
 } from "postprocessing";
 import {
-  ACESFilmicToneMapping,
-  PCFSoftShadowMap,
+  Color as Color4,
+  LinearSRGBColorSpace,
+  LoadingManager as LoadingManager2,
+  PMREMGenerator,
   Vector2 as Vector22,
   WebGLRenderer as WebGLRenderer2
 } from "three";
+import { RGBELoader } from "three/examples/jsm/loaders/RGBELoader.js";
+import { Pane } from "tweakpane";
+
+// src/rendering/composerSettings.ts
+import { BlendFunction } from "postprocessing";
+import { Color as Color3 } from "three";
+var composerValues = {
+  renderer: {
+    shadowMap: 2,
+    toneMapping: 1,
+    exposure: 0.75,
+    bgIntensity: 0.6,
+    bgBlurriness: 0
+  },
+  ssao: {
+    blendFunction: BlendFunction.MULTIPLY,
+    distanceScaling: true,
+    depthAwareUpsampling: true,
+    samples: 50,
+    rings: 11,
+    luminanceInfluence: 0.3,
+    radius: 0.07,
+    intensity: 3,
+    bias: 0.03,
+    fade: 0.03,
+    resolutionScale: 1,
+    color: new Color3(0),
+    worldDistanceThreshold: 200,
+    worldDistanceFalloff: 2,
+    worldProximityThreshold: 100,
+    worldProximityFalloff: 2
+  },
+  grain: 0.04,
+  bloom: 0.7
+};
+var composerOptions = {
+  renderer: {
+    shadowMap: { min: 0, max: 2, step: 1 },
+    toneMapping: { min: 0, max: 5, step: 1 },
+    exposure: { min: 0, max: 1, 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 }
+  },
+  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 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 ssaoMaterialParams = [
+  "fade",
+  "bias",
+  "minRadiusScale",
+  "worldDistanceThreshold",
+  "worldDistanceFalloff",
+  "worldProximityThreshold",
+  "worldProximityFalloff"
+];
+var statsData = {
+  triangles: "0",
+  geometries: "0",
+  textures: "0",
+  shaders: "0",
+  postPasses: "0",
+  drawCalls: "0",
+  FPS: "0"
+};
 
 // src/rendering/post-effects/gauss-grain.ts
 import { ShaderMaterial, Uniform, Vector2 } from "three";
@@ -1219,6 +1511,7 @@ var Composer = class {
     __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");
@@ -1228,8 +1521,19 @@ var Composer = class {
     __publicField(this, "fxaaPass");
     __publicField(this, "bloomEffect");
     __publicField(this, "bloomPass");
+    __publicField(this, "normalPass");
+    __publicField(this, "normalTextureEffect");
+    __publicField(this, "ssaoEffect");
+    __publicField(this, "ssaoPass");
     __publicField(this, "gaussGrainEffect", GaussGrainEffect);
     __publicField(this, "gaussGrainPass");
+    __publicField(this, "gui", new Pane());
+    __publicField(this, "guiVisible", false);
+    __publicField(this, "stats", this.gui.addFolder({ title: "stats", expanded: true }));
+    __publicField(this, "renderOptions", this.gui.addFolder({ title: "renderOptions", expanded: false }));
+    __publicField(this, "ssao", this.gui.addFolder({ title: "ambientOcclusion", expanded: false }));
+    __publicField(this, "post", this.gui.addFolder({ title: "post", expanded: false }));
+    __publicField(this, "export", this.gui.addFolder({ title: "import/export", expanded: false }));
     this.scene = scene;
     this.camera = camera;
     this.renderer = new WebGLRenderer2({
@@ -1238,27 +1542,161 @@ var Composer = class {
       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 = PCFSoftShadowMap;
-    this.renderer.toneMapping = ACESFilmicToneMapping;
-    this.renderer.toneMappingExposure = 0.5;
+    this.renderer.shadowMap.type = composerValues.renderer.shadowMap;
+    this.renderer.toneMapping = composerValues.renderer.toneMapping;
+    this.renderer.toneMappingExposure = 0.7;
     document.body.appendChild(this.renderer.domElement);
     this.composer = new EffectComposer(this.renderer);
     this.renderPass = new RenderPass(this.scene, this.camera);
+    this.normalPass = new NormalPass(this.scene, this.camera);
+    this.normalTextureEffect = new TextureEffect({
+      blendFunction: BlendFunction2.SKIP,
+      texture: this.normalPass.texture
+    });
     this.fxaaEffect = new FXAAEffect();
+    this.bloomEffect = new BloomEffect({
+      intensity: composerValues.bloom
+    });
+    this.ssaoEffect = new SSAOEffect(this.camera, this.normalPass.texture, {
+      ...composerValues.ssao
+    });
     this.fxaaPass = new EffectPass(this.camera, this.fxaaEffect);
-    this.bloomEffect = new BloomEffect();
     this.bloomPass = new EffectPass(this.camera, this.bloomEffect);
+    this.ssaoPass = new EffectPass(this.camera, this.ssaoEffect, this.normalTextureEffect);
     this.gaussGrainPass = new ShaderPass(this.gaussGrainEffect, "tDiffuse");
     this.composer.addPass(this.renderPass);
+    this.composer.addPass(this.normalPass);
+    this.composer.addPass(this.ssaoPass);
     this.composer.addPass(this.fxaaPass);
     this.composer.addPass(this.bloomPass);
     this.composer.addPass(this.gaussGrainPass);
-    window.addEventListener("resize", () => {
-      this.updateProjection();
-    });
+    window.addEventListener("resize", () => this.updateProjection());
+    window.addEventListener("keydown", this.processKey.bind(this));
+    this.setupGUIListeners.bind(this)();
     this.updateProjection();
+    this.setupTweakPane();
+  }
+  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));
+  }
+  setupTweakPane() {
+    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, "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;
+          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");
+    this.ssao.on("change", (e) => {
+      if (!e.presetKey) {
+        return;
+      }
+      const preset = e.presetKey;
+      if (preset === "showEffectOnly") {
+        this.ssaoEffect.blendMode.blendFunction = e.value === true ? BlendFunction2.NORMAL : BlendFunction2.MULTIPLY;
+        return;
+      }
+      if (preset === "resolutionScale") {
+        this.ssaoEffect.resolution.scale = e.value;
+        return;
+      }
+      if (ssaoMaterialParams.includes(e.presetKey)) {
+        this.ssaoEffect.ssaoMaterial[preset] = e.value;
+        return;
+      }
+      if (e.presetKey === "color") {
+        this.ssaoEffect.color = new Color4().setRGB(
+          e.value.r / 255,
+          e.value.g / 255,
+          e.value.b / 255
+        );
+        return;
+      }
+      this.ssaoEffect[preset] = e.value;
+    });
+    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;
+      console.log(target);
+      switch (target) {
+        case "bloom":
+          this.bloomEffect.intensity = e.value;
+          break;
+        case "grain":
+          this.gaussGrainEffect.uniforms.amount.value = e.value;
+          break;
+        default:
+          break;
+      }
+    });
+    const button = this.export.addButton({ title: "export" });
+    button.on("click", () => {
+      console.log(this.gui.exportPreset());
+    });
+  }
+  toggleGUI() {
+    const gui = this.gui;
+    const paneElement = gui.containerElem_;
+    paneElement.style.display = this.guiVisible ? "none" : "unset";
+    this.guiVisible = !this.guiVisible;
+  }
+  processKey(e) {
+    if (e.key === "p")
+      this.toggleGUI();
   }
   updateProjection() {
     this.width = window.innerWidth;
@@ -1270,15 +1708,59 @@ var Composer = class {
       this.fxaaPass.setSize(this.width, this.height);
     if (this.renderPass)
       this.renderPass.setSize(this.width, this.height);
+    if (this.bloomPass)
+      this.bloomPass.setSize(this.width, this.height);
+    if (this.ssaoPass)
+      this.ssaoPass.setSize(this.width, this.height);
+    if (this.normalPass)
+      this.normalPass.setSize(this.width, this.height);
     this.renderer.setSize(this.width, this.height);
   }
-  render(time) {
-    this.composer.render();
+  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.FPS = Math.round(timeManager.averageFPS).toString();
+  }
+  render(timeManager) {
+    this.renderer.info.reset();
+    this.normalPass.texture.needsUpdate = true;
     this.gaussGrainEffect.uniforms.resolution.value = this.resolution;
-    this.gaussGrainEffect.uniforms.time.value = time;
+    this.gaussGrainEffect.uniforms.time.value = timeManager.time;
     this.gaussGrainEffect.uniforms.alpha.value = 1;
-    this.gaussGrainEffect.uniforms.amount.value = 0.035;
-    this.bloomEffect.intensity = 1;
+    this.composer.render();
+    this.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 = 0.5;
+          this.isEnvHDRI = true;
+          texture.dispose();
+          pmremGenerator.dispose();
+        }
+      },
+      () => {
+      },
+      (error) => {
+        console.error(`Can't load ${url}: ${JSON.stringify(error)}`);
+      }
+    );
   }
 };
 
@@ -1288,8 +1770,10 @@ var TimeManager = class {
   constructor() {
     __publicField(this, "clock", new Clock());
     __publicField(this, "roundMagnitude", 2e5);
-    __publicField(this, "maxAverageFrames", 300);
+    __publicField(this, "maxAverageFrames", 700);
     __publicField(this, "deltaTimes", []);
+    __publicField(this, "fpsMaxSamples", 10);
+    __publicField(this, "fpsSamples", []);
     __publicField(this, "targetAverageDeltaTime", 0);
     __publicField(this, "lerpedAverageMagDelta", 0);
     __publicField(this, "fpsUpdateTime", 0);
@@ -1299,15 +1783,15 @@ var TimeManager = class {
     __publicField(this, "rawDeltaTime", 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) {
+    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,
@@ -1318,8 +1802,14 @@ var TimeManager = class {
     const smoothDT = Math.round(revertMagnitude * this.roundMagnitude) / this.roundMagnitude;
     this.deltaTime = smoothDT > this.rawDeltaTime * 1.75 ? this.rawDeltaTime : smoothDT;
     this.framesSinceLastFPSUpdate++;
-    if (this.framesSinceLastFPSUpdate >= this.maxAverageFrames) {
+    if (this.framesSinceLastFPSUpdate >= 60) {
       this.fps = Math.round(this.framesSinceLastFPSUpdate / (this.time - this.fpsUpdateTime) * 100) / 100;
+      this.fpsSamples.push(this.fps);
+      if (this.fpsSamples.length > this.fpsMaxSamples)
+        this.fpsSamples.shift();
+      this.averageFPS = this.fpsSamples.length === this.fpsMaxSamples ? Math.round(
+        this.fpsSamples.reduce((prev, curr) => prev + curr, 0) / this.fpsSamples.length
+      ) : this.fps;
       this.fpsUpdateTime = this.time;
       this.framesSinceLastFPSUpdate = 0;
     }
@@ -1332,9 +1822,10 @@ import {
   getRelativePositionAndRotationRelativeToObject
 } from "mml-web";
 import {
-  Color as Color3,
+  Color as Color5,
   Euler,
   FrontSide,
+  Group as Group3,
   Mesh as Mesh2,
   MeshStandardMaterial as MeshStandardMaterial2,
   Vector3 as Vector37
@@ -1349,9 +1840,24 @@ var CollisionsManager = class {
     __publicField(this, "tempVector2", new Vector37());
     __publicField(this, "collisionMeshState", /* @__PURE__ */ new Map());
     __publicField(this, "collisionTrigger");
+    __publicField(this, "colliders", new Group3());
+    __publicField(this, "collisionEnabledMeshes", {});
     this.scene = scene;
     this.collisionTrigger = MMLCollisionTrigger.init();
   }
+  safeAddColliders(child) {
+    if (!(child.uuid in this.collisionEnabledMeshes)) {
+      const clone = child.clone();
+      this.collisionEnabledMeshes[child.uuid] = clone;
+      this.colliders.add(clone);
+    }
+  }
+  removeFromColliders(child) {
+    if (child.uuid in this.collisionEnabledMeshes) {
+      this.colliders.remove(this.collisionEnabledMeshes[child.uuid]);
+      delete this.collisionEnabledMeshes[child.uuid];
+    }
+  }
   createCollisionMeshState(group) {
     const geometries = [];
     group.traverse((child) => {
@@ -1359,6 +1865,7 @@ var CollisionsManager = class {
         const mesh = child;
         mesh.localToWorld(new Vector37());
         mesh.updateMatrixWorld();
+        this.safeAddColliders(mesh);
         const clonedGeometry = mesh.geometry.clone();
         clonedGeometry.applyMatrix4(mesh.matrixWorld);
         for (const key in clonedGeometry.attributes) {
@@ -1384,7 +1891,7 @@ var CollisionsManager = class {
     );
     mergedMesh.geometry.boundsTree = meshBVH;
     const visualizer = new MeshBVHVisualizer(mergedMesh, 3);
-    visualizer.edgeMaterial.color = new Color3(255);
+    visualizer.edgeMaterial.color = new Color5(255);
     visualizer.update();
     return { source: group, visualizer, meshBVH };
   }
@@ -1419,6 +1926,13 @@ var CollisionsManager = class {
         this.scene.remove(meshState.visualizer);
       }
       this.collisionMeshState.delete(group);
+      if (group) {
+        group.traverse((child) => {
+          if (child.type === "Mesh") {
+            this.removeFromColliders(child);
+          }
+        });
+      }
     }
   }
   applyCollider(tempSegment, radius, boundingBox, meshState) {