@guoquan.net/flow-engine 0.1.2 → 0.1.10

package/dist/flow.es.js

@@ -1,11 +1,465 @@
-import * as i from "three";
-import { WebGPURenderer as g } from "three/webgpu";
-import { OrbitControls as y } from "three/examples/jsm/controls/OrbitControls.js";
-import { GLTFLoader as f } from "three/examples/jsm/loaders/GLTFLoader.js";
-class M {
+import * as n from "three";
+import { Controls as v, Vector3 as _, MOUSE as b, TOUCH as y, Quaternion as T, Spherical as S, Vector2 as m, Ray as x, Plane as N, MathUtils as I } from "three";
+import { WebGPURenderer as j } from "three/webgpu";
+import { GLTFLoader as k } from "three/examples/jsm/loaders/GLTFLoader.js";
+const L = { type: "change" }, A = { type: "start" }, R = { type: "end" }, E = new x(), C = new N(), H = Math.cos(70 * I.DEG2RAD), d = new _(), p = 2 * Math.PI, l = {
+  NONE: -1,
+  ROTATE: 0,
+  DOLLY: 1,
+  PAN: 2,
+  TOUCH_ROTATE: 3,
+  TOUCH_PAN: 4,
+  TOUCH_DOLLY_PAN: 5,
+  TOUCH_DOLLY_ROTATE: 6
+}, D = 1e-6;
+class U extends v {
+  /**
+   * Constructs a new controls instance.
+   *
+   * @param {Object3D} object - The object that is managed by the controls.
+   * @param {?HTMLElement} domElement - The HTML element used for event listeners.
+   */
+  constructor(t, e = null) {
+    super(t, e), this.state = l.NONE, this.target = new _(), this.cursor = new _(), this.minDistance = 0, this.maxDistance = 1 / 0, this.minZoom = 0, this.maxZoom = 1 / 0, this.minTargetRadius = 0, this.maxTargetRadius = 1 / 0, this.minPolarAngle = 0, this.maxPolarAngle = Math.PI, this.minAzimuthAngle = -1 / 0, this.maxAzimuthAngle = 1 / 0, this.enableDamping = !1, this.dampingFactor = 0.05, this.enableZoom = !0, this.zoomSpeed = 1, this.enableRotate = !0, this.rotateSpeed = 1, this.keyRotateSpeed = 1, this.enablePan = !0, this.panSpeed = 1, this.screenSpacePanning = !0, this.keyPanSpeed = 7, this.zoomToCursor = !1, this.autoRotate = !1, this.autoRotateSpeed = 2, this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" }, this.mouseButtons = { LEFT: b.ROTATE, MIDDLE: b.DOLLY, RIGHT: b.PAN }, this.touches = { ONE: y.ROTATE, TWO: y.DOLLY_PAN }, this.target0 = this.target.clone(), this.position0 = this.object.position.clone(), this.zoom0 = this.object.zoom, this._domElementKeyEvents = null, this._lastPosition = new _(), this._lastQuaternion = new T(), this._lastTargetPosition = new _(), this._quat = new T().setFromUnitVectors(t.up, new _(0, 1, 0)), this._quatInverse = this._quat.clone().invert(), this._spherical = new S(), this._sphericalDelta = new S(), this._scale = 1, this._panOffset = new _(), this._rotateStart = new m(), this._rotateEnd = new m(), this._rotateDelta = new m(), this._panStart = new m(), this._panEnd = new m(), this._panDelta = new m(), this._dollyStart = new m(), this._dollyEnd = new m(), this._dollyDelta = new m(), this._dollyDirection = new _(), this._mouse = new m(), this._performCursorZoom = !1, this._pointers = [], this._pointerPositions = {}, this._controlActive = !1, this._onPointerMove = F.bind(this), this._onPointerDown = Y.bind(this), this._onPointerUp = z.bind(this), this._onContextMenu = X.bind(this), this._onMouseWheel = W.bind(this), this._onKeyDown = Z.bind(this), this._onTouchStart = B.bind(this), this._onTouchMove = Q.bind(this), this._onMouseDown = G.bind(this), this._onMouseMove = K.bind(this), this._interceptControlDown = V.bind(this), this._interceptControlUp = q.bind(this), this.domElement !== null && this.connect(this.domElement), this.update();
+  }
+  connect(t) {
+    super.connect(t), this.domElement.addEventListener("pointerdown", this._onPointerDown), this.domElement.addEventListener("pointercancel", this._onPointerUp), this.domElement.addEventListener("contextmenu", this._onContextMenu), this.domElement.addEventListener("wheel", this._onMouseWheel, { passive: !1 }), this.domElement.getRootNode().addEventListener("keydown", this._interceptControlDown, { passive: !0, capture: !0 }), this.domElement.style.touchAction = "none";
+  }
+  disconnect() {
+    this.domElement.removeEventListener("pointerdown", this._onPointerDown), this.domElement.ownerDocument.removeEventListener("pointermove", this._onPointerMove), this.domElement.ownerDocument.removeEventListener("pointerup", this._onPointerUp), this.domElement.removeEventListener("pointercancel", this._onPointerUp), this.domElement.removeEventListener("wheel", this._onMouseWheel), this.domElement.removeEventListener("contextmenu", this._onContextMenu), this.stopListenToKeyEvents(), this.domElement.getRootNode().removeEventListener("keydown", this._interceptControlDown, { capture: !0 }), this.domElement.style.touchAction = "auto";
+  }
+  dispose() {
+    this.disconnect();
+  }
+  /**
+   * Get the current vertical rotation, in radians.
+   *
+   * @return {number} The current vertical rotation, in radians.
+   */
+  getPolarAngle() {
+    return this._spherical.phi;
+  }
+  /**
+   * Get the current horizontal rotation, in radians.
+   *
+   * @return {number} The current horizontal rotation, in radians.
+   */
+  getAzimuthalAngle() {
+    return this._spherical.theta;
+  }
+  /**
+   * Returns the distance from the camera to the target.
+   *
+   * @return {number} The distance from the camera to the target.
+   */
+  getDistance() {
+    return this.object.position.distanceTo(this.target);
+  }
+  /**
+   * Adds key event listeners to the given DOM element.
+   * `window` is a recommended argument for using this method.
+   *
+   * @param {HTMLElement} domElement - The DOM element
+   */
+  listenToKeyEvents(t) {
+    t.addEventListener("keydown", this._onKeyDown), this._domElementKeyEvents = t;
+  }
+  /**
+   * Removes the key event listener previously defined with `listenToKeyEvents()`.
+   */
+  stopListenToKeyEvents() {
+    this._domElementKeyEvents !== null && (this._domElementKeyEvents.removeEventListener("keydown", this._onKeyDown), this._domElementKeyEvents = null);
+  }
+  /**
+   * Save the current state of the controls. This can later be recovered with `reset()`.
+   */
+  saveState() {
+    this.target0.copy(this.target), this.position0.copy(this.object.position), this.zoom0 = this.object.zoom;
+  }
+  /**
+   * Reset the controls to their state from either the last time the `saveState()`
+   * was called, or the initial state.
+   */
+  reset() {
+    this.target.copy(this.target0), this.object.position.copy(this.position0), this.object.zoom = this.zoom0, this.object.updateProjectionMatrix(), this.dispatchEvent(L), this.update(), this.state = l.NONE;
+  }
+  update(t = null) {
+    const e = this.object.position;
+    d.copy(e).sub(this.target), d.applyQuaternion(this._quat), this._spherical.setFromVector3(d), this.autoRotate && this.state === l.NONE && this._rotateLeft(this._getAutoRotationAngle(t)), this.enableDamping ? (this._spherical.theta += this._sphericalDelta.theta * this.dampingFactor, this._spherical.phi += this._sphericalDelta.phi * this.dampingFactor) : (this._spherical.theta += this._sphericalDelta.theta, this._spherical.phi += this._sphericalDelta.phi);
+    let i = this.minAzimuthAngle, s = this.maxAzimuthAngle;
+    isFinite(i) && isFinite(s) && (i < -Math.PI ? i += p : i > Math.PI && (i -= p), s < -Math.PI ? s += p : s > Math.PI && (s -= p), i <= s ? this._spherical.theta = Math.max(i, Math.min(s, this._spherical.theta)) : this._spherical.theta = this._spherical.theta > (i + s) / 2 ? Math.max(i, this._spherical.theta) : Math.min(s, this._spherical.theta)), this._spherical.phi = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, this._spherical.phi)), this._spherical.makeSafe(), this.enableDamping === !0 ? this.target.addScaledVector(this._panOffset, this.dampingFactor) : this.target.add(this._panOffset), this.target.sub(this.cursor), this.target.clampLength(this.minTargetRadius, this.maxTargetRadius), this.target.add(this.cursor);
+    let a = !1;
+    if (this.zoomToCursor && this._performCursorZoom || this.object.isOrthographicCamera)
+      this._spherical.radius = this._clampDistance(this._spherical.radius);
+    else {
+      const r = this._spherical.radius;
+      this._spherical.radius = this._clampDistance(this._spherical.radius * this._scale), a = r != this._spherical.radius;
+    }
+    if (d.setFromSpherical(this._spherical), d.applyQuaternion(this._quatInverse), e.copy(this.target).add(d), this.object.lookAt(this.target), this.enableDamping === !0 ? (this._sphericalDelta.theta *= 1 - this.dampingFactor, this._sphericalDelta.phi *= 1 - this.dampingFactor, this._panOffset.multiplyScalar(1 - this.dampingFactor)) : (this._sphericalDelta.set(0, 0, 0), this._panOffset.set(0, 0, 0)), this.zoomToCursor && this._performCursorZoom) {
+      let r = null;
+      if (this.object.isPerspectiveCamera) {
+        const h = d.length();
+        r = this._clampDistance(h * this._scale);
+        const c = h - r;
+        this.object.position.addScaledVector(this._dollyDirection, c), this.object.updateMatrixWorld(), a = !!c;
+      } else if (this.object.isOrthographicCamera) {
+        const h = new _(this._mouse.x, this._mouse.y, 0);
+        h.unproject(this.object);
+        const c = this.object.zoom;
+        this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale)), this.object.updateProjectionMatrix(), a = c !== this.object.zoom;
+        const f = new _(this._mouse.x, this._mouse.y, 0);
+        f.unproject(this.object), this.object.position.sub(f).add(h), this.object.updateMatrixWorld(), r = d.length();
+      } else
+        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled."), this.zoomToCursor = !1;
+      r !== null && (this.screenSpacePanning ? this.target.set(0, 0, -1).transformDirection(this.object.matrix).multiplyScalar(r).add(this.object.position) : (E.origin.copy(this.object.position), E.direction.set(0, 0, -1).transformDirection(this.object.matrix), Math.abs(this.object.up.dot(E.direction)) < H ? this.object.lookAt(this.target) : (C.setFromNormalAndCoplanarPoint(this.object.up, this.target), E.intersectPlane(C, this.target))));
+    } else if (this.object.isOrthographicCamera) {
+      const r = this.object.zoom;
+      this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale)), r !== this.object.zoom && (this.object.updateProjectionMatrix(), a = !0);
+    }
+    return this._scale = 1, this._performCursorZoom = !1, a || this._lastPosition.distanceToSquared(this.object.position) > D || 8 * (1 - this._lastQuaternion.dot(this.object.quaternion)) > D || this._lastTargetPosition.distanceToSquared(this.target) > D ? (this.dispatchEvent(L), this._lastPosition.copy(this.object.position), this._lastQuaternion.copy(this.object.quaternion), this._lastTargetPosition.copy(this.target), !0) : !1;
+  }
+  _getAutoRotationAngle(t) {
+    return t !== null ? p / 60 * this.autoRotateSpeed * t : p / 60 / 60 * this.autoRotateSpeed;
+  }
+  _getZoomScale(t) {
+    const e = Math.abs(t * 0.01);
+    return Math.pow(0.95, this.zoomSpeed * e);
+  }
+  _rotateLeft(t) {
+    this._sphericalDelta.theta -= t;
+  }
+  _rotateUp(t) {
+    this._sphericalDelta.phi -= t;
+  }
+  _panLeft(t, e) {
+    d.setFromMatrixColumn(e, 0), d.multiplyScalar(-t), this._panOffset.add(d);
+  }
+  _panUp(t, e) {
+    this.screenSpacePanning === !0 ? d.setFromMatrixColumn(e, 1) : (d.setFromMatrixColumn(e, 0), d.crossVectors(this.object.up, d)), d.multiplyScalar(t), this._panOffset.add(d);
+  }
+  // deltaX and deltaY are in pixels; right and down are positive
+  _pan(t, e) {
+    const i = this.domElement;
+    if (this.object.isPerspectiveCamera) {
+      const s = this.object.position;
+      d.copy(s).sub(this.target);
+      let a = d.length();
+      a *= Math.tan(this.object.fov / 2 * Math.PI / 180), this._panLeft(2 * t * a / i.clientHeight, this.object.matrix), this._panUp(2 * e * a / i.clientHeight, this.object.matrix);
+    } else this.object.isOrthographicCamera ? (this._panLeft(t * (this.object.right - this.object.left) / this.object.zoom / i.clientWidth, this.object.matrix), this._panUp(e * (this.object.top - this.object.bottom) / this.object.zoom / i.clientHeight, this.object.matrix)) : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled."), this.enablePan = !1);
+  }
+  _dollyOut(t) {
+    this.object.isPerspectiveCamera || this.object.isOrthographicCamera ? this._scale /= t : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."), this.enableZoom = !1);
+  }
+  _dollyIn(t) {
+    this.object.isPerspectiveCamera || this.object.isOrthographicCamera ? this._scale *= t : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."), this.enableZoom = !1);
+  }
+  _updateZoomParameters(t, e) {
+    if (!this.zoomToCursor)
+      return;
+    this._performCursorZoom = !0;
+    const i = this.domElement.getBoundingClientRect(), s = t - i.left, a = e - i.top, r = i.width, h = i.height;
+    this._mouse.x = s / r * 2 - 1, this._mouse.y = -(a / h) * 2 + 1, this._dollyDirection.set(this._mouse.x, this._mouse.y, 1).unproject(this.object).sub(this.object.position).normalize();
+  }
+  _clampDistance(t) {
+    return Math.max(this.minDistance, Math.min(this.maxDistance, t));
+  }
+  //
+  // event callbacks - update the object state
+  //
+  _handleMouseDownRotate(t) {
+    this._rotateStart.set(t.clientX, t.clientY);
+  }
+  _handleMouseDownDolly(t) {
+    this._updateZoomParameters(t.clientX, t.clientX), this._dollyStart.set(t.clientX, t.clientY);
+  }
+  _handleMouseDownPan(t) {
+    this._panStart.set(t.clientX, t.clientY);
+  }
+  _handleMouseMoveRotate(t) {
+    this._rotateEnd.set(t.clientX, t.clientY), this._rotateDelta.subVectors(this._rotateEnd, this._rotateStart).multiplyScalar(this.rotateSpeed);
+    const e = this.domElement;
+    this._rotateLeft(p * this._rotateDelta.x / e.clientHeight), this._rotateUp(p * this._rotateDelta.y / e.clientHeight), this._rotateStart.copy(this._rotateEnd), this.update();
+  }
+  _handleMouseMoveDolly(t) {
+    this._dollyEnd.set(t.clientX, t.clientY), this._dollyDelta.subVectors(this._dollyEnd, this._dollyStart), this._dollyDelta.y > 0 ? this._dollyOut(this._getZoomScale(this._dollyDelta.y)) : this._dollyDelta.y < 0 && this._dollyIn(this._getZoomScale(this._dollyDelta.y)), this._dollyStart.copy(this._dollyEnd), this.update();
+  }
+  _handleMouseMovePan(t) {
+    this._panEnd.set(t.clientX, t.clientY), this._panDelta.subVectors(this._panEnd, this._panStart).multiplyScalar(this.panSpeed), this._pan(this._panDelta.x, this._panDelta.y), this._panStart.copy(this._panEnd), this.update();
+  }
+  _handleMouseWheel(t) {
+    this._updateZoomParameters(t.clientX, t.clientY), t.deltaY < 0 ? this._dollyIn(this._getZoomScale(t.deltaY)) : t.deltaY > 0 && this._dollyOut(this._getZoomScale(t.deltaY)), this.update();
+  }
+  _handleKeyDown(t) {
+    let e = !1;
+    switch (t.code) {
+      case this.keys.UP:
+        t.ctrlKey || t.metaKey || t.shiftKey ? this.enableRotate && this._rotateUp(p * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(0, this.keyPanSpeed), e = !0;
+        break;
+      case this.keys.BOTTOM:
+        t.ctrlKey || t.metaKey || t.shiftKey ? this.enableRotate && this._rotateUp(-p * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(0, -this.keyPanSpeed), e = !0;
+        break;
+      case this.keys.LEFT:
+        t.ctrlKey || t.metaKey || t.shiftKey ? this.enableRotate && this._rotateLeft(p * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(this.keyPanSpeed, 0), e = !0;
+        break;
+      case this.keys.RIGHT:
+        t.ctrlKey || t.metaKey || t.shiftKey ? this.enableRotate && this._rotateLeft(-p * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(-this.keyPanSpeed, 0), e = !0;
+        break;
+    }
+    e && (t.preventDefault(), this.update());
+  }
+  _handleTouchStartRotate(t) {
+    if (this._pointers.length === 1)
+      this._rotateStart.set(t.pageX, t.pageY);
+    else {
+      const e = this._getSecondPointerPosition(t), i = 0.5 * (t.pageX + e.x), s = 0.5 * (t.pageY + e.y);
+      this._rotateStart.set(i, s);
+    }
+  }
+  _handleTouchStartPan(t) {
+    if (this._pointers.length === 1)
+      this._panStart.set(t.pageX, t.pageY);
+    else {
+      const e = this._getSecondPointerPosition(t), i = 0.5 * (t.pageX + e.x), s = 0.5 * (t.pageY + e.y);
+      this._panStart.set(i, s);
+    }
+  }
+  _handleTouchStartDolly(t) {
+    const e = this._getSecondPointerPosition(t), i = t.pageX - e.x, s = t.pageY - e.y, a = Math.sqrt(i * i + s * s);
+    this._dollyStart.set(0, a);
+  }
+  _handleTouchStartDollyPan(t) {
+    this.enableZoom && this._handleTouchStartDolly(t), this.enablePan && this._handleTouchStartPan(t);
+  }
+  _handleTouchStartDollyRotate(t) {
+    this.enableZoom && this._handleTouchStartDolly(t), this.enableRotate && this._handleTouchStartRotate(t);
+  }
+  _handleTouchMoveRotate(t) {
+    if (this._pointers.length == 1)
+      this._rotateEnd.set(t.pageX, t.pageY);
+    else {
+      const i = this._getSecondPointerPosition(t), s = 0.5 * (t.pageX + i.x), a = 0.5 * (t.pageY + i.y);
+      this._rotateEnd.set(s, a);
+    }
+    this._rotateDelta.subVectors(this._rotateEnd, this._rotateStart).multiplyScalar(this.rotateSpeed);
+    const e = this.domElement;
+    this._rotateLeft(p * this._rotateDelta.x / e.clientHeight), this._rotateUp(p * this._rotateDelta.y / e.clientHeight), this._rotateStart.copy(this._rotateEnd);
+  }
+  _handleTouchMovePan(t) {
+    if (this._pointers.length === 1)
+      this._panEnd.set(t.pageX, t.pageY);
+    else {
+      const e = this._getSecondPointerPosition(t), i = 0.5 * (t.pageX + e.x), s = 0.5 * (t.pageY + e.y);
+      this._panEnd.set(i, s);
+    }
+    this._panDelta.subVectors(this._panEnd, this._panStart).multiplyScalar(this.panSpeed), this._pan(this._panDelta.x, this._panDelta.y), this._panStart.copy(this._panEnd);
+  }
+  _handleTouchMoveDolly(t) {
+    const e = this._getSecondPointerPosition(t), i = t.pageX - e.x, s = t.pageY - e.y, a = Math.sqrt(i * i + s * s);
+    this._dollyEnd.set(0, a), this._dollyDelta.set(0, Math.pow(this._dollyEnd.y / this._dollyStart.y, this.zoomSpeed)), this._dollyOut(this._dollyDelta.y), this._dollyStart.copy(this._dollyEnd);
+    const r = (t.pageX + e.x) * 0.5, h = (t.pageY + e.y) * 0.5;
+    this._updateZoomParameters(r, h);
+  }
+  _handleTouchMoveDollyPan(t) {
+    this.enableZoom && this._handleTouchMoveDolly(t), this.enablePan && this._handleTouchMovePan(t);
+  }
+  _handleTouchMoveDollyRotate(t) {
+    this.enableZoom && this._handleTouchMoveDolly(t), this.enableRotate && this._handleTouchMoveRotate(t);
+  }
+  // pointers
+  _addPointer(t) {
+    this._pointers.push(t.pointerId);
+  }
+  _removePointer(t) {
+    delete this._pointerPositions[t.pointerId];
+    for (let e = 0; e < this._pointers.length; e++)
+      if (this._pointers[e] == t.pointerId) {
+        this._pointers.splice(e, 1);
+        return;
+      }
+  }
+  _isTrackingPointer(t) {
+    for (let e = 0; e < this._pointers.length; e++)
+      if (this._pointers[e] == t.pointerId) return !0;
+    return !1;
+  }
+  _trackPointer(t) {
+    let e = this._pointerPositions[t.pointerId];
+    e === void 0 && (e = new m(), this._pointerPositions[t.pointerId] = e), e.set(t.pageX, t.pageY);
+  }
+  _getSecondPointerPosition(t) {
+    const e = t.pointerId === this._pointers[0] ? this._pointers[1] : this._pointers[0];
+    return this._pointerPositions[e];
+  }
+  //
+  _customWheelEvent(t) {
+    const e = t.deltaMode, i = {
+      clientX: t.clientX,
+      clientY: t.clientY,
+      deltaY: t.deltaY
+    };
+    switch (e) {
+      case 1:
+        i.deltaY *= 16;
+        break;
+      case 2:
+        i.deltaY *= 100;
+        break;
+    }
+    return t.ctrlKey && !this._controlActive && (i.deltaY *= 10), i;
+  }
+}
+function Y(o) {
+  this.enabled !== !1 && (this._pointers.length === 0 && (this.domElement.setPointerCapture(o.pointerId), this.domElement.ownerDocument.addEventListener("pointermove", this._onPointerMove), this.domElement.ownerDocument.addEventListener("pointerup", this._onPointerUp)), !this._isTrackingPointer(o) && (this._addPointer(o), o.pointerType === "touch" ? this._onTouchStart(o) : this._onMouseDown(o)));
+}
+function F(o) {
+  this.enabled !== !1 && (o.pointerType === "touch" ? this._onTouchMove(o) : this._onMouseMove(o));
+}
+function z(o) {
+  switch (this._removePointer(o), this._pointers.length) {
+    case 0:
+      this.domElement.releasePointerCapture(o.pointerId), this.domElement.ownerDocument.removeEventListener("pointermove", this._onPointerMove), this.domElement.ownerDocument.removeEventListener("pointerup", this._onPointerUp), this.dispatchEvent(R), this.state = l.NONE;
+      break;
+    case 1:
+      const t = this._pointers[0], e = this._pointerPositions[t];
+      this._onTouchStart({ pointerId: t, pageX: e.x, pageY: e.y });
+      break;
+  }
+}
+function G(o) {
+  let t;
+  switch (o.button) {
+    case 0:
+      t = this.mouseButtons.LEFT;
+      break;
+    case 1:
+      t = this.mouseButtons.MIDDLE;
+      break;
+    case 2:
+      t = this.mouseButtons.RIGHT;
+      break;
+    default:
+      t = -1;
+  }
+  switch (t) {
+    case b.DOLLY:
+      if (this.enableZoom === !1) return;
+      this._handleMouseDownDolly(o), this.state = l.DOLLY;
+      break;
+    case b.ROTATE:
+      if (o.ctrlKey || o.metaKey || o.shiftKey) {
+        if (this.enablePan === !1) return;
+        this._handleMouseDownPan(o), this.state = l.PAN;
+      } else {
+        if (this.enableRotate === !1) return;
+        this._handleMouseDownRotate(o), this.state = l.ROTATE;
+      }
+      break;
+    case b.PAN:
+      if (o.ctrlKey || o.metaKey || o.shiftKey) {
+        if (this.enableRotate === !1) return;
+        this._handleMouseDownRotate(o), this.state = l.ROTATE;
+      } else {
+        if (this.enablePan === !1) return;
+        this._handleMouseDownPan(o), this.state = l.PAN;
+      }
+      break;
+    default:
+      this.state = l.NONE;
+  }
+  this.state !== l.NONE && this.dispatchEvent(A);
+}
+function K(o) {
+  switch (this.state) {
+    case l.ROTATE:
+      if (this.enableRotate === !1) return;
+      this._handleMouseMoveRotate(o);
+      break;
+    case l.DOLLY:
+      if (this.enableZoom === !1) return;
+      this._handleMouseMoveDolly(o);
+      break;
+    case l.PAN:
+      if (this.enablePan === !1) return;
+      this._handleMouseMovePan(o);
+      break;
+  }
+}
+function W(o) {
+  this.enabled === !1 || this.enableZoom === !1 || this.state !== l.NONE || (o.preventDefault(), this.dispatchEvent(A), this._handleMouseWheel(this._customWheelEvent(o)), this.dispatchEvent(R));
+}
+function Z(o) {
+  this.enabled !== !1 && this._handleKeyDown(o);
+}
+function B(o) {
+  switch (this._trackPointer(o), this._pointers.length) {
+    case 1:
+      switch (this.touches.ONE) {
+        case y.ROTATE:
+          if (this.enableRotate === !1) return;
+          this._handleTouchStartRotate(o), this.state = l.TOUCH_ROTATE;
+          break;
+        case y.PAN:
+          if (this.enablePan === !1) return;
+          this._handleTouchStartPan(o), this.state = l.TOUCH_PAN;
+          break;
+        default:
+          this.state = l.NONE;
+      }
+      break;
+    case 2:
+      switch (this.touches.TWO) {
+        case y.DOLLY_PAN:
+          if (this.enableZoom === !1 && this.enablePan === !1) return;
+          this._handleTouchStartDollyPan(o), this.state = l.TOUCH_DOLLY_PAN;
+          break;
+        case y.DOLLY_ROTATE:
+          if (this.enableZoom === !1 && this.enableRotate === !1) return;
+          this._handleTouchStartDollyRotate(o), this.state = l.TOUCH_DOLLY_ROTATE;
+          break;
+        default:
+          this.state = l.NONE;
+      }
+      break;
+    default:
+      this.state = l.NONE;
+  }
+  this.state !== l.NONE && this.dispatchEvent(A);
+}
+function Q(o) {
+  switch (this._trackPointer(o), this.state) {
+    case l.TOUCH_ROTATE:
+      if (this.enableRotate === !1) return;
+      this._handleTouchMoveRotate(o), this.update();
+      break;
+    case l.TOUCH_PAN:
+      if (this.enablePan === !1) return;
+      this._handleTouchMovePan(o), this.update();
+      break;
+    case l.TOUCH_DOLLY_PAN:
+      if (this.enableZoom === !1 && this.enablePan === !1) return;
+      this._handleTouchMoveDollyPan(o), this.update();
+      break;
+    case l.TOUCH_DOLLY_ROTATE:
+      if (this.enableZoom === !1 && this.enableRotate === !1) return;
+      this._handleTouchMoveDollyRotate(o), this.update();
+      break;
+    default:
+      this.state = l.NONE;
+  }
+}
+function X(o) {
+  this.enabled !== !1 && o.preventDefault();
+}
+function V(o) {
+  o.key === "Control" && (this._controlActive = !0, this.domElement.getRootNode().addEventListener("keyup", this._interceptControlUp, { passive: !0, capture: !0 }));
+}
+function q(o) {
+  o.key === "Control" && (this._controlActive = !1, this.domElement.getRootNode().removeEventListener("keyup", this._interceptControlUp, { passive: !0, capture: !0 }));
+}
+class $ {
   loader;
   constructor() {
-    this.loader = new f();
+    this.loader = new k();
   }
   /**
    * 加载数字人
@@ -18,16 +472,16 @@ class M {
       const e = await fetch(t);
       if (!e.ok)
         throw new Error(`Failed to load config: ${e.statusText}`);
-      const o = await e.json(), n = t.substring(0, t.lastIndexOf("/") + 1) + o.modelSrc;
-      console.log(`[Flow] Config loaded. Loading model from: ${n}`);
-      let r, s = [];
+      const i = await e.json(), a = t.substring(0, t.lastIndexOf("/") + 1) + i.modelSrc;
+      console.log(`[Flow] Config loaded. Loading model from: ${a}`);
+      let r, h = [];
       try {
-        const l = await this.loader.loadAsync(n);
-        r = l.scene, s = l.animations || [];
-      } catch (l) {
-        console.warn(`[Flow] Failed to load 3D model at ${n}. Using fallback placeholder.`, l), r = this.createFallbackAvatar();
+        const c = await this.loader.loadAsync(a);
+        r = c.scene, h = c.animations || [];
+      } catch (c) {
+        console.warn(`[Flow] Failed to load 3D model at ${a}. Using fallback placeholder.`, c), r = this.createFallbackAvatar();
       }
-      return this.applyConfig(r, o), { model: r, config: o, animations: s };
+      return this.applyConfig(r, i), { model: r, config: i, animations: h };
     } catch (e) {
       throw console.error("[Flow] Error loading avatar:", e), e;
     }
@@ -36,8 +490,8 @@ class M {
    * 应用配置到模型
    */
   applyConfig(t, e) {
-    e.scale && t.scale.setScalar(e.scale), e.initialPosition && t.position.set(...e.initialPosition), t.traverse((o) => {
-      o.isMesh && (o.castShadow = !0, o.receiveShadow = !0);
+    e.scale && t.scale.setScalar(e.scale), e.initialPosition && t.position.set(...e.initialPosition), t.traverse((i) => {
+      i.isMesh && (i.castShadow = !0, i.receiveShadow = !0);
     });
   }
   /**
@@ -45,67 +499,67 @@ class M {
    * 生成一个简单的机器人形状
    */
   createFallbackAvatar() {
-    const t = new i.Group(), e = new i.MeshStandardMaterial({
+    const t = new n.Group(), e = new n.MeshStandardMaterial({
       color: 54015,
       roughness: 0.3,
       metalness: 0.8
-    }), o = new i.BoxGeometry(0.8, 0.9, 0.8), a = new i.Mesh(o, e);
-    a.position.y = 1.5, a.name = "Head", t.add(a);
-    const n = new i.SphereGeometry(0.1), r = new i.MeshBasicMaterial({ color: 16777215 }), s = new i.Mesh(n, r);
-    s.position.set(-0.2, 1.5, 0.4), t.add(s);
-    const l = new i.Mesh(n, r);
-    l.position.set(0.2, 1.5, 0.4), t.add(l);
-    const d = new i.CylinderGeometry(0.6, 0.4, 1.5, 8), c = new i.Mesh(d, e);
-    c.position.y = 0.5, c.name = "Body", t.add(c);
-    const h = new i.CapsuleGeometry(0.15, 1), p = new i.Mesh(h, e);
-    p.position.set(-0.9, 0.8, 0), p.rotation.z = Math.PI / 4, p.name = "LeftArm", t.add(p);
-    const w = new i.Mesh(h, e);
-    return w.position.set(0.9, 0.8, 0), w.rotation.z = -Math.PI / 4, w.name = "RightArm", t.add(w), t;
-  }
-}
-class S {
+    }), i = new n.BoxGeometry(0.8, 0.9, 0.8), s = new n.Mesh(i, e);
+    s.position.y = 1.5, s.name = "Head", t.add(s);
+    const a = new n.SphereGeometry(0.1), r = new n.MeshBasicMaterial({ color: 16777215 }), h = new n.Mesh(a, r);
+    h.position.set(-0.2, 1.5, 0.4), t.add(h);
+    const c = new n.Mesh(a, r);
+    c.position.set(0.2, 1.5, 0.4), t.add(c);
+    const f = new n.CylinderGeometry(0.6, 0.4, 1.5, 8), g = new n.Mesh(f, e);
+    g.position.y = 0.5, g.name = "Body", t.add(g);
+    const w = new n.CapsuleGeometry(0.15, 1), P = new n.Mesh(w, e);
+    P.position.set(-0.9, 0.8, 0), P.rotation.z = Math.PI / 4, P.name = "LeftArm", t.add(P);
+    const M = new n.Mesh(w, e);
+    return M.position.set(0.9, 0.8, 0), M.rotation.z = -Math.PI / 4, M.name = "RightArm", t.add(M), t;
+  }
+}
+class J {
   loader;
   constructor() {
-    this.loader = new f();
+    this.loader = new k();
   }
   async load(t) {
     try {
       const e = await fetch(t);
       if (!e.ok) throw new Error("Failed to load stage config");
-      const o = await e.json();
-      let a, n = [];
-      if (o.modelSrc) {
-        const s = t.substring(0, t.lastIndexOf("/") + 1) + o.modelSrc, l = await this.loader.loadAsync(s);
-        a = l.scene, n = l.animations || [];
+      const i = await e.json();
+      let s, a = [];
+      if (i.modelSrc) {
+        const h = t.substring(0, t.lastIndexOf("/") + 1) + i.modelSrc, c = await this.loader.loadAsync(h);
+        s = c.scene, a = c.animations || [];
       } else
-        a = this.createProceduralStage();
-      return this.applyConfig(a, o), { model: a, config: o, animations: n };
+        s = this.createProceduralStage();
+      return this.applyConfig(s, i), { model: s, config: i, animations: a };
     } catch (e) {
       throw console.error("[Flow] Stage load error:", e), e;
     }
   }
   applyConfig(t, e) {
-    e.scale && t.scale.setScalar(e.scale), e.position && t.position.set(...e.position), e.rotation && t.rotation.set(...e.rotation), t.traverse((o) => {
-      o.isMesh && (o.receiveShadow = !0, o.castShadow = !0);
+    e.scale && t.scale.setScalar(e.scale), e.position && t.position.set(...e.position), e.rotation && t.rotation.set(...e.rotation), t.traverse((i) => {
+      i.isMesh && (i.receiveShadow = !0, i.castShadow = !0);
     });
   }
   /**
    * Generates a cool Sci-Fi Podium if no model is provided
    */
   createProceduralStage() {
-    const t = new i.Group(), e = new i.CylinderGeometry(2, 2.2, 0.2, 32), o = new i.MeshStandardMaterial({ color: 2236962, roughness: 0.2, metalness: 0.8 }), a = new i.Mesh(e, o);
-    a.position.y = -0.1, t.add(a);
-    const n = new i.TorusGeometry(1.8, 0.05, 16, 100), r = new i.MeshBasicMaterial({ color: 54015 }), s = new i.Mesh(n, r);
-    s.rotation.x = -Math.PI / 2, s.position.y = 0.01, t.add(s);
-    const l = new i.BoxGeometry(0.5, 0.05, 0.5);
-    for (let d = 0; d < 4; d++) {
-      const c = new i.Mesh(l, o), h = d / 4 * Math.PI * 2;
-      c.position.set(Math.cos(h) * 2.5, 0, Math.sin(h) * 2.5), c.lookAt(0, 0, 0), t.add(c);
+    const t = new n.Group(), e = new n.CylinderGeometry(2, 2.2, 0.2, 32), i = new n.MeshStandardMaterial({ color: 2236962, roughness: 0.2, metalness: 0.8 }), s = new n.Mesh(e, i);
+    s.position.y = -0.1, t.add(s);
+    const a = new n.TorusGeometry(1.8, 0.05, 16, 100), r = new n.MeshBasicMaterial({ color: 54015 }), h = new n.Mesh(a, r);
+    h.rotation.x = -Math.PI / 2, h.position.y = 0.01, t.add(h);
+    const c = new n.BoxGeometry(0.5, 0.05, 0.5);
+    for (let f = 0; f < 4; f++) {
+      const g = new n.Mesh(c, i), w = f / 4 * Math.PI * 2;
+      g.position.set(Math.cos(w) * 2.5, 0, Math.sin(w) * 2.5), g.lookAt(0, 0, 0), t.add(g);
     }
     return t;
   }
 }
-class u {
+class O {
   mixer;
   clips;
   states = {};
@@ -113,14 +567,14 @@ class u {
   currentState = null;
   defaultState = "idle";
   constructor(t, e) {
-    this.mixer = new i.AnimationMixer(t), this.clips = e, this.mixer.addEventListener("finished", this.onFinished.bind(this));
+    this.mixer = new n.AnimationMixer(t), this.clips = e, this.mixer.addEventListener("finished", this.onFinished.bind(this));
   }
   /**
    * Initialize with configuration
    */
   init(t) {
-    this.defaultState = t.defaultState, this.states = t.states, Object.entries(this.states).forEach(([e, o]) => {
-      this.findClip(o.clipName) || console.warn(`[AnimationController] Clip "${o.clipName}" for state "${e}" not found.`);
+    this.defaultState = t.defaultState, this.states = t.states, Object.entries(this.states).forEach(([e, i]) => {
+      this.findClip(i.clipName) || console.warn(`[AnimationController] Clip "${i.clipName}" for state "${e}" not found.`);
     }), this.play(this.defaultState);
   }
   /**
@@ -133,40 +587,173 @@ class u {
    * Play a state
    */
   play(t, e = !1) {
-    const o = this.states[t];
-    if (!o) {
+    const i = this.states[t];
+    if (!i) {
       console.warn(`[AnimationController] State "${t}" not defined.`);
       return;
     }
-    const a = this.findClip(o.clipName);
-    if (!a || this.currentState === t && !e) return;
-    const n = this.mixer.clipAction(a);
-    n.setLoop(o.loop ? i.LoopRepeat : i.LoopOnce, o.loop ? 1 / 0 : 1), n.clampWhenFinished = !o.loop, n.timeScale = o.timeScale ?? 1;
-    const r = o.fadeDuration ?? 0.3;
+    const s = this.findClip(i.clipName);
+    if (!s || this.currentState === t && !e) return;
+    const a = this.mixer.clipAction(s);
+    a.setLoop(i.loop ? n.LoopRepeat : n.LoopOnce, i.loop ? 1 / 0 : 1), a.clampWhenFinished = !i.loop, a.timeScale = i.timeScale ?? 1;
+    const r = i.fadeDuration ?? 0.3;
     if (this.currentState) {
-      const s = this.activeActions.get(this.currentState);
-      s && s !== n ? (s.fadeOut(r), n.reset(), n.fadeIn(r), n.play()) : n.reset().play();
+      const h = this.activeActions.get(this.currentState);
+      h && h !== a ? (h.fadeOut(r), a.reset(), a.fadeIn(r), a.play()) : a.reset().play();
     } else
-      n.reset().play();
-    this.activeActions.set(t, n), this.currentState = t, console.log(`[Anim] Transition to: ${t} (Loop: ${o.loop})`);
+      a.reset().play();
+    this.activeActions.set(t, a), this.currentState = t, console.log(`[Anim] Transition to: ${t} (Loop: ${i.loop})`);
   }
   onFinished(t) {
     if (this.currentState && this.activeActions.get(this.currentState) === t.action) {
-      const e = this.states[this.currentState], o = () => {
+      const e = this.states[this.currentState], i = () => {
         e && e.next ? this.play(e.next) : !e.loop && this.currentState !== this.defaultState && this.play(this.defaultState);
       };
-      e.holdDuration && e.holdDuration > 0 ? setTimeout(o, e.holdDuration * 1e3) : o();
+      e.holdDuration && e.holdDuration > 0 ? setTimeout(i, e.holdDuration * 1e3) : i();
     }
   }
   /**
    * Finds an animation clip by name using exact, case-insensitive, or fuzzy matching.
    */
   findClip(t) {
-    let e = this.clips.find((o) => o.name === t);
-    return e || (e = this.clips.find((o) => o.name.toLowerCase() === t.toLowerCase())), e || (e = this.clips.find((o) => o.name.toLowerCase().includes(t.toLowerCase()))), e;
+    let e = this.clips.find((i) => i.name === t);
+    return e || (e = this.clips.find((i) => i.name.toLowerCase() === t.toLowerCase())), e || (e = this.clips.find((i) => i.name.toLowerCase().includes(t.toLowerCase()))), e;
   }
 }
-class L {
+const u = {
+  IDLE: "IDLE",
+  TRACKING: "TRACKING",
+  HOLDING: "HOLDING"
+}, tt = 5, et = 1.5, it = Number.EPSILON;
+class st {
+  raycaster = new n.Raycaster();
+  mouse = new n.Vector2();
+  // State Machine
+  state = u.IDLE;
+  stateTimer = 0;
+  // Core Data
+  lookAtTarget = new n.Vector3();
+  // Desired World Target
+  currentLookAt = new n.Vector3();
+  // Smoothed World Target (For debug visualization)
+  activePlane = new n.Plane(new n.Vector3(0, 0, 1), -2.5);
+  planeCenter = new n.Vector3(0, 1.5, 2.5);
+  // Visual center of the plane
+  // Physics / Math Helpers
+  lookAtProxy = new n.Object3D();
+  // Reusable temporaries to reduce GC
+  _targetQuat = new n.Quaternion();
+  _dummyVec = new n.Vector3();
+  _offsetQuat = new n.Quaternion();
+  _parentWorldQuat = new n.Quaternion();
+  // V6 Architecture: Persistent State Tracker
+  outputQuaternion = null;
+  weight = 0;
+  // Legacy debug value
+  // Dependencies
+  container;
+  camera;
+  getHeadBone;
+  getConfig;
+  getModels;
+  // Bound event handlers
+  boundOnPointerDown;
+  boundOnPointerMove;
+  boundOnPointerUp;
+  constructor(t, e, i, s, a) {
+    this.container = t, this.camera = e, this.getHeadBone = i, this.getConfig = s, this.getModels = a, this.boundOnPointerDown = this.onPointerDown.bind(this), this.boundOnPointerMove = this.onPointerMove.bind(this), this.boundOnPointerUp = this.onPointerUp.bind(this), this.container.addEventListener("pointerdown", this.boundOnPointerDown), this.container.addEventListener("pointermove", this.boundOnPointerMove), window.addEventListener("pointerup", this.boundOnPointerUp);
+  }
+  update(t, e) {
+    const i = this.getHeadBone(), s = this.getConfig();
+    if (!i || !s || s.lookAt?.enabled === !1) return;
+    const a = i.quaternion.clone();
+    this.outputQuaternion || (this.outputQuaternion = a.clone()), this.updateState(t, s);
+    const r = this.state === u.TRACKING || this.state === u.HOLDING;
+    r ? (this.calculateLookAtRotation(i, s, this._targetQuat), this.weight = 1) : (this._targetQuat.copy(a), this.weight = 0);
+    const h = s.lookAt?.damping ?? tt, c = 1 - Math.exp(-h * e);
+    this.outputQuaternion.slerp(this._targetQuat, c), i.quaternion.copy(this.outputQuaternion), r && this.currentLookAt.lerp(this.lookAtTarget, c);
+  }
+  calculateLookAtRotation(t, e, i) {
+    const s = this._dummyVec;
+    t.getWorldPosition(s), this.lookAtProxy.position.copy(s), this.lookAtProxy.lookAt(this.lookAtTarget), this.lookAtProxy.updateMatrixWorld();
+    const a = e.lookAt?.rotationOffset || [0, 0, 0];
+    this._offsetQuat.setFromEuler(new n.Euler(...a));
+    const r = this.lookAtProxy.quaternion.multiply(this._offsetQuat), h = t.parent;
+    if (h) {
+      h.getWorldQuaternion(this._parentWorldQuat);
+      const c = this._parentWorldQuat.invert();
+      i.copy(c.multiply(r));
+    } else
+      i.copy(r);
+  }
+  updateState(t, e) {
+    const i = e.lookAt?.holdDuration ?? 2e3;
+    switch (this.state) {
+      case u.TRACKING:
+        this.calculateLookAtTarget();
+        break;
+      case u.HOLDING:
+        t - this.stateTimer > i && (this.state = u.IDLE, console.log("[Flow] LookAt: Holding finished, releasing to animation."));
+        break;
+    }
+  }
+  onPointerDown(t) {
+    this.updateMouse(t);
+    const e = this.getHeadBone();
+    if (e) {
+      const i = new n.Vector3();
+      e.getWorldPosition(i);
+      const s = this.camera.position.clone(), a = new n.Vector3().subVectors(s, i), r = new n.Vector3();
+      if (a.lengthSq() < 1e-6) {
+        const c = this.camera;
+        "getWorldDirection" in c && typeof c.getWorldDirection == "function" ? (c.getWorldDirection(r), r.negate()) : r.set(0, 0, 1);
+      } else
+        r.copy(a).normalize();
+      const h = r.clone().multiplyScalar(et);
+      this.planeCenter.copy(i).add(h), this.activePlane.setFromNormalAndCoplanarPoint(r, this.planeCenter);
+    }
+    this.state = u.TRACKING, this.calculateLookAtTarget(), this.outputQuaternion || this.currentLookAt.copy(this.lookAtTarget);
+  }
+  onPointerMove(t) {
+    this.state === u.TRACKING && this.updateMouse(t);
+  }
+  onPointerUp() {
+    this.state === u.TRACKING && (this.state = u.HOLDING, this.stateTimer = performance.now());
+  }
+  updateMouse(t) {
+    const e = this.container.getBoundingClientRect();
+    this.mouse.x = (t.clientX - e.left) / e.width * 2 - 1, this.mouse.y = -((t.clientY - e.top) / e.height) * 2 + 1;
+  }
+  calculateLookAtTarget() {
+    this.raycaster.setFromCamera(this.mouse, this.camera);
+    const t = this.getModels().filter((i) => !!i);
+    if (t.length > 0) {
+      const i = this.raycaster.intersectObjects(t, !0);
+      if (i.length > 0) {
+        this.lookAtTarget.copy(i[0].point);
+        return;
+      }
+    }
+    const e = this._dummyVec;
+    this.activePlane.normal.lengthSq() > it && this.raycaster.ray.intersectPlane(this.activePlane, e) && this.lookAtTarget.copy(e);
+  }
+  getDebugInfo() {
+    return {
+      isEngaged: this.state !== u.IDLE,
+      currentLookAt: this.currentLookAt,
+      activePlane: this.activePlane,
+      planeCenter: this.planeCenter,
+      weight: this.weight
+    };
+  }
+  interrupt() {
+    this.state = u.IDLE;
+  }
+  dispose() {
+    this.container.removeEventListener("pointerdown", this.boundOnPointerDown), this.container.removeEventListener("pointermove", this.boundOnPointerMove), window.removeEventListener("pointerup", this.boundOnPointerUp);
+  }
+}
+class rt {
   container;
   scene;
   camera;
@@ -177,77 +764,115 @@ class L {
   stageLoader;
   avatarModel = null;
   stageModel = null;
+  headBone = null;
   animController = null;
   stageAnimController = null;
+  // Components
+  lookAtProcessor;
+  currentAvatarConfig = null;
+  // Debug Helpers
+  isDebug = !1;
+  debugTargetMesh = null;
+  debugPlaneMesh = null;
   constructor(t) {
     const e = document.getElementById(t);
     if (!e) throw new Error(`Container #${t} not found`);
-    this.container = e, this.clock = new i.Clock(), this.loader = new M(), this.stageLoader = new S(), this.scene = new i.Scene(), this.scene.background = new i.Color(1710618), this.scene.fog = new i.Fog(1710618, 10, 50), this.camera = new i.PerspectiveCamera(
+    this.container = e, this.clock = new n.Clock(), this.loader = new $(), this.stageLoader = new J(), this.scene = new n.Scene(), this.scene.background = new n.Color(1710618), this.scene.fog = new n.Fog(1710618, 10, 50), this.camera = new n.PerspectiveCamera(
       45,
       window.innerWidth / window.innerHeight,
       0.1,
       100
-    ), this.camera.position.set(0, 1.5, 5), this.renderer = new g({ antialias: !0, alpha: !0 }), this.renderer.setSize(window.innerWidth, window.innerHeight), this.renderer.setPixelRatio(window.devicePixelRatio), this.container.appendChild(this.renderer.domElement), this.setupLights(), this.controls = new y(this.camera, this.renderer.domElement), this.controls.enableDamping = !0, this.controls.target.set(0, 1, 0), window.addEventListener("resize", this.onWindowResize.bind(this)), this.renderer.setAnimationLoop(this.animate.bind(this));
+    ), this.camera.position.set(0, 1.5, 5), this.renderer = new j({ antialias: !0, alpha: !0 }), this.renderer.setSize(window.innerWidth, window.innerHeight), this.renderer.setPixelRatio(window.devicePixelRatio), this.container.appendChild(this.renderer.domElement), this.setupLights(), this.controls = new U(this.camera, this.renderer.domElement), this.controls.enableDamping = !0, this.controls.target.set(0, 1, 0), this.lookAtProcessor = new st(
+      this.container,
+      this.camera,
+      () => this.headBone,
+      () => this.currentAvatarConfig,
+      () => {
+        const i = [];
+        return this.avatarModel && i.push(this.avatarModel), this.stageModel && i.push(this.stageModel), i;
+      }
+    ), window.addEventListener("resize", this.onWindowResize.bind(this)), this.renderer.setAnimationLoop(this.animate.bind(this));
   }
   setupLights() {
-    const t = new i.AmbientLight(16777215, 0.6);
+    const t = new n.AmbientLight(16777215, 0.6);
     this.scene.add(t);
-    const e = new i.DirectionalLight(16777215, 1);
+    const e = new n.DirectionalLight(16777215, 1);
     e.position.set(5, 10, 7), e.castShadow = !0, this.scene.add(e);
-    const o = new i.SpotLight(54015, 5);
-    o.position.set(-5, 5, -5), o.lookAt(0, 1, 0), this.scene.add(o);
+    const i = new n.SpotLight(54015, 5);
+    i.position.set(-5, 5, -5), i.lookAt(0, 1, 0), this.scene.add(i);
   }
   /**
    * Load an avatar by config URL
    */
   async loadAvatar(t) {
     this.avatarModel && this.scene.remove(this.avatarModel);
-    const { model: e, config: o, animations: a } = await this.loader.load(t);
-    if (this.avatarModel = e, this.scene.add(this.avatarModel), a.length > 0) {
-      this.animController = new u(this.avatarModel, a);
-      const n = o.animations || {
+    const { model: e, config: i, animations: s } = await this.loader.load(t);
+    this.avatarModel = e, this.currentAvatarConfig = i, this.scene.add(this.avatarModel);
+    const a = i.lookAt?.headBoneName || "Head";
+    if (this.headBone = this.avatarModel.getObjectByName(a) || null, this.headBone || this.avatarModel.traverse((r) => {
+      !this.headBone && r.name.toLowerCase().includes("head") && (this.headBone = r);
+    }), s.length > 0) {
+      this.animController = new O(this.avatarModel, s);
+      const r = i.animations || {
         defaultState: "idle",
         states: {
           idle: { clipName: "Idle", loop: !0 },
+          walk: { clipName: "Walking", loop: !0 },
           wave: { clipName: "Wave", loop: !1, next: "idle" },
           dance: { clipName: "Dance", loop: !1, next: "idle" },
-          bow: { clipName: "Bow", loop: !1, next: "idle" },
-          walk: { clipName: "Walking", loop: !0 }
+          bow: { clipName: "Bow", loop: !1, next: "idle" }
         }
       };
-      this.animController.init(n);
+      this.animController.init(r);
     }
-    console.log(`[Flow] Avatar "${o.name}" loaded successfully.`);
+    console.log(`[Flow] Avatar "${i.name}" loaded.`);
   }
   /**
    * Load a stage (podium/scene) by config URL
    */
   async loadStage(t) {
     this.stageModel && this.scene.remove(this.stageModel);
-    const { model: e, config: o, animations: a } = await this.stageLoader.load(t);
-    this.stageModel = e, this.scene.add(this.stageModel), a.length > 0 && o.animations && (this.stageAnimController = new u(this.stageModel, a), this.stageAnimController.init(o.animations)), console.log(`[Flow] Stage "${o.name}" loaded successfully.`);
+    const { model: e, config: i, animations: s } = await this.stageLoader.load(t);
+    this.stageModel = e, this.scene.add(this.stageModel), s.length > 0 && i.animations && (this.stageAnimController = new O(this.stageModel, s), this.stageAnimController.init(i.animations));
+  }
+  setDebug(t) {
+    this.isDebug = t, t ? this.createDebugHelpers() : this.removeDebugHelpers();
+  }
+  createDebugHelpers() {
+    if (this.debugTargetMesh || (this.debugTargetMesh = new n.Mesh(
+      new n.SphereGeometry(0.1, 8, 8),
+      new n.MeshBasicMaterial({ color: 16711680, wireframe: !0, depthTest: !1 })
+    ), this.debugTargetMesh.renderOrder = 999, this.scene.add(this.debugTargetMesh)), !this.debugPlaneMesh) {
+      const t = new n.GridHelper(5, 10, 65280, 34816);
+      t.material.transparent = !0, t.material.opacity = 0.5, t.rotateX(Math.PI / 2), this.debugPlaneMesh = t, this.scene.add(this.debugPlaneMesh);
+    }
+  }
+  updateDebugHelpers() {
+    if (!this.isDebug || !this.lookAtProcessor) return;
+    const t = this.lookAtProcessor.getDebugInfo(), e = !!(t.planeCenter && t.activePlane);
+    if (this.debugTargetMesh && (this.debugTargetMesh.position.copy(t.currentLookAt), this.debugTargetMesh.visible = t.isEngaged), this.debugPlaneMesh && (this.debugPlaneMesh.visible = e, e)) {
+      this.debugPlaneMesh.position.copy(t.planeCenter);
+      const i = t.activePlane.normal, s = this.debugPlaneMesh.position.clone().add(i);
+      this.debugPlaneMesh.lookAt(s), this.debugPlaneMesh.rotateX(Math.PI / 2);
+    }
+  }
+  removeDebugHelpers() {
+    this.debugTargetMesh && (this.scene.remove(this.debugTargetMesh), this.debugTargetMesh = null), this.debugPlaneMesh && (this.scene.remove(this.debugPlaneMesh), this.debugPlaneMesh = null);
   }
   onWindowResize() {
     this.camera.aspect = window.innerWidth / window.innerHeight, this.camera.updateProjectionMatrix(), this.renderer.setSize(window.innerWidth, window.innerHeight);
   }
-  // State
   isAutoRotate = !1;
-  /**
-   * Play a specific action
-   */
   playAction(t) {
-    if (console.log(`[FlowEngine] Playing action: ${t}`), this.animController) {
-      this.animController.play(t.toLowerCase());
-      return;
-    }
+    this.lookAtProcessor.interrupt(), this.animController && this.animController.play(t.toLowerCase());
   }
   animate(t) {
     const e = this.clock.getDelta();
-    this.avatarModel && this.animController && this.animController.update(e), this.stageModel && this.stageAnimController && this.stageAnimController.update(e), this.controls.autoRotate = this.isAutoRotate, this.controls.update(), this.renderer.render(this.scene, this.camera);
+    this.avatarModel && (this.animController && this.animController.update(e), this.lookAtProcessor.update(t, e)), this.updateDebugHelpers(), this.stageModel && this.stageAnimController && this.stageAnimController.update(e), this.controls.autoRotate = this.isAutoRotate, this.controls.update(), this.renderer.render(this.scene, this.camera);
   }
 }
 export {
-  u as AnimationController,
-  M as AvatarLoader,
-  L as FlowEngine
+  O as AnimationController,
+  $ as AvatarLoader,
+  rt as FlowEngine
 };