editor3d.js

// ══════════════════════════════════════════════════════════════════════════
// editor3d.js — редактирование благоустройства ПРЯМО В 3D-СЦЕНЕ
//
// Версия 3D-UI: 2D-план убран, разметка и выбор объектов происходят в сцене.
// Модуль отвечает за:
//   • перевод курсора в координаты плана (луч в сцену → мир → worldToCanvas);
//   • выбор объекта активного раздела кликом и снятие выбора кликом по пустому;
//   • перетаскивание: террасу за углы и за тело, лестницу за середину и за
//     боковые маркеры, грядку и мебель за тело плюс ручка поворота на 90°,
//     точки ломаных и маркеры входа в ограждение;
//   • рисование дорожек и забора ОТРЕЗКАМИ: клик — начало, второй клик — конец;
//     клик по существующей точке склеивает отрезки в одну ломаную;
//   • подсветку выбранного объекта, маркеры и ручки;
//   • сетку 1 м на земле (снап при этом прежний, SNAP = 0.25 м);
//   • оверлей с размерами и площадями, пока раздел открыт.
//
// Вся геометрия считается в НОРМИРОВАННЫХ координатах плана (0..1 на сетке
// GRID×GRID м) — тех же, в которых работали canvas-редакторы. Поэтому снап,
// прилипание к дому и к столбам ограждения, нормализация лестницы и повороты
// переиспользуются из canvas.js как есть, а не пишутся заново.
//
// Разделение кнопок мыши (решение по ТЗ, вариант «а»):
//   ЛКМ по объекту своего раздела — выбор и перетаскивание,
//   ЛКМ по пустому месту       — орбита камеры (OrbitControls),
//   ПКМ — панорама, колесо — зум (как было).
// Клик по объекту ЧУЖОГО раздела игнорируется: активный раздел меняют только
// кнопки левой панели.
//
// Зависимости: Three.js r128, state.js (S, RECT_SECTIONS, secRects…),
// canvas.js (GRID, SNAP — геометрические константы плана),
// viewer3d-builders.js (worldToCanvas / canvasToWorld / lastHouseSize),
// viewer3d-core.js (threeState).
// ══════════════════════════════════════════════════════════════════════════

const E3D_GRID_STEP  = 1.0;    // шаг ВИДИМОЙ сетки на земле, м (снап мельче — SNAP)
const E3D_PICK_R     = 0.45;   // радиус попадания по точке линии / мебели, м
const E3D_HANDLE_HIT = 0.40;   // радиус попадания по ручке, м
const E3D_HANDLE_R   = 0.20;   // радиус кружка ручки, м
const E3D_GLUE_R     = 0.45;   // клик ближе этого к существующей точке — склейка, м
// Все маркеры, контуры и ручки лежат НА ЗЕМЛЕ, на одной отметке. Раньше высота
// бралась лучом вниз, по поверхности под точкой, и угол террасы, попавший под
// свес крыши, получал отметку КРОВЛИ — маркер улетал на крышу, а контур тянулся
// к ней через весь дом. Разметка и так плоская, поэтому единый уровень и
// нагляднее, и не зависит от того, что под точкой. Глубину слой не проверяет
// (depthTest: false), так что маркеры под настилом остаются видимыми.
const E3D_LIFT       = 0.03;   // подъём слоя редактора над землёй, м
const E3D_MOVE_TOL   = 4;      // px: дальше этого — это протяжка, а не клик

// Разделы по типу разметки. От типа зависит и хит-тест, и вид подсветки.
const E3D_KIND = {
  terrace:      'rect',
  pool_terrace: 'rect',
  steps:        'steps',
  beds:         'beds',
  furniture:    'point',
  paths:        'line',
  fence:        'line',
  railing:      'railing',   // строится по террасе — таскаются только маркеры входа
  facade:       'facade',    // выбор сегментов стен кликом по самим мешам
  facade2:      'facade',    // вторая отделка: та же механика, свой набор кусков
};

// Палец толще курсора: на телефоне все радиусы попадания растягиваются (режим
// включает nav-mobile.js через e3dSetTouch). Ручка на экране остаётся прежнего
// размера — растёт только зона, которая её ловит.
const E3D_TOUCH_R = 1.8;

// Радиусы заданы в метрах, а хватается пользователь за пиксели: с видом сверху
// на весь участок камера уходит на 60+ м, и ручка в 0.2 м превращается в точку
// размером с курсор. Коэффициент держит маркеры и зоны попадания примерно того
// же экранного размера, под какой они подбирались с обычной дистанции.
const E3D_VIEW_REF = 24;    // м — дистанция, на которую рассчитаны радиусы
const E3D_VIEW_MAX = 2.6;   // потолок: вблизи ручки не должны разрастаться

function _e3dViewScale() {
  if (typeof threeState === 'undefined' || !threeState
      || !threeState.camera || !threeState.controls) return 1;
  const d = threeState.camera.position.distanceTo(threeState.controls.target);
  return Math.min(E3D_VIEW_MAX, Math.max(1, d / E3D_VIEW_REF));
}

function _e3dR(r) { return r * (E3D.touch ? E3D_TOUCH_R : 1) * _e3dViewScale(); }

const E3D = {
  sec:   null,   // активный раздел («terrace», «paths», …) или null
  touch: false,  // мобильный режим: жесты пальцем вместо мыши
  group: null,   // THREE.Group: сетка, подсветка, маркеры, ручки
  grid:  null,   // THREE.GridHelper — живёт внутри group
  press: null,   // {x, y, hit, np} — состояние между pointerdown и pointerup
  drag:  null,   // {kind, idx, handle, start, from} — идущее перетаскивание
  draw:  null,   // {name, start} — начатый, но не законченный отрезок линии
  bound: false,  // слушатели уже навешаны на канвас рендерера
};

// Выбранная точка ломаной хранится в _lineSel (canvas.js) — на неё завязаны
// delLinePoint и удаление калитки, поэтому второго источника не заводим.

// ── Мир ⇄ план ───────────────────────────────────────────────────────────
// Обе стороны берут габариты дома из последней сборки сцены — теми же
// значениями считает и 3D, значит план и сцена не разъезжаются.

function _e3dToNorm(x, z) {
  const sz = (typeof lastHouseSize === 'function') ? lastHouseSize() : { L: 0, W: 0 };
  return worldToCanvas([{ x, z }], sz.L, sz.W)[0];
}

function _e3dToWorld(p) {
  const sz = (typeof lastHouseSize === 'function') ? lastHouseSize() : { L: 0, W: 0 };
  return canvasToWorld([p], sz.L, sz.W)[0];
}

// ── Луч в сцену ──────────────────────────────────────────────────────────
// Берём ПЕРВОЕ пересечение с геометрией сцены (настил, ступени, земля…) и
// переводим точку попадания в координаты плана. Так клик по приподнятой
// террасе попадает именно в её прямоугольник, а не в землю под ней.

const _e3dRay = new THREE.Raycaster();
const _e3dNdc = new THREE.Vector2();
const _e3dGroundPlane = new THREE.Plane(new THREE.Vector3(0, 1, 0), 0);

function _e3dPickTargets() {
  if (!threeState) return [];
  const skip = new Set([threeState.skyMesh, E3D.group].filter(Boolean));
  return threeState.scene.children.filter(o => o.visible && !skip.has(o));
}

