@mavonengine/editor 0.0.8 → 0.0.10

package/dist/Editor.mjs

@@ -1,10 +1,1816 @@
-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, c as t, l as n, r } from "./panels-DFsnKBKK.mjs";
+import i from "@mavonengine/core/Editor/EditorHelper";
+import a from "@mavonengine/core/Game";
+import { SCENE_SAVE_PATH as o } from "@mavonengine/core/Plugins/types";
+import s from "@mavonengine/core/Utils/EventEmitter";
+import { AdditiveBlending as c, BoxGeometry as l, BufferGeometry as u, Color as d, Controls as f, CylinderGeometry as p, DoubleSide as m, EdgesGeometry as h, Euler as g, Float32BufferAttribute as _, Group as v, HalfFloatType as y, Line as b, LineBasicMaterial as ee, LineLoop as x, LineSegments as S, Matrix4 as C, Mesh as w, MeshBasicMaterial as te, MeshDepthMaterial as ne, NoBlending as T, Object3D as E, OctahedronGeometry as D, OrthographicCamera as re, PlaneGeometry as ie, Quaternion as O, RGBADepthPacking as ae, Raycaster as oe, ShaderMaterial as k, SphereGeometry as se, TorusGeometry as A, UniformsUtils as ce, Vector2 as j, Vector3 as M, WebGLRenderTarget as N } from "three";
+import { lightType as le, primitiveType as ue } from "@mavonengine/core/Scene/builtinSceneObjects";
+import { SCENE_FORMAT_VERSION as de } from "@mavonengine/core/Scene/types";
+// ../../node_modules/three/examples/jsm/controls/FlyControls.js
+var fe = { type: "change" }, pe = 1e-6, me = new O(), he = class extends f {
+	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 M(0, 0, 0), this._rotationVector = new M(0, 0, 0), this._lastQuaternion = new O(), this._lastPosition = new M(), this._status = 0, this._onKeyDown = ge.bind(this), this._onKeyUp = _e.bind(this), this._onPointerMove = ye.bind(this), this._onPointerDown = ve.bind(this), this._onPointerUp = be.bind(this), this._onPointerCancel = xe.bind(this), this._onContextMenu = Se.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), me.set(this._rotationVector.x * r, this._rotationVector.y * r, this._rotationVector.z * r, 1).normalize(), t.quaternion.multiply(me), (this._lastPosition.distanceToSquared(t.position) > pe || 8 * (1 - this._lastQuaternion.dot(t.quaternion)) > pe) && (this.dispatchEvent(fe), 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 ge(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 _e(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 ve(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 ye(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 be(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 xe() {
+	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 Se(e) {
+	this.enabled !== !1 && e.preventDefault();
+}
+// ../../node_modules/three/examples/jsm/controls/TransformControls.js
+var P = new oe(), F = new M(), I = new M(), L = new O(), Ce = {
+	X: new M(1, 0, 0),
+	Y: new M(0, 1, 0),
+	Z: new M(0, 0, 1)
+}, R = { type: "change" }, we = {
+	type: "mouseDown",
+	mode: null
+}, Te = {
+	type: "mouseUp",
+	mode: null
+}, Ee = { type: "objectChange" }, De = class extends f {
+	constructor(e, t = null) {
+		super(void 0, t);
+		let n = new Ie(this);
+		this._root = n;
+		let r = new Le();
+		this._gizmo = r, n.add(r);
+		let i = new Re();
+		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(R));
+				}
+			}), 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 M(), c = new M(), l = new O(), u = new O(), d = new M(), f = new O(), p = new M(), m = new M(), h = new M(), g = new M();
+		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 M(), this._startNorm = new M(), this._endNorm = new M(), this._cameraScale = new M(), this._parentPosition = new M(), this._parentQuaternion = new O(), this._parentQuaternionInv = new O(), this._parentScale = new M(), this._worldScaleStart = new M(), this._worldQuaternionInv = new O(), this._worldScale = new M(), this._positionStart = new M(), this._quaternionStart = new O(), this._scaleStart = new M(), this._getPointer = Oe.bind(this), this._onPointerDown = Ae.bind(this), this._onPointerHover = ke.bind(this), this._onPointerMove = je.bind(this), this._onPointerUp = Me.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 && P.setFromCamera(e, this.camera);
+		let t = z(this._gizmo.picker[this.mode], P);
+		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 && P.setFromCamera(e, this.camera);
+			let t = z(this._plane, P, !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, we.mode = this.mode, this.dispatchEvent(we);
+		}
+	}
+	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 && P.setFromCamera(e, this.camera);
+		let a = z(this._plane, P, !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(L.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(F.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(F.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), I.set(e, e, e);
+				} else F.copy(this.pointStart), I.copy(this.pointEnd), F.applyQuaternion(this._worldQuaternionInv), I.applyQuaternion(this._worldQuaternionInv), I.divide(F), t.search("X") === -1 && (I.x = 1), t.search("Y") === -1 && (I.y = 1), t.search("Z") === -1 && (I.z = 1);
+				r.scale.copy(this._scaleStart).multiply(I), 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(F.setFromMatrixPosition(this.camera.matrixWorld)), n = !1;
+				t === "XYZE" ? (this.rotationAxis.copy(this._offset).cross(this.eye).normalize(), this.rotationAngle = this._offset.dot(F.copy(this.rotationAxis).cross(this.eye)) * e) : (t === "X" || t === "Y" || t === "Z") && (this.rotationAxis.copy(Ce[t]), F.copy(Ce[t]), i === "local" && F.applyQuaternion(this.worldQuaternion), F.cross(this.eye), F.length() === 0 ? n = !0 : this.rotationAngle = this._offset.dot(F.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(L.setFromAxisAngle(this.rotationAxis, this.rotationAngle)).normalize()) : (this.rotationAxis.applyQuaternion(this._parentQuaternionInv), r.quaternion.copy(L.setFromAxisAngle(this.rotationAxis, this.rotationAngle)), r.quaternion.multiply(this._quaternionStart).normalize());
+			}
+			this.dispatchEvent(R), this.dispatchEvent(Ee);
+		}
+	}
+	pointerUp(e) {
+		(e === null || e.button === 0) && (this.dragging && this.axis !== null && (Te.mode = this.mode, this.dispatchEvent(Te)), 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(R), this.dispatchEvent(Ee), this.pointStart.copy(this.pointEnd));
+	}
+	getRaycaster() {
+		return P;
+	}
+	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 Oe(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 ke(e) {
+	if (this.enabled) switch (e.pointerType) {
+		case "mouse":
+		case "pen": this.pointerHover(this._getPointer(e));
+	}
+}
+function Ae(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 je(e) {
+	this.enabled && this.pointerMove(this._getPointer(e));
+}
+function Me(e) {
+	this.enabled && (this.domElement.releasePointerCapture(e.pointerId), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.pointerUp(this._getPointer(e)));
+}
+function z(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 B = new g(), V = new M(0, 1, 0), Ne = new M(0, 0, 0), Pe = new C(), H = new O(), U = new O(), W = new M(), Fe = new C(), G = new M(1, 0, 0), K = new M(0, 1, 0), q = new M(0, 0, 1), J = new M(), Y = new M(), X = new M(), Ie = class extends E {
+	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();
+		});
+	}
+}, Le = class extends E {
+	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 c = e.clone();
+		c.color.setHex(65280), c.opacity = .5;
+		let d = e.clone();
+		d.color.setHex(255), d.opacity = .5;
+		let f = e.clone();
+		f.opacity = .25;
+		let m = e.clone();
+		m.color.setHex(16776960), m.opacity = .25;
+		let h = e.clone();
+		h.color.setHex(16776960);
+		let g = e.clone();
+		g.color.setHex(7895160), this.materialLib = {
+			xAxis: i,
+			yAxis: a,
+			zAxis: o,
+			active: h,
+			xAxisTransparent: s,
+			yAxisTransparent: c,
+			zAxisTransparent: d,
+			activeTransparent: m
+		};
+		let v = new p(0, .04, .1, 12);
+		v.translate(0, .05, 0);
+		let y = new l(.08, .08, .08);
+		y.translate(0, .04, 0);
+		let x = new u();
+		x.setAttribute("position", new _([
+			0,
+			0,
+			0,
+			1,
+			0,
+			0
+		], 3));
+		let S = new p(.0075, .0075, .5, 3);
+		S.translate(0, .25, 0);
+		function C(e, t) {
+			let n = new A(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 u();
+			return e.setAttribute("position", new _([
+				0,
+				0,
+				0,
+				1,
+				1,
+				1
+			], 3)), e;
+		}
+		let T = {
+			X: [
+				[
+					new w(v, i),
+					[
+						.5,
+						0,
+						0
+					],
+					[
+						0,
+						0,
+						-Math.PI / 2
+					]
+				],
+				[
+					new w(v, i),
+					[
+						-.5,
+						0,
+						0
+					],
+					[
+						0,
+						0,
+						Math.PI / 2
+					]
+				],
+				[
+					new w(S, i),
+					[
+						0,
+						0,
+						0
+					],
+					[
+						0,
+						0,
+						-Math.PI / 2
+					]
+				]
+			],
+			Y: [
+				[new w(v, a), [
+					0,
+					.5,
+					0
+				]],
+				[
+					new w(v, a),
+					[
+						0,
+						-.5,
+						0
+					],
+					[
+						Math.PI,
+						0,
+						0
+					]
+				],
+				[new w(S, a)]
+			],
+			Z: [
+				[
+					new w(v, o),
+					[
+						0,
+						0,
+						.5
+					],
+					[
+						Math.PI / 2,
+						0,
+						0
+					]
+				],
+				[
+					new w(v, o),
+					[
+						0,
+						0,
+						-.5
+					],
+					[
+						-Math.PI / 2,
+						0,
+						0
+					]
+				],
+				[
+					new w(S, o),
+					null,
+					[
+						Math.PI / 2,
+						0,
+						0
+					]
+				]
+			],
+			XYZ: [[new w(new D(.1, 0), f), [
+				0,
+				0,
+				0
+			]]],
+			XY: [[new w(new l(.15, .15, .01), d), [
+				.15,
+				.15,
+				0
+			]]],
+			YZ: [[
+				new w(new l(.15, .15, .01), s),
+				[
+					0,
+					.15,
+					.15
+				],
+				[
+					0,
+					Math.PI / 2,
+					0
+				]
+			]],
+			XZ: [[
+				new w(new l(.15, .15, .01), c),
+				[
+					.15,
+					0,
+					.15
+				],
+				[
+					-Math.PI / 2,
+					0,
+					0
+				]
+			]]
+		}, re = {
+			X: [[
+				new w(new p(.2, 0, .6, 4), n),
+				[
+					.3,
+					0,
+					0
+				],
+				[
+					0,
+					0,
+					-Math.PI / 2
+				]
+			], [
+				new w(new p(.2, 0, .6, 4), n),
+				[
+					-.3,
+					0,
+					0
+				],
+				[
+					0,
+					0,
+					Math.PI / 2
+				]
+			]],
+			Y: [[new w(new p(.2, 0, .6, 4), n), [
+				0,
+				.3,
+				0
+			]], [
+				new w(new p(.2, 0, .6, 4), n),
+				[
+					0,
+					-.3,
+					0
+				],
+				[
+					0,
+					0,
+					Math.PI
+				]
+			]],
+			Z: [[
+				new w(new p(.2, 0, .6, 4), n),
+				[
+					0,
+					0,
+					.3
+				],
+				[
+					Math.PI / 2,
+					0,
+					0
+				]
+			], [
+				new w(new p(.2, 0, .6, 4), n),
+				[
+					0,
+					0,
+					-.3
+				],
+				[
+					-Math.PI / 2,
+					0,
+					0
+				]
+			]],
+			XYZ: [[new w(new D(.2, 0), n)]],
+			XY: [[new w(new l(.2, .2, .01), n), [
+				.15,
+				.15,
+				0
+			]]],
+			YZ: [[
+				new w(new l(.2, .2, .01), n),
+				[
+					0,
+					.15,
+					.15
+				],
+				[
+					0,
+					Math.PI / 2,
+					0
+				]
+			]],
+			XZ: [[
+				new w(new l(.2, .2, .01), n),
+				[
+					.15,
+					0,
+					.15
+				],
+				[
+					-Math.PI / 2,
+					0,
+					0
+				]
+			]]
+		}, ie = {
+			START: [[
+				new w(new D(.01, 2), r),
+				null,
+				null,
+				null,
+				"helper"
+			]],
+			END: [[
+				new w(new D(.01, 2), r),
+				null,
+				null,
+				null,
+				"helper"
+			]],
+			DELTA: [[
+				new b(ne(), r),
+				null,
+				null,
+				null,
+				"helper"
+			]],
+			X: [[
+				new b(x, r),
+				[
+					-1e3,
+					0,
+					0
+				],
+				null,
+				[
+					1e6,
+					1,
+					1
+				],
+				"helper"
+			]],
+			Y: [[
+				new b(x, r),
+				[
+					0,
+					-1e3,
+					0
+				],
+				[
+					0,
+					0,
+					Math.PI / 2
+				],
+				[
+					1e6,
+					1,
+					1
+				],
+				"helper"
+			]],
+			Z: [[
+				new b(x, r),
+				[
+					0,
+					0,
+					-1e3
+				],
+				[
+					0,
+					-Math.PI / 2,
+					0
+				],
+				[
+					1e6,
+					1,
+					1
+				],
+				"helper"
+			]]
+		}, O = {
+			XYZE: [[
+				new w(C(.5, 1), g),
+				null,
+				[
+					0,
+					Math.PI / 2,
+					0
+				]
+			]],
+			X: [[new w(C(.5, .5), i)]],
+			Y: [[
+				new w(C(.5, .5), a),
+				null,
+				[
+					0,
+					0,
+					-Math.PI / 2
+				]
+			]],
+			Z: [[
+				new w(C(.5, .5), o),
+				null,
+				[
+					0,
+					Math.PI / 2,
+					0
+				]
+			]],
+			E: [[
+				new w(C(.75, 1), m),
+				null,
+				[
+					0,
+					Math.PI / 2,
+					0
+				]
+			]]
+		}, ae = { AXIS: [[
+			new b(x, r),
+			[
+				-1e3,
+				0,
+				0
+			],
+			null,
+			[
+				1e6,
+				1,
+				1
+			],
+			"helper"
+		]] }, oe = {
+			XYZE: [[new w(new se(.25, 10, 8), n)]],
+			X: [[
+				new w(new A(.5, .1, 4, 24), n),
+				[
+					0,
+					0,
+					0
+				],
+				[
+					0,
+					-Math.PI / 2,
+					-Math.PI / 2
+				]
+			]],
+			Y: [[
+				new w(new A(.5, .1, 4, 24), n),
+				[
+					0,
+					0,
+					0
+				],
+				[
+					Math.PI / 2,
+					0,
+					0
+				]
+			]],
+			Z: [[
+				new w(new A(.5, .1, 4, 24), n),
+				[
+					0,
+					0,
+					0
+				],
+				[
+					0,
+					0,
+					-Math.PI / 2
+				]
+			]],
+			E: [[new w(new A(.75, .1, 2, 24), n)]]
+		}, k = {
+			X: [
+				[
+					new w(y, i),
+					[
+						.5,
+						0,
+						0
+					],
+					[
+						0,
+						0,
+						-Math.PI / 2
+					]
+				],
+				[
+					new w(S, i),
+					[
+						0,
+						0,
+						0
+					],
+					[
+						0,
+						0,
+						-Math.PI / 2
+					]
+				],
+				[
+					new w(y, i),
+					[
+						-.5,
+						0,
+						0
+					],
+					[
+						0,
+						0,
+						Math.PI / 2
+					]
+				]
+			],
+			Y: [
+				[new w(y, a), [
+					0,
+					.5,
+					0
+				]],
+				[new w(S, a)],
+				[
+					new w(y, a),
+					[
+						0,
+						-.5,
+						0
+					],
+					[
+						0,
+						0,
+						Math.PI
+					]
+				]
+			],
+			Z: [
+				[
+					new w(y, o),
+					[
+						0,
+						0,
+						.5
+					],
+					[
+						Math.PI / 2,
+						0,
+						0
+					]
+				],
+				[
+					new w(S, o),
+					[
+						0,
+						0,
+						0
+					],
+					[
+						Math.PI / 2,
+						0,
+						0
+					]
+				],
+				[
+					new w(y, o),
+					[
+						0,
+						0,
+						-.5
+					],
+					[
+						-Math.PI / 2,
+						0,
+						0
+					]
+				]
+			],
+			XY: [[new w(new l(.15, .15, .01), d), [
+				.15,
+				.15,
+				0
+			]]],
+			YZ: [[
+				new w(new l(.15, .15, .01), s),
+				[
+					0,
+					.15,
+					.15
+				],
+				[
+					0,
+					Math.PI / 2,
+					0
+				]
+			]],
+			XZ: [[
+				new w(new l(.15, .15, .01), c),
+				[
+					.15,
+					0,
+					.15
+				],
+				[
+					-Math.PI / 2,
+					0,
+					0
+				]
+			]],
+			XYZ: [[new w(new l(.1, .1, .1), f)]]
+		}, ce = {
+			X: [[
+				new w(new p(.2, 0, .6, 4), n),
+				[
+					.3,
+					0,
+					0
+				],
+				[
+					0,
+					0,
+					-Math.PI / 2
+				]
+			], [
+				new w(new p(.2, 0, .6, 4), n),
+				[
+					-.3,
+					0,
+					0
+				],
+				[
+					0,
+					0,
+					Math.PI / 2
+				]
+			]],
+			Y: [[new w(new p(.2, 0, .6, 4), n), [
+				0,
+				.3,
+				0
+			]], [
+				new w(new p(.2, 0, .6, 4), n),
+				[
+					0,
+					-.3,
+					0
+				],
+				[
+					0,
+					0,
+					Math.PI
+				]
+			]],
+			Z: [[
+				new w(new p(.2, 0, .6, 4), n),
+				[
+					0,
+					0,
+					.3
+				],
+				[
+					Math.PI / 2,
+					0,
+					0
+				]
+			], [
+				new w(new p(.2, 0, .6, 4), n),
+				[
+					0,
+					0,
+					-.3
+				],
+				[
+					-Math.PI / 2,
+					0,
+					0
+				]
+			]],
+			XY: [[new w(new l(.2, .2, .01), n), [
+				.15,
+				.15,
+				0
+			]]],
+			YZ: [[
+				new w(new l(.2, .2, .01), n),
+				[
+					0,
+					.15,
+					.15
+				],
+				[
+					0,
+					Math.PI / 2,
+					0
+				]
+			]],
+			XZ: [[
+				new w(new l(.2, .2, .01), n),
+				[
+					.15,
+					0,
+					.15
+				],
+				[
+					-Math.PI / 2,
+					0,
+					0
+				]
+			]],
+			XYZ: [[new w(new l(.2, .2, .2), n), [
+				0,
+				0,
+				0
+			]]]
+		}, j = {
+			X: [[
+				new b(x, r),
+				[
+					-1e3,
+					0,
+					0
+				],
+				null,
+				[
+					1e6,
+					1,
+					1
+				],
+				"helper"
+			]],
+			Y: [[
+				new b(x, r),
+				[
+					0,
+					-1e3,
+					0
+				],
+				[
+					0,
+					0,
+					Math.PI / 2
+				],
+				[
+					1e6,
+					1,
+					1
+				],
+				"helper"
+			]],
+			Z: [[
+				new b(x, r),
+				[
+					0,
+					0,
+					-1e3
+				],
+				[
+					0,
+					-Math.PI / 2,
+					0
+				],
+				[
+					1e6,
+					1,
+					1
+				],
+				"helper"
+			]]
+		};
+		function M(e) {
+			let t = new E();
+			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 = M(T)), this.add(this.gizmo.rotate = M(O)), this.add(this.gizmo.scale = M(k)), this.add(this.picker.translate = M(re)), this.add(this.picker.rotate = M(oe)), this.add(this.picker.scale = M(ce)), this.add(this.helper.translate = M(ie)), this.add(this.helper.rotate = M(ae)), this.add(this.helper.scale = M(j)), 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 : U;
+		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" && (L.setFromEuler(B.set(0, 0, 0)), r.quaternion.copy(t).multiply(L), Math.abs(V.copy(G).applyQuaternion(t).dot(this.eye)) > .9 && (r.visible = !1)), this.axis === "Y" && (L.setFromEuler(B.set(0, 0, Math.PI / 2)), r.quaternion.copy(t).multiply(L), Math.abs(V.copy(K).applyQuaternion(t).dot(this.eye)) > .9 && (r.visible = !1)), this.axis === "Z" && (L.setFromEuler(B.set(0, Math.PI / 2, 0)), r.quaternion.copy(t).multiply(L), Math.abs(V.copy(q).applyQuaternion(t).dot(this.eye)) > .9 && (r.visible = !1)), this.axis === "XYZE" && (L.setFromEuler(B.set(0, Math.PI / 2, 0)), V.copy(this.rotationAxis), r.quaternion.setFromRotationMatrix(Pe.lookAt(Ne, V, K)), r.quaternion.multiply(L), 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), F.set(1e-10, 1e-10, 1e-10).add(this.worldPositionStart).sub(this.worldPosition).multiplyScalar(-1), F.applyQuaternion(this.worldQuaternionStart.clone().invert()), r.scale.copy(F), 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(V.copy(G).applyQuaternion(t).dot(this.eye)) > e && (r.scale.set(1e-10, 1e-10, 1e-10), r.visible = !1), r.name === "Y" && Math.abs(V.copy(K).applyQuaternion(t).dot(this.eye)) > e && (r.scale.set(1e-10, 1e-10, 1e-10), r.visible = !1), r.name === "Z" && Math.abs(V.copy(q).applyQuaternion(t).dot(this.eye)) > e && (r.scale.set(1e-10, 1e-10, 1e-10), r.visible = !1), r.name === "XY" && Math.abs(V.copy(q).applyQuaternion(t).dot(this.eye)) < n && (r.scale.set(1e-10, 1e-10, 1e-10), r.visible = !1), r.name === "YZ" && Math.abs(V.copy(G).applyQuaternion(t).dot(this.eye)) < n && (r.scale.set(1e-10, 1e-10, 1e-10), r.visible = !1), r.name === "XZ" && Math.abs(V.copy(K).applyQuaternion(t).dot(this.eye)) < n && (r.scale.set(1e-10, 1e-10, 1e-10), r.visible = !1);
+				} else this.mode === "rotate" && (H.copy(t), V.copy(this.eye).applyQuaternion(L.copy(t).invert()), r.name.search("E") !== -1 && r.quaternion.setFromRotationMatrix(Pe.lookAt(this.eye, Ne, K)), r.name === "X" && (L.setFromAxisAngle(G, Math.atan2(-V.y, V.z)), L.multiplyQuaternions(H, L), r.quaternion.copy(L)), r.name === "Y" && (L.setFromAxisAngle(K, Math.atan2(V.x, V.z)), L.multiplyQuaternions(H, L), r.quaternion.copy(L)), r.name === "Z" && (L.setFromAxisAngle(q, Math.atan2(V.y, V.x)), L.multiplyQuaternions(H, L), r.quaternion.copy(L)));
+				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);
+	}
+}, Re = class extends w {
+	constructor() {
+		super(new ie(1e5, 1e5, 2, 2), new te({
+			visible: !1,
+			wireframe: !0,
+			side: m,
+			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"), J.copy(G).applyQuaternion(t === "local" ? this.worldQuaternion : U), Y.copy(K).applyQuaternion(t === "local" ? this.worldQuaternion : U), X.copy(q).applyQuaternion(t === "local" ? this.worldQuaternion : U), V.copy(Y), this.mode) {
+			case "translate":
+			case "scale":
+				switch (this.axis) {
+					case "X":
+						V.copy(this.eye).cross(J), W.copy(J).cross(V);
+						break;
+					case "Y":
+						V.copy(this.eye).cross(Y), W.copy(Y).cross(V);
+						break;
+					case "Z":
+						V.copy(this.eye).cross(X), W.copy(X).cross(V);
+						break;
+					case "XY":
+						W.copy(X);
+						break;
+					case "YZ":
+						W.copy(J);
+						break;
+					case "XZ":
+						V.copy(X), W.copy(Y);
+						break;
+					case "XYZ":
+					case "E": W.set(0, 0, 0);
+				}
+				break;
+			default: W.set(0, 0, 0);
+		}
+		W.length() === 0 ? this.quaternion.copy(this.cameraQuaternion) : (Fe.lookAt(F.set(0, 0, 0), W, V), this.quaternion.setFromRotationMatrix(Fe)), super.updateMatrixWorld(e);
+	}
+}, ze = 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() {}
+}, Be = new re(-1, 1, 1, -1, 0, 1), Ve = new class extends u {
+	constructor() {
+		super(), this.setAttribute("position", new _([
+			-1,
+			3,
+			0,
+			-1,
+			-1,
+			0,
+			3,
+			-1,
+			0
+		], 3)), this.setAttribute("uv", new _([
+			0,
+			2,
+			0,
+			0,
+			2,
+			0
+		], 2));
+	}
+}(), He = class {
+	constructor(e) {
+		this._mesh = new w(Ve, e);
+	}
+	dispose() {
+		this._mesh.geometry.dispose();
+	}
+	render(e) {
+		e.render(this._mesh, Be);
+	}
+	get material() {
+		return this._mesh.material;
+	}
+	set material(e) {
+		this._mesh.material = e;
+	}
+}, Ue = {
+	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		}"
+}, We = class e extends ze {
+	constructor(e, t, n, r) {
+		super(), this.renderScene = t, this.renderCamera = n, this.selectedObjects = r === void 0 ? [] : r, this.visibleEdgeColor = new d(1, 1, 1), this.hiddenEdgeColor = new d(.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 j(256, 256) : new j(e.x, e.y);
+		let i = Math.round(this.resolution.x / this.downSampleRatio), a = Math.round(this.resolution.y / this.downSampleRatio);
+		this.renderTargetMaskBuffer = new N(this.resolution.x, this.resolution.y), this.renderTargetMaskBuffer.texture.name = "OutlinePass.mask", this.renderTargetMaskBuffer.texture.generateMipmaps = !1, this.depthMaterial = new ne(), this.depthMaterial.side = m, this.depthMaterial.depthPacking = ae, this.depthMaterial.blending = T, this.prepareMaskMaterial = this._getPrepareMaskMaterial(), this.prepareMaskMaterial.side = m, this.prepareMaskMaterial.fragmentShader = s(this.prepareMaskMaterial.fragmentShader, this.renderCamera), this.renderTargetDepthBuffer = new N(this.resolution.x, this.resolution.y, { type: y }), this.renderTargetDepthBuffer.texture.name = "OutlinePass.depth", this.renderTargetDepthBuffer.texture.generateMipmaps = !1, this.renderTargetMaskDownSampleBuffer = new N(i, a, { type: y }), this.renderTargetMaskDownSampleBuffer.texture.name = "OutlinePass.depthDownSample", this.renderTargetMaskDownSampleBuffer.texture.generateMipmaps = !1, this.renderTargetBlurBuffer1 = new N(i, a, { type: y }), this.renderTargetBlurBuffer1.texture.name = "OutlinePass.blur1", this.renderTargetBlurBuffer1.texture.generateMipmaps = !1, this.renderTargetBlurBuffer2 = new N(Math.round(i / 2), Math.round(a / 2), { type: y }), this.renderTargetBlurBuffer2.texture.name = "OutlinePass.blur2", this.renderTargetBlurBuffer2.texture.generateMipmaps = !1, this.edgeDetectionMaterial = this._getEdgeDetectionMaterial(), this.renderTargetEdgeBuffer1 = new N(i, a, { type: y }), this.renderTargetEdgeBuffer1.texture.name = "OutlinePass.edge1", this.renderTargetEdgeBuffer1.texture.generateMipmaps = !1, this.renderTargetEdgeBuffer2 = new N(Math.round(i / 2), Math.round(a / 2), { type: y }), 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 = Ue;
+		this.copyUniforms = ce.clone(o.uniforms), this.materialCopy = new k({
+			uniforms: this.copyUniforms,
+			vertexShader: o.vertexShader,
+			fragmentShader: o.fragmentShader,
+			blending: T,
+			depthTest: !1,
+			depthWrite: !1
+		}), this.enabled = !0, this.needsSwap = !1, this._oldClearColor = new d(), this.oldClearAlpha = 1, this._fsQuad = new He(null), this.tempPulseColor1 = new d(), this.tempPulseColor2 = new d(), this.textureMatrix = new C();
+		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 k({
+			uniforms: {
+				depthTexture: { value: null },
+				cameraNearFar: { value: new j(.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 k({
+			uniforms: {
+				maskTexture: { value: null },
+				texSize: { value: new j(.5, .5) },
+				visibleEdgeColor: { value: new M(1, 1, 1) },
+				hiddenEdgeColor: { value: new M(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 k({
+			defines: { MAX_RADIUS: e },
+			uniforms: {
+				colorTexture: { value: null },
+				texSize: { value: new j(.5, .5) },
+				direction: { value: new j(.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 k({
+			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: c,
+			depthTest: !1,
+			depthWrite: !1,
+			transparent: !0
+		});
+	}
+};
+We.BlurDirectionX = new j(1, 0), We.BlurDirectionY = new j(0, 1);
+// src/Editor/demoScene.ts
+var Z = "main";
+function Q(e, t, n, r) {
+	return {
+		id: e,
+		type: t,
+		transform: {
+			position: n,
+			rotation: [
+				0,
+				0,
+				0
+			],
+			scale: [
+				1,
+				1,
+				1
+			]
+		},
+		...r ? { props: r } : {}
+	};
+}
+function Ge() {
+	let e = 5 * .707, t = (e, t, n) => Q(e, ue(t), n, { castShadow: !0 });
+	return {
+		version: de,
+		name: Z,
+		settings: {},
+		objects: [
+			Q("ambient_light", le("AmbientLight"), [
+				0,
+				5,
+				0
+			]),
+			Q("sun", le("DirectionalLightShadow"), [
+				10,
+				15,
+				5
+			], {
+				intensity: 5,
+				castShadow: !0
+			}),
+			Q("ground", ue("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/Network/SyncStore.ts
+var Ke = class {
+	constructor(e = 250, n = t) {
+		this.intervalMs = e, this.load = n, this.state = {}, this.listeners = /* @__PURE__ */ new Set(), this.loading = !1, this.get = () => this.state, this.subscribe = (e) => (this.listeners.add(e), this.timer || (this.timer = setInterval(() => void this.refresh(), this.intervalMs), this.refresh()), () => {
+			this.listeners.delete(e), !this.listeners.size && this.timer && (clearInterval(this.timer), this.timer = void 0);
+		});
+	}
+	async refresh() {
+		if (!this.loading) {
+			this.loading = !0;
+			try {
+				this.state = { sync: await this.load() };
+			} catch (e) {
+				let t = e.message;
+				if (this.state.error === t && !this.state.sync) return;
+				this.state = { error: t };
+			} finally {
+				this.loading = !1;
+			}
+			this.listeners.forEach((e) => e());
+		}
+	}
+}, qe = {
+	synced: 5163440,
+	stale: 13537656,
+	untracked: 8947848
+}, Je = 31436, Ye = 16777215, Xe = 16009031, Ze = 96, Qe = 2e3, $e = .01, et = "editor-network-overlay";
+function tt(e, t, n, r) {
+	if (n) {
+		let t = r ? n.players.find((e) => e.id === r) : void 0;
+		if (t) return t.id === e.id || t.tracked.includes(e.id) ? "synced" : "untracked";
+		let i = n.entities.find((t) => t.id === e.id);
+		if (i && !i.player && i.trackedBy === 0 && n.players.length > 0) return "untracked";
+	}
+	return t !== null && t - e.tick > 1 ? "stale" : "synced";
+}
+function nt() {
+	let e = {
+		ghosts: !1,
+		rings: !1,
+		viewAs: null
+	};
+	try {
+		return {
+			...e,
+			...JSON.parse(localStorage.getItem(et) ?? "{}"),
+			viewAs: null
+		};
+	} catch {
+		return e;
+	}
+}
+var rt = class extends s {
+	constructor(e = new Ke(), t = nt()) {
+		super(), this.group = new v(), this.ghosts = /* @__PURE__ */ new Map(), this.rings = /* @__PURE__ */ new Map(), this.errorMaterial = $(Xe), this.ringMaterial = $(Je), this.ringSelectedMaterial = $(Ye), this.sync = e, this._options = t, this.group.name = "NetworkOverlay", this.group.userData.isEditorInternal = !0;
+		let n = new l(1, 1, 1);
+		n.translate(0, .5, 0), this.boxGeometry = new h(n), n.dispose();
+		let r = [];
+		for (let e = 0; e < Ze; e++) {
+			let t = e / Ze * Math.PI * 2;
+			r.push(Math.cos(t), 0, Math.sin(t));
+		}
+		this.ringGeometry = new u().setAttribute("position", new _(r, 3)), this.materials = {
+			synced: $(qe.synced),
+			stale: $(qe.stale),
+			untracked: $(qe.untracked)
+		}, this.applyOptions();
+	}
+	get options() {
+		return this._options;
+	}
+	setOptions(e) {
+		this._options = {
+			...this._options,
+			...e
+		};
+		try {
+			localStorage.setItem(et, JSON.stringify({
+				ghosts: this._options.ghosts,
+				rings: this._options.rings
+			}));
+		} catch {}
+		this.applyOptions(), this.trigger("changed", this._options);
+	}
+	get active() {
+		return this._options.ghosts || this._options.rings;
+	}
+	applyOptions() {
+		let e = a.instance().scene;
+		this.active && !this.group.parent ? (e.add(this.group), this.unsubscribe = this.sync.subscribe(() => {})) : !this.active && this.group.parent && (e.remove(this.group), this.unsubscribe?.(), this.unsubscribe = void 0);
+	}
+	update() {
+		this.active && (this.group.parent || a.instance().scene.add(this.group), this.updateGhosts(), this.updateRings());
+	}
+	updateGhosts() {
+		let e = a.instance().network, t = this._options.ghosts ? e?.serverView : void 0, { sync: n } = this.sync.get(), r = a.instance().world.entities.items, i = performance.now(), o = /* @__PURE__ */ new Set();
+		for (let e of t?.entities.values() ?? []) {
+			let a = r.get(e.id);
+			if (!a && i - e.receivedAt > Qe) continue;
+			o.add(e.id);
+			let s = this.ghosts.get(e.id) ?? this.createGhost(e.id);
+			s.box.position.set(e.position.x, e.position.y, e.position.z), s.box.rotation.set(e.rotation.x, e.rotation.y, e.rotation.z), s.box.scale.set(e.scale.x, e.scale.y * 2, e.scale.z), s.box.material = this.materials[tt(e, t.tick, n, this._options.viewAs)];
+			let c = a ? a.position.distanceTo(s.box.position) : 0;
+			if (s.error.visible = c > $e, s.error.visible) {
+				let t = s.error.geometry.getAttribute("position");
+				t.setXYZ(0, e.position.x, e.position.y, e.position.z), t.setXYZ(1, a.position.x, a.position.y, a.position.z), t.needsUpdate = !0;
+			}
+		}
+		for (let [e, t] of this.ghosts) o.has(e) || (this.group.remove(t.box, t.error), t.error.geometry.dispose(), this.ghosts.delete(e));
+	}
+	createGhost(e) {
+		let t = it(new S(this.boxGeometry, this.materials.synced));
+		t.name = `ServerGhost:${e}`;
+		let n = new u().setAttribute("position", new _([
+			0,
+			0,
+			0,
+			0,
+			0,
+			0
+		], 3)), r = it(new b(n, this.errorMaterial));
+		r.frustumCulled = !1, r.visible = !1;
+		let i = {
+			box: t,
+			error: r
+		};
+		return this.group.add(t, r), this.ghosts.set(e, i), i;
+	}
+	updateRings() {
+		let { sync: e } = this.sync.get(), t = this._options.rings && e?.syncDistance ? e.players : [], n = /* @__PURE__ */ new Set();
+		for (let r of t) {
+			n.add(r.id);
+			let t = this.rings.get(r.id);
+			t || (t = it(new x(this.ringGeometry, this.ringMaterial)), t.name = `SyncRing:${r.id}`, this.rings.set(r.id, t), this.group.add(t)), t.position.set(r.position.x, r.position.y + .05, r.position.z), t.scale.setScalar(e.syncDistance), t.material = r.id === this._options.viewAs ? this.ringSelectedMaterial : this.ringMaterial;
+		}
+		for (let [e, t] of this.rings) n.has(e) || (this.group.remove(t), this.rings.delete(e));
+	}
+	get counts() {
+		return {
+			ghosts: this.ghosts.size,
+			rings: this.rings.size
+		};
+	}
+	dispose() {
+		this.unsubscribe?.(), this.unsubscribe = void 0, this.group.removeFromParent(), this.ghosts.forEach((e) => e.error.geometry.dispose()), this.ghosts.clear(), this.rings.clear(), this.boxGeometry.dispose(), this.ringGeometry.dispose(), Object.values(this.materials).forEach((e) => e.dispose()), this.errorMaterial.dispose(), this.ringMaterial.dispose(), this.ringSelectedMaterial.dispose();
+	}
+};
+function $(e) {
+	return new ee({
+		color: e,
+		depthTest: !1,
+		depthWrite: !1,
+		transparent: !0,
+		toneMapped: !1
+	});
+}
+function it(e) {
+	return e.raycast = () => {}, e.renderOrder = 999, e.userData.isEditorInternal = !0, e;
+}
+// src/Editor.ts
+var at = class t extends s {
+	static registerPanel(e) {
+		return r(e);
+	}
+	static registerListener() {
+		a.instance().input.on("keydown", (e) => {
+			(e.code === "Insert" || e.code === "Period") && (a.instance().editor = new t());
+		});
+	}
+	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", a.instance().editor = this, a.instance().logger?.info("Booting Editor"), a.instance().trigger("editorBoot", this), a.instance().trigger("uiDestroy", this);
+		let e = a.instance().activeScene;
+		e ? e.rebuild() : this.clearGame(), this.initEditorScene(), e || this.openDefaultScene(), a.instance().contextMenuAbort.abort(), a.instance().uiRoot.innerHTML = "", a.instance().uiRoot.style.opacity = "1", document.title = "MavonEngine | Editor", document.getElementsByTagName("body")[0].removeAttribute("onContextMenu"), Promise.all([import("./mount-BfaV9yI_.mjs"), import("./global-l94NfB94.mjs").then((e) => e.t)]).then(([{ mountEditorUI: e }]) => {
+			this.reactRoot = e(a.instance().uiRoot);
+		}).catch((e) => {
+			a.instance().logger?.error(`The editor's UI could not be loaded: ${e?.stack ?? e}`);
+		});
+	}
+	initEditorScene() {
+		a.instance().camera.instance.position.set(20, 10, 20), a.instance().camera.instance.rotation.set(0, 0, 0), a.instance().camera.instance.rotateY(Math.PI / 360 * 90), a.instance().camera.instance.rotateX(Math.PI / 360 * -45), this.outlinePass = new We(new j(a.instance().sizes.width, a.instance().sizes.height), a.instance().scene, a.instance().camera.instance), a.instance().renderer.composer.addPass(this.outlinePass), this.initFlyControls(), this.networkOverlay = new rt(), this.watchScene(a.instance().activeScene), a.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"), a.instance().input.on("mousedown", (e) => {
+			e.target === a.instance().canvas && this.handleCanvasClick(e);
+		}), a.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), a.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(a.instance().resources.items).map(([e, t]) => t.constructor.name))];
+	}
+	setActiveAssetCategory(e) {
+		this.activeAssetCategory = e;
+	}
+	applyShadeMode(e) {
+		this.shadeMode = e, n(a.instance().scene, e, this.originalMaterials, this.shadeOverrideMaterials, this.flatColors);
+	}
+	initFlyControls() {
+		this.flyControls = new he(a.instance().camera.instance, a.instance().canvas), this.flyControls.autoForward = !1, this.flyControls.dragToLook = !0, this.flyControls.movementSpeed = 10, this.flyControls.rollSpeed = .5;
+	}
+	handleItemDelete() {
+		a.instance().input.on("keydown", (e) => {
+			if (e.code === "Delete" && this.activeItem) {
+				let e = this.activeItem;
+				for (; e.parent && e.parent !== a.instance().scene;) e = e.parent;
+				e.traverse((e) => {
+					e instanceof w && (e.geometry?.dispose(), Array.isArray(e.material) ? e.material.forEach((e) => e.dispose()) : e.material?.dispose());
+				}), this.deselect();
+				let t = i.from(e), n = a.instance().activeScene, r = n?.entryOfObject3D(e) ?? (t?.owner && n?.getEntries().find((e) => e.object === t.owner));
+				n && r ? n.remove(r.data.id) : t?.owner ? t.owner.destroy() : (t && (t.dispose(), this.helpers = this.helpers.filter((e) => e !== t)), a.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 = a.instance().input.getPointerWorldPosition(void 0, null, !0);
+			e instanceof E ? this.selectObject(e) : this.deselect();
+		}
+	}
+	handleHelperTool() {
+		if (!this.transformControls) {
+			this.transformControls = new De(a.instance().camera.instance, a.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, a.instance().scene.add(e);
+		}
+		this.transformControls.setMode(this.activeToolMode), this.transformControls.attach(this.activeItem);
+	}
+	addPanel(e) {
+		return r(e);
+	}
+	removePanel(t) {
+		e(t);
+	}
+	saveScene(e = fetch) {
+		let t = a.instance().activeScene;
+		if (!t) return a.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 i = (e) => (a.instance().logger?.error(`Could not save scene ${n}: ${e}`), this.trigger("sceneSaveFailed", {
+			name: n,
+			error: e
+		}), !1);
+		return this.saving = e(o, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				name: n,
+				scene: r
+			})
+		}).then(async (e) => {
+			let o = await e.json().catch(() => ({}));
+			return e.ok ? (t.source = n, t.markSaved(r), a.instance().logger?.info(`Saved scene ${n} to ${o.file ?? n}`), this.trigger("sceneSaved", {
+				name: n,
+				file: o.file
+			}), !0) : i(o.error ?? `${e.status} ${e.statusText}`);
+		}, (e) => i(e.message)).finally(() => {
+			this.saving = void 0;
+		}), this.saving;
+	}
+	async openDefaultScene() {
+		try {
+			await a.instance().openScene(Z);
+		} catch {
+			a.instance().logger?.info(`No scenes/${Z}.json yet, opening a demo scene. Save it with Ctrl+S`), a.instance().loadScene(Ge(), Z);
+		}
+	}
+	watchScene(e) {
+		e?.on("changed", () => this.trigger("sceneChanged"));
+	}
+	clearGame() {
+		a.instance().world.destroy(), a.instance().world.entities.items.clear(), a.instance().scene.traverse((e) => {
+			e instanceof w && (e.geometry?.dispose(), Array.isArray(e.material) ? e.material.forEach((e) => e.dispose()) : e.material?.dispose());
+		}), a.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)), this.networkOverlay.update();
+	}
+	updateCamera(e) {
+		this.flyControls.update(e);
+		let t = a.instance().camera.instance, n = new M();
+		t.getWorldDirection(n), t.quaternion.setFromRotationMatrix(new C().lookAt(new M(), n, new M(0, 1, 0)));
+	}
+	destroy() {
+		this.abort.abort(), this.reactRoot.unmount(), this.outlinePass.dispose(), this.networkOverlay.dispose(), this.shadeOverrideMaterials.forEach((e) => e.dispose()), this.shadeOverrideMaterials.clear(), this.originalMaterials.clear(), this.flatColors.clear();
+	}
+};
+export { at as default, r as registerEditorPanel, e as unregisterEditorPanel };