@mavonengine/core 0.0.2

package/dist/cjs/Prefab/Water/Water.cjs

@@ -0,0 +1,234 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Water_exports = {};
+__export(Water_exports, {
+  default: () => Water
+});
+module.exports = __toCommonJS(Water_exports);
+var import_WithEditorHelper = require("../../Editor/WithEditorHelper");
+var import_Game = __toESM(require("../../Game"), 1);
+var import_GameObject = __toESM(require("../../World/GameObject"), 1);
+var import_three = require("three");
+var import_Fragment = __toESM(require("./Fragment.glsl"), 1);
+var import_Vertex = __toESM(require("./Vertex.glsl"), 1);
+var import_WaterManager = __toESM(require("./WaterManager"), 1);
+const MAX_PUSH_POINTS = 150;
+const DEFAULT_LOD = {
+  segments: [512, 128, 32],
+  distances: [40, 60]
+};
+class Water extends (0, import_WithEditorHelper.WithEditorHelper)(import_GameObject.default) {
+  constructor(position, size, sectionCount = 1, lod = DEFAULT_LOD) {
+    super(void 0, position);
+    this.sections = [];
+    this.cullPadding = 0;
+    this.lodConfig = lod;
+    this.sectionCount = sectionCount;
+    this.material = new import_three.ShaderMaterial({
+      transparent: true,
+      stencilWrite: true,
+      stencilFunc: import_three.EqualStencilFunc,
+      stencilRef: 0,
+      stencilZPass: import_three.IncrementStencilOp,
+      fragmentShader: import_Fragment.default,
+      vertexShader: import_Vertex.default,
+      uniforms: {
+        uTime: { value: 0 },
+        uBigWavesElevation: { value: 0.38 },
+        uBigWavesFrequency: { value: new import_three.Vector2(0.326, 0.978) },
+        uBigWavesSpeed: { value: 1 },
+        uDepthColor: { value: new import_three.Color("#186691") },
+        uSurfaceColor: { value: new import_three.Color("#9bd8ff") },
+        uColorOffset: { value: 0.38 },
+        uColorMultiplier: { value: 0.761 },
+        pushPositions: {
+          value: Array.from({ length: MAX_PUSH_POINTS }, () => new import_three.Vector3())
+        },
+        pushRadii: {
+          value: Array.from({ length: MAX_PUSH_POINTS }).fill(0)
+        },
+        uSunDirection: { value: new import_three.Vector3(0, 1, 0) },
+        uSunReflectionStrength: { value: 1 }
+      }
+    });
+    const sectionSize = size / sectionCount;
+    for (let gx = 0; gx < sectionCount; gx++) {
+      for (let gz = 0; gz < sectionCount; gz++) {
+        const offsetX = (gx - (sectionCount - 1) / 2) * sectionSize;
+        const offsetZ = (gz - (sectionCount - 1) / 2) * sectionSize;
+        const farSegments = Math.max(1, Math.round(lod.segments[2] / sectionCount));
+        const geoSize = sectionSize * 1.02;
+        const geometry = new import_three.PlaneGeometry(geoSize, geoSize, farSegments, farSegments);
+        const mesh = new import_three.Mesh(geometry, this.material);
+        mesh.position.set(
+          this.position.x + offsetX,
+          this.position.y,
+          this.position.z + offsetZ
+        );
+        mesh.rotation.x = -Math.PI * 0.5;
+        this.sections.push({ mesh, sectionSize, currentLOD: 2 });
+        import_Game.default.instance().scene.add(mesh);
+      }
+    }
+    this.registerEditorHelper(position, "Water", {
+      addBindings: (folder) => import_WaterManager.default.instance?.addBindings(folder)
+    });
+    for (const section of this.sections)
+      this.tagWithHelper(section.mesh);
+    this.addDebugTools();
+  }
+  addDebugTools() {
+    if (!import_Game.default.instance().debug.active || !import_WaterManager.default.instance)
+      return;
+    import_WaterManager.default.instance.uBigWavesElevationController?.on("change", (ev) => {
+      this.material.uniforms.uBigWavesElevation.value = ev.value;
+    });
+    import_WaterManager.default.instance.uBigWavesFrequencyControllerX?.on("change", (ev) => {
+      this.material.uniforms.uBigWavesFrequency.value.setX(ev.value);
+    });
+    import_WaterManager.default.instance.uBigWavesFrequencyControllerY?.on("change", (ev) => {
+      this.material.uniforms.uBigWavesFrequency.value.setY(ev.value);
+    });
+    import_WaterManager.default.instance.uBigWavesSpeedController?.on("change", (ev) => {
+      this.material.uniforms.uBigWavesSpeed.value = ev.value;
+    });
+    import_WaterManager.default.instance.uDepthColorController?.on("change", (ev) => {
+      this.material.uniforms.uDepthColor.value = new import_three.Color(ev.value);
+    });
+    import_WaterManager.default.instance.uSurfaceColorController?.on("change", (ev) => {
+      this.material.uniforms.uSurfaceColor.value = new import_three.Color(ev.value);
+    });
+    import_WaterManager.default.instance.uColorOffsetController?.on("change", (ev) => {
+      this.material.uniforms.uColorOffset.value = ev.value;
+    });
+    import_WaterManager.default.instance.uColorMultiplierController?.on("change", (ev) => {
+      this.material.uniforms.uColorMultiplier.value = ev.value;
+    });
+    import_WaterManager.default.instance.uSunReflectionStrengthController?.on("change", (ev) => {
+      this.material.uniforms.uSunReflectionStrength.value = ev.value;
+    });
+  }
+  swapGeometry(section, targetLOD) {
+    const segments = Math.max(1, Math.round(this.lodConfig.segments[targetLOD] / this.sectionCount));
+    const oldGeometry = section.mesh.geometry;
+    const geoSize = section.sectionSize * 1.05;
+    const newGeometry = new import_three.PlaneGeometry(
+      geoSize,
+      geoSize,
+      segments,
+      segments
+    );
+    if (this.cullHeight) {
+      this.cullGeometry(newGeometry, section.mesh, this.cullHeight, this.cullPadding);
+    }
+    section.mesh.geometry = newGeometry;
+    section.currentLOD = targetLOD;
+    oldGeometry.dispose();
+  }
+  cullGeometry(geometry, mesh, getHeight, padding) {
+    const position = geometry.attributes.position;
+    const index = geometry.index;
+    if (!index)
+      return;
+    const culled = new Uint8Array(position.count);
+    for (let i = 0; i < position.count; i++) {
+      const worldX = position.getX(i) + mesh.position.x;
+      const worldZ = -position.getY(i) + mesh.position.z;
+      const terrainHeight = getHeight(worldX, worldZ);
+      if (terrainHeight - padding > mesh.position.y) {
+        culled[i] = 1;
+      }
+    }
+    const oldIndices = index.array;
+    const newIndices = [];
+    for (let i = 0; i < oldIndices.length; i += 3) {
+      const a = oldIndices[i];
+      const b = oldIndices[i + 1];
+      const c = oldIndices[i + 2];
+      if (!culled[a] || !culled[b] || !culled[c]) {
+        newIndices.push(a, b, c);
+      }
+    }
+    geometry.setIndex(newIndices);
+  }
+  /**
+   * Removes triangles where all 3 vertices are beneath the surface returned by
+   * `getHeight`. The callback is stored so culling is automatically re-applied
+   * whenever a section swaps LOD.
+   */
+  cullVertices(getHeight, padding = 0) {
+    this.cullHeight = getHeight;
+    this.cullPadding = padding;
+    for (const section of this.sections) {
+      this.cullGeometry(
+        section.mesh.geometry,
+        section.mesh,
+        getHeight,
+        padding
+      );
+    }
+  }
+  setPushPoints(points) {
+    for (let i = 0; i < MAX_PUSH_POINTS; i++) {
+      if (points[i]) {
+        this.material.uniforms.pushPositions.value[i].copy(points[i].position);
+        this.material.uniforms.pushRadii.value[i] = points[i].radius;
+      }
+    }
+  }
+  update(_delta) {
+    this.material.uniforms.uTime.value = import_Game.default.instance().clock.elapsedTime;
+    if (import_WaterManager.default.instance) {
+      this.material.uniforms.uSunDirection.value.copy(import_WaterManager.default.instance.sunPosition);
+    }
+    const cameraPos = import_Game.default.instance().camera.instance.position;
+    for (const section of this.sections) {
+      const distance = cameraPos.distanceTo(section.mesh.position);
+      let targetLOD;
+      if (distance < this.lodConfig.distances[0]) {
+        targetLOD = 0;
+      } else if (distance < this.lodConfig.distances[1]) {
+        targetLOD = 1;
+      } else {
+        targetLOD = 2;
+      }
+      if (targetLOD !== section.currentLOD) {
+        this.swapGeometry(section, targetLOD);
+      }
+    }
+  }
+  destroy() {
+    for (const section of this.sections) {
+      section.mesh.geometry.dispose();
+      import_Game.default.instance().scene.remove(section.mesh);
+    }
+    this.material.dispose();
+    super.destroy();
+  }
+}