// Экранные координаты события → {norm:{x,y}, world:{x,y,z}} или null.
// norm ВСЕГДА считается по плоскости земли: там же лежит весь слой редактора
// (контуры и маркеры, E3D_LIFT), поэтому курсор и маркер совпадают. Раньше norm
// брался с первой попавшейся геометрии, и над настилом террасы точка плана
// уезжала на высоту настила: ручка размера бассейна, нарисованная на земле, не
// бралась «сквозь» настил, а перетаскивание прыгало при сходе с настила.
// object/world — то, во что реально попал луч: нужны там, где выбор идёт по
// самой модели (отделка фасада, садовая мебель).
function _e3dPointAt(ev) {
  if (!threeState || !threeState.renderer) return null;
  const el = threeState.renderer.domElement;
  const r = el.getBoundingClientRect();
  _e3dNdc.x =  ((ev.clientX - r.left) / r.width)  * 2 - 1;
  _e3dNdc.y = -((ev.clientY - r.top)  / r.height) * 2 + 1;
  _e3dRay.setFromCamera(_e3dNdc, threeState.camera);

  const gp = new THREE.Vector3();
  const onGround = !!_e3dRay.ray.intersectPlane(_e3dGroundPlane, gp);
  const hits = _e3dRay.intersectObjects(_e3dPickTargets(), true);
  const object = hits.length ? hits[0].object : null;
  const world = hits.length ? hits[0].point : (onGround ? gp : null);
  if (!world) return null;                      // луч в небо мимо всей геометрии
  const n = onGround ? gp : world;              // взгляд снизу вверх — берём саму геометрию
  return { world, object, norm: _e3dToNorm(n.x, n.z) };
}

// ── Хит-тесты в координатах плана (0..1) ─────────────────────────────────

function _e3dInRect(np, r) {
  return np.x >= r.x && np.x <= r.x + r.w && np.y >= r.y && np.y <= r.y + r.h;
}

// Прямоугольники: сначала активный (он сверху), потом остальные.
function _e3dHitRects(list, act, np) {
  if (act !== null && act !== undefined && list[act] && _e3dInRect(np, list[act])) return act;
  for (let i = 0; i < list.length; i++) if (_e3dInRect(np, list[i])) return i;
  return null;
}

// Точка ломаной, а если мимо точек — ближайший сегмент (для вставки в PR2).
function _e3dHitLine(name, np) {
  const pts = S.pts[name] || [];
  const r = _e3dR(E3D_PICK_R) / GRID;
  let best = r, idx = null;
  pts.forEach((q, i) => {
    if (q.break) return;
    const d = Math.hypot(q.x - np.x, q.y - np.y);
    if (d < best) { best = d; idx = i; }
  });
  return idx;
}

function _e3dHitPoints(list, np) {
  const r = _e3dR(E3D_PICK_R) / GRID;
  let best = r, idx = null;
  (list || []).forEach((q, i) => {
    const d = Math.hypot(q.x - np.x, q.y - np.y);
    if (d < best) { best = d; idx = i; }
  });
  return idx;
}

// Ручки выбранного объекта: углы прямоугольника, боковины лестницы, поворот.
// Возвращают массив [{ handle, np }] в координатах плана.
function _e3dRectHandles(r) {
  return [
    { handle: 'nw', np: { x: r.x,       y: r.y       } },
    { handle: 'ne', np: { x: r.x + r.w, y: r.y       } },
    { handle: 'sw', np: { x: r.x,       y: r.y + r.h } },
    { handle: 'se', np: { x: r.x + r.w, y: r.y + r.h } },
  ];
}

// У лестницы ширину меняют ТОЛЬКО боковые маркеры: глубину считает
// _stepsNormalize по высоте подъёма, тянуть её незачем. Боковые — те две
// стороны, что поперёк спуска.
function _e3dStepsHandles(s) {
  const alongX = s.w >= s.h;                       // спуск по Y → ширина по X
  return alongX
    ? [{ handle: 'nw', np: { x: s.x,       y: s.y + s.h / 2 } },
       { handle: 'ne', np: { x: s.x + s.w, y: s.y + s.h / 2 } }]
    : [{ handle: 'nw', np: { x: s.x + s.w / 2, y: s.y       } },
       { handle: 'sw', np: { x: s.x + s.w / 2, y: s.y + s.h } }];
}

// Грядка и мебель поворачиваются на 90° КЛИКОМ по себе — отдельной ручки у них
// нет: объекты мелкие, и ручка рядом с ними только мешала прицелиться.

// Бассейн лежит ПОВЕРХ настила и в редакторе не отзывался вовсе: у раздела
// проверялись только прямоугольники террасы. Тянется за тело, размер — за
// нижний правый угол; у круглого бассейна габарит остаётся квадратным.
const E3D_POOL_MIN = 1.0;   // минимальный габарит бассейна, м

function _e3dHitPool(np) {
  const p = S.pool;
  if (!p) return null;
  const r = _e3dR(E3D_HANDLE_HIT) / GRID;
  if (Math.hypot(np.x - (p.x + p.w), np.y - (p.y + p.h)) < r) return { kind: 'pool', idx: 0, handle: 'resize' };
  if (p.kind === 'round') {
    const cx = p.x + p.w / 2, cy = p.y + p.h / 2;
    return (Math.hypot(np.x - cx, np.y - cy) <= p.w / 2) ? { kind: 'pool', idx: 0, handle: 'move' } : null;
  }
  return (np.x >= p.x && np.x <= p.x + p.w && np.y >= p.y && np.y <= p.y + p.h)
    ? { kind: 'pool', idx: 0, handle: 'move' } : null;
}

// Контур бассейна в координатах плана: прямоугольник как есть, круглый —
// многоугольником (в 3D он тоже строится многоугольником).
function _e3dPoolOutline(p) {
  if (p.kind !== 'round') return _e3dRectPts(p);
  const cx = p.x + p.w / 2, cy = p.y + p.h / 2, R = p.w / 2;
  const out = [];
  for (let i = 0; i < 32; i++) {
    const a = i / 32 * Math.PI * 2;
    out.push({ x: cx + Math.cos(a) * R, y: cy + Math.sin(a) * R });
  }
  return out;
}

function _e3dHitHandles(list, np) {
  const r = _e3dR(E3D_HANDLE_HIT) / GRID;
  let best = r, hit = null;
  for (const h of list) {
    const d = Math.hypot(h.np.x - np.x, h.np.y - np.y);
    if (d < best) { best = d; hit = h.handle; }
  }
  return hit;
}

// Маркеры входа в ограждение: пара точек на петле, каждую можно таскать.
function _e3dHitEntry(np) {
  if (typeof railingEntryPointsNorm !== 'function') return null;
  const r = _e3dR(E3D_HANDLE_HIT) / GRID;
  let best = r, hit = null;
  for (const e of railingEntryPointsNorm()) {
    for (const [k, q] of [[0, e.a], [1, e.b]]) {
      const d = Math.hypot(q.x - np.x, q.y - np.y);
      if (d < best) { best = d; hit = { kind: 'entry', idx: e.li, handle: k }; }
    }
  }
  return hit;
}

// Индекс предмета мебели под объектом, в который попал луч: модель лежит в
// пивоте, помеченном furnIdx (buildFurniture3d), а луч приходит в её меш.
function _e3dFurnIdxOf(obj) {
  for (let o = obj; o; o = o.parent) {
    if (o.userData && typeof o.userData.furnIdx === 'number') return o.userData.furnIdx;
  }
  return null;
}

// Элемент фасада под объектом, в который попал луч: id стоит на группе-модуле,
// а луч приходит в её меш, поэтому поднимаемся по родителям.
function _e3dFacadeIdOf(obj) {
  for (let o = obj; o; o = o.parent) {
    if (o.userData && o.userData.segId) return o.userData.segId;
  }
  return null;
}

