@sequent-org/ifc-viewer 1.2.4-ci.32.0 → 1.2.4-ci.34.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sequent-org/ifc-viewer",
   "private": false,
-  "version": "1.2.4-ci.32.0",
+  "version": "1.2.4-ci.34.0",
   "type": "module",
   "description": "IFC 3D model viewer component for web applications - fully self-contained with local IFCLoader",
   "main": "src/index.js",

package/src/main.js

@@ -9,6 +9,29 @@ if (app) {
   const viewer = new Viewer(app);
   viewer.init();
 
+  // ===== Диагностика (включается через query-параметры) =====
+  // ?debugViewer=1  -> window.__viewer = viewer
+  // ?zoomDebug=1    -> включает логирование zoom-to-cursor
+  // ?zoomCursor=0   -> отключает zoom-to-cursor (для сравнения с OrbitControls)
+  try {
+    const params = new URLSearchParams(location.search);
+    const debugViewer = params.get("debugViewer") === "1" || params.get("zoomDebug") === "1";
+    if (debugViewer) {
+      // eslint-disable-next-line no-undef
+      window.__viewer = viewer;
+    }
+    if (params.get("zoomDebug") === "1") {
+      viewer.setZoomToCursorDebug?.(true);
+      // eslint-disable-next-line no-console
+      console.log("[Viewer] zoom-to-cursor debug enabled");
+    }
+    if (params.get("zoomCursor") === "0") {
+      viewer.setZoomToCursorEnabled?.(false);
+      // eslint-disable-next-line no-console
+      console.log("[Viewer] zoom-to-cursor disabled (zoomCursor=0)");
+    }
+  } catch (_) {}
+
   // ===== Левая панель: временно оставляем только "Тест" =====
   // Остальные контролы (тени/солнце/материалы/визуал/цветокор) будем добавлять пошагово позже.
   // (Старый код управления панелью закомментирован ниже для последующего восстановления при необходимости.)
@@ -532,7 +555,10 @@ if (app) {
 
   // Очистка при HMR (vite)
   if (import.meta.hot) {
-    import.meta.hot.dispose(() => { ifc.dispose(); viewer.dispose(); });
+    import.meta.hot.dispose(() => {
+      ifc.dispose();
+      viewer.dispose();
+    });
   }
 }
 

package/src/viewer/MiddleMousePanController.js

@@ -0,0 +1,250 @@
+import * as THREE from "three";
+
+/**
+ * Middle-mouse (MMB) pan controller.
+ *
+ * Цель: панорамирование "как в Autodesk" — сдвигать всю картинку (вид) при drag
+ * средней кнопкой мыши (нажатое колесо), но НЕ менять pivot вращения (controls.target).
+ *
+ * Реализация: camera.setViewOffset(...) — экранное смещение проекции (off-axis).
+ *
+ * Важно:
+ * - перехватывает события в capture-phase, чтобы OrbitControls не выполнял dolly на MMB
+ * - не трогает поведение ЛКМ/ПКМ
+ */
+export class MiddleMousePanController {
+  /**
+   * @param {object} deps
+   * @param {HTMLElement} deps.domElement
+   * @param {() => (THREE.Camera|null)} deps.getCamera
+   * @param {() => (import('three/examples/jsm/controls/OrbitControls').OrbitControls|null)} deps.getControls
+   * @param {() => boolean} [deps.isEnabled]
+   * @param {(e: PointerEvent) => boolean} [deps.shouldIgnoreEvent]
+   * @param {() => boolean} [deps.isDebug]
+   */
+  constructor(deps) {
+    this.domElement = deps.domElement;
+    this.getCamera = deps.getCamera;
+    this.getControls = deps.getControls;
+    this.isEnabled = deps.isEnabled || (() => true);
+    this.shouldIgnoreEvent = deps.shouldIgnoreEvent || (() => false);
+    this.isDebug = deps.isDebug || (() => false);
+
+    this._activePointerId = null;
+    this._last = { x: 0, y: 0 };
+    this._prevControlsEnabled = null;
+
+    // Смещение вида в пикселях (screen-space)
+    this._offsetPx = { x: 0, y: 0 };
+
+    // Векторы оставлены только для возможных будущих расширений (не обязаны, но безопасно)
+    this._tmp = new THREE.Vector2();
+
+    /** @type {(e: PointerEvent) => void} */
+    this._onPointerDown = (e) => this.#handlePointerDown(e);
+    /** @type {(e: PointerEvent) => void} */
+    this._onPointerMove = (e) => this.#handlePointerMove(e);
+    /** @type {(e: PointerEvent) => void} */
+    this._onPointerUp = (e) => this.#handlePointerUp(e);
+
+    // Capture-phase: чтобы остановить OrbitControls (MMB по умолчанию = dolly)
+    this.domElement.addEventListener("pointerdown", this._onPointerDown, { capture: true, passive: false });
+  }
+
+  /**
+   * Сбрасывает MMB-pan смещение (возвращает вид как без viewOffset).
+   * Используется Home-кнопкой.
+   */
+  reset() {
+    this._offsetPx.x = 0;
+    this._offsetPx.y = 0;
+    const camera = this.getCamera?.();
+    if (!camera) return;
+
+    try {
+      if (typeof camera.clearViewOffset === "function") {
+        camera.clearViewOffset();
+        camera.updateProjectionMatrix();
+        return;
+      }
+    } catch (_) {}
+
+    // Fallback: setViewOffset(…, 0,0, …) с текущим размером
+    try {
+      const rect = this.domElement.getBoundingClientRect?.();
+      if (!rect || rect.width <= 0 || rect.height <= 0) return;
+      const w = Math.max(1, Math.floor(rect.width));
+      const h = Math.max(1, Math.floor(rect.height));
+      camera.setViewOffset(w, h, 0, 0, w, h);
+      camera.updateProjectionMatrix();
+    } catch (_) {}
+  }
+
+  /**
+   * Добавляет смещение viewOffset в пикселях (в координатах camera.setViewOffset).
+   * Используется для внутренней компенсации (например, чтобы убрать "скачок" при смене pivot).
+   * @param {number} dxPx
+   * @param {number} dyPx
+   */
+  addOffsetPx(dxPx, dyPx) {
+    const dx = Number(dxPx);
+    const dy = Number(dyPx);
+    if (!Number.isFinite(dx) || !Number.isFinite(dy)) return;
+    this._offsetPx.x += dx;
+    this._offsetPx.y += dy;
+    this.applyCurrentOffset();
+  }
+
+  /**
+   * Переустанавливает текущий viewOffset (например, после resize / смены камеры).
+   * @param {number} [width]
+   * @param {number} [height]
+   */
+  applyCurrentOffset(width, height) {
+    const camera = this.getCamera?.();
+    if (!camera) return;
+    let w = width, h = height;
+    if (!(Number.isFinite(w) && Number.isFinite(h))) {
+      const rect = this.domElement.getBoundingClientRect?.();
+      if (!rect || rect.width <= 0 || rect.height <= 0) return;
+      w = rect.width;
+      h = rect.height;
+    }
+    this.#applyViewOffset(camera, w, h);
+  }
+
+  dispose() {
+    try {
+      this.domElement.removeEventListener("pointerdown", this._onPointerDown, { capture: true });
+    } catch (_) {
+      try { this.domElement.removeEventListener("pointerdown", this._onPointerDown); } catch (_) {}
+    }
+    this.#stopDrag(null);
+  }
+
+  #handlePointerDown(e) {
+    if (!this.isEnabled()) return;
+    if (e.button !== 1) return; // MMB only
+    if (this.shouldIgnoreEvent && this.shouldIgnoreEvent(e)) return;
+
+    const camera = this.getCamera?.();
+    const controls = this.getControls?.();
+    if (!camera || !controls) return;
+
+    // Заблокируем дефолт браузера (автоскролл) и OrbitControls dolly.
+    e.preventDefault();
+    e.stopPropagation();
+    // eslint-disable-next-line no-undef
+    if (typeof e.stopImmediatePropagation === "function") e.stopImmediatePropagation();
+
+    // Начинаем drag
+    this._activePointerId = e.pointerId;
+    this._last.x = e.clientX;
+    this._last.y = e.clientY;
+
+    // На время MMB-pan отключаем controls, чтобы не срабатывали внутренние обработчики
+    try {
+      this._prevControlsEnabled = !!controls.enabled;
+      controls.enabled = false;
+    } catch (_) {
+      this._prevControlsEnabled = null;
+    }
+
+    try { this.domElement.setPointerCapture?.(e.pointerId); } catch (_) {}
+
+    // Слушаем move/up на window — надёжно при уходе курсора за пределы канваса
+    window.addEventListener("pointermove", this._onPointerMove, { passive: false });
+    window.addEventListener("pointerup", this._onPointerUp, { passive: false });
+    window.addEventListener("pointercancel", this._onPointerUp, { passive: false });
+
+    if (this.isDebug()) {
+      try { console.log("[MMB-Pan] start"); } catch (_) {}
+    }
+  }
+
+  #handlePointerMove(e) {
+    if (this._activePointerId == null) return;
+    if (e.pointerId !== this._activePointerId) return;
+
+    const camera = this.getCamera?.();
+    if (!camera) return;
+
+    const rect = this.domElement.getBoundingClientRect?.();
+    if (!rect || rect.width <= 0 || rect.height <= 0) return;
+
+    // Заблокируем дефолт (на некоторых браузерах автоскролл может пытаться включиться)
+    e.preventDefault();
+    e.stopPropagation();
+    // eslint-disable-next-line no-undef
+    if (typeof e.stopImmediatePropagation === "function") e.stopImmediatePropagation();
+
+    const dxPx = e.clientX - this._last.x;
+    const dyPx = e.clientY - this._last.y;
+    if (dxPx === 0 && dyPx === 0) return;
+    this._last.x = e.clientX;
+    this._last.y = e.clientY;
+
+    // Screen-space смещение: двигаем "картинку", pivot (controls.target) НЕ трогаем.
+    // Подбор знака: drag вправо => объект на экране тоже уходит вправо (как "тащим" сцену рукой).
+    // Интуитивное направление: "тащим" сцену рукой.
+    // Если курсор уходит влево — картинка должна уйти влево (и наоборот).
+    this._offsetPx.x -= dxPx;
+    this._offsetPx.y -= dyPx;
+    this.#applyViewOffset(camera, rect.width, rect.height);
+
+    if (this.isDebug()) {
+      try {
+        console.log("[MMB-Pan]", {
+          dxPx,
+          dyPx,
+          offsetPx: { x: this._offsetPx.x, y: this._offsetPx.y },
+        });
+      } catch (_) {}
+    }
+  }
+
+  #applyViewOffset(camera, width, height) {
+    const w = Math.max(1, Math.floor(width));
+    const h = Math.max(1, Math.floor(height));
+    const ox = Math.round(this._offsetPx.x);
+    const oy = Math.round(this._offsetPx.y);
+    try {
+      // fullWidth/fullHeight == width/height => off-axis shift (без "подматриц")
+      camera.setViewOffset(w, h, ox, oy, w, h);
+      camera.updateProjectionMatrix();
+    } catch (_) {}
+  }
+
+  #handlePointerUp(e) {
+    if (this._activePointerId == null) return;
+    if (e && e.pointerId !== this._activePointerId) return;
+    this.#stopDrag(e);
+  }
+
+  #stopDrag(e) {
+    // Снимем window listeners
+    try { window.removeEventListener("pointermove", this._onPointerMove); } catch (_) {}
+    try { window.removeEventListener("pointerup", this._onPointerUp); } catch (_) {}
+    try { window.removeEventListener("pointercancel", this._onPointerUp); } catch (_) {}
+
+    // Восстановим OrbitControls
+    try {
+      const controls = this.getControls?.();
+      if (controls && this._prevControlsEnabled != null) controls.enabled = this._prevControlsEnabled;
+    } catch (_) {}
+    this._prevControlsEnabled = null;
+
+    // Освободим pointer capture
+    try {
+      if (e && this.domElement.releasePointerCapture) this.domElement.releasePointerCapture(e.pointerId);
+    } catch (_) {}
+
+    this._activePointerId = null;
+
+    if (this.isDebug()) {
+      try { console.log("[MMB-Pan] end"); } catch (_) {}
+    }
+  }
+}
+
+