package/dist/cjs/Prefab/Water/WaterManager.cjs

@@ -0,0 +1,146 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var WaterManager_exports = {};
+__export(WaterManager_exports, {
+  default: () => WaterManager
+});
+module.exports = __toCommonJS(WaterManager_exports);
+var import_Game = __toESM(require("../../Game"), 1);
+var import_three = require("three");
+class WaterManager {
+  constructor() {
+    this.uBigwavesElevation = 0.2;
+    this.uBigwavesFrequency = new import_three.Vector2(4, 1.5);
+    this.uBigWavesSpeed = 0.75;
+    this.uSurfaceColor = "#9bd8ff";
+    this.uDepthColor = "#186691";
+    this.uColorOffset = 0.08;
+    this.uColorMultiplier = 5;
+    this.sunPosition = new import_three.Vector3(0, 1, 0);
+    this.uSunReflectionStrength = 1;
+    this.waters = [];
+    WaterManager.instance = this;
+    if (import_Game.default.instance().debug.active || import_Game.default.instance().editor) {
+      const waterFolder = import_Game.default.instance().debug.ui?.addFolder({ title: "Water" });
+      if (waterFolder)
+        this.addBindings(waterFolder);
+    }
+  }
+  static init() {
+    WaterManager.instance = new WaterManager();
+  }
+  addBindings(folder) {
+    this.uBigWavesElevationController = folder.addBinding(this, "uBigwavesElevation", {
+      min: 0,
+      max: 1,
+      step: 1e-3,
+      label: "Height"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uBigWavesElevation.value = value;
+      });
+    });
+    this.uBigWavesFrequencyControllerX = folder.addBinding(this.uBigwavesFrequency, "x", {
+      min: 0,
+      max: 10,
+      step: 1e-3,
+      label: "FrequencyX"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uBigWavesFrequency.value.setX(value);
+      });
+    });
+    this.uBigWavesFrequencyControllerY = folder.addBinding(this.uBigwavesFrequency, "y", {
+      min: 0,
+      max: 10,
+      step: 1e-3,
+      label: "FrequencyY"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uBigWavesFrequency.value.setY(value);
+      });
+    });
+    this.uBigWavesSpeedController = folder.addBinding(this, "uBigWavesSpeed", {
+      min: 0,
+      max: 4,
+      step: 1e-3,
+      label: "Speed"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uBigWavesSpeed.value = value;
+      });
+    });
+    this.uSurfaceColorController = folder.addBinding(this, "uSurfaceColor", {
+      label: "Surface Color",
+      view: "color"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uSurfaceColor.value.set(value);
+      });
+    });
+    this.uDepthColorController = folder.addBinding(this, "uDepthColor", {
+      label: "Depth Color",
+      view: "color"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uDepthColor.value.set(value);
+      });
+    });
+    this.uColorOffsetController = folder.addBinding(this, "uColorOffset", {
+      min: 0,
+      max: 1,
+      step: 1e-3,
+      label: "uColorOffset"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uColorOffset.value = value;
+      });
+    });
+    this.uColorMultiplierController = folder.addBinding(this, "uColorMultiplier", {
+      min: 0,
+      max: 10,
+      step: 1e-3,
+      label: "uColorMultiplier"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uColorMultiplier.value = value;
+      });
+    });
+    this.uSunReflectionStrengthController = folder.addBinding(this, "uSunReflectionStrength", {
+      min: 0,
+      max: 3,
+      step: 0.01,
+      label: "Sun Reflection"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uSunReflectionStrength.value = value;
+      });
+    });
+  }
+}