// Что под курсором в АКТИВНОМ разделе? → {kind, idx, handle} или null.
// Ручки выбранного объекта имеют приоритет над телом — иначе за угол не
// ухватиться, клик всегда попадал бы в прямоугольник.
function e3dHitTest(np, object) {
  const sec = E3D.sec;
  if (!sec) return null;
  const kind = E3D_KIND[sec];

  if (kind === 'facade') {
    const id = object ? _e3dFacadeIdOf(object) : null;
    return id ? { kind, idx: id, handle: 'toggle' } : null;
  }
  if (!np) return null;

  // Бассейн проверяем ПЕРВЫМ: он лежит поверх настила своей террасы.
  if (sec === 'pool_terrace') {
    const hit = _e3dHitPool(np);
    if (hit) return hit;
  }

  if (kind === 'rect' || kind === 'steps' || kind === 'beds') {
    const list = kind === 'rect' ? secRects(sec)
               : kind === 'steps' ? (S.stepsList || [])
               : (S.beds || []);
    const act = kind === 'rect' ? secActiveIdx(sec)
              : kind === 'steps' ? S.activeSteps : S.activeBed;
    // Ручки есть только у прямоугольников и лестницы — у грядки её нет.
    const cur = (act !== null && act !== undefined && kind !== 'beds') ? list[act] : null;
    if (cur) {
      const handles = kind === 'rect' ? _e3dRectHandles(cur) : _e3dStepsHandles(cur);
      const h = _e3dHitHandles(handles, np);
      if (h) return { kind, idx: act, handle: h };
    }
    const i = _e3dHitRects(list, act, np);
    return i === null ? null : { kind, idx: i, handle: 'move' };
  }

  if (kind === 'point') {
    // Сначала — по самой модели: у составных комплектов (стол со стульями)
    // кружок вокруг точки покрывал лишь малую часть предмета, и попасть по
    // стулу было нельзя. Радиус вокруг точки остаётся запасным вариантом —
    // он ловит клик, пока модель ещё грузится.
    const byMesh = object ? _e3dFurnIdxOf(object) : null;
    if (byMesh !== null) return { kind, idx: byMesh, handle: 'move' };
    const i = _e3dHitPoints(S.furniture || [], np);
    return i === null ? null : { kind, idx: i, handle: 'move' };
  }

  if (kind === 'railing') return _e3dHitEntry(np);

  if (kind === 'line') {
    if (sec === 'fence' && typeof _gateHit === 'function' && _gateHit(np)) {
      return { kind, idx: 'gate', handle: 'move' };
    }
    const i = _e3dHitLine(sec, np);
    return i === null ? null : { kind, idx: i, handle: 'move' };
  }
  return null;
}

// ── Выбор ────────────────────────────────────────────────────────────────

function e3dSelect(hit) {
  const sec = E3D.sec;
  if (!sec) return;
  const idx = hit ? hit.idx : null;
  const kind = E3D_KIND[sec];
  if (kind === 'facade') {
    // Мультивыбор: повторный клик снимает. Клик мимо стены не трогает выбранное —
    // иначе один промах сбрасывал бы всю отделку.
    if (idx === null) return;
    const mine = facadeZones(sec);
    if (mine[idx]) delete mine[idx];
    else {
      mine[idx] = true;
      // Отделок две, и кусок принадлежит одной: взяли его во вторую — из первой
      // он уходит, иначе на одном месте лежали бы два материала.
      delete facadeZones(facadeOtherSec(sec))[idx];
    }
    if (typeof _applyFacadeSelection === 'function') _applyFacadeSelection();
    e3dSync();
    return;
  }
  if (kind === 'rect')       setSecActiveIdx(sec, idx);
  else if (kind === 'steps') { if (idx !== null) S.activeSteps = idx; }
  else if (kind === 'beds')  S.activeBed = idx;
  else if (kind === 'point') S.activeFurniture = idx;
  else if (kind === 'line')  _lineSel = { name: sec, idx };
  e3dSync();
  if (typeof _dSyncSectionActions === 'function') _dSyncSectionActions();
}

// Индекс выбранного объекта активного раздела (null — ничего не выбрано).
function e3dSelectedIdx() {
  const sec = E3D.sec;
  if (!sec) return null;
  const kind = E3D_KIND[sec];
  if (kind === 'rect')  return secActiveIdx(sec);
  if (kind === 'steps') return S.activeSteps;
  if (kind === 'beds')  return S.activeBed;
  if (kind === 'point') return S.activeFurniture;
  if (kind === 'line')  return (_lineSel.name === sec) ? _lineSel.idx : null;
  if (kind === 'railing') return null;   // отдельных объектов нет — только вход
  if (kind === 'facade')  return null;   // выбор мультиэлементный, в S.wallZones
  return null;
}

// ── Подсветка, маркеры и сетка ───────────────────────────────────────────

function _e3dEnsureGroup() {
  if (!threeState) return null;
  if (!E3D.group || E3D.group.parent !== threeState.scene) {
    E3D.group = new THREE.Group();
    E3D.group.name = 'editor3d';
    E3D.group.renderOrder = 999;
    threeState.scene.add(E3D.group);
    E3D.grid = null;
  }
  return E3D.group;
}

function _e3dClearGroup() {
  const g = _e3dEnsureGroup();
  if (!g) return null;
  for (let i = g.children.length - 1; i >= 0; i--) {
    const o = g.children[i];
    g.remove(o);
    if (o === E3D.grid) continue;               // сетку переиспользуем
    if (o.geometry) o.geometry.dispose();
    if (o.material) o.material.dispose();
  }
  return g;
}

// Разметка редактора — интерфейс, а не предмет в сцене: тональная кривая рендера
// (ACES) её не трогает, цвета на экране — ровно цвета интерфейса (правка 2026-10-08;
// раньше оранжевый выбора выходил грязно-жёлтым #dab05e, белые ручки — серыми).
function _e3dLineMat(color, width) {
  return new THREE.LineBasicMaterial({
    color, linewidth: width || 1, depthTest: false, transparent: true, opacity: 0.95,
    toneMapped: false,
  });
}

// Замкнутый контур по точкам плана, положенный на поверхность.
function _e3dOutline(pts, color, closed) {
  const v = pts.map(p => {
    const w = _e3dToWorld(p);
    return new THREE.Vector3(w.x, E3D_LIFT, w.z);
  });
  if (closed && v.length) v.push(v[0].clone());
  const geo = new THREE.BufferGeometry().setFromPoints(v);
  const line = new THREE.Line(geo, _e3dLineMat(color, 2));
  line.renderOrder = 999;
  return line;
}

// Маркер точки: кружок на поверхности.
function _e3dMarker(np, color, radius) {
  const w = _e3dToWorld(np);
  const y = E3D_LIFT;
  const geo = new THREE.CircleGeometry(radius || 0.18, 20);
  const mesh = new THREE.Mesh(geo, new THREE.MeshBasicMaterial({
    color, depthTest: false, transparent: true, opacity: 0.9, side: THREE.DoubleSide,
    toneMapped: false,
  }));
  mesh.rotation.x = -Math.PI / 2;
  mesh.position.set(w.x, y, w.z);
  mesh.renderOrder = 1000;
  // Размер кружка догоняет камеру покадрово (_e3dScaleMarkers): пересобирать
  // слой на каждый поворот колеса ради этого не стоит.
  mesh.userData.e3dMarker = true;
  mesh.scale.setScalar(_e3dViewScale());
  return mesh;
}

// Маркеры масштабируются вокруг собственного центра, поэтому позиции не едут.
function _e3dScaleMarkers() {
  if (!E3D.group) return;
  const k = _e3dViewScale();
  E3D.group.traverse(o => { if (o.userData && o.userData.e3dMarker) o.scale.setScalar(k); });
}

function _e3dRectPts(r) {
  return [
    { x: r.x,       y: r.y       },
    { x: r.x + r.w, y: r.y       },
    { x: r.x + r.w, y: r.y + r.h },
    { x: r.x,       y: r.y + r.h },
  ];
}

const E3D_COL_SEL  = 0xff7a1a;   // выбранный объект — оранжевый, как акцент интерфейса
// Прочие объекты раздела — приглушённый зелёный. Значение — то, что раньше было
// видно на экране (0x2f6f3f проходил через высветление и ACES и выглядел так).
const E3D_COL_IDLE = 0x73a782;