package/src/viewer/RightMouseModelMoveController.js

@@ -0,0 +1,217 @@
+import * as THREE from "three";
+
+/**
+ * Right-mouse (RMB) drag controller that moves the MODEL (activeModel) in screen plane,
+ * while keeping OrbitControls pivot (controls.target) fixed.
+ *
+ * Это восстанавливает поведение:
+ * - ПКМ: "таскаем" модель относительно оси (pivot остаётся на месте)
+ * - ЛКМ: вращаем вокруг pivot (модель может ездить по окружности)
+ */
+export class RightMouseModelMoveController {
+  /**
+   * @param {object} deps
+   * @param {HTMLElement} deps.domElement
+   * @param {() => (THREE.Camera|null)} deps.getCamera
+   * @param {() => (import('three/examples/jsm/controls/OrbitControls').OrbitControls|null)} deps.getControls
+   * @param {() => (THREE.Object3D|null)} deps.getModel
+   * @param {() => boolean} [deps.isEnabled]
+   * @param {(e: PointerEvent) => boolean} [deps.shouldIgnoreEvent]
+   * @param {() => boolean} [deps.isDebug]
+   * @param {(pivotWorld: THREE.Vector3) => void} [deps.onRmbStart]
+   */
+  constructor(deps) {
+    this.domElement = deps.domElement;
+    this.getCamera = deps.getCamera;
+    this.getControls = deps.getControls;
+    this.getModel = deps.getModel;
+    this.isEnabled = deps.isEnabled || (() => true);
+    this.shouldIgnoreEvent = deps.shouldIgnoreEvent || (() => false);
+    this.isDebug = deps.isDebug || (() => false);
+    this.onRmbStart = typeof deps.onRmbStart === "function" ? deps.onRmbStart : null;
+
+    this._activePointerId = null;
+    this._last = { x: 0, y: 0 };
+    this._prevControlsEnabled = null;
+    this._suppressContextMenu = false;
+
+    this._vRight = new THREE.Vector3();
+    this._vUp = new THREE.Vector3();
+    this._vDelta = new THREE.Vector3();
+
+    /** @type {(e: PointerEvent) => void} */
+    this._onPointerDown = (e) => this.#handlePointerDown(e);
+    /** @type {(e: PointerEvent) => void} */
+    this._onPointerMove = (e) => this.#handlePointerMove(e);
+    /** @type {(e: PointerEvent) => void} */
+    this._onPointerUp = (e) => this.#handlePointerUp(e);
+    /** @type {(e: MouseEvent) => void} */
+    this._onContextMenu = (e) => this.#handleContextMenu(e);
+
+    this.domElement.addEventListener("pointerdown", this._onPointerDown, { capture: true, passive: false });
+    this.domElement.addEventListener("contextmenu", this._onContextMenu, { capture: true, passive: false });
+  }
+
+  dispose() {
+    try { this.domElement.removeEventListener("pointerdown", this._onPointerDown, { capture: true }); } catch (_) {
+      try { this.domElement.removeEventListener("pointerdown", this._onPointerDown); } catch (_) {}
+    }
+    try { this.domElement.removeEventListener("contextmenu", this._onContextMenu, { capture: true }); } catch (_) {
+      try { this.domElement.removeEventListener("contextmenu", this._onContextMenu); } catch (_) {}
+    }
+    this.#stopDrag(null);
+  }
+
+  #handleContextMenu(e) {
+    if (!this._suppressContextMenu) return;
+    try { e.preventDefault(); } catch (_) {}
+  }
+
+  #handlePointerDown(e) {
+    if (!this.isEnabled()) return;
+    if (e.button !== 2) return; // RMB only
+    if (this.shouldIgnoreEvent && this.shouldIgnoreEvent(e)) return;
+
+    const camera = this.getCamera?.();
+    const controls = this.getControls?.();
+    const model = this.getModel?.();
+    if (!camera || !controls || !model) return;
+
+    // Блокируем context menu и OrbitControls pan на ПКМ
+    this._suppressContextMenu = true;
+    e.preventDefault();
+    e.stopPropagation();
+    // eslint-disable-next-line no-undef
+    if (typeof e.stopImmediatePropagation === "function") e.stopImmediatePropagation();
+
+    // Сохраним pivot-ось для режима "двигаем модель вокруг оси"
+    try {
+      const pivot = controls.target?.clone?.();
+      if (pivot && this.onRmbStart) this.onRmbStart(pivot);
+    } catch (_) {}
+
+    this._activePointerId = e.pointerId;
+    this._last.x = e.clientX;
+    this._last.y = e.clientY;
+
+    // На время drag отключаем OrbitControls, чтобы он не панорамировал камеру
+    try {
+      this._prevControlsEnabled = !!controls.enabled;
+      controls.enabled = false;
+    } catch (_) {
+      this._prevControlsEnabled = null;
+    }
+
+    try { this.domElement.setPointerCapture?.(e.pointerId); } catch (_) {}
+    window.addEventListener("pointermove", this._onPointerMove, { passive: false });
+    window.addEventListener("pointerup", this._onPointerUp, { passive: false });
+    window.addEventListener("pointercancel", this._onPointerUp, { passive: false });
+
+    if (this.isDebug()) {
+      try { console.log("[RMB-ModelMove] start"); } catch (_) {}
+    }
+  }
+
+  #handlePointerMove(e) {
+    if (this._activePointerId == null) return;
+    if (e.pointerId !== this._activePointerId) return;
+
+    const camera = this.getCamera?.();
+    const controls = this.getControls?.();
+    const model = this.getModel?.();
+    if (!camera || !controls || !model) return;
+
+    const rect = this.domElement.getBoundingClientRect?.();
+    if (!rect || rect.width <= 0 || rect.height <= 0) return;
+
+    e.preventDefault();
+    e.stopPropagation();
+    // eslint-disable-next-line no-undef
+    if (typeof e.stopImmediatePropagation === "function") e.stopImmediatePropagation();
+
+    const dxPx = e.clientX - this._last.x;
+    const dyPx = e.clientY - this._last.y;
+    if (dxPx === 0 && dyPx === 0) return;
+    this._last.x = e.clientX;
+    this._last.y = e.clientY;
+
+    // Перевод пикселей в world-сдвиг в плоскости экрана (right/up).
+    const w = rect.width;
+    const h = rect.height;
+    const aspect = w / h;
+
+    let worldPerPxX = 0;
+    let worldPerPxY = 0;
+
+    if (camera.isPerspectiveCamera) {
+      // Масштабируем по расстоянию до pivot (так поведение стабильно при орбит-камере)
+      const dist = camera.position.distanceTo(controls.target);
+      const vFov = (camera.fov * Math.PI) / 180;
+      const visibleH = 2 * dist * Math.tan(vFov / 2);
+      const visibleW = visibleH * aspect;
+      worldPerPxX = visibleW / w;
+      worldPerPxY = visibleH / h;
+    } else if (camera.isOrthographicCamera) {
+      const visibleW = (camera.right - camera.left) / Math.max(1e-6, camera.zoom || 1);
+      const visibleH = (camera.top - camera.bottom) / Math.max(1e-6, camera.zoom || 1);
+      worldPerPxX = visibleW / w;
+      worldPerPxY = visibleH / h;
+    } else {
+      return;
+    }
+
+    // Интуитивно: модель "идёт" за мышью.
+    const moveX = dxPx * worldPerPxX;
+    const moveY = -dyPx * worldPerPxY;
+
+    try { camera.updateMatrixWorld?.(true); } catch (_) {}
+    this._vRight.setFromMatrixColumn(camera.matrixWorld, 0).normalize();
+    this._vUp.setFromMatrixColumn(camera.matrixWorld, 1).normalize();
+    this._vDelta.copy(this._vRight).multiplyScalar(moveX).add(this._vUp.multiplyScalar(moveY));
+
+    model.position.add(this._vDelta);
+    model.updateMatrixWorld?.(true);
+
+    if (this.isDebug()) {
+      try {
+        console.log("[RMB-ModelMove]", {
+          dxPx,
+          dyPx,
+          delta: { x: +this._vDelta.x.toFixed(4), y: +this._vDelta.y.toFixed(4), z: +this._vDelta.z.toFixed(4) },
+        });
+      } catch (_) {}
+    }
+  }
+
+  #handlePointerUp(e) {
+    if (this._activePointerId == null) return;
+    if (e && e.pointerId !== this._activePointerId) return;
+    this.#stopDrag(e);
+  }
+
+  #stopDrag(e) {
+    try { window.removeEventListener("pointermove", this._onPointerMove); } catch (_) {}
+    try { window.removeEventListener("pointerup", this._onPointerUp); } catch (_) {}
+    try { window.removeEventListener("pointercancel", this._onPointerUp); } catch (_) {}
+
+    try {
+      const controls = this.getControls?.();
+      if (controls && this._prevControlsEnabled != null) controls.enabled = this._prevControlsEnabled;
+    } catch (_) {}
+    this._prevControlsEnabled = null;
+
+    try {
+      if (e && this.domElement.releasePointerCapture) this.domElement.releasePointerCapture(e.pointerId);
+    } catch (_) {}
+
+    this._activePointerId = null;
+    // чуть задержим сброс, чтобы contextmenu не проскочил на mouseup
+    setTimeout(() => { this._suppressContextMenu = false; }, 0);
+
+    if (this.isDebug()) {
+      try { console.log("[RMB-ModelMove] end"); } catch (_) {}
+    }
+  }
+}
+
+

