@nice2dev/ui-3d 1.0.0 → 1.0.2

package/dist/cjs/model/modelEditorUtils.js

@@ -0,0 +1,1049 @@
+'use strict';
+
+var 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);
+}
+
+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
+ */
+class UndoRedoStack {
+    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();
+        }
+        this.redoStack.length = 0;
+    }
+    undo() {
+        const action = this.undoStack.pop();
+        if (!action)
+            return null;
+        action.undo();
+        this.redoStack.push(action);
+        return action.label;
+    }
+    redo() {
+        const action = this.redoStack.pop();
+        if (!action)
+            return null;
+        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.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();
+    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));
+    // 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++;
+        }
+    }
+    // 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;
+    }
+    // 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);
+            }
+        }
+    }
+    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);
+            }
+        }
+    }
+    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);
+    }
+    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;
+    }
+    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;
+    }
+}
+/** 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),
+    });
+}
+/* ═══════════════════════════════════════════
+   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++;
+        }
+    }
+    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;
+            }
+        }
+    });
+    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;
+}
+/** Measure distance between two world-space points. */
+function measureDistance(a, 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 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,
+    },
+];
+/**
+ * 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);
+    }
+    // Fog
+    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);
+}
+/** 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;
+}
+/** 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;
+}
+/** 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));
+}
+/**
+ * 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" };
+        }
+    }
+    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;
+}
+/** Evaluate a keyframe track at a given time. */
+function evaluateTrack(track, time) {
+    var _a, _b;
+    const { keyframes } = track;
+    if (keyframes.length === 0)
+        return 0;
+    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;
+    }
+}
+/** 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;
+}
+/** 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;
+}
+/** 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);
+}
+/** 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);
+}
+/** 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);
+}
+/** 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 : [],
+        });
+    });
+}
+/** 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) => {
+        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);
+}
+/**
+ * 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;
+}
+/**
+ * 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();
+        }
+    }
+}
+/**
+ * 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);
+}
+/**
+ * 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);
+            }
+        }
+    }
+    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 },
+];
+/** 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 },
+};
+/**
+ * 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;
+}
+/**
+ * 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);
+}
+
+exports.HDRI_PRESETS = HDRI_PRESETS;
+exports.PBR_PRESETS = PBR_PRESETS;
+exports.QUAD_VIEWPORT = QUAD_VIEWPORT;
+exports.UndoRedoStack = UndoRedoStack;
+exports.applyHDRIPreset = applyHDRIPreset;
+exports.applyPBRPreset = applyPBRPreset;
+exports.blendAnimations = blendAnimations;
+exports.computeSceneBounds = computeSceneBounds;
+exports.convertToInstanced = convertToInstanced;
+exports.countTriangles = countTriangles;
+exports.createAnimationClip = createAnimationClip;
+exports.createMaterialFromPreset = createMaterialFromPreset;
+exports.createViewportCamera = createViewportCamera;
+exports.crossfadeAnimations = crossfadeAnimations;
+exports.downloadBlob = downloadBlob;
+exports.evaluateTrack = evaluateTrack;
+exports.exportSceneGLTF = exportSceneGLTF;
+exports.exportSceneUSDZ = exportSceneUSDZ;
+exports.generateLOD = generateLOD;
+exports.makeAdditiveAction = makeAdditiveAction;
+exports.measureAngle = measureAngle;
+exports.measureDistance = measureDistance;
+exports.removeKeyframe = removeKeyframe;
+exports.renderMultiViewport = renderMultiViewport;
+exports.setKeyframe = setKeyframe;
+exports.snapMulti = snapMulti;
+exports.snapToEdge = snapToEdge;
+exports.snapToGrid = snapToGrid;
+exports.snapToVertex = snapToVertex;
+exports.solveIKChain = solveIKChain;
+exports.subclip = subclip;
+exports.toThreeKeyframeTrack = toThreeKeyframeTrack;
+//# sourceMappingURL=modelEditorUtils.js.map