@mavonengine/editor 0.0.8 → 0.0.9

package/dist/Editor.mjs

@@ -1,10 +1,1655 @@
-import "@mavonengine/core/Editor/EditorHelper";
-import "@mavonengine/core/Game";
-import "@mavonengine/core/Prefab/Lights/index";
-import "@mavonengine/core/Prefab/Primitives/index";
-import "@mavonengine/core/Utils/EventEmitter";
-import "three";
-import { E as f } from "./Editor-CUEoQ8jG.mjs";
-export {
-  f as default
+import { a as e, o as t, r as n } from "./panels-BqmX3eap.mjs";
+import r from "@mavonengine/core/Editor/EditorHelper";
+import i from "@mavonengine/core/Game";
+import { SCENE_SAVE_PATH as a } from "@mavonengine/core/Plugins/types";
+import o from "@mavonengine/core/Utils/EventEmitter";
+import { AdditiveBlending as s, BoxGeometry as c, BufferGeometry as l, Color as u, Controls as d, CylinderGeometry as f, DoubleSide as p, Euler as m, Float32BufferAttribute as h, HalfFloatType as g, Line as _, LineBasicMaterial as ee, Matrix4 as v, Mesh as y, MeshBasicMaterial as te, MeshDepthMaterial as b, NoBlending as x, Object3D as S, OctahedronGeometry as C, OrthographicCamera as w, PlaneGeometry as T, Quaternion as E, RGBADepthPacking as ne, Raycaster as re, ShaderMaterial as D, SphereGeometry as ie, TorusGeometry as O, UniformsUtils as ae, Vector2 as k, Vector3 as A, WebGLRenderTarget as j } from "three";
+import { lightType as M, primitiveType as N } from "@mavonengine/core/Scene/builtinSceneObjects";
+import { SCENE_FORMAT_VERSION as oe } from "@mavonengine/core/Scene/types";
+// ../../node_modules/three/examples/jsm/controls/FlyControls.js
+var P = { type: "change" }, se = 1e-6, ce = new E(), le = class extends d {
+	constructor(e, t = null) {
+		super(e, t), this.movementSpeed = 1, this.rollSpeed = .005, 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 A(0, 0, 0), this._rotationVector = new A(0, 0, 0), this._lastQuaternion = new E(), this._lastPosition = new A(), this._status = 0, this._onKeyDown = ue.bind(this), this._onKeyUp = de.bind(this), this._onPointerMove = pe.bind(this), this._onPointerDown = fe.bind(this), this._onPointerUp = me.bind(this), this._onPointerCancel = he.bind(this), this._onContextMenu = ge.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), this.domElement.style.touchAction = "none";
+	}
+	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), this.domElement.style.touchAction = "";
+	}
+	dispose() {
+		this.disconnect();
+	}
+	update(e) {
+		if (this.enabled === !1) return;
+		let t = this.object, n = e * this.movementSpeed, r = e * this.rollSpeed;
+		t.translateX(this._moveVector.x * n), t.translateY(this._moveVector.y * n), t.translateZ(this._moveVector.z * n), ce.set(this._rotationVector.x * r, this._rotationVector.y * r, this._rotationVector.z * r, 1).normalize(), t.quaternion.multiply(ce), (this._lastPosition.distanceToSquared(t.position) > se || 8 * (1 - this._lastQuaternion.dot(t.quaternion)) > se) && (this.dispatchEvent(P), this._lastQuaternion.copy(t.quaternion), this._lastPosition.copy(t.position));
+	}
+	_updateMovementVector() {
+		let 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: [window.innerWidth, window.innerHeight],
+			offset: [0, 0]
+		} : {
+			size: [this.domElement.offsetWidth, this.domElement.offsetHeight],
+			offset: [this.domElement.offsetLeft, this.domElement.offsetTop]
+		};
+	}
 };