// Сетка 1 м: видна, пока открыт раздел с разметкой на земле.
function _e3dSyncGrid(show) {
  const g = _e3dEnsureGroup();
  if (!g) return;
  if (!show) { if (E3D.grid) E3D.grid.visible = false; return; }
  if (!E3D.grid) {
    const div = Math.round(GRID / E3D_GRID_STEP);
    // Цвета — видимые раньше (0x8a8a8a / 0xb9b9b9 после высветления и ACES).
    E3D.grid = new THREE.GridHelper(GRID, div, 0xb6b6b6, 0xc7c7c7);
    E3D.grid.material.toneMapped = false;
    E3D.grid.material.transparent = true;
    E3D.grid.material.opacity = 0.35;
    E3D.grid.material.depthWrite = false;
  }
  const c = _e3dToWorld({ x: 0.5, y: 0.5 });
  E3D.grid.position.set(c.x, 0.012, c.z);
  E3D.grid.visible = true;
  if (E3D.grid.parent !== g) g.add(E3D.grid);
}

const E3D_COL_HANDLE = 0xffffff;   // ручки — белые кружки с оранжевым контуром

// Ручка: белый кружок в обводке, чтобы читался и на настиле, и на траве.
function _e3dHandle(np) {
  const g = new THREE.Group();
  g.add(_e3dMarker(np, E3D_COL_SEL, E3D_HANDLE_R));
  g.add(_e3dMarker(np, E3D_COL_HANDLE, E3D_HANDLE_R * 0.62));
  return g;
}

// Полная перерисовка слоя редактора: подсветка + маркеры + ручки + сетка + оверлей.
function e3dSync() {
  if (!threeState || typeof worldToCanvas !== 'function') return;
  const g = _e3dClearGroup();
  if (!g) return;
  const sec = E3D.sec;
  _e3dSyncGrid(!!sec && E3D_KIND[sec] !== 'facade');
  if (!sec) { _e3dSyncOverlay(); return; }

  const kind = E3D_KIND[sec];
  const sel = e3dSelectedIdx();

  if (kind === 'rect' || kind === 'steps' || kind === 'beds') {
    const list = kind === 'rect' ? secRects(sec)
               : kind === 'steps' ? (S.stepsList || [])
               : (S.beds || []);
    list.forEach((r, i) => {
      if (!r || !(r.w > 0) || !(r.h > 0)) return;
      g.add(_e3dOutline(_e3dRectPts(r), i === sel ? E3D_COL_SEL : E3D_COL_IDLE, true));
    });
    if (sec === 'pool_terrace' && S.pool) {
      g.add(_e3dOutline(_e3dPoolOutline(S.pool), E3D_COL_SEL, true));
      g.add(_e3dHandle({ x: S.pool.x + S.pool.w, y: S.pool.y + S.pool.h }));
    }
    const cur = (sel !== null && sel !== undefined && kind !== 'beds') ? list[sel] : null;
    if (cur && cur.w > 0 && cur.h > 0) {
      const handles = kind === 'rect' ? _e3dRectHandles(cur) : _e3dStepsHandles(cur);
      for (const h of handles) g.add(_e3dHandle(h.np));
    }
  } else if (kind === 'point') {
    // Маркер у мебели нужен ТОЛЬКО пока её тащат: слой лежит на земле, и у
    // предмета, стоящего на террасе, кружок оказывается далеко под ним и сбивает
    // с толку. В покое предмет виден сам по себе, а при протяжке кружок
    // показывает точку на земле, куда он встанет.
    const d = E3D.drag;
    if (d && d.kind === 'point' && (S.furniture || [])[d.idx]) {
      g.add(_e3dMarker(S.furniture[d.idx], E3D_COL_SEL, 0.22));
    }
  } else if (kind === 'railing') {
    // Ограждение считается по периметру террасы — рисуем только маркеры входа.
    if (typeof railingEntryPointsNorm === 'function') {
      for (const e of railingEntryPointsNorm()) {
        g.add(_e3dOutline([e.a, e.b], E3D_COL_SEL, false));
        g.add(_e3dHandle(e.a));
        g.add(_e3dHandle(e.b));
      }
    }
  } else if (kind === 'facade') {
    // Рамки выбора нужны, пока отделка НЕ назначена: без них не видно, что
    // отмечено. Как только товар выбран, панели видны сами, и разметка только
    // мешает — прячем. Снимут отделку («Удалить всё») — рамки вернутся.
    // Считается материал СВОЕГО раздела: у второй отделки он может быть ещё не
    // выбран, когда у первой уже есть.
    const zones = facadeZones(sec);
    const hasMat = !!(S.elementMat && S.elementMat[sec]);
    for (const seg of hasMat ? [] : (threeState.facadeSegs || [])) {
      if (!zones[seg.userData.segId]) continue;
      const box = new THREE.Box3().setFromObject(seg);
      const h = new THREE.Box3Helper(box, E3D_COL_SEL);
      h.material.depthTest = false;
      h.material.toneMapped = false;
      h.renderOrder = 999;
      g.add(h);
    }
  } else if (kind === 'line') {
    const pts = S.pts[sec] || [];
    // Ломаная рвётся на сегменты по служебным точкам-разрывам.
    const segs = (typeof splitAtBreaks === 'function') ? splitAtBreaks(pts) : [pts];
    for (const seg of segs) if (seg.length >= 2) g.add(_e3dOutline(seg, E3D_COL_IDLE, false));
    pts.forEach((p, i) => {
      if (p.break) return;
      g.add(_e3dMarker(p, i === sel ? E3D_COL_SEL : E3D_COL_IDLE, 0.16));
    });
    if (sec === 'fence' && S.fenceGate) {
      g.add(_e3dMarker(S.fenceGate, sel === 'gate' ? E3D_COL_SEL : E3D_COL_IDLE, 0.20));
    }
    // Начатый отрезок: точка старта и «резинка» до курсора.
    if (E3D.draw && E3D.draw.name === sec) {
      g.add(_e3dHandle(E3D.draw.start));
      if (E3D.draw.cursor) g.add(_e3dOutline([E3D.draw.start, E3D.draw.cursor], E3D_COL_SEL, false));
    }
  }
  _e3dSyncOverlay();
}

// ── Оверлей размеров и площадей ──────────────────────────────────────────
// HTML-плашки над канвасом: 3D-текст здесь неудобен (поворачивается вместе со
// сценой и мельчает вдали). Позиции пересчитываются каждый кадр — иначе
// подписи отстают от вращения камеры.

function _e3dOverlayEl() { return document.getElementById('d-3d-overlay'); }

// Что показывать в этом кадре: [{ text, corners }] — прямоугольник (подпись под
// ним), [{ text, a, b }] — отрезок (подпись сбоку), [{ text, np }] — точка.
let _e3dLabels = [];

function _fmtM3d(m) {
  return (Math.round(m * 100) / 100).toFixed(m < 10 ? 2 : 1).replace(/\.?0+$/, '') + ' м';
}

function _e3dSyncOverlay() {
  const host = _e3dOverlayEl();
  if (!host) return;
  _e3dLabels = [];
  const sec = E3D.sec;
  if (sec) {
    const kind = E3D_KIND[sec];
    if (kind === 'rect' || kind === 'steps' || kind === 'beds') {
      const list = kind === 'rect' ? secRects(sec)
                 : kind === 'steps' ? (S.stepsList || [])
                 : (S.beds || []);
      list.forEach(r => {
        if (!r || !(r.w > 0) || !(r.h > 0)) return;
        const wm = r.w * GRID, hm = r.h * GRID;
        const txt = kind === 'rect'
          ? `${_fmtM3d(wm)} × ${_fmtM3d(hm)}  ·  ${(wm * hm).toFixed(1)} м²`
          : `${_fmtM3d(wm)} × ${_fmtM3d(hm)}`;
        // Подпись ставится ПОД объектом, а не на нём: над центром она закрывала
        // угловые ручки, особенно у маленькой террасы и при виде сверху издалека.
        _e3dLabels.push({ text: txt, corners: [
          { x: r.x, y: r.y }, { x: r.x + r.w, y: r.y },
          { x: r.x + r.w, y: r.y + r.h }, { x: r.x, y: r.y + r.h }] });
      });
    } else if (kind === 'railing') {
      // Ширина разрыва — таким же числом, как остальные размеры: на глаз её было
      // не подобрать, а маркеры тянутся по периметру.
      if (typeof railingEntryPointsNorm === 'function') {
        for (const e of railingEntryPointsNorm()) {
          const len = Math.hypot(e.b.x - e.a.x, e.b.y - e.a.y) * GRID;
          if (len < 0.05) continue;
          _e3dLabels.push({ a: e.a, b: e.b, text: _fmtM3d(len) });
        }
      }
    } else if (kind === 'line') {
      const pts = S.pts[sec] || [];
      const segs = (typeof splitAtBreaks === 'function') ? splitAtBreaks(pts) : [pts];
      for (const seg of segs) {
        for (let i = 1; i < seg.length; i++) {
          const a = seg[i - 1], b = seg[i];
          const len = Math.hypot(b.x - a.x, b.y - a.y) * GRID;
          if (len < 0.3) continue;
          _e3dLabels.push({ a, b, text: _fmtM3d(len) });
        }
      }
    }
  }
  // Плашек столько же, сколько подписей — переиспользуем узлы, чтобы не дёргать DOM.
  while (host.children.length > _e3dLabels.length) host.removeChild(host.lastChild);
  while (host.children.length < _e3dLabels.length) {
    const d = document.createElement('div');
    d.className = 'd-3d-dim';
    host.appendChild(d);
  }
  _e3dLabels.forEach((l, i) => { host.children[i].textContent = l.text; });
  _e3dPlaceLabels();
}