package/dist/cjs/Renderer/AssetRenderer.cjs

@@ -0,0 +1,85 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AssetRenderer_exports = {};
+__export(AssetRenderer_exports, {
+  default: () => AssetRenderer
+});
+module.exports = __toCommonJS(AssetRenderer_exports);
+var import_three = require("three");
+var import_webgpu = require("three/webgpu");
+var import_Game = __toESM(require("../Game"), 1);
+const _AssetRenderer = class _AssetRenderer {
+  constructor(key) {
+    this.item = import_Game.default.instance().resources.items[key];
+    this.initRenderer();
+    if ("scene" in this.item) {
+      _AssetRenderer.previewScene.add(this.item.scene);
+      this.adjustCameraToModel(this.item.scene);
+    }
+  }
+  initRenderer() {
+    if (_AssetRenderer.initialized)
+      return;
+    _AssetRenderer.previewRenderer.setSize(100, 100);
+    const light = new import_webgpu.DirectionalLight(16777215, 3);
+    light.position.set(5, 5, 5);
+    _AssetRenderer.previewScene.add(light);
+    const ambientLight = new import_webgpu.DirectionalLight(16777215, 4);
+    ambientLight.position.set(-5, -5, -5);
+    _AssetRenderer.previewScene.add(ambientLight);
+    _AssetRenderer.initialized = true;
+  }
+  adjustCameraToModel(model) {
+    const box = new import_webgpu.Box3().setFromObject(model);
+    const size = new import_webgpu.Vector3();
+    const center = new import_webgpu.Vector3();
+    box.getSize(size);
+    box.getCenter(center);
+    const maxDim = Math.max(size.x, size.y, size.z);
+    const fov = _AssetRenderer.previewCamera.fov * (Math.PI / 180);
+    const cameraZ = maxDim / (2 * Math.tan(fov / 2));
+    _AssetRenderer.previewCamera.position.set(center.x, center.y, center.z + cameraZ * 1.5);
+    _AssetRenderer.previewCamera.lookAt(center);
+    _AssetRenderer.previewCamera.near = 0.1;
+    _AssetRenderer.previewCamera.far = cameraZ + maxDim * 2;
+    _AssetRenderer.previewCamera.updateProjectionMatrix();
+  }
+  render() {
+    if ("scene" in this.item === false)
+      return;
+    _AssetRenderer.previewRenderer.render(_AssetRenderer.previewScene, _AssetRenderer.previewCamera);
+    _AssetRenderer.previewScene.remove(this.item.scene);
+    return _AssetRenderer.previewRenderer.domElement.toDataURL();
+  }
+};
+_AssetRenderer.previewScene = new import_webgpu.Scene();
+_AssetRenderer.previewRenderer = new import_three.WebGLRenderer({ alpha: true });
+_AssetRenderer.previewCamera = new import_webgpu.PerspectiveCamera(50, 1, 0, 10);
+_AssetRenderer.initialized = false;
+let AssetRenderer = _AssetRenderer;

