@nice2dev/ui-3d 1.3.14 → 1.3.16

package/dist/cjs/model/modelEditorUtils.js

@@ -1,1244 +1,1159 @@
-'use strict';
-
-var THREE = require('three');
-
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
 function _interopNamespaceDefault(e) {
-   var n = Object.create(null);
-   if (e) {
-      Object.keys(e).forEach(function (k) {
-         if (k !== 'default') {
-            var d = Object.getOwnPropertyDescriptor(e, k);
-            Object.defineProperty(n, k, d.get ? d : {
-               enumerable: true,
-               get: function () { return e[k]; }
-            });
-         }
-      });
-   }
-   n.default = e;
-   return Object.freeze(n);
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
 }
-
-var THREE__namespace = /*#__PURE__*/_interopNamespaceDefault(THREE);
-
-/**
- * modelEditorUtils.ts — Utility functions for the ModelEditor.
- *
- * Features:
- * - Undo/Redo stack
- * - LOD auto-generation
- * - PBR material presets
- * - Batch import
- * - Instancing helpers
- */
+const THREE__namespace = /* @__PURE__ */ _interopNamespaceDefault(THREE);
 class UndoRedoStack {
-    constructor(maxSize = 50) {
-        this.undoStack = [];
-        this.redoStack = [];
-        this.maxSize = maxSize;
+  constructor(maxSize = 50) {
+    this.undoStack = [];
+    this.redoStack = [];
+    this.maxSize = maxSize;
+  }
+  push(action) {
+    this.undoStack.push(action);
+    if (this.undoStack.length > this.maxSize) {
+      this.undoStack.shift();
     }
-    push(action) {
-        this.undoStack.push(action);
-        if (this.undoStack.length > this.maxSize) {
-            this.undoStack.shift();
-        }
-        this.redoStack.length = 0;
+    this.redoStack.length = 0;
+  }
+  undo() {
+    const action = this.undoStack.pop();
+    if (!action) {
+      return null;
     }
-    undo() {
-        const action = this.undoStack.pop();
-        if (!action) {
-            return null;
-        }
-        action.undo();
-        this.redoStack.push(action);
-        return action.label;
+    action.undo();
+    this.redoStack.push(action);
+    return action.label;
+  }
+  redo() {
+    const action = this.redoStack.pop();
+    if (!action) {
+      return null;
     }
-    redo() {
-        const action = this.redoStack.pop();
-        if (!action) {
-            return null;
-        }
-        action.redo();
-        this.undoStack.push(action);
-        return action.label;
+    action.redo();
+    this.undoStack.push(action);
+    return action.label;
+  }
+  canUndo() {
+    return this.undoStack.length > 0;
+  }
+  canRedo() {
+    return this.redoStack.length > 0;
+  }
+  clear() {
+    this.undoStack.length = 0;
+    this.redoStack.length = 0;
+  }
+  get undoLabel() {
+    return this.undoStack.length > 0 ? this.undoStack[this.undoStack.length - 1].label : null;
+  }
+  get redoLabel() {
+    return this.redoStack.length > 0 ? this.redoStack[this.redoStack.length - 1].label : null;
+  }
+}
+const DEFAULT_LOD_LEVELS = [
+  { distance: 0, ratio: 1 },
+  { distance: 10, ratio: 0.5 },
+  { distance: 25, ratio: 0.25 },
+  { distance: 50, ratio: 0.1 }
+];
+function decimateGeometry(geometry, ratio) {
+  if (ratio >= 1) {
+    return geometry.clone();
+  }
+  const posAttr = geometry.getAttribute("position");
+  if (!posAttr) {
+    return geometry.clone();
+  }
+  const positions = Array.from(posAttr.array);
+  const vertexCount = posAttr.count;
+  const targetCount = Math.max(3, Math.floor(vertexCount * ratio));
+  const gridSize = Math.cbrt(vertexCount / targetCount) * 0.5;
+  const merged = /* @__PURE__ */ new Map();
+  const vertexMap = new Int32Array(vertexCount);
+  let newIndex = 0;
+  for (let i = 0; i < vertexCount; i++) {
+    const x = positions[i * 3];
+    const y = positions[i * 3 + 1];
+    const z = positions[i * 3 + 2];
+    const key = `${Math.round(x / gridSize)},${Math.round(y / gridSize)},${Math.round(z / gridSize)}`;
+    const existing = merged.get(key);
+    if (existing) {
+      existing.x += x;
+      existing.y += y;
+      existing.z += z;
+      existing.count++;
+      vertexMap[i] = existing.index;
+    } else {
+      merged.set(key, { x, y, z, count: 1, index: newIndex });
+      vertexMap[i] = newIndex;
+      newIndex++;
     }
-    canUndo() {
-        return this.undoStack.length > 0;
+  }
+  const newPositions = new Float32Array(merged.size * 3);
+  for (const cell of merged.values()) {
+    newPositions[cell.index * 3] = cell.x / cell.count;
+    newPositions[cell.index * 3 + 1] = cell.y / cell.count;
+    newPositions[cell.index * 3 + 2] = cell.z / cell.count;
+  }
+  const oldIndex = geometry.index;
+  const newIndices = [];
+  if (oldIndex) {
+    for (let i = 0; i < oldIndex.count; i += 3) {
+      const a = vertexMap[oldIndex.array[i]];
+      const b = vertexMap[oldIndex.array[i + 1]];
+      const c = vertexMap[oldIndex.array[i + 2]];
+      if (a !== b && b !== c && a !== c) {
+        newIndices.push(a, b, c);
+      }
     }
-    canRedo() {
-        return this.redoStack.length > 0;
+  } else {
+    for (let i = 0; i < vertexCount; i += 3) {
+      const a = vertexMap[i];
+      const b = vertexMap[i + 1];
+      const c = vertexMap[i + 2];
+      if (a !== b && b !== c && a !== c) {
+        newIndices.push(a, b, c);
+      }
     }
-    clear() {
-        this.undoStack.length = 0;
-        this.redoStack.length = 0;
+  }
+  const result = new THREE__namespace.BufferGeometry();
+  result.setAttribute("position", new THREE__namespace.BufferAttribute(newPositions, 3));
+  result.setIndex(newIndices);
+  result.computeVertexNormals();
+  return result;
+}
+function generateLOD(mesh, levels = DEFAULT_LOD_LEVELS) {
+  const lod = new THREE__namespace.LOD();
+  lod.name = mesh.name + "_LOD";
+  lod.position.copy(mesh.position);
+  lod.rotation.copy(mesh.rotation);
+  lod.scale.copy(mesh.scale);
+  for (const level of levels) {
+    const decimated = decimateGeometry(mesh.geometry, level.ratio);
+    const mat = Array.isArray(mesh.material) ? mesh.material.map((m) => m.clone()) : mesh.material.clone();
+    const lodMesh = new THREE__namespace.Mesh(decimated, mat);
+    lodMesh.castShadow = mesh.castShadow;
+    lodMesh.receiveShadow = mesh.receiveShadow;
+    lod.addLevel(lodMesh, level.distance);
+  }
+  return lod;
+}
+const PBR_PRESETS = [
+  // Metals
+  { name: "Gold", category: "Metal", params: { color: 16766720, metalness: 1, roughness: 0.15 } },
+  {
+    name: "Silver",
+    category: "Metal",
+    params: { color: 12632256, metalness: 1, roughness: 0.1 }
+  },
+  {
+    name: "Copper",
+    category: "Metal",
+    params: { color: 12088115, metalness: 1, roughness: 0.25 }
+  },
+  { name: "Iron", category: "Metal", params: { color: 8421504, metalness: 0.95, roughness: 0.6 } },
+  {
+    name: "Brushed Steel",
+    category: "Metal",
+    params: { color: 10526880, metalness: 0.95, roughness: 0.4 }
+  },
+  {
+    name: "Chrome",
+    category: "Metal",
+    params: { color: 14540253, metalness: 1, roughness: 0.02 }
+  },
+  {
+    name: "Bronze",
+    category: "Metal",
+    params: { color: 13467442, metalness: 0.9, roughness: 0.35 }
+  },
+  {
+    name: "Aluminum",
+    category: "Metal",
+    params: { color: 14079702, metalness: 0.85, roughness: 0.2 }
+  },
+  // Non-metals
+  {
+    name: "Plastic (White)",
+    category: "Plastic",
+    params: { color: 15790320, metalness: 0, roughness: 0.3 }
+  },
+  {
+    name: "Plastic (Red)",
+    category: "Plastic",
+    params: { color: 13378082, metalness: 0, roughness: 0.35 }
+  },
+  {
+    name: "Rubber",
+    category: "Plastic",
+    params: { color: 3355443, metalness: 0, roughness: 0.9 }
+  },
+  // Glass
+  {
+    name: "Clear Glass",
+    category: "Glass",
+    params: {
+      color: 16777215,
+      metalness: 0,
+      roughness: 0,
+      opacity: 0.15,
+      transparent: true,
+      ior: 1.5,
+      transmission: 0.95
     }
-    get undoLabel() {
-        return this.undoStack.length > 0 ? this.undoStack[this.undoStack.length - 1].label : null;
+  },
+  {
+    name: "Frosted Glass",
+    category: "Glass",
+    params: {
+      color: 15658751,
+      metalness: 0,
+      roughness: 0.5,
+      opacity: 0.3,
+      transparent: true,
+      ior: 1.5,
+      transmission: 0.7
     }
-    get redoLabel() {
-        return this.redoStack.length > 0 ? this.redoStack[this.redoStack.length - 1].label : null;
+  },
+  {
+    name: "Tinted Glass",
+    category: "Glass",
+    params: {
+      color: 2245768,
+      metalness: 0,
+      roughness: 0.05,
+      opacity: 0.3,
+      transparent: true,
+      ior: 1.5,
+      transmission: 0.8
     }
-}
-const DEFAULT_LOD_LEVELS = [
-    { distance: 0, ratio: 1.0 },
-    { distance: 10, ratio: 0.5 },
-    { distance: 25, ratio: 0.25 },
-    { distance: 50, ratio: 0.1 },
-];
-/**
- * Simple vertex decimation by merging nearby vertices.
- * Returns a new geometry with reduced vertex count.
- */
-function decimateGeometry(geometry, ratio) {
-    if (ratio >= 1.0) {
-        return geometry.clone();
+  },
+  // Natural
+  {
+    name: "Wood (Light)",
+    category: "Natural",
+    params: { color: 12687979, metalness: 0, roughness: 0.7 }
+  },
+  {
+    name: "Wood (Dark)",
+    category: "Natural",
+    params: { color: 6042391, metalness: 0, roughness: 0.65 }
+  },
+  {
+    name: "Stone",
+    category: "Natural",
+    params: { color: 8947848, metalness: 0, roughness: 0.85 }
+  },
+  {
+    name: "Marble",
+    category: "Natural",
+    params: { color: 15789280, metalness: 0, roughness: 0.15 }
+  },
+  {
+    name: "Clay",
+    category: "Natural",
+    params: { color: 11887901, metalness: 0, roughness: 0.8 }
+  },
+  {
+    name: "Concrete",
+    category: "Natural",
+    params: { color: 10066329, metalness: 0, roughness: 0.95 }
+  },
+  // Fabric
+  {
+    name: "Cotton (White)",
+    category: "Fabric",
+    params: {
+      color: 16119260,
+      metalness: 0,
+      roughness: 0.9,
+      sheen: 0.5,
+      sheenRoughness: 0.8,
+      sheenColor: 16777215
     }
-    const posAttr = geometry.getAttribute('position');
-    if (!posAttr) {
-        return geometry.clone();
+  },
+  {
+    name: "Silk",
+    category: "Fabric",
+    params: {
+      color: 14932681,
+      metalness: 0,
+      roughness: 0.3,
+      sheen: 1,
+      sheenRoughness: 0.3,
+      sheenColor: 16772829
     }
-    const positions = Array.from(posAttr.array);
-    const vertexCount = posAttr.count;
-    const targetCount = Math.max(3, Math.floor(vertexCount * ratio));
-    // Grid-based vertex merging
-    const gridSize = Math.cbrt(vertexCount / targetCount) * 0.5;
-    const merged = new Map();
-    const vertexMap = new Int32Array(vertexCount);
-    let newIndex = 0;
-    for (let i = 0; i < vertexCount; i++) {
-        const x = positions[i * 3];
-        const y = positions[i * 3 + 1];
-        const z = positions[i * 3 + 2];
-        const key = `${Math.round(x / gridSize)},${Math.round(y / gridSize)},${Math.round(z / gridSize)}`;
-        const existing = merged.get(key);
-        if (existing) {
-            existing.x += x;
-            existing.y += y;
-            existing.z += z;
-            existing.count++;
-            vertexMap[i] = existing.index;
-        }
-        else {
-            merged.set(key, { x, y, z, count: 1, index: newIndex });
-            vertexMap[i] = newIndex;
-            newIndex++;
-        }
+  },
+  {
+    name: "Velvet",
+    category: "Fabric",
+    params: {
+      color: 8388640,
+      metalness: 0,
+      roughness: 0.95,
+      sheen: 0.9,
+      sheenRoughness: 0.9,
+      sheenColor: 16728160
     }
-    // Build new positions
-    const newPositions = new Float32Array(merged.size * 3);
-    for (const cell of merged.values()) {
-        newPositions[cell.index * 3] = cell.x / cell.count;
-        newPositions[cell.index * 3 + 1] = cell.y / cell.count;
-        newPositions[cell.index * 3 + 2] = cell.z / cell.count;
+  },
+  {
+    name: "Leather",
+    category: "Fabric",
+    params: { color: 5583650, metalness: 0, roughness: 0.6 }
+  },
+  {
+    name: "Denim",
+    category: "Fabric",
+    params: { color: 3889560, metalness: 0, roughness: 0.85 }
+  },
+  // Skin
+  {
+    name: "Skin (Light)",
+    category: "Skin",
+    params: { color: 16767916, metalness: 0, roughness: 0.55 }
+  },
+  {
+    name: "Skin (Medium)",
+    category: "Skin",
+    params: { color: 13010498, metalness: 0, roughness: 0.5 }
+  },
+  {
+    name: "Skin (Dark)",
+    category: "Skin",
+    params: { color: 9262372, metalness: 0, roughness: 0.5 }
+  },
+  // Special
+  {
+    name: "Car Paint",
+    category: "Special",
+    params: {
+      color: 13369344,
+      metalness: 0.5,
+      roughness: 0.15,
+      clearcoat: 1,
+      clearcoatRoughness: 0.05
     }
-    // Build new indices
-    const oldIndex = geometry.index;
-    const newIndices = [];
-    if (oldIndex) {
-        for (let i = 0; i < oldIndex.count; i += 3) {
-            const a = vertexMap[oldIndex.array[i]];
-            const b = vertexMap[oldIndex.array[i + 1]];
-            const c = vertexMap[oldIndex.array[i + 2]];
-            if (a !== b && b !== c && a !== c) {
-                newIndices.push(a, b, c);
-            }
-        }
+  },
+  {
+    name: "Emissive (Blue)",
+    category: "Special",
+    params: {
+      color: 1118481,
+      metalness: 0,
+      roughness: 0.5,
+      emissive: 35071,
+      emissiveIntensity: 2
     }
-    else {
-        for (let i = 0; i < vertexCount; i += 3) {
-            const a = vertexMap[i];
-            const b = vertexMap[i + 1];
-            const c = vertexMap[i + 2];
-            if (a !== b && b !== c && a !== c) {
-                newIndices.push(a, b, c);
-            }
-        }
+  },
+  {
+    name: "Emissive (Orange)",
+    category: "Special",
+    params: {
+      color: 1118481,
+      metalness: 0,
+      roughness: 0.5,
+      emissive: 16737792,
+      emissiveIntensity: 2
     }
-    const result = new THREE__namespace.BufferGeometry();
-    result.setAttribute('position', new THREE__namespace.BufferAttribute(newPositions, 3));
-    result.setIndex(newIndices);
-    result.computeVertexNormals();
-    return result;
-}
-/**
- * Creates a THREE.LOD object from a mesh with automatic level generation.
- */
-function generateLOD(mesh, levels = DEFAULT_LOD_LEVELS) {
-    const lod = new THREE__namespace.LOD();
-    lod.name = mesh.name + '_LOD';
-    lod.position.copy(mesh.position);
-    lod.rotation.copy(mesh.rotation);
-    lod.scale.copy(mesh.scale);
-    for (const level of levels) {
-        const decimated = decimateGeometry(mesh.geometry, level.ratio);
-        const mat = Array.isArray(mesh.material)
-            ? mesh.material.map((m) => m.clone())
-            : mesh.material.clone();
-        const lodMesh = new THREE__namespace.Mesh(decimated, mat);
-        lodMesh.castShadow = mesh.castShadow;
-        lodMesh.receiveShadow = mesh.receiveShadow;
-        lod.addLevel(lodMesh, level.distance);
+  },
+  {
+    name: "Neon",
+    category: "Special",
+    params: {
+      color: 0,
+      metalness: 0,
+      roughness: 0.1,
+      emissive: 65416,
+      emissiveIntensity: 5
     }
-    return lod;
-}
-const PBR_PRESETS = [
-    // Metals
-    { name: 'Gold', category: 'Metal', params: { color: 0xffd700, metalness: 1.0, roughness: 0.15 } },
-    {
-        name: 'Silver',
-        category: 'Metal',
-        params: { color: 0xc0c0c0, metalness: 1.0, roughness: 0.1 },
-    },
-    {
-        name: 'Copper',
-        category: 'Metal',
-        params: { color: 0xb87333, metalness: 1.0, roughness: 0.25 },
-    },
-    { name: 'Iron', category: 'Metal', params: { color: 0x808080, metalness: 0.95, roughness: 0.6 } },
-    {
-        name: 'Brushed Steel',
-        category: 'Metal',
-        params: { color: 0xa0a0a0, metalness: 0.95, roughness: 0.4 },
-    },
-    {
-        name: 'Chrome',
-        category: 'Metal',
-        params: { color: 0xdddddd, metalness: 1.0, roughness: 0.02 },
-    },
-    {
-        name: 'Bronze',
-        category: 'Metal',
-        params: { color: 0xcd7f32, metalness: 0.9, roughness: 0.35 },
-    },
-    {
-        name: 'Aluminum',
-        category: 'Metal',
-        params: { color: 0xd6d6d6, metalness: 0.85, roughness: 0.2 },
-    },
-    // Non-metals
-    {
-        name: 'Plastic (White)',
-        category: 'Plastic',
-        params: { color: 0xf0f0f0, metalness: 0.0, roughness: 0.3 },
-    },
-    {
-        name: 'Plastic (Red)',
-        category: 'Plastic',
-        params: { color: 0xcc2222, metalness: 0.0, roughness: 0.35 },
-    },
-    {
-        name: 'Rubber',
-        category: 'Plastic',
-        params: { color: 0x333333, metalness: 0.0, roughness: 0.9 },
-    },
-    // Glass
-    {
-        name: 'Clear Glass',
-        category: 'Glass',
-        params: {
-            color: 0xffffff,
-            metalness: 0.0,
-            roughness: 0.0,
-            opacity: 0.15,
-            transparent: true,
-            ior: 1.5,
-            transmission: 0.95,
-        },
-    },
-    {
-        name: 'Frosted Glass',
-        category: 'Glass',
-        params: {
-            color: 0xeeeeff,
-            metalness: 0.0,
-            roughness: 0.5,
-            opacity: 0.3,
-            transparent: true,
-            ior: 1.5,
-            transmission: 0.7,
-        },
-    },
-    {
-        name: 'Tinted Glass',
-        category: 'Glass',
-        params: {
-            color: 0x224488,
-            metalness: 0.0,
-            roughness: 0.05,
-            opacity: 0.3,
-            transparent: true,
-            ior: 1.5,
-            transmission: 0.8,
-        },
-    },
-    // Natural
-    {
-        name: 'Wood (Light)',
-        category: 'Natural',
-        params: { color: 0xc19a6b, metalness: 0.0, roughness: 0.7 },
-    },
-    {
-        name: 'Wood (Dark)',
-        category: 'Natural',
-        params: { color: 0x5c3317, metalness: 0.0, roughness: 0.65 },
-    },
-    {
-        name: 'Stone',
-        category: 'Natural',
-        params: { color: 0x888888, metalness: 0.0, roughness: 0.85 },
-    },
-    {
-        name: 'Marble',
-        category: 'Natural',
-        params: { color: 0xf0ece0, metalness: 0.0, roughness: 0.15 },
-    },
-    {
-        name: 'Clay',
-        category: 'Natural',
-        params: { color: 0xb5651d, metalness: 0.0, roughness: 0.8 },
-    },
-    {
-        name: 'Concrete',
-        category: 'Natural',
-        params: { color: 0x999999, metalness: 0.0, roughness: 0.95 },
-    },
-    // Fabric
-    {
-        name: 'Cotton (White)',
-        category: 'Fabric',
-        params: {
-            color: 0xf5f5dc,
-            metalness: 0.0,
-            roughness: 0.9,
-            sheen: 0.5,
-            sheenRoughness: 0.8,
-            sheenColor: 0xffffff,
-        },
-    },
-    {
-        name: 'Silk',
-        category: 'Fabric',
-        params: {
-            color: 0xe3dac9,
-            metalness: 0.0,
-            roughness: 0.3,
-            sheen: 1.0,
-            sheenRoughness: 0.3,
-            sheenColor: 0xffeedd,
-        },
-    },
-    {
-        name: 'Velvet',
-        category: 'Fabric',
-        params: {
-            color: 0x800020,
-            metalness: 0.0,
-            roughness: 0.95,
-            sheen: 0.9,
-            sheenRoughness: 0.9,
-            sheenColor: 0xff4060,
-        },
-    },
-    {
-        name: 'Leather',
-        category: 'Fabric',
-        params: { color: 0x553322, metalness: 0.0, roughness: 0.6 },
-    },
-    {
-        name: 'Denim',
-        category: 'Fabric',
-        params: { color: 0x3b5998, metalness: 0.0, roughness: 0.85 },
-    },
-    // Skin
-    {
-        name: 'Skin (Light)',
-        category: 'Skin',
-        params: { color: 0xffdbac, metalness: 0.0, roughness: 0.55 },
-    },
-    {
-        name: 'Skin (Medium)',
-        category: 'Skin',
-        params: { color: 0xc68642, metalness: 0.0, roughness: 0.5 },
-    },
-    {
-        name: 'Skin (Dark)',
-        category: 'Skin',
-        params: { color: 0x8d5524, metalness: 0.0, roughness: 0.5 },
-    },
-    // Special
-    {
-        name: 'Car Paint',
-        category: 'Special',
-        params: {
-            color: 0xcc0000,
-            metalness: 0.5,
-            roughness: 0.15,
-            clearcoat: 1.0,
-            clearcoatRoughness: 0.05,
-        },
-    },
-    {
-        name: 'Emissive (Blue)',
-        category: 'Special',
-        params: {
-            color: 0x111111,
-            metalness: 0.0,
-            roughness: 0.5,
-            emissive: 0x0088ff,
-            emissiveIntensity: 2.0,
-        },
-    },
-    {
-        name: 'Emissive (Orange)',
-        category: 'Special',
-        params: {
-            color: 0x111111,
-            metalness: 0.0,
-            roughness: 0.5,
-            emissive: 0xff6600,
-            emissiveIntensity: 2.0,
-        },
-    },
-    {
-        name: 'Neon',
-        category: 'Special',
-        params: {
-            color: 0x000000,
-            metalness: 0.0,
-            roughness: 0.1,
-            emissive: 0x00ff88,
-            emissiveIntensity: 5.0,
-        },
-    },
+  }
 ];
-/**
- * Apply a PBR preset to a MeshStandardMaterial or MeshPhysicalMaterial.
- */
 function applyPBRPreset(material, preset) {
-    var _a, _b;
-    const p = preset.params;
-    // Upgrade to MeshPhysicalMaterial if needed for advanced features
-    const needsPhysical = p.clearcoat != null || p.transmission != null || p.sheen != null || p.ior != null;
-    if (material instanceof THREE__namespace.MeshPhysicalMaterial) {
-        material.color.setHex(p.color);
-        material.metalness = p.metalness;
-        material.roughness = p.roughness;
-        if (p.emissive != null) {
-            material.emissive.setHex(p.emissive);
-        }
-        if (p.emissiveIntensity != null) {
-            material.emissiveIntensity = p.emissiveIntensity;
-        }
-        if (p.opacity != null) {
-            material.opacity = p.opacity;
-        }
-        material.transparent = (_a = p.transparent) !== null && _a !== void 0 ? _a : false;
-        if (p.clearcoat != null) {
-            material.clearcoat = p.clearcoat;
-        }
-        if (p.clearcoatRoughness != null) {
-            material.clearcoatRoughness = p.clearcoatRoughness;
-        }
-        if (p.ior != null) {
-            material.ior = p.ior;
-        }
-        if (p.transmission != null) {
-            material.transmission = p.transmission;
-        }
-        if (p.sheen != null) {
-            material.sheen = p.sheen;
-        }
-        if (p.sheenRoughness != null) {
-            material.sheenRoughness = p.sheenRoughness;
-        }
-        if (p.sheenColor != null) {
-            material.sheenColor.setHex(p.sheenColor);
-        }
-        material.needsUpdate = true;
+  const p = preset.params;
+  const needsPhysical = p.clearcoat != null || p.transmission != null || p.sheen != null || p.ior != null;
+  if (material instanceof THREE__namespace.MeshPhysicalMaterial) {
+    material.color.setHex(p.color);
+    material.metalness = p.metalness;
+    material.roughness = p.roughness;
+    if (p.emissive != null) {
+      material.emissive.setHex(p.emissive);
     }
-    else if (material instanceof THREE__namespace.MeshStandardMaterial && !needsPhysical) {
-        material.color.setHex(p.color);
-        material.metalness = p.metalness;
-        material.roughness = p.roughness;
-        if (p.emissive != null) {
-            material.emissive.setHex(p.emissive);
-        }
-        if (p.emissiveIntensity != null) {
-            material.emissiveIntensity = p.emissiveIntensity;
-        }
-        if (p.opacity != null) {
-            material.opacity = p.opacity;
-        }
-        material.transparent = (_b = p.transparent) !== null && _b !== void 0 ? _b : false;
-        material.needsUpdate = true;
+    if (p.emissiveIntensity != null) {
+      material.emissiveIntensity = p.emissiveIntensity;
+    }
+    if (p.opacity != null) {
+      material.opacity = p.opacity;
+    }
+    material.transparent = p.transparent ?? false;
+    if (p.clearcoat != null) {
+      material.clearcoat = p.clearcoat;
     }
+    if (p.clearcoatRoughness != null) {
+      material.clearcoatRoughness = p.clearcoatRoughness;
+    }
+    if (p.ior != null) {
+      material.ior = p.ior;
+    }
+    if (p.transmission != null) {
+      material.transmission = p.transmission;
+    }
+    if (p.sheen != null) {
+      material.sheen = p.sheen;
+    }
+    if (p.sheenRoughness != null) {
+      material.sheenRoughness = p.sheenRoughness;
+    }
+    if (p.sheenColor != null) {
+      material.sheenColor.setHex(p.sheenColor);
+    }
+    material.needsUpdate = true;
+  } else if (material instanceof THREE__namespace.MeshStandardMaterial && !needsPhysical) {
+    material.color.setHex(p.color);
+    material.metalness = p.metalness;
+    material.roughness = p.roughness;
+    if (p.emissive != null) {
+      material.emissive.setHex(p.emissive);
+    }
+    if (p.emissiveIntensity != null) {
+      material.emissiveIntensity = p.emissiveIntensity;
+    }
+    if (p.opacity != null) {
+      material.opacity = p.opacity;
+    }
+    material.transparent = p.transparent ?? false;
+    material.needsUpdate = true;
+  }
 }
-/** Create a new MeshPhysicalMaterial from a preset. */
 function createMaterialFromPreset(preset) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
-    const p = preset.params;
-    return new THREE__namespace.MeshPhysicalMaterial({
-        color: p.color,
-        metalness: p.metalness,
-        roughness: p.roughness,
-        emissive: (_a = p.emissive) !== null && _a !== void 0 ? _a : 0x000000,
-        emissiveIntensity: (_b = p.emissiveIntensity) !== null && _b !== void 0 ? _b : 0,
-        opacity: (_c = p.opacity) !== null && _c !== void 0 ? _c : 1,
-        transparent: (_d = p.transparent) !== null && _d !== void 0 ? _d : false,
-        clearcoat: (_e = p.clearcoat) !== null && _e !== void 0 ? _e : 0,
-        clearcoatRoughness: (_f = p.clearcoatRoughness) !== null && _f !== void 0 ? _f : 0,
-        ior: (_g = p.ior) !== null && _g !== void 0 ? _g : 1.5,
-        transmission: (_h = p.transmission) !== null && _h !== void 0 ? _h : 0,
-        sheen: (_j = p.sheen) !== null && _j !== void 0 ? _j : 0,
-        sheenRoughness: (_k = p.sheenRoughness) !== null && _k !== void 0 ? _k : 0,
-        sheenColor: new THREE__namespace.Color((_l = p.sheenColor) !== null && _l !== void 0 ? _l : 0x000000),
-    });
+  const p = preset.params;
+  return new THREE__namespace.MeshPhysicalMaterial({
+    color: p.color,
+    metalness: p.metalness,
+    roughness: p.roughness,
+    emissive: p.emissive ?? 0,
+    emissiveIntensity: p.emissiveIntensity ?? 0,
+    opacity: p.opacity ?? 1,
+    transparent: p.transparent ?? false,
+    clearcoat: p.clearcoat ?? 0,
+    clearcoatRoughness: p.clearcoatRoughness ?? 0,
+    ior: p.ior ?? 1.5,
+    transmission: p.transmission ?? 0,
+    sheen: p.sheen ?? 0,
+    sheenRoughness: p.sheenRoughness ?? 0,
+    sheenColor: new THREE__namespace.Color(p.sheenColor ?? 0)
+  });
 }
-/* ═══════════════════════════════════════════
-   4. INSTANCING
-   ═══════════════════════════════════════════ */
-/**
- * Convert duplicate meshes to InstancedMesh for better performance.
- * Groups meshes by geometry UUID + material UUID.
- */
 function convertToInstanced(parent) {
-    var _a;
-    const groups = new Map();
-    parent.traverse((child) => {
-        if (child instanceof THREE__namespace.Mesh && !child.name.startsWith('__')) {
-            const geoId = child.geometry.uuid;
-            const matId = Array.isArray(child.material)
-                ? child.material.map((m) => m.uuid).join(',')
-                : child.material.uuid;
-            const key = `${geoId}|${matId}`;
-            let list = groups.get(key);
-            if (!list) {
-                list = [];
-                groups.set(key, list);
-            }
-            list.push(child);
-        }
-    });
-    let created = 0;
-    let removed = 0;
-    for (const [, meshes] of groups) {
-        if (meshes.length < 2) {
-            continue;
-        }
-        const source = meshes[0];
-        const instancedMesh = new THREE__namespace.InstancedMesh(source.geometry, source.material, meshes.length);
-        instancedMesh.name = source.name + '_Instanced';
-        instancedMesh.castShadow = source.castShadow;
-        instancedMesh.receiveShadow = source.receiveShadow;
-        const matrix = new THREE__namespace.Matrix4();
-        for (let i = 0; i < meshes.length; i++) {
-            meshes[i].updateWorldMatrix(true, false);
-            matrix.copy(meshes[i].matrixWorld);
-            instancedMesh.setMatrixAt(i, matrix);
-        }
-        instancedMesh.instanceMatrix.needsUpdate = true;
-        parent.add(instancedMesh);
-        created++;
-        for (const mesh of meshes) {
-            (_a = mesh.parent) === null || _a === void 0 ? void 0 : _a.remove(mesh);
-            removed++;
-        }
+  const groups = /* @__PURE__ */ new Map();
+  parent.traverse((child) => {
+    if (child instanceof THREE__namespace.Mesh && !child.name.startsWith("__")) {
+      const geoId = child.geometry.uuid;
+      const matId = Array.isArray(child.material) ? child.material.map((m) => m.uuid).join(",") : child.material.uuid;
+      const key = `${geoId}|${matId}`;
+      let list = groups.get(key);
+      if (!list) {
+        list = [];
+        groups.set(key, list);
+      }
+      list.push(child);
     }
-    return { created, removed };
+  });
+  let created = 0;
+  let removed = 0;
+  for (const [, meshes] of groups) {
+    if (meshes.length < 2) {
+      continue;
+    }
+    const source = meshes[0];
+    const instancedMesh = new THREE__namespace.InstancedMesh(source.geometry, source.material, meshes.length);
+    instancedMesh.name = source.name + "_Instanced";
+    instancedMesh.castShadow = source.castShadow;
+    instancedMesh.receiveShadow = source.receiveShadow;
+    const matrix = new THREE__namespace.Matrix4();
+    for (let i = 0; i < meshes.length; i++) {
+      meshes[i].updateWorldMatrix(true, false);
+      matrix.copy(meshes[i].matrixWorld);
+      instancedMesh.setMatrixAt(i, matrix);
+    }
+    instancedMesh.instanceMatrix.needsUpdate = true;
+    parent.add(instancedMesh);
+    created++;
+    for (const mesh of meshes) {
+      mesh.parent?.remove(mesh);
+      removed++;
+    }
+  }
+  return { created, removed };
 }
-/* ═══════════════════════════════════════════
-   5. GEOMETRY HELPERS
-   ═══════════════════════════════════════════ */
-/** Count total triangles in a scene. */
 function countTriangles(object) {
-    let count = 0;
-    object.traverse((child) => {
-        if (child instanceof THREE__namespace.Mesh) {
-            const geo = child.geometry;
-            if (geo.index) {
-                count += geo.index.count / 3;
-            }
-            else {
-                const pos = geo.getAttribute('position');
-                if (pos) {
-                    count += pos.count / 3;
-                }
-            }
+  let count = 0;
+  object.traverse((child) => {
+    if (child instanceof THREE__namespace.Mesh) {
+      const geo = child.geometry;
+      if (geo.index) {
+        count += geo.index.count / 3;
+      } else {
+        const pos = geo.getAttribute("position");
+        if (pos) {
+          count += pos.count / 3;
         }
-    });
-    return Math.round(count);
+      }
+    }
+  });
+  return Math.round(count);
 }
-/** Compute bounding box for an object and all its children. */
 function computeSceneBounds(object) {
-    const box = new THREE__namespace.Box3();
-    object.traverse((child) => {
-        if (child instanceof THREE__namespace.Mesh) {
-            child.geometry.computeBoundingBox();
-            if (child.geometry.boundingBox) {
-                const worldBox = child.geometry.boundingBox.clone();
-                worldBox.applyMatrix4(child.matrixWorld);
-                box.union(worldBox);
-            }
-        }
-    });
-    return box;
+  const box = new THREE__namespace.Box3();
+  object.traverse((child) => {
+    if (child instanceof THREE__namespace.Mesh) {
+      child.geometry.computeBoundingBox();
+      if (child.geometry.boundingBox) {
+        const worldBox = child.geometry.boundingBox.clone();
+        worldBox.applyMatrix4(child.matrixWorld);
+        box.union(worldBox);
+      }
+    }
+  });
+  return box;
 }
-/** Measure distance between two world-space points. */
 function measureDistance(a, b) {
-    return a.distanceTo(b);
+  return a.distanceTo(b);
 }
-/** Measure angle (in degrees) between three world-space points (vertex at B). */
 function measureAngle(a, b, c) {
-    const ba = new THREE__namespace.Vector3().subVectors(a, b).normalize();
-    const bc = new THREE__namespace.Vector3().subVectors(c, b).normalize();
-    return THREE__namespace.MathUtils.radToDeg(Math.acos(THREE__namespace.MathUtils.clamp(ba.dot(bc), -1, 1)));
+  const ba = new THREE__namespace.Vector3().subVectors(a, b).normalize();
+  const bc = new THREE__namespace.Vector3().subVectors(c, b).normalize();
+  return THREE__namespace.MathUtils.radToDeg(Math.acos(THREE__namespace.MathUtils.clamp(ba.dot(bc), -1, 1)));
 }
 const HDRI_PRESETS = [
-    // Studio
-    {
-        name: 'Studio Soft',
-        category: 'Studio',
-        bgColor: 0x1a1a2e,
-        envIntensity: 1.0,
-        ambientColor: 0xffffff,
-        ambientIntensity: 0.6,
-        dirColor: 0xffffff,
-        dirIntensity: 1.2,
-        dirPosition: [5, 10, 7],
-        exposure: 1.0,
-    },
-    {
-        name: 'Studio High Key',
-        category: 'Studio',
-        bgColor: 0xf0f0f0,
-        envIntensity: 1.2,
-        ambientColor: 0xffffff,
-        ambientIntensity: 1.0,
-        dirColor: 0xffffff,
-        dirIntensity: 1.5,
-        dirPosition: [2, 8, 3],
-        exposure: 1.2,
-    },
-    {
-        name: 'Studio Low Key',
-        category: 'Studio',
-        bgColor: 0x0a0a0a,
-        envIntensity: 0.5,
-        ambientColor: 0x222244,
-        ambientIntensity: 0.2,
-        dirColor: 0xffeedd,
-        dirIntensity: 2.0,
-        dirPosition: [3, 5, 2],
-        exposure: 0.8,
-    },
-    {
-        name: 'Studio Rim',
-        category: 'Studio',
-        bgColor: 0x111111,
-        envIntensity: 0.3,
-        ambientColor: 0x111122,
-        ambientIntensity: 0.15,
-        dirColor: 0xffffff,
-        dirIntensity: 2.5,
-        dirPosition: [-5, 3, -2],
-        exposure: 0.9,
-    },
-    // Outdoor
-    {
-        name: 'Sunny Day',
-        category: 'Outdoor',
-        bgColor: 0x87ceeb,
-        envIntensity: 1.0,
-        ambientColor: 0x8ec8f0,
-        ambientIntensity: 0.4,
-        dirColor: 0xfff4e0,
-        dirIntensity: 2.0,
-        dirPosition: [5, 10, 5],
-        exposure: 1.0,
-    },
-    {
-        name: 'Overcast',
-        category: 'Outdoor',
-        bgColor: 0xb0b0b8,
-        envIntensity: 0.8,
-        ambientColor: 0xccccdd,
-        ambientIntensity: 0.7,
-        dirColor: 0xddddee,
-        dirIntensity: 0.5,
-        dirPosition: [0, 10, 0],
-        fog: { color: 0xccccdd, near: 20, far: 200 },
-        exposure: 1.0,
-    },
-    {
-        name: 'Golden Hour',
-        category: 'Outdoor',
-        bgColor: 0xff8844,
-        envIntensity: 1.0,
-        ambientColor: 0xffaa55,
-        ambientIntensity: 0.3,
-        dirColor: 0xff9933,
-        dirIntensity: 2.5,
-        dirPosition: [10, 2, 5],
-        exposure: 1.1,
-    },
-    {
-        name: 'Blue Hour',
-        category: 'Outdoor',
-        bgColor: 0x1a2a4a,
-        envIntensity: 0.6,
-        ambientColor: 0x334466,
-        ambientIntensity: 0.3,
-        dirColor: 0x6688cc,
-        dirIntensity: 0.8,
-        dirPosition: [-5, 3, 5],
-        exposure: 0.8,
-    },
-    {
-        name: 'Night',
-        category: 'Outdoor',
-        bgColor: 0x050510,
-        envIntensity: 0.1,
-        ambientColor: 0x111133,
-        ambientIntensity: 0.05,
-        dirColor: 0xaabbdd,
-        dirIntensity: 0.3,
-        dirPosition: [-3, 8, 2],
-        exposure: 0.5,
-    },
-    // Interior
-    {
-        name: 'Warm Interior',
-        category: 'Interior',
-        bgColor: 0x2a1a10,
-        envIntensity: 0.7,
-        ambientColor: 0xffddaa,
-        ambientIntensity: 0.4,
-        dirColor: 0xffeebb,
-        dirIntensity: 1.0,
-        dirPosition: [2, 5, 3],
-        exposure: 1.0,
-    },
-    {
-        name: 'Cool Office',
-        category: 'Interior',
-        bgColor: 0x1a2230,
-        envIntensity: 0.8,
-        ambientColor: 0xddeeff,
-        ambientIntensity: 0.6,
-        dirColor: 0xffffff,
-        dirIntensity: 0.8,
-        dirPosition: [0, 8, 0],
-        exposure: 1.0,
-    },
-    {
-        name: 'Gallery',
-        category: 'Interior',
-        bgColor: 0xfafafa,
-        envIntensity: 1.0,
-        ambientColor: 0xffffff,
-        ambientIntensity: 0.8,
-        dirColor: 0xffffff,
-        dirIntensity: 0.6,
-        dirPosition: [0, 10, 2],
-        exposure: 1.1,
-    },
-    // Dramatic
-    {
-        name: 'Neon City',
-        category: 'Dramatic',
-        bgColor: 0x0a0015,
-        envIntensity: 0.4,
-        ambientColor: 0xff00ff,
-        ambientIntensity: 0.2,
-        dirColor: 0x00ffff,
-        dirIntensity: 1.5,
-        dirPosition: [-3, 5, 2],
-        exposure: 1.0,
-    },
-    {
-        name: 'Cinematic',
-        category: 'Dramatic',
-        bgColor: 0x0f0f1a,
-        envIntensity: 0.5,
-        ambientColor: 0x223344,
-        ambientIntensity: 0.15,
-        dirColor: 0xffeedd,
-        dirIntensity: 2.0,
-        dirPosition: [8, 4, 2],
-        exposure: 0.9,
-    },
-    {
-        name: 'Sunrise',
-        category: 'Dramatic',
-        bgColor: 0xff6633,
-        envIntensity: 0.8,
-        ambientColor: 0xffaa66,
-        ambientIntensity: 0.3,
-        dirColor: 0xff7744,
-        dirIntensity: 2.0,
-        dirPosition: [15, 1, 0],
-        exposure: 1.2,
-    },
-    {
-        name: 'Desert',
-        category: 'Dramatic',
-        bgColor: 0xe8c888,
-        envIntensity: 1.0,
-        ambientColor: 0xddcc99,
-        ambientIntensity: 0.5,
-        dirColor: 0xfff0cc,
-        dirIntensity: 2.5,
-        dirPosition: [5, 12, 3],
-        exposure: 1.3,
-    },
+  // Studio
+  {
+    name: "Studio Soft",
+    category: "Studio",
+    bgColor: 1710638,
+    envIntensity: 1,
+    ambientColor: 16777215,
+    ambientIntensity: 0.6,
+    dirColor: 16777215,
+    dirIntensity: 1.2,
+    dirPosition: [5, 10, 7],
+    exposure: 1
+  },
+  {
+    name: "Studio High Key",
+    category: "Studio",
+    bgColor: 15790320,
+    envIntensity: 1.2,
+    ambientColor: 16777215,
+    ambientIntensity: 1,
+    dirColor: 16777215,
+    dirIntensity: 1.5,
+    dirPosition: [2, 8, 3],
+    exposure: 1.2
+  },
+  {
+    name: "Studio Low Key",
+    category: "Studio",
+    bgColor: 657930,
+    envIntensity: 0.5,
+    ambientColor: 2236996,
+    ambientIntensity: 0.2,
+    dirColor: 16772829,
+    dirIntensity: 2,
+    dirPosition: [3, 5, 2],
+    exposure: 0.8
+  },
+  {
+    name: "Studio Rim",
+    category: "Studio",
+    bgColor: 1118481,
+    envIntensity: 0.3,
+    ambientColor: 1118498,
+    ambientIntensity: 0.15,
+    dirColor: 16777215,
+    dirIntensity: 2.5,
+    dirPosition: [-5, 3, -2],
+    exposure: 0.9
+  },
+  // Outdoor
+  {
+    name: "Sunny Day",
+    category: "Outdoor",
+    bgColor: 8900331,
+    envIntensity: 1,
+    ambientColor: 9357552,
+    ambientIntensity: 0.4,
+    dirColor: 16774368,
+    dirIntensity: 2,
+    dirPosition: [5, 10, 5],
+    exposure: 1
+  },
+  {
+    name: "Overcast",
+    category: "Outdoor",
+    bgColor: 11579576,
+    envIntensity: 0.8,
+    ambientColor: 13421789,
+    ambientIntensity: 0.7,
+    dirColor: 14540270,
+    dirIntensity: 0.5,
+    dirPosition: [0, 10, 0],
+    fog: { color: 13421789, near: 20, far: 200 },
+    exposure: 1
+  },
+  {
+    name: "Golden Hour",
+    category: "Outdoor",
+    bgColor: 16746564,
+    envIntensity: 1,
+    ambientColor: 16755285,
+    ambientIntensity: 0.3,
+    dirColor: 16750899,
+    dirIntensity: 2.5,
+    dirPosition: [10, 2, 5],
+    exposure: 1.1
+  },
+  {
+    name: "Blue Hour",
+    category: "Outdoor",
+    bgColor: 1714762,
+    envIntensity: 0.6,
+    ambientColor: 3359846,
+    ambientIntensity: 0.3,
+    dirColor: 6719692,
+    dirIntensity: 0.8,
+    dirPosition: [-5, 3, 5],
+    exposure: 0.8
+  },
+  {
+    name: "Night",
+    category: "Outdoor",
+    bgColor: 328976,
+    envIntensity: 0.1,
+    ambientColor: 1118515,
+    ambientIntensity: 0.05,
+    dirColor: 11189213,
+    dirIntensity: 0.3,
+    dirPosition: [-3, 8, 2],
+    exposure: 0.5
+  },
+  // Interior
+  {
+    name: "Warm Interior",
+    category: "Interior",
+    bgColor: 2759184,
+    envIntensity: 0.7,
+    ambientColor: 16768426,
+    ambientIntensity: 0.4,
+    dirColor: 16772795,
+    dirIntensity: 1,
+    dirPosition: [2, 5, 3],
+    exposure: 1
+  },
+  {
+    name: "Cool Office",
+    category: "Interior",
+    bgColor: 1712688,
+    envIntensity: 0.8,
+    ambientColor: 14544639,
+    ambientIntensity: 0.6,
+    dirColor: 16777215,
+    dirIntensity: 0.8,
+    dirPosition: [0, 8, 0],
+    exposure: 1
+  },
+  {
+    name: "Gallery",
+    category: "Interior",
+    bgColor: 16448250,
+    envIntensity: 1,
+    ambientColor: 16777215,
+    ambientIntensity: 0.8,
+    dirColor: 16777215,
+    dirIntensity: 0.6,
+    dirPosition: [0, 10, 2],
+    exposure: 1.1
+  },
+  // Dramatic
+  {
+    name: "Neon City",
+    category: "Dramatic",
+    bgColor: 655381,
+    envIntensity: 0.4,
+    ambientColor: 16711935,
+    ambientIntensity: 0.2,
+    dirColor: 65535,
+    dirIntensity: 1.5,
+    dirPosition: [-3, 5, 2],
+    exposure: 1
+  },
+  {
+    name: "Cinematic",
+    category: "Dramatic",
+    bgColor: 986906,
+    envIntensity: 0.5,
+    ambientColor: 2241348,
+    ambientIntensity: 0.15,
+    dirColor: 16772829,
+    dirIntensity: 2,
+    dirPosition: [8, 4, 2],
+    exposure: 0.9
+  },
+  {
+    name: "Sunrise",
+    category: "Dramatic",
+    bgColor: 16737843,
+    envIntensity: 0.8,
+    ambientColor: 16755302,
+    ambientIntensity: 0.3,
+    dirColor: 16742212,
+    dirIntensity: 2,
+    dirPosition: [15, 1, 0],
+    exposure: 1.2
+  },
+  {
+    name: "Desert",
+    category: "Dramatic",
+    bgColor: 15255688,
+    envIntensity: 1,
+    ambientColor: 14535833,
+    ambientIntensity: 0.5,
+    dirColor: 16773324,
+    dirIntensity: 2.5,
+    dirPosition: [5, 12, 3],
+    exposure: 1.3
+  }
 ];
-/**
- * Apply an HDRI preset to a Three.js scene and renderer.
- */
 function applyHDRIPreset(scene, renderer, preset) {
-    // Background
-    scene.background = new THREE__namespace.Color(preset.bgColor);
-    // Tone mapping exposure
-    renderer.toneMappingExposure = preset.exposure;
-    // Update ambient light (find existing or create)
-    let ambient;
-    let directional;
-    scene.traverse((child) => {
-        if (child instanceof THREE__namespace.AmbientLight && !ambient) {
-            ambient = child;
-        }
-        if (child instanceof THREE__namespace.DirectionalLight && !directional) {
-            directional = child;
-        }
-    });
-    if (ambient != null) {
-        ambient.color.setHex(preset.ambientColor);
-        ambient.intensity = preset.ambientIntensity;
-    }
-    if (directional != null) {
-        directional.color.setHex(preset.dirColor);
-        directional.intensity = preset.dirIntensity;
-        directional.position.set(...preset.dirPosition);
+  scene.background = new THREE__namespace.Color(preset.bgColor);
+  renderer.toneMappingExposure = preset.exposure;
+  let ambient;
+  let directional;
+  scene.traverse((child) => {
+    if (child instanceof THREE__namespace.AmbientLight && !ambient) {
+      ambient = child;
     }
-    // Fog
-    if (preset.fog) {
-        scene.fog = new THREE__namespace.Fog(preset.fog.color, preset.fog.near, preset.fog.far);
-    }
-    else {
-        scene.fog = null;
+    if (child instanceof THREE__namespace.DirectionalLight && !directional) {
+      directional = child;
     }
+  });
+  if (ambient != null) {
+    ambient.color.setHex(preset.ambientColor);
+    ambient.intensity = preset.ambientIntensity;
+  }
+  if (directional != null) {
+    directional.color.setHex(preset.dirColor);
+    directional.intensity = preset.dirIntensity;
+    directional.position.set(...preset.dirPosition);
+  }
+  if (preset.fog) {
+    scene.fog = new THREE__namespace.Fog(preset.fog.color, preset.fog.near, preset.fog.far);
+  } else {
+    scene.fog = null;
+  }
 }
-/** Snap a point to the nearest grid intersection. */
 function snapToGrid(point, gridSize) {
-    return new THREE__namespace.Vector3(Math.round(point.x / gridSize) * gridSize, Math.round(point.y / gridSize) * gridSize, Math.round(point.z / gridSize) * gridSize);
+  return new THREE__namespace.Vector3(
+    Math.round(point.x / gridSize) * gridSize,
+    Math.round(point.y / gridSize) * gridSize,
+    Math.round(point.z / gridSize) * gridSize
+  );
 }
-/** Find the closest vertex in a mesh to a given world-space point. */
 function snapToVertex(point, scene, maxDistance = Infinity) {
-    let closest = null;
-    let minDist = maxDistance;
-    const tmpV = new THREE__namespace.Vector3();
-    scene.traverse((child) => {
-        if (!(child instanceof THREE__namespace.Mesh)) {
-            return;
-        }
-        const posAttr = child.geometry.getAttribute('position');
-        if (!posAttr) {
-            return;
-        }
-        child.updateWorldMatrix(true, false);
-        for (let i = 0; i < posAttr.count; i++) {
-            tmpV.fromBufferAttribute(posAttr, i);
-            tmpV.applyMatrix4(child.matrixWorld);
-            const d = point.distanceTo(tmpV);
-            if (d < minDist) {
-                minDist = d;
-                closest = { point: tmpV.clone(), target: 'vertex', object: child };
-            }
-        }
-    });
-    return closest;
+  let closest = null;
+  let minDist = maxDistance;
+  const tmpV = new THREE__namespace.Vector3();
+  scene.traverse((child) => {
+    if (!(child instanceof THREE__namespace.Mesh)) {
+      return;
+    }
+    const posAttr = child.geometry.getAttribute("position");
+    if (!posAttr) {
+      return;
+    }
+    child.updateWorldMatrix(true, false);
+    for (let i = 0; i < posAttr.count; i++) {
+      tmpV.fromBufferAttribute(posAttr, i);
+      tmpV.applyMatrix4(child.matrixWorld);
+      const d = point.distanceTo(tmpV);
+      if (d < minDist) {
+        minDist = d;
+        closest = { point: tmpV.clone(), target: "vertex", object: child };
+      }
+    }
+  });
+  return closest;
 }
-/** Find the closest point on any edge in the scene to a given world-space point. */
 function snapToEdge(point, scene, maxDistance = Infinity) {
-    let closest = null;
-    let minDist = maxDistance;
-    const a = new THREE__namespace.Vector3();
-    const b = new THREE__namespace.Vector3();
-    scene.traverse((child) => {
-        if (!(child instanceof THREE__namespace.Mesh)) {
-            return;
-        }
-        const posAttr = child.geometry.getAttribute('position');
-        if (!posAttr) {
-            return;
-        }
-        const index = child.geometry.index;
-        child.updateWorldMatrix(true, false);
-        const processEdge = (i0, i1) => {
-            a.fromBufferAttribute(posAttr, i0).applyMatrix4(child.matrixWorld);
-            b.fromBufferAttribute(posAttr, i1).applyMatrix4(child.matrixWorld);
-            const closestOnEdge = closestPointOnSegment(point, a, b);
-            const d = point.distanceTo(closestOnEdge);
-            if (d < minDist) {
-                minDist = d;
-                closest = { point: closestOnEdge.clone(), target: 'edge', object: child };
-            }
-        };
-        if (index) {
-            for (let i = 0; i < index.count; i += 3) {
-                const i0 = index.array[i], i1 = index.array[i + 1], i2 = index.array[i + 2];
-                processEdge(i0, i1);
-                processEdge(i1, i2);
-                processEdge(i2, i0);
-            }
-        }
-        else {
-            for (let i = 0; i < posAttr.count; i += 3) {
-                processEdge(i, i + 1);
-                processEdge(i + 1, i + 2);
-                processEdge(i + 2, i);
-            }
-        }
-    });
-    return closest;
+  let closest = null;
+  let minDist = maxDistance;
+  const a = new THREE__namespace.Vector3();
+  const b = new THREE__namespace.Vector3();
+  scene.traverse((child) => {
+    if (!(child instanceof THREE__namespace.Mesh)) {
+      return;
+    }
+    const posAttr = child.geometry.getAttribute("position");
+    if (!posAttr) {
+      return;
+    }
+    const index = child.geometry.index;
+    child.updateWorldMatrix(true, false);
+    const processEdge = (i0, i1) => {
+      a.fromBufferAttribute(posAttr, i0).applyMatrix4(child.matrixWorld);
+      b.fromBufferAttribute(posAttr, i1).applyMatrix4(child.matrixWorld);
+      const closestOnEdge = closestPointOnSegment(point, a, b);
+      const d = point.distanceTo(closestOnEdge);
+      if (d < minDist) {
+        minDist = d;
+        closest = { point: closestOnEdge.clone(), target: "edge", object: child };
+      }
+    };
+    if (index) {
+      for (let i = 0; i < index.count; i += 3) {
+        const i0 = index.array[i], i1 = index.array[i + 1], i2 = index.array[i + 2];
+        processEdge(i0, i1);
+        processEdge(i1, i2);
+        processEdge(i2, i0);
+      }
+    } else {
+      for (let i = 0; i < posAttr.count; i += 3) {
+        processEdge(i, i + 1);
+        processEdge(i + 1, i + 2);
+        processEdge(i + 2, i);
+      }
+    }
+  });
+  return closest;
 }
-/** Find closest point on a line segment. */
 function closestPointOnSegment(p, a, b) {
-    const ab = new THREE__namespace.Vector3().subVectors(b, a);
-    const ap = new THREE__namespace.Vector3().subVectors(p, a);
-    const t = THREE__namespace.MathUtils.clamp(ap.dot(ab) / ab.dot(ab), 0, 1);
-    return new THREE__namespace.Vector3().addVectors(a, ab.multiplyScalar(t));
+  const ab = new THREE__namespace.Vector3().subVectors(b, a);
+  const ap = new THREE__namespace.Vector3().subVectors(p, a);
+  const t = THREE__namespace.MathUtils.clamp(ap.dot(ab) / ab.dot(ab), 0, 1);
+  return new THREE__namespace.Vector3().addVectors(a, ab.multiplyScalar(t));
 }
-/**
- * Multi-mode snap: tries vertex/edge/grid in priority order.
- * Returns the best snap within maxDistance, or grid snap as fallback.
- */
-function snapMulti(point, scene, gridSize, modes = ['vertex', 'edge', 'grid'], maxDistance = 0.5) {
-    for (const mode of modes) {
-        if (mode === 'vertex') {
-            const result = snapToVertex(point, scene, maxDistance);
-            if (result) {
-                return result;
-            }
-        }
-        else if (mode === 'edge') {
-            const result = snapToEdge(point, scene, maxDistance);
-            if (result) {
-                return result;
-            }
-        }
-        else if (mode === 'grid') {
-            return { point: snapToGrid(point, gridSize), target: 'grid' };
-        }
+function snapMulti(point, scene, gridSize, modes = ["vertex", "edge", "grid"], maxDistance = 0.5) {
+  for (const mode of modes) {
+    if (mode === "vertex") {
+      const result = snapToVertex(point, scene, maxDistance);
+      if (result) {
+        return result;
+      }
+    } else if (mode === "edge") {
+      const result = snapToEdge(point, scene, maxDistance);
+      if (result) {
+        return result;
+      }
+    } else if (mode === "grid") {
+      return { point: snapToGrid(point, gridSize), target: "grid" };
     }
-    return { point: snapToGrid(point, gridSize), target: 'grid' };
+  }
+  return { point: snapToGrid(point, gridSize), target: "grid" };
 }
-/** Evaluate a cubic bezier segment at parameter t (0-1). */
 function cubicBezier(p0, p1, p2, p3, t) {
-    const t2 = t * t;
-    const t3 = t2 * t;
-    const mt = 1 - t;
-    const mt2 = mt * mt;
-    const mt3 = mt2 * mt;
-    return mt3 * p0 + 3 * mt2 * t * p1 + 3 * mt * t2 * p2 + t3 * p3;
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const mt = 1 - t;
+  const mt2 = mt * mt;
+  const mt3 = mt2 * mt;
+  return mt3 * p0 + 3 * mt2 * t * p1 + 3 * mt * t2 * p2 + t3 * p3;
 }
-/** Evaluate a keyframe track at a given time. */
 function evaluateTrack(track, time) {
-    var _a, _b;
-    const { keyframes } = track;
-    if (keyframes.length === 0) {
-        return 0;
+  const { keyframes } = track;
+  if (keyframes.length === 0) {
+    return 0;
+  }
+  if (keyframes.length === 1) {
+    return keyframes[0].value;
+  }
+  if (time <= keyframes[0].time) {
+    return keyframes[0].value;
+  }
+  if (time >= keyframes[keyframes.length - 1].time) {
+    return keyframes[keyframes.length - 1].value;
+  }
+  let left = 0;
+  for (let i = 1; i < keyframes.length; i++) {
+    if (keyframes[i].time >= time) {
+      left = i - 1;
+      break;
     }
-    if (keyframes.length === 1) {
-        return keyframes[0].value;
-    }
-    // Clamp to range
-    if (time <= keyframes[0].time) {
-        return keyframes[0].value;
-    }
-    if (time >= keyframes[keyframes.length - 1].time) {
-        return keyframes[keyframes.length - 1].value;
-    }
-    // Find surrounding keyframes
-    let left = 0;
-    for (let i = 1; i < keyframes.length; i++) {
-        if (keyframes[i].time >= time) {
-            left = i - 1;
-            break;
-        }
-    }
-    const right = left + 1;
-    const kfL = keyframes[left];
-    const kfR = keyframes[right];
-    const dt = kfR.time - kfL.time;
-    if (dt === 0) {
-        return kfL.value;
-    }
-    const t = (time - kfL.time) / dt;
-    switch (kfL.interpolation) {
-        case 'constant':
-            return kfL.value;
-        case 'linear':
-            return kfL.value + (kfR.value - kfL.value) * t;
-        case 'ease-in':
-            return kfL.value + (kfR.value - kfL.value) * (t * t);
-        case 'ease-out':
-            return kfL.value + (kfR.value - kfL.value) * (1 - (1 - t) * (1 - t));
-        case 'ease-in-out':
-            return (kfL.value + (kfR.value - kfL.value) * (t < 0.5 ? 2 * t * t : 1 - 2 * (1 - t) * (1 - t)));
-        case 'bezier': {
-            const handleR = (_a = kfL.handleRight) !== null && _a !== void 0 ? _a : { y: 0 };
-            const handleL = (_b = kfR.handleLeft) !== null && _b !== void 0 ? _b : { y: 0 };
-            return cubicBezier(kfL.value, kfL.value + handleR.y, kfR.value + handleL.y, kfR.value, t);
-        }
-        default:
-            return kfL.value + (kfR.value - kfL.value) * t;
+  }
+  const right = left + 1;
+  const kfL = keyframes[left];
+  const kfR = keyframes[right];
+  const dt = kfR.time - kfL.time;
+  if (dt === 0) {
+    return kfL.value;
+  }
+  const t = (time - kfL.time) / dt;
+  switch (kfL.interpolation) {
+    case "constant":
+      return kfL.value;
+    case "linear":
+      return kfL.value + (kfR.value - kfL.value) * t;
+    case "ease-in":
+      return kfL.value + (kfR.value - kfL.value) * (t * t);
+    case "ease-out":
+      return kfL.value + (kfR.value - kfL.value) * (1 - (1 - t) * (1 - t));
+    case "ease-in-out":
+      return kfL.value + (kfR.value - kfL.value) * (t < 0.5 ? 2 * t * t : 1 - 2 * (1 - t) * (1 - t));
+    case "bezier": {
+      const handleR = kfL.handleRight ?? { y: 0 };
+      const handleL = kfR.handleLeft ?? { y: 0 };
+      return cubicBezier(kfL.value, kfL.value + handleR.y, kfR.value + handleL.y, kfR.value, t);
     }
+    default:
+      return kfL.value + (kfR.value - kfL.value) * t;
+  }
 }
-/** Insert or update a keyframe at a given time. */
-function setKeyframe(track, time, value, interpolation = 'bezier') {
-    // Find existing keyframe at same time (within epsilon)
-    const epsilon = 0.001;
-    const existingIdx = track.keyframes.findIndex((kf) => Math.abs(kf.time - time) < epsilon);
-    const kf = { time, value, interpolation };
-    if (existingIdx >= 0) {
-        track.keyframes[existingIdx] = kf;
-    }
-    else {
-        track.keyframes.push(kf);
-        track.keyframes.sort((a, b) => a.time - b.time);
-    }
-    return kf;
+function setKeyframe(track, time, value, interpolation = "bezier") {
+  const epsilon = 1e-3;
+  const existingIdx = track.keyframes.findIndex((kf2) => Math.abs(kf2.time - time) < epsilon);
+  const kf = { time, value, interpolation };
+  if (existingIdx >= 0) {
+    track.keyframes[existingIdx] = kf;
+  } else {
+    track.keyframes.push(kf);
+    track.keyframes.sort((a, b) => a.time - b.time);
+  }
+  return kf;
 }
-/** Remove a keyframe at a given time. */
 function removeKeyframe(track, time) {
-    const epsilon = 0.001;
-    const idx = track.keyframes.findIndex((kf) => Math.abs(kf.time - time) < epsilon);
-    if (idx >= 0) {
-        track.keyframes.splice(idx, 1);
-        return true;
-    }
-    return false;
+  const epsilon = 1e-3;
+  const idx = track.keyframes.findIndex((kf) => Math.abs(kf.time - time) < epsilon);
+  if (idx >= 0) {
+    track.keyframes.splice(idx, 1);
+    return true;
+  }
+  return false;
 }
-/** Convert KeyframeTrack to THREE.KeyframeTrack for use in AnimationClip. */
 function toThreeKeyframeTrack(track, sampleRate = 30) {
-    if (track.keyframes.length === 0) {
-        return new THREE__namespace.NumberKeyframeTrack(track.property, [0], [0]);
-    }
-    const startTime = track.keyframes[0].time;
-    const endTime = track.keyframes[track.keyframes.length - 1].time;
-    const duration = endTime - startTime;
-    const numSamples = Math.max(2, Math.ceil(duration * sampleRate));
-    const times = [];
-    const values = [];
-    for (let i = 0; i < numSamples; i++) {
-        const t = startTime + (duration * i) / (numSamples - 1);
-        times.push(t);
-        values.push(evaluateTrack(track, t));
-    }
-    return new THREE__namespace.NumberKeyframeTrack(track.property, times, values);
+  if (track.keyframes.length === 0) {
+    return new THREE__namespace.NumberKeyframeTrack(track.property, [0], [0]);
+  }
+  const startTime = track.keyframes[0].time;
+  const endTime = track.keyframes[track.keyframes.length - 1].time;
+  const duration = endTime - startTime;
+  const numSamples = Math.max(2, Math.ceil(duration * sampleRate));
+  const times = [];
+  const values = [];
+  for (let i = 0; i < numSamples; i++) {
+    const t = startTime + duration * i / (numSamples - 1);
+    times.push(t);
+    values.push(evaluateTrack(track, t));
+  }
+  return new THREE__namespace.NumberKeyframeTrack(track.property, times, values);
 }
-/** Create an AnimationClip from multiple KeyframeTracks. */
 function createAnimationClip(name, tracks, sampleRate = 30) {
-    const threeTracks = tracks.map((t) => toThreeKeyframeTrack(t, sampleRate));
-    return new THREE__namespace.AnimationClip(name, -1, threeTracks);
+  const threeTracks = tracks.map((t) => toThreeKeyframeTrack(t, sampleRate));
+  return new THREE__namespace.AnimationClip(name, -1, threeTracks);
 }
-/** Trigger a file download in the browser. */
 function downloadBlob(blob, filename) {
-    const url = URL.createObjectURL(blob);
-    const a = document.createElement('a');
-    a.href = url;
-    a.download = filename;
-    document.body.appendChild(a);
-    a.click();
-    document.body.removeChild(a);
-    URL.revokeObjectURL(url);
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url);
 }
-/** Export scene to ArrayBuffer as GLTF/GLB with optional Draco. */
 async function exportSceneGLTF(scene, options = {}) {
-    const { GLTFExporter } = await import('three/examples/jsm/exporters/GLTFExporter.js');
-    const exporter = new GLTFExporter();
-    return new Promise((resolve, reject) => {
-        var _a, _b;
-        exporter.parse(scene, (result) => resolve(result), (error) => reject(error), {
-            binary: (_a = options.binary) !== null && _a !== void 0 ? _a : true,
-            animations: (_b = options.animations) !== null && _b !== void 0 ? _b : [],
-        });
-    });
+  const { GLTFExporter } = await import("three/examples/jsm/exporters/GLTFExporter.js");
+  const exporter = new GLTFExporter();
+  return new Promise((resolve, reject) => {
+    exporter.parse(
+      scene,
+      (result) => resolve(result),
+      (error) => reject(error),
+      {
+        binary: options.binary ?? true,
+        animations: options.animations ?? []
+      }
+    );
+  });
 }
-/** Export scene to USDZ format (Apple AR). */
 async function exportSceneUSDZ(scene) {
-    const { USDZExporter } = await import('three/examples/jsm/exporters/USDZExporter.js');
-    const exporter = new USDZExporter();
-    const arraybuffer = await new Promise((resolve, reject) => {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- USDZExporter.parse callback signature varies between three.js minor versions
-        exporter.parse(scene, resolve, reject);
-    });
-    return new Blob([arraybuffer], { type: 'model/vnd.usdz+zip' });
+  const { USDZExporter } = await import("three/examples/jsm/exporters/USDZExporter.js");
+  const exporter = new USDZExporter();
+  const arraybuffer = await new Promise((resolve, reject) => {
+    exporter.parse(scene, resolve, reject);
+  });
+  return new Blob([arraybuffer], { type: "model/vnd.usdz+zip" });
 }
-/**
- * Setup crossfade between two animation actions.
- * Smoothly transitions from current to target over duration.
- */
 function crossfadeAnimations(mixer, fromAction, toAction, duration = 0.5) {
-    toAction.reset();
-    toAction.setEffectiveTimeScale(1);
-    toAction.setEffectiveWeight(1);
-    toAction.play();
-    fromAction.crossFadeTo(toAction, duration, true);
+  toAction.reset();
+  toAction.setEffectiveTimeScale(1);
+  toAction.setEffectiveWeight(1);
+  toAction.play();
+  fromAction.crossFadeTo(toAction, duration, true);
 }
-/**
- * Setup additive blending for an animation action.
- * Additive animations can layer on top of other animations.
- */
 function makeAdditiveAction(mixer, clip, referenceClip) {
-    const action = mixer.clipAction(clip);
-    if (referenceClip) {
-        THREE__namespace.AnimationUtils.makeClipAdditive(clip, 0, referenceClip);
-    }
-    action.blendMode = THREE__namespace.AdditiveAnimationBlendMode;
-    return action;
+  const action = mixer.clipAction(clip);
+  if (referenceClip) {
+    THREE__namespace.AnimationUtils.makeClipAdditive(clip, 0, referenceClip);
+  }
+  action.blendMode = THREE__namespace.AdditiveAnimationBlendMode;
+  return action;
 }
-/**
- * Apply weighted blend to multiple animation actions.
- * Normalizes weights so they sum to 1.0.
- */
 function blendAnimations(actions) {
-    const totalWeight = actions.reduce((sum, a) => sum + a.weight, 0);
-    if (totalWeight === 0) {
-        return;
-    }
-    for (const { action, weight } of actions) {
-        const normalizedWeight = weight / totalWeight;
-        action.setEffectiveWeight(normalizedWeight);
-        if (!action.isRunning()) {
-            action.play();
-        }
+  const totalWeight = actions.reduce((sum, a) => sum + a.weight, 0);
+  if (totalWeight === 0) {
+    return;
+  }
+  for (const { action, weight } of actions) {
+    const normalizedWeight = weight / totalWeight;
+    action.setEffectiveWeight(normalizedWeight);
+    if (!action.isRunning()) {
+      action.play();
     }
+  }
 }
-/**
- * Create a sub-clip from an existing animation clip (trim).
- */
 function subclip(clip, name, startFrame, endFrame, fps = 30) {
-    return THREE__namespace.AnimationUtils.subclip(clip, name, startFrame, endFrame, fps);
+  return THREE__namespace.AnimationUtils.subclip(clip, name, startFrame, endFrame, fps);
 }
-/**
- * Simple CCD (Cyclic Coordinate Descent) IK solver.
- * Iteratively rotates each bone in the chain to reach the target.
- */
 function solveIKChain(skeleton, chain) {
-    const { bones: boneNames, target, iterations = 10, tolerance = 0.001 } = chain;
-    const bones = [];
-    for (const name of boneNames) {
-        const bone = skeleton.bones.find((b) => b.name === name);
-        if (!bone) {
-            return false;
-        }
-        bones.push(bone);
-    }
-    if (bones.length < 2) {
-        return false;
-    }
-    const endEffector = bones[bones.length - 1];
-    const endPos = new THREE__namespace.Vector3();
-    const toEnd = new THREE__namespace.Vector3();
-    const toTarget = new THREE__namespace.Vector3();
-    const axis = new THREE__namespace.Vector3();
-    const quat = new THREE__namespace.Quaternion();
-    for (let iter = 0; iter < iterations; iter++) {
-        // Get end-effector world position
-        endEffector.updateWorldMatrix(true, false);
-        endPos.setFromMatrixPosition(endEffector.matrixWorld);
-        if (endPos.distanceTo(target) < tolerance) {
-            return true;
-        }
-        // Iterate bones from end to root (skip end-effector)
-        for (let i = bones.length - 2; i >= 0; i--) {
-            const bone = bones[i];
-            bone.updateWorldMatrix(true, false);
-            const boneWorldPos = new THREE__namespace.Vector3().setFromMatrixPosition(bone.matrixWorld);
-            // Direction from bone to end-effector
-            endEffector.updateWorldMatrix(true, false);
-            endPos.setFromMatrixPosition(endEffector.matrixWorld);
-            toEnd.subVectors(endPos, boneWorldPos).normalize();
-            // Direction from bone to target
-            toTarget.subVectors(target, boneWorldPos).normalize();
-            // Calculate rotation axis and angle
-            const dot = THREE__namespace.MathUtils.clamp(toEnd.dot(toTarget), -1, 1);
-            const angle = Math.acos(dot);
-            if (angle > 0.0001) {
-                axis.crossVectors(toEnd, toTarget).normalize();
-                // Convert to bone local space
-                const boneWorldQuat = new THREE__namespace.Quaternion();
-                bone.getWorldQuaternion(boneWorldQuat);
-                const invWorldQuat = boneWorldQuat.clone().invert();
-                const localAxis = axis.clone().applyQuaternion(invWorldQuat);
-                // Apply limited rotation
-                const maxAngle = Math.PI / 6; // 30° per iteration
-                const clampedAngle = Math.min(angle, maxAngle);
-                quat.setFromAxisAngle(localAxis, clampedAngle);
-                bone.quaternion.premultiply(quat);
-                bone.updateWorldMatrix(true, true);
-            }
-        }
+  const { bones: boneNames, target, iterations = 10, tolerance = 1e-3 } = chain;
+  const bones = [];
+  for (const name of boneNames) {
+    const bone = skeleton.bones.find((b) => b.name === name);
+    if (!bone) {
+      return false;
     }
+    bones.push(bone);
+  }
+  if (bones.length < 2) {
+    return false;
+  }
+  const endEffector = bones[bones.length - 1];
+  const endPos = new THREE__namespace.Vector3();
+  const toEnd = new THREE__namespace.Vector3();
+  const toTarget = new THREE__namespace.Vector3();
+  const axis = new THREE__namespace.Vector3();
+  const quat = new THREE__namespace.Quaternion();
+  for (let iter = 0; iter < iterations; iter++) {
     endEffector.updateWorldMatrix(true, false);
     endPos.setFromMatrixPosition(endEffector.matrixWorld);
-    return endPos.distanceTo(target) < tolerance;
+    if (endPos.distanceTo(target) < tolerance) {
+      return true;
+    }
+    for (let i = bones.length - 2; i >= 0; i--) {
+      const bone = bones[i];
+      bone.updateWorldMatrix(true, false);
+      const boneWorldPos = new THREE__namespace.Vector3().setFromMatrixPosition(bone.matrixWorld);
+      endEffector.updateWorldMatrix(true, false);
+      endPos.setFromMatrixPosition(endEffector.matrixWorld);
+      toEnd.subVectors(endPos, boneWorldPos).normalize();
+      toTarget.subVectors(target, boneWorldPos).normalize();
+      const dot = THREE__namespace.MathUtils.clamp(toEnd.dot(toTarget), -1, 1);
+      const angle = Math.acos(dot);
+      if (angle > 1e-4) {
+        axis.crossVectors(toEnd, toTarget).normalize();
+        const boneWorldQuat = new THREE__namespace.Quaternion();
+        bone.getWorldQuaternion(boneWorldQuat);
+        const invWorldQuat = boneWorldQuat.clone().invert();
+        const localAxis = axis.clone().applyQuaternion(invWorldQuat);
+        const maxAngle = Math.PI / 6;
+        const clampedAngle = Math.min(angle, maxAngle);
+        quat.setFromAxisAngle(localAxis, clampedAngle);
+        bone.quaternion.premultiply(quat);
+        bone.updateWorldMatrix(true, true);
+      }
+    }
+  }
+  endEffector.updateWorldMatrix(true, false);
+  endPos.setFromMatrixPosition(endEffector.matrixWorld);
+  return endPos.distanceTo(target) < tolerance;
 }
-/** Standard quad viewport layout. */
 const QUAD_VIEWPORT = [
-    { preset: 'perspective', x: 0.5, y: 0.5, width: 0.5, height: 0.5 },
-    { preset: 'top', x: 0, y: 0.5, width: 0.5, height: 0.5 },
-    { preset: 'front', x: 0, y: 0, width: 0.5, height: 0.5 },
-    { preset: 'right', x: 0.5, y: 0, width: 0.5, height: 0.5 },
+  { preset: "perspective", x: 0.5, y: 0.5, width: 0.5, height: 0.5 },
+  { preset: "top", x: 0, y: 0.5, width: 0.5, height: 0.5 },
+  { preset: "front", x: 0, y: 0, width: 0.5, height: 0.5 },
+  { preset: "right", x: 0.5, y: 0, width: 0.5, height: 0.5 }
 ];
-/** Camera position/rotation for orthographic viewport presets. */
 const VIEWPORT_CAMERAS = {
-    perspective: { position: [5, 5, 5], up: [0, 1, 0], ortho: false },
-    top: { position: [0, 10, 0], up: [0, 0, -1], ortho: true },
-    front: { position: [0, 0, 10], up: [0, 1, 0], ortho: true },
-    right: { position: [10, 0, 0], up: [0, 1, 0], ortho: true },
-    left: { position: [-10, 0, 0], up: [0, 1, 0], ortho: true },
-    back: { position: [0, 0, -10], up: [0, 1, 0], ortho: true },
-    bottom: { position: [0, -10, 0], up: [0, 0, 1], ortho: true },
+  perspective: { position: [5, 5, 5], up: [0, 1, 0], ortho: false },
+  top: { position: [0, 10, 0], up: [0, 0, -1], ortho: true },
+  front: { position: [0, 0, 10], up: [0, 1, 0], ortho: true },
+  right: { position: [10, 0, 0], up: [0, 1, 0], ortho: true },
+  left: { position: [-10, 0, 0], up: [0, 1, 0], ortho: true },
+  back: { position: [0, 0, -10], up: [0, 1, 0], ortho: true },
+  bottom: { position: [0, -10, 0], up: [0, 0, 1], ortho: true }
 };
-/**
- * Create a camera for a viewport preset.
- */
 function createViewportCamera(preset, aspect = 1, frustumSize = 10) {
-    const config = VIEWPORT_CAMERAS[preset];
-    if (config.ortho) {
-        const camera = new THREE__namespace.OrthographicCamera((-frustumSize * aspect) / 2, (frustumSize * aspect) / 2, frustumSize / 2, -frustumSize / 2, 0.01, 10000);
-        camera.position.set(...config.position);
-        camera.up.set(...config.up);
-        camera.lookAt(0, 0, 0);
-        return camera;
-    }
-    const camera = new THREE__namespace.PerspectiveCamera(50, aspect, 0.01, 10000);
-    camera.position.set(...config.position);
-    camera.up.set(...config.up);
-    camera.lookAt(0, 0, 0);
-    return camera;
+  const config = VIEWPORT_CAMERAS[preset];
+  if (config.ortho) {
+    const camera2 = new THREE__namespace.OrthographicCamera(
+      -frustumSize * aspect / 2,
+      frustumSize * aspect / 2,
+      frustumSize / 2,
+      -frustumSize / 2,
+      0.01,
+      1e4
+    );
+    camera2.position.set(...config.position);
+    camera2.up.set(...config.up);
+    camera2.lookAt(0, 0, 0);
+    return camera2;
+  }
+  const camera = new THREE__namespace.PerspectiveCamera(50, aspect, 0.01, 1e4);
+  camera.position.set(...config.position);
+  camera.up.set(...config.up);
+  camera.lookAt(0, 0, 0);
+  return camera;
 }
-/**
- * Render a multi-viewport layout to a single renderer.
- */
 function renderMultiViewport(renderer, scene, viewports) {
-    const { width, height } = renderer.getSize(new THREE__namespace.Vector2());
-    renderer.setScissorTest(true);
-    for (const { camera, config } of viewports) {
-        const left = Math.floor(config.x * width);
-        const bottom = Math.floor(config.y * height);
-        const vpWidth = Math.floor(config.width * width);
-        const vpHeight = Math.floor(config.height * height);
-        renderer.setViewport(left, bottom, vpWidth, vpHeight);
-        renderer.setScissor(left, bottom, vpWidth, vpHeight);
-        renderer.render(scene, camera);
-    }
-    renderer.setScissorTest(false);
+  const { width, height } = renderer.getSize(new THREE__namespace.Vector2());
+  renderer.setScissorTest(true);
+  for (const { camera, config } of viewports) {
+    const left = Math.floor(config.x * width);
+    const bottom = Math.floor(config.y * height);
+    const vpWidth = Math.floor(config.width * width);
+    const vpHeight = Math.floor(config.height * height);
+    renderer.setViewport(left, bottom, vpWidth, vpHeight);
+    renderer.setScissor(left, bottom, vpWidth, vpHeight);
+    renderer.render(scene, camera);
+  }
+  renderer.setScissorTest(false);
 }
-
 exports.HDRI_PRESETS = HDRI_PRESETS;
 exports.PBR_PRESETS = PBR_PRESETS;
 exports.QUAD_VIEWPORT = QUAD_VIEWPORT;