// Проекция подписей в экранные координаты — вызывается и из кадра анимации.
const _e3dProj = new THREE.Vector3();

// Подписи НЕ садятся на сам объект (правка 2026-09-26): над центром они закрывали
// ручки. Прямоугольник подписывается под своим экранным габаритом (у края кадра —
// над ним), отрезок — сбоку, со сдвигом поперёк линии на экране. Зазор берётся
// с запасом на радиус ручки.
const E3D_LABEL_GAP = 14;   // px от объекта до края плашки

function _e3dScreen(np, W, H) {
  const w = _e3dToWorld(np);
  _e3dProj.set(w.x, E3D_LIFT, w.z).project(threeState.camera);   // та же отметка, что маркеры
  return { x: (_e3dProj.x * 0.5 + 0.5) * W, y: (-_e3dProj.y * 0.5 + 0.5) * H, behind: _e3dProj.z > 1 };
}

function _e3dPlaceLabels() {
  const host = _e3dOverlayEl();
  if (!host || !threeState || !_e3dLabels.length) return;
  const el = threeState.renderer.domElement;
  const W = el.clientWidth, H = el.clientHeight;
  _e3dLabels.forEach((l, i) => {
    const node = host.children[i];
    if (!node) return;
    const lw = node.offsetWidth || 0, lh = node.offsetHeight || 0;
    let cx, cy;
    if (l.corners) {
      const pts = l.corners.map(c => _e3dScreen(c, W, H));
      if (pts.some(p => p.behind)) { node.style.display = 'none'; return; }
      const xs = pts.map(p => p.x), ys = pts.map(p => p.y);
      cx = (Math.min(...xs) + Math.max(...xs)) / 2;
      const below = Math.max(...ys) + E3D_LABEL_GAP + lh / 2;
      const above = Math.min(...ys) - E3D_LABEL_GAP - lh / 2;
      cy = (below + lh / 2 <= H || above - lh / 2 < 0) ? below : above;
    } else if (l.a && l.b) {
      const pa = _e3dScreen(l.a, W, H), pb = _e3dScreen(l.b, W, H);
      if (pa.behind || pb.behind) { node.style.display = 'none'; return; }
      const dx = pb.x - pa.x, dy = pb.y - pa.y, len = Math.hypot(dx, dy) || 1;
      // Нормаль к отрезку на экране — в сторону «вниз» (или вправо у вертикали),
      // чтобы подписи вдоль ломаной ложились на одну сторону.
      let nx = -dy / len, ny = dx / len;
      if (ny < 0 || (Math.abs(ny) < 1e-3 && nx < 0)) { nx = -nx; ny = -ny; }
      // Сдвиг — на полгабарита плашки поперёк линии плюс зазор.
      const reach = Math.abs(nx) * lw / 2 + Math.abs(ny) * lh / 2 + E3D_LABEL_GAP;
      cx = (pa.x + pb.x) / 2 + nx * reach;
      cy = (pa.y + pb.y) / 2 + ny * reach;
    } else {
      const p = _e3dScreen(l.np, W, H);
      if (p.behind) { node.style.display = 'none'; return; }
      cx = p.x; cy = p.y;
    }
    node.style.display = '';
    node.style.left = cx + 'px';
    node.style.top  = cy + 'px';
  });
}

// ── Перетаскивание ───────────────────────────────────────────────────────
// Снап, прилипание к дому и к столбам, нормализация лестницы — из canvas.js:
// там та же система координат, и правила согласованы с 3D-сборкой.

function _e3dDragStart(hit, np) {
  const sec = E3D.sec;
  const kind = hit.kind;
  if (kind === 'rect' || kind === 'steps' || kind === 'beds') {
    const list = kind === 'rect' ? secRects(sec)
               : kind === 'steps' ? (S.stepsList || []) : (S.beds || []);
    const r = list[hit.idx];
    if (!r) return null;
    return { ...hit, from: { ...np }, start: { x: r.x, y: r.y, w: r.w, h: r.h } };
  }
  if (kind === 'point') {
    const p = (S.furniture || [])[hit.idx];
    return p ? { ...hit, from: { ...np }, start: { x: p.x, y: p.y } } : null;
  }
  if (kind === 'pool') {
    return S.pool ? { ...hit, from: { ...np }, start: { ...S.pool } } : null;
  }
  if (kind === 'entry') return { ...hit, from: { ...np } };
  if (kind === 'line') return { ...hit, from: { ...np }, mates: _e3dLineMates(sec, hit.idx) };
  return null;
}

