Skip to content

Production interior authoring and interactive Three.js delivery plugin for img2.

34.6 KB
Raw Blame
import * as THREE from 'three';
import { validateRoomBounds, vector3 } from './interior-manifest.js';

const COLS = 50;
const ROWS = 16;
const STRIDE = COLS + 1;
const COUNT = STRIDE * (ROWS + 1);
const STEP = 1 / 60;
const clamp = THREE.MathUtils.clamp;

// All simulation positions are world-space. UVs, including the glTF V flip,
// identify material points independently of split vertices and panel direction.
export function createCurtainInteraction({ root, camera, canvas, controls, roomBounds, onChange = () => {}, isInteractive = () => true }) {
  validateRoomBounds(roomBounds);
  const room = new THREE.Box3(new THREE.Vector3().fromArray(roomBounds.min), new THREE.Vector3().fromArray(roomBounds.max));
  const doc = canvas.ownerDocument;
  const win = doc.defaultView;
  const motion = win.matchMedia('(prefers-reduced-motion: reduce)');
  let reduced = motion.matches;
  let windRequested = true;
  let wind = windRequested && !reduced;
  let enabled = true;
  let disposed = false;
  let inView = true;
  let paused = true;
  let accumulator = 0;
  let time = 0;
  let active = true;
  let quiet = 0;
  let grip = null;
  const originalCursor = canvas.style.cursor;
  const panels = [];
  const panelById = new Map();
  const fabricBindings = new Map();
  const fabricMeshes = [];
  const raycaster = new THREE.Raycaster();
  const pointer = new THREE.Vector2();
  const hits = [];
  const point = new THREE.Vector3();
  const sample = new THREE.Vector3();
  const contactPoint = new THREE.Vector3();
  const identity = new THREE.Matrix4();
  const delta = new THREE.Vector3();
  const normal = new THREE.Vector3();
  const inverse = new THREE.Matrix4();
  const blocked = new Set();
  const cornerIds = new Int32Array(4);
  const cornerWeights = new Float64Array(4);

  function metadata(mesh) {
    const result = {};
    for (let node = mesh; node; node = node.parent) {
      for (const key of Object.keys(node.userData)) {
        if (key.startsWith('curtain_') && result[key] === undefined) result[key] = node.userData[key];
      }
      if (node === root) break;
    }
    return result;
  }

  function weights(u, v, ids = cornerIds, values = cornerWeights) {
    const x = clamp(u, 0, 1) * COLS;
    const y = clamp(v, 0, 1) * ROWS;
    const i = Math.min(COLS - 1, Math.floor(x));
    const j = Math.min(ROWS - 1, Math.floor(y));
    const a = x - i;
    const b = y - j;
    ids[0] = j * STRIDE + i; ids[1] = ids[0] + 1;
    ids[2] = ids[0] + STRIDE; ids[3] = ids[2] + 1;
    values[0] = (1 - a) * (1 - b); values[1] = a * (1 - b);
    values[2] = (1 - a) * b; values[3] = a * b;
  }

  function interpolate(array, ids, values, out) {
    out.set(0, 0, 0);
    for (let k = 0; k < 4; k++) {
      const i = ids[k] * 3;
      out.x += array[i] * values[k];
      out.y += array[i + 1] * values[k];
      out.z += array[i + 2] * values[k];
    }
    return out;
  }

  root.updateWorldMatrix(true, true);
  const geometryUsers = new Map();
  root.traverse(node => {
    if (node.isMesh) geometryUsers.set(node.geometry, (geometryUsers.get(node.geometry) ?? 0) + 1);
  });
  const meshes = [];
  root.traverse(node => {
    if (!node.isMesh) return;
    const meta = metadata(node);
    if (meta.curtain_id === undefined && meta.curtain_part === undefined) return;
    if (typeof meta.curtain_id !== 'string' || !meta.curtain_id) throw new Error(`Curtain mesh ${node.name} requires a nonempty curtain_id.`);
    if (!['cloth', 'hem', 'hook', 'rail'].includes(meta.curtain_part)) throw new Error(`Curtain ${meta.curtain_id} has an unsupported curtain_part.`);
    meshes.push({ mesh: node, meta });
    if (['cloth', 'hem', 'hook'].includes(meta.curtain_part)) {
      if (!root.matrixWorld.elements.every((value, i) => Math.abs(value - identity.elements[i]) < 1e-8)) {
        throw new Error('Interactive curtains require an identity scene root. Apply root transforms in the authoring scene and re-export metadata in Y-up scene coordinates.');
      }
      if (geometryUsers.get(node.geometry) !== 1) throw new Error(`Curtain ${meta.curtain_id} shares geometry with another mesh; make deforming geometry single-user before export.`);
      const p = node.geometry.getAttribute('position');
      const uv = node.geometry.getAttribute('uv');
      if (!p || p.itemSize !== 3 || !uv || uv.itemSize !== 2 || uv.count !== p.count) throw new Error(`Curtain ${meta.curtain_id} requires complete position and material UV0 attributes.`);
      for (let i = 0; i < p.count; i++) {
        if (![p.getX(i), p.getY(i), p.getZ(i), uv.getX(i), uv.getY(i)].every(Number.isFinite)) throw new Error(`Curtain ${meta.curtain_id} has non-finite geometry or UV0.`);
      }
      if (meta.curtain_part === 'hook' && (!Number.isFinite(meta.curtain_u) || meta.curtain_u < 0 || meta.curtain_u > 1)) throw new Error(`Curtain ${meta.curtain_id} hook needs curtain_u in [0, 1].`);
      if (meta.curtain_part === 'hem' && (!Number.isFinite(meta.curtain_v) || meta.curtain_v < 0 || meta.curtain_v > 1)) throw new Error(`Curtain ${meta.curtain_id} hem needs curtain_v in [0, 1].`);
    }
    if (meta.curtain_part !== 'cloth') return;
    for (const key of ['curtain_tile', 'curtain_fabric_width', 'curtain_height', 'curtain_open_width', 'curtain_closed_width']) {
      if (!Number.isFinite(meta[key]) || meta[key] <= 0) throw new Error(`Curtain ${meta.curtain_id} requires positive ${key}.`);
    }
    if (meta.curtain_closed_width <= meta.curtain_open_width) throw new Error(`Curtain ${meta.curtain_id} closed width must exceed open width.`);
    for (const key of ['curtain_rail_axis', 'curtain_depth_axis', 'curtain_plane_origin']) {
      if (!vector3(meta[key])) throw new Error(`Curtain ${meta.curtain_id} requires explicit Y-up ${key}; re-export using the current curtain helper.`);
    }
    const rail = new THREE.Vector3().fromArray(meta.curtain_rail_axis);
    const depthAxis = new THREE.Vector3().fromArray(meta.curtain_depth_axis);
    const planeOrigin = new THREE.Vector3().fromArray(meta.curtain_plane_origin);
    if (Math.abs(rail.lengthSq()-1) > 1e-5 || Math.abs(depthAxis.lengthSq()-1) > 1e-5
        || Math.abs(rail.dot(depthAxis)) > 1e-5 || Math.abs(rail.y) > 1e-5 || Math.abs(depthAxis.y) > 1e-5) {
      throw new Error(`Curtain ${meta.curtain_id} rail/depth axes must be horizontal orthogonal unit vectors in Y-up scene space.`);
    }
    const existing = panelById.get(meta.curtain_id);
    if (existing) {
      const keys = ['curtain_tile', 'curtain_fabric_width', 'curtain_height', 'curtain_open_width', 'curtain_closed_width', 'curtain_rail_axis', 'curtain_depth_axis', 'curtain_plane_origin'];
      if (keys.some(key => JSON.stringify(existing.meta[key]) !== JSON.stringify(meta[key]))) throw new Error(`Curtain ${meta.curtain_id} primitives disagree on panel metadata.`);
      return;
    }
    const panel = {
      id: meta.curtain_id, meta, rail, closure: 0, targetClosure: 0,
      depthAxis, planeOrigin, pleatDepth: new Float64Array(COUNT),
      rest: new Float64Array(COUNT * 3), goal: new Float64Array(COUNT * 3),
      position: new Float64Array(COUNT * 3), previous: new Float64Array(COUNT * 3),
      counts: new Uint16Array(COUNT), bindings: [], edges: [], speed: 0, displacement: 0,
    };
    panels.push(panel);
    panelById.set(panel.id, panel);
  });
  for (const { meta } of meshes) {
    if (meta.curtain_part !== 'rail' && !panelById.has(meta.curtain_id)) throw new Error(`Curtain ${meta.curtain_id} ${meta.curtain_part} has no cloth panel.`);
  }

  // Average front/back copies at each authored grid point, retaining the shell
  // offset separately when mapping the solver back onto the imported geometry.
  for (const { mesh, meta } of meshes) {
    if (meta.curtain_part !== 'cloth') continue;
    const panel = panelById.get(meta.curtain_id);
    const uv = mesh.geometry.getAttribute('uv');
    const positions = mesh.geometry.getAttribute('position');
    if (!uv) throw new Error(`Curtain ${panel.id} requires material UV0`);
    for (let i = 0; i < positions.count; i++) {
      const u = clamp(uv.getX(i) * meta.curtain_tile / meta.curtain_fabric_width, 0, 1);
      const v = clamp((1 - uv.getY(i)) * meta.curtain_tile / meta.curtain_height, 0, 1);
      const gridU = u*COLS, gridV = v*ROWS;
      const col = Math.round(gridU), row = Math.round(gridV);
      // The solver samples exact intersections of the denser authored mesh.
      // Averaging neighbouring material points would move rail pins and folds.
      if (Math.abs(gridU-col) > 1e-4 || Math.abs(gridV-row) > 1e-4) continue;
      const index = row*STRIDE + col;
      point.fromBufferAttribute(positions, i).applyMatrix4(mesh.matrixWorld);
      panel.rest[index * 3] += point.x;
      panel.rest[index * 3 + 1] += point.y;
      panel.rest[index * 3 + 2] += point.z;
      panel.counts[index]++;
    }
  }
  for (const panel of panels) {
    for (let i = 0; i < COUNT; i++) {
      if (!panel.counts[i]) throw new Error(`Curtain ${panel.id} is missing material grid point ${i}`);
      for (let a = 0; a < 3; a++) panel.rest[i * 3 + a] /= panel.counts[i];
      point.fromArray(panel.rest, i * 3);
      panel.pleatDepth[i] = delta.copy(point).sub(panel.planeOrigin).dot(panel.depthAxis);
      if (i >= ROWS * STRIDE) {
        const travel = (i % STRIDE) / COLS * (panel.meta.curtain_closed_width-panel.meta.curtain_open_width);
        if (!room.containsPoint(point) || !room.containsPoint(point.addScaledVector(panel.rail, travel))) {
          throw new Error(`Curtain ${panel.id} pinned header leaves roomBounds at open or closed coverage; repair the rail metadata or authored bounds.`);
        }
      }
    }
    panel.goal.set(panel.rest);
    panel.position.set(panel.rest);
    panel.previous.set(panel.rest);
    const edges = [];
    const add = (a, b, stiffness) => edges.push(a, b, stiffness);
    for (let j = 0; j <= ROWS; j++) {
      for (let i = 0; i <= COLS; i++) {
        const a = j * STRIDE + i;
        if (i < COLS) add(a, a + 1, 0.85);
        if (j < ROWS) add(a, a + STRIDE, 0.95);
        if (i < COLS && j < ROWS) {
          add(a, a + STRIDE + 1, 0.55);
          add(a + 1, a + STRIDE, 0.55);
        }
        if (i + 2 <= COLS) add(a, a + 2, 0.18);
        if (j + 2 <= ROWS) add(a, a + 2 * STRIDE, 0.18);
      }
    }
    panel.edges = new Float64Array(edges);
    panel.lengths = new Float64Array(edges.length / 3);
    updateGoal(panel);
  }

  for (const { mesh, meta } of meshes) {
    const panel = panelById.get(meta.curtain_id);
    if (!panel || !['cloth', 'hem', 'hook'].includes(meta.curtain_part)) continue;
    const geometry = mesh.geometry;
    const positions = geometry.getAttribute('position');
    const uv = geometry.getAttribute('uv');
    const binding = {
      panel, mesh, part: meta.curtain_part, ids: new Int32Array(positions.count * 4),
      weights: new Float64Array(positions.count * 4), offsets: new Float64Array(positions.count * 3),
      original: positions.array.slice(), originalUsage: positions.usage,
      originalNormal: geometry.getAttribute('normal')?.array.slice() ?? null,
      originalTangent: geometry.getAttribute('tangent')?.array.slice() ?? null,
      tangent1: null, tangent2: null,
    };
    positions.setUsage(THREE.DynamicDrawUsage);
    if (!geometry.getAttribute('normal')) geometry.setAttribute('normal', new THREE.BufferAttribute(new Float32Array(positions.count * 3), 3));
    if (geometry.getAttribute('tangent')) {
      binding.tangent1 = new Float64Array(positions.count * 3);
      binding.tangent2 = new Float64Array(positions.count * 3);
    }
    for (let i = 0; i < positions.count; i++) {
      point.fromBufferAttribute(positions, i).applyMatrix4(mesh.matrixWorld);
      let u;
      let v;
      if (meta.curtain_part === 'cloth') {
        u = uv.getX(i) * panel.meta.curtain_tile / panel.meta.curtain_fabric_width;
        v = (1 - uv.getY(i)) * panel.meta.curtain_tile / panel.meta.curtain_height;
      } else if (meta.curtain_part === 'hook') {
        u = meta.curtain_u; v = 1;
      } else {
        // Project onto the authored rail rather than raw local mesh axes.
        delta.copy(point).sub(sample.fromArray(panel.rest, ROWS * STRIDE * 3));
        u = delta.dot(panel.rail) / (panel.rail.lengthSq() * panel.meta.curtain_open_width);
        v = meta.curtain_v;
      }
      weights(u, v);
      interpolate(panel.rest, cornerIds, cornerWeights, sample);
      for (let k = 0; k < 4; k++) {
        binding.ids[i * 4 + k] = cornerIds[k];
        binding.weights[i * 4 + k] = cornerWeights[k];
      }
      binding.offsets[i * 3] = point.x - sample.x;
      binding.offsets[i * 3 + 1] = point.y - sample.y;
      binding.offsets[i * 3 + 2] = point.z - sample.z;
    }
    panel.bindings.push(binding);
    if (binding.part === 'cloth' || binding.part === 'hem') {
      fabricBindings.set(mesh, binding);
      fabricMeshes.push(mesh);
    }
  }

  function updateGoal(panel) {
    const expansion = panel.closure * (panel.meta.curtain_closed_width - panel.meta.curtain_open_width);
    for (let i = 0; i < COUNT; i++) {
      const shift = (i % STRIDE) / COLS * expansion;
      // Unfold the gathered depth as the rail expands, leaving modest closed
      // pleats. The short pinned header retains its authored depth so hooks
      // and their cloth attachments translate only along the rail.
      const v = Math.floor(i / STRIDE) / ROWS;
      const headerBlend = clamp((1 - v) * 8, 0, 1);
      const unfold = -panel.pleatDepth[i] * 0.72 * panel.closure
        * headerBlend * headerBlend * (3 - 2 * headerBlend);
      panel.goal[i * 3] = panel.rest[i * 3] + panel.rail.x * shift + panel.depthAxis.x * unfold;
      panel.goal[i * 3 + 1] = panel.rest[i * 3 + 1] + panel.rail.y * shift + panel.depthAxis.y * unfold;
      panel.goal[i * 3 + 2] = panel.rest[i * 3 + 2] + panel.rail.z * shift + panel.depthAxis.z * unfold;
    }
    for (let e = 0; e < panel.edges.length; e += 3) {
      const a = panel.edges[e] * 3;
      const b = panel.edges[e + 1] * 3;
      panel.lengths[e / 3] = Math.hypot(panel.goal[b] - panel.goal[a], panel.goal[b + 1] - panel.goal[a + 1], panel.goal[b + 2] - panel.goal[a + 2]);
    }
  }

  function constrainGrip(panel) {
    if (!grip || grip.panel !== panel) return;
    interpolate(panel.position, grip.ids, grip.weights, sample);
    delta.copy(grip.target).sub(grip.offset).sub(sample);
    let denominator = 0;
    let largestWeight = 0;
    for (let k = 0; k < 4; k++) {
      if (grip.ids[k] < ROWS * STRIDE) {
        denominator += grip.weights[k] ** 2;
        largestWeight = Math.max(largestWeight, grip.weights[k]);
      }
    }
    if (denominator < 0.0001) return; // A point exactly on the rail remains pinned.
    delta.clampLength(0, Math.min(0.10, 0.04 * denominator / largestWeight));
    for (let k = 0; k < 4; k++) {
      if (grip.ids[k] >= ROWS * STRIDE) continue;
      const i = grip.ids[k] * 3;
      const w = grip.weights[k] / denominator * 0.9;
      panel.position[i] += delta.x * w;
      panel.position[i + 1] += delta.y * w;
      panel.position[i + 2] += delta.z * w;
    }
  }

  function clampToRoom(vector) {
    return room.clampPoint(vector, vector);
  }

  function boundsAndPins(panel) {
    for (let i = 0; i < COUNT; i++) {
      const a = i * 3;
      if (i >= ROWS * STRIDE) {
        for (let k = 0; k < 3; k++) panel.position[a + k] = panel.goal[a + k];
      } else {
        contactPoint.fromArray(panel.position, a);
        clampToRoom(contactPoint);
        panel.position[a] = contactPoint.x;
        panel.position[a + 1] = contactPoint.y;
        panel.position[a + 2] = contactPoint.z;
      }
    }
  }

  function stepPanel(panel) {
    const difference = panel.targetClosure - panel.closure;
    if (Math.abs(difference) > 0.00001) {
      panel.closure += difference * (1 - Math.exp(-STEP * 9));
      if (Math.abs(panel.targetClosure - panel.closure) < 0.0001) panel.closure = panel.targetClosure;
      updateGoal(panel);
    }
    const p = panel.position;
    const prev = panel.previous;
    const goal = panel.goal;
    const damping = reduced ? 0.75 : 0.94;
    for (let i = 0; i < ROWS * STRIDE; i++) {
      const a = i * 3;
      const v = Math.floor(i / STRIDE) / ROWS;
      const breeze = wind ? 0.19 * Math.sin(time * 1.15 + i % STRIDE * 0.075 + v * 2.4) * (1 - v) : 0;
      for (let k = 0; k < 3; k++) {
        const value = p[a + k];
        const velocity = clamp((value - prev[a + k]) * damping, -0.035, 0.035);
        const force = (goal[a + k] - value) * 14 + (k === 1 ? -1.5 : 0) + breeze * panel.depthAxis.getComponent(k);
        p[a + k] = value + velocity + force * STEP * STEP;
        prev[a + k] = value;
      }
    }
    for (let iteration = 0; iteration < 7; iteration++) {
      for (let e = 0; e < panel.edges.length; e += 3) {
        const ai = panel.edges[e];
        const bi = panel.edges[e + 1];
        const a = ai * 3;
        const b = bi * 3;
        const dx = p[b] - p[a]; const dy = p[b + 1] - p[a + 1]; const dz = p[b + 2] - p[a + 2];
        const distance = Math.sqrt(dx*dx + dy*dy + dz*dz);
        const wa = ai < ROWS * STRIDE ? 1 : 0;
        const wb = bi < ROWS * STRIDE ? 1 : 0;
        if (!distance || !wa && !wb) continue;
        const correction = (distance - panel.lengths[e / 3]) / distance * panel.edges[e + 2] / (wa + wb);
        p[a] += dx * correction * wa; p[a + 1] += dy * correction * wa; p[a + 2] += dz * correction * wa;
        p[b] -= dx * correction * wb; p[b + 1] -= dy * correction * wb; p[b + 2] -= dz * correction * wb;
      }
      constrainGrip(panel);
      boundsAndPins(panel);
    }
    panel.speed = 0;
    panel.displacement = 0;
    for (let i = 0; i < COUNT; i++) {
      const a = i * 3;
      const vx = p[a]-prev[a], vy = p[a+1]-prev[a+1], vz = p[a+2]-prev[a+2];
      const dx = p[a]-goal[a], dy = p[a+1]-goal[a+1], dz = p[a+2]-goal[a+2];
      panel.speed = Math.max(panel.speed, vx*vx + vy*vy + vz*vz);
      panel.displacement = Math.max(panel.displacement, dx*dx + dy*dy + dz*dz);
      if (i >= ROWS * STRIDE) for (let k = 0; k < 3; k++) prev[a + k] = p[a + k];
    }
    panel.speed = Math.sqrt(panel.speed)/STEP;
    panel.displacement = Math.sqrt(panel.displacement);
  }

  // Reuse normal/tangent accumulators: computeTangents creates scratch arrays on
  // each call. UV0/UV1 and the imported shell topology remain untouched.
  function updateSurface(binding) {
    const geometry = binding.mesh.geometry;
    const p = geometry.getAttribute('position');
    const n = geometry.getAttribute('normal');
    const uv = geometry.getAttribute('uv');
    const tangent = geometry.getAttribute('tangent');
    const index = geometry.index;
    n.array.fill(0);
    binding.tangent1?.fill(0);
    binding.tangent2?.fill(0);
    const count = index ? index.count : p.count;
    for (let t = 0; t + 2 < count; t += 3) {
      const a = index ? index.getX(t) : t;
      const b = index ? index.getX(t + 1) : t + 1;
      const c = index ? index.getX(t + 2) : t + 2;
      const x1 = p.getX(b) - p.getX(a); const y1 = p.getY(b) - p.getY(a); const z1 = p.getZ(b) - p.getZ(a);
      const x2 = p.getX(c) - p.getX(a); const y2 = p.getY(c) - p.getY(a); const z2 = p.getZ(c) - p.getZ(a);
      const nx = y1 * z2 - z1 * y2; const ny = z1 * x2 - x1 * z2; const nz = x1 * y2 - y1 * x2;
      let sx = 0; let sy = 0; let sz = 0; let tx = 0; let ty = 0; let tz = 0;
      if (tangent && uv) {
        const s1 = uv.getX(b) - uv.getX(a); const s2 = uv.getX(c) - uv.getX(a);
        const t1 = uv.getY(b) - uv.getY(a); const t2 = uv.getY(c) - uv.getY(a);
        const determinant = s1 * t2 - s2 * t1;
        if (Math.abs(determinant) > 1e-12) {
          const r = 1 / determinant;
          sx = (t2 * x1 - t1 * x2) * r; sy = (t2 * y1 - t1 * y2) * r; sz = (t2 * z1 - t1 * z2) * r;
          tx = (s1 * x2 - s2 * x1) * r; ty = (s1 * y2 - s2 * y1) * r; tz = (s1 * z2 - s2 * z1) * r;
        }
      }
      for (let corner = 0; corner < 3; corner++) {
        const i = corner === 0 ? a : corner === 1 ? b : c;
        n.setXYZ(i, n.getX(i) + nx, n.getY(i) + ny, n.getZ(i) + nz);
        if (tangent) {
          binding.tangent1[i * 3] += sx; binding.tangent1[i * 3 + 1] += sy; binding.tangent1[i * 3 + 2] += sz;
          binding.tangent2[i * 3] += tx; binding.tangent2[i * 3 + 1] += ty; binding.tangent2[i * 3 + 2] += tz;
        }
      }
    }
    for (let i = 0; i < p.count; i++) {
      normal.fromBufferAttribute(n, i).normalize();
      n.setXYZ(i, normal.x, normal.y, normal.z);
      if (tangent) {
        point.fromArray(binding.tangent1, i * 3);
        point.addScaledVector(normal, -normal.dot(point)).normalize();
        delta.crossVectors(normal, point);
        sample.fromArray(binding.tangent2, i * 3);
        tangent.setXYZW(i, point.x, point.y, point.z, delta.dot(sample) < 0 ? -1 : 1);
      }
    }
    n.needsUpdate = true;
    if (tangent) tangent.needsUpdate = true;
  }

  function renderGeometry() {
    root.updateWorldMatrix(true, true);
    for (const panel of panels) for (const binding of panel.bindings) {
      inverse.copy(binding.mesh.matrixWorld).invert();
      const positions = binding.mesh.geometry.getAttribute('position');
      for (let i = 0; i < positions.count; i++) {
        point.fromArray(binding.offsets, i * 3);
        for (let k = 0; k < 4; k++) {
          const a = binding.ids[i * 4 + k] * 3;
          const w = binding.weights[i * 4 + k];
          point.x += panel.position[a] * w;
          point.y += panel.position[a + 1] * w;
          point.z += panel.position[a + 2] * w;
        }
        point.applyMatrix4(inverse);
        positions.setXYZ(i, point.x, point.y, point.z);
      }
      positions.needsUpdate = true;
      updateSurface(binding);
      binding.mesh.geometry.computeBoundingBox();
      binding.mesh.geometry.computeBoundingSphere();
    }
  }

  function available() {
    return !disposed && enabled && !doc.hidden && inView && isInteractive();
  }

  function wake() {
    active = true;
    quiet = 0;
    if (!disposed) onChange();
  }

  function setRay(event) {
    const rect = canvas.getBoundingClientRect();
    if (!rect.width || !rect.height) return false;
    pointer.set((event.clientX - rect.left) / rect.width * 2 - 1, 1 - (event.clientY - rect.top) / rect.height * 2);
    camera.updateWorldMatrix(true, false);
    raycaster.setFromCamera(pointer, camera);
    return true;
  }

  function visibleHit(hit) {
    if (!hit.object.isMesh || !camera.layers.test(hit.object.layers)) return false;
    for (let node = hit.object; node; node = node.parent) if (!node.visible) return false;
    const materials = hit.object.material;
    const material = Array.isArray(materials) ? materials[hit.face?.materialIndex ?? 0] : materials;
    return !!material?.visible && !(material.transparent && material.opacity === 0);
  }

  function pick(event) {
    if (!setRay(event)) return null;
    root.updateWorldMatrix(true, true);
    hits.length = 0;
    raycaster.intersectObjects(fabricMeshes, false, hits);
    let candidate = null;
    for (const hit of hits) {
      if (hit.uv && visibleHit(hit)) { candidate = hit; break; }
    }
    if (!candidate) return null;
    // Only pay for scene occlusion when the pointer actually reaches fabric.
    // Limit the second query to the candidate; geometry behind it is irrelevant.
    const previousFar = raycaster.far;
    raycaster.far = Math.min(previousFar, candidate.distance + 0.0001);
    hits.length = 0;
    try {
      raycaster.intersectObject(root, true, hits);
    } finally {
      raycaster.far = previousFar;
    }
    for (const hit of hits) {
      if (!visibleHit(hit)) continue;
      return fabricBindings.has(hit.object) && hit.uv ? hit : null;
    }
    return null;
  }

  function cancelGrip() {
    if (!grip) return;
    const old = grip;
    grip = null;
    win.removeEventListener('wheel', suppress, true);
    controls.enabled = old.controlsEnabled && enabled && isInteractive();
    canvas.style.cursor = originalCursor;
    if (canvas.hasPointerCapture(old.pointerId)) canvas.releasePointerCapture(old.pointerId);
    wake();
  }

  function suppress(event) {
    event.preventDefault();
    event.stopImmediatePropagation();
  }

  function pointerDown(event) {
    if (grip && event.pointerId !== grip.pointerId) {
      blocked.add(event.pointerId);
      blocked.add(grip.pointerId);
      cancelGrip();
      suppress(event);
      return;
    }
    if (event.target !== canvas || !available() || blocked.size || event.button !== 0 || event.isPrimary === false) return;
    const hit = pick(event);
    if (!hit) return;
    const binding = fabricBindings.get(hit.object);
    const panel = binding.panel;
    let u, v;
    if (binding.part === 'cloth') {
      u = hit.uv.x * panel.meta.curtain_tile / panel.meta.curtain_fabric_width;
      v = (1-hit.uv.y) * panel.meta.curtain_tile / panel.meta.curtain_height;
    } else {
      // Hem texture UVs describe the tube, not the parent fabric. Recover the
      // grabbed material point from the same vertex bindings used to deform it.
      u = v = 0;
      for (let corner = 0; corner < 3; corner++) {
        const vertex = corner === 0 ? hit.face.a : corner === 1 ? hit.face.b : hit.face.c;
        const barycentric = corner === 0 ? hit.barycoord.x : corner === 1 ? hit.barycoord.y : hit.barycoord.z;
        for (let k = 0; k < 4; k++) {
          const slot = vertex*4+k;
          const id = binding.ids[slot];
          const weight = barycentric*binding.weights[slot];
          u += id%STRIDE/COLS*weight;
          v += Math.floor(id/STRIDE)/ROWS*weight;
        }
      }
    }
    u = clamp(u, 0, 1); v = clamp(v, 0, 1);
    const ids = new Int32Array(4);
    const values = new Float64Array(4);
    weights(u, v, ids, values);
    interpolate(panel.position, ids, values, sample);
    camera.getWorldDirection(normal);
    grip = {
      panel, part: binding.part, pointerId: event.pointerId, ids, weights: values, uv: [u, v],
      offset: hit.point.clone().sub(sample), start: hit.point.clone(), target: hit.point.clone(),
      plane: new THREE.Plane().setFromNormalAndCoplanarPoint(normal, hit.point),
      startClosure: panel.closure, controlsEnabled: controls.enabled,
    };
    controls.enabled = false;
    suppress(event);
    try { canvas.setPointerCapture(event.pointerId); } catch { cancelGrip(); return; }
    win.addEventListener('wheel', suppress, eventOptions);
    canvas.style.cursor = 'grabbing';
    wake();
  }

  function pointerMove(event) {
    if (blocked.has(event.pointerId)) { suppress(event); return; }
    if (!grip) {
      if (event.target === canvas && event.pointerType !== 'touch') canvas.style.cursor = available() && pick(event) ? 'grab' : originalCursor;
      return;
    }
    if (event.pointerId !== grip.pointerId) return;
    suppress(event);
    if (!available()) { cancelGrip(); return; }
    if (!setRay(event) || !raycaster.ray.intersectPlane(grip.plane, point)) return;
    const panel = grip.panel;
    // Rail displacement is retained independently from elastic displacement.
    delta.copy(point).sub(grip.start);
    const travel = panel.meta.curtain_closed_width - panel.meta.curtain_open_width;
    const alongRail = delta.dot(panel.rail) / panel.rail.lengthSq();
    panel.targetClosure = clamp(grip.startClosure + alongRail / (Math.max(0.18, grip.uv[0]) * travel), 0, 1);
    sample.copy(panel.rail).multiplyScalar((panel.targetClosure - grip.startClosure) * travel * grip.uv[0]).add(grip.start);
    delta.copy(point).sub(sample).clampLength(0, 0.85);
    grip.target.copy(sample).add(delta);
    clampToRoom(grip.target);
    wake();
  }

  function pointerEnd(event) {
    if (blocked.delete(event.pointerId)) { suppress(event); return; }
    if (grip?.pointerId !== event.pointerId) return;
    suppress(event);
    cancelGrip();
  }

  function interrupt() {
    cancelGrip();
    blocked.clear();
    accumulator = 0;
    paused = true;
    for (const panel of panels) panel.previous.set(panel.position);
    canvas.style.cursor = originalCursor;
  }

  function visibilityChanged() {
    interrupt();
    if (available()) wake();
  }

  function preferenceChanged() {
    reduced = motion.matches;
    wind = windRequested && !reduced;
    wake();
  }

  function pointerLeave() { if (!grip) canvas.style.cursor = originalCursor; }
  function lostCapture(event) { if (grip?.pointerId === event.pointerId) cancelGrip(); }
  const eventOptions = { capture: true, passive: false };
  win.addEventListener('pointerdown', pointerDown, eventOptions);
  win.addEventListener('pointermove', pointerMove, eventOptions);
  win.addEventListener('pointerup', pointerEnd, eventOptions);
  win.addEventListener('pointercancel', pointerEnd, eventOptions);
  win.addEventListener('blur', interrupt);
  doc.addEventListener('visibilitychange', visibilityChanged);
  canvas.addEventListener('lostpointercapture', lostCapture);
  canvas.addEventListener('pointerleave', pointerLeave);
  motion.addEventListener('change', preferenceChanged);
  const observer = win.IntersectionObserver ? new win.IntersectionObserver(entries => {
    inView = entries[0].isIntersecting;
    visibilityChanged();
  }) : null;
  observer?.observe(canvas);

  function probe(panel, u, v, rect) {
    weights(u, v);
    interpolate(panel.position, cornerIds, cornerWeights, point);
    const world = point.toArray();
    point.project(camera);
    return { uv: [u, v], world, canvas: [(point.x + 1) * rect.width / 2, (1 - point.y) * rect.height / 2], inFrustum: Math.abs(point.x) <= 1 && Math.abs(point.y) <= 1 && Math.abs(point.z) <= 1 };
  }

  return {
    get count() { return panels.length; },
    get closure() {
      let sum = 0;
      for (const panel of panels) sum += panel.closure;
      return panels.length ? sum / panels.length : 0;
    },
    get targetClosure() {
      let sum = 0;
      for (const panel of panels) sum += panel.targetClosure;
      return panels.length ? sum / panels.length : 0;
    },
    get wind() { return wind; },
    get reducedMotion() { return reduced; },
    get grabbing() { return !!grip; },
    update(deltaSeconds, elapsedSeconds) {
      // Native lostpointercapture can wait for the next pointer event.
      if (grip && !canvas.hasPointerCapture(grip.pointerId)) cancelGrip();
      if (!available()) { if (!paused || grip) interrupt(); return false; }
      if (!panels.length) return false;
      if (paused) { paused = false; accumulator = 0; deltaSeconds = 0; }
      if (!active && !wind && !grip) return false;
      // Use simulation time, not wall-clock elapsedSeconds, so tab resumes never
      // jump the wind phase or integrate an accumulated background interval.
      accumulator += clamp(Number.isFinite(deltaSeconds) ? deltaSeconds : 0, 0, STEP * 4);
      let changed = false;
      while (accumulator >= STEP) {
        accumulator -= STEP;
        time += STEP;
        for (const panel of panels) stepPanel(panel);
        changed = true;
        const settling = panels.some(panel => panel.speed > 0.012 || Math.abs(panel.targetClosure - panel.closure) > 0.0001);
        quiet = settling || grip || wind ? 0 : quiet + STEP;
        if (quiet > (reduced ? 0.12 : 0.4)) {
          active = false;
          for (const panel of panels) { panel.previous.set(panel.position); panel.speed = 0; }
          break;
        }
      }
      if (changed) renderGeometry();
      return active || wind || !!grip;
    },
    setClosure(value) {
      if (disposed || !Number.isFinite(value)) return;
      cancelGrip();
      for (const panel of panels) panel.targetClosure = clamp(value, 0, 1);
      wake();
    },
    setWind(value) {
      if (!disposed) { windRequested = !!value; wind = windRequested && !reduced; wake(); }
      return wind;
    },
    setEnabled(value) {
      if (disposed || enabled === !!value) return;
      enabled = !!value;
      if (!enabled) interrupt(); else wake();
    },
    reset() {
      if (disposed) return;
      interrupt();
      windRequested = true;
      wind = !reduced;
      time = 0;
      for (const panel of panels) {
        panel.closure = panel.targetClosure = 0;
        panel.position.set(panel.rest);
        panel.previous.set(panel.rest);
        panel.speed = panel.displacement = 0;
        updateGoal(panel);
      }
      renderGeometry();
      wake();
    },
    snapshot() {
      const rect = canvas.getBoundingClientRect();
      camera.updateWorldMatrix(true, false);
      const result = {
        closure: panels.length ? panels.reduce((sum, panel) => sum + panel.closure, 0) / panels.length : 0,
        wind, grabbing: !!grip, enabled, reducedMotion: reduced,
        panels: panels.map(panel => {
          let topAnchorError = 0;
          for (let i = ROWS * STRIDE * 3; i < COUNT * 3; i += 3) topAnchorError = Math.max(topAnchorError, Math.hypot(panel.position[i] - panel.goal[i], panel.position[i + 1] - panel.goal[i + 1], panel.position[i + 2] - panel.goal[i + 2]));
          return { id: panel.id, closure: panel.closure, targetClosure: panel.targetClosure,
            maxDisplacement: panel.displacement, maxSpeed: panel.speed, topAnchorError,
            probes: [probe(panel, 0.55, 0.25, rect), probe(panel, 0.7, 0.5, rect), probe(panel, 0.8, 0.8, rect), probe(panel, 0.9, 1, rect), probe(panel, 0.55, 0, rect)] };
        }),
        grip: null,
      };
      if (grip) {
        interpolate(grip.panel.position, grip.ids, grip.weights, point).add(grip.offset);
        result.grip = { panel: grip.panel.id, part: grip.part, uv: [...grip.uv], point: point.toArray(), target: grip.target.toArray(), error: point.distanceTo(grip.target) };
      }
      return result;
    },
    dispose() {
      if (disposed) return;
      disposed = true;
      interrupt();
      observer?.disconnect();
      win.removeEventListener('pointerdown', pointerDown, true);
      win.removeEventListener('pointermove', pointerMove, true);
      win.removeEventListener('pointerup', pointerEnd, true);
      win.removeEventListener('pointercancel', pointerEnd, true);
      win.removeEventListener('blur', interrupt);
      doc.removeEventListener('visibilitychange', visibilityChanged);
      canvas.removeEventListener('lostpointercapture', lostCapture);
      canvas.removeEventListener('pointerleave', pointerLeave);
      motion.removeEventListener('change', preferenceChanged);
      // Geometry belongs to the caller: restore it, never dispose shared assets.
      for (const panel of panels) for (const binding of panel.bindings) {
        const geometry = binding.mesh.geometry;
        const positions = geometry.getAttribute('position');
        positions.array.set(binding.original);
        positions.setUsage(binding.originalUsage);
        positions.needsUpdate = true;
        if (binding.originalNormal) {
          geometry.getAttribute('normal').array.set(binding.originalNormal);
          geometry.getAttribute('normal').needsUpdate = true;
        } else geometry.deleteAttribute('normal');
        if (binding.originalTangent) {
          geometry.getAttribute('tangent').array.set(binding.originalTangent);
          geometry.getAttribute('tangent').needsUpdate = true;
        }
        binding.mesh.geometry.computeBoundingBox();
        binding.mesh.geometry.computeBoundingSphere();
      }
      fabricBindings.clear();
      blocked.clear();
    },
  };
}