package/dist/cjs/Renderer/PhysicsRenderer.cjs

@@ -0,0 +1,84 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var PhysicsRenderer_exports = {};
+__export(PhysicsRenderer_exports, {
+  RapierDebugRenderer: () => RapierDebugRenderer
+});
+module.exports = __toCommonJS(PhysicsRenderer_exports);
+var import_three = require("three");
+var import_Game = __toESM(require("../Game"), 1);
+class RapierDebugRenderer {
+  constructor(scene, world, enabled = false) {
+    this.stats = {
+      bodies: 0,
+      colliders: 0,
+      active: 0
+    };
+    this.world = world;
+    this.mesh = new import_three.LineSegments(new import_three.BufferGeometry(), new import_three.LineBasicMaterial({ color: 16777215, vertexColors: true }));
+    this.mesh.frustumCulled = false;
+    this.enabled = enabled;
+    scene.add(this.mesh);
+    const physicsPane = import_Game.default.instance().debug.ui?.addFolder({
+      title: "Physics"
+    });
+    if (physicsPane) {
+      physicsPane.addBinding(this.stats, "bodies", { label: "Bodies", readonly: true });
+      physicsPane.addBinding(this.stats, "colliders", { label: "Colliders", readonly: true });
+      physicsPane.addBinding(this.stats, "active", { label: "Active", readonly: true });
+      this.toggleVisible(true);
+    }
+  }
+  toggleVisible(visible) {
+    this.enabled = visible;
+  }
+  update() {
+    if (this.enabled) {
+      const { vertices, colors } = this.world.debugRender();
+      this.mesh.geometry.setAttribute("position", new import_three.BufferAttribute(vertices, 3));
+      this.mesh.geometry.setAttribute("color", new import_three.BufferAttribute(colors, 4));
+      this.mesh.visible = true;
+      this.stats.bodies = 0;
+      this.stats.active = 0;
+      this.stats.colliders = this.world.colliders.len();
+      this.world.bodies.forEach((body) => {
+        this.stats.bodies++;
+        if (!body.isSleeping() && body.isEnabled()) {
+          this.stats.active++;
+        }
+      });
+    } else {
+      this.mesh.visible = false;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RapierDebugRenderer
+});

package/dist/cjs/Renderer.cjs

@@ -0,0 +1,135 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Renderer_exports = {};
+__export(Renderer_exports, {
+  default: () => Renderer
+});
+module.exports = __toCommonJS(Renderer_exports);
+var import_three = require("three");
+var import_three_perf = require("three-perf");
+var import_Addons = require("three/examples/jsm/Addons.js");
+var import_Game = __toESM(require("./Game"), 1);
+var import_SkeletonAxesHelper = __toESM(require("./Utils/SkeletonAxesHelper"), 1);
+class Renderer {
+  constructor(parameters) {
+    this.options = {
+      wireframe: false,
+      perf: false,
+      armature: false
+    };
+    this.armatureHelpers = [];
+    this.fps = 0;
+    this._fpsFrameCount = 0;
+    this._fpsElapsed = 0;
+    this.instance = new import_three.WebGLRenderer(parameters);
+    this.composer = new import_Addons.EffectComposer(this.instance);
+    this.composer.addPass(
+      new import_Addons.RenderPass(
+        import_Game.default.instance().scene,
+        import_Game.default.instance().camera.instance
+      )
+    );
+    this.composer.addPass(new import_Addons.OutputPass());
+    this.instance.shadowMap.enabled = true;
+    this.instance.shadowMap.type = import_three.PCFSoftShadowMap;
+    this.instance.setSize(
+      import_Game.default.instance().sizes.width,
+      import_Game.default.instance().sizes.height
+    );
+    this.instance.setClearColor("#181818");
+    this.instance.setPixelRatio(import_Game.default.instance().sizes.pixelRatio);
+    this.composer.setPixelRatio(import_Game.default.instance().sizes.pixelRatio);
+    this.composer.setSize(
+      import_Game.default.instance().sizes.width,
+      import_Game.default.instance().sizes.height
+    );
+    const renderDebug = import_Game.default.instance().debug.ui?.addFolder({ title: "Render" });
+    if (renderDebug) {
+      this.perf = new import_three_perf.ThreePerf({
+        anchorX: "right",
+        anchorY: "bottom",
+        memory: true,
+        guiVisible: false,
+        domElement: document.body,
+        renderer: this.instance
+      });
+      renderDebug.addBinding(this.options, "wireframe").on("change", () => {
+        import_Game.default.instance().scene.traverse((object) => {
+          if (object instanceof import_three.Mesh && object.material) {
+            object.material.wireframe = this.options.wireframe;
+          }
+        });
+      });
+      renderDebug.addBinding(this.options, "armature").on("change", () => {
+        if (this.options.armature) {
+          import_Game.default.instance().scene.traverse((object) => {
+            if (object instanceof import_three.SkinnedMesh) {
+              const skeletonHelper = new import_three.SkeletonHelper(object.skeleton.bones[0]);
+              const axesHelper = new import_SkeletonAxesHelper.default(object.skeleton.bones[0]);
+              import_Game.default.instance().scene.add(skeletonHelper, axesHelper);
+              this.armatureHelpers.push(skeletonHelper, axesHelper);
+            }
+          });
+        } else {
+          for (const helper of this.armatureHelpers) {
+            import_Game.default.instance().scene.remove(helper);
+            if (helper instanceof import_SkeletonAxesHelper.default) {
+              helper.dispose();
+            }
+          }
+          this.armatureHelpers = [];
+        }
+      });
+    }
+  }
+  resize() {
+    this.instance.setSize(
+      import_Game.default.instance().sizes.width,
+      import_Game.default.instance().sizes.height
+    );
+    this.instance.setPixelRatio(import_Game.default.instance().sizes.pixelRatio);
+    this.composer.setPixelRatio(import_Game.default.instance().sizes.pixelRatio);
+    this.composer.setSize(
+      import_Game.default.instance().sizes.width,
+      import_Game.default.instance().sizes.height
+    );
+  }
+  update(delta) {
+    this.perf?.begin();
+    this.composer.render(delta);
+    this.perf?.end();
+    this._fpsFrameCount++;
+    this._fpsElapsed += delta;
+    if (this._fpsElapsed >= 0.5) {
+      this.fps = Math.round(this._fpsFrameCount / this._fpsElapsed);
+      this._fpsFrameCount = 0;
+      this._fpsElapsed = 0;
+    }
+  }
+}