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

package/build/index.js

@@ -6,7 +6,7 @@ var __publicField = (obj, key, value) => {
 };
 
 // src/camera/CameraManager.ts
-import { PerspectiveCamera, Vector3 as Vector32 } from "three";
+import { PerspectiveCamera, Raycaster, Vector3 as Vector32 } from "three";
 
 // src/helpers/math-helpers.ts
 import { Vector3 } from "three";
@@ -27,25 +27,51 @@ 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/tweakpane/tweakPaneActivity.ts
+var isTweakpaneActive = false;
+function setTweakpaneActive(status) {
+  isTweakpaneActive = status;
+}
+function getTweakpaneActive() {
+  return isTweakpaneActive;
+}
 
 // src/camera/CameraManager.ts
 var CameraManager = class {
-  constructor() {
+  constructor(collisionsManager) {
+    this.collisionsManager = collisionsManager;
     __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", 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);
-    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;
+    __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));
@@ -65,22 +91,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);
@@ -102,19 +127,41 @@ var CameraManager = class {
     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) {
+    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.updateMatrixWorld();
+      this.camera.position.set(x, clamp(y, 0.1, Infinity), z);
+      this.adjustCameraPosition();
       this.camera.lookAt(this.target);
     }
   }
@@ -225,6 +272,41 @@ ${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() {
@@ -232,16 +314,32 @@ var CharacterMaterial = class extends MeshPhysicalMaterial {
     __publicField(this, "uniforms", {});
     __publicField(this, "colorsCube216", []);
     this.color = new Color(16777215);
-    this.transmission = 0.5;
-    this.metalness = 0.5;
-    this.roughness = 0.3;
-    this.ior = 2;
-    this.thickness = 0.1;
-    this.specularColor = new Color(30719);
-    this.specularIntensity = 0.1;
-    this.envMapIntensity = 1.8;
-    this.sheenColor = new Color(7798903);
-    this.sheen = 0.35;
+    this.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 };
@@ -257,6 +355,7 @@ var CharacterMaterial = class extends MeshPhysicalMaterial {
         shader.fragmentShader,
         /* glsl */
         `
+          //#define showPattern
           varying vec2 vUv;
           uniform float nearClip;
           uniform float farClip;
@@ -265,6 +364,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 +404,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 +427,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++) {
@@ -308,6 +438,34 @@ var CharacterMaterial = class extends MeshPhysicalMaterial {
       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
@@ -323,73 +481,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 +625,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 +681,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 +704,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 +725,7 @@ var CharacterModel = class {
 };
 
 // src/character/LocalController.ts
-import { Box3, Line3, Matrix4, Quaternion, Vector3 as Vector33 } from "three";
+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;
@@ -520,10 +739,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 +760,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 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);
@@ -550,75 +778,90 @@ 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 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 (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;
     }
   }
   updateAzimuthalAngle() {
     if (!this.thirdPersonCamera || !this.model?.mesh)
       return;
-    this.azimuthalAngle = Math.atan2(
-      this.thirdPersonCamera.position.x - this.model.mesh.position.x,
-      this.thirdPersonCamera.position.z - this.model.mesh.position.z
-    );
+    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)
@@ -626,7 +869,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 +880,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 +937,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 +969,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;
   }
 };
@@ -760,6 +1015,7 @@ var Character = class {
     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();
     }
   }
 };
@@ -770,24 +1026,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 +1046,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 +1056,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 +1084,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);
     }
@@ -905,10 +1128,19 @@ var CharacterManager = class {
     __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();
-  }
-  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 +1155,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 +1193,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);
@@ -990,7 +1242,13 @@ var CharacterManager = class {
   update() {
     if (this.character) {
       this.character.update(this.timeManager.time);
-      this.cameraManager.setTarget(this.character.position.add(new Vector36(0, 1.3, 0)));
+      if (this.character.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) {
@@ -998,8 +1256,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 +1295,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 +1312,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));
   }
 };
 
@@ -1128,22 +1415,606 @@ var MMLCompositionScene = class {
 
 // src/rendering/composer.ts
 import {
-  EffectComposer,
+  EffectComposer as EffectComposer2,
   RenderPass,
-  EffectPass,
+  EffectPass as EffectPass2,
   FXAAEffect,
   ShaderPass,
-  BloomEffect
+  BloomEffect as BloomEffect2,
+  SSAOEffect as SSAOEffect2,
+  BlendFunction as BlendFunction3,
+  TextureEffect,
+  ToneMappingEffect as ToneMappingEffect2,
+  SMAAEffect,
+  SMAAPreset,
+  EdgeDetectionMode,
+  PredicationMode,
+  NormalPass
 } from "postprocessing";
 import {
-  ACESFilmicToneMapping,
-  PCFSoftShadowMap,
+  Color as Color4,
+  HalfFloatType,
+  LinearSRGBColorSpace,
+  LoadingManager as LoadingManager2,
+  PMREMGenerator,
   Vector2 as Vector22,
-  WebGLRenderer as WebGLRenderer2
+  WebGLRenderer as WebGLRenderer3
 } from "three";
+import { RGBELoader } from "three/examples/jsm/loaders/RGBELoader.js";
 
-// src/rendering/post-effects/gauss-grain.ts
-import { ShaderMaterial, Uniform, Vector2 } from "three";
+// 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 = (
@@ -1159,14 +2030,86 @@ var vertexShader = (
   `
 );
 
-// src/rendering/post-effects/gauss-grain.ts
-var GaussGrainEffect = new ShaderMaterial({
+// src/rendering/post-effects/bright-contrast-sat.ts
+var BrightnessContrastSaturation = new ShaderMaterial({
   uniforms: {
     tDiffuse: new Uniform(null),
-    resolution: new Uniform(new Vector2()),
-    time: new Uniform(0),
-    amount: new Uniform(0),
-    alpha: new Uniform(0)
+    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: (
@@ -1193,7 +2136,7 @@ var GaussGrainEffect = new ShaderMaterial({
     }
 
     vec3 gaussgrain() {
-      vec2 ps = vec2(1.01) / resolution.xy;
+      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));
@@ -1210,7 +2153,8 @@ var GaussGrainEffect = new ShaderMaterial({
       gl_FragColor = vec4(clamp(col, 0.0, 1.0), alpha);
     }
   `
-  )
+  ),
+  dithering: true
 });
 
 // src/rendering/composer.ts
@@ -1219,6 +2163,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,57 +2173,165 @@ var Composer = class {
     __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 WebGLRenderer2({
+    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 = 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 = composerValues.renderer.exposure;
     document.body.appendChild(this.renderer.domElement);
-    this.composer = new EffectComposer(this.renderer);
+    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.fxaaPass = new EffectPass(this.camera, this.fxaaEffect);
-    this.bloomEffect = new BloomEffect();
-    this.bloomPass = new EffectPass(this.camera, this.bloomEffect);
+    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);
-    window.addEventListener("resize", () => {
-      this.updateProjection();
-    });
+    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);
-    if (this.composer)
-      this.composer.setSize(this.width, this.height);
-    if (this.fxaaPass)
-      this.fxaaPass.setSize(this.width, this.height);
-    if (this.renderPass)
-      this.renderPass.setSize(this.width, this.height);
+    this.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);
   }
-  render(time) {
-    this.composer.render();
+  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 = 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();
+    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)}`);
+      }
+    );
   }
 };
 
@@ -1288,7 +2341,7 @@ var TimeManager = class {
   constructor() {
     __publicField(this, "clock", new Clock());
     __publicField(this, "roundMagnitude", 2e5);
-    __publicField(this, "maxAverageFrames", 300);
+    __publicField(this, "maxAverageFrames", 150);
     __publicField(this, "deltaTimes", []);
     __publicField(this, "targetAverageDeltaTime", 0);
     __publicField(this, "lerpedAverageMagDelta", 0);
@@ -1297,17 +2350,18 @@ var TimeManager = class {
     __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) {
+    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,
@@ -1316,9 +2370,10 @@ var TimeManager = class {
     );
     const revertMagnitude = this.lerpedAverageMagDelta / this.roundMagnitude;
     const smoothDT = Math.round(revertMagnitude * this.roundMagnitude) / this.roundMagnitude;
-    this.deltaTime = smoothDT > this.rawDeltaTime * 1.75 ? this.rawDeltaTime : smoothDT;
+    this.smoothDeltaTime = smoothDT > this.rawDeltaTime * 1.75 ? this.rawDeltaTime : smoothDT;
+    this.deltaTime = this.smoothDeltaTime;
     this.framesSinceLastFPSUpdate++;
-    if (this.framesSinceLastFPSUpdate >= this.maxAverageFrames) {
+    if (this.framesSinceLastFPSUpdate >= 60) {
       this.fps = Math.round(this.framesSinceLastFPSUpdate / (this.time - this.fpsUpdateTime) * 100) / 100;
       this.fpsUpdateTime = this.time;
       this.framesSinceLastFPSUpdate = 0;
@@ -1332,7 +2387,8 @@ import {
   getRelativePositionAndRotationRelativeToObject
 } from "mml-web";
 import {
-  Color as Color3,
+  Color as Color5,
+  DoubleSide,
   Euler,
   FrontSide,
   Mesh as Mesh2,
@@ -1352,6 +2408,18 @@ var CollisionsManager = class {
     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) => {
@@ -1384,7 +2452,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 };
   }