function _e3dDragMove(np) {
  const d = E3D.drag, sec = E3D.sec;
  if (!d) return;
  const dx = np.x - d.from.x, dy = np.y - d.from.y;

  // Объект не проходит сквозь другие: положение, в котором он налез бы на дом
  // или на чужую разметку, просто не применяется — объект упирается и остаётся
  // на последнем допустимом месте (ТЗ п. 13). Касание при этом разрешено, на нём
  // держатся стык террас и примыкание лестницы.
  const blocked = (rect, secId, idx) =>
    (typeof rectCollides === 'function') && rectCollides(rect, secId, idx);

  if (d.kind === 'rect') {
    const r = secRects(sec)[d.idx];
    if (!r) return;
    const res = snapDraggedRect(d.handle, d.start, dx, dy, d.idx, sec);
    if (blocked(res, sec, d.idx)) return;
    r.x = res.x; r.y = res.y; r.w = res.w; r.h = res.h;
  } else if (d.kind === 'steps') {
    const st = (S.stepsList || [])[d.idx];
    if (!st) return;
    // excludeIdx = -1 — лестница снапается ко ВСЕМ террасам и стенам дома.
    const res = snapDraggedRect(d.handle, d.start, dx, dy, -1);
    const was = { x: st.x, y: st.y, w: st.w, h: st.h };
    st.x = res.x; st.y = res.y; st.w = res.w; st.h = res.h;
    _stepsNormalize();                       // глубину и разворот задаёт не пользователь
    _stepsSnapToRailPost(d.handle);          // «залипание» к столбу ограждения
    // Проверяем уже нормализованную лестницу: разворот и глубину ставит код, и
    // именно они решают, налезает ли она на соседей.
    if (blocked({ x: st.x, y: st.y, w: st.w, h: st.h }, 'steps', d.idx)) {
      st.x = was.x; st.y = was.y; st.w = was.w; st.h = was.h;
      return;
    }
  } else if (d.kind === 'beds') {
    const b = (S.beds || [])[d.idx];
    if (!b || d.handle !== 'move') return;
    const c = _clampBedPos(snapNorm(d.start.x + dx), snapNorm(d.start.y + dy), b.w, b.h);
    if (blocked({ x: c.x, y: c.y, w: b.w, h: b.h }, 'beds', d.idx)) return;
    b.x = c.x; b.y = c.y;
  } else if (d.kind === 'point') {
    const p = (S.furniture || [])[d.idx];
    if (!p || d.handle !== 'move') return;
    const q = { x: Math.max(0, Math.min(1, snapNorm(d.start.x + dx))),
                y: Math.max(0, Math.min(1, snapNorm(d.start.y + dy))) };
    // Мебель ходит по настилу и сквозь ограждение, но не сквозь стены дома.
    if (typeof furnitureCollides === 'function' && furnitureCollides(q, d.idx)) return;
    p.x = q.x;
    p.y = q.y;
    // Сама модель едет за курсором сразу: маркера под мебелью больше нет, и без
    // этого во время протяжки не было бы никакой обратной связи. Отметку по
    // высоте (настил террасы или земля) досчитает сборка на отпускании.
    const obj = (threeState.furnitureMeshes || [])[d.idx];
    if (obj) { const w = _e3dToWorld(p); obj.position.x = w.x; obj.position.z = w.z; }
  } else if (d.kind === 'pool') {
    if (!S.pool) return;
    const MIN = E3D_POOL_MIN / GRID;
    if (d.handle === 'move') {
      S.pool.x = snapNorm(d.start.x + dx);
      S.pool.y = snapNorm(d.start.y + dy);
    } else {
      let w = Math.max(MIN, snapNorm(d.start.w + dx));
      let h = Math.max(MIN, snapNorm(d.start.h + dy));
      if (S.pool.kind === 'round') { const sq = Math.max(w, h); w = sq; h = sq; }
      S.pool.w = w; S.pool.h = h;
    }
  } else if (d.kind === 'entry') {
    if (typeof railingEntryDrag === 'function') railingEntryDrag(d.idx, d.handle, np);
  } else if (d.kind === 'line' && d.idx === 'gate') {
    const q = _fenceProjectToLine(np);      // калитка не сходит с линии забора
    if (q) S.fenceGate = q;
  } else if (d.kind === 'line') {
    const pts = S.pts[sec] || [];
    const pt = pts[d.idx];
    if (!pt) return;
    let q = { x: snapNorm(np.x), y: snapNorm(np.y) };
    // Сшитые точки (шов кольца, стык линий) едут вместе — см. _e3dLineMates.
    const group = [d.idx, ...(d.mates || [])];
    // Конец, подведённый к началу своей же линии, прилипает — контур замыкается.
    // У уже сшитой точки цель прилипания — она сама, её не ищем.
    const snapTo = (!d.mates || !d.mates.length) && typeof _lineCloseTarget === 'function'
      ? _lineCloseTarget(sec, d.idx, q) : null;
    if (snapTo) q = { x: snapTo.x, y: snapTo.y };
    else if (sec === 'fence' && typeof _fenceTooClose === 'function' && _fenceTooClose(q)) return;
    // Соседи всех сшитых точек — у шва кольца это первый и последний отрезки.
    const nbs = [];
    for (const i of group) for (const nb of [pts[i - 1], pts[i + 1]]) {
      if (nb && !nb.break && !group.some(j => pts[j] === nb)) nbs.push(nb);
    }
    // Точка забора тянет за собой два своих отрезка — ни один не должен пройти
    // сквозь дом или террасу (правка 2026-09-26): точка упирается, как объекты.
    if (sec === 'fence' && typeof fenceSegBlocked === 'function') {
      for (const nb of nbs) if (fenceSegBlocked(nb, q)) return;
    }
    // Дорожке пересекать дом и террасу тоже нельзя (правка 2026-09-26; 19.09
    // было решено наоборот — вести насквозь и обрезать скрытое).
    if (sec === 'paths' && typeof pathSegBlocked === 'function') {
      for (const nb of nbs) if (pathSegBlocked(nb, q)) return;
    }
    for (const i of group) { if (pts[i]) { pts[i].x = q.x; pts[i].y = q.y; } }
  }
  e3dSync();   // сцену НЕ пересобираем: тяжёлая сборка идёт один раз, на отпускании
}

// ── Рисование дорожек и забора отрезками ─────────────────────────────────
// Клик — начало отрезка, второй клик — конец. Следующий отрезок начинается
// новым кликом. Клик по существующей точке склеивает: координаты берутся её,
// а если это КОНЕЦ ломаной, отрезок дописывается к ней, а не заводит новую.

function _e3dLineSegs(name) {
  return (typeof splitAtBreaks === 'function') ? splitAtBreaks(S.pts[name] || []) : [];
}

// Точки, сшитые с данной: те же координаты в той же разметке. Так хранится шов
// кольца (последняя точка ломаной легла на первую) и стык линий. Перетаскивание
// двигает их вместе — раньше тянулась одна точка, и кольцо расходилось
// (правка 2026-10-04).
function _e3dLineMates(name, idx) {
  const pts = S.pts[name] || [];
  const p = (typeof idx === 'number') ? pts[idx] : null;
  if (!p || p.break) return [];
  const out = [];
  pts.forEach((q, j) => {
    if (j !== idx && q && !q.break && Math.abs(q.x - p.x) < 1e-9 && Math.abs(q.y - p.y) < 1e-9) out.push(j);
  });
  return out;
}

// Записать список ломаных обратно плоским массивом с маркерами разрыва.
function _e3dLineWrite(name, segs) {
  const out = [];
  for (const seg of segs.filter(s => s.length)) {
    if (out.length) out.push({ break: true });
    for (const p of seg) out.push(p);
  }
  S.pts[name] = out;
}

// Ближайшая существующая точка в пределах радиуса склейки → {si, pi, pt}.
function _e3dGluePoint(name, np) {
  const segs = _e3dLineSegs(name);
  const r = _e3dR(E3D_GLUE_R) / GRID;
  let best = r, hit = null;
  segs.forEach((seg, si) => seg.forEach((p, pi) => {
    const d = Math.hypot(p.x - np.x, p.y - np.y);
    if (d < best) { best = d; hit = { si, pi, pt: p }; }
  }));
  return hit;
}

// Точка клика для рисования: склеенная координата, иначе снап на сетку.
function _e3dDrawPoint(name, np) {
  const g = _e3dGluePoint(name, np);
  if (g) return { x: g.pt.x, y: g.pt.y, glue: g };
  return { x: snapNorm(np.x), y: snapNorm(np.y), glue: null };
}

// Закончить отрезок: приклеить к существующей ломаной, если конец совпал с её
// концом, иначе завести новую. Так три отрезка, нарисованные подряд от точки к
// точке, дают ОДНУ ломаную — забор и дорожка строятся по ней без задвоенных
// столбов на стыках.
function _e3dLineCommit(name, a, b) {
  const segs = _e3dLineSegs(name);
  const endOf = (p) => {
    for (let si = 0; si < segs.length; si++) {
      const seg = segs[si];
      if (seg.length < 1) continue;
      if (seg[0].x === p.x && seg[0].y === p.y) return { si, at: 'head' };
      if (seg[seg.length - 1].x === p.x && seg[seg.length - 1].y === p.y) return { si, at: 'tail' };
    }
    return null;
  };
  const ea = endOf(a), eb = endOf(b);
  const A = { x: a.x, y: a.y }, B = { x: b.x, y: b.y };

  if (ea && eb && ea.si === eb.si) {          // замкнули ту же ломаную
    const seg = segs[ea.si];
    if (ea.at === 'tail') seg.push(B); else seg.unshift(B);
  } else if (ea && eb) {                      // соединили две разные ломаные
    const s1 = ea.at === 'tail' ? segs[ea.si] : segs[ea.si].slice().reverse();
    const s2 = eb.at === 'head' ? segs[eb.si] : segs[eb.si].slice().reverse();
    const merged = s1.concat(s2.slice(1).length ? s2.slice(1) : []);
    const keep = segs.filter((_, i) => i !== ea.si && i !== eb.si);
    keep.push(merged);
    _e3dLineWrite(name, keep);
    return;
  } else if (ea) {                            // продолжили существующую с её конца
    if (ea.at === 'tail') segs[ea.si].push(B); else segs[ea.si].unshift(B);
  } else if (eb) {                            // пришли в конец существующей
    if (eb.at === 'head') segs[eb.si].unshift(A); else segs[eb.si].push(A);
  } else {
    segs.push([A, B]);                        // отдельный новый отрезок
  }
  _e3dLineWrite(name, segs);
}

// Рисование линии НЕПРЕРЫВНОЕ (правка 2026-09-26): первый клик начинает линию,
// каждый следующий добавляет вершину, и линия тянется дальше, пока её не
// закончат — правой кнопкой мыши, Esc или повторным кликом в последнюю точку
// (на телефоне правой кнопки нет). Клик по существующей точке, пока ничего не
// рисуем, только выделяет её: раньше он сразу заводил новую линию, и чтобы
// передвинуть или удалить точку, приходилось сперва сбрасывать построение
// через Esc. Во время рисования клик по существующей точке соединяет с ней;
// если это начало самой рисуемой линии — контур замкнут, рисование кончается.
function _e3dDrawClick(np) {
  const name = E3D.sec;
  const p = _e3dDrawPoint(name, np);
  if (name === 'fence' && typeof _fenceTooClose === 'function' && _fenceTooClose(p)) {
    if (typeof dToast === 'function') dToast('Ближе 3 м к дому и террасе забор не ставится');
    return;
  }
  if (!E3D.draw || E3D.draw.name !== name) {
    E3D.draw = { name, start: { x: p.x, y: p.y }, first: { x: p.x, y: p.y }, cursor: null };
    _lineSel = { name, idx: null };
    e3dSync();
    return;
  }
  const a = E3D.draw.start;
  if (Math.hypot(p.x - a.x, p.y - a.y) < SNAP / GRID) { _e3dDrawFinish(); return; }  // повторный клик в последнюю точку
  // Линия забора не проходит сквозь дом и террасу (правка 2026-09-26): концы
  // уже держатся в 3 м от них, но отрезок между двумя разрешёнными точками мог
  // пересечь дом насквозь.
  const why = (name === 'fence' && typeof fenceSegBlocked === 'function') ? fenceSegBlocked(a, p) : null;
  if (why) {
    if (typeof dToast === 'function') {
      dToast(why === 'cross' ? 'Забор не может проходить через дом или террасу'
                             : 'Ближе 3 м к дому и террасе забор не ставится');
    }
    return;
  }
  // Дорожка тоже не проходит через дом и террасу (правка 2026-09-26), но
  // подходить к ним вплотную может — она к ним и ведёт.
  if (name === 'paths' && typeof pathSegBlocked === 'function' && pathSegBlocked(a, p)) {
    if (typeof dToast === 'function') dToast('Дорожка не может проходить через дом или террасу');
    return;
  }
  _e3dLineCommit(name, a, p);
  const f = E3D.draw.first;
  const closed = p.glue && f && Math.hypot(p.x - f.x, p.y - f.y) < 1e-9;
  E3D.draw.start = { x: p.x, y: p.y };        // дальше тянемся от новой вершины
  E3D.draw.cursor = null;
  if (closed) E3D.draw = null;                // замкнули контур — построение закончено
  _lineSel = { name, idx: null };
  e3dSync();
  if (typeof onParamChange === 'function') onParamChange();
  if (typeof _dSyncSectionActions === 'function') _dSyncSectionActions();
}

// Закончить начатую линию: правая кнопка, Esc или клик в последнюю точку.
// Одиночная стартовая точка без отрезков ничего не оставляет.
function _e3dDrawFinish() {
  if (!E3D.draw) return false;
  E3D.draw = null;
  e3dSync();
  return true;
}

// ── События ──────────────────────────────────────────────────────────────

function _e3dCancelPress() {
  E3D.press = null;
  E3D.drag = null;
  if (threeState) threeState.controls.enabled = true;
}

// Мобильный режим (вызывает nav-mobile.js). Жесты: одно касание — только выбор и
// перетаскивание объекта, вид от него не крутится; два пальца — поворот и
// масштаб вида. Мышиные кнопки не трогаем: на планшете с мышью всё как было.
function e3dSetTouch(on) {
  E3D.touch = !!on;
  const c = (typeof threeState !== 'undefined' && threeState) ? threeState.controls : null;
  if (!c || typeof THREE === 'undefined') return;
  c.touches.ONE = on ? -1 : THREE.TOUCH.ROTATE;      // -1 — «ничего» (см. onTouchStart)
  c.touches.TWO = THREE.TOUCH.DOLLY_ROTATE;
}

// Правая кнопка заканчивает рисуемую линию. Правой же кнопкой двигают вид
// (OrbitControls, панорама), поэтому линия заканчивается только КЛИКОМ — без
// протяжки; протяжка правой по-прежнему двигает вид.
let _e3dRightPress = null;

function _e3dOnDown(ev) {
  if (ev.button === 2) { _e3dRightPress = { x: ev.clientX, y: ev.clientY }; return; }
  if (ev.button !== 0 || !E3D.sec || !threeState) return;
  // Второй палец — это жест камеры (два пальца крутят и масштабируют вид):
  // начатую протяжку бросаем, иначе объект уехал бы вместе с видом.
  if (E3D.touch && ev.isPrimary === false) { _e3dCancelPress(); return; }
  const p = _e3dPointAt(ev);
  const hit = p ? e3dHitTest(p.norm, p.object) : null;
  E3D.press = { x: ev.clientX, y: ev.clientY, hit, np: p ? p.norm : null, moved: false };
  // Попали в свой объект — орбиту на время жеста выключаем: ЛКМ тянет объект.
  // Промах — орбита работает как обычно.
  if (hit) {
    E3D.drag = (hit.handle === 'toggle') ? null : _e3dDragStart(hit, p.norm);
    if (E3D.drag) threeState.controls.enabled = false;
  }
}

function _e3dOnMove(ev) {
  if (E3D.press) {
    if (Math.abs(ev.clientX - E3D.press.x) > E3D_MOVE_TOL
     || Math.abs(ev.clientY - E3D.press.y) > E3D_MOVE_TOL) E3D.press.moved = true;
    if (E3D.press.moved && E3D.drag) {
      const p = _e3dPointAt(ev);
      if (p) _e3dDragMove(p.norm);
    }
    return;
  }
  // «Резинка» начатого отрезка тянется за курсором.
  if (E3D.draw && E3D.draw.name === E3D.sec) {
    const p = _e3dPointAt(ev);
    if (p) { E3D.draw.cursor = { x: snapNorm(p.norm.x), y: snapNorm(p.norm.y) }; e3dSync(); }
  }
}

function _e3dOnUp(ev) {
  if (ev.button === 2) {
    const r = _e3dRightPress;
    _e3dRightPress = null;
    if (r && E3D.draw && Math.abs(ev.clientX - r.x) <= E3D_MOVE_TOL
                      && Math.abs(ev.clientY - r.y) <= E3D_MOVE_TOL) _e3dDrawFinish();
    return;
  }
  if (!E3D.press) return;
  const pr = E3D.press;
  E3D.press = null;
  const drag = E3D.drag;
  E3D.drag = null;
  if (threeState) threeState.controls.enabled = true;

  if (pr.moved) {
    // Перетаскивание закончено — досчитываем сцену набело.
    if (drag && typeof onParamChange === 'function') onParamChange();
    return;                                   // без объекта это было вращение камеры
  }

  if (pr.hit) {
    // Во время рисования клик по точке линии — это вершина (соединение с
    // точкой), а не выбор: построение продолжается.
    if (E3D_KIND[E3D.sec] === 'line' && E3D.draw && pr.hit.idx !== 'gate' && pr.np) {
      _e3dDrawClick(pr.np);
      return;
    }
    e3dSelect(pr.hit);
    // Грядка и мебель поворачиваются на 90° тем же кликом, которым выбираются
    // (как было на плане): отдельной ручки у них нет.
    if (pr.hit.kind === 'beds' || pr.hit.kind === 'point') { _e3dRotate(pr.hit); return; }
    // В линиях клик по точке только выделяет её (правка 2026-09-26) — дальше
    // её можно тянуть или удалить; новую линию он не начинает.
    return;
  }
  // Клик по пустому месту: в линиях — рисуем, в остальных разделах — снимаем выбор.
  if (E3D_KIND[E3D.sec] === 'line' && pr.np) _e3dDrawClick(pr.np);
  else e3dSelect(null);
}

// Поворот на 90° (ТЗ): у грядки это обмен сторон, у мебели — угол rot.
function _e3dRotate(hit) {
  if (hit.kind === 'beds' && typeof rotateActiveBed === 'function') rotateActiveBed();
  else if (hit.kind === 'point' && typeof rotateActiveFurniture === 'function') rotateActiveFurniture(1);
  e3dSync();
  if (typeof onParamChange === 'function') onParamChange();
}

// Курсор-указатель над своим объектом — видно, что по нему можно кликнуть.
function _e3dOnHover(ev) {
  if (!E3D.sec || !threeState || E3D.press) return;
  const p = _e3dPointAt(ev);
  const hit = p ? e3dHitTest(p.norm, p.object) : null;
  threeState.renderer.domElement.style.cursor =
    hit ? (hit.handle === 'move' ? 'move' : 'pointer')
        : (E3D_KIND[E3D.sec] === 'line' ? 'crosshair' : '');
}

// Навешивается один раз на канвас рендерера (канвас переезжает между шагами
// целиком, вместе со слушателями).
function e3dAttach() {
  if (!threeState || !threeState.renderer || E3D.bound) return;
  const el = threeState.renderer.domElement;
  el.addEventListener('pointerdown', _e3dOnDown);
  window.addEventListener('pointermove', _e3dOnMove);
  window.addEventListener('pointerup', _e3dOnUp);
  el.addEventListener('pointermove', _e3dOnHover);
  window.addEventListener('keydown', _e3dOnKey);
  // Меню браузера по правой кнопке над видом не нужно: правая кнопка здесь
  // заканчивает линию и двигает вид.
  el.addEventListener('contextmenu', ev => { if (E3D.sec) ev.preventDefault(); });
  E3D.bound = true;
  // Сцена могла родиться позже, чем включился мобильный режим — переносим на
  // неё настройку жестов (touches у OrbitControls живут в самой сцене).
  if (E3D.touch) e3dSetTouch(true);
}

// Delete / Backspace — удалить выбранный объект (то же, что кнопка в панели).
// Esc — бросить начатый отрезок.
function _e3dOnKey(ev) {
  if (!E3D.sec || dStep !== 3) return;
  const t = ev.target;
  if (t && (t.tagName === 'INPUT' || t.tagName === 'TEXTAREA' || t.isContentEditable)) return;
  // Открыто окно (размеры, заявка, подсказка) — клавиши его, а не сцены: Delete
  // с фокусом на кнопке окна удалял бы выбранную террасу.
  if (document.querySelector('.d-hint-overlay.active')) return;
  if (ev.key === 'Escape') {
    if (_e3dDrawFinish()) ev.preventDefault();
    return;
  }
  if (ev.key !== 'Delete' && ev.key !== 'Backspace') return;
  if (e3dSelectedIdx() === null) return;
  ev.preventDefault();
  if (typeof dDeleteSelected === 'function') dDeleteSelected();
}

// Смена активного раздела: сбрасываем начатый отрезок, перерисовываем слой.
// Разделы, которые размечаются «по земле»: при их открытии камера поднимается
// на вид сверху — с уровня глаз разметку видно плохо, а участок целиком не
// помещается. Вид НЕ строго вертикальный (иначе теряются высоты) и азимут
// сохраняется — меняются только угол подъёма и дистанция.
const E3D_TOP_SECS = new Set(['terrace', 'pool_terrace', 'steps', 'paths', 'fence', 'beds']);
const E3D_TOP_PITCH = 58 * Math.PI / 180;   // угол над горизонтом
const E3D_TOP_MARGIN = 1.08;                // поля вокруг участка, чтобы сетка не упиралась в рамку

// Дистанция, с которой квадрат участка целиком попадает в кадр при заданных
// азимуте и подъёме. Камера смотрит в центр участка с расстояния d, поэтому для
// точки v (от центра, по земле) глубина в кадре равна d + v·f, а смещения по
// осям кадра — v·right и v·up. Условие «точка внутри кадра» разворачивается в
// нижнюю границу для d, и берём наибольшую по всем четырём углам.
function _e3dFitDist(cam, az, pitch, half) {
  const tanY = Math.tan(cam.fov * Math.PI / 360);
  const tanX = tanY * (cam.aspect || 1);
  const f     = new THREE.Vector3(-Math.sin(az) * Math.cos(pitch), -Math.sin(pitch),
                                  -Math.cos(az) * Math.cos(pitch));
  const right = new THREE.Vector3(Math.cos(az), 0, -Math.sin(az));
  const up    = new THREE.Vector3().crossVectors(right, f);
  let dist = 0;
  for (const [sx, sz] of [[-1, -1], [1, -1], [1, 1], [-1, 1]]) {
    const v = new THREE.Vector3(sx * half, 0, sz * half);
    const depth = v.dot(f);
    dist = Math.max(dist,
                    Math.abs(v.dot(right)) / tanX - depth,
                    Math.abs(v.dot(up))    / tanY - depth);
  }
  return dist;
}

function e3dTopView() {
  if (!threeState || !threeState.camera || !threeState.controls) return;
  const cam = threeState.camera, ctr = threeState.controls;
  // Цель — центр участка (он же центр плана): разметка любого раздела лежит
  // внутри него, а центр дома увёл бы вид к краю.
  const c = _e3dToWorld({ x: 0.5, y: 0.5 });
  // Азимут оставляем прежний: пользователь сам развернул сцену как ему удобно.
  const dx = cam.position.x - ctr.target.x, dz = cam.position.z - ctr.target.z;
  const az = (Math.hypot(dx, dz) > 0.01) ? Math.atan2(dx, dz) : Math.PI / 4;
  // В кадр берём весь участок, а не окрестность дома: размечать дорожку или
  // забор по краю иначе приходится вслепую, подтягивая камеру руками.
  const dist = Math.min(ctr.maxDistance || 80,
                        Math.max(ctr.minDistance || 4,
                                 _e3dFitDist(cam, az, E3D_TOP_PITCH, GRID / 2) * E3D_TOP_MARGIN));
  const horiz = Math.cos(E3D_TOP_PITCH) * dist;
  ctr.target.set(c.x, 0, c.z);
  cam.position.set(c.x + Math.sin(az) * horiz,
                   Math.sin(E3D_TOP_PITCH) * dist,
                   c.z + Math.cos(az) * horiz);
  threeState.camTouched = true;   // сцена больше не переставляет камеру сама
  ctr.update();
}

function e3dSetSection(secId) {
  const changed = E3D.sec !== ((secId && E3D_KIND[secId]) ? secId : null);
  E3D.sec = (secId && E3D_KIND[secId]) ? secId : null;
  E3D.press = null;
  E3D.drag = null;
  E3D.draw = null;
  if (threeState) {
    threeState.controls.enabled = true;
    threeState.renderer.domElement.style.cursor = '';
  }
  if (changed && E3D.sec && E3D_TOP_SECS.has(E3D.sec)) e3dTopView();
  e3dSync();
  // Панель раздела рисуется РАНЬШЕ этого вызова, и состояние кнопки «Удалить
  // выбранную» там считалось по ещё не обновлённому разделу: при первом открытии
  // выбранный блок уже был, а кнопка оставалась неактивной.
  if (typeof _dSyncSectionActions === 'function') _dSyncSectionActions();
}

// Кадровый хук: подписи следуют за камерой. Вызывается из animate (см. _onAnimFrame).
function e3dOnFrame() { _e3dPlaceLabels(); _e3dScaleMarkers(); }