+function ue(e) {
+	if (!(e.altKey || this.enabled === !1)) {
+		switch (e.code) {
+			case "ShiftLeft":
+			case "ShiftRight":
+				this.movementSpeedMultiplier = .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;
+		}
+		this._updateMovementVector(), this._updateRotationVector();
+	}
+}
+function de(e) {
+	if (this.enabled !== !1) {
+		switch (e.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;
+		}
+		this._updateMovementVector(), this._updateRotationVector();
+	}
+}
+function fe(e) {
+	if (this.enabled !== !1) {
+		if (this.dragToLook) this._status++;
+		else {
+			switch (e.button) {
+				case 0:
+					this._moveState.forward = 1;
+					break;
+				case 2: this._moveState.back = 1;
+			}
+			this._updateMovementVector();
+		}
+	}
+}
+function pe(e) {
+	if (this.enabled !== !1 && (!this.dragToLook || this._status > 0)) {
+		let t = this._getContainerDimensions(), n = t.size[0] / 2, r = t.size[1] / 2;
+		this._moveState.yawLeft = -(e.pageX - t.offset[0] - n) / n, this._moveState.pitchDown = (e.pageY - t.offset[1] - r) / r, this._updateRotationVector();
+	}
+}
+function me(e) {
+	if (this.enabled !== !1) {
+		if (this.dragToLook) this._status--, this._moveState.yawLeft = this._moveState.pitchDown = 0;
+		else {
+			switch (e.button) {
+				case 0:
+					this._moveState.forward = 0;
+					break;
+				case 2: this._moveState.back = 0;
+			}
+			this._updateMovementVector();
+		}
+		this._updateRotationVector();
+	}
+}
+function he() {
+	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 ge(e) {
+	this.enabled !== !1 && e.preventDefault();
+}
+// ../../node_modules/three/examples/jsm/controls/TransformControls.js
+var F = new re(), I = new A(), L = new A(), R = new E(), _e = {
+	X: new A(1, 0, 0),
+	Y: new A(0, 1, 0),
+	Z: new A(0, 0, 1)
+}, z = { type: "change" }, ve = {
+	type: "mouseDown",
+	mode: null
+}, ye = {
+	type: "mouseUp",
+	mode: null
+}, be = { type: "objectChange" }, xe = class extends d {
+	constructor(e, t = null) {
+		super(void 0, t);
+		let n = new Ae(this);
+		this._root = n;
+		let r = new je();
+		this._gizmo = r, n.add(r);
+		let i = new Me();
+		this._plane = i, n.add(i);
+		let a = this;
+		function o(e, t) {
+			let n = t;
+			Object.defineProperty(a, e, {
+				get: function() {
+					return n === void 0 ? t : n;
+				},
+				set: function(t) {
+					n !== t && (n = t, i[e] = t, r[e] = t, a.dispatchEvent({
+						type: e + "-changed",
+						value: t
+					}), a.dispatchEvent(z));
+				}
+			}), a[e] = t, i[e] = t, r[e] = t;
+		}
+		o("camera", e), o("object", void 0), o("enabled", !0), o("axis", null), o("mode", "translate"), o("translationSnap", null), o("rotationSnap", null), o("scaleSnap", null), o("space", "world"), o("size", 1), o("dragging", !1), o("showX", !0), o("showY", !0), o("showZ", !0), o("showXY", !0), o("showYZ", !0), o("showXZ", !0), o("minX", -Infinity), o("maxX", Infinity), o("minY", -Infinity), o("maxY", Infinity), o("minZ", -Infinity), o("maxZ", Infinity);
+		let s = new A(), c = new A(), l = new E(), u = new E(), d = new A(), f = new E(), p = new A(), m = new A(), h = new A(), g = new A();
+		o("worldPosition", s), o("worldPositionStart", c), o("worldQuaternion", l), o("worldQuaternionStart", u), o("cameraPosition", d), o("cameraQuaternion", f), o("pointStart", p), o("pointEnd", m), o("rotationAxis", h), o("rotationAngle", 0), o("eye", g), this._offset = new A(), this._startNorm = new A(), this._endNorm = new A(), this._cameraScale = new A(), this._parentPosition = new A(), this._parentQuaternion = new E(), this._parentQuaternionInv = new E(), this._parentScale = new A(), this._worldScaleStart = new A(), this._worldQuaternionInv = new E(), this._worldScale = new A(), this._positionStart = new A(), this._quaternionStart = new E(), this._scaleStart = new A(), this._getPointer = Se.bind(this), this._onPointerDown = we.bind(this), this._onPointerHover = Ce.bind(this), this._onPointerMove = Te.bind(this), this._onPointerUp = Ee.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 = "";
+	}
+	getHelper() {
+		return this._root;
+	}
+	pointerHover(e) {
+		if (this.object === void 0 || this.dragging === !0) return;
+		e !== null && F.setFromCamera(e, this.camera);
+		let t = B(this._gizmo.picker[this.mode], F);
+		this.axis = t ? t.object.name : null;
+	}
+	pointerDown(e) {
+		if (!(this.object === void 0 || this.dragging === !0 || e != null && e.button !== 0) && this.axis !== null) {
+			e !== null && F.setFromCamera(e, this.camera);
+			let t = B(this._plane, F, !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, ve.mode = this.mode, this.dispatchEvent(ve);
+		}
+	}
+	pointerMove(e) {
+		let t = this.axis, n = this.mode, r = this.object, i = this.space;
+		if (n === "scale" ? i = "local" : (t === "E" || t === "XYZE" || t === "XYZ") && (i = "world"), r === void 0 || t === null || this.dragging === !1 || e !== null && e.button !== -1) return;
+		e !== null && F.setFromCamera(e, this.camera);
+		let a = B(this._plane, F, !0);
+		if (a) {
+			if (this.pointEnd.copy(a.point).sub(this.worldPositionStart), n === "translate") this._offset.copy(this.pointEnd).sub(this.pointStart), i === "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), i === "local" && t !== "XYZ" ? this._offset.applyQuaternion(this._quaternionStart).divide(this._parentScale) : this._offset.applyQuaternion(this._parentQuaternionInv).divide(this._parentScale), r.position.copy(this._offset).add(this._positionStart), this.translationSnap && (i === "local" && (r.position.applyQuaternion(R.copy(this._quaternionStart).invert()), t.search("X") !== -1 && (r.position.x = Math.round(r.position.x / this.translationSnap) * this.translationSnap), t.search("Y") !== -1 && (r.position.y = Math.round(r.position.y / this.translationSnap) * this.translationSnap), t.search("Z") !== -1 && (r.position.z = Math.round(r.position.z / this.translationSnap) * this.translationSnap), r.position.applyQuaternion(this._quaternionStart)), i === "world" && (r.parent && r.position.add(I.setFromMatrixPosition(r.parent.matrixWorld)), t.search("X") !== -1 && (r.position.x = Math.round(r.position.x / this.translationSnap) * this.translationSnap), t.search("Y") !== -1 && (r.position.y = Math.round(r.position.y / this.translationSnap) * this.translationSnap), t.search("Z") !== -1 && (r.position.z = Math.round(r.position.z / this.translationSnap) * this.translationSnap), r.parent && r.position.sub(I.setFromMatrixPosition(r.parent.matrixWorld)))), r.position.x = Math.max(this.minX, Math.min(this.maxX, r.position.x)), r.position.y = Math.max(this.minY, Math.min(this.maxY, r.position.y)), r.position.z = Math.max(this.minZ, Math.min(this.maxZ, r.position.z));
+			else if (n === "scale") {
+				if (t.search("XYZ") !== -1) {
+					let e = this.pointEnd.length() / this.pointStart.length();
+					this.pointEnd.dot(this.pointStart) < 0 && (e *= -1), L.set(e, e, e);
+				} else I.copy(this.pointStart), L.copy(this.pointEnd), I.applyQuaternion(this._worldQuaternionInv), L.applyQuaternion(this._worldQuaternionInv), L.divide(I), t.search("X") === -1 && (L.x = 1), t.search("Y") === -1 && (L.y = 1), t.search("Z") === -1 && (L.z = 1);
+				r.scale.copy(this._scaleStart).multiply(L), this.scaleSnap && (t.search("X") !== -1 && (r.scale.x = Math.round(r.scale.x / this.scaleSnap) * this.scaleSnap || this.scaleSnap), t.search("Y") !== -1 && (r.scale.y = Math.round(r.scale.y / this.scaleSnap) * this.scaleSnap || this.scaleSnap), t.search("Z") !== -1 && (r.scale.z = Math.round(r.scale.z / this.scaleSnap) * this.scaleSnap || this.scaleSnap));
+			} else if (n === "rotate") {
+				this._offset.copy(this.pointEnd).sub(this.pointStart);
+				let e = 20 / this.worldPosition.distanceTo(I.setFromMatrixPosition(this.camera.matrixWorld)), n = !1;
+				t === "XYZE" ? (this.rotationAxis.copy(this._offset).cross(this.eye).normalize(), this.rotationAngle = this._offset.dot(I.copy(this.rotationAxis).cross(this.eye)) * e) : (t === "X" || t === "Y" || t === "Z") && (this.rotationAxis.copy(_e[t]), I.copy(_e[t]), i === "local" && I.applyQuaternion(this.worldQuaternion), I.cross(this.eye), I.length() === 0 ? n = !0 : this.rotationAngle = this._offset.dot(I.normalize()) * e), (t === "E" || n) && (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), i === "local" && t !== "E" && t !== "XYZE" ? (r.quaternion.copy(this._quaternionStart), r.quaternion.multiply(R.setFromAxisAngle(this.rotationAxis, this.rotationAngle)).normalize()) : (this.rotationAxis.applyQuaternion(this._parentQuaternionInv), r.quaternion.copy(R.setFromAxisAngle(this.rotationAxis, this.rotationAngle)), r.quaternion.multiply(this._quaternionStart).normalize());
+			}
+			this.dispatchEvent(z), this.dispatchEvent(be);
+		}
+	}
+	pointerUp(e) {
+		(e === null || e.button === 0) && (this.dragging && this.axis !== null && (ye.mode = this.mode, this.dispatchEvent(ye)), this.dragging = !1, this.axis = null);
+	}
+	dispose() {
+		this.disconnect(), this._root.dispose();
+	}
+	attach(e) {
+		return this.object = e, this._root.visible = !0, this;
+	}
+	detach() {
+		return this.object = void 0, this.axis = null, this._root.visible = !1, this;
+	}
+	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(z), this.dispatchEvent(be), this.pointStart.copy(this.pointEnd));
+	}
+	getRaycaster() {
+		return F;
+	}
+	getMode() {
+		return this.mode;
+	}
+	setMode(e) {
+		this.mode = e;
+	}
+	setTranslationSnap(e) {
+		this.translationSnap = e;
+	}
+	setRotationSnap(e) {
+		this.rotationSnap = e;
+	}
+	setScaleSnap(e) {
+		this.scaleSnap = e;
+	}
+	setSize(e) {
+		this.size = e;
+	}
+	setSpace(e) {
+		this.space = e;
+	}
+	setColors(e, t, n, r) {
+		let i = this._gizmo.materialLib;
+		i.xAxis.color.set(e), i.yAxis.color.set(t), i.zAxis.color.set(n), i.active.color.set(r), i.xAxisTransparent.color.set(e), i.yAxisTransparent.color.set(t), i.zAxisTransparent.color.set(n), i.activeTransparent.color.set(r), i.xAxis._color && i.xAxis._color.set(e), i.yAxis._color && i.yAxis._color.set(t), i.zAxis._color && i.zAxis._color.set(n), i.active._color && i.active._color.set(r), i.xAxisTransparent._color && i.xAxisTransparent._color.set(e), i.yAxisTransparent._color && i.yAxisTransparent._color.set(t), i.zAxisTransparent._color && i.zAxisTransparent._color.set(n), i.activeTransparent._color && i.activeTransparent._color.set(r);
+	}
+};
+function Se(e) {
+	if (this.domElement.ownerDocument.pointerLockElement) return {
+		x: 0,
+		y: 0,
+		button: e.button
+	};
+	{
+		let t = this.domElement.getBoundingClientRect();
+		return {
+			x: (e.clientX - t.left) / t.width * 2 - 1,
+			y: -(e.clientY - t.top) / t.height * 2 + 1,
+			button: e.button
+		};
+	}
+}
+function Ce(e) {
+	if (this.enabled) switch (e.pointerType) {
+		case "mouse":
+		case "pen": this.pointerHover(this._getPointer(e));
+	}
+}
+function we(e) {
+	this.enabled && (document.pointerLockElement || this.domElement.setPointerCapture(e.pointerId), this.domElement.addEventListener("pointermove", this._onPointerMove), this.pointerHover(this._getPointer(e)), this.pointerDown(this._getPointer(e)));
+}
+function Te(e) {
+	this.enabled && this.pointerMove(this._getPointer(e));
+}
+function Ee(e) {
+	this.enabled && (this.domElement.releasePointerCapture(e.pointerId), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.pointerUp(this._getPointer(e)));
+}
+function B(e, t, n) {
+	let r = t.intersectObject(e, !0);
+	for (let e = 0; e < r.length; e++) if (r[e].object.visible || n) return r[e];
+	return !1;
+}
+var V = new m(), H = new A(0, 1, 0), De = new A(0, 0, 0), Oe = new v(), U = new E(), W = new E(), G = new A(), ke = new v(), K = new A(1, 0, 0), q = new A(0, 1, 0), J = new A(0, 0, 1), Y = new A(), X = new A(), Z = new A(), Ae = class extends S {
+	constructor(e) {
+		super(), this.isTransformControlsRoot = !0, this.controls = e, this.visible = !1;
+	}
+	updateMatrixWorld(e) {
+		let 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();
+		});
+	}
+}, je = class extends S {
+	constructor() {
+		super(), this.isTransformControlsGizmo = !0, this.type = "TransformControlsGizmo";
+		let e = new te({
+			depthTest: !1,
+			depthWrite: !1,
+			fog: !1,
+			toneMapped: !1,
+			transparent: !0
+		}), t = new ee({
+			depthTest: !1,
+			depthWrite: !1,
+			fog: !1,
+			toneMapped: !1,
+			transparent: !0
+		}), n = e.clone();
+		n.opacity = .15;
+		let r = t.clone();
+		r.opacity = .5;
+		let i = e.clone();
+		i.color.setHex(16711680);
+		let a = e.clone();
+		a.color.setHex(65280);
+		let o = e.clone();
+		o.color.setHex(255);
+		let s = e.clone();
+		s.color.setHex(16711680), s.opacity = .5;
+		let u = e.clone();
+		u.color.setHex(65280), u.opacity = .5;
+		let d = e.clone();
+		d.color.setHex(255), d.opacity = .5;
+		let p = e.clone();
+		p.opacity = .25;
+		let m = e.clone();
+		m.color.setHex(16776960), m.opacity = .25;
+		let g = e.clone();
+		g.color.setHex(16776960);
+		let v = e.clone();
+		v.color.setHex(7895160), this.materialLib = {
+			xAxis: i,
+			yAxis: a,
+			zAxis: o,
+			active: g,
+			xAxisTransparent: s,
+			yAxisTransparent: u,
+			zAxisTransparent: d,
+			activeTransparent: m
+		};
+		let b = new f(0, .04, .1, 12);
+		b.translate(0, .05, 0);
+		let x = new c(.08, .08, .08);
+		x.translate(0, .04, 0);
+		let w = new l();
+		w.setAttribute("position", new h([
+			0,
+			0,
+			0,
+			1,
+			0,
+			0
+		], 3));
+		let T = new f(.0075, .0075, .5, 3);
+		T.translate(0, .25, 0);
+		function E(e, t) {
+			let n = new O(e, .0075, 3, 64, t * Math.PI * 2);
+			return n.rotateY(Math.PI / 2), n.rotateX(Math.PI / 2), n;
+		}
+		function ne() {
+			let e = new l();
+			return e.setAttribute("position", new h([
+				0,
+				0,
+				0,
+				1,
+				1,
+				1
+			], 3)), e;
+		}
+		let re = {
+			X: [
+				[
+					new y(b, i),
+					[
+						.5,
+						0,
+						0
+					],
+					[
+						0,
+						0,
+						-Math.PI / 2
+					]
+				],
+				[
+					new y(b, i),
+					[
+						-.5,
+						0,
+						0
+					],
+					[
+						0,
+						0,
+						Math.PI / 2
+					]
+				],
+				[
+					new y(T, i),
+					[
+						0,
+						0,
+						0
+					],
+					[
+						0,
+						0,
+						-Math.PI / 2
+					]
+				]
+			],
+			Y: [
+				[new y(b, a), [
+					0,
+					.5,
+					0
+				]],
+				[
+					new y(b, a),
+					[
+						0,
+						-.5,
+						0
+					],
+					[
+						Math.PI,
+						0,
+						0
+					]
+				],
+				[new y(T, a)]
+			],
+			Z: [
+				[
+					new y(b, o),
+					[
+						0,
+						0,
+						.5
+					],
+					[
+						Math.PI / 2,
+						0,
+						0
+					]
+				],
+				[
+					new y(b, o),
+					[
+						0,
+						0,
+						-.5
+					],
+					[
+						-Math.PI / 2,
+						0,
+						0
+					]
+				],
+				[
+					new y(T, o),
+					null,
+					[
+						Math.PI / 2,
+						0,
+						0
+					]
+				]
+			],
+			XYZ: [[new y(new C(.1, 0), p), [
+				0,
+				0,
+				0
+			]]],
+			XY: [[new y(new c(.15, .15, .01), d), [
+				.15,
+				.15,
+				0
+			]]],
+			YZ: [[
+				new y(new c(.15, .15, .01), s),
+				[
+					0,
+					.15,
+					.15
+				],
+				[
+					0,
+					Math.PI / 2,
+					0
+				]
+			]],
+			XZ: [[
+				new y(new c(.15, .15, .01), u),
+				[
+					.15,
+					0,
+					.15
+				],
+				[
+					-Math.PI / 2,
+					0,
+					0
+				]
+			]]
+		}, D = {
+			X: [[
+				new y(new f(.2, 0, .6, 4), n),
+				[
+					.3,
+					0,
+					0
+				],
+				[
+					0,
+					0,
+					-Math.PI / 2
+				]
+			], [
+				new y(new f(.2, 0, .6, 4), n),
+				[
+					-.3,
+					0,
+					0
+				],
+				[
+					0,
+					0,
+					Math.PI / 2
+				]
+			]],
+			Y: [[new y(new f(.2, 0, .6, 4), n), [
+				0,
+				.3,
+				0
+			]], [
+				new y(new f(.2, 0, .6, 4), n),
+				[
+					0,
+					-.3,
+					0
+				],
+				[
+					0,
+					0,
+					Math.PI
+				]
+			]],
+			Z: [[
+				new y(new f(.2, 0, .6, 4), n),
+				[
+					0,
+					0,
+					.3
+				],
+				[
+					Math.PI / 2,
+					0,
+					0
+				]
+			], [
+				new y(new f(.2, 0, .6, 4), n),
+				[
+					0,
+					0,
+					-.3
+				],
+				[
+					-Math.PI / 2,
+					0,
+					0
+				]
+			]],
+			XYZ: [[new y(new C(.2, 0), n)]],
+			XY: [[new y(new c(.2, .2, .01), n), [
+				.15,
+				.15,
+				0
+			]]],
+			YZ: [[
+				new y(new c(.2, .2, .01), n),
+				[
+					0,
+					.15,
+					.15
+				],
+				[
+					0,
+					Math.PI / 2,
+					0
+				]
+			]],
+			XZ: [[
+				new y(new c(.2, .2, .01), n),
+				[
+					.15,
+					0,
+					.15
+				],
+				[
+					-Math.PI / 2,
+					0,
+					0
+				]
+			]]
+		}, ae = {
+			START: [[
+				new y(new C(.01, 2), r),
+				null,
+				null,
+				null,
+				"helper"
+			]],
+			END: [[
+				new y(new C(.01, 2), r),
+				null,
+				null,
+				null,
+				"helper"
+			]],
+			DELTA: [[
+				new _(ne(), r),
+				null,
+				null,
+				null,
+				"helper"
+			]],
+			X: [[
+				new _(w, r),
+				[
+					-1e3,
+					0,
+					0
+				],
+				null,
+				[
+					1e6,
+					1,
+					1
+				],
+				"helper"
+			]],
+			Y: [[
+				new _(w, r),
+				[
+					0,
+					-1e3,
+					0
+				],
+				[
+					0,
+					0,
+					Math.PI / 2
+				],
+				[
+					1e6,
+					1,
+					1
+				],
+				"helper"
+			]],
+			Z: [[
+				new _(w, r),
+				[
+					0,
+					0,
+					-1e3
+				],
+				[
+					0,
+					-Math.PI / 2,
+					0
+				],
+				[
+					1e6,
+					1,
+					1
+				],
+				"helper"
+			]]
+		}, k = {
+			XYZE: [[
+				new y(E(.5, 1), v),
+				null,
+				[
+					0,
+					Math.PI / 2,
+					0
+				]
+			]],
+			X: [[new y(E(.5, .5), i)]],
+			Y: [[
+				new y(E(.5, .5), a),
+				null,
+				[
+					0,
+					0,
+					-Math.PI / 2
+				]
+			]],
+			Z: [[
+				new y(E(.5, .5), o),
+				null,
+				[
+					0,
+					Math.PI / 2,
+					0
+				]
+			]],
+			E: [[
+				new y(E(.75, 1), m),
+				null,
+				[
+					0,
+					Math.PI / 2,
+					0
+				]
+			]]
+		}, A = { AXIS: [[
+			new _(w, r),
+			[
+				-1e3,
+				0,
+				0
+			],
+			null,
+			[
+				1e6,
+				1,
+				1
+			],
+			"helper"
+		]] }, j = {
+			XYZE: [[new y(new ie(.25, 10, 8), n)]],
+			X: [[
+				new y(new O(.5, .1, 4, 24), n),
+				[
+					0,
+					0,
+					0
+				],
+				[
+					0,
+					-Math.PI / 2,
+					-Math.PI / 2
+				]
+			]],
+			Y: [[
+				new y(new O(.5, .1, 4, 24), n),
+				[
+					0,
+					0,
+					0
+				],
+				[
+					Math.PI / 2,
+					0,
+					0
+				]
+			]],
+			Z: [[
+				new y(new O(.5, .1, 4, 24), n),
+				[
+					0,
+					0,
+					0
+				],
+				[
+					0,
+					0,
+					-Math.PI / 2
+				]
+			]],
+			E: [[new y(new O(.75, .1, 2, 24), n)]]
+		}, M = {
+			X: [
+				[
+					new y(x, i),
+					[
+						.5,
+						0,
+						0
+					],
+					[
+						0,
+						0,
+						-Math.PI / 2
+					]
+				],
+				[
+					new y(T, i),
+					[
+						0,
+						0,
+						0
+					],
+					[
+						0,
+						0,
+						-Math.PI / 2
+					]
+				],
+				[
+					new y(x, i),
+					[
+						-.5,
+						0,
+						0
+					],
+					[
+						0,
+						0,
+						Math.PI / 2
+					]
+				]
+			],
+			Y: [
+				[new y(x, a), [
+					0,
+					.5,
+					0
+				]],
+				[new y(T, a)],
+				[
+					new y(x, a),
+					[
+						0,
+						-.5,
+						0
+					],
+					[
+						0,
+						0,
+						Math.PI
+					]
+				]
+			],
+			Z: [
+				[
+					new y(x, o),
+					[
+						0,
+						0,
+						.5
+					],
+					[
+						Math.PI / 2,
+						0,
+						0
+					]
+				],
+				[
+					new y(T, o),
+					[
+						0,
+						0,
+						0
+					],
+					[
+						Math.PI / 2,
+						0,
+						0
+					]
+				],
+				[
+					new y(x, o),
+					[
+						0,
+						0,
+						-.5
+					],
+					[
+						-Math.PI / 2,
+						0,
+						0
+					]
+				]
+			],
+			XY: [[new y(new c(.15, .15, .01), d), [
+				.15,
+				.15,
+				0
+			]]],
+			YZ: [[
+				new y(new c(.15, .15, .01), s),
+				[
+					0,
+					.15,
+					.15
+				],
+				[
+					0,
+					Math.PI / 2,
+					0
+				]
+			]],
+			XZ: [[
+				new y(new c(.15, .15, .01), u),
+				[
+					.15,
+					0,
+					.15
+				],
+				[
+					-Math.PI / 2,
+					0,
+					0
+				]
+			]],
+			XYZ: [[new y(new c(.1, .1, .1), p)]]
+		}, N = {
+			X: [[
+				new y(new f(.2, 0, .6, 4), n),
+				[
+					.3,
+					0,
+					0
+				],
+				[
+					0,
+					0,
+					-Math.PI / 2
+				]
+			], [
+				new y(new f(.2, 0, .6, 4), n),
+				[
+					-.3,
+					0,
+					0
+				],
+				[
+					0,
+					0,
+					Math.PI / 2
+				]
+			]],
+			Y: [[new y(new f(.2, 0, .6, 4), n), [
+				0,
+				.3,
+				0
+			]], [
+				new y(new f(.2, 0, .6, 4), n),
+				[
+					0,
+					-.3,
+					0
+				],
+				[
+					0,
+					0,
+					Math.PI
+				]
+			]],
+			Z: [[
+				new y(new f(.2, 0, .6, 4), n),
+				[
+					0,
+					0,
+					.3
+				],
+				[
+					Math.PI / 2,
+					0,
+					0
+				]
+			], [
+				new y(new f(.2, 0, .6, 4), n),
+				[
+					0,
+					0,
+					-.3
+				],
+				[
+					-Math.PI / 2,
+					0,
+					0
+				]
+			]],
+			XY: [[new y(new c(.2, .2, .01), n), [
+				.15,
+				.15,
+				0
+			]]],
+			YZ: [[
+				new y(new c(.2, .2, .01), n),
+				[
+					0,
+					.15,
+					.15
+				],
+				[
+					0,
+					Math.PI / 2,
+					0
+				]
+			]],
+			XZ: [[
+				new y(new c(.2, .2, .01), n),
+				[
+					.15,
+					0,
+					.15
+				],
+				[
+					-Math.PI / 2,
+					0,
+					0
+				]
+			]],
+			XYZ: [[new y(new c(.2, .2, .2), n), [
+				0,
+				0,
+				0
+			]]]
+		}, oe = {
+			X: [[
+				new _(w, r),
+				[
+					-1e3,
+					0,
+					0
+				],
+				null,
+				[
+					1e6,
+					1,
+					1
+				],
+				"helper"
+			]],
+			Y: [[
+				new _(w, r),
+				[
+					0,
+					-1e3,
+					0
+				],
+				[
+					0,
+					0,
+					Math.PI / 2
+				],
+				[
+					1e6,
+					1,
+					1
+				],
+				"helper"
+			]],
+			Z: [[
+				new _(w, r),
+				[
+					0,
+					0,
+					-1e3
+				],
+				[
+					0,
+					-Math.PI / 2,
+					0
+				],
+				[
+					1e6,
+					1,
+					1
+				],
+				"helper"
+			]]
+		};
+		function P(e) {
+			let t = new S();
+			for (let n in e) for (let r = e[n].length; r--;) {
+				let i = e[n][r][0].clone(), a = e[n][r][1], o = e[n][r][2], s = e[n][r][3], c = e[n][r][4];
+				i.name = n, i.tag = c, a && i.position.set(a[0], a[1], a[2]), o && i.rotation.set(o[0], o[1], o[2]), s && i.scale.set(s[0], s[1], s[2]), i.updateMatrix();
+				let l = i.geometry.clone();
+				l.applyMatrix4(i.matrix), i.geometry = l, i.renderOrder = Infinity, i.position.set(0, 0, 0), i.rotation.set(0, 0, 0), i.scale.set(1, 1, 1), t.add(i);
+			}
+			return t;
+		}
+		this.gizmo = {}, this.picker = {}, this.helper = {}, this.add(this.gizmo.translate = P(re)), this.add(this.gizmo.rotate = P(k)), this.add(this.gizmo.scale = P(M)), this.add(this.picker.translate = P(D)), this.add(this.picker.rotate = P(j)), this.add(this.picker.scale = P(N)), this.add(this.helper.translate = P(ae)), this.add(this.helper.rotate = P(A)), this.add(this.helper.scale = P(oe)), this.picker.translate.visible = !1, this.picker.rotate.visible = !1, this.picker.scale.visible = !1;
+	}
+	updateMatrixWorld(e) {
+		let t = (this.mode === "scale" ? "local" : this.space) === "local" ? this.worldQuaternion : W;
+		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 n = [];
+		n = n.concat(this.picker[this.mode].children), n = n.concat(this.gizmo[this.mode].children), n = n.concat(this.helper[this.mode].children);
+		for (let e = 0; e < n.length; e++) {
+			let r = n[e];
+			r.visible = !0, r.rotation.set(0, 0, 0), r.position.copy(this.worldPosition);
+			let i;
+			if (i = this.camera.isOrthographicCamera ? (this.camera.top - this.camera.bottom) / this.camera.zoom : this.worldPosition.distanceTo(this.cameraPosition) * Math.min(1.9 * Math.tan(Math.PI * this.camera.fov / 360) / this.camera.zoom, 7), r.scale.set(1, 1, 1).multiplyScalar(i * this.size / 4), r.tag === "helper") r.visible = !1, r.name === "AXIS" ? (r.visible = !!this.axis, this.axis === "X" && (R.setFromEuler(V.set(0, 0, 0)), r.quaternion.copy(t).multiply(R), Math.abs(H.copy(K).applyQuaternion(t).dot(this.eye)) > .9 && (r.visible = !1)), this.axis === "Y" && (R.setFromEuler(V.set(0, 0, Math.PI / 2)), r.quaternion.copy(t).multiply(R), Math.abs(H.copy(q).applyQuaternion(t).dot(this.eye)) > .9 && (r.visible = !1)), this.axis === "Z" && (R.setFromEuler(V.set(0, Math.PI / 2, 0)), r.quaternion.copy(t).multiply(R), Math.abs(H.copy(J).applyQuaternion(t).dot(this.eye)) > .9 && (r.visible = !1)), this.axis === "XYZE" && (R.setFromEuler(V.set(0, Math.PI / 2, 0)), H.copy(this.rotationAxis), r.quaternion.setFromRotationMatrix(Oe.lookAt(De, H, q)), r.quaternion.multiply(R), r.visible = this.dragging), this.axis === "E" && (r.visible = !1)) : r.name === "START" ? (r.position.copy(this.worldPositionStart), r.visible = this.dragging) : r.name === "END" ? (r.position.copy(this.worldPosition), r.visible = this.dragging) : r.name === "DELTA" ? (r.position.copy(this.worldPositionStart), r.quaternion.copy(this.worldQuaternionStart), I.set(1e-10, 1e-10, 1e-10).add(this.worldPositionStart).sub(this.worldPosition).multiplyScalar(-1), I.applyQuaternion(this.worldQuaternionStart.clone().invert()), r.scale.copy(I), r.visible = this.dragging) : (r.quaternion.copy(t), this.dragging ? r.position.copy(this.worldPositionStart) : r.position.copy(this.worldPosition), this.axis && (r.visible = this.axis.search(r.name) !== -1));
+			else {
+				if (r.quaternion.copy(t), this.mode === "translate" || this.mode === "scale") {
+					let e = .99, n = .2;
+					r.name === "X" && Math.abs(H.copy(K).applyQuaternion(t).dot(this.eye)) > e && (r.scale.set(1e-10, 1e-10, 1e-10), r.visible = !1), r.name === "Y" && Math.abs(H.copy(q).applyQuaternion(t).dot(this.eye)) > e && (r.scale.set(1e-10, 1e-10, 1e-10), r.visible = !1), r.name === "Z" && Math.abs(H.copy(J).applyQuaternion(t).dot(this.eye)) > e && (r.scale.set(1e-10, 1e-10, 1e-10), r.visible = !1), r.name === "XY" && Math.abs(H.copy(J).applyQuaternion(t).dot(this.eye)) < n && (r.scale.set(1e-10, 1e-10, 1e-10), r.visible = !1), r.name === "YZ" && Math.abs(H.copy(K).applyQuaternion(t).dot(this.eye)) < n && (r.scale.set(1e-10, 1e-10, 1e-10), r.visible = !1), r.name === "XZ" && Math.abs(H.copy(q).applyQuaternion(t).dot(this.eye)) < n && (r.scale.set(1e-10, 1e-10, 1e-10), r.visible = !1);
+				} else this.mode === "rotate" && (U.copy(t), H.copy(this.eye).applyQuaternion(R.copy(t).invert()), r.name.search("E") !== -1 && r.quaternion.setFromRotationMatrix(Oe.lookAt(this.eye, De, q)), r.name === "X" && (R.setFromAxisAngle(K, Math.atan2(-H.y, H.z)), R.multiplyQuaternions(U, R), r.quaternion.copy(R)), r.name === "Y" && (R.setFromAxisAngle(q, Math.atan2(H.x, H.z)), R.multiplyQuaternions(U, R), r.quaternion.copy(R)), r.name === "Z" && (R.setFromAxisAngle(J, Math.atan2(H.y, H.x)), R.multiplyQuaternions(U, R), r.quaternion.copy(R)));
+				r.visible = r.visible && (r.name.indexOf("X") === -1 || this.showX), r.visible = r.visible && (r.name.indexOf("Y") === -1 || this.showY), r.visible = r.visible && (r.name.indexOf("Z") === -1 || this.showZ), r.visible = r.visible && (r.name.indexOf("E") === -1 || this.showX && this.showY && this.showZ), r.visible = r.visible && (r.name.indexOf("XY") === -1 || this.showXY), r.visible = r.visible && (r.name.indexOf("YZ") === -1 || this.showYZ), r.visible = r.visible && (r.name.indexOf("XZ") === -1 || this.showXZ), r.material._color = r.material._color || r.material.color.clone(), r.material._opacity = r.material._opacity || r.material.opacity, r.material.color.copy(r.material._color), r.material.opacity = r.material._opacity, this.enabled && this.axis && (r.name === this.axis || this.axis.split("").some(function(e) {
+					return r.name === e;
+				})) && (r.material.color.copy(this.materialLib.active.color), r.material.opacity = 1);
+			}
+		}
+		super.updateMatrixWorld(e);
+	}
+}, Me = class extends y {
+	constructor() {
+		super(new T(1e5, 1e5, 2, 2), new te({
+			visible: !1,
+			wireframe: !0,
+			side: p,
+			transparent: !0,
+			opacity: .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"), Y.copy(K).applyQuaternion(t === "local" ? this.worldQuaternion : W), X.copy(q).applyQuaternion(t === "local" ? this.worldQuaternion : W), Z.copy(J).applyQuaternion(t === "local" ? this.worldQuaternion : W), H.copy(X), this.mode) {
+			case "translate":
+			case "scale":
+				switch (this.axis) {
+					case "X":
+						H.copy(this.eye).cross(Y), G.copy(Y).cross(H);
+						break;
+					case "Y":
+						H.copy(this.eye).cross(X), G.copy(X).cross(H);
+						break;
+					case "Z":
+						H.copy(this.eye).cross(Z), G.copy(Z).cross(H);
+						break;
+					case "XY":
+						G.copy(Z);
+						break;
+					case "YZ":
+						G.copy(Y);
+						break;
+					case "XZ":
+						H.copy(Z), G.copy(X);
+						break;
+					case "XYZ":
+					case "E": G.set(0, 0, 0);
+				}
+				break;
+			default: G.set(0, 0, 0);
+		}
+		G.length() === 0 ? this.quaternion.copy(this.cameraQuaternion) : (ke.lookAt(I.set(0, 0, 0), G, H), this.quaternion.setFromRotationMatrix(ke)), super.updateMatrixWorld(e);
+	}
+}, Ne = class {
+	constructor() {
+		this.isPass = !0, this.enabled = !0, this.needsSwap = !0, this.clear = !1, this.renderToScreen = !1;
+	}
+	setSize() {}
+	render() {
+		console.error("THREE.Pass: .render() must be implemented in derived pass.");
+	}
+	dispose() {}
+}, Pe = new w(-1, 1, 1, -1, 0, 1), Fe = new class extends l {
+	constructor() {
+		super(), this.setAttribute("position", new h([
+			-1,
+			3,
+			0,
+			-1,
+			-1,
+			0,
+			3,
+			-1,
+			0
+		], 3)), this.setAttribute("uv", new h([
+			0,
+			2,
+			0,
+			0,
+			2,
+			0
+		], 2));
+	}
+}(), Ie = class {
+	constructor(e) {
+		this._mesh = new y(Fe, e);
+	}
+	dispose() {
+		this._mesh.geometry.dispose();
+	}
+	render(e) {
+		e.render(this._mesh, Pe);
+	}
+	get material() {
+		return this._mesh.material;
+	}
+	set material(e) {
+		this._mesh.material = e;
+	}
+}, Le = {
+	name: "CopyShader",
+	uniforms: {
+		tDiffuse: { value: null },
+		opacity: { value: 1 }
+	},
+	vertexShader: "\n\n		varying vec2 vUv;\n\n		void main() {\n\n			vUv = uv;\n			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n\n		}",
+	fragmentShader: "\n\n		uniform float opacity;\n\n		uniform sampler2D tDiffuse;\n\n		varying vec2 vUv;\n\n		void main() {\n\n			vec4 texel = texture2D( tDiffuse, vUv );\n			gl_FragColor = opacity * texel;\n\n\n		}"
+}, Re = class e extends Ne {
+	constructor(e, t, n, r) {
+		super(), this.renderScene = t, this.renderCamera = n, this.selectedObjects = r === void 0 ? [] : r, this.visibleEdgeColor = new u(1, 1, 1), this.hiddenEdgeColor = new u(.1, .04, .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(256, 256) : new k(e.x, e.y);
+		let i = Math.round(this.resolution.x / this.downSampleRatio), a = Math.round(this.resolution.y / this.downSampleRatio);
+		this.renderTargetMaskBuffer = new j(this.resolution.x, this.resolution.y), this.renderTargetMaskBuffer.texture.name = "OutlinePass.mask", this.renderTargetMaskBuffer.texture.generateMipmaps = !1, this.depthMaterial = new b(), this.depthMaterial.side = p, this.depthMaterial.depthPacking = ne, this.depthMaterial.blending = x, this.prepareMaskMaterial = this._getPrepareMaskMaterial(), this.prepareMaskMaterial.side = p, this.prepareMaskMaterial.fragmentShader = s(this.prepareMaskMaterial.fragmentShader, this.renderCamera), this.renderTargetDepthBuffer = new j(this.resolution.x, this.resolution.y, { type: g }), this.renderTargetDepthBuffer.texture.name = "OutlinePass.depth", this.renderTargetDepthBuffer.texture.generateMipmaps = !1, this.renderTargetMaskDownSampleBuffer = new j(i, a, { type: g }), this.renderTargetMaskDownSampleBuffer.texture.name = "OutlinePass.depthDownSample", this.renderTargetMaskDownSampleBuffer.texture.generateMipmaps = !1, this.renderTargetBlurBuffer1 = new j(i, a, { type: g }), this.renderTargetBlurBuffer1.texture.name = "OutlinePass.blur1", this.renderTargetBlurBuffer1.texture.generateMipmaps = !1, this.renderTargetBlurBuffer2 = new j(Math.round(i / 2), Math.round(a / 2), { type: g }), this.renderTargetBlurBuffer2.texture.name = "OutlinePass.blur2", this.renderTargetBlurBuffer2.texture.generateMipmaps = !1, this.edgeDetectionMaterial = this._getEdgeDetectionMaterial(), this.renderTargetEdgeBuffer1 = new j(i, a, { type: g }), this.renderTargetEdgeBuffer1.texture.name = "OutlinePass.edge1", this.renderTargetEdgeBuffer1.texture.generateMipmaps = !1, this.renderTargetEdgeBuffer2 = new j(Math.round(i / 2), Math.round(a / 2), { type: g }), this.renderTargetEdgeBuffer2.texture.name = "OutlinePass.edge2", this.renderTargetEdgeBuffer2.texture.generateMipmaps = !1, this.separableBlurMaterial1 = this._getSeparableBlurMaterial(4), this.separableBlurMaterial1.uniforms.texSize.value.set(i, a), this.separableBlurMaterial1.uniforms.kernelRadius.value = 1, this.separableBlurMaterial2 = this._getSeparableBlurMaterial(4), this.separableBlurMaterial2.uniforms.texSize.value.set(Math.round(i / 2), Math.round(a / 2)), this.separableBlurMaterial2.uniforms.kernelRadius.value = 4, this.overlayMaterial = this._getOverlayMaterial();
+		let o = Le;
+		this.copyUniforms = ae.clone(o.uniforms), this.materialCopy = new D({
+			uniforms: this.copyUniforms,
+			vertexShader: o.vertexShader,
+			fragmentShader: o.fragmentShader,
+			blending: x,
+			depthTest: !1,
+			depthWrite: !1
+		}), this.enabled = !0, this.needsSwap = !1, this._oldClearColor = new u(), this.oldClearAlpha = 1, this._fsQuad = new Ie(null), this.tempPulseColor1 = new u(), this.tempPulseColor2 = new u(), this.textureMatrix = new v();
+		function s(e, t) {
+			let n = t.isPerspectiveCamera ? "perspective" : "orthographic";
+			return e.replace(/DEPTH_TO_VIEW_Z/g, n + "DepthToViewZ");
+		}
+	}
+	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();
+	}
+	setSize(e, t) {
+		this.renderTargetMaskBuffer.setSize(e, t), this.renderTargetDepthBuffer.setSize(e, t);
+		let n = Math.round(e / this.downSampleRatio), r = Math.round(t / this.downSampleRatio);
+		this.renderTargetMaskDownSampleBuffer.setSize(n, r), this.renderTargetBlurBuffer1.setSize(n, r), this.renderTargetEdgeBuffer1.setSize(n, r), this.separableBlurMaterial1.uniforms.texSize.value.set(n, r), n = Math.round(n / 2), r = Math.round(r / 2), this.renderTargetBlurBuffer2.setSize(n, r), this.renderTargetEdgeBuffer2.setSize(n, r), this.separableBlurMaterial2.uniforms.texSize.value.set(n, r);
+	}
+	render(t, n, r, i, a) {
+		if (this.selectedObjects.length > 0) {
+			t.getClearColor(this._oldClearColor), this.oldClearAlpha = t.getClearAlpha();
+			let n = t.autoClear;
+			t.autoClear = !1, a && t.state.buffers.stencil.setTest(!1), t.setClearColor(16777215, 1), this._updateSelectionCache(), this._changeVisibilityOfSelectedObjects(!1);
+			let i = this.renderScene.background, o = this.renderScene.overrideMaterial;
+			if (this.renderScene.background = null, this.renderScene.overrideMaterial = this.depthMaterial, t.setRenderTarget(this.renderTargetDepthBuffer), t.clear(), t.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, t.setRenderTarget(this.renderTargetMaskBuffer), t.clear(), t.render(this.renderScene, this.renderCamera), this._changeVisibilityOfNonSelectedObjects(!0), this._visibilityCache.clear(), this._selectionCache.clear(), this.renderScene.background = i, this.renderScene.overrideMaterial = o, this._fsQuad.material = this.materialCopy, this.copyUniforms.tDiffuse.value = this.renderTargetMaskBuffer.texture, t.setRenderTarget(this.renderTargetMaskDownSampleBuffer), t.clear(), this._fsQuad.render(t), this.tempPulseColor1.copy(this.visibleEdgeColor), this.tempPulseColor2.copy(this.hiddenEdgeColor), this.pulsePeriod > 0) {
+				let e = 1.25 / 2 + Math.cos(performance.now() * .01 / this.pulsePeriod) * .75 / 2;
+				this.tempPulseColor1.multiplyScalar(e), this.tempPulseColor2.multiplyScalar(e);
+			}
+			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, t.setRenderTarget(this.renderTargetEdgeBuffer1), t.clear(), this._fsQuad.render(t), this._fsQuad.material = this.separableBlurMaterial1, this.separableBlurMaterial1.uniforms.colorTexture.value = this.renderTargetEdgeBuffer1.texture, this.separableBlurMaterial1.uniforms.direction.value = e.BlurDirectionX, this.separableBlurMaterial1.uniforms.kernelRadius.value = this.edgeThickness, t.setRenderTarget(this.renderTargetBlurBuffer1), t.clear(), this._fsQuad.render(t), this.separableBlurMaterial1.uniforms.colorTexture.value = this.renderTargetBlurBuffer1.texture, this.separableBlurMaterial1.uniforms.direction.value = e.BlurDirectionY, t.setRenderTarget(this.renderTargetEdgeBuffer1), t.clear(), this._fsQuad.render(t), this._fsQuad.material = this.separableBlurMaterial2, this.separableBlurMaterial2.uniforms.colorTexture.value = this.renderTargetEdgeBuffer1.texture, this.separableBlurMaterial2.uniforms.direction.value = e.BlurDirectionX, t.setRenderTarget(this.renderTargetBlurBuffer2), t.clear(), this._fsQuad.render(t), this.separableBlurMaterial2.uniforms.colorTexture.value = this.renderTargetBlurBuffer2.texture, this.separableBlurMaterial2.uniforms.direction.value = e.BlurDirectionY, t.setRenderTarget(this.renderTargetEdgeBuffer2), t.clear(), this._fsQuad.render(t), 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, a && t.state.buffers.stencil.setTest(!0), t.setRenderTarget(r), this._fsQuad.render(t), t.setClearColor(this._oldClearColor, this.oldClearAlpha), t.autoClear = n;
+		}
+		this.renderToScreen && (this._fsQuad.material = this.materialCopy, this.copyUniforms.tDiffuse.value = r.texture, t.setRenderTarget(null), this._fsQuad.render(t));
+	}
+	_updateSelectionCache() {
+		let e = this._selectionCache;
+		function t(t) {
+			t.isMesh && e.add(t);
+		}
+		e.clear();
+		for (let e = 0; e < this.selectedObjects.length; e++) this.selectedObjects[e].traverse(t);
+	}
+	_changeVisibilityOfSelectedObjects(e) {
+		let t = this._visibilityCache;
+		for (let n of this._selectionCache) e === !0 ? n.visible = t.get(n) : (t.set(n, n.visible), n.visible = e);
+	}
+	_changeVisibilityOfNonSelectedObjects(e) {
+		let t = this._visibilityCache, n = this._selectionCache;
+		function r(r) {
+			if (r.isPoints || r.isLine || r.isLine2) e === !0 ? r.visible = t.get(r) : (t.set(r, r.visible), r.visible = e);
+			else if ((r.isMesh || r.isSprite) && !n.has(r)) {
+				let n = r.visible;
+				(e === !1 || t.get(r) === !0) && (r.visible = e), t.set(r, n);
+			}
+		}
+		this.renderScene.traverse(r);
+	}
+	_updateTextureMatrix() {
+		this.textureMatrix.set(.5, 0, 0, .5, 0, .5, 0, .5, 0, 0, .5, .5, 0, 0, 0, 1), this.textureMatrix.multiply(this.renderCamera.projectionMatrix), this.textureMatrix.multiply(this.renderCamera.matrixWorldInverse);
+	}
+	_getPrepareMaskMaterial() {
+		return new D({
+			uniforms: {
+				depthTexture: { value: null },
+				cameraNearFar: { value: new k(.5, .5) },
+				textureMatrix: { value: null }
+			},
+			vertexShader: "#include <batching_pars_vertex>\n				#include <morphtarget_pars_vertex>\n				#include <skinning_pars_vertex>\n\n				varying vec4 projTexCoord;\n				varying vec4 vPosition;\n				uniform mat4 textureMatrix;\n\n				void main() {\n\n					#include <batching_vertex>\n					#include <skinbase_vertex>\n					#include <begin_vertex>\n					#include <morphtarget_vertex>\n					#include <skinning_vertex>\n					#include <project_vertex>\n\n					vPosition = mvPosition;\n\n					vec4 worldPosition = vec4( transformed, 1.0 );\n\n					#ifdef USE_INSTANCING\n\n						worldPosition = instanceMatrix * worldPosition;\n\n					#endif\n\n					worldPosition = modelMatrix * worldPosition;\n\n					projTexCoord = textureMatrix * worldPosition;\n\n				}",
+			fragmentShader: "#include <packing>\n				varying vec4 vPosition;\n				varying vec4 projTexCoord;\n				uniform sampler2D depthTexture;\n				uniform vec2 cameraNearFar;\n\n				void main() {\n\n					float depth = unpackRGBAToDepth(texture2DProj( depthTexture, projTexCoord ));\n					float viewZ = - DEPTH_TO_VIEW_Z( depth, cameraNearFar.x, cameraNearFar.y );\n					float depthTest = (-vPosition.z > viewZ) ? 1.0 : 0.0;\n					gl_FragColor = vec4(0.0, depthTest, 1.0, 1.0);\n\n				}"
+		});
+	}
+	_getEdgeDetectionMaterial() {
+		return new D({
+			uniforms: {
+				maskTexture: { value: null },
+				texSize: { value: new k(.5, .5) },
+				visibleEdgeColor: { value: new A(1, 1, 1) },
+				hiddenEdgeColor: { value: new A(1, 1, 1) }
+			},
+			vertexShader: "varying vec2 vUv;\n\n				void main() {\n					vUv = uv;\n					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n				}",
+			fragmentShader: "varying vec2 vUv;\n\n				uniform sampler2D maskTexture;\n				uniform vec2 texSize;\n				uniform vec3 visibleEdgeColor;\n				uniform vec3 hiddenEdgeColor;\n\n				void main() {\n					vec2 invSize = 1.0 / texSize;\n					vec4 uvOffset = vec4(1.0, 0.0, 0.0, 1.0) * vec4(invSize, invSize);\n					vec4 c1 = texture2D( maskTexture, vUv + uvOffset.xy);\n					vec4 c2 = texture2D( maskTexture, vUv - uvOffset.xy);\n					vec4 c3 = texture2D( maskTexture, vUv + uvOffset.yw);\n					vec4 c4 = texture2D( maskTexture, vUv - uvOffset.yw);\n					float diff1 = (c1.r - c2.r)*0.5;\n					float diff2 = (c3.r - c4.r)*0.5;\n					float d = length( vec2(diff1, diff2) );\n					float a1 = min(c1.g, c2.g);\n					float a2 = min(c3.g, c4.g);\n					float visibilityFactor = min(a1, a2);\n					vec3 edgeColor = 1.0 - visibilityFactor > 0.001 ? visibleEdgeColor : hiddenEdgeColor;\n					gl_FragColor = vec4(edgeColor, 1.0) * vec4(d);\n				}"
+		});
+	}
+	_getSeparableBlurMaterial(e) {
+		return new D({
+			defines: { MAX_RADIUS: e },
+			uniforms: {
+				colorTexture: { value: null },
+				texSize: { value: new k(.5, .5) },
+				direction: { value: new k(.5, .5) },
+				kernelRadius: { value: 1 }
+			},
+			vertexShader: "varying vec2 vUv;\n\n				void main() {\n					vUv = uv;\n					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n				}",
+			fragmentShader: "#include <common>\n				varying vec2 vUv;\n				uniform sampler2D colorTexture;\n				uniform vec2 texSize;\n				uniform vec2 direction;\n				uniform float kernelRadius;\n\n				float gaussianPdf(in float x, in float sigma) {\n					return 0.39894 * exp( -0.5 * x * x/( sigma * sigma))/sigma;\n				}\n\n				void main() {\n					vec2 invSize = 1.0 / texSize;\n					float sigma = kernelRadius/2.0;\n					float weightSum = gaussianPdf(0.0, sigma);\n					vec4 diffuseSum = texture2D( colorTexture, vUv) * weightSum;\n					vec2 delta = direction * invSize * kernelRadius/float(MAX_RADIUS);\n					vec2 uvOffset = delta;\n					for( int i = 1; i <= MAX_RADIUS; i ++ ) {\n						float x = kernelRadius * float(i) / float(MAX_RADIUS);\n						float w = gaussianPdf(x, sigma);\n						vec4 sample1 = texture2D( colorTexture, vUv + uvOffset);\n						vec4 sample2 = texture2D( colorTexture, vUv - uvOffset);\n						diffuseSum += ((sample1 + sample2) * w);\n						weightSum += (2.0 * w);\n						uvOffset += delta;\n					}\n					gl_FragColor = diffuseSum/weightSum;\n				}"
+		});
+	}
+	_getOverlayMaterial() {
+		return new D({
+			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;\n\n				void main() {\n					vUv = uv;\n					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n				}",
+			fragmentShader: "varying vec2 vUv;\n\n				uniform sampler2D maskTexture;\n				uniform sampler2D edgeTexture1;\n				uniform sampler2D edgeTexture2;\n				uniform sampler2D patternTexture;\n				uniform float edgeStrength;\n				uniform float edgeGlow;\n				uniform bool usePatternTexture;\n\n				void main() {\n					vec4 edgeValue1 = texture2D(edgeTexture1, vUv);\n					vec4 edgeValue2 = texture2D(edgeTexture2, vUv);\n					vec4 maskColor = texture2D(maskTexture, vUv);\n					vec4 patternColor = texture2D(patternTexture, 6.0 * vUv);\n					float visibilityFactor = 1.0 - maskColor.g > 0.0 ? 1.0 : 0.5;\n					vec4 edgeValue = edgeValue1 + edgeValue2 * edgeGlow;\n					vec4 finalColor = edgeStrength * maskColor.r * edgeValue;\n					if(usePatternTexture)\n						finalColor += + visibilityFactor * (1.0 - maskColor.r) * (1.0 - patternColor.r);\n					gl_FragColor = finalColor;\n				}",
+			blending: s,
+			depthTest: !1,
+			depthWrite: !1,
+			transparent: !0
+		});
+	}
+};
+Re.BlurDirectionX = new k(1, 0), Re.BlurDirectionY = new k(0, 1);
+// src/Editor/demoScene.ts
+var Q = "main";
+function $(e, t, n, r) {
+	return {
+		id: e,
+		type: t,
+		transform: {
+			position: n,
+			rotation: [
+				0,
+				0,
+				0
+			],
+			scale: [
+				1,
+				1,
+				1
+			]
+		},
+		...r ? { props: r } : {}
+	};
+}
+function ze() {
+	let e = 5 * .707, t = (e, t, n) => $(e, N(t), n, { castShadow: !0 });
+	return {
+		version: oe,
+		name: Q,
+		settings: {},
+		objects: [
+			$("ambient_light", M("AmbientLight"), [
+				0,
+				5,
+				0
+			]),
+			$("sun", M("DirectionalLightShadow"), [
+				10,
+				15,
+				5
+			], {
+				intensity: 5,
+				castShadow: !0
+			}),
+			$("ground", N("Plane"), [
+				0,
+				0,
+				0
+			], {
+				width: 50,
+				height: 50,
+				color: "#ffbe6f",
+				receiveShadow: !0
+			}),
+			t("box", "Box", [
+				5,
+				.5,
+				0
+			]),
+			t("sphere", "Sphere", [
+				e,
+				1,
+				e
+			]),
+			t("cone", "Cone", [
+				0,
+				.5,
+				5
+			]),
+			t("cylinder", "Cylinder", [
+				-3.5349999999999997,
+				.5,
+				e
+			]),
+			t("octahedron", "Octahedron", [
+				-5,
+				1,
+				0
+			]),
+			t("dodecahedron", "Dodecahedron", [
+				-3.5349999999999997,
+				1,
+				-3.5349999999999997
+			]),
+			t("capsule", "Capsule", [
+				0,
+				1,
+				-5
+			]),
+			t("icosahedron", "Icosahedron", [
+				e,
+				1,
+				-3.5349999999999997
+			]),
+			t("torus_knot", "TorusKnot", [
+				0,
+				3.5,
+				0
+			])
+		]
+	};
+}
+// src/Editor.ts
+var Be = class s extends o {
+	static registerPanel(e) {
+		return n(e);
+	}
+	static registerListener() {
+		i.instance().input.on("keydown", (e) => {
+			(e.code === "Insert" || e.code === "Period") && (i.instance().editor = new s());
+		});
+	}
+	constructor() {
+		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.abort = new AbortController(), this.activeAssetCategory = "Object", i.instance().editor = this, i.instance().logger?.info("Booting Editor"), i.instance().trigger("editorBoot", this), i.instance().trigger("uiDestroy", this);
+		let e = i.instance().activeScene;
+		e ? e.rebuild() : this.clearGame(), this.initEditorScene(), e || this.openDefaultScene(), i.instance().contextMenuAbort.abort(), i.instance().uiRoot.innerHTML = "", i.instance().uiRoot.style.opacity = "1", document.title = "MavonEngine | Editor", document.getElementsByTagName("body")[0].removeAttribute("onContextMenu"), Promise.all([import("./mount-CnirMLg0.mjs"), import("./global-l94NfB94.mjs").then((e) => e.t)]).then(([{ mountEditorUI: e }]) => {
+			this.reactRoot = e(i.instance().uiRoot);
+		});
+	}
+	initEditorScene() {
+		i.instance().camera.instance.position.set(20, 10, 20), i.instance().camera.instance.rotation.set(0, 0, 0), i.instance().camera.instance.rotateY(Math.PI / 360 * 90), i.instance().camera.instance.rotateX(Math.PI / 360 * -45), this.outlinePass = new Re(new k(i.instance().sizes.width, i.instance().sizes.height), i.instance().scene, i.instance().camera.instance), i.instance().renderer.composer.addPass(this.outlinePass), this.initFlyControls(), this.watchScene(i.instance().activeScene), i.instance().on("sceneLoaded", (e) => {
+			this.deselect(), this.watchScene(e), this.trigger("sceneChanged");
+		}), window.addEventListener("keydown", (e) => {
+			(e.ctrlKey || e.metaKey) && e.code === "KeyS" && (e.preventDefault(), this.saveScene());
+		}, { signal: this.abort.signal }), this.trigger("sceneChanged"), i.instance().input.on("mousedown", (e) => {
+			e.target === i.instance().canvas && this.handleCanvasClick(e);
+		}), i.instance().input.on("keydown", (e) => {
+			e.code === "Escape" && this.activeItem && this.deselect();
+		}), this.handleItemDelete(), this.on("setTransformMode", (e) => {
+			this.activeToolMode = e, this.transformControls?.setMode(e), i.instance().logger?.info(`Setting editor tool mode: ${e}`);
+		}), this.on("setShadeMode", (e) => {
+			this.applyShadeMode(e);
+		}), this.on("assetDropped", () => {
+			this.shadeMode !== "solid" && this.applyShadeMode(this.shadeMode);
+		}), this.initAssetsFilter();
+	}
+	initAssetsFilter() {
+		this.availableAssetCategories = [...new Set(Object.entries(i.instance().resources.items).map(([e, t]) => t.constructor.name))];
+	}
+	setActiveAssetCategory(e) {
+		this.activeAssetCategory = e;
+	}
+	applyShadeMode(e) {
+		this.shadeMode = e, t(i.instance().scene, e, this.originalMaterials, this.shadeOverrideMaterials, this.flatColors);
+	}
+	initFlyControls() {
+		this.flyControls = new le(i.instance().camera.instance, i.instance().canvas), this.flyControls.autoForward = !1, this.flyControls.dragToLook = !0, this.flyControls.movementSpeed = 10, this.flyControls.rollSpeed = .5;
+	}
+	handleItemDelete() {
+		i.instance().input.on("keydown", (e) => {
+			if (e.code === "Delete" && this.activeItem) {
+				let e = this.activeItem;
+				for (; e.parent && e.parent !== i.instance().scene;) e = e.parent;
+				e.traverse((e) => {
+					e instanceof y && (e.geometry?.dispose(), Array.isArray(e.material) ? e.material.forEach((e) => e.dispose()) : e.material?.dispose());
+				}), this.deselect();
+				let t = r.from(e), n = i.instance().activeScene, a = n?.entryOfObject3D(e) ?? (t?.owner && n?.getEntries().find((e) => e.object === t.owner));
+				n && a ? n.remove(a.data.id) : t?.owner ? t.owner.destroy() : (t && (t.dispose(), this.helpers = this.helpers.filter((e) => e !== t)), i.instance().scene.remove(e)), this.trigger("sceneChanged");
+			}
+		});
+	}
+	deselect() {
+		this.transformControls?.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;
+			let e = i.instance().input.getPointerWorldPosition(void 0, null, !0);
+			e instanceof S ? this.selectObject(e) : this.deselect();
+		}
+	}
+	handleHelperTool() {
+		if (!this.transformControls) {
+			this.transformControls = new xe(i.instance().camera.instance, i.instance().canvas), this.transformControls.addEventListener("dragging-changed", (e) => {
+				this.flyControls.enabled = !e.value, e.value || this.initFlyControls();
+			});
+			let e = this.transformControls.getHelper();
+			e.userData.isEditorInternal = !0, i.instance().scene.add(e);
+		}
+		this.transformControls.setMode(this.activeToolMode), this.transformControls.attach(this.activeItem);
+	}
+	addPanel(e) {
+		return n(e);
+	}
+	removePanel(t) {
+		e(t);
+	}
+	saveScene(e = fetch) {
+		let t = i.instance().activeScene;
+		if (!t) return i.instance().logger?.warn("No scene to save"), Promise.resolve(!1);
+		if (this.saving) return this.saving;
+		let n = t.source ?? "main", r = t.serialize();
+		this.trigger("sceneSaving", { name: n });
+		let o = (e) => (i.instance().logger?.error(`Could not save scene ${n}: ${e}`), this.trigger("sceneSaveFailed", {
+			name: n,
+			error: e
+		}), !1);
+		return this.saving = e(a, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				name: n,
+				scene: r
+			})
+		}).then(async (e) => {
+			let a = await e.json().catch(() => ({}));
+			return e.ok ? (t.source = n, t.markSaved(r), i.instance().logger?.info(`Saved scene ${n} to ${a.file ?? n}`), this.trigger("sceneSaved", {
+				name: n,
+				file: a.file
+			}), !0) : o(a.error ?? `${e.status} ${e.statusText}`);
+		}, (e) => o(e.message)).finally(() => {
+			this.saving = void 0;
+		}), this.saving;
+	}
+	async openDefaultScene() {
+		try {
+			await i.instance().openScene(Q);
+		} catch {
+			i.instance().logger?.info(`No scenes/${Q}.json yet, opening a demo scene. Save it with Ctrl+S`), i.instance().loadScene(ze(), Q);
+		}
+	}
+	watchScene(e) {
+		e?.on("changed", () => this.trigger("sceneChanged"));
+	}
+	clearGame() {
+		i.instance().world.destroy(), i.instance().world.entities.items.clear(), i.instance().scene.traverse((e) => {
+			e instanceof y && (e.geometry?.dispose(), Array.isArray(e.material) ? e.material.forEach((e) => e.dispose()) : e.material?.dispose());
+		}), i.instance().scene.clear();
+	}
+	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);
+		let t = i.instance().camera.instance, n = new A();
+		t.getWorldDirection(n), t.quaternion.setFromRotationMatrix(new v().lookAt(new A(), n, new A(0, 1, 0)));
+	}
+	destroy() {
+		this.abort.abort(), this.reactRoot.unmount(), this.outlinePass.dispose(), this.shadeOverrideMaterials.forEach((e) => e.dispose()), this.shadeOverrideMaterials.clear(), this.originalMaterials.clear(), this.flatColors.clear();
+	}
+};
+export { Be as default, n as registerEditorPanel, e as unregisterEditorPanel };