package/src/viewer/Viewer.js

@@ -12,6 +12,9 @@ import { BrightnessContrastShader } from "three/examples/jsm/shaders/BrightnessC
 import { RoomEnvironment } from "three/examples/jsm/environments/RoomEnvironment.js";
 import { NavCube } from "./NavCube.js";
 import { SectionManipulator } from "./SectionManipulator.js";
+import { ZoomToCursorController } from "./ZoomToCursorController.js";
+import { MiddleMousePanController } from "./MiddleMousePanController.js";
+import { RightMouseModelMoveController } from "./RightMouseModelMoveController.js";
 
 export class Viewer {
   constructor(containerElement) {
@@ -149,11 +152,16 @@ export class Viewer {
       flatShading: true,
       quality: 'medium',
       clipEnabled: [Infinity, Infinity, Infinity],
+      // Трансформ модели (для сброса ПКМ-сдвигов)
+      modelTransform: null, // { position: Vector3, quaternion: Quaternion, scale: Vector3 }
     };
 
     // Визуализация оси вращения
     this.rotationAxisLine = null;
     this._isLmbDown = false;
+    // OrbitControls 'start' может прийти раньше нашего bubble pointerdown.
+    // Поэтому сохраняем кнопку последнего pointerdown в capture-phase.
+    this._lastPointerDownButton = null;
     this._wasRotating = false;
     this._prevViewDir = null;
     this._smoothedAxis = null;
@@ -169,10 +177,174 @@ export class Viewer {
     this._onControlsChange = null;
     this._onControlsEnd = null;
 
+    // Zoom-to-cursor (wheel): включено по умолчанию, debug выключен
+    this._zoomToCursor = {
+      enabled: true,
+      debug: false,
+      controller: null,
+    };
+
+    // MMB-pan (wheel-click drag): включено по умолчанию, debug выключен
+    this._mmbPan = {
+      enabled: true,
+      debug: false,
+      controller: null,
+    };
+
+    // RMB: перемещение модели относительно "оси" (pivot), pivot остаётся на месте
+    this._rmbModelMove = {
+      enabled: true,
+      debug: false,
+      controller: null,
+      pivotAnchor: null, // THREE.Vector3|null (фиксированная ось после ПКМ)
+    };
+
     this.handleResize = this.handleResize.bind(this);
     this.animate = this.animate.bind(this);
   }
 
+  /**
+   * Включает/выключает zoom-to-cursor (wheel).
+   * @param {boolean} enabled
+   */
+  setZoomToCursorEnabled(enabled) {
+    if (!this._zoomToCursor) return;
+    this._zoomToCursor.enabled = !!enabled;
+  }
+
+  /**
+   * Включает/выключает диагностическое логирование zoom-to-cursor.
+   * @param {boolean} debug
+   */
+  setZoomToCursorDebug(debug) {
+    if (!this._zoomToCursor) return;
+    this._zoomToCursor.debug = !!debug;
+  }
+
+  /**
+   * Возвращает текущие флаги zoom-to-cursor (для диагностики).
+   */
+  getZoomToCursorState() {
+    if (!this._zoomToCursor) return { enabled: false, debug: false };
+    return { enabled: !!this._zoomToCursor.enabled, debug: !!this._zoomToCursor.debug };
+  }
+
+  /**
+   * Возвращает "домашнюю" точку вращения для текущей модели:
+   * центр bbox со смещением вниз по Y (как при первичной загрузке).
+   * @returns {THREE.Vector3|null}
+   */
+  #getDefaultPivotForActiveModel() {
+    const subject = this.activeModel || this.demoCube;
+    if (!subject) return null;
+    try {
+      const box = new THREE.Box3().setFromObject(subject);
+      const center = box.getCenter(new THREE.Vector3());
+      const size = box.getSize(new THREE.Vector3());
+      const pivot = center.clone();
+      // Держим модель "выше" в кадре, как при replaceWithModel()
+      const verticalBias = size.y * 0.30; // 30% высоты
+      pivot.y = center.y - verticalBias;
+      return pivot;
+    } catch (_) {
+      return null;
+    }
+  }
+
+  /**
+   * Возвращает целевой pivot для ЛКМ-вращения:
+   * - если модель двигали ПКМ, используем фиксированную ось (pivotAnchor)
+   * - иначе используем "домашний" pivot (центр bbox + verticalBias)
+   * @returns {THREE.Vector3|null}
+   */
+  #getDesiredPivotForRotate() {
+    try {
+      const fixed = this._rmbModelMove?.pivotAnchor;
+      if (fixed) return fixed.clone();
+    } catch (_) {}
+    return this.#getDefaultPivotForActiveModel();
+  }
+
+  /**
+   * После zoom-to-cursor target может сместиться к точке под курсором (например, к углу),
+   * и вращение начнёт происходить вокруг этой точки.
+   * Здесь мы возвращаем pivot к "домашнему" центру модели перед началом LMB-вращения,
+   * сохраняя кадр (camera смещается на тот же delta).
+   */
+  #rebaseRotatePivotToModelCenterIfNeeded() {
+    if (!this.camera || !this.controls) return;
+    const desired = this.#getDesiredPivotForRotate();
+    if (!desired) return;
+
+    const current = this.controls.target;
+    const dx = desired.x - current.x;
+    const dy = desired.y - current.y;
+    const dz = desired.z - current.z;
+    const dist2 = dx * dx + dy * dy + dz * dz;
+    // Порог: чтобы не дергать pivot от микросдвигов зума
+    if (dist2 < 1e-6) return;
+
+    // Важно: нельзя "двигать модель к оси" визуально. Поэтому:
+    // 1) запоминаем положение старого target на экране
+    // 2) меняем pivot (controls.target) на центр модели
+    // 3) компенсируем экранный сдвиг через viewOffset (MMB-pan controller), чтобы картинка не дернулась
+    const dom = this.renderer?.domElement;
+    const rect = dom?.getBoundingClientRect?.();
+    const w = rect?.width || 0;
+    const h = rect?.height || 0;
+    const canProject = w > 1 && h > 1;
+
+    const oldTarget = this.controls.target.clone();
+    let p0 = null;
+    if (canProject) {
+      try { this.camera.updateMatrixWorld?.(true); } catch (_) {}
+      try { p0 = oldTarget.clone().project(this.camera); } catch (_) { p0 = null; }
+    }
+
+    try { this.controls.target.copy(desired); } catch (_) {}
+    try { this.controls.update(); } catch (_) {}
+
+    if (canProject && p0) {
+      let p1 = null;
+      try { this.camera.updateMatrixWorld?.(true); } catch (_) {}
+      try { p1 = oldTarget.clone().project(this.camera); } catch (_) { p1 = null; }
+      if (p1) {
+        // NDC -> px. Y: NDC вверх, а viewOffset.y увеличением поднимает картинку (см. MMB-pan).
+        const dNdcX = (p1.x - p0.x);
+        const dNdcY = (p1.y - p0.y);
+        const dxPx = dNdcX * (w / 2);
+        const dyPx = -dNdcY * (h / 2);
+        try { this._mmbPan?.controller?.addOffsetPx?.(dxPx, dyPx); } catch (_) {}
+      }
+    }
+  }
+
+  /**
+   * Включает/выключает MMB-pan (нажатое колесо + drag).
+   * @param {boolean} enabled
+   */
+  setMiddleMousePanEnabled(enabled) {
+    if (!this._mmbPan) return;
+    this._mmbPan.enabled = !!enabled;
+  }
+
+  /**
+   * Включает/выключает диагностическое логирование MMB-pan.
+   * @param {boolean} debug
+   */
+  setMiddleMousePanDebug(debug) {
+    if (!this._mmbPan) return;
+    this._mmbPan.debug = !!debug;
+  }
+
+  /**
+   * Возвращает текущие флаги MMB-pan (для диагностики).
+   */
+  getMiddleMousePanState() {
+    if (!this._mmbPan) return { enabled: false, debug: false };
+    return { enabled: !!this._mmbPan.enabled, debug: !!this._mmbPan.debug };
+  }
+
   /**
    * Меняет FOV перспективной камеры, сохраняя кадрирование (масштаб объекта на экране) по текущему target.
    * Это позволяет "ослабить перспективу" без резкого зума.
@@ -312,6 +484,69 @@ export class Viewer {
     this.controls.minZoom = this._projection.minZoom;
     this.controls.maxZoom = this._projection.maxZoom;
 
+    // Zoom-to-cursor: перехватываем wheel в capture-phase, чтобы OrbitControls не выполнял dolly сам
+    try {
+      this._zoomToCursor.controller = new ZoomToCursorController({
+        domElement: this.renderer.domElement,
+        getCamera: () => this.camera,
+        getControls: () => this.controls,
+        getPickRoot: () => this.activeModel,
+        onZoomChanged: (force) => this._notifyZoomIfChanged(force),
+        isEnabled: () => !!this._zoomToCursor.enabled,
+        isDebug: () => !!this._zoomToCursor.debug,
+      });
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.warn("ZoomToCursor init failed:", e);
+    }
+
+    // MMB-pan: перехватываем pointerdown в capture-phase, чтобы OrbitControls не делал dolly на MMB
+    try {
+      this._mmbPan.controller = new MiddleMousePanController({
+        domElement: this.renderer.domElement,
+        getCamera: () => this.camera,
+        getControls: () => this.controls,
+        isEnabled: () => !!this._mmbPan.enabled,
+        isDebug: () => !!this._mmbPan.debug,
+        // Не стартуем пан, если нажали на overlay NavCube (иначе "тащит" камеру при клике по кубу)
+        shouldIgnoreEvent: (e) => {
+          try {
+            return !!(this.navCube && typeof this.navCube._isInsideOverlay === "function" && this.navCube._isInsideOverlay(e.clientX, e.clientY));
+          } catch (_) {
+            return false;
+          }
+        },
+      });
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.warn("MMB-pan init failed:", e);
+    }
+
+    // RMB model move: перехватываем ПКМ и двигаем МОДЕЛЬ (activeModel), не трогая pivot (target)
+    try {
+      this._rmbModelMove.controller = new RightMouseModelMoveController({
+        domElement: this.renderer.domElement,
+        getCamera: () => this.camera,
+        getControls: () => this.controls,
+        getModel: () => this.activeModel,
+        isEnabled: () => !!this._rmbModelMove.enabled,
+        isDebug: () => !!this._rmbModelMove.debug,
+        shouldIgnoreEvent: (e) => {
+          try {
+            return !!(this.navCube && typeof this.navCube._isInsideOverlay === "function" && this.navCube._isInsideOverlay(e.clientX, e.clientY));
+          } catch (_) {
+            return false;
+          }
+        },
+        onRmbStart: (pivot) => {
+          try { this._rmbModelMove.pivotAnchor = pivot?.clone?.() || null; } catch (_) { this._rmbModelMove.pivotAnchor = null; }
+        },
+      });
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.warn("RMB-model-move init failed:", e);
+    }
+
     // Создадим вторую камеру "без перспективы" (orthographic), но не включаем её по умолчанию.
     // Фрустум подбираем так, чтобы при переключении вид менялся только за счёт перспективных искажений.
     try {
@@ -381,8 +616,15 @@ export class Viewer {
     });
 
     // Визуальная ось вращения: события мыши и контролов
-    this._onPointerDown = (e) => { if (e.button === 0) this._isLmbDown = true; };
-    this._onPointerUp = (e) => { if (e.button === 0) { this._isLmbDown = false; this.#hideRotationAxisLine(); } };
+    this._onPointerDown = (e) => {
+      this._lastPointerDownButton = e?.button;
+      if (e.button === 0) this._isLmbDown = true;
+    };
+    this._onPointerUp = (e) => {
+      // Сбросим "последнюю кнопку" на отпускании, чтобы не использовать устаревшее значение.
+      this._lastPointerDownButton = null;
+      if (e.button === 0) { this._isLmbDown = false; this.#hideRotationAxisLine(); }
+    };
     this._onPointerMove = (e) => {
       const rect = this.renderer?.domElement?.getBoundingClientRect?.();
       if (!rect) return;
@@ -394,13 +636,17 @@ export class Viewer {
       this._recentPointerDelta = dx + dy;
       this._lastPointer = now;
     };
-    this.renderer.domElement.addEventListener('pointerdown', this._onPointerDown, { passive: true });
+    // Capture-phase: чтобы успеть выставить флаги до OrbitControls (его start может прийти раньше bubble pointerdown)
+    this.renderer.domElement.addEventListener('pointerdown', this._onPointerDown, { capture: true, passive: true });
     this.renderer.domElement.addEventListener('pointerup', this._onPointerUp, { passive: true });
     this.renderer.domElement.addEventListener('pointermove', this._onPointerMove, { passive: true });
 
     this._onControlsStart = () => {
       // Инициализируем предыдущий вектор направления вида
       if (!this.camera || !this.controls) return;
+      // Если стартовали вращение ЛКМ после zoom-to-cursor, то target мог сместиться к "углу".
+      // Возвращаем pivot к центру модели (как при загрузке), сохраняя кадр.
+      if (this._lastPointerDownButton === 0) this.#rebaseRotatePivotToModelCenterIfNeeded();
       const dir = this.camera.position.clone().sub(this.controls.target).normalize();
       this._prevViewDir = dir;
       this._smoothedAxis = null;
@@ -445,6 +691,7 @@ export class Viewer {
     this._home.flatShading = this.flatShading;
     this._home.quality = this.quality;
     this._home.clipEnabled = this.clipping.planes.map(p => p.constant);
+    // Модель может быть ещё не загружена — modelTransform снимем после replaceWithModel()
 
     // Сигнал о готовности после первого кадра
     requestAnimationFrame(() => {
@@ -523,6 +770,15 @@ export class Viewer {
       try { this.renderer.domElement.removeEventListener('pointerup', this._onPointerUp); } catch(_) {}
       try { this.renderer.domElement.removeEventListener('pointermove', this._onPointerMove); } catch(_) {}
     }
+    // Снимем wheel zoom-to-cursor
+    try { this._zoomToCursor?.controller?.dispose?.(); } catch (_) {}
+    if (this._zoomToCursor) this._zoomToCursor.controller = null;
+    // Снимем MMB-pan
+    try { this._mmbPan?.controller?.dispose?.(); } catch (_) {}
+    if (this._mmbPan) this._mmbPan.controller = null;
+    // Снимем RMB model move
+    try { this._rmbModelMove?.controller?.dispose?.(); } catch (_) {}
+    if (this._rmbModelMove) this._rmbModelMove.controller = null;
     if (this.controls) {
       try { this.controls.removeEventListener('start', this._onControlsStart); } catch(_) {}
       try { this.controls.removeEventListener('change', this._onControlsChange); } catch(_) {}
@@ -684,8 +940,8 @@ export class Viewer {
 
     const newMin = Math.max(0.01, fitDist * Math.max(0.0, minRatio));
     const newMax = Math.max(newMin * 1.5, fitDist * Math.max(1.0, slack));
-    this.controls.minDistance = newMin;
     this.controls.maxDistance = newMax;
+    this.controls.minDistance = newMin;
 
     // Настройка near/far для стабильной глубины (уменьшает z-fighting на тонких/накладных деталях).
     // Важно: far должен быть "как можно меньше", но достаточен для maxDistance.
@@ -771,6 +1027,9 @@ export class Viewer {
     if (this._ssaoPass?.setSize) {
       try { this._ssaoPass.setSize(width, height); } catch (_) {}
     }
+
+    // Если активен MMB-pan (viewOffset), нужно переустановить его под новый размер
+    try { this._mmbPan?.controller?.applyCurrentOffset?.(width, height); } catch (_) {}
   }
 
   // ================= Projection (Perspective / Ortho) =================
@@ -838,6 +1097,9 @@ export class Viewer {
     this.controls.target.copy(target);
     this.controls.update();
 
+    // ViewOffset (MMB-pan) должен примениться к новой камере, если он включён
+    try { this._mmbPan?.controller?.applyCurrentOffset?.(); } catch (_) {}
+
     // Внутренние зависимости, которые держат ссылку на camera
     if (this.navCube) this.navCube.mainCamera = this.camera;
     try {
@@ -955,6 +1217,21 @@ export class Viewer {
         this._home.flatShading = this.flatShading;
         this._home.quality = this.quality;
         this._home.clipEnabled = this.clipping.planes.map(p => p.constant);
+
+        // Снимем исходный трансформ модели для Home (ПКМ-сдвиги должны сбрасываться)
+        try {
+          const m = this.activeModel;
+          if (m) {
+            this._home.modelTransform = {
+              position: m.position.clone(),
+              quaternion: m.quaternion.clone(),
+              scale: m.scale.clone(),
+            };
+          }
+        } catch (_) {}
+
+        // После загрузки модели сбрасываем "фиксированную ось" от ПКМ
+        try { if (this._rmbModelMove) this._rmbModelMove.pivotAnchor = null; } catch (_) {}
       });
     } catch(_) {}
   }
@@ -2785,9 +3062,29 @@ export class Viewer {
   // Вернуть стартовый вид
   goHome() {
     if (!this.camera || !this.controls) return;
+
+    // Сброс MMB-pan (viewOffset), чтобы оси/вид вернулись как при загрузке
+    try { this._mmbPan?.controller?.reset?.(); } catch (_) {}
+
     // Камера и прицел
     this.controls.target.copy(this._home.target);
     this.camera.position.copy(this._home.cameraPos);
+
+    // Сброс трансформа модели (ПКМ-сдвиг): вернуть как при загрузке
+    try {
+      const mt = this._home?.modelTransform;
+      const m = this.activeModel;
+      if (m && mt && mt.position && mt.quaternion && mt.scale) {
+        m.position.copy(mt.position);
+        m.quaternion.copy(mt.quaternion);
+        m.scale.copy(mt.scale);
+        m.updateMatrixWorld?.(true);
+      }
+    } catch (_) {}
+
+    // Home: сбрасываем "фиксированную ось" от ПКМ
+    try { if (this._rmbModelMove) this._rmbModelMove.pivotAnchor = null; } catch (_) {}
+
     // Визуальные настройки
     this.setEdgesVisible(this._home.edgesVisible);
     this.setFlatShading(this._home.flatShading);

package/src/viewer/ZoomToCursorController.js

@@ -0,0 +1,285 @@
+import * as THREE from "three";
+
+/**
+ * Zoom-to-cursor для three.js камер (Perspective + Orthographic).
+ * Делает зум колёсиком относительно точки под курсором.
+ *
+ * Реализовано через:
+ * - выбор "опорной плоскости" (hit по модели, иначе плоскость через target)
+ * - изменение дистанции/zoom
+ * - компенсацию сдвига (camera + controls.target), чтобы опорная точка оставалась под курсором
+ */
+export class ZoomToCursorController {
+  /**
+   * @param {object} deps
+   * @param {HTMLElement} deps.domElement
+   * @param {() => (THREE.Camera|null)} deps.getCamera
+   * @param {() => (import('three/examples/jsm/controls/OrbitControls').OrbitControls|null)} deps.getControls
+   * @param {() => (THREE.Object3D|null)} deps.getPickRoot
+   * @param {(force?: boolean) => void} [deps.onZoomChanged]
+   * @param {() => boolean} [deps.isEnabled]
+   * @param {() => boolean} [deps.isDebug]
+   */
+  constructor(deps) {
+    this.domElement = deps.domElement;
+    this.getCamera = deps.getCamera;
+    this.getControls = deps.getControls;
+    this.getPickRoot = deps.getPickRoot;
+    this.onZoomChanged = deps.onZoomChanged || null;
+    this.isEnabled = deps.isEnabled || (() => true);
+    this.isDebug = deps.isDebug || (() => false);
+
+    this._raycaster = new THREE.Raycaster();
+    this._ndc = new THREE.Vector2();
+    this._plane = new THREE.Plane();
+
+    this._vDir = new THREE.Vector3();
+    this._vA = new THREE.Vector3();
+    this._vB = new THREE.Vector3();
+    this._vC = new THREE.Vector3();
+    this._vBefore = new THREE.Vector3();
+    this._vAfter = new THREE.Vector3();
+
+    /** @type {(e: WheelEvent) => void} */
+    this._onWheel = (e) => this.#handleWheel(e);
+    this.domElement.addEventListener("wheel", this._onWheel, { capture: true, passive: false });
+  }
+
+  dispose() {
+    try {
+      this.domElement.removeEventListener("wheel", this._onWheel, { capture: true });
+    } catch (_) {
+      try {
+        // fallback для браузеров/реализаций, которые игнорируют options при remove
+        this.domElement.removeEventListener("wheel", this._onWheel);
+      } catch (_) {}
+    }
+  }
+
+  #handleWheel(e) {
+    if (!this.isEnabled()) return;
+    const camera = this.getCamera?.();
+    const controls = this.getControls?.();
+    if (!camera || !controls) return;
+
+    // Предотвратить скролл страницы и работу OrbitControls (у него свой wheel listener)
+    e.preventDefault();
+    e.stopPropagation();
+    // eslint-disable-next-line no-undef
+    if (typeof e.stopImmediatePropagation === "function") e.stopImmediatePropagation();
+
+    const rect = this.domElement.getBoundingClientRect?.();
+    if (!rect || rect.width <= 0 || rect.height <= 0) return;
+
+    // --- NDC курсора ---
+    const x = ((e.clientX - rect.left) / rect.width) * 2 - 1;
+    const y = -(((e.clientY - rect.top) / rect.height) * 2 - 1);
+    this._ndc.set(x, y);
+
+    // --- нормализуем deltaY для разных режимов прокрутки ---
+    let dy = e.deltaY;
+    if (e.deltaMode === 1) dy *= 16;     // lines -> px (примерно)
+    else if (e.deltaMode === 2) dy *= 100; // pages -> px (грубо)
+
+    const zoomSpeed = Number(controls.zoomSpeed ?? 1);
+    const speed = Number.isFinite(zoomSpeed) ? zoomSpeed : 1;
+    // scale > 1 => zoom out, scale < 1 => zoom in
+    let scale = Math.exp(dy * 0.002 * speed);
+    // защита от экстремальных значений
+    scale = Math.min(5, Math.max(0.2, scale));
+
+    // --- Опорная плоскость: hit по модели, иначе плоскость через target ---
+    // ВАЖНО: для "пролёта" внутрь здания нам нельзя зависеть от ближайшей стены.
+    // Поэтому при попытке приблизиться дальше minDistance мы используем target-plane,
+    // а "излишек" приближения превращаем в поступательное движение вперёд (camera+target).
+    const pickRoot = this.getPickRoot?.();
+    let anchor = null;
+    let source = "target-plane";
+    const flyMinEps = 1e-6;
+
+    // Определим, упёрлись ли мы в minDistance и пытаемся приблизиться ещё
+    let distToTargetNow = null;
+    let minDNow = null;
+    let wantFlyForward = false;
+    if (camera.isPerspectiveCamera) {
+      distToTargetNow = camera.position.distanceTo(controls.target);
+      minDNow = controls.minDistance || 0.01;
+      // scale < 1 => приближение
+      const desired = distToTargetNow * scale;
+      wantFlyForward = scale < 1 && desired < (minDNow - flyMinEps);
+    }
+
+    // 1) пробуем попадание по модели (только если не в режиме fly-forward)
+    if (pickRoot && !wantFlyForward) {
+      this._raycaster.setFromCamera(this._ndc, camera);
+      const hits = this._raycaster.intersectObject(pickRoot, true);
+      if (hits && hits.length > 0 && hits[0] && hits[0].point) {
+        anchor = this._vA.copy(hits[0].point);
+        source = "model-hit";
+      }
+    }
+
+    // 2) если по модели не попали — используем target как точку на плоскости
+    if (!anchor) {
+      anchor = this._vA.copy(controls.target);
+      if (wantFlyForward) source = "fly-target";
+    }
+
+    // Для корректной диагностики проекций/лучей обновим матрицы (не меняет поведения)
+    try { camera.updateMatrixWorld?.(true); } catch (_) {}
+
+    // Плоскость перпендикулярна направлению взгляда.
+    // ВАЖНО: при сильном приближении камера может "пересечь" плоскость через anchor,
+    // и ray.intersectPlane() начнёт возвращать null (пересечение "позади" луча),
+    // что раньше полностью "останавливало" зум. Поэтому:
+    // - сначала пробуем anchor-plane
+    // - если не получилось — переключаемся на fallback-plane перед камерой
+    // - если всё равно не получилось — продолжаем зум БЕЗ cursor-компенсации (но зум не замирает)
+    camera.getWorldDirection(this._vDir).normalize();
+    let planeKind = "anchor-plane";
+    this._plane.setFromNormalAndCoplanarPoint(this._vDir, anchor);
+
+    // Точка под курсором ДО зума (пересечение луча курсора с плоскостью)
+    this._raycaster.setFromCamera(this._ndc, camera);
+    let okBefore = this._raycaster.ray.intersectPlane(this._plane, this._vBefore);
+
+    if (!okBefore) {
+      // Fallback-plane: гарантированно "перед" камерой по направлению взгляда
+      planeKind = "camera-plane";
+      const distToTarget = camera.position.distanceTo(controls.target);
+      const depth = Math.max(0.01, (camera.near || 0.01) * 2, distToTarget);
+      const p = this._vC.copy(camera.position).add(this._vB.copy(this._vDir).multiplyScalar(depth));
+      this._plane.setFromNormalAndCoplanarPoint(this._vDir, p);
+      okBefore = this._raycaster.ray.intersectPlane(this._plane, this._vBefore);
+    }
+
+    const canCompensate = !!okBefore;
+
+    // Диагностика: посчитаем дрейф anchor в пикселях (до/после) — то, что вы визуально наблюдаете
+    let debugPayload = null;
+    if (this.isDebug()) {
+      const anchorNdc0 = this._vB.copy(anchor).project(camera);
+      const driftPx0 = {
+        dx: (anchorNdc0.x - this._ndc.x) * (rect.width / 2),
+        dy: (anchorNdc0.y - this._ndc.y) * (rect.height / 2),
+      };
+      debugPayload = {
+        src: source,
+        mode: camera.isOrthographicCamera ? "ortho" : "perspective",
+        plane: planeKind,
+        canCompensate,
+        dy,
+        scale: +scale.toFixed(4),
+        cursorNdc: { x: +this._ndc.x.toFixed(4), y: +this._ndc.y.toFixed(4) },
+        anchorWorld: { x: +anchor.x.toFixed(3), y: +anchor.y.toFixed(3), z: +anchor.z.toFixed(3) },
+        anchorNdcBefore: { x: +anchorNdc0.x.toFixed(4), y: +anchorNdc0.y.toFixed(4), z: +anchorNdc0.z.toFixed(4) },
+        anchorDriftPxBefore: { dx: +driftPx0.dx.toFixed(2), dy: +driftPx0.dy.toFixed(2) },
+        viewDir: { x: +this._vDir.x.toFixed(4), y: +this._vDir.y.toFixed(4), z: +this._vDir.z.toFixed(4) },
+        rayDir: {
+          x: +this._raycaster.ray.direction.x.toFixed(4),
+          y: +this._raycaster.ray.direction.y.toFixed(4),
+          z: +this._raycaster.ray.direction.z.toFixed(4),
+        },
+        camPosBefore: {
+          x: +camera.position.x.toFixed(3),
+          y: +camera.position.y.toFixed(3),
+          z: +camera.position.z.toFixed(3),
+        },
+        targetBefore: {
+          x: +controls.target.x.toFixed(3),
+          y: +controls.target.y.toFixed(3),
+          z: +controls.target.z.toFixed(3),
+        },
+      };
+    }
+
+    const t0 = this.isDebug() ? performance.now() : 0;
+
+    // --- Применяем зум ---
+    if (camera.isOrthographicCamera) {
+      const minZ = controls.minZoom ?? 0.01;
+      const maxZ = controls.maxZoom ?? 100;
+      const curr = camera.zoom || 1;
+      const next = curr / scale; // scale>1 => zoom out (уменьшаем zoom)
+      camera.zoom = Math.min(Math.max(next, minZ), maxZ);
+      camera.updateProjectionMatrix();
+    } else {
+      const target = controls.target;
+      const camPos = camera.position;
+      const dir = this._vB.copy(camPos).sub(target).normalize(); // от target к камере
+      const dist = camPos.distanceTo(target);
+      const minD = controls.minDistance || 0.01;
+      const maxD = controls.maxDistance || Infinity;
+      const desiredDist = dist * scale; // scale>1 => zoom out (увеличиваем дистанцию), scale<1 => zoom in
+      let nextDist = Math.min(Math.max(desiredDist, minD), maxD);
+
+      // Базовый dolly до minDistance
+      camPos.copy(this._vC.copy(target).add(dir.multiplyScalar(nextDist)));
+
+      // Fly-through: преднамеренный "пролёт" дальше minDistance (только на zoom-in)
+      // Излишек приближения превращаем в движение вперёд (camera+target) вдоль направления взгляда.
+      // Это снимает "упор" в minDistance и позволяет проходить через стены/внутрь помещений.
+      if (scale < 1 && desiredDist < minD - flyMinEps) {
+        const forward = this._vC.copy(target).sub(camPos).normalize(); // от камеры к target
+        const leftover = (minD - desiredDist);
+        // Сдвигаем и камеру, и target: дистанция остаётся minD, но мы "летим" вперёд
+        camPos.add(this._vA.copy(forward).multiplyScalar(leftover));
+        target.add(this._vA.copy(forward).multiplyScalar(leftover));
+        camera.updateProjectionMatrix();
+      }
+      camera.updateProjectionMatrix();
+    }
+
+    // Матрицы могли устареть после изменения позиции/zoom
+    try { camera.updateMatrixWorld?.(true); } catch (_) {}
+
+    // --- Компенсация: чтобы точка на плоскости осталась под курсором ---
+    let didCompensate = false;
+    if (canCompensate) {
+      this._raycaster.setFromCamera(this._ndc, camera);
+      const okAfter = this._raycaster.ray.intersectPlane(this._plane, this._vAfter);
+      if (okAfter) {
+        const delta = this._vC.copy(this._vBefore).sub(this._vAfter);
+        camera.position.add(delta);
+        controls.target.add(delta);
+        didCompensate = true;
+      } else {
+        // Нельзя компенсировать на этом шаге (например, камера пересекла плоскость) —
+        // но зум уже применён, поэтому не останавливаемся.
+        didCompensate = false;
+      }
+    }
+
+    controls.update();
+    if (this.onZoomChanged) this.onZoomChanged(true);
+
+    if (this.isDebug()) {
+      const ms = performance.now() - t0;
+      const anchorNdc1 = this._vB.copy(anchor).project(camera);
+      const driftPx1 = {
+        dx: (anchorNdc1.x - this._ndc.x) * (rect.width / 2),
+        dy: (anchorNdc1.y - this._ndc.y) * (rect.height / 2),
+      };
+      const out = debugPayload || {};
+      out.dtMs = +ms.toFixed(2);
+      out.didCompensate = didCompensate;
+      out.anchorNdcAfter = { x: +anchorNdc1.x.toFixed(4), y: +anchorNdc1.y.toFixed(4), z: +anchorNdc1.z.toFixed(4) };
+      out.anchorDriftPxAfter = { dx: +driftPx1.dx.toFixed(2), dy: +driftPx1.dy.toFixed(2) };
+      out.camPosAfter = {
+        x: +camera.position.x.toFixed(3),
+        y: +camera.position.y.toFixed(3),
+        z: +camera.position.z.toFixed(3),
+      };
+      out.targetAfter = {
+        x: +controls.target.x.toFixed(3),
+        y: +controls.target.y.toFixed(3),
+        z: +controls.target.z.toFixed(3),
+      };
+      out.zoom = camera.isOrthographicCamera ? +(camera.zoom || 1).toFixed(4) : null;
+      // eslint-disable-next-line no-console
+      console.log("[ZoomToCursor]", out);
+    }
+  }
+}
+
+