minerender 2.1.0-alpha.114 → 2.1.0-alpha.115

package/dist/browser/index.mjs

@@ -13104,6 +13104,321 @@ init_ModelObject();
 // src/index.ts
 init_nbt();
 
+// src/renderer/FlyControls.ts
+import { Controls, Euler as Euler11, MathUtils as MathUtils2, Quaternion as Quaternion6, Vector3 as Vector313 } from "three";
+var VANILLA_FLY_SPEED = 10.89;
+var PITCH_LIMIT = Math.PI / 2;
+var MOVE_EPSILON = 1e-6;
+var _euler = new Euler11(0, 0, 0, "YXZ");
+var _forward = new Vector313();
+var _right = new Vector313();
+var _targetVelocity = new Vector313();
+var FlyControls = class extends Controls {
+  constructor(camera, domElement) {
+    super(camera, domElement ?? null);
+    this.isFlyControls = true;
+    /** Horizontal and vertical speed in scene units per second; vanilla creative flight by default. */
+    this.movementSpeed = 16 * VANILLA_FLY_SPEED;
+    /** Speed multiplier while the sprint key is held. */
+    this.sprintMultiplier = 2;
+    /** Radians per pixel of pointer movement. */
+    this.lookSpeed = 2e-3;
+    /** Smooth acceleration and deceleration, approximating vanilla flight momentum. */
+    this.enableDamping = true;
+    /** Portion of the remaining velocity change applied per 60 Hz frame (0–1) when damping is enabled. */
+    this.dampingFactor = 0.25;
+    /** Capture the pointer on click so the mouse turns the camera without dragging; dragging works regardless. */
+    this.pointerLock = true;
+    /** Scroll the wheel to change `movementSpeed` within `speedRange`. */
+    this.enableWheelSpeed = true;
+    /** Minimum and maximum `movementSpeed` reachable with the wheel. */
+    this.speedRange = [16, 16 * 500];
+    /** Touch joystick travel in CSS pixels for full speed. */
+    this.joystickRadius = 64;
+    /** Key bindings by `KeyboardEvent.code`. */
+    this.keys = {
+      forward: ["KeyW", "ArrowUp"],
+      back: ["KeyS", "ArrowDown"],
+      left: ["KeyA", "ArrowLeft"],
+      right: ["KeyD", "ArrowRight"],
+      up: ["Space"],
+      down: ["ShiftLeft", "ShiftRight"],
+      sprint: ["ControlLeft", "ControlRight"]
+    };
+    this._pressed = /* @__PURE__ */ new Set();
+    this._velocity = new Vector313();
+    this._lastPosition = new Vector313();
+    this._lastQuaternion = new Quaternion6();
+    this._position0 = new Vector313();
+    this._quaternion0 = new Quaternion6();
+    this._dragMoved = false;
+    this._locked = false;
+    this._onKeyDown = (event) => this.handleKey(event, true);
+    this._onKeyUp = (event) => this.handleKey(event, false);
+    this._onPointerDown = (event) => this.handlePointerDown(event);
+    this._onPointerMove = (event) => this.handlePointerMove(event);
+    this._onPointerUp = (event) => this.handlePointerUp(event);
+    this._onPointerLockChange = () => this.handlePointerLockChange();
+    this._onContextMenu = (event) => event.preventDefault();
+    this._onWheel = (event) => this.handleWheel(event);
+    this._onBlur = () => this.releaseKeys();
+    this._lastPosition.copy(camera.position);
+    this._lastQuaternion.copy(camera.quaternion);
+    this.saveState();
+    if (domElement) this.connect(domElement);
+  }
+  connect(element) {
+    super.connect(element);
+    const document2 = element.ownerDocument;
+    document2.addEventListener("keydown", this._onKeyDown);
+    document2.addEventListener("keyup", this._onKeyUp);
+    document2.addEventListener("pointerlockchange", this._onPointerLockChange);
+    document2.defaultView?.addEventListener("blur", this._onBlur);
+    element.addEventListener("pointerdown", this._onPointerDown);
+    element.addEventListener("pointermove", this._onPointerMove);
+    element.addEventListener("pointerup", this._onPointerUp);
+    element.addEventListener("pointercancel", this._onPointerUp);
+    element.addEventListener("contextmenu", this._onContextMenu);
+    element.addEventListener("wheel", this._onWheel, { passive: false });
+    element.addEventListener("blur", this._onBlur);
+    element.style.touchAction = "none";
+    if (element.tabIndex < 0) element.tabIndex = 0;
+  }
+  disconnect() {
+    const element = this.domElement;
+    if (!element) return;
+    const document2 = element.ownerDocument;
+    document2.removeEventListener("keydown", this._onKeyDown);
+    document2.removeEventListener("keyup", this._onKeyUp);
+    document2.removeEventListener("pointerlockchange", this._onPointerLockChange);
+    document2.defaultView?.removeEventListener("blur", this._onBlur);
+    element.removeEventListener("pointerdown", this._onPointerDown);
+    element.removeEventListener("pointermove", this._onPointerMove);
+    element.removeEventListener("pointerup", this._onPointerUp);
+    element.removeEventListener("pointercancel", this._onPointerUp);
+    element.removeEventListener("contextmenu", this._onContextMenu);
+    element.removeEventListener("wheel", this._onWheel);
+    element.removeEventListener("blur", this._onBlur);
+    element.style.touchAction = "auto";
+    this.unlock();
+    this._locked = false;
+    this.releaseKeys();
+    this._dragPointer = void 0;
+    this._joystick = void 0;
+  }
+  dispose() {
+    this.disconnect();
+  }
+  /** Whether mouse look currently owns the pointer. */
+  get locked() {
+    return this._locked;
+  }
+  /** Requests pointer capture; browsers only allow this from a user gesture. */
+  lock() {
+    const element = this.domElement;
+    if (!element || this._locked || typeof element.requestPointerLock !== "function") return;
+    try {
+      const result = element.requestPointerLock();
+      if (result instanceof Promise) result.catch(() => void 0);
+    } catch {
+    }
+  }
+  /** Releases a captured pointer. */
+  unlock() {
+    const document2 = this.domElement?.ownerDocument;
+    if (document2?.pointerLockElement && document2.pointerLockElement === this.domElement) {
+      document2.exitPointerLock();
+    }
+  }
+  /** Stores the camera pose that {@link reset} restores. */
+  saveState() {
+    this._position0.copy(this.object.position);
+    this._quaternion0.copy(this.object.quaternion);
+  }
+  /** Restores the saved camera pose and stops movement. */
+  reset() {
+    this.object.position.copy(this._position0);
+    this.object.quaternion.copy(this._quaternion0);
+    this._velocity.set(0, 0, 0);
+    this.notifyChange();
+  }
+  /** Horizontal yaw in radians, where zero looks toward -Z. */
+  get yaw() {
+    return _euler.setFromQuaternion(this.object.quaternion).y;
+  }
+  /** Vertical pitch in radians, positive looking up. */
+  get pitch() {
+    return _euler.setFromQuaternion(this.object.quaternion).x;
+  }
+  /** Turns the camera; pitch is clamped to straight up and down. */
+  setRotation(yaw, pitch) {
+    _euler.set(MathUtils2.clamp(pitch, -PITCH_LIMIT, PITCH_LIMIT), yaw, 0);
+    this.object.quaternion.setFromEuler(_euler);
+    this.notifyChange();
+  }
+  /** Points the camera at a position without rolling it. */
+  lookAt(target) {
+    _forward.copy(target).sub(this.object.position);
+    if (_forward.lengthSq() < MOVE_EPSILON) return;
+    _forward.normalize();
+    this.setRotation(Math.atan2(-_forward.x, -_forward.z), Math.asin(MathUtils2.clamp(_forward.y, -1, 1)));
+  }
+  /** Whether an action's key is held. */
+  isPressed(action) {
+    return this._pressed.has(action);
+  }
+  /**
+   * Advances movement by `delta` seconds (measured since the previous call when omitted)
+   * and dispatches `change` when the camera moved.
+   */
+  update(delta) {
+    if (delta === void 0) {
+      const now = typeof performance !== "undefined" ? performance.now() : Date.now();
+      delta = this._lastTime === void 0 ? 0 : (now - this._lastTime) / 1e3;
+      this._lastTime = now;
+    }
+    if (!this.enabled) {
+      this._velocity.set(0, 0, 0);
+      return;
+    }
+    if (delta > 0) this.move(delta);
+    this.notifyChange();
+  }
+  move(delta) {
+    const camera = this.object;
+    let forward = (this._pressed.has("forward") ? 1 : 0) - (this._pressed.has("back") ? 1 : 0);
+    let strafe = (this._pressed.has("right") ? 1 : 0) - (this._pressed.has("left") ? 1 : 0);
+    const climb = (this._pressed.has("up") ? 1 : 0) - (this._pressed.has("down") ? 1 : 0);
+    const joystick = this._joystick;
+    if (joystick) {
+      const radius = Math.max(this.joystickRadius, 1);
+      forward = MathUtils2.clamp(forward + (joystick.originY - joystick.y) / radius, -1, 1);
+      strafe = MathUtils2.clamp(strafe + (joystick.x - joystick.originX) / radius, -1, 1);
+    }
+    _euler.setFromQuaternion(camera.quaternion);
+    const yaw = _euler.y;
+    _forward.set(-Math.sin(yaw), 0, -Math.cos(yaw));
+    _right.set(Math.cos(yaw), 0, -Math.sin(yaw));
+    _targetVelocity.set(0, 0, 0);
+    if (forward || strafe || climb) {
+      _targetVelocity.addScaledVector(_forward, forward).addScaledVector(_right, strafe);
+      if (_targetVelocity.lengthSq() > 1) _targetVelocity.normalize();
+      _targetVelocity.y = climb;
+      const speed = this.movementSpeed * (this._pressed.has("sprint") ? this.sprintMultiplier : 1);
+      _targetVelocity.multiplyScalar(speed);
+    }
+    if (this.enableDamping) {
+      const blend = 1 - Math.pow(1 - MathUtils2.clamp(this.dampingFactor, 0, 1), delta * 60);
+      this._velocity.lerp(_targetVelocity, blend);
+      if (_targetVelocity.lengthSq() === 0 && this._velocity.lengthSq() < MOVE_EPSILON) this._velocity.set(0, 0, 0);
+    } else {
+      this._velocity.copy(_targetVelocity);
+    }
+    camera.position.addScaledVector(this._velocity, delta);
+  }
+  notifyChange() {
+    const camera = this.object;
+    if (this._lastPosition.distanceToSquared(camera.position) > MOVE_EPSILON || 8 * (1 - this._lastQuaternion.dot(camera.quaternion)) > MOVE_EPSILON) {
+      this._lastPosition.copy(camera.position);
+      this._lastQuaternion.copy(camera.quaternion);
+      this.dispatchEvent({ type: "change" });
+    }
+  }
+  releaseKeys() {
+    this._pressed.clear();
+  }
+  handleKey(event, down) {
+    const action = this.actionFor(event.code);
+    if (!action) return;
+    const ownsInput = this.enabled && (this._locked || event.target === this.domElement);
+    if (down && !ownsInput) return;
+    const pressed = this._pressed.has(action);
+    if (down) this._pressed.add(action);
+    else this._pressed.delete(action);
+    if (ownsInput || this.enabled && pressed) event.preventDefault();
+  }
+  actionFor(code) {
+    for (const action in this.keys) {
+      if (this.keys[action].includes(code)) return action;
+    }
+    return void 0;
+  }
+  handlePointerDown(event) {
+    const element = this.domElement;
+    if (!this.enabled || !element) return;
+    element.focus?.({ preventScroll: true });
+    if (this._locked) return;
+    if (event.pointerType === "touch" && !this._joystick && this.onJoystickSide(event)) {
+      this._joystick = { id: event.pointerId, originX: event.clientX, originY: event.clientY, x: event.clientX, y: event.clientY };
+      element.setPointerCapture?.(event.pointerId);
+      return;
+    }
+    if (this._dragPointer !== void 0) return;
+    if (event.pointerType === "mouse" && event.button !== 0 && event.button !== 2) return;
+    this._dragPointer = event.pointerId;
+    this._dragMoved = false;
+    element.setPointerCapture?.(event.pointerId);
+  }
+  onJoystickSide(event) {
+    const rect = this.domElement?.getBoundingClientRect?.();
+    return !!rect && event.clientX < rect.left + rect.width / 2;
+  }
+  handlePointerMove(event) {
+    if (!this.enabled) return;
+    const joystick = this._joystick;
+    if (joystick && event.pointerId === joystick.id) {
+      joystick.x = event.clientX;
+      joystick.y = event.clientY;
+      return;
+    }
+    if (!this._locked && event.pointerId !== this._dragPointer) return;
+    const dx = event.movementX ?? 0;
+    const dy = event.movementY ?? 0;
+    if (!dx && !dy) return;
+    this._dragMoved = true;
+    this.turn(dx, dy);
+  }
+  handlePointerUp(event) {
+    if (this._joystick?.id === event.pointerId) {
+      this._joystick = void 0;
+      this.domElement?.releasePointerCapture?.(event.pointerId);
+      return;
+    }
+    if (event.pointerId !== this._dragPointer) return;
+    this._dragPointer = void 0;
+    this.domElement?.releasePointerCapture?.(event.pointerId);
+    if (this.enabled && this.pointerLock && !this._dragMoved && event.pointerType === "mouse" && event.button === 0) {
+      this.lock();
+    }
+  }
+  handleWheel(event) {
+    if (!this.enabled || !this.enableWheelSpeed) return;
+    event.preventDefault();
+    const steps = event.deltaMode === 0 ? event.deltaY / 100 : event.deltaY;
+    const [min, max] = this.speedRange;
+    this.movementSpeed = MathUtils2.clamp(this.movementSpeed * Math.pow(1.15, -steps), Math.min(min, max), Math.max(min, max));
+  }
+  handlePointerLockChange() {
+    const document2 = this.domElement?.ownerDocument;
+    const locked = !!document2 && document2.pointerLockElement === this.domElement;
+    if (locked === this._locked) return;
+    this._locked = locked;
+    if (!locked) this.releaseKeys();
+    this.dispatchEvent({ type: locked ? "lock" : "unlock" });
+  }
+  turn(dx, dy) {
+    _euler.setFromQuaternion(this.object.quaternion);
+    _euler.y -= dx * this.lookSpeed;
+    _euler.x = MathUtils2.clamp(_euler.x - dy * this.lookSpeed, -PITCH_LIMIT, PITCH_LIMIT);
+    _euler.z = 0;
+    this.object.quaternion.setFromEuler(_euler);
+    this.notifyChange();
+  }
+};
+function isFlyControls(obj) {
+  return obj?.isFlyControls === true;
+}
+
 // src/renderer/MineRenderScene.ts
 init_SceneObject();
 var import_ts_deepmerge8 = __toESM(require_dist());
@@ -14170,7 +14485,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFShadowMap, PerspectiveCamera, SRGBColorSpace as SRGBColorSpace7, Vector3 as Vector314, WebGLRenderer } from "three";
+import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFShadowMap, PerspectiveCamera, SRGBColorSpace as SRGBColorSpace7, Vector3 as Vector315, WebGLRenderer } from "three";
 var import_ts_deepmerge9 = __toESM(require_dist());
 init_util();
 init_Model();
@@ -14182,11 +14497,11 @@ import { EffectComposer, RenderPass } from "postprocessing";
 import {
   EventDispatcher,
   MOUSE,
-  Quaternion as Quaternion6,
+  Quaternion as Quaternion7,
   Spherical,
   TOUCH,
   Vector2 as Vector26,
-  Vector3 as Vector313
+  Vector3 as Vector314
 } from "three";
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
@@ -14200,7 +14515,7 @@ var OrbitControls = class extends EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new Vector313();
+    this.target = new Vector314();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -14252,11 +14567,11 @@ var OrbitControls = class extends EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new Vector313();
-      const quat = new Quaternion6().setFromUnitVectors(object4.up, new Vector313(0, 1, 0));
+      const offset = new Vector314();
+      const quat = new Quaternion7().setFromUnitVectors(object4.up, new Vector314(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new Vector313();
-      const lastQuaternion = new Quaternion6();
+      const lastPosition = new Vector314();
+      const lastQuaternion = new Quaternion7();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -14345,7 +14660,7 @@ var OrbitControls = class extends EventDispatcher {
     const spherical = new Spherical();
     const sphericalDelta = new Spherical();
     let scale = 1;
-    const panOffset = new Vector313();
+    const panOffset = new Vector314();
     let zoomChanged = false;
     const rotateStart = new Vector26();
     const rotateEnd = new Vector26();
@@ -14371,7 +14686,7 @@ var OrbitControls = class extends EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new Vector313();
+      const v = new Vector314();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -14379,7 +14694,7 @@ var OrbitControls = class extends EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new Vector313();
+      const v = new Vector314();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -14392,7 +14707,7 @@ var OrbitControls = class extends EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new Vector313();
+      const offset = new Vector314();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -14947,20 +15262,77 @@ var _Renderer = class _Renderer {
   }
   createControls() {
     if (!this.options.controls?.enabled) return void 0;
-    const position = this.camera.position.clone();
-    const controls = new OrbitControls(this.camera, this.renderer.domElement);
-    this.camera.position.copy(position);
+    return this.createControlsFor(this.options.controls.mode ?? "orbit", this.initialTarget());
+  }
+  initialTarget() {
     const target = this.options.camera.lookingAt;
-    if (isVector3(target)) {
+    if (isVector3(target)) return target.clone();
+    if (isTripleArray(target)) return new Vector315(target[0], target[1], target[2]);
+    return new Vector315();
+  }
+  createControlsFor(mode, target) {
+    let controls;
+    if (mode === "fly") {
+      controls = new FlyControls(this.camera, this.renderer.domElement);
+      controls.lookAt(target);
+      controls.saveState();
+    } else {
+      const position = this.camera.position.clone();
+      controls = new OrbitControls(this.camera, this.renderer.domElement);
+      this.camera.position.copy(position);
       controls.target.copy(target);
-    } else if (isTripleArray(target)) {
-      controls.target.set(target[0], target[1], target[2]);
+      controls.update();
+      controls.saveState();
     }
-    controls.update();
-    controls.saveState();
+    this._controlsTime = void 0;
     this.registerEventDispatcher(controls);
     return controls;
   }
+  /**
+   * Replaces renderer-owned controls with the selected mode, keeping the camera where it is.
+   * Switching to orbit controls targets the point the camera looks at, at the previous orbit distance.
+   * Returns the new controls, or undefined when controls were disabled at construction or after disposal.
+   */
+  setControlsMode(mode) {
+    const current = this._controls;
+    if (this._disposed || !current) return void 0;
+    if (this.controlsMode === mode) return current;
+    let target;
+    if (isFlyControls(current)) {
+      const distance = this._orbitDistance ?? (this.camera.position.distanceTo(this.initialTarget()) || 1);
+      target = new Vector315(0, 0, -distance).applyQuaternion(this.camera.quaternion).add(this.camera.position);
+    } else {
+      target = current.target.clone();
+      this._orbitDistance = this.camera.position.distanceTo(target);
+    }
+    const enabled = current.enabled;
+    this.disposeControls(current);
+    this._controls = this.createControlsFor(mode, target);
+    this._controls.enabled = enabled;
+    this.dirty = true;
+    return this._controls;
+  }
+  disposeControls(controls) {
+    this._controls = void 0;
+    this.unregisterEventDispatcher(controls);
+    controls.enabled = false;
+    controls.dispose();
+  }
+  /** Advances owned controls; without a frame time, flight movement does not progress. */
+  updateControls(time) {
+    const controls = this._controls;
+    if (!controls?.enabled) {
+      this._controlsTime = void 0;
+      return;
+    }
+    if (!isFlyControls(controls)) {
+      controls.update();
+      return;
+    }
+    const previous = this._controlsTime;
+    if (time !== void 0) this._controlsTime = time;
+    controls.update(time === void 0 || previous === void 0 ? 0 : (time - previous) / 1e3);
+  }
   //</editor-fold>
   init() {
     if (this._disposed) return;
@@ -15037,6 +15409,12 @@ var _Renderer = class _Renderer {
     events.add(changeEvent2);
     dispatcher.addEventListener(changeEvent2, this._changeListener);
   }
+  unregisterEventDispatcher(dispatcher) {
+    const events = this._eventDispatchers.get(dispatcher);
+    if (!events) return;
+    for (const event of events) dispatcher.removeEventListener(event, this._changeListener);
+    this._eventDispatchers.delete(dispatcher);
+  }
   /** Updates the camera and canvas size. Width and height are in CSS pixels. */
   resize(width, height) {
     if (this._disposed) return;
@@ -15113,6 +15491,7 @@ var _Renderer = class _Renderer {
       this.renderer.setAnimationLoop(null);
     }
     this._nextFrameTime = void 0;
+    this._controlsTime = void 0;
     for (const subscription of this._frameCallbacks.values()) subscription.previous = void 0;
   }
   /**
@@ -15142,10 +15521,7 @@ var _Renderer = class _Renderer {
     }
     this._element = void 0;
     if (this._controls) {
-      const controls = this._controls;
-      this._controls = void 0;
-      controls.enabled = false;
-      controls.dispose();
+      this.disposeControls(this._controls);
     }
     this.scene.clear();
     for (const helper of this._debugHelpers) {
@@ -15162,9 +15538,7 @@ var _Renderer = class _Renderer {
   }
   animate(t = performance.now()) {
     if (!this._running) return;
-    if (this._controls?.enabled) {
-      this._controls.update();
-    }
+    this.updateControls(t);
     if (!this._running) return;
     if (!this.dirty && !this.options.render.renderAlways && !this._frameCallbacks.size && !this._videoExporter) return;
     const interval = this._frameInterval;
@@ -15201,7 +15575,7 @@ var _Renderer = class _Renderer {
   /** Draws a fresh frame without starting the animation loop or invoking frame callbacks. */
   renderOnce() {
     if (this._disposed) throw new Error("Cannot render a disposed renderer");
-    if (this._controls?.enabled) this._controls.update();
+    this.updateControls();
     this.drawFrame();
   }
   /**
@@ -15231,7 +15605,7 @@ var _Renderer = class _Renderer {
       try {
         if (!wasRunning) this.start();
         this._videoExporter = exporter;
-        if (this._controls?.enabled) this._controls.update();
+        this.updateControls();
         this.drawFrame();
       } catch (error) {
         exporter.cancel(error);
@@ -15282,6 +15656,19 @@ var _Renderer = class _Renderer {
   get controls() {
     return this._controls;
   }
+  /** Renderer-owned OrbitControls, or undefined in fly mode or without controls. */
+  get orbitControls() {
+    return this._controls && !isFlyControls(this._controls) ? this._controls : void 0;
+  }
+  /** Renderer-owned {@link FlyControls}, or undefined in orbit mode or without controls. */
+  get flyControls() {
+    return isFlyControls(this._controls) ? this._controls : void 0;
+  }
+  /** The active renderer-owned controls mode, or undefined without controls. */
+  get controlsMode() {
+    if (!this._controls) return void 0;
+    return isFlyControls(this._controls) ? "fly" : "orbit";
+  }
   ///
 };
 _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
@@ -15299,8 +15686,8 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
       top: void 0,
       bottom: void 0
     },
-    position: new Vector314(50, 50, 50),
-    lookingAt: new Vector314(0, 0, 0)
+    position: new Vector315(50, 50, 50),
+    lookingAt: new Vector315(0, 0, 0)
   },
   render: {
     fpsLimit: 60,
@@ -15315,7 +15702,8 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
     enabled: true
   },
   controls: {
-    enabled: false
+    enabled: false,
+    mode: "orbit"
   },
   debug: {
     grid: false,
@@ -16548,14 +16936,14 @@ var AnvilWorldSource = class {
 };
 
 // src/world/Chunk.ts
-import { Vector3 as Vector317 } from "three";
+import { Vector3 as Vector318 } from "three";
 init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
 init_Model();
 init_util();
-import { Vector3 as Vector316 } from "three";
+import { Vector3 as Vector317 } from "three";
 init_AssetKey();
 init_BlockStates();
 init_CubeFace();
@@ -16564,7 +16952,7 @@ init_CubeFace();
 init_AssetKey();
 init_Models();
 init_CubeFace();
-import { BufferAttribute as BufferAttribute7, BufferGeometry as BufferGeometry8, Matrix4 as Matrix412, Vector3 as Vector315 } from "three";
+import { BufferAttribute as BufferAttribute7, BufferGeometry as BufferGeometry8, Matrix4 as Matrix412, Vector3 as Vector316 } from "three";
 init_ModelCulling();
 init_ModelObject();
 init_UVMapper();
@@ -16685,7 +17073,7 @@ var SectionModels = class {
                 cullFaces.push(0);
                 continue;
               }
-              const normal = new Vector315(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
+              const normal = new Vector316(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
               const world = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
               cullFaces.push(world < 0 ? 0 : 1 << world);
             }
@@ -16881,17 +17269,17 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector316(posOrX, y, z));
+      return this.getBlockAt(new Vector317(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector316(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector317(posOrX[0], posOrX[1], posOrX[2]));
     }
     this.validatePosBounds(posOrX);
     return this.getChunkAt(posOrX)?.getBlockAt(posOrX);
   }
   getBiomeAt(posOrX, y, z) {
-    if (typeof posOrX === "number") return this.getBiomeAt(new Vector316(posOrX, y, z));
-    if (isTripleArray(posOrX)) return this.getBiomeAt(new Vector316(...posOrX));
+    if (typeof posOrX === "number") return this.getBiomeAt(new Vector317(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getBiomeAt(new Vector317(...posOrX));
     this.validatePosBounds(posOrX);
     const cx = Math.floor(posOrX.x / 16), cy = Math.floor(posOrX.y / 16), cz = Math.floor(posOrX.z / 16);
     const lx = posOrX.x - cx * 16, ly = posOrX.y - cy * 16, lz = posOrX.z - cz * 16;
@@ -16899,10 +17287,10 @@ var MineRenderWorld = class {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector316(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector317(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector316(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector317(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -16913,10 +17301,10 @@ var MineRenderWorld = class {
   }
   async setBlockVisibleAt(posOrX, yOrVisible, z, visible) {
     if (typeof posOrX === "number") {
-      return this.setBlockVisibleAt(new Vector316(posOrX, yOrVisible, z), visible);
+      return this.setBlockVisibleAt(new Vector317(posOrX, yOrVisible, z), visible);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockVisibleAt(new Vector316(...posOrX), yOrVisible);
+      return this.setBlockVisibleAt(new Vector317(...posOrX), yOrVisible);
     }
     this.validatePosBounds(posOrX);
     await this.getChunkAt(posOrX)?.setBlockVisibleAt(posOrX, yOrVisible);
@@ -16942,7 +17330,7 @@ var MineRenderWorld = class {
     const collect = async (positions2) => {
       for (const pos of positions2) changes.set(pos.toArray().join(","), pos);
     };
-    const place = (block) => this.placeBlock(new Vector316(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new Vector317(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     const types = /* @__PURE__ */ new Set();
     for (const block of multiblock.blocks) {
@@ -16958,7 +17346,7 @@ var MineRenderWorld = class {
     }
     if (!executor) {
       const groups2 = /* @__PURE__ */ new Map();
-      const position = new Vector316();
+      const position = new Vector317();
       for (const block of multiblock.blocks) {
         const [x, y, z] = block.position;
         this.validatePosBounds(position.set(x, y, z));
@@ -16998,7 +17386,7 @@ var MineRenderWorld = class {
       try {
         positions = await chunk.placeBlocks(blocks);
       } finally {
-        positions ?? (positions = blocks.map(({ index }) => new Vector316(
+        positions ?? (positions = blocks.map(({ index }) => new Vector317(
           chunk.x * 16 + index % 16,
           chunk.y * 16 + Math.floor(index / 256),
           chunk.z * 16 + Math.floor(index / 16) % 16
@@ -17037,7 +17425,7 @@ var MineRenderWorld = class {
       let sliceStart = performance.now();
       for (const section of chunk.sections) {
         if (section.biomes) {
-          const position = new Vector316(chunk.x * 16, section.y * 16, chunk.z * 16);
+          const position = new Vector317(chunk.x * 16, section.y * 16, chunk.z * 16);
           this.validatePosBounds(position);
           const copy = [...section.biomes];
           if (copy.length !== 64 || !copy.every((id) => typeof id === "string" && id.length > 0)) {
@@ -17050,7 +17438,7 @@ var MineRenderWorld = class {
         }
         if (!executor) {
           if (!occupiedSections.has(section.y)) continue;
-          const position = new Vector316(chunk.x * 16, section.y * 16, chunk.z * 16);
+          const position = new Vector317(chunk.x * 16, section.y * 16, chunk.z * 16);
           this.validatePosBounds(position);
           const target = this.getOrCreateChunkAt(position);
           try {
@@ -17144,7 +17532,7 @@ var MineRenderWorld = class {
     this.sectionModels?.clear();
   }
   updateCulling(positions) {
-    const neighbor = new Vector316();
+    const neighbor = new Vector317();
     for (const pos of positions) {
       const cx = Math.floor(pos.x / 16), cy = Math.floor(pos.y / 16), cz = Math.floor(pos.z / 16);
       const chunk = this._chunks.get(`${cx}_${cy}_${cz}`);
@@ -17236,7 +17624,7 @@ var MineRenderWorld = class {
   }
   /** Converts block coordinates to scene units by multiplying each component by 16. */
   static worldToScenePosition(pos) {
-    return new Vector316(
+    return new Vector317(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
@@ -17244,7 +17632,7 @@ var MineRenderWorld = class {
   }
   /** Converts scene units to block coordinates without rounding to an integer block. */
   static sceneToWorldPosition(pos) {
-    return new Vector316(
+    return new Vector317(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -17680,7 +18068,7 @@ var Chunk = class _Chunk {
     this.sectionBlocks = /* @__PURE__ */ new Map();
     this.hiddenBlocks = /* @__PURE__ */ new Set();
     this.fluidCells = new Uint8Array(4096);
-    this.blockPosition = new Vector317();
+    this.blockPosition = new Vector318();
     this.meshDirty = false;
     this.meshGeneration = 0;
     this.scene = scene;
@@ -17690,10 +18078,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector317(posOrX, y, z));
+      return this.getBlockAt(new Vector318(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector317(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector318(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.blockPosition.set(posOrX.x - this.x * 16, posOrX.y - this.y * 16, posOrX.z - this.z * 16);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -17701,10 +18089,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector317(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector318(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector317(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector318(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -17757,7 +18145,7 @@ var Chunk = class _Chunk {
       if (this.fluidCells[index]) this.meshDirty = true;
       this.fluidCells[index] = 0;
       this.renderedBlocks.delete(index);
-      const worldPos = new Vector317(
+      const worldPos = new Vector318(
         this.x * 16 + index % 16,
         this.y * 16 + Math.floor(index / 256),
         this.z * 16 + Math.floor(index / 16) % 16
@@ -17882,7 +18270,7 @@ var Chunk = class _Chunk {
             this.z * 16 + Math.floor(index / 16) % 16
           ]
         });
-        object4.setPosition(new Vector317(
+        object4.setPosition(new Vector318(
           this.x * 256 + index % 16 * 16,
           this.y * 256 + Math.floor(index / 256) * 16,
           this.z * 256 + Math.floor(index / 16) % 16 * 16
@@ -18033,7 +18421,7 @@ var Chunk = class _Chunk {
   /** Removes stored blocks and render objects. Set `notify` to false to skip the owning world's update. */
   async clear(notify = true) {
     const positions = notify && this.onBlocksChanged ? [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
-      new Vector317(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new Vector318(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     )) : [];
     for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
     this.sectionBlocks.clear();
@@ -18061,14 +18449,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new Vector317(
+    return new Vector318(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new Vector317(
+    return new Vector318(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z
@@ -18299,6 +18687,7 @@ export {
   EntityObject,
   Env,
   FluidModelObject,
+  FlyControls,
   Fonts,
   GUI_CONTAINER_LAYOUTS,
   Geometries,
@@ -18401,6 +18790,7 @@ export {
   isDisposable,
   isDoubleArray,
   isEntityObject,
+  isFlyControls,
   isGuiObject,
   isInstanceManager,
   isInstanceReference,