@mavonengine/editor 0.0.2 → 0.0.3

package/dist/Editor-BwUHVuHu.mjs

@@ -0,0 +1,1333 @@
+import { Quaternion as S, Controls as Ee, Vector3 as l, Raycaster as Le, Object3D as le, MeshBasicMaterial as me, LineBasicMaterial as Xe, CylinderGeometry as g, BoxGeometry as v, BufferGeometry as pe, Float32BufferAttribute as he, Mesh as o, OctahedronGeometry as se, Line as B, TorusGeometry as j, SphereGeometry as He, Euler as Oe, Matrix4 as ce, PlaneGeometry as Ye, DoubleSide as fe, OrthographicCamera as Ze, Color as F, Vector2 as k, WebGLRenderTarget as X, MeshDepthMaterial as Ue, RGBADepthPacking as je, NoBlending as we, HalfFloatType as U, UniformsUtils as Fe, ShaderMaterial as V, AdditiveBlending as Ve } from "three";
+import Ge from "@mavonengine/core/Editor/EditorHelper";
+import c from "@mavonengine/core/Game";
+import { AmbientLightPrimitive as We, DirectionalLightShadowPrimitive as qe } from "@mavonengine/core/Prefab/Lights/index";
+import { PlanePrimitive as Ke, BoxPrimitive as Ne, SpherePrimitive as $e, ConePrimitive as Je, CylinderPrimitive as et, OctahedronPrimitive as tt, DodecahedronPrimitive as it, CapsulePrimitive as st, IcosahedronPrimitive as nt, TorusKnotPrimitive as at } from "@mavonengine/core/Prefab/Primitives/index";
+import rt from "@mavonengine/core/Utils/EventEmitter";
+const ot = { type: "change" }, ge = 1e-6, ye = new S();
+class lt extends Ee {
+  /**
+   * Constructs a new controls instance.
+   *
+   * @param {Object3D} object - The object that is managed by the controls.
+   * @param {?HTMLDOMElement} domElement - The HTML element used for event listeners.
+   */
+  constructor(e, t = null) {
+    super(e, t), this.movementSpeed = 1, this.rollSpeed = 5e-3, this.dragToLook = !1, this.autoForward = !1, this._moveState = { up: 0, down: 0, left: 0, right: 0, forward: 0, back: 0, pitchUp: 0, pitchDown: 0, yawLeft: 0, yawRight: 0, rollLeft: 0, rollRight: 0 }, this._moveVector = new l(0, 0, 0), this._rotationVector = new l(0, 0, 0), this._lastQuaternion = new S(), this._lastPosition = new l(), this._status = 0, this._onKeyDown = ht.bind(this), this._onKeyUp = ct.bind(this), this._onPointerMove = dt.bind(this), this._onPointerDown = ut.bind(this), this._onPointerUp = pt.bind(this), this._onPointerCancel = ft.bind(this), this._onContextMenu = mt.bind(this), t !== null && this.connect(t);
+  }
+  connect(e) {
+    super.connect(e), window.addEventListener("keydown", this._onKeyDown), window.addEventListener("keyup", this._onKeyUp), this.domElement.addEventListener("pointermove", this._onPointerMove), this.domElement.addEventListener("pointerdown", this._onPointerDown), this.domElement.addEventListener("pointerup", this._onPointerUp), this.domElement.addEventListener("pointercancel", this._onPointerCancel), this.domElement.addEventListener("contextmenu", this._onContextMenu);
+  }
+  disconnect() {
+    window.removeEventListener("keydown", this._onKeyDown), window.removeEventListener("keyup", this._onKeyUp), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.domElement.removeEventListener("pointerdown", this._onPointerDown), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.domElement.removeEventListener("pointercancel", this._onPointerCancel), this.domElement.removeEventListener("contextmenu", this._onContextMenu);
+  }
+  dispose() {
+    this.disconnect();
+  }
+  update(e) {
+    if (this.enabled === !1) return;
+    const t = this.object, n = e * this.movementSpeed, s = e * this.rollSpeed;
+    t.translateX(this._moveVector.x * n), t.translateY(this._moveVector.y * n), t.translateZ(this._moveVector.z * n), ye.set(this._rotationVector.x * s, this._rotationVector.y * s, this._rotationVector.z * s, 1).normalize(), t.quaternion.multiply(ye), (this._lastPosition.distanceToSquared(t.position) > ge || 8 * (1 - this._lastQuaternion.dot(t.quaternion)) > ge) && (this.dispatchEvent(ot), this._lastQuaternion.copy(t.quaternion), this._lastPosition.copy(t.position));
+  }
+  // private
+  _updateMovementVector() {
+    const e = this._moveState.forward || this.autoForward && !this._moveState.back ? 1 : 0;
+    this._moveVector.x = -this._moveState.left + this._moveState.right, this._moveVector.y = -this._moveState.down + this._moveState.up, this._moveVector.z = -e + this._moveState.back;
+  }
+  _updateRotationVector() {
+    this._rotationVector.x = -this._moveState.pitchDown + this._moveState.pitchUp, this._rotationVector.y = -this._moveState.yawRight + this._moveState.yawLeft, this._rotationVector.z = -this._moveState.rollRight + this._moveState.rollLeft;
+  }
+  _getContainerDimensions() {
+    return this.domElement != document ? {
+      size: [this.domElement.offsetWidth, this.domElement.offsetHeight],
+      offset: [this.domElement.offsetLeft, this.domElement.offsetTop]
+    } : {
+      size: [window.innerWidth, window.innerHeight],
+      offset: [0, 0]
+    };
+  }
+}
+function ht(h) {
+  if (!(h.altKey || this.enabled === !1)) {
+    switch (h.code) {
+      case "ShiftLeft":
+      case "ShiftRight":
+        this.movementSpeedMultiplier = 0.1;
+        break;
+      case "KeyW":
+        this._moveState.forward = 1;
+        break;
+      case "KeyS":
+        this._moveState.back = 1;
+        break;
+      case "KeyA":
+        this._moveState.left = 1;
+        break;
+      case "KeyD":
+        this._moveState.right = 1;
+        break;
+      case "KeyR":
+        this._moveState.up = 1;
+        break;
+      case "KeyF":
+        this._moveState.down = 1;
+        break;
+      case "ArrowUp":
+        this._moveState.pitchUp = 1;
+        break;
+      case "ArrowDown":
+        this._moveState.pitchDown = 1;
+        break;
+      case "ArrowLeft":
+        this._moveState.yawLeft = 1;
+        break;
+      case "ArrowRight":
+        this._moveState.yawRight = 1;
+        break;
+      case "KeyQ":
+        this._moveState.rollLeft = 1;
+        break;
+      case "KeyE":
+        this._moveState.rollRight = 1;
+        break;
+    }
+    this._updateMovementVector(), this._updateRotationVector();
+  }
+}
+function ct(h) {
+  if (this.enabled !== !1) {
+    switch (h.code) {
+      case "ShiftLeft":
+      case "ShiftRight":
+        this.movementSpeedMultiplier = 1;
+        break;
+      case "KeyW":
+        this._moveState.forward = 0;
+        break;
+      case "KeyS":
+        this._moveState.back = 0;
+        break;
+      case "KeyA":
+        this._moveState.left = 0;
+        break;
+      case "KeyD":
+        this._moveState.right = 0;
+        break;
+      case "KeyR":
+        this._moveState.up = 0;
+        break;
+      case "KeyF":
+        this._moveState.down = 0;
+        break;
+      case "ArrowUp":
+        this._moveState.pitchUp = 0;
+        break;
+      case "ArrowDown":
+        this._moveState.pitchDown = 0;
+        break;
+      case "ArrowLeft":
+        this._moveState.yawLeft = 0;
+        break;
+      case "ArrowRight":
+        this._moveState.yawRight = 0;
+        break;
+      case "KeyQ":
+        this._moveState.rollLeft = 0;
+        break;
+      case "KeyE":
+        this._moveState.rollRight = 0;
+        break;
+    }
+    this._updateMovementVector(), this._updateRotationVector();
+  }
+}
+function ut(h) {
+  if (this.enabled !== !1)
+    if (this.dragToLook)
+      this._status++;
+    else {
+      switch (h.button) {
+        case 0:
+          this._moveState.forward = 1;
+          break;
+        case 2:
+          this._moveState.back = 1;
+          break;
+      }
+      this._updateMovementVector();
+    }
+}
+function dt(h) {
+  if (this.enabled !== !1 && (!this.dragToLook || this._status > 0)) {
+    const e = this._getContainerDimensions(), t = e.size[0] / 2, n = e.size[1] / 2;
+    this._moveState.yawLeft = -(h.pageX - e.offset[0] - t) / t, this._moveState.pitchDown = (h.pageY - e.offset[1] - n) / n, this._updateRotationVector();
+  }
+}
+function pt(h) {
+  if (this.enabled !== !1) {
+    if (this.dragToLook)
+      this._status--, this._moveState.yawLeft = this._moveState.pitchDown = 0;
+    else {
+      switch (h.button) {
+        case 0:
+          this._moveState.forward = 0;
+          break;
+        case 2:
+          this._moveState.back = 0;
+          break;
+      }
+      this._updateMovementVector();
+    }
+    this._updateRotationVector();
+  }
+}
+function ft() {
+  this.enabled !== !1 && (this.dragToLook ? (this._status = 0, this._moveState.yawLeft = this._moveState.pitchDown = 0) : (this._moveState.forward = 0, this._moveState.back = 0, this._updateMovementVector()), this._updateRotationVector());
+}
+function mt(h) {
+  this.enabled !== !1 && h.preventDefault();
+}
+const H = new Le(), m = new l(), I = new l(), p = new S(), _e = {
+  X: new l(1, 0, 0),
+  Y: new l(0, 1, 0),
+  Z: new l(0, 0, 1)
+}, ue = { type: "change" }, Se = { type: "mouseDown", mode: null }, Me = { type: "mouseUp", mode: null }, xe = { type: "objectChange" };
+class vt extends Ee {
+  /**
+   * Constructs a new controls instance.
+   *
+   * @param {Camera} camera - The camera of the rendered scene.
+   * @param {?HTMLDOMElement} domElement - The HTML element used for event listeners.
+   */
+  constructor(e, t = null) {
+    super(void 0, t);
+    const n = new Mt(this);
+    this._root = n;
+    const s = new xt();
+    this._gizmo = s, n.add(s);
+    const r = new bt();
+    this._plane = r, n.add(r);
+    const i = this;
+    function a(y, z) {
+      let Y = z;
+      Object.defineProperty(i, y, {
+        get: function() {
+          return Y !== void 0 ? Y : z;
+        },
+        set: function(L) {
+          Y !== L && (Y = L, r[y] = L, s[y] = L, i.dispatchEvent({ type: y + "-changed", value: L }), i.dispatchEvent(ue));
+        }
+      }), i[y] = z, r[y] = z, s[y] = z;
+    }
+    a("camera", e), a("object", void 0), a("enabled", !0), a("axis", null), a("mode", "translate"), a("translationSnap", null), a("rotationSnap", null), a("scaleSnap", null), a("space", "world"), a("size", 1), a("dragging", !1), a("showX", !0), a("showY", !0), a("showZ", !0), a("minX", -1 / 0), a("maxX", 1 / 0), a("minY", -1 / 0), a("maxY", 1 / 0), a("minZ", -1 / 0), a("maxZ", 1 / 0);
+    const d = new l(), f = new l(), D = new S(), R = new S(), Q = new l(), N = new S(), $ = new l(), P = new l(), T = new l(), x = 0, E = new l();
+    a("worldPosition", d), a("worldPositionStart", f), a("worldQuaternion", D), a("worldQuaternionStart", R), a("cameraPosition", Q), a("cameraQuaternion", N), a("pointStart", $), a("pointEnd", P), a("rotationAxis", T), a("rotationAngle", x), a("eye", E), this._offset = new l(), this._startNorm = new l(), this._endNorm = new l(), this._cameraScale = new l(), this._parentPosition = new l(), this._parentQuaternion = new S(), this._parentQuaternionInv = new S(), this._parentScale = new l(), this._worldScaleStart = new l(), this._worldQuaternionInv = new S(), this._worldScale = new l(), this._positionStart = new l(), this._quaternionStart = new S(), this._scaleStart = new l(), this._getPointer = wt.bind(this), this._onPointerDown = yt.bind(this), this._onPointerHover = gt.bind(this), this._onPointerMove = _t.bind(this), this._onPointerUp = St.bind(this), t !== null && this.connect(t);
+  }
+  connect(e) {
+    super.connect(e), this.domElement.addEventListener("pointerdown", this._onPointerDown), this.domElement.addEventListener("pointermove", this._onPointerHover), this.domElement.addEventListener("pointerup", this._onPointerUp), this.domElement.style.touchAction = "none";
+  }
+  disconnect() {
+    this.domElement.removeEventListener("pointerdown", this._onPointerDown), this.domElement.removeEventListener("pointermove", this._onPointerHover), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.domElement.style.touchAction = "auto";
+  }
+  /**
+   * Returns the visual representation of the controls. Add the helper to your scene to
+   * visually transform the attached  3D object.
+   *
+   * @return {TransformControlsRoot} The helper.
+   */
+  getHelper() {
+    return this._root;
+  }
+  pointerHover(e) {
+    if (this.object === void 0 || this.dragging === !0) return;
+    e !== null && H.setFromCamera(e, this.camera);
+    const t = de(this._gizmo.picker[this.mode], H);
+    t ? this.axis = t.object.name : this.axis = null;
+  }
+  pointerDown(e) {
+    if (!(this.object === void 0 || this.dragging === !0 || e != null && e.button !== 0) && this.axis !== null) {
+      e !== null && H.setFromCamera(e, this.camera);
+      const t = de(this._plane, H, !0);
+      t && (this.object.updateMatrixWorld(), this.object.parent.updateMatrixWorld(), this._positionStart.copy(this.object.position), this._quaternionStart.copy(this.object.quaternion), this._scaleStart.copy(this.object.scale), this.object.matrixWorld.decompose(this.worldPositionStart, this.worldQuaternionStart, this._worldScaleStart), this.pointStart.copy(t.point).sub(this.worldPositionStart)), this.dragging = !0, Se.mode = this.mode, this.dispatchEvent(Se);
+    }
+  }
+  pointerMove(e) {
+    const t = this.axis, n = this.mode, s = this.object;
+    let r = this.space;
+    if (n === "scale" ? r = "local" : (t === "E" || t === "XYZE" || t === "XYZ") && (r = "world"), s === void 0 || t === null || this.dragging === !1 || e !== null && e.button !== -1) return;
+    e !== null && H.setFromCamera(e, this.camera);
+    const i = de(this._plane, H, !0);
+    if (i) {
+      if (this.pointEnd.copy(i.point).sub(this.worldPositionStart), n === "translate")
+        this._offset.copy(this.pointEnd).sub(this.pointStart), r === "local" && t !== "XYZ" && this._offset.applyQuaternion(this._worldQuaternionInv), t.indexOf("X") === -1 && (this._offset.x = 0), t.indexOf("Y") === -1 && (this._offset.y = 0), t.indexOf("Z") === -1 && (this._offset.z = 0), r === "local" && t !== "XYZ" ? this._offset.applyQuaternion(this._quaternionStart).divide(this._parentScale) : this._offset.applyQuaternion(this._parentQuaternionInv).divide(this._parentScale), s.position.copy(this._offset).add(this._positionStart), this.translationSnap && (r === "local" && (s.position.applyQuaternion(p.copy(this._quaternionStart).invert()), t.search("X") !== -1 && (s.position.x = Math.round(s.position.x / this.translationSnap) * this.translationSnap), t.search("Y") !== -1 && (s.position.y = Math.round(s.position.y / this.translationSnap) * this.translationSnap), t.search("Z") !== -1 && (s.position.z = Math.round(s.position.z / this.translationSnap) * this.translationSnap), s.position.applyQuaternion(this._quaternionStart)), r === "world" && (s.parent && s.position.add(m.setFromMatrixPosition(s.parent.matrixWorld)), t.search("X") !== -1 && (s.position.x = Math.round(s.position.x / this.translationSnap) * this.translationSnap), t.search("Y") !== -1 && (s.position.y = Math.round(s.position.y / this.translationSnap) * this.translationSnap), t.search("Z") !== -1 && (s.position.z = Math.round(s.position.z / this.translationSnap) * this.translationSnap), s.parent && s.position.sub(m.setFromMatrixPosition(s.parent.matrixWorld)))), s.position.x = Math.max(this.minX, Math.min(this.maxX, s.position.x)), s.position.y = Math.max(this.minY, Math.min(this.maxY, s.position.y)), s.position.z = Math.max(this.minZ, Math.min(this.maxZ, s.position.z));
+      else if (n === "scale") {
+        if (t.search("XYZ") !== -1) {
+          let a = this.pointEnd.length() / this.pointStart.length();
+          this.pointEnd.dot(this.pointStart) < 0 && (a *= -1), I.set(a, a, a);
+        } else
+          m.copy(this.pointStart), I.copy(this.pointEnd), m.applyQuaternion(this._worldQuaternionInv), I.applyQuaternion(this._worldQuaternionInv), I.divide(m), t.search("X") === -1 && (I.x = 1), t.search("Y") === -1 && (I.y = 1), t.search("Z") === -1 && (I.z = 1);
+        s.scale.copy(this._scaleStart).multiply(I), this.scaleSnap && (t.search("X") !== -1 && (s.scale.x = Math.round(s.scale.x / this.scaleSnap) * this.scaleSnap || this.scaleSnap), t.search("Y") !== -1 && (s.scale.y = Math.round(s.scale.y / this.scaleSnap) * this.scaleSnap || this.scaleSnap), t.search("Z") !== -1 && (s.scale.z = Math.round(s.scale.z / this.scaleSnap) * this.scaleSnap || this.scaleSnap));
+      } else if (n === "rotate") {
+        this._offset.copy(this.pointEnd).sub(this.pointStart);
+        const a = 20 / this.worldPosition.distanceTo(m.setFromMatrixPosition(this.camera.matrixWorld));
+        let d = !1;
+        t === "XYZE" ? (this.rotationAxis.copy(this._offset).cross(this.eye).normalize(), this.rotationAngle = this._offset.dot(m.copy(this.rotationAxis).cross(this.eye)) * a) : (t === "X" || t === "Y" || t === "Z") && (this.rotationAxis.copy(_e[t]), m.copy(_e[t]), r === "local" && m.applyQuaternion(this.worldQuaternion), m.cross(this.eye), m.length() === 0 ? d = !0 : this.rotationAngle = this._offset.dot(m.normalize()) * a), (t === "E" || d) && (this.rotationAxis.copy(this.eye), this.rotationAngle = this.pointEnd.angleTo(this.pointStart), this._startNorm.copy(this.pointStart).normalize(), this._endNorm.copy(this.pointEnd).normalize(), this.rotationAngle *= this._endNorm.cross(this._startNorm).dot(this.eye) < 0 ? 1 : -1), this.rotationSnap && (this.rotationAngle = Math.round(this.rotationAngle / this.rotationSnap) * this.rotationSnap), r === "local" && t !== "E" && t !== "XYZE" ? (s.quaternion.copy(this._quaternionStart), s.quaternion.multiply(p.setFromAxisAngle(this.rotationAxis, this.rotationAngle)).normalize()) : (this.rotationAxis.applyQuaternion(this._parentQuaternionInv), s.quaternion.copy(p.setFromAxisAngle(this.rotationAxis, this.rotationAngle)), s.quaternion.multiply(this._quaternionStart).normalize());
+      }
+      this.dispatchEvent(ue), this.dispatchEvent(xe);
+    }
+  }
+  pointerUp(e) {
+    e !== null && e.button !== 0 || (this.dragging && this.axis !== null && (Me.mode = this.mode, this.dispatchEvent(Me)), this.dragging = !1, this.axis = null);
+  }
+  dispose() {
+    this.disconnect(), this._root.dispose();
+  }
+  /**
+   * Sets the 3D object that should be transformed and ensures the controls UI is visible.
+   *
+   * @param {Object3D} object -  The 3D object that should be transformed.
+   * @return {TransformControls} A reference to this controls.
+   */
+  attach(e) {
+    return this.object = e, this._root.visible = !0, this;
+  }
+  /**
+   * Removes the current 3D object from the controls and makes the helper UI invisible.
+   *
+   * @return {TransformControls} A reference to this controls.
+   */
+  detach() {
+    return this.object = void 0, this.axis = null, this._root.visible = !1, this;
+  }
+  /**
+   * Resets the object's position, rotation and scale to when the current transform began.
+   */
+  reset() {
+    this.enabled && this.dragging && (this.object.position.copy(this._positionStart), this.object.quaternion.copy(this._quaternionStart), this.object.scale.copy(this._scaleStart), this.dispatchEvent(ue), this.dispatchEvent(xe), this.pointStart.copy(this.pointEnd));
+  }
+  /**
+   * Returns the raycaster that is used for user interaction. This object is shared between all
+   * instances of `TransformControls`.
+   *
+   * @returns {Raycaster} The internal raycaster.
+   */
+  getRaycaster() {
+    return H;
+  }
+  /**
+   * Returns the transformation mode.
+   *
+   * @returns {'translate'|'rotate'|'scale'} The transformation mode.
+   */
+  getMode() {
+    return this.mode;
+  }
+  /**
+   * Sets the given transformation mode.
+   *
+   * @param {'translate'|'rotate'|'scale'} mode - The transformation mode to set.
+   */
+  setMode(e) {
+    this.mode = e;
+  }
+  /**
+   * Sets the translation snap.
+   *
+   * @param {?number} translationSnap - The translation snap to set.
+   */
+  setTranslationSnap(e) {
+    this.translationSnap = e;
+  }
+  /**
+   * Sets the rotation snap.
+   *
+   * @param {?number} rotationSnap - The rotation snap to set.
+   */
+  setRotationSnap(e) {
+    this.rotationSnap = e;
+  }
+  /**
+   * Sets the scale snap.
+   *
+   * @param {?number} scaleSnap - The scale snap to set.
+   */
+  setScaleSnap(e) {
+    this.scaleSnap = e;
+  }
+  /**
+   * Sets the size of the helper UI.
+   *
+   * @param {number} size - The size to set.
+   */
+  setSize(e) {
+    this.size = e;
+  }
+  /**
+   * Sets the coordinate space in which transformations are applied.
+   *
+   * @param {'world'|'local'} space - The space to set.
+   */
+  setSpace(e) {
+    this.space = e;
+  }
+}
+function wt(h) {
+  if (this.domElement.ownerDocument.pointerLockElement)
+    return {
+      x: 0,
+      y: 0,
+      button: h.button
+    };
+  {
+    const e = this.domElement.getBoundingClientRect();
+    return {
+      x: (h.clientX - e.left) / e.width * 2 - 1,
+      y: -(h.clientY - e.top) / e.height * 2 + 1,
+      button: h.button
+    };
+  }
+}
+function gt(h) {
+  if (this.enabled)
+    switch (h.pointerType) {
+      case "mouse":
+      case "pen":
+        this.pointerHover(this._getPointer(h));
+        break;
+    }
+}
+function yt(h) {
+  this.enabled && (document.pointerLockElement || this.domElement.setPointerCapture(h.pointerId), this.domElement.addEventListener("pointermove", this._onPointerMove), this.pointerHover(this._getPointer(h)), this.pointerDown(this._getPointer(h)));
+}
+function _t(h) {
+  this.enabled && this.pointerMove(this._getPointer(h));
+}
+function St(h) {
+  this.enabled && (this.domElement.releasePointerCapture(h.pointerId), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.pointerUp(this._getPointer(h)));
+}
+function de(h, e, t) {
+  const n = e.intersectObject(h, !0);
+  for (let s = 0; s < n.length; s++)
+    if (n[s].object.visible || t)
+      return n[s];
+  return !1;
+}
+const ne = new Oe(), u = new l(0, 1, 0), be = new l(0, 0, 0), Pe = new ce(), ae = new S(), oe = new S(), b = new l(), Te = new ce(), q = new l(1, 0, 0), O = new l(0, 1, 0), K = new l(0, 0, 1), re = new l(), G = new l(), W = new l();
+class Mt extends le {
+  constructor(e) {
+    super(), this.isTransformControlsRoot = !0, this.controls = e, this.visible = !1;
+  }
+  // updateMatrixWorld updates key transformation variables
+  updateMatrixWorld(e) {
+    const t = this.controls;
+    t.object !== void 0 && (t.object.updateMatrixWorld(), t.object.parent === null ? console.error("TransformControls: The attached 3D object must be a part of the scene graph.") : t.object.parent.matrixWorld.decompose(t._parentPosition, t._parentQuaternion, t._parentScale), t.object.matrixWorld.decompose(t.worldPosition, t.worldQuaternion, t._worldScale), t._parentQuaternionInv.copy(t._parentQuaternion).invert(), t._worldQuaternionInv.copy(t.worldQuaternion).invert()), t.camera.updateMatrixWorld(), t.camera.matrixWorld.decompose(t.cameraPosition, t.cameraQuaternion, t._cameraScale), t.camera.isOrthographicCamera ? t.camera.getWorldDirection(t.eye).negate() : t.eye.copy(t.cameraPosition).sub(t.worldPosition).normalize(), super.updateMatrixWorld(e);
+  }
+  dispose() {
+    this.traverse(function(e) {
+      e.geometry && e.geometry.dispose(), e.material && e.material.dispose();
+    });
+  }
+}
+class xt extends le {
+  constructor() {
+    super(), this.isTransformControlsGizmo = !0, this.type = "TransformControlsGizmo";
+    const e = new me({
+      depthTest: !1,
+      depthWrite: !1,
+      fog: !1,
+      toneMapped: !1,
+      transparent: !0
+    }), t = new Xe({
+      depthTest: !1,
+      depthWrite: !1,
+      fog: !1,
+      toneMapped: !1,
+      transparent: !0
+    }), n = e.clone();
+    n.opacity = 0.15;
+    const s = t.clone();
+    s.opacity = 0.5;
+    const r = e.clone();
+    r.color.setHex(16711680);
+    const i = e.clone();
+    i.color.setHex(65280);
+    const a = e.clone();
+    a.color.setHex(255);
+    const d = e.clone();
+    d.color.setHex(16711680), d.opacity = 0.5;
+    const f = e.clone();
+    f.color.setHex(65280), f.opacity = 0.5;
+    const D = e.clone();
+    D.color.setHex(255), D.opacity = 0.5;
+    const R = e.clone();
+    R.opacity = 0.25;
+    const Q = e.clone();
+    Q.color.setHex(16776960), Q.opacity = 0.25, e.clone().color.setHex(16776960);
+    const $ = e.clone();
+    $.color.setHex(7895160);
+    const P = new g(0, 0.04, 0.1, 12);
+    P.translate(0, 0.05, 0);
+    const T = new v(0.08, 0.08, 0.08);
+    T.translate(0, 0.04, 0);
+    const x = new pe();
+    x.setAttribute("position", new he([0, 0, 0, 1, 0, 0], 3));
+    const E = new g(75e-4, 75e-4, 0.5, 3);
+    E.translate(0, 0.25, 0);
+    function y(_, J) {
+      const M = new j(_, 75e-4, 3, 64, J * Math.PI * 2);
+      return M.rotateY(Math.PI / 2), M.rotateX(Math.PI / 2), M;
+    }
+    function z() {
+      const _ = new pe();
+      return _.setAttribute("position", new he([0, 0, 0, 1, 1, 1], 3)), _;
+    }
+    const Y = {
+      X: [
+        [new o(P, r), [0.5, 0, 0], [0, 0, -Math.PI / 2]],
+        [new o(P, r), [-0.5, 0, 0], [0, 0, Math.PI / 2]],
+        [new o(E, r), [0, 0, 0], [0, 0, -Math.PI / 2]]
+      ],
+      Y: [
+        [new o(P, i), [0, 0.5, 0]],
+        [new o(P, i), [0, -0.5, 0], [Math.PI, 0, 0]],
+        [new o(E, i)]
+      ],
+      Z: [
+        [new o(P, a), [0, 0, 0.5], [Math.PI / 2, 0, 0]],
+        [new o(P, a), [0, 0, -0.5], [-Math.PI / 2, 0, 0]],
+        [new o(E, a), null, [Math.PI / 2, 0, 0]]
+      ],
+      XYZ: [
+        [new o(new se(0.1, 0), R.clone()), [0, 0, 0]]
+      ],
+      XY: [
+        [new o(new v(0.15, 0.15, 0.01), D.clone()), [0.15, 0.15, 0]]
+      ],
+      YZ: [
+        [new o(new v(0.15, 0.15, 0.01), d.clone()), [0, 0.15, 0.15], [0, Math.PI / 2, 0]]
+      ],
+      XZ: [
+        [new o(new v(0.15, 0.15, 0.01), f.clone()), [0.15, 0, 0.15], [-Math.PI / 2, 0, 0]]
+      ]
+    }, L = {
+      X: [
+        [new o(new g(0.2, 0, 0.6, 4), n), [0.3, 0, 0], [0, 0, -Math.PI / 2]],
+        [new o(new g(0.2, 0, 0.6, 4), n), [-0.3, 0, 0], [0, 0, Math.PI / 2]]
+      ],
+      Y: [
+        [new o(new g(0.2, 0, 0.6, 4), n), [0, 0.3, 0]],
+        [new o(new g(0.2, 0, 0.6, 4), n), [0, -0.3, 0], [0, 0, Math.PI]]
+      ],
+      Z: [
+        [new o(new g(0.2, 0, 0.6, 4), n), [0, 0, 0.3], [Math.PI / 2, 0, 0]],
+        [new o(new g(0.2, 0, 0.6, 4), n), [0, 0, -0.3], [-Math.PI / 2, 0, 0]]
+      ],
+      XYZ: [
+        [new o(new se(0.2, 0), n)]
+      ],
+      XY: [
+        [new o(new v(0.2, 0.2, 0.01), n), [0.15, 0.15, 0]]
+      ],
+      YZ: [
+        [new o(new v(0.2, 0.2, 0.01), n), [0, 0.15, 0.15], [0, Math.PI / 2, 0]]
+      ],
+      XZ: [
+        [new o(new v(0.2, 0.2, 0.01), n), [0.15, 0, 0.15], [-Math.PI / 2, 0, 0]]
+      ]
+    }, ke = {
+      START: [
+        [new o(new se(0.01, 2), s), null, null, null, "helper"]
+      ],
+      END: [
+        [new o(new se(0.01, 2), s), null, null, null, "helper"]
+      ],
+      DELTA: [
+        [new B(z(), s), null, null, null, "helper"]
+      ],
+      X: [
+        [new B(x, s.clone()), [-1e3, 0, 0], null, [1e6, 1, 1], "helper"]
+      ],
+      Y: [
+        [new B(x, s.clone()), [0, -1e3, 0], [0, 0, Math.PI / 2], [1e6, 1, 1], "helper"]
+      ],
+      Z: [
+        [new B(x, s.clone()), [0, 0, -1e3], [0, -Math.PI / 2, 0], [1e6, 1, 1], "helper"]
+      ]
+    }, De = {
+      XYZE: [
+        [new o(y(0.5, 1), $), null, [0, Math.PI / 2, 0]]
+      ],
+      X: [
+        [new o(y(0.5, 0.5), r)]
+      ],
+      Y: [
+        [new o(y(0.5, 0.5), i), null, [0, 0, -Math.PI / 2]]
+      ],
+      Z: [
+        [new o(y(0.5, 0.5), a), null, [0, Math.PI / 2, 0]]
+      ],
+      E: [
+        [new o(y(0.75, 1), Q), null, [0, Math.PI / 2, 0]]
+      ]
+    }, Be = {
+      AXIS: [
+        [new B(x, s.clone()), [-1e3, 0, 0], null, [1e6, 1, 1], "helper"]
+      ]
+    }, Ie = {
+      XYZE: [
+        [new o(new He(0.25, 10, 8), n)]
+      ],
+      X: [
+        [new o(new j(0.5, 0.1, 4, 24), n), [0, 0, 0], [0, -Math.PI / 2, -Math.PI / 2]]
+      ],
+      Y: [
+        [new o(new j(0.5, 0.1, 4, 24), n), [0, 0, 0], [Math.PI / 2, 0, 0]]
+      ],
+      Z: [
+        [new o(new j(0.5, 0.1, 4, 24), n), [0, 0, 0], [0, 0, -Math.PI / 2]]
+      ],
+      E: [
+        [new o(new j(0.75, 0.1, 2, 24), n)]
+      ]
+    }, Ae = {
+      X: [
+        [new o(T, r), [0.5, 0, 0], [0, 0, -Math.PI / 2]],
+        [new o(E, r), [0, 0, 0], [0, 0, -Math.PI / 2]],
+        [new o(T, r), [-0.5, 0, 0], [0, 0, Math.PI / 2]]
+      ],
+      Y: [
+        [new o(T, i), [0, 0.5, 0]],
+        [new o(E, i)],
+        [new o(T, i), [0, -0.5, 0], [0, 0, Math.PI]]
+      ],
+      Z: [
+        [new o(T, a), [0, 0, 0.5], [Math.PI / 2, 0, 0]],
+        [new o(E, a), [0, 0, 0], [Math.PI / 2, 0, 0]],
+        [new o(T, a), [0, 0, -0.5], [-Math.PI / 2, 0, 0]]
+      ],
+      XY: [
+        [new o(new v(0.15, 0.15, 0.01), D), [0.15, 0.15, 0]]
+      ],
+      YZ: [
+        [new o(new v(0.15, 0.15, 0.01), d), [0, 0.15, 0.15], [0, Math.PI / 2, 0]]
+      ],
+      XZ: [
+        [new o(new v(0.15, 0.15, 0.01), f), [0.15, 0, 0.15], [-Math.PI / 2, 0, 0]]
+      ],
+      XYZ: [
+        [new o(new v(0.1, 0.1, 0.1), R.clone())]
+      ]
+    }, Re = {
+      X: [
+        [new o(new g(0.2, 0, 0.6, 4), n), [0.3, 0, 0], [0, 0, -Math.PI / 2]],
+        [new o(new g(0.2, 0, 0.6, 4), n), [-0.3, 0, 0], [0, 0, Math.PI / 2]]
+      ],
+      Y: [
+        [new o(new g(0.2, 0, 0.6, 4), n), [0, 0.3, 0]],
+        [new o(new g(0.2, 0, 0.6, 4), n), [0, -0.3, 0], [0, 0, Math.PI]]
+      ],
+      Z: [
+        [new o(new g(0.2, 0, 0.6, 4), n), [0, 0, 0.3], [Math.PI / 2, 0, 0]],
+        [new o(new g(0.2, 0, 0.6, 4), n), [0, 0, -0.3], [-Math.PI / 2, 0, 0]]
+      ],
+      XY: [
+        [new o(new v(0.2, 0.2, 0.01), n), [0.15, 0.15, 0]]
+      ],
+      YZ: [
+        [new o(new v(0.2, 0.2, 0.01), n), [0, 0.15, 0.15], [0, Math.PI / 2, 0]]
+      ],
+      XZ: [
+        [new o(new v(0.2, 0.2, 0.01), n), [0.15, 0, 0.15], [-Math.PI / 2, 0, 0]]
+      ],
+      XYZ: [
+        [new o(new v(0.2, 0.2, 0.2), n), [0, 0, 0]]
+      ]
+    }, Qe = {
+      X: [
+        [new B(x, s.clone()), [-1e3, 0, 0], null, [1e6, 1, 1], "helper"]
+      ],
+      Y: [
+        [new B(x, s.clone()), [0, -1e3, 0], [0, 0, Math.PI / 2], [1e6, 1, 1], "helper"]
+      ],
+      Z: [
+        [new B(x, s.clone()), [0, 0, -1e3], [0, -Math.PI / 2, 0], [1e6, 1, 1], "helper"]
+      ]
+    };
+    function C(_) {
+      const J = new le();
+      for (const M in _)
+        for (let Z = _[M].length; Z--; ) {
+          const w = _[M][Z][0].clone(), ee = _[M][Z][1], te = _[M][Z][2], ie = _[M][Z][3], ze = _[M][Z][4];
+          w.name = M, w.tag = ze, ee && w.position.set(ee[0], ee[1], ee[2]), te && w.rotation.set(te[0], te[1], te[2]), ie && w.scale.set(ie[0], ie[1], ie[2]), w.updateMatrix();
+          const ve = w.geometry.clone();
+          ve.applyMatrix4(w.matrix), w.geometry = ve, w.renderOrder = 1 / 0, w.position.set(0, 0, 0), w.rotation.set(0, 0, 0), w.scale.set(1, 1, 1), J.add(w);
+        }
+      return J;
+    }
+    this.gizmo = {}, this.picker = {}, this.helper = {}, this.add(this.gizmo.translate = C(Y)), this.add(this.gizmo.rotate = C(De)), this.add(this.gizmo.scale = C(Ae)), this.add(this.picker.translate = C(L)), this.add(this.picker.rotate = C(Ie)), this.add(this.picker.scale = C(Re)), this.add(this.helper.translate = C(ke)), this.add(this.helper.rotate = C(Be)), this.add(this.helper.scale = C(Qe)), this.picker.translate.visible = !1, this.picker.rotate.visible = !1, this.picker.scale.visible = !1;
+  }
+  // updateMatrixWorld will update transformations and appearance of individual handles
+  updateMatrixWorld(e) {
+    const n = (this.mode === "scale" ? "local" : this.space) === "local" ? this.worldQuaternion : oe;
+    this.gizmo.translate.visible = this.mode === "translate", this.gizmo.rotate.visible = this.mode === "rotate", this.gizmo.scale.visible = this.mode === "scale", this.helper.translate.visible = this.mode === "translate", this.helper.rotate.visible = this.mode === "rotate", this.helper.scale.visible = this.mode === "scale";
+    let s = [];
+    s = s.concat(this.picker[this.mode].children), s = s.concat(this.gizmo[this.mode].children), s = s.concat(this.helper[this.mode].children);
+    for (let r = 0; r < s.length; r++) {
+      const i = s[r];
+      i.visible = !0, i.rotation.set(0, 0, 0), i.position.copy(this.worldPosition);
+      let a;
+      if (this.camera.isOrthographicCamera ? a = (this.camera.top - this.camera.bottom) / this.camera.zoom : a = this.worldPosition.distanceTo(this.cameraPosition) * Math.min(1.9 * Math.tan(Math.PI * this.camera.fov / 360) / this.camera.zoom, 7), i.scale.set(1, 1, 1).multiplyScalar(a * this.size / 4), i.tag === "helper") {
+        i.visible = !1, i.name === "AXIS" ? (i.visible = !!this.axis, this.axis === "X" && (p.setFromEuler(ne.set(0, 0, 0)), i.quaternion.copy(n).multiply(p), Math.abs(u.copy(q).applyQuaternion(n).dot(this.eye)) > 0.9 && (i.visible = !1)), this.axis === "Y" && (p.setFromEuler(ne.set(0, 0, Math.PI / 2)), i.quaternion.copy(n).multiply(p), Math.abs(u.copy(O).applyQuaternion(n).dot(this.eye)) > 0.9 && (i.visible = !1)), this.axis === "Z" && (p.setFromEuler(ne.set(0, Math.PI / 2, 0)), i.quaternion.copy(n).multiply(p), Math.abs(u.copy(K).applyQuaternion(n).dot(this.eye)) > 0.9 && (i.visible = !1)), this.axis === "XYZE" && (p.setFromEuler(ne.set(0, Math.PI / 2, 0)), u.copy(this.rotationAxis), i.quaternion.setFromRotationMatrix(Pe.lookAt(be, u, O)), i.quaternion.multiply(p), i.visible = this.dragging), this.axis === "E" && (i.visible = !1)) : i.name === "START" ? (i.position.copy(this.worldPositionStart), i.visible = this.dragging) : i.name === "END" ? (i.position.copy(this.worldPosition), i.visible = this.dragging) : i.name === "DELTA" ? (i.position.copy(this.worldPositionStart), i.quaternion.copy(this.worldQuaternionStart), m.set(1e-10, 1e-10, 1e-10).add(this.worldPositionStart).sub(this.worldPosition).multiplyScalar(-1), m.applyQuaternion(this.worldQuaternionStart.clone().invert()), i.scale.copy(m), i.visible = this.dragging) : (i.quaternion.copy(n), this.dragging ? i.position.copy(this.worldPositionStart) : i.position.copy(this.worldPosition), this.axis && (i.visible = this.axis.search(i.name) !== -1));
+        continue;
+      }
+      i.quaternion.copy(n), this.mode === "translate" || this.mode === "scale" ? (i.name === "X" && Math.abs(u.copy(q).applyQuaternion(n).dot(this.eye)) > 0.99 && (i.scale.set(1e-10, 1e-10, 1e-10), i.visible = !1), i.name === "Y" && Math.abs(u.copy(O).applyQuaternion(n).dot(this.eye)) > 0.99 && (i.scale.set(1e-10, 1e-10, 1e-10), i.visible = !1), i.name === "Z" && Math.abs(u.copy(K).applyQuaternion(n).dot(this.eye)) > 0.99 && (i.scale.set(1e-10, 1e-10, 1e-10), i.visible = !1), i.name === "XY" && Math.abs(u.copy(K).applyQuaternion(n).dot(this.eye)) < 0.2 && (i.scale.set(1e-10, 1e-10, 1e-10), i.visible = !1), i.name === "YZ" && Math.abs(u.copy(q).applyQuaternion(n).dot(this.eye)) < 0.2 && (i.scale.set(1e-10, 1e-10, 1e-10), i.visible = !1), i.name === "XZ" && Math.abs(u.copy(O).applyQuaternion(n).dot(this.eye)) < 0.2 && (i.scale.set(1e-10, 1e-10, 1e-10), i.visible = !1)) : this.mode === "rotate" && (ae.copy(n), u.copy(this.eye).applyQuaternion(p.copy(n).invert()), i.name.search("E") !== -1 && i.quaternion.setFromRotationMatrix(Pe.lookAt(this.eye, be, O)), i.name === "X" && (p.setFromAxisAngle(q, Math.atan2(-u.y, u.z)), p.multiplyQuaternions(ae, p), i.quaternion.copy(p)), i.name === "Y" && (p.setFromAxisAngle(O, Math.atan2(u.x, u.z)), p.multiplyQuaternions(ae, p), i.quaternion.copy(p)), i.name === "Z" && (p.setFromAxisAngle(K, Math.atan2(u.y, u.x)), p.multiplyQuaternions(ae, p), i.quaternion.copy(p))), i.visible = i.visible && (i.name.indexOf("X") === -1 || this.showX), i.visible = i.visible && (i.name.indexOf("Y") === -1 || this.showY), i.visible = i.visible && (i.name.indexOf("Z") === -1 || this.showZ), i.visible = i.visible && (i.name.indexOf("E") === -1 || this.showX && this.showY && this.showZ), i.material._color = i.material._color || i.material.color.clone(), i.material._opacity = i.material._opacity || i.material.opacity, i.material.color.copy(i.material._color), i.material.opacity = i.material._opacity, this.enabled && this.axis && (i.name === this.axis || this.axis.split("").some(function(d) {
+        return i.name === d;
+      })) && (i.material.color.setHex(16776960), i.material.opacity = 1);
+    }
+    super.updateMatrixWorld(e);
+  }
+}
+class bt extends o {
+  constructor() {
+    super(
+      new Ye(1e5, 1e5, 2, 2),
+      new me({ visible: !1, wireframe: !0, side: fe, transparent: !0, opacity: 0.1, toneMapped: !1 })
+    ), this.isTransformControlsPlane = !0, this.type = "TransformControlsPlane";
+  }
+  updateMatrixWorld(e) {
+    let t = this.space;
+    switch (this.position.copy(this.worldPosition), this.mode === "scale" && (t = "local"), re.copy(q).applyQuaternion(t === "local" ? this.worldQuaternion : oe), G.copy(O).applyQuaternion(t === "local" ? this.worldQuaternion : oe), W.copy(K).applyQuaternion(t === "local" ? this.worldQuaternion : oe), u.copy(G), this.mode) {
+      case "translate":
+      case "scale":
+        switch (this.axis) {
+          case "X":
+            u.copy(this.eye).cross(re), b.copy(re).cross(u);
+            break;
+          case "Y":
+            u.copy(this.eye).cross(G), b.copy(G).cross(u);
+            break;
+          case "Z":
+            u.copy(this.eye).cross(W), b.copy(W).cross(u);
+            break;
+          case "XY":
+            b.copy(W);
+            break;
+          case "YZ":
+            b.copy(re);
+            break;
+          case "XZ":
+            u.copy(W), b.copy(G);
+            break;
+          case "XYZ":
+          case "E":
+            b.set(0, 0, 0);
+            break;
+        }
+        break;
+      case "rotate":
+      default:
+        b.set(0, 0, 0);
+    }
+    b.length() === 0 ? this.quaternion.copy(this.cameraQuaternion) : (Te.lookAt(m.set(0, 0, 0), b, u), this.quaternion.setFromRotationMatrix(Te)), super.updateMatrixWorld(e);
+  }
+}
+class Pt {
+  /**
+   * Constructs a new pass.
+   */
+  constructor() {
+    this.isPass = !0, this.enabled = !0, this.needsSwap = !0, this.clear = !1, this.renderToScreen = !1;
+  }
+  /**
+   * Sets the size of the pass.
+   *
+   * @abstract
+   * @param {number} width - The width to set.
+   * @param {number} height - The width to set.
+   */
+  setSize() {
+  }
+  /**
+   * This method holds the render logic of a pass. It must be implemented in all derived classes.
+   *
+   * @abstract
+   * @param {WebGLRenderer} renderer - The renderer.
+   * @param {WebGLRenderTarget} writeBuffer - The write buffer. This buffer is intended as the rendering
+   * destination for the pass.
+   * @param {WebGLRenderTarget} readBuffer - The read buffer. The pass can access the result from the
+   * previous pass from this buffer.
+   * @param {number} deltaTime - The delta time in seconds.
+   * @param {boolean} maskActive - Whether masking is active or not.
+   */
+  render() {
+    console.error("THREE.Pass: .render() must be implemented in derived pass.");
+  }
+  /**
+   * Frees the GPU-related resources allocated by this instance. Call this
+   * method whenever the pass is no longer used in your app.
+   *
+   * @abstract
+   */
+  dispose() {
+  }
+}
+const Tt = new Ze(-1, 1, 1, -1, 0, 1);
+class Et extends pe {
+  constructor() {
+    super(), this.setAttribute("position", new he([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3)), this.setAttribute("uv", new he([0, 2, 0, 0, 2, 0], 2));
+  }
+}
+const Ct = new Et();
+class kt {
+  /**
+   * Constructs a new full screen quad.
+   *
+   * @param {?Material} material - The material to render te full screen quad with.
+   */
+  constructor(e) {
+    this._mesh = new o(Ct, e);
+  }
+  /**
+   * Frees the GPU-related resources allocated by this instance. Call this
+   * method whenever the instance is no longer used in your app.
+   */
+  dispose() {
+    this._mesh.geometry.dispose();
+  }
+  /**
+   * Renders the full screen quad.
+   *
+   * @param {WebGLRenderer} renderer - The renderer.
+   */
+  render(e) {
+    e.render(this._mesh, Tt);
+  }
+  /**
+   * The quad's material.
+   *
+   * @type {?Material}
+   */
+  get material() {
+    return this._mesh.material;
+  }
+  set material(e) {
+    this._mesh.material = e;
+  }
+}
+const Dt = {
+  name: "CopyShader",
+  uniforms: {
+    tDiffuse: { value: null },
+    opacity: { value: 1 }
+  },
+  vertexShader: (
+    /* glsl */
+    `
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`
+  ),
+  fragmentShader: (
+    /* glsl */
+    `
+
+		uniform float opacity;
+
+		uniform sampler2D tDiffuse;
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vec4 texel = texture2D( tDiffuse, vUv );
+			gl_FragColor = opacity * texel;
+
+
+		}`
+  )
+};
+class A extends Pt {
+  /**
+   * Constructs a new outline pass.
+   *
+   * @param {Vector2} [resolution] - The effect's resolution.
+   * @param {Scene} scene - The scene to render.
+   * @param {Camera} camera - The camera.
+   * @param {Array<Object3D>} [selectedObjects] - The selected 3D objects that should receive an outline.
+   *
+   */
+  constructor(e, t, n, s) {
+    super(), this.renderScene = t, this.renderCamera = n, this.selectedObjects = s !== void 0 ? s : [], this.visibleEdgeColor = new F(1, 1, 1), this.hiddenEdgeColor = new F(0.1, 0.04, 0.02), this.edgeGlow = 0, this.usePatternTexture = !1, this.patternTexture = null, this.edgeThickness = 1, this.edgeStrength = 3, this.downSampleRatio = 2, this.pulsePeriod = 0, this._visibilityCache = /* @__PURE__ */ new Map(), this._selectionCache = /* @__PURE__ */ new Set(), this.resolution = e !== void 0 ? new k(e.x, e.y) : new k(256, 256);
+    const r = Math.round(this.resolution.x / this.downSampleRatio), i = Math.round(this.resolution.y / this.downSampleRatio);
+    this.renderTargetMaskBuffer = new X(this.resolution.x, this.resolution.y), this.renderTargetMaskBuffer.texture.name = "OutlinePass.mask", this.renderTargetMaskBuffer.texture.generateMipmaps = !1, this.depthMaterial = new Ue(), this.depthMaterial.side = fe, this.depthMaterial.depthPacking = je, this.depthMaterial.blending = we, this.prepareMaskMaterial = this._getPrepareMaskMaterial(), this.prepareMaskMaterial.side = fe, this.prepareMaskMaterial.fragmentShader = D(this.prepareMaskMaterial.fragmentShader, this.renderCamera), this.renderTargetDepthBuffer = new X(this.resolution.x, this.resolution.y, { type: U }), this.renderTargetDepthBuffer.texture.name = "OutlinePass.depth", this.renderTargetDepthBuffer.texture.generateMipmaps = !1, this.renderTargetMaskDownSampleBuffer = new X(r, i, { type: U }), this.renderTargetMaskDownSampleBuffer.texture.name = "OutlinePass.depthDownSample", this.renderTargetMaskDownSampleBuffer.texture.generateMipmaps = !1, this.renderTargetBlurBuffer1 = new X(r, i, { type: U }), this.renderTargetBlurBuffer1.texture.name = "OutlinePass.blur1", this.renderTargetBlurBuffer1.texture.generateMipmaps = !1, this.renderTargetBlurBuffer2 = new X(Math.round(r / 2), Math.round(i / 2), { type: U }), this.renderTargetBlurBuffer2.texture.name = "OutlinePass.blur2", this.renderTargetBlurBuffer2.texture.generateMipmaps = !1, this.edgeDetectionMaterial = this._getEdgeDetectionMaterial(), this.renderTargetEdgeBuffer1 = new X(r, i, { type: U }), this.renderTargetEdgeBuffer1.texture.name = "OutlinePass.edge1", this.renderTargetEdgeBuffer1.texture.generateMipmaps = !1, this.renderTargetEdgeBuffer2 = new X(Math.round(r / 2), Math.round(i / 2), { type: U }), this.renderTargetEdgeBuffer2.texture.name = "OutlinePass.edge2", this.renderTargetEdgeBuffer2.texture.generateMipmaps = !1;
+    const a = 4, d = 4;
+    this.separableBlurMaterial1 = this._getSeparableBlurMaterial(a), this.separableBlurMaterial1.uniforms.texSize.value.set(r, i), this.separableBlurMaterial1.uniforms.kernelRadius.value = 1, this.separableBlurMaterial2 = this._getSeparableBlurMaterial(d), this.separableBlurMaterial2.uniforms.texSize.value.set(Math.round(r / 2), Math.round(i / 2)), this.separableBlurMaterial2.uniforms.kernelRadius.value = d, this.overlayMaterial = this._getOverlayMaterial();
+    const f = Dt;
+    this.copyUniforms = Fe.clone(f.uniforms), this.materialCopy = new V({
+      uniforms: this.copyUniforms,
+      vertexShader: f.vertexShader,
+      fragmentShader: f.fragmentShader,
+      blending: we,
+      depthTest: !1,
+      depthWrite: !1
+    }), this.enabled = !0, this.needsSwap = !1, this._oldClearColor = new F(), this.oldClearAlpha = 1, this._fsQuad = new kt(null), this.tempPulseColor1 = new F(), this.tempPulseColor2 = new F(), this.textureMatrix = new ce();
+    function D(R, Q) {
+      const N = Q.isPerspectiveCamera ? "perspective" : "orthographic";
+      return R.replace(/DEPTH_TO_VIEW_Z/g, N + "DepthToViewZ");
+    }
+  }
+  /**
+   * Frees the GPU-related resources allocated by this instance. Call this
+   * method whenever the pass is no longer used in your app.
+   */
+  dispose() {
+    this.renderTargetMaskBuffer.dispose(), this.renderTargetDepthBuffer.dispose(), this.renderTargetMaskDownSampleBuffer.dispose(), this.renderTargetBlurBuffer1.dispose(), this.renderTargetBlurBuffer2.dispose(), this.renderTargetEdgeBuffer1.dispose(), this.renderTargetEdgeBuffer2.dispose(), this.depthMaterial.dispose(), this.prepareMaskMaterial.dispose(), this.edgeDetectionMaterial.dispose(), this.separableBlurMaterial1.dispose(), this.separableBlurMaterial2.dispose(), this.overlayMaterial.dispose(), this.materialCopy.dispose(), this._fsQuad.dispose();
+  }
+  /**
+   * Sets the size of the pass.
+   *
+   * @param {number} width - The width to set.
+   * @param {number} height - The width to set.
+   */
+  setSize(e, t) {
+    this.renderTargetMaskBuffer.setSize(e, t), this.renderTargetDepthBuffer.setSize(e, t);
+    let n = Math.round(e / this.downSampleRatio), s = Math.round(t / this.downSampleRatio);
+    this.renderTargetMaskDownSampleBuffer.setSize(n, s), this.renderTargetBlurBuffer1.setSize(n, s), this.renderTargetEdgeBuffer1.setSize(n, s), this.separableBlurMaterial1.uniforms.texSize.value.set(n, s), n = Math.round(n / 2), s = Math.round(s / 2), this.renderTargetBlurBuffer2.setSize(n, s), this.renderTargetEdgeBuffer2.setSize(n, s), this.separableBlurMaterial2.uniforms.texSize.value.set(n, s);
+  }
+  /**
+   * Performs the Outline pass.
+   *
+   * @param {WebGLRenderer} renderer - The renderer.
+   * @param {WebGLRenderTarget} writeBuffer - The write buffer. This buffer is intended as the rendering
+   * destination for the pass.
+   * @param {WebGLRenderTarget} readBuffer - The read buffer. The pass can access the result from the
+   * previous pass from this buffer.
+   * @param {number} deltaTime - The delta time in seconds.
+   * @param {boolean} maskActive - Whether masking is active or not.
+   */
+  render(e, t, n, s, r) {
+    if (this.selectedObjects.length > 0) {
+      e.getClearColor(this._oldClearColor), this.oldClearAlpha = e.getClearAlpha();
+      const i = e.autoClear;
+      e.autoClear = !1, r && e.state.buffers.stencil.setTest(!1), e.setClearColor(16777215, 1), this._updateSelectionCache(), this._changeVisibilityOfSelectedObjects(!1);
+      const a = this.renderScene.background, d = this.renderScene.overrideMaterial;
+      if (this.renderScene.background = null, this.renderScene.overrideMaterial = this.depthMaterial, e.setRenderTarget(this.renderTargetDepthBuffer), e.clear(), e.render(this.renderScene, this.renderCamera), this._changeVisibilityOfSelectedObjects(!0), this._visibilityCache.clear(), this._updateTextureMatrix(), this._changeVisibilityOfNonSelectedObjects(!1), this.renderScene.overrideMaterial = this.prepareMaskMaterial, this.prepareMaskMaterial.uniforms.cameraNearFar.value.set(this.renderCamera.near, this.renderCamera.far), this.prepareMaskMaterial.uniforms.depthTexture.value = this.renderTargetDepthBuffer.texture, this.prepareMaskMaterial.uniforms.textureMatrix.value = this.textureMatrix, e.setRenderTarget(this.renderTargetMaskBuffer), e.clear(), e.render(this.renderScene, this.renderCamera), this._changeVisibilityOfNonSelectedObjects(!0), this._visibilityCache.clear(), this._selectionCache.clear(), this.renderScene.background = a, this.renderScene.overrideMaterial = d, this._fsQuad.material = this.materialCopy, this.copyUniforms.tDiffuse.value = this.renderTargetMaskBuffer.texture, e.setRenderTarget(this.renderTargetMaskDownSampleBuffer), e.clear(), this._fsQuad.render(e), this.tempPulseColor1.copy(this.visibleEdgeColor), this.tempPulseColor2.copy(this.hiddenEdgeColor), this.pulsePeriod > 0) {
+        const f = 0.625 + Math.cos(performance.now() * 0.01 / this.pulsePeriod) * 0.75 / 2;
+        this.tempPulseColor1.multiplyScalar(f), this.tempPulseColor2.multiplyScalar(f);
+      }
+      this._fsQuad.material = this.edgeDetectionMaterial, this.edgeDetectionMaterial.uniforms.maskTexture.value = this.renderTargetMaskDownSampleBuffer.texture, this.edgeDetectionMaterial.uniforms.texSize.value.set(this.renderTargetMaskDownSampleBuffer.width, this.renderTargetMaskDownSampleBuffer.height), this.edgeDetectionMaterial.uniforms.visibleEdgeColor.value = this.tempPulseColor1, this.edgeDetectionMaterial.uniforms.hiddenEdgeColor.value = this.tempPulseColor2, e.setRenderTarget(this.renderTargetEdgeBuffer1), e.clear(), this._fsQuad.render(e), this._fsQuad.material = this.separableBlurMaterial1, this.separableBlurMaterial1.uniforms.colorTexture.value = this.renderTargetEdgeBuffer1.texture, this.separableBlurMaterial1.uniforms.direction.value = A.BlurDirectionX, this.separableBlurMaterial1.uniforms.kernelRadius.value = this.edgeThickness, e.setRenderTarget(this.renderTargetBlurBuffer1), e.clear(), this._fsQuad.render(e), this.separableBlurMaterial1.uniforms.colorTexture.value = this.renderTargetBlurBuffer1.texture, this.separableBlurMaterial1.uniforms.direction.value = A.BlurDirectionY, e.setRenderTarget(this.renderTargetEdgeBuffer1), e.clear(), this._fsQuad.render(e), this._fsQuad.material = this.separableBlurMaterial2, this.separableBlurMaterial2.uniforms.colorTexture.value = this.renderTargetEdgeBuffer1.texture, this.separableBlurMaterial2.uniforms.direction.value = A.BlurDirectionX, e.setRenderTarget(this.renderTargetBlurBuffer2), e.clear(), this._fsQuad.render(e), this.separableBlurMaterial2.uniforms.colorTexture.value = this.renderTargetBlurBuffer2.texture, this.separableBlurMaterial2.uniforms.direction.value = A.BlurDirectionY, e.setRenderTarget(this.renderTargetEdgeBuffer2), e.clear(), this._fsQuad.render(e), this._fsQuad.material = this.overlayMaterial, this.overlayMaterial.uniforms.maskTexture.value = this.renderTargetMaskBuffer.texture, this.overlayMaterial.uniforms.edgeTexture1.value = this.renderTargetEdgeBuffer1.texture, this.overlayMaterial.uniforms.edgeTexture2.value = this.renderTargetEdgeBuffer2.texture, this.overlayMaterial.uniforms.patternTexture.value = this.patternTexture, this.overlayMaterial.uniforms.edgeStrength.value = this.edgeStrength, this.overlayMaterial.uniforms.edgeGlow.value = this.edgeGlow, this.overlayMaterial.uniforms.usePatternTexture.value = this.usePatternTexture, r && e.state.buffers.stencil.setTest(!0), e.setRenderTarget(n), this._fsQuad.render(e), e.setClearColor(this._oldClearColor, this.oldClearAlpha), e.autoClear = i;
+    }
+    this.renderToScreen && (this._fsQuad.material = this.materialCopy, this.copyUniforms.tDiffuse.value = n.texture, e.setRenderTarget(null), this._fsQuad.render(e));
+  }
+  // internals
+  _updateSelectionCache() {
+    const e = this._selectionCache;
+    function t(n) {
+      n.isMesh && e.add(n);
+    }
+    e.clear();
+    for (let n = 0; n < this.selectedObjects.length; n++)
+      this.selectedObjects[n].traverse(t);
+  }
+  _changeVisibilityOfSelectedObjects(e) {
+    const t = this._visibilityCache;
+    for (const n of this._selectionCache)
+      e === !0 ? n.visible = t.get(n) : (t.set(n, n.visible), n.visible = e);
+  }
+  _changeVisibilityOfNonSelectedObjects(e) {
+    const t = this._visibilityCache, n = this._selectionCache;
+    function s(r) {
+      if (r.isMesh || r.isSprite) {
+        if (!n.has(r)) {
+          const i = r.visible;
+          (e === !1 || t.get(r) === !0) && (r.visible = e), t.set(r, i);
+        }
+      } else (r.isPoints || r.isLine) && (e === !0 ? r.visible = t.get(r) : (t.set(r, r.visible), r.visible = e));
+    }
+    this.renderScene.traverse(s);
+  }
+  _updateTextureMatrix() {
+    this.textureMatrix.set(
+      0.5,
+      0,
+      0,
+      0.5,
+      0,
+      0.5,
+      0,
+      0.5,
+      0,
+      0,
+      0.5,
+      0.5,
+      0,
+      0,
+      0,
+      1
+    ), this.textureMatrix.multiply(this.renderCamera.projectionMatrix), this.textureMatrix.multiply(this.renderCamera.matrixWorldInverse);
+  }
+  _getPrepareMaskMaterial() {
+    return new V({
+      uniforms: {
+        depthTexture: { value: null },
+        cameraNearFar: { value: new k(0.5, 0.5) },
+        textureMatrix: { value: null }
+      },
+      vertexShader: `#include <batching_pars_vertex>
+				#include <morphtarget_pars_vertex>
+				#include <skinning_pars_vertex>
+
+				varying vec4 projTexCoord;
+				varying vec4 vPosition;
+				uniform mat4 textureMatrix;
+
+				void main() {
+
+					#include <batching_vertex>
+					#include <skinbase_vertex>
+					#include <begin_vertex>
+					#include <morphtarget_vertex>
+					#include <skinning_vertex>
+					#include <project_vertex>
+
+					vPosition = mvPosition;
+
+					vec4 worldPosition = vec4( transformed, 1.0 );
+
+					#ifdef USE_INSTANCING
+
+						worldPosition = instanceMatrix * worldPosition;
+
+					#endif
+
+					worldPosition = modelMatrix * worldPosition;
+
+					projTexCoord = textureMatrix * worldPosition;
+
+				}`,
+      fragmentShader: `#include <packing>
+				varying vec4 vPosition;
+				varying vec4 projTexCoord;
+				uniform sampler2D depthTexture;
+				uniform vec2 cameraNearFar;
+
+				void main() {
+
+					float depth = unpackRGBAToDepth(texture2DProj( depthTexture, projTexCoord ));
+					float viewZ = - DEPTH_TO_VIEW_Z( depth, cameraNearFar.x, cameraNearFar.y );
+					float depthTest = (-vPosition.z > viewZ) ? 1.0 : 0.0;
+					gl_FragColor = vec4(0.0, depthTest, 1.0, 1.0);
+
+				}`
+    });
+  }
+  _getEdgeDetectionMaterial() {
+    return new V({
+      uniforms: {
+        maskTexture: { value: null },
+        texSize: { value: new k(0.5, 0.5) },
+        visibleEdgeColor: { value: new l(1, 1, 1) },
+        hiddenEdgeColor: { value: new l(1, 1, 1) }
+      },
+      vertexShader: `varying vec2 vUv;
+
+				void main() {
+					vUv = uv;
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+				}`,
+      fragmentShader: `varying vec2 vUv;
+
+				uniform sampler2D maskTexture;
+				uniform vec2 texSize;
+				uniform vec3 visibleEdgeColor;
+				uniform vec3 hiddenEdgeColor;
+
+				void main() {
+					vec2 invSize = 1.0 / texSize;
+					vec4 uvOffset = vec4(1.0, 0.0, 0.0, 1.0) * vec4(invSize, invSize);
+					vec4 c1 = texture2D( maskTexture, vUv + uvOffset.xy);
+					vec4 c2 = texture2D( maskTexture, vUv - uvOffset.xy);
+					vec4 c3 = texture2D( maskTexture, vUv + uvOffset.yw);
+					vec4 c4 = texture2D( maskTexture, vUv - uvOffset.yw);
+					float diff1 = (c1.r - c2.r)*0.5;
+					float diff2 = (c3.r - c4.r)*0.5;
+					float d = length( vec2(diff1, diff2) );
+					float a1 = min(c1.g, c2.g);
+					float a2 = min(c3.g, c4.g);
+					float visibilityFactor = min(a1, a2);
+					vec3 edgeColor = 1.0 - visibilityFactor > 0.001 ? visibleEdgeColor : hiddenEdgeColor;
+					gl_FragColor = vec4(edgeColor, 1.0) * vec4(d);
+				}`
+    });
+  }
+  _getSeparableBlurMaterial(e) {
+    return new V({
+      defines: {
+        MAX_RADIUS: e
+      },
+      uniforms: {
+        colorTexture: { value: null },
+        texSize: { value: new k(0.5, 0.5) },
+        direction: { value: new k(0.5, 0.5) },
+        kernelRadius: { value: 1 }
+      },
+      vertexShader: `varying vec2 vUv;
+
+				void main() {
+					vUv = uv;
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+				}`,
+      fragmentShader: `#include <common>
+				varying vec2 vUv;
+				uniform sampler2D colorTexture;
+				uniform vec2 texSize;
+				uniform vec2 direction;
+				uniform float kernelRadius;
+
+				float gaussianPdf(in float x, in float sigma) {
+					return 0.39894 * exp( -0.5 * x * x/( sigma * sigma))/sigma;
+				}
+
+				void main() {
+					vec2 invSize = 1.0 / texSize;
+					float sigma = kernelRadius/2.0;
+					float weightSum = gaussianPdf(0.0, sigma);
+					vec4 diffuseSum = texture2D( colorTexture, vUv) * weightSum;
+					vec2 delta = direction * invSize * kernelRadius/float(MAX_RADIUS);
+					vec2 uvOffset = delta;
+					for( int i = 1; i <= MAX_RADIUS; i ++ ) {
+						float x = kernelRadius * float(i) / float(MAX_RADIUS);
+						float w = gaussianPdf(x, sigma);
+						vec4 sample1 = texture2D( colorTexture, vUv + uvOffset);
+						vec4 sample2 = texture2D( colorTexture, vUv - uvOffset);
+						diffuseSum += ((sample1 + sample2) * w);
+						weightSum += (2.0 * w);
+						uvOffset += delta;
+					}
+					gl_FragColor = diffuseSum/weightSum;
+				}`
+    });
+  }
+  _getOverlayMaterial() {
+    return new V({
+      uniforms: {
+        maskTexture: { value: null },
+        edgeTexture1: { value: null },
+        edgeTexture2: { value: null },
+        patternTexture: { value: null },
+        edgeStrength: { value: 1 },
+        edgeGlow: { value: 1 },
+        usePatternTexture: { value: 0 }
+      },
+      vertexShader: `varying vec2 vUv;
+
+				void main() {
+					vUv = uv;
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+				}`,
+      fragmentShader: `varying vec2 vUv;
+
+				uniform sampler2D maskTexture;
+				uniform sampler2D edgeTexture1;
+				uniform sampler2D edgeTexture2;
+				uniform sampler2D patternTexture;
+				uniform float edgeStrength;
+				uniform float edgeGlow;
+				uniform bool usePatternTexture;
+
+				void main() {
+					vec4 edgeValue1 = texture2D(edgeTexture1, vUv);
+					vec4 edgeValue2 = texture2D(edgeTexture2, vUv);
+					vec4 maskColor = texture2D(maskTexture, vUv);
+					vec4 patternColor = texture2D(patternTexture, 6.0 * vUv);
+					float visibilityFactor = 1.0 - maskColor.g > 0.0 ? 1.0 : 0.5;
+					vec4 edgeValue = edgeValue1 + edgeValue2 * edgeGlow;
+					vec4 finalColor = edgeStrength * maskColor.r * edgeValue;
+					if(usePatternTexture)
+						finalColor += + visibilityFactor * (1.0 - maskColor.r) * (1.0 - patternColor.r);
+					gl_FragColor = finalColor;
+				}`,
+      blending: Ve,
+      depthTest: !1,
+      depthWrite: !1,
+      transparent: !0
+    });
+  }
+}
+A.BlurDirectionX = new k(1, 0);
+A.BlurDirectionY = new k(0, 1);
+function Bt(h, e, t, n, s) {
+  h.traverse((r) => {
+    var i, a;
+    if (r instanceof o)
+      if (e === "solid") {
+        (i = n.get(r.uuid)) == null || i.dispose(), n.delete(r.uuid);
+        const d = t.get(r.uuid);
+        d && (r.material = d, t.delete(r.uuid));
+      } else {
+        t.has(r.uuid) || t.set(r.uuid, r.material), (a = n.get(r.uuid)) == null || a.dispose(), s.has(r.uuid) || s.set(r.uuid, Math.random() * 16777215);
+        const d = s.get(r.uuid), f = new me(
+          e === "wireframe" ? { wireframe: !0, color: d } : { color: d }
+        );
+        n.set(r.uuid, f), r.material = f;
+      }
+  });
+}
+class Ce extends rt {
+  constructor() {
+    var e;
+    super(), this.activeToolMode = "translate", this.shadeMode = "solid", this.originalMaterials = /* @__PURE__ */ new Map(), this.shadeOverrideMaterials = /* @__PURE__ */ new Map(), this.flatColors = /* @__PURE__ */ new Map(), this.helpers = [], this.lightHelpers = [], this._showHelpers = !0, this.activeAssetCategory = "Object", c.instance().editor = this, (e = c.instance().logger) == null || e.info("Booting Editor"), c.instance().trigger("editorBoot", this), c.instance().trigger("uiDestroy", this), c.instance().world.destroy(), c.instance().scene.traverse((t) => {
+      var n, s;
+      t instanceof o && ((n = t.geometry) == null || n.dispose(), Array.isArray(t.material) ? t.material.forEach((r) => r.dispose()) : (s = t.material) == null || s.dispose());
+    }), c.instance().scene.clear(), this.initEditorScene(), c.instance().contextMenuAbort.abort(), c.instance().uiRoot.innerHTML = "", c.instance().uiRoot.style.opacity = "1", document.title = "MavonEngine | Editor", document.getElementsByTagName("body")[0].removeAttribute("onContextMenu"), Promise.all([
+      import("./mount-wt1eaFr0.mjs"),
+      Promise.resolve({            })
+    ]).then(([{ mountEditorUI: t }]) => {
+      this.reactRoot = t(c.instance().uiRoot);
+    });
+  }
+  /**
+   * The editor should only be instantiated when button is pressed
+   */
+  static registerListener() {
+    c.instance().input.on("keydown", (e) => {
+      (e.code === "Insert" || e.code === "Period") && (c.instance().editor = new Ce());
+    });
+  }
+  initEditorScene() {
+    c.instance().camera.instance.position.set(20, 10, 20), c.instance().camera.instance.rotation.set(0, 0, 0), c.instance().camera.instance.rotateY(Math.PI / 360 * 90), c.instance().camera.instance.rotateX(Math.PI / 360 * -45), this.outlinePass = new A(
+      new k(c.instance().sizes.width, c.instance().sizes.height),
+      c.instance().scene,
+      c.instance().camera.instance
+    ), c.instance().renderer.composer.addPass(this.outlinePass), this.initFlyControls();
+    const e = new We(new l(0, 5, 0)), t = new qe(new l(10, 15, 5));
+    t.instance.intensity = 5;
+    const n = new Ke(new l(0, 0, 0), 50, 50);
+    n.setReceiveShadow(!0), n.instance instanceof o && n.instance.material.color.set("#ffbe6f");
+    const s = 5, r = [
+      new Ne(new l(s, 0.5, 0)),
+      new $e(new l(s * 0.707, 1, s * 0.707)),
+      new Je(new l(0, 0.5, s)),
+      new et(new l(-s * 0.707, 0.5, s * 0.707)),
+      new tt(new l(-s, 1, 0)),
+      new it(new l(-s * 0.707, 1, -s * 0.707)),
+      new st(new l(0, 1, -s)),
+      new nt(new l(s * 0.707, 1, -s * 0.707)),
+      new at(new l(0, 3.5, 0))
+    ];
+    r.forEach((a) => a.setCastShadow(!0));
+    const i = {};
+    [e, t, n, ...r].forEach((a) => i[a.id] = a), c.instance().world.add(i), this.trigger("sceneChanged"), c.instance().input.on("mousedown", (a) => {
+      a.target === c.instance().canvas && this.handleCanvasClick(a);
+    }), c.instance().input.on("keydown", (a) => {
+      a.code === "Escape" && this.activeItem && this.deselect();
+    }), this.handleItemDelete(), this.on("setTransformMode", (a) => {
+      var d, f;
+      this.activeToolMode = a, (d = this.transformControls) == null || d.setMode(a), (f = c.instance().logger) == null || f.info(`Setting editor tool mode: ${a}`);
+    }), this.on("setShadeMode", (a) => {
+      this.applyShadeMode(a);
+    }), this.on("assetDropped", () => {
+      this.shadeMode !== "solid" && this.applyShadeMode(this.shadeMode);
+    }), this.initAssetsFilter();
+  }
+  initAssetsFilter() {
+    this.availableAssetCategories = [
+      ...new Set(Object.entries(c.instance().resources.items).map(([e, t]) => t.constructor.name))
+    ];
+  }
+  setActiveAssetCategory(e) {
+    this.activeAssetCategory = e;
+  }
+  applyShadeMode(e) {
+    this.shadeMode = e, Bt(c.instance().scene, e, this.originalMaterials, this.shadeOverrideMaterials, this.flatColors);
+  }
+  initFlyControls() {
+    this.flyControls = new lt(c.instance().camera.instance, c.instance().canvas), this.flyControls.autoForward = !1, this.flyControls.dragToLook = !0, this.flyControls.movementSpeed = 10, this.flyControls.rollSpeed = 0.5;
+  }
+  handleItemDelete() {
+    c.instance().input.on("keydown", (e) => {
+      if (e.code === "Delete" && this.activeItem) {
+        let t = this.activeItem;
+        for (; t.parent && t.parent !== c.instance().scene; )
+          t = t.parent;
+        t.traverse((s) => {
+          var r, i;
+          s instanceof o && ((r = s.geometry) == null || r.dispose(), Array.isArray(s.material) ? s.material.forEach((a) => a.dispose()) : (i = s.material) == null || i.dispose());
+        }), this.deselect();
+        const n = Ge.from(t);
+        n != null && n.owner ? n.owner.destroy() : (n && (n.dispose(), this.helpers = this.helpers.filter((s) => s !== n)), c.instance().scene.remove(t)), this.trigger("sceneChanged");
+      }
+    });
+  }
+  deselect() {
+    var e;
+    (e = this.transformControls) == null || e.detach(), this.outlinePass.selectedObjects = [], this.activeItem = null, this.trigger("objectDeselected");
+  }
+  selectObject(e) {
+    this.activeItem = e, this.trigger("objectSelected", this.activeItem), this.outlinePass.selectedObjects = [this.activeItem], this.handleHelperTool();
+  }
+  handleCanvasClick(e) {
+    if (e.button === 0) {
+      if (this.transformControls && (this.transformControls.dragging || this.transformControls.axis !== null))
+        return;
+      const t = c.instance().input.getPointerWorldPosition(void 0, null, !0);
+      t instanceof le ? this.selectObject(t) : this.deselect();
+    }
+  }
+  handleHelperTool() {
+    if (!this.transformControls) {
+      this.transformControls = new vt(
+        c.instance().camera.instance,
+        c.instance().canvas
+      ), this.transformControls.addEventListener("dragging-changed", (t) => {
+        this.flyControls.enabled = !t.value, t.value || this.initFlyControls();
+      });
+      const e = this.transformControls.getHelper();
+      e.userData.isEditorInternal = !0, c.instance().scene.add(e);
+    }
+    this.transformControls.setMode(this.activeToolMode), this.transformControls.attach(this.activeItem);
+  }
+  addHelper(e) {
+    this.helpers.push(e), this._showHelpers || (e.mesh.visible = !1, e.label.domElement.style.display = "none");
+  }
+  removeHelper(e) {
+    this.helpers = this.helpers.filter((t) => t !== e);
+  }
+  addLightHelper(e) {
+    this.lightHelpers.push(e), this._showHelpers || (e.visible = !1);
+  }
+  removeLightHelper(e) {
+    this.lightHelpers = this.lightHelpers.filter((t) => t !== e);
+  }
+  setShowHelpers(e) {
+    this._showHelpers = e, this.helpers.forEach((t) => {
+      t.mesh.visible = e, t.label.domElement.style.display = e ? "" : "none";
+    }), this.lightHelpers.forEach((t) => t.visible = e);
+  }
+  update(e) {
+    this.updateCamera(e), this.helpers.forEach((t) => t.update(e));
+  }
+  updateCamera(e) {
+    this.flyControls.update(e);
+    const t = c.instance().camera.instance, n = new l();
+    t.getWorldDirection(n), t.quaternion.setFromRotationMatrix(
+      new ce().lookAt(new l(), n, new l(0, 1, 0))
+    );
+  }
+  destroy() {
+    this.reactRoot.unmount(), this.outlinePass.dispose(), this.shadeOverrideMaterials.forEach((e) => e.dispose()), this.shadeOverrideMaterials.clear(), this.originalMaterials.clear(), this.flatColors.clear();
+  }
+}
+export {
+  Dt as C,
+  Ce as E,
+  kt as F,
+  Pt as P,
+  Bt as a
+};