three-zoo 0.11.6 → 0.11.8

package/dist/index.js

@@ -1,246 +1,4 @@
-import { PerspectiveCamera, MathUtils, Vector3, Object3D, Matrix4, Quaternion, InstancedMesh, MeshPhysicalMaterial, Color, MeshBasicMaterial, MeshLambertMaterial, MeshPhongMaterial, MeshToonMaterial, Mesh, BufferAttribute, AnimationMixer, HemisphereLight, RGBAFormat, DirectionalLight, Box3, Spherical } from 'three';
-
-/** Default horizontal field of view in degrees */
-const DEFAULT_HORIZONTAL_FOV = 90;
-/** Default vertical field of view in degrees */
-const DEFAULT_VERTICAL_FOV = 90;
-/** Default aspect ratio (width/height) */
-const DEFAULT_ASPECT = 1;
-/** Default near clipping plane distance */
-const DEFAULT_NEAR = 1;
-/** Default far clipping plane distance */
-const DEFAULT_FAR = 1000;
-/** Minimum allowed field of view in degrees */
-const MIN_FOV = 1;
-/** Maximum allowed field of view in degrees */
-const MAX_FOV = 179;
-/**
- * Camera with independent horizontal and vertical FOV settings.
- */
-class DualFovCamera extends PerspectiveCamera {
-    /**
-     * @param horizontalFov - Horizontal FOV in degrees (clamped 1-179°)
-     * @param verticalFov - Vertical FOV in degrees (clamped 1-179°)
-     * @param aspect - Aspect ratio (width/height)
-     * @param near - Near clipping plane distance
-     * @param far - Far clipping plane distance
-     */
-    constructor(horizontalFov = DEFAULT_HORIZONTAL_FOV, verticalFov = DEFAULT_VERTICAL_FOV, aspect = DEFAULT_ASPECT, near = DEFAULT_NEAR, far = DEFAULT_FAR) {
-        super(verticalFov, aspect, near, far);
-        this._private_horizontalFovInternal = horizontalFov;
-        this._private_verticalFovInternal = verticalFov;
-        this.updateProjectionMatrix();
-    }
-    /**
-     * @returns Horizontal FOV in degrees
-     */
-    get horizontalFov() {
-        return this._private_horizontalFovInternal;
-    }
-    /**
-     * @returns Vertical FOV in degrees
-     */
-    get verticalFov() {
-        return this._private_verticalFovInternal;
-    }
-    /**
-     * @param value - Horizontal FOV in degrees (clamped 1-179°)
-     */
-    set horizontalFov(value) {
-        this._private_horizontalFovInternal = MathUtils.clamp(value, MIN_FOV, MAX_FOV);
-        this.updateProjectionMatrix();
-    }
-    /**
-     * @param value - Vertical FOV in degrees (clamped 1-179°)
-     */
-    set verticalFov(value) {
-        this._private_verticalFovInternal = MathUtils.clamp(value, MIN_FOV, MAX_FOV);
-        this.updateProjectionMatrix();
-    }
-    /**
-     * Sets both FOV values.
-     *
-     * @param horizontal - Horizontal FOV in degrees (clamped 1-179°)
-     * @param vertical - Vertical FOV in degrees (clamped 1-179°)
-     */
-    setFov(horizontal, vertical) {
-        this._private_horizontalFovInternal = MathUtils.clamp(horizontal, MIN_FOV, MAX_FOV);
-        this._private_verticalFovInternal = MathUtils.clamp(vertical, MIN_FOV, MAX_FOV);
-        this.updateProjectionMatrix();
-    }
-    /**
-     * Copies FOV settings from another DualFovCamera.
-     *
-     * @param source - Source camera to copy from
-     */
-    copyFovSettings(source) {
-        this._private_horizontalFovInternal = source.horizontalFov;
-        this._private_verticalFovInternal = source.verticalFov;
-        this.updateProjectionMatrix();
-    }
-    /**
-     * Updates projection matrix based on FOV and aspect ratio.
-     *
-     * Landscape (aspect > 1): preserves horizontal FOV.
-     * Portrait (aspect ≤ 1): preserves vertical FOV.
-     *
-     * @override
-     */
-    updateProjectionMatrix() {
-        if (this.aspect > 1) {
-            // Landscape orientation: preserve horizontal FOV
-            const radians = MathUtils.degToRad(this._private_horizontalFovInternal);
-            this.fov = MathUtils.radToDeg(Math.atan(Math.tan(radians / 2) / this.aspect) * 2);
-        }
-        else {
-            // Portrait orientation: preserve vertical FOV
-            this.fov = this._private_verticalFovInternal;
-        }
-        super.updateProjectionMatrix();
-    }
-    /**
-     * Gets actual horizontal FOV after aspect ratio adjustments.
-     *
-     * @returns Horizontal FOV in degrees
-     */
-    getActualHorizontalFov() {
-        if (this.aspect >= 1) {
-            return this._private_horizontalFovInternal;
-        }
-        const verticalRadians = MathUtils.degToRad(this._private_verticalFovInternal);
-        return MathUtils.radToDeg(Math.atan(Math.tan(verticalRadians / 2) * this.aspect) * 2);
-    }
-    /**
-     * Gets actual vertical FOV after aspect ratio adjustments.
-     *
-     * @returns Vertical FOV in degrees
-     */
-    getActualVerticalFov() {
-        if (this.aspect < 1) {
-            return this._private_verticalFovInternal;
-        }
-        const horizontalRadians = MathUtils.degToRad(this._private_horizontalFovInternal);
-        return MathUtils.radToDeg(Math.atan(Math.tan(horizontalRadians / 2) / this.aspect) * 2);
-    }
-    /**
-     * Adjusts vertical FOV to fit points within camera view.
-     *
-     * @param vertices - Array of 3D points in world coordinates
-     */
-    fitVerticalFovToPoints(vertices) {
-        const up = new Vector3(0, 1, 0).applyQuaternion(this.quaternion);
-        let maxVerticalAngle = 0;
-        for (const vertex of vertices) {
-            const vertexToCam = this.position.clone().sub(vertex);
-            const vertexDirection = vertexToCam.normalize();
-            const verticalAngle = Math.asin(Math.abs(vertexDirection.dot(up))) *
-                Math.sign(vertexDirection.dot(up));
-            if (Math.abs(verticalAngle) > maxVerticalAngle) {
-                maxVerticalAngle = Math.abs(verticalAngle);
-            }
-        }
-        const requiredFov = MathUtils.radToDeg(2 * maxVerticalAngle);
-        this._private_verticalFovInternal = MathUtils.clamp(requiredFov, MIN_FOV, MAX_FOV);
-        this.updateProjectionMatrix();
-    }
-    /**
-     * Adjusts vertical FOV to fit bounding box within camera view.
-     *
-     * @param box - 3D bounding box in world coordinates
-     */
-    fitVerticalFovToBox(box) {
-        this.fitVerticalFovToPoints([
-            new Vector3(box.min.x, box.min.y, box.min.z),
-            new Vector3(box.min.x, box.min.y, box.max.z),
-            new Vector3(box.min.x, box.max.y, box.min.z),
-            new Vector3(box.min.x, box.max.y, box.max.z),
-            new Vector3(box.max.x, box.min.y, box.min.z),
-            new Vector3(box.max.x, box.min.y, box.max.z),
-            new Vector3(box.max.x, box.max.y, box.min.z),
-            new Vector3(box.max.x, box.max.y, box.max.z),
-        ]);
-    }
-    /**
-     * Adjusts vertical FOV to fit skinned mesh within camera view.
-     * Updates skeleton and applies bone transformations.
-     *
-     * @param skinnedMesh - Skinned mesh with active skeleton
-     */
-    fitVerticalFovToMesh(skinnedMesh) {
-        skinnedMesh.updateWorldMatrix(true, true);
-        skinnedMesh.skeleton.update();
-        const bakedGeometry = skinnedMesh.geometry;
-        const position = bakedGeometry.attributes["position"];
-        const target = new Vector3();
-        const points = [];
-        for (let i = 0; i < position.count; i++) {
-            target.fromBufferAttribute(position, i);
-            skinnedMesh.applyBoneTransform(i, target);
-            points.push(target.clone());
-        }
-        this.fitVerticalFovToPoints(points);
-    }
-    /**
-     * Points camera to look at skinned mesh center of mass.
-     * Uses iterative clustering to find main vertex concentration.
-     *
-     * @param skinnedMesh - Skinned mesh with active skeleton
-     */
-    lookAtMeshCenterOfMass(skinnedMesh) {
-        skinnedMesh.updateWorldMatrix(true, true);
-        skinnedMesh.skeleton.update();
-        const bakedGeometry = skinnedMesh.geometry;
-        const position = bakedGeometry.attributes.position;
-        const target = new Vector3();
-        const points = [];
-        for (let i = 0; i < position.count; i++) {
-            target.fromBufferAttribute(position, i);
-            skinnedMesh.applyBoneTransform(i, target);
-            points.push(target.clone());
-        }
-        /**
-         * Finds main cluster center using iterative refinement.
-         *
-         * @param points - Array of 3D points to cluster
-         * @param iterations - Number of refinement iterations
-         * @returns Center point of main cluster
-         */
-        const findMainCluster = (points, iterations = 3) => {
-            if (points.length === 0) {
-                return new Vector3();
-            }
-            let center = points[Math.floor(points.length / 2)].clone();
-            for (let i = 0; i < iterations; i++) {
-                let total = new Vector3();
-                let count = 0;
-                for (const point of points) {
-                    if (point.distanceTo(center) < point.distanceTo(total) ||
-                        count === 0) {
-                        total.add(point);
-                        count++;
-                    }
-                }
-                if (count > 0) {
-                    center = total.divideScalar(count);
-                }
-            }
-            return center;
-        };
-        const centerOfMass = findMainCluster(points);
-        this.lookAt(centerOfMass);
-    }
-    /**
-     * Creates a copy of this camera with identical settings.
-     *
-     * @returns New DualFovCamera instance
-     * @override
-     */
-    clone() {
-        const camera = new DualFovCamera(this._private_horizontalFovInternal, this._private_verticalFovInternal, this.aspect, this.near, this.far);
-        camera.copy(this, true);
-        return camera;
-    }
-}
+import { Object3D, Vector3, Quaternion, Matrix4, InstancedMesh, HemisphereLight, RGBAFormat, DirectionalLight, Box3, Spherical, MeshPhysicalMaterial, Color, MeshBasicMaterial, MeshLambertMaterial, MeshPhongMaterial, MeshToonMaterial, PerspectiveCamera, MathUtils, Mesh, BufferAttribute, AnimationMixer } from 'three';
 
 class InstancedMeshGroup extends Object3D {
     constructor(_private_instances) {
@@ -261,124 +19,200 @@ class InstancedMeshGroup extends Object3D {
 }
 
 class InstancedMeshInstance {
-    constructor(pool, entry, index) {
-        this._private_pool = pool;
-        this["entry"] = entry;
-        this.index = index;
-        this._private_matrix = new Matrix4();
+    constructor(_private_pool, geometry, material, tag = "") {
+        this._private_pool = _private_pool;
         this._private_position = new Vector3();
         this._private_quaternion = new Quaternion();
         this._private_scale = new Vector3(1, 1, 1);
+        this._private_matrix = new Matrix4();
+        this._private_needsUpdateMatrixFromTransform = false;
+        this._private_needsUpdateTransformFromMatrix = false;
+        this._private_needUpdateInstancedMatrixFromLocalMatrix = false;
+        this._private_handler = this._private_pool["allocate"](geometry, material, tag);
     }
-    setPosition(v) {
-        this._private_position.copy(v);
-        this._private_apply();
-        return this;
+    destroy() {
+        if (this._private_handler >= 0) {
+            this._private_pool["deallocate"](this._private_handler);
+        }
     }
-    setPosition3f(x, y, z) {
-        this._private_position.set(x, y, z);
-        this._private_apply();
+    setQuaternion(source, flushTransform = false) {
+        this._private_updateTransformFromMatrix();
+        if (!this._private_quaternion.equals(source)) {
+            this._private_quaternion.copy(source);
+            this._private_needsUpdateMatrixFromTransform = true;
+            if (flushTransform) {
+                this.flushTransform();
+            }
+        }
         return this;
     }
-    setQuaternion(q) {
-        this._private_quaternion.copy(q);
-        this._private_apply();
+    setQuaternion4f(x, y, z, w, flushTransform = false) {
+        this._private_updateTransformFromMatrix();
+        if (this._private_quaternion.x !== x ||
+            this._private_quaternion.y !== y ||
+            this._private_quaternion.z !== z ||
+            this._private_quaternion.w !== w) {
+            this._private_quaternion.set(x, y, z, w);
+            this._private_needsUpdateMatrixFromTransform = true;
+            if (flushTransform) {
+                this.flushTransform();
+            }
+        }
         return this;
     }
-    setQuaternion4f(x, y, z, w) {
-        this._private_quaternion.set(x, y, z, w);
-        this._private_apply();
+    setScale(source, flushTransform = false) {
+        this._private_updateTransformFromMatrix();
+        if (!this._private_scale.equals(source)) {
+            this._private_scale.copy(source);
+            this._private_needsUpdateMatrixFromTransform = true;
+            if (flushTransform) {
+                this.flushTransform();
+            }
+        }
         return this;
     }
-    setScale(v) {
-        this._private_scale.copy(v);
-        this._private_apply();
+    setScale3f(x, y, z, flushTransform = false) {
+        this._private_updateTransformFromMatrix();
+        if (this._private_scale.x !== x || this._private_scale.y !== y || this._private_scale.z !== z) {
+            this._private_scale.set(x, y, z);
+            this._private_needsUpdateMatrixFromTransform = true;
+            if (flushTransform) {
+                this.flushTransform();
+            }
+        }
         return this;
     }
-    setScale3f(x, y, z) {
-        this._private_scale.set(x, y, z);
-        this._private_apply();
-        return this;
-    }
-    setTransform(m) {
-        m.decompose(this._private_position, this._private_quaternion, this._private_scale);
-        this._private_apply();
+    setTransform(source, flushTransform = false) {
+        this._private_updateMatrixFromTransform();
+        if (!this._private_matrix.equals(source)) {
+            this._private_matrix.copy(source);
+            this._private_needsUpdateTransformFromMatrix = true;
+            this._private_needUpdateInstancedMatrixFromLocalMatrix = true;
+            if (flushTransform) {
+                this._private_updateTransformFromMatrix();
+                this.flushTransform();
+            }
+        }
         return this;
     }
-    destroy() {
-        if (this.index === -1)
-            return;
-        this._private_pool.deallocate(this);
+    flushTransform() {
+        this._private_updateMatrixFromTransform();
+        if (this._private_handler >= 0 && this._private_needUpdateInstancedMatrixFromLocalMatrix) {
+            this._private_pool["setTransformMatrix"](this._private_handler, this._private_matrix);
+        }
     }
-    _private_apply() {
-        if (this.index === -1)
-            return;
-        this._private_matrix.compose(this._private_position, this._private_quaternion, this._private_scale);
-        this["entry"].mesh.setMatrixAt(this.index, this._private_matrix);
-        this._private_pool["notifyUpdate"](this["entry"]);
+    _private_updateTransformFromMatrix() {
+        if (this._private_needsUpdateTransformFromMatrix) {
+            this._private_matrix.decompose(this._private_position, this._private_quaternion, this._private_scale);
+            this._private_needsUpdateTransformFromMatrix = false;
+        }
+    }
+    _private_updateMatrixFromTransform() {
+        if (this._private_needsUpdateMatrixFromTransform) {
+            this._private_matrix.compose(this._private_position, this._private_quaternion, this._private_scale);
+            this._private_needsUpdateMatrixFromTransform = false;
+            this._private_needUpdateInstancedMatrixFromLocalMatrix = true;
+        }
     }
 }
 
-const TEMP_MATRIX = new Matrix4();
+const DEFAULT_INITIAL_CAPACITY = 16;
+const DEFAULT_CAPACITY_STEP = 2;
+const MATRIX_SIZE = 16;
+const TEMP_MATRIX_A = new Matrix4();
+const TEMP_MATRIX_B = new Matrix4();
 class InstancedMeshPool {
-    constructor(options) {
+    constructor(_private_scene, options = {}) {
         var _a, _b;
-        this._private_scene = options.scene;
-        this._private_initialCapacity = (_a = options.initialCapacity) !== null && _a !== void 0 ? _a : 16;
-        this._private_capacityStep = (_b = options.capacityStep) !== null && _b !== void 0 ? _b : this._private_initialCapacity;
-        this._private_meshes = new Map();
+        this._private_scene = _private_scene;
+        this._private_entries = new Map();
+        this._private_descriptors = new Map();
+        this._private_nextHandler = 1;
+        this._private_initialCapacity = (_a = options.initialCapacity) !== null && _a !== void 0 ? _a : DEFAULT_INITIAL_CAPACITY;
+        this._private_capacityStep = (_b = options.capacityStep) !== null && _b !== void 0 ? _b : DEFAULT_CAPACITY_STEP;
+    }
+    isValidHandler(handler) {
+        return this._private_descriptors.has(handler);
+    }
+    sortMeshes(baseRenderOrder, compare) {
+        const sorted = [];
+        for (const entry of this._private_entries.values()) {
+            sorted.push(entry);
+        }
+        sorted.sort((a, b) => compare(a.mesh, a.tag, b.mesh, b.tag));
+        let currentRenderOrder = baseRenderOrder;
+        for (const entry of sorted) {
+            entry.mesh.renderOrder = currentRenderOrder++;
+        }
+    }
+    sortInstances(compare) {
+        for (const entry of this._private_entries.values()) {
+            this._private_sortEntryInstances(entry, compare);
+        }
+    }
+    dispose() {
+        for (const entry of this._private_entries.values()) {
+            this._private_scene.remove(entry.mesh);
+            entry.mesh.dispose();
+        }
+        this._private_entries.clear();
+        this._private_descriptors.clear();
     }
-    allocate(geometry, material) {
-        const entry = this._private_getOrCreateEntry(geometry, material);
+    allocate(geometry, material, tag) {
+        const entry = this._private_getOrCreateEntry(geometry, material, tag);
         if (entry.count === entry.capacity) {
             this._private_growEntry(entry);
         }
         const index = entry.count;
+        const handler = this._private_nextHandler++;
+        entry.handlers[index] = handler;
         entry.count++;
-        const instance = new InstancedMeshInstance(this, entry, index);
-        instance.setScale3f(1, 1, 1);
-        entry.instances.set(index, instance);
         entry.mesh.count = entry.count;
-        return instance;
+        this._private_descriptors.set(handler, { entry, index });
+        return handler;
     }
-    deallocate(instance) {
-        if (instance.index === -1)
+    deallocate(handler) {
+        const descriptor = this._private_descriptors.get(handler);
+        if (descriptor === undefined) {
             return;
-        const entry = instance["entry"];
-        const removedIndex = instance.index;
+        }
+        const { entry, index: removedIndex } = descriptor;
         const lastIndex = entry.count - 1;
-        entry.instances.delete(removedIndex);
+        this._private_descriptors.delete(handler);
         if (removedIndex !== lastIndex) {
-            // swap: move last to removed position
-            const lastInstance = entry.instances.get(lastIndex);
-            entry.mesh.getMatrixAt(lastIndex, TEMP_MATRIX);
-            entry.mesh.setMatrixAt(removedIndex, TEMP_MATRIX);
-            lastInstance.index = removedIndex;
-            entry.instances.delete(lastIndex);
-            entry.instances.set(removedIndex, lastInstance);
+            const lastHandler = entry.handlers[lastIndex];
+            const lastDescriptor = this._private_descriptors.get(lastHandler);
+            if (lastDescriptor !== undefined) {
+                entry.mesh.getMatrixAt(lastIndex, TEMP_MATRIX_A);
+                entry.mesh.setMatrixAt(removedIndex, TEMP_MATRIX_A);
+                lastDescriptor.index = removedIndex;
+                entry.handlers[removedIndex] = lastHandler;
+            }
         }
         entry.count--;
         entry.mesh.count = entry.count;
-        instance.index = -1;
-        this["notifyUpdate"](entry);
+        entry.mesh.instanceMatrix.needsUpdate = true;
     }
-    sortMeshes(compare) {
-        const meshes = [];
-        for (const entry of this._private_meshes.values()) {
-            meshes.push(entry.mesh);
-        }
-        meshes.sort(compare);
-        for (const mesh of meshes) {
-            this._private_scene.remove(mesh);
+    setTransformMatrix(handler, matrix) {
+        const descriptor = this._private_descriptors.get(handler);
+        if (descriptor === undefined) {
+            return;
         }
-        for (const mesh of meshes) {
-            this._private_scene.add(mesh);
+        descriptor.entry.mesh.setMatrixAt(descriptor.index, matrix);
+        descriptor.entry.mesh.instanceMatrix.needsUpdate = true;
+    }
+    getTransformMatrix(handler, target) {
+        const descriptor = this._private_descriptors.get(handler);
+        if (descriptor === undefined) {
+            return undefined;
         }
+        descriptor.entry.mesh.getMatrixAt(descriptor.index, target);
+        return target;
     }
-    _private_getOrCreateEntry(geometry, material) {
+    _private_getOrCreateEntry(geometry, material, tag) {
         const key = `${geometry.uuid}:${material.uuid}`;
-        let entry = this._private_meshes.get(key);
-        if (!entry) {
+        let entry = this._private_entries.get(key);
+        if (entry === undefined) {
             const mesh = new InstancedMesh(geometry, material, this._private_initialCapacity);
             mesh.count = 0;
             mesh.frustumCulled = false;
@@ -387,11 +221,12 @@ class InstancedMeshPool {
                 mesh,
                 geometry,
                 material,
+                tag: tag,
                 capacity: this._private_initialCapacity,
                 count: 0,
-                instances: new Map(),
+                handlers: [],
             };
-            this._private_meshes.set(key, entry);
+            this._private_entries.set(key, entry);
         }
         return entry;
     }
@@ -410,135 +245,480 @@ class InstancedMeshPool {
         entry.capacity = newCapacity;
         entry.mesh.count = entry.count;
     }
-    ["notifyUpdate"](entry) {
-        entry.mesh.instanceMatrix.needsUpdate = true;
-    }
-}
-
-class BasicToPhysicalConverter {
-    static convert(material, options = {}) {
-        const config = Object.assign({ preserveName: true, copyUserData: true, disposeOriginal: false }, options);
-        const physicalMaterial = new MeshPhysicalMaterial();
-        this.copyBasicProperties(material, physicalMaterial, config);
-        this.convertColorAndPBRProperties(material, physicalMaterial, config);
-        this.convertTextureMaps(material, physicalMaterial);
-        this.convertTransparencyProperties(material, physicalMaterial);
-        this.applyPhysicalProperties(physicalMaterial, config);
-        if (config.disposeOriginal) {
-            material.dispose();
+    _private_sortEntryInstances(entry, compare) {
+        if (entry.count <= 1) {
+            return;
         }
-        physicalMaterial.needsUpdate = true;
-        return physicalMaterial;
-    }
-    static copyBasicProperties(source, target, config) {
-        if (config.preserveName) {
-            target.name = source.name;
+        const items = [];
+        for (let i = 0; i < entry.count; i++) {
+            items.push({ originalIndex: i, handler: entry.handlers[i] });
+        }
+        let needsReorder = false;
+        items.sort((a, b) => {
+            entry.mesh.getMatrixAt(a.originalIndex, TEMP_MATRIX_A);
+            entry.mesh.getMatrixAt(b.originalIndex, TEMP_MATRIX_B);
+            const result = compare(TEMP_MATRIX_A, TEMP_MATRIX_B, entry.tag);
+            if (result > 0) {
+                needsReorder = true;
+            }
+            return result;
+        });
+        if (!needsReorder) {
+            return;
         }
-        target.side = source.side;
-        target.visible = source.visible;
-        target.fog = source.fog;
-        target.wireframe = source.wireframe;
-        target.wireframeLinewidth = source.wireframeLinewidth;
-        target.wireframeLinecap = source.wireframeLinecap;
-        target.wireframeLinejoin = source.wireframeLinejoin;
-        target.vertexColors = source.vertexColors;
-        if (config.copyUserData && source.userData) {
-            target.userData = Object.assign({}, source.userData);
+        const matricesData = new Float32Array(entry.count * MATRIX_SIZE);
+        for (let i = 0; i < items.length; i++) {
+            entry.mesh.getMatrixAt(items[i].originalIndex, TEMP_MATRIX_A);
+            matricesData.set(TEMP_MATRIX_A.elements, i * MATRIX_SIZE);
+        }
+        for (let i = 0; i < entry.count; i++) {
+            TEMP_MATRIX_A.fromArray(matricesData, i * MATRIX_SIZE);
+            entry.mesh.setMatrixAt(i, TEMP_MATRIX_A);
+        }
+        for (let i = 0; i < items.length; i++) {
+            const handler = items[i].handler;
+            entry.handlers[i] = handler;
+            const descriptor = this._private_descriptors.get(handler);
+            if (descriptor !== undefined) {
+                descriptor.index = i;
+            }
         }
+        entry.mesh.instanceMatrix.needsUpdate = true;
     }
-    static convertColorAndPBRProperties(source, target, config) {
-        if (source.color) {
-            target.color = source.color.clone();
-        }
-        if (config.emissive !== undefined) {
-            if (config.emissive instanceof Color) {
-                target.emissive.copy(config.emissive);
+}
+
+/** Number of color channels in RGBA format */
+const RGBA_CHANNEL_COUNT$1 = 4;
+/** Number of color channels in RGB format */
+const RGB_CHANNEL_COUNT$1 = 3;
+/** Red channel weight for luminance calculation (ITU-R BT.709) */
+const LUMINANCE_R$1 = 0.2126;
+/** Green channel weight for luminance calculation (ITU-R BT.709) */
+const LUMINANCE_G$1 = 0.7152;
+/** Blue channel weight for luminance calculation (ITU-R BT.709) */
+const LUMINANCE_B$1 = 0.0722;
+/** Threshold for upper hemisphere sampling (0 = equator, 1 = top) */
+const SKY_SAMPLE_THRESHOLD = 0.25;
+/** Threshold for lower hemisphere sampling (0 = equator, 1 = bottom) */
+const GROUND_SAMPLE_THRESHOLD = 0.75;
+/**
+ * Hemisphere light with HDR environment map support for automatic sky/ground color extraction.
+ */
+class SkyLight extends HemisphereLight {
+    /**
+     * Sets sky and ground colors from an HDR texture.
+     * Analyzes upper hemisphere for sky color and lower hemisphere for ground color.
+     *
+     * @param texture - HDR texture to analyze (must have image data)
+     * @param options - Configuration options for color extraction
+     */
+    setColorsFromHDRTexture(texture, options = {}) {
+        const { skySampleCount = 100, groundSampleCount = 100, applyGamma = true, gamma = 2.2, } = options;
+        const data = texture.image.data;
+        const width = texture.image.width;
+        const height = texture.image.height;
+        const step = texture.format === RGBAFormat ? RGBA_CHANNEL_COUNT$1 : RGB_CHANNEL_COUNT$1;
+        const skyPixels = [];
+        const groundPixels = [];
+        // Sample pixels from upper and lower hemispheres
+        for (let i = 0; i < data.length; i += step) {
+            const pixelIndex = i / step;
+            const y = Math.floor(pixelIndex / width);
+            const v = y / height;
+            const r = data[i];
+            const g = data[i + 1];
+            const b = data[i + 2];
+            const luminance = LUMINANCE_R$1 * r + LUMINANCE_G$1 * g + LUMINANCE_B$1 * b;
+            const pixel = { r, g, b, lum: luminance };
+            // Upper hemisphere (sky)
+            if (v < SKY_SAMPLE_THRESHOLD) {
+                this._private_insertSorted(skyPixels, pixel, skySampleCount, true);
             }
-            else {
-                target.emissive.set(config.emissive);
+            // Lower hemisphere (ground)
+            else if (v > GROUND_SAMPLE_THRESHOLD) {
+                this._private_insertSorted(groundPixels, pixel, groundSampleCount, false);
             }
         }
-        if (config.emissiveIntensity !== undefined) {
-            target.emissiveIntensity = config.emissiveIntensity;
-        }
-        if (config.metalness !== undefined) {
-            target.metalness = config.metalness;
-        }
-        if (config.roughness !== undefined) {
-            target.roughness = config.roughness;
+        // Calculate average sky color from brightest samples
+        const skyColor = this._private_averagePixels(skyPixels);
+        // Calculate average ground color
+        const groundColor = this._private_averagePixels(groundPixels);
+        // Apply gamma correction if needed
+        if (applyGamma) {
+            const invGamma = 1 / gamma;
+            skyColor.r = Math.pow(skyColor.r, invGamma);
+            skyColor.g = Math.pow(skyColor.g, invGamma);
+            skyColor.b = Math.pow(skyColor.b, invGamma);
+            groundColor.r = Math.pow(groundColor.r, invGamma);
+            groundColor.g = Math.pow(groundColor.g, invGamma);
+            groundColor.b = Math.pow(groundColor.b, invGamma);
         }
+        // Normalize HDR values to [0, 1] range
+        const maxSky = Math.max(skyColor.r, skyColor.g, skyColor.b, 1);
+        const maxGround = Math.max(groundColor.r, groundColor.g, groundColor.b, 1);
+        this.color.setRGB(skyColor.r / maxSky, skyColor.g / maxSky, skyColor.b / maxSky);
+        this.groundColor.setRGB(groundColor.r / maxGround, groundColor.g / maxGround, groundColor.b / maxGround);
     }
-    static convertTextureMaps(source, target) {
-        if (source.map) {
-            target.map = source.map;
-        }
-        if (source.alphaMap) {
-            target.alphaMap = source.alphaMap;
-        }
-        if (source.lightMap) {
-            target.lightMap = source.lightMap;
-            target.lightMapIntensity = source.lightMapIntensity;
-        }
-        if (source.aoMap) {
-            target.aoMap = source.aoMap;
-            target.aoMapIntensity = source.aoMapIntensity;
+    /**
+     * Inserts pixel into sorted array, maintaining size limit.
+     */
+    _private_insertSorted(array, pixel, maxSize, sortDescending) {
+        if (array.length < maxSize) {
+            array.push(pixel);
+            array.sort((a, b) => (sortDescending ? b.lum - a.lum : a.lum - b.lum));
         }
-        if (source.envMap) {
-            target.envMap = source.envMap;
+        else {
+            const threshold = array[array.length - 1].lum;
+            const shouldInsert = sortDescending
+                ? pixel.lum > threshold
+                : pixel.lum < threshold;
+            if (shouldInsert) {
+                array.pop();
+                array.push(pixel);
+                array.sort((a, b) => (sortDescending ? b.lum - a.lum : a.lum - b.lum));
+            }
         }
     }
-    static convertTransparencyProperties(source, target) {
-        target.transparent = source.transparent;
-        target.opacity = source.opacity;
-        target.alphaTest = source.alphaTest;
-        target.depthTest = source.depthTest;
-        target.depthWrite = source.depthWrite;
-        target.blending = source.blending;
-        target.blendSrc = source.blendSrc;
-        target.blendDst = source.blendDst;
-        target.blendEquation = source.blendEquation;
-        target.blendSrcAlpha = source.blendSrcAlpha;
-        target.blendDstAlpha = source.blendDstAlpha;
-        target.blendEquationAlpha = source.blendEquationAlpha;
-    }
-    static applyPhysicalProperties(target, config) {
-        if (config.clearcoat !== undefined) {
-            target.clearcoat = config.clearcoat;
-        }
-        if (config.clearcoatRoughness !== undefined) {
-            target.clearcoatRoughness = config.clearcoatRoughness;
-        }
-        if (config.sheen !== undefined) {
-            target.sheen = config.sheen;
-        }
-        if (config.transmission !== undefined) {
-            target.transmission = config.transmission;
+    /**
+     * Calculates average color from pixel array.
+     */
+    _private_averagePixels(pixels) {
+        if (pixels.length === 0) {
+            return { r: 0.5, g: 0.5, b: 0.5 };
         }
-        if (config.ior !== undefined) {
-            target.ior = config.ior;
+        let totalR = 0;
+        let totalG = 0;
+        let totalB = 0;
+        for (const pixel of pixels) {
+            totalR += pixel.r;
+            totalG += pixel.g;
+            totalB += pixel.b;
         }
+        return {
+            r: totalR / pixels.length,
+            g: totalG / pixels.length,
+            b: totalB / pixels.length,
+        };
     }
 }
 
-/** Factor for metalness brightness adjustment */
-const METALNESS_BRIGHTNESS_FACTOR = 0.3;
-/** Factor for emissive color contribution when combining with base color */
-const EMISSIVE_CONTRIBUTION_FACTOR = 0.5;
+/** Number of color channels in RGBA format */
+const RGBA_CHANNEL_COUNT = 4;
+/** Number of color channels in RGB format */
+const RGB_CHANNEL_COUNT = 3;
+/** Red channel weight for luminance calculation (ITU-R BT.709) */
+const LUMINANCE_R = 0.2126;
+/** Green channel weight for luminance calculation (ITU-R BT.709) */
+const LUMINANCE_G = 0.7152;
+/** Blue channel weight for luminance calculation (ITU-R BT.709) */
+const LUMINANCE_B = 0.0722;
 /**
- * Converts MeshStandardMaterial to MeshBasicMaterial with brightness compensation.
+ * Directional light with spherical positioning and HDR environment support.
  */
-class StandardToBasicConverter {
-    /**
-     * Converts MeshStandardMaterial to MeshBasicMaterial.
-     *
-     * @param standardMaterial - Source material to convert
-     * @param options - Conversion options
-     * @returns New MeshBasicMaterial with mapped properties
-     */
-    static convert(standardMaterial, options = {}) {
-        const config = Object.assign({ preserveName: true, copyUserData: true, disposeOriginal: false, combineEmissive: true, brightnessFactor: 1.3 }, options);
-        // Create new Basic material
-        const basicMaterial = new MeshBasicMaterial();
+class Sun extends DirectionalLight {
+    constructor() {
+        super(...arguments);
+        /** Internal vectors to avoid garbage collection during calculations */
+        this._private_tempVector3D0 = new Vector3();
+        this._private_tempVector3D1 = new Vector3();
+        this._private_tempVector3D2 = new Vector3();
+        this._private_tempVector3D3 = new Vector3();
+        this._private_tempVector3D4 = new Vector3();
+        this._private_tempVector3D5 = new Vector3();
+        this._private_tempVector3D6 = new Vector3();
+        this._private_tempVector3D7 = new Vector3();
+        this._private_tempBox3 = new Box3();
+        this._private_tempSpherical = new Spherical();
+    }
+    /**
+     * @returns Distance from light position to origin
+     */
+    get distance() {
+        return this.position.length();
+    }
+    /**
+     * @returns Elevation angle in radians (phi angle)
+     */
+    get elevation() {
+        return this._private_tempSpherical.setFromVector3(this.position).phi;
+    }
+    /**
+     * @returns Azimuth angle in radians (theta angle)
+     */
+    get azimuth() {
+        return this._private_tempSpherical.setFromVector3(this.position).theta;
+    }
+    /**
+     * @param value - New distance in world units
+     */
+    set distance(value) {
+        this._private_tempSpherical.setFromVector3(this.position);
+        this.position.setFromSphericalCoords(value, this._private_tempSpherical.phi, this._private_tempSpherical.theta);
+    }
+    /**
+     * @param value - New elevation angle in radians (phi angle)
+     */
+    set elevation(value) {
+        this._private_tempSpherical.setFromVector3(this.position);
+        this.position.setFromSphericalCoords(this._private_tempSpherical.radius, value, this._private_tempSpherical.theta);
+    }
+    /**
+     * @param value - New azimuth angle in radians (theta angle)
+     */
+    set azimuth(value) {
+        this._private_tempSpherical.setFromVector3(this.position);
+        this.position.setFromSphericalCoords(this._private_tempSpherical.radius, this._private_tempSpherical.phi, value);
+    }
+    /**
+     * Sets spherical position of the sun.
+     *
+     * @param elevation - Elevation angle in radians (phi angle)
+     * @param azimuth - Azimuth angle in radians (theta angle)
+     * @param distance - Distance from origin in world units
+     */
+    setPosition(elevation, azimuth, distance = 1) {
+        this.position.setFromSphericalCoords(distance, elevation, azimuth);
+    }
+    /**
+     * Configures shadow camera frustum to cover bounding box.
+     *
+     * @param box3 - 3D bounding box to cover with shadows
+     */
+    configureShadowsForBoundingBox(box3) {
+        const camera = this.shadow.camera;
+        this.target.updateWorldMatrix(true, false);
+        this.lookAt(this.target.getWorldPosition(this._private_tempVector3D0));
+        this.updateWorldMatrix(true, false);
+        const points = [
+            this._private_tempVector3D0.set(box3.min.x, box3.min.y, box3.min.z),
+            this._private_tempVector3D1.set(box3.min.x, box3.min.y, box3.max.z),
+            this._private_tempVector3D2.set(box3.min.x, box3.max.y, box3.min.z),
+            this._private_tempVector3D3.set(box3.min.x, box3.max.y, box3.max.z),
+            this._private_tempVector3D4.set(box3.max.x, box3.min.y, box3.min.z),
+            this._private_tempVector3D5.set(box3.max.x, box3.min.y, box3.max.z),
+            this._private_tempVector3D6.set(box3.max.x, box3.max.y, box3.min.z),
+            this._private_tempVector3D7.set(box3.max.x, box3.max.y, box3.max.z),
+        ];
+        const inverseMatrix = this.matrixWorld.clone().invert();
+        for (const point of points) {
+            point.applyMatrix4(inverseMatrix);
+        }
+        const newBox3 = this._private_tempBox3.setFromPoints(points);
+        camera.left = newBox3.min.x;
+        camera.bottom = newBox3.min.y;
+        camera.near = -newBox3.max.z;
+        camera.right = newBox3.max.x;
+        camera.top = newBox3.max.y;
+        camera.far = -newBox3.min.z;
+        camera.updateWorldMatrix(true, false);
+        camera.updateProjectionMatrix();
+    }
+    /**
+     * Sets sun direction, color and intensity based on brightest point in HDR environment map.
+     *
+     * @param texture - HDR texture to analyze (must have image data)
+     * @param distance - Distance to place sun from origin
+     * @param intensityScale - Multiplier for intensity derived from luminance (default: 1)
+     */
+    setFromHDRTexture(texture, intensityScale = 1, distance = 1) {
+        this.setColorFromHDRTexture(texture);
+        this.setIntensityFromHDRTexture(texture, intensityScale);
+        this.setDirectionFromHDRTexture(texture, distance);
+    }
+    /**
+     * Sets sun color based on brightest point in HDR environment map.
+     *
+     * @param texture - HDR texture to analyze (must have image data)
+     */
+    setColorFromHDRTexture(texture) {
+        const { index } = this._private_findBrightestPixel(texture);
+        const data = texture.image.data;
+        const r = data[index];
+        const g = data[index + 1];
+        const b = data[index + 2];
+        const maxChannel = Math.max(r, g, b, 1);
+        this.color.setRGB(r / maxChannel, g / maxChannel, b / maxChannel);
+    }
+    /**
+     * Sets sun intensity based on luminance of brightest point in HDR environment map.
+     *
+     * @param texture - HDR texture to analyze (must have image data)
+     * @param scale - Multiplier for intensity (default: 1)
+     */
+    setIntensityFromHDRTexture(texture, scale = 1) {
+        const { luminance } = this._private_findBrightestPixel(texture);
+        this.intensity = luminance * scale;
+    }
+    /**
+     * Sets sun direction based on brightest point in HDR environment map.
+     *
+     * @param texture - HDR texture to analyze (must have image data)
+     * @param distance - Distance to place sun from origin
+     */
+    setDirectionFromHDRTexture(texture, distance = 1) {
+        const { index } = this._private_findBrightestPixel(texture);
+        const width = texture.image.width;
+        const height = texture.image.height;
+        const step = texture.format === RGBAFormat ? RGBA_CHANNEL_COUNT : RGB_CHANNEL_COUNT;
+        // Convert to spherical coordinates
+        const pixelIndex = index / step;
+        const x = pixelIndex % width;
+        const y = Math.floor(pixelIndex / width);
+        const u = x / width;
+        const v = y / height;
+        const elevation = v * Math.PI;
+        const azimuth = u * -Math.PI * 2 - Math.PI / 2;
+        this.position.setFromSphericalCoords(distance, elevation, azimuth);
+    }
+    /**
+     * Finds the brightest pixel in an HDR texture.
+     *
+     * @param texture - HDR texture to analyze
+     * @returns Index and luminance of brightest pixel
+     */
+    _private_findBrightestPixel(texture) {
+        const data = texture.image.data;
+        let maxLuminance = 0;
+        let maxIndex = 0;
+        const step = texture.format === RGBAFormat ? RGBA_CHANNEL_COUNT : RGB_CHANNEL_COUNT;
+        for (let i = 0; i < data.length; i += step) {
+            const r = data[i];
+            const g = data[i + 1];
+            const b = data[i + 2];
+            const luminance = LUMINANCE_R * r + LUMINANCE_G * g + LUMINANCE_B * b;
+            if (luminance > maxLuminance) {
+                maxLuminance = luminance;
+                maxIndex = i;
+            }
+        }
+        return { index: maxIndex, luminance: maxLuminance };
+    }
+}
+
+class BasicToPhysicalConverter {
+    static convert(material, options = {}) {
+        const config = Object.assign({ preserveName: true, copyUserData: true, disposeOriginal: false }, options);
+        const physicalMaterial = new MeshPhysicalMaterial();
+        this.copyBasicProperties(material, physicalMaterial, config);
+        this.convertColorAndPBRProperties(material, physicalMaterial, config);
+        this.convertTextureMaps(material, physicalMaterial);
+        this.convertTransparencyProperties(material, physicalMaterial);
+        this.applyPhysicalProperties(physicalMaterial, config);
+        if (config.disposeOriginal) {
+            material.dispose();
+        }
+        physicalMaterial.needsUpdate = true;
+        return physicalMaterial;
+    }
+    static copyBasicProperties(source, target, config) {
+        if (config.preserveName) {
+            target.name = source.name;
+        }
+        target.side = source.side;
+        target.visible = source.visible;
+        target.fog = source.fog;
+        target.wireframe = source.wireframe;
+        target.wireframeLinewidth = source.wireframeLinewidth;
+        target.wireframeLinecap = source.wireframeLinecap;
+        target.wireframeLinejoin = source.wireframeLinejoin;
+        target.vertexColors = source.vertexColors;
+        if (config.copyUserData && source.userData) {
+            target.userData = Object.assign({}, source.userData);
+        }
+    }
+    static convertColorAndPBRProperties(source, target, config) {
+        if (source.color) {
+            target.color = source.color.clone();
+        }
+        if (config.emissive !== undefined) {
+            if (config.emissive instanceof Color) {
+                target.emissive.copy(config.emissive);
+            }
+            else {
+                target.emissive.set(config.emissive);
+            }
+        }
+        if (config.emissiveIntensity !== undefined) {
+            target.emissiveIntensity = config.emissiveIntensity;
+        }
+        if (config.metalness !== undefined) {
+            target.metalness = config.metalness;
+        }
+        if (config.roughness !== undefined) {
+            target.roughness = config.roughness;
+        }
+    }
+    static convertTextureMaps(source, target) {
+        if (source.map) {
+            target.map = source.map;
+        }
+        if (source.alphaMap) {
+            target.alphaMap = source.alphaMap;
+        }
+        if (source.lightMap) {
+            target.lightMap = source.lightMap;
+            target.lightMapIntensity = source.lightMapIntensity;
+        }
+        if (source.aoMap) {
+            target.aoMap = source.aoMap;
+            target.aoMapIntensity = source.aoMapIntensity;
+        }
+        if (source.envMap) {
+            target.envMap = source.envMap;
+        }
+    }
+    static convertTransparencyProperties(source, target) {
+        target.transparent = source.transparent;
+        target.opacity = source.opacity;
+        target.alphaTest = source.alphaTest;
+        target.depthTest = source.depthTest;
+        target.depthWrite = source.depthWrite;
+        target.blending = source.blending;
+        target.blendSrc = source.blendSrc;
+        target.blendDst = source.blendDst;
+        target.blendEquation = source.blendEquation;
+        target.blendSrcAlpha = source.blendSrcAlpha;
+        target.blendDstAlpha = source.blendDstAlpha;
+        target.blendEquationAlpha = source.blendEquationAlpha;
+    }
+    static applyPhysicalProperties(target, config) {
+        if (config.clearcoat !== undefined) {
+            target.clearcoat = config.clearcoat;
+        }
+        if (config.clearcoatRoughness !== undefined) {
+            target.clearcoatRoughness = config.clearcoatRoughness;
+        }
+        if (config.sheen !== undefined) {
+            target.sheen = config.sheen;
+        }
+        if (config.transmission !== undefined) {
+            target.transmission = config.transmission;
+        }
+        if (config.ior !== undefined) {
+            target.ior = config.ior;
+        }
+    }
+}
+
+/** Factor for metalness brightness adjustment */
+const METALNESS_BRIGHTNESS_FACTOR = 0.3;
+/** Factor for emissive color contribution when combining with base color */
+const EMISSIVE_CONTRIBUTION_FACTOR = 0.5;
+/**
+ * Converts MeshStandardMaterial to MeshBasicMaterial with brightness compensation.
+ */
+class StandardToBasicConverter {
+    /**
+     * Converts MeshStandardMaterial to MeshBasicMaterial.
+     *
+     * @param standardMaterial - Source material to convert
+     * @param options - Conversion options
+     * @returns New MeshBasicMaterial with mapped properties
+     */
+    static convert(standardMaterial, options = {}) {
+        const config = Object.assign({ preserveName: true, copyUserData: true, disposeOriginal: false, combineEmissive: true, brightnessFactor: 1.3 }, options);
+        // Create new Basic material
+        const basicMaterial = new MeshBasicMaterial();
         // Copy basic material properties
         this.copyBasicProperties(standardMaterial, basicMaterial, config);
         // Handle color properties with lighting compensation
@@ -1319,622 +1499,556 @@ class StandardToToonConverter {
     }
 }
 
+/** Default horizontal field of view in degrees */
+const DEFAULT_HORIZONTAL_FOV = 90;
+/** Default vertical field of view in degrees */
+const DEFAULT_VERTICAL_FOV = 90;
+/** Default aspect ratio (width/height) */
+const DEFAULT_ASPECT = 1;
+/** Default near clipping plane distance */
+const DEFAULT_NEAR = 1;
+/** Default far clipping plane distance */
+const DEFAULT_FAR = 1000;
+/** Minimum allowed field of view in degrees */
+const MIN_FOV = 1;
+/** Maximum allowed field of view in degrees */
+const MAX_FOV = 179;
 /**
- * Static methods for traversing Three.js scene hierarchies.
- *
- * All methods use depth-first traversal.
+ * Camera with independent horizontal and vertical FOV settings.
  */
-class SceneTraversal {
-    /**
-     * Finds first object with exact name match.
-     *
-     * @param object - Root object to start from
-     * @param name - Name to search for (case-sensitive)
-     * @returns First matching object or undefined
-     */
-    static getObjectByName(object, name) {
-        if (object.name === name) {
-            return object;
-        }
-        for (const child of object.children) {
-            const result = SceneTraversal.getObjectByName(child, name);
-            if (result) {
-                return result;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Finds first material with exact name match from mesh objects.
-     *
-     * @param object - Root object to start from
-     * @param name - Material name to search for (case-sensitive)
-     * @returns First matching material or undefined
-     */
-    static getMaterialByName(object, name) {
-        if (object instanceof Mesh) {
-            if (Array.isArray(object.material)) {
-                for (const material of object.material) {
-                    if (material.name === name) {
-                        return material;
-                    }
-                }
-            }
-            else if (object.material.name === name) {
-                return object.material;
-            }
-        }
-        for (const child of object.children) {
-            const material = SceneTraversal.getMaterialByName(child, name);
-            if (material) {
-                return material;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Executes callback for all objects of specified type.
-     *
-     * @template T - Type of objects to process
-     * @param object - Root object to start from
-     * @param type - Constructor to filter by
-     * @param callback - Function to execute for each matching object
-     */
-    static enumerateObjectsByType(object, type, callback) {
-        if (object instanceof type) {
-            callback(object);
-        }
-        for (const child of object.children) {
-            SceneTraversal.enumerateObjectsByType(child, type, callback);
-        }
-    }
-    /**
-     * Executes callback for all materials of specified type from mesh objects.
-     *
-     * @template T - Type of materials to process
-     * @param object - Root object to start from
-     * @param type - Constructor to filter by
-     * @param callback - Function to execute for each matching material
-     */
-    static enumerateMaterialsByType(object, type, callback) {
-        if (object instanceof Mesh) {
-            if (Array.isArray(object.material)) {
-                for (const material of object.material) {
-                    if (material instanceof type) {
-                        callback(material);
-                    }
-                }
-            }
-            else if (object.material instanceof type) {
-                callback(object.material);
-            }
-        }
-        for (const child of object.children) {
-            SceneTraversal.enumerateMaterialsByType(child, type, callback);
-        }
-    }
-    /**
-     * Executes callback for all objects in hierarchy.
-     *
-     * @param object - Root object to start from
-     * @param callback - Function to execute for each object
-     */
-    static enumerateObjects(object, callback) {
-        callback(object);
-        for (const child of object.children) {
-            SceneTraversal.enumerateObjects(child, callback);
-        }
-    }
-    /**
-     * Executes callback for all materials from mesh objects.
-     * If callback returns a material, replaces the original material.
-     *
-     * @param object - Root object to start from
-     * @param callback - Function to execute for each material. Return a material to replace.
-     */
-    static enumerateMaterials(object, callback) {
-        var _a, _b;
-        if (object instanceof Mesh) {
-            if (Array.isArray(object.material)) {
-                for (let i = 0; i < object.material.length; i++) {
-                    object.material[i] =
-                        (_a = callback(object.material[i], object)) !== null && _a !== void 0 ? _a : object.material[i];
-                }
-            }
-            else {
-                object.material = (_b = callback(object.material, object)) !== null && _b !== void 0 ? _b : object.material;
-            }
-        }
-        for (const child of object.children) {
-            SceneTraversal.enumerateMaterials(child, callback);
-        }
-    }
+class DualFovCamera extends PerspectiveCamera {
     /**
-     * Returns all objects matching filter criteria.
-     *
-     * @param object - Root object to start from
-     * @param filter - RegExp for object names or predicate function
-     * @returns Array of matching objects
+     * @param horizontalFov - Horizontal FOV in degrees (clamped 1-179°)
+     * @param verticalFov - Vertical FOV in degrees (clamped 1-179°)
+     * @param aspect - Aspect ratio (width/height)
+     * @param near - Near clipping plane distance
+     * @param far - Far clipping plane distance
      */
-    static filterObjects(object, filter) {
-        let result = [];
-        if (typeof filter === "function") {
-            if (filter(object)) {
-                result.push(object);
-            }
-        }
-        else {
-            if (object.name && filter.test(object.name)) {
-                result.push(object);
-            }
-        }
-        for (const child of object.children) {
-            result = result.concat(SceneTraversal.filterObjects(child, filter));
-        }
-        return result;
+    constructor(horizontalFov = DEFAULT_HORIZONTAL_FOV, verticalFov = DEFAULT_VERTICAL_FOV, aspect = DEFAULT_ASPECT, near = DEFAULT_NEAR, far = DEFAULT_FAR) {
+        super(verticalFov, aspect, near, far);
+        this._private_horizontalFovInternal = horizontalFov;
+        this._private_verticalFovInternal = verticalFov;
+        this.updateProjectionMatrix();
     }
-    /**
-     * Returns all materials matching filter criteria from mesh objects.
-     *
-     * @param object - Root object to start from
-     * @param filter - RegExp for material names or predicate function
-     * @returns Array of matching materials
-     */
-    static filterMaterials(object, filter) {
-        let result = [];
-        if (object instanceof Mesh) {
-            if (Array.isArray(object.material)) {
-                for (const material of object.material) {
-                    if (typeof filter === "function") {
-                        if (filter(material)) {
-                            result.push(material);
-                        }
-                    }
-                    else if (filter.test(material.name)) {
-                        result.push(material);
-                    }
-                }
-            }
-            else if (typeof filter === "function") {
-                if (filter(object.material)) {
-                    result.push(object.material);
-                }
-            }
-            else if (filter.test(object.material.name)) {
-                result.push(object.material);
-            }
-        }
-        for (const child of object.children) {
-            result = result.concat(SceneTraversal.filterMaterials(child, filter));
-        }
-        return result;
+    /**
+     * @returns Horizontal FOV in degrees
+     */
+    get horizontalFov() {
+        return this._private_horizontalFovInternal;
     }
     /**
-     * Returns all mesh objects that use any of the specified materials.
+     * @returns Vertical FOV in degrees
+     */
+    get verticalFov() {
+        return this._private_verticalFovInternal;
+    }
+    /**
+     * @param value - Horizontal FOV in degrees (clamped 1-179°)
+     */
+    set horizontalFov(value) {
+        this._private_horizontalFovInternal = MathUtils.clamp(value, MIN_FOV, MAX_FOV);
+        this.updateProjectionMatrix();
+    }
+    /**
+     * @param value - Vertical FOV in degrees (clamped 1-179°)
+     */
+    set verticalFov(value) {
+        this._private_verticalFovInternal = MathUtils.clamp(value, MIN_FOV, MAX_FOV);
+        this.updateProjectionMatrix();
+    }
+    /**
+     * Sets both FOV values.
      *
-     * @param object - Root object to start from
-     * @param materials - Array of materials to search for
-     * @returns Array of mesh objects using the materials
+     * @param horizontal - Horizontal FOV in degrees (clamped 1-179°)
+     * @param vertical - Vertical FOV in degrees (clamped 1-179°)
      */
-    static findMaterialUsers(object, materials) {
-        let result = [];
-        if (object instanceof Mesh) {
-            let hasMatchingMaterial = false;
-            if (Array.isArray(object.material)) {
-                for (const material of object.material) {
-                    if (materials.includes(material)) {
-                        hasMatchingMaterial = true;
-                        break;
-                    }
-                }
-            }
-            else {
-                if (materials.includes(object.material)) {
-                    hasMatchingMaterial = true;
-                }
-            }
-            if (hasMatchingMaterial) {
-                result.push(object);
-            }
-        }
-        for (const child of object.children) {
-            result = result.concat(SceneTraversal.findMaterialUsers(child, materials));
-        }
-        return result;
+    setFov(horizontal, vertical) {
+        this._private_horizontalFovInternal = MathUtils.clamp(horizontal, MIN_FOV, MAX_FOV);
+        this._private_verticalFovInternal = MathUtils.clamp(vertical, MIN_FOV, MAX_FOV);
+        this.updateProjectionMatrix();
     }
     /**
-     * Clones material by name and replaces all instances with the clone.
+     * Copies FOV settings from another DualFovCamera.
      *
-     * @param object - Root object to start from
-     * @param name - Material name to search for (case-sensitive)
-     * @returns Cloned material or undefined if not found
+     * @param source - Source camera to copy from
      */
-    static cloneMaterialByName(object, name) {
-        const originalMaterial = SceneTraversal.getMaterialByName(object, name);
-        if (!originalMaterial) {
-            return undefined;
-        }
-        const clonedMaterial = originalMaterial.clone();
-        SceneTraversal.replaceMaterial(object, originalMaterial, clonedMaterial);
-        return clonedMaterial;
+    copyFovSettings(source) {
+        this._private_horizontalFovInternal = source.horizontalFov;
+        this._private_verticalFovInternal = source.verticalFov;
+        this.updateProjectionMatrix();
     }
     /**
-     * Replaces all instances of a material with another material.
+     * Updates projection matrix based on FOV and aspect ratio.
      *
-     * @param object - Root object to start from
-     * @param oldMaterial - Material to replace
-     * @param newMaterial - Material to use as replacement
+     * Landscape (aspect > 1): preserves horizontal FOV.
+     * Portrait (aspect ≤ 1): preserves vertical FOV.
+     *
+     * @override
      */
-    static replaceMaterial(object, oldMaterial, newMaterial) {
-        if (object instanceof Mesh) {
-            if (Array.isArray(object.material)) {
-                object.material = object.material.map((material) => material === oldMaterial ? newMaterial : material);
-            }
-            else if (object.material === oldMaterial) {
-                object.material = newMaterial;
-            }
+    updateProjectionMatrix() {
+        if (this.aspect > 1) {
+            // Landscape orientation: preserve horizontal FOV
+            const radians = MathUtils.degToRad(this._private_horizontalFovInternal);
+            this.fov = MathUtils.radToDeg(Math.atan(Math.tan(radians / 2) / this.aspect) * 2);
         }
-        for (const child of object.children) {
-            SceneTraversal.replaceMaterial(child, oldMaterial, newMaterial);
+        else {
+            // Portrait orientation: preserve vertical FOV
+            this.fov = this._private_verticalFovInternal;
         }
+        super.updateProjectionMatrix();
     }
-}
-
-/** Number of components per vertex */
-const COMPONENT_COUNT = 3;
-/** Converts skinned meshes to static meshes. */
-class SkinnedMeshBaker {
     /**
-     * Converts skinned mesh to static mesh in current pose.
+     * Gets actual horizontal FOV after aspect ratio adjustments.
      *
-     * @param skinnedMesh - Mesh to convert
-     * @returns Static mesh with baked positions
+     * @returns Horizontal FOV in degrees
      */
-    static bakePose(skinnedMesh) {
-        const bakedGeometry = skinnedMesh.geometry.clone();
-        const position = bakedGeometry.attributes["position"];
-        const newPositions = new Float32Array(position.count * COMPONENT_COUNT);
-        const target = new Vector3();
-        for (let i = 0; i < position.count; i++) {
-            target.fromBufferAttribute(position, i);
-            skinnedMesh.applyBoneTransform(i, target);
-            newPositions[i * COMPONENT_COUNT + 0] = target.x;
-            newPositions[i * COMPONENT_COUNT + 1] = target.y;
-            newPositions[i * COMPONENT_COUNT + 2] = target.z;
+    getActualHorizontalFov() {
+        if (this.aspect >= 1) {
+            return this._private_horizontalFovInternal;
         }
-        bakedGeometry.setAttribute("position", new BufferAttribute(newPositions, COMPONENT_COUNT));
-        bakedGeometry.computeVertexNormals();
-        bakedGeometry.deleteAttribute("skinIndex");
-        bakedGeometry.deleteAttribute("skinWeight");
-        const mesh = new Mesh(bakedGeometry, skinnedMesh.material);
-        mesh.name = skinnedMesh.name;
-        return mesh;
+        const verticalRadians = MathUtils.degToRad(this._private_verticalFovInternal);
+        return MathUtils.radToDeg(Math.atan(Math.tan(verticalRadians / 2) * this.aspect) * 2);
     }
     /**
-     * Bakes animation frame to static mesh.
+     * Gets actual vertical FOV after aspect ratio adjustments.
      *
-     * @param armature - Root object with bones
-     * @param skinnedMesh - Mesh to convert
-     * @param timeOffset - Time in seconds within animation
-     * @param clip - Animation clip for pose
-     * @returns Static mesh with baked positions
+     * @returns Vertical FOV in degrees
      */
-    static bakeAnimationFrame(armature, skinnedMesh, timeOffset, clip) {
-        const mixer = new AnimationMixer(armature);
-        const action = mixer.clipAction(clip);
-        action.play();
-        mixer.setTime(timeOffset);
-        armature.updateWorldMatrix(true, true);
-        skinnedMesh.skeleton.update();
-        return this.bakePose(skinnedMesh);
+    getActualVerticalFov() {
+        if (this.aspect < 1) {
+            return this._private_verticalFovInternal;
+        }
+        const horizontalRadians = MathUtils.degToRad(this._private_horizontalFovInternal);
+        return MathUtils.radToDeg(Math.atan(Math.tan(horizontalRadians / 2) / this.aspect) * 2);
     }
-}
-
-/** Number of color channels in RGBA format */
-const RGBA_CHANNEL_COUNT$1 = 4;
-/** Number of color channels in RGB format */
-const RGB_CHANNEL_COUNT$1 = 3;
-/** Red channel weight for luminance calculation (ITU-R BT.709) */
-const LUMINANCE_R$1 = 0.2126;
-/** Green channel weight for luminance calculation (ITU-R BT.709) */
-const LUMINANCE_G$1 = 0.7152;
-/** Blue channel weight for luminance calculation (ITU-R BT.709) */
-const LUMINANCE_B$1 = 0.0722;
-/** Threshold for upper hemisphere sampling (0 = equator, 1 = top) */
-const SKY_SAMPLE_THRESHOLD = 0.25;
-/** Threshold for lower hemisphere sampling (0 = equator, 1 = bottom) */
-const GROUND_SAMPLE_THRESHOLD = 0.75;
-/**
- * Hemisphere light with HDR environment map support for automatic sky/ground color extraction.
- */
-class SkyLight extends HemisphereLight {
     /**
-     * Sets sky and ground colors from an HDR texture.
-     * Analyzes upper hemisphere for sky color and lower hemisphere for ground color.
+     * Adjusts vertical FOV to fit points within camera view.
      *
-     * @param texture - HDR texture to analyze (must have image data)
-     * @param options - Configuration options for color extraction
+     * @param vertices - Array of 3D points in world coordinates
      */
-    setColorsFromHDRTexture(texture, options = {}) {
-        const { skySampleCount = 100, groundSampleCount = 100, applyGamma = true, gamma = 2.2, } = options;
-        const data = texture.image.data;
-        const width = texture.image.width;
-        const height = texture.image.height;
-        const step = texture.format === RGBAFormat ? RGBA_CHANNEL_COUNT$1 : RGB_CHANNEL_COUNT$1;
-        const skyPixels = [];
-        const groundPixels = [];
-        // Sample pixels from upper and lower hemispheres
-        for (let i = 0; i < data.length; i += step) {
-            const pixelIndex = i / step;
-            const y = Math.floor(pixelIndex / width);
-            const v = y / height;
-            const r = data[i];
-            const g = data[i + 1];
-            const b = data[i + 2];
-            const luminance = LUMINANCE_R$1 * r + LUMINANCE_G$1 * g + LUMINANCE_B$1 * b;
-            const pixel = { r, g, b, lum: luminance };
-            // Upper hemisphere (sky)
-            if (v < SKY_SAMPLE_THRESHOLD) {
-                this._private_insertSorted(skyPixels, pixel, skySampleCount, true);
-            }
-            // Lower hemisphere (ground)
-            else if (v > GROUND_SAMPLE_THRESHOLD) {
-                this._private_insertSorted(groundPixels, pixel, groundSampleCount, false);
+    fitVerticalFovToPoints(vertices) {
+        const up = new Vector3(0, 1, 0).applyQuaternion(this.quaternion);
+        let maxVerticalAngle = 0;
+        for (const vertex of vertices) {
+            const vertexToCam = this.position.clone().sub(vertex);
+            const vertexDirection = vertexToCam.normalize();
+            const verticalAngle = Math.asin(Math.abs(vertexDirection.dot(up))) *
+                Math.sign(vertexDirection.dot(up));
+            if (Math.abs(verticalAngle) > maxVerticalAngle) {
+                maxVerticalAngle = Math.abs(verticalAngle);
             }
         }
-        // Calculate average sky color from brightest samples
-        const skyColor = this._private_averagePixels(skyPixels);
-        // Calculate average ground color
-        const groundColor = this._private_averagePixels(groundPixels);
-        // Apply gamma correction if needed
-        if (applyGamma) {
-            const invGamma = 1 / gamma;
-            skyColor.r = Math.pow(skyColor.r, invGamma);
-            skyColor.g = Math.pow(skyColor.g, invGamma);
-            skyColor.b = Math.pow(skyColor.b, invGamma);
-            groundColor.r = Math.pow(groundColor.r, invGamma);
-            groundColor.g = Math.pow(groundColor.g, invGamma);
-            groundColor.b = Math.pow(groundColor.b, invGamma);
-        }
-        // Normalize HDR values to [0, 1] range
-        const maxSky = Math.max(skyColor.r, skyColor.g, skyColor.b, 1);
-        const maxGround = Math.max(groundColor.r, groundColor.g, groundColor.b, 1);
-        this.color.setRGB(skyColor.r / maxSky, skyColor.g / maxSky, skyColor.b / maxSky);
-        this.groundColor.setRGB(groundColor.r / maxGround, groundColor.g / maxGround, groundColor.b / maxGround);
+        const requiredFov = MathUtils.radToDeg(2 * maxVerticalAngle);
+        this._private_verticalFovInternal = MathUtils.clamp(requiredFov, MIN_FOV, MAX_FOV);
+        this.updateProjectionMatrix();
+    }
+    /**
+     * Adjusts vertical FOV to fit bounding box within camera view.
+     *
+     * @param box - 3D bounding box in world coordinates
+     */
+    fitVerticalFovToBox(box) {
+        this.fitVerticalFovToPoints([
+            new Vector3(box.min.x, box.min.y, box.min.z),
+            new Vector3(box.min.x, box.min.y, box.max.z),
+            new Vector3(box.min.x, box.max.y, box.min.z),
+            new Vector3(box.min.x, box.max.y, box.max.z),
+            new Vector3(box.max.x, box.min.y, box.min.z),
+            new Vector3(box.max.x, box.min.y, box.max.z),
+            new Vector3(box.max.x, box.max.y, box.min.z),
+            new Vector3(box.max.x, box.max.y, box.max.z),
+        ]);
     }
     /**
-     * Inserts pixel into sorted array, maintaining size limit.
+     * Adjusts vertical FOV to fit skinned mesh within camera view.
+     * Updates skeleton and applies bone transformations.
+     *
+     * @param skinnedMesh - Skinned mesh with active skeleton
      */
-    _private_insertSorted(array, pixel, maxSize, sortDescending) {
-        if (array.length < maxSize) {
-            array.push(pixel);
-            array.sort((a, b) => (sortDescending ? b.lum - a.lum : a.lum - b.lum));
-        }
-        else {
-            const threshold = array[array.length - 1].lum;
-            const shouldInsert = sortDescending
-                ? pixel.lum > threshold
-                : pixel.lum < threshold;
-            if (shouldInsert) {
-                array.pop();
-                array.push(pixel);
-                array.sort((a, b) => (sortDescending ? b.lum - a.lum : a.lum - b.lum));
-            }
+    fitVerticalFovToMesh(skinnedMesh) {
+        skinnedMesh.updateWorldMatrix(true, true);
+        skinnedMesh.skeleton.update();
+        const bakedGeometry = skinnedMesh.geometry;
+        const position = bakedGeometry.attributes["position"];
+        const target = new Vector3();
+        const points = [];
+        for (let i = 0; i < position.count; i++) {
+            target.fromBufferAttribute(position, i);
+            skinnedMesh.applyBoneTransform(i, target);
+            points.push(target.clone());
         }
+        this.fitVerticalFovToPoints(points);
     }
     /**
-     * Calculates average color from pixel array.
+     * Points camera to look at skinned mesh center of mass.
+     * Uses iterative clustering to find main vertex concentration.
+     *
+     * @param skinnedMesh - Skinned mesh with active skeleton
      */
-    _private_averagePixels(pixels) {
-        if (pixels.length === 0) {
-            return { r: 0.5, g: 0.5, b: 0.5 };
-        }
-        let totalR = 0;
-        let totalG = 0;
-        let totalB = 0;
-        for (const pixel of pixels) {
-            totalR += pixel.r;
-            totalG += pixel.g;
-            totalB += pixel.b;
+    lookAtMeshCenterOfMass(skinnedMesh) {
+        skinnedMesh.updateWorldMatrix(true, true);
+        skinnedMesh.skeleton.update();
+        const bakedGeometry = skinnedMesh.geometry;
+        const position = bakedGeometry.attributes.position;
+        const target = new Vector3();
+        const points = [];
+        for (let i = 0; i < position.count; i++) {
+            target.fromBufferAttribute(position, i);
+            skinnedMesh.applyBoneTransform(i, target);
+            points.push(target.clone());
         }
-        return {
-            r: totalR / pixels.length,
-            g: totalG / pixels.length,
-            b: totalB / pixels.length,
+        /**
+         * Finds main cluster center using iterative refinement.
+         *
+         * @param points - Array of 3D points to cluster
+         * @param iterations - Number of refinement iterations
+         * @returns Center point of main cluster
+         */
+        const findMainCluster = (points, iterations = 3) => {
+            if (points.length === 0) {
+                return new Vector3();
+            }
+            let center = points[Math.floor(points.length / 2)].clone();
+            for (let i = 0; i < iterations; i++) {
+                let total = new Vector3();
+                let count = 0;
+                for (const point of points) {
+                    if (point.distanceTo(center) < point.distanceTo(total) ||
+                        count === 0) {
+                        total.add(point);
+                        count++;
+                    }
+                }
+                if (count > 0) {
+                    center = total.divideScalar(count);
+                }
+            }
+            return center;
         };
+        const centerOfMass = findMainCluster(points);
+        this.lookAt(centerOfMass);
+    }
+    /**
+     * Creates a copy of this camera with identical settings.
+     *
+     * @returns New DualFovCamera instance
+     * @override
+     */
+    clone() {
+        const camera = new DualFovCamera(this._private_horizontalFovInternal, this._private_verticalFovInternal, this.aspect, this.near, this.far);
+        camera.copy(this, true);
+        return camera;
     }
 }
 
-/** Number of color channels in RGBA format */
-const RGBA_CHANNEL_COUNT = 4;
-/** Number of color channels in RGB format */
-const RGB_CHANNEL_COUNT = 3;
-/** Red channel weight for luminance calculation (ITU-R BT.709) */
-const LUMINANCE_R = 0.2126;
-/** Green channel weight for luminance calculation (ITU-R BT.709) */
-const LUMINANCE_G = 0.7152;
-/** Blue channel weight for luminance calculation (ITU-R BT.709) */
-const LUMINANCE_B = 0.0722;
 /**
- * Directional light with spherical positioning and HDR environment support.
+ * Static methods for traversing Three.js scene hierarchies.
+ *
+ * All methods use depth-first traversal.
  */
-class Sun extends DirectionalLight {
-    constructor() {
-        super(...arguments);
-        /** Internal vectors to avoid garbage collection during calculations */
-        this._private_tempVector3D0 = new Vector3();
-        this._private_tempVector3D1 = new Vector3();
-        this._private_tempVector3D2 = new Vector3();
-        this._private_tempVector3D3 = new Vector3();
-        this._private_tempVector3D4 = new Vector3();
-        this._private_tempVector3D5 = new Vector3();
-        this._private_tempVector3D6 = new Vector3();
-        this._private_tempVector3D7 = new Vector3();
-        this._private_tempBox3 = new Box3();
-        this._private_tempSpherical = new Spherical();
-    }
+class SceneTraversal {
     /**
-     * @returns Distance from light position to origin
+     * Finds first object with exact name match.
+     *
+     * @param object - Root object to start from
+     * @param name - Name to search for (case-sensitive)
+     * @returns First matching object or undefined
      */
-    get distance() {
-        return this.position.length();
+    static getObjectByName(object, name) {
+        if (object.name === name) {
+            return object;
+        }
+        for (const child of object.children) {
+            const result = SceneTraversal.getObjectByName(child, name);
+            if (result) {
+                return result;
+            }
+        }
+        return undefined;
     }
     /**
-     * @returns Elevation angle in radians (phi angle)
+     * Finds first material with exact name match from mesh objects.
+     *
+     * @param object - Root object to start from
+     * @param name - Material name to search for (case-sensitive)
+     * @returns First matching material or undefined
      */
-    get elevation() {
-        return this._private_tempSpherical.setFromVector3(this.position).phi;
+    static getMaterialByName(object, name) {
+        if (object instanceof Mesh) {
+            if (Array.isArray(object.material)) {
+                for (const material of object.material) {
+                    if (material.name === name) {
+                        return material;
+                    }
+                }
+            }
+            else if (object.material.name === name) {
+                return object.material;
+            }
+        }
+        for (const child of object.children) {
+            const material = SceneTraversal.getMaterialByName(child, name);
+            if (material) {
+                return material;
+            }
+        }
+        return undefined;
     }
     /**
-     * @returns Azimuth angle in radians (theta angle)
+     * Executes callback for all objects of specified type.
+     *
+     * @template T - Type of objects to process
+     * @param object - Root object to start from
+     * @param type - Constructor to filter by
+     * @param callback - Function to execute for each matching object
      */
-    get azimuth() {
-        return this._private_tempSpherical.setFromVector3(this.position).theta;
+    static enumerateObjectsByType(object, type, callback) {
+        if (object instanceof type) {
+            callback(object);
+        }
+        for (const child of object.children) {
+            SceneTraversal.enumerateObjectsByType(child, type, callback);
+        }
     }
     /**
-     * @param value - New distance in world units
+     * Executes callback for all materials of specified type from mesh objects.
+     *
+     * @template T - Type of materials to process
+     * @param object - Root object to start from
+     * @param type - Constructor to filter by
+     * @param callback - Function to execute for each matching material
      */
-    set distance(value) {
-        this._private_tempSpherical.setFromVector3(this.position);
-        this.position.setFromSphericalCoords(value, this._private_tempSpherical.phi, this._private_tempSpherical.theta);
+    static enumerateMaterialsByType(object, type, callback) {
+        if (object instanceof Mesh) {
+            if (Array.isArray(object.material)) {
+                for (const material of object.material) {
+                    if (material instanceof type) {
+                        callback(material);
+                    }
+                }
+            }
+            else if (object.material instanceof type) {
+                callback(object.material);
+            }
+        }
+        for (const child of object.children) {
+            SceneTraversal.enumerateMaterialsByType(child, type, callback);
+        }
     }
     /**
-     * @param value - New elevation angle in radians (phi angle)
+     * Executes callback for all objects in hierarchy.
+     *
+     * @param object - Root object to start from
+     * @param callback - Function to execute for each object
      */
-    set elevation(value) {
-        this._private_tempSpherical.setFromVector3(this.position);
-        this.position.setFromSphericalCoords(this._private_tempSpherical.radius, value, this._private_tempSpherical.theta);
+    static enumerateObjects(object, callback) {
+        callback(object);
+        for (const child of object.children) {
+            SceneTraversal.enumerateObjects(child, callback);
+        }
     }
     /**
-     * @param value - New azimuth angle in radians (theta angle)
+     * Executes callback for all materials from mesh objects.
+     * If callback returns a material, replaces the original material.
+     *
+     * @param object - Root object to start from
+     * @param callback - Function to execute for each material. Return a material to replace.
      */
-    set azimuth(value) {
-        this._private_tempSpherical.setFromVector3(this.position);
-        this.position.setFromSphericalCoords(this._private_tempSpherical.radius, this._private_tempSpherical.phi, value);
+    static enumerateMaterials(object, callback) {
+        var _a, _b;
+        if (object instanceof Mesh) {
+            if (Array.isArray(object.material)) {
+                for (let i = 0; i < object.material.length; i++) {
+                    object.material[i] =
+                        (_a = callback(object.material[i], object)) !== null && _a !== void 0 ? _a : object.material[i];
+                }
+            }
+            else {
+                object.material = (_b = callback(object.material, object)) !== null && _b !== void 0 ? _b : object.material;
+            }
+        }
+        for (const child of object.children) {
+            SceneTraversal.enumerateMaterials(child, callback);
+        }
     }
     /**
-     * Sets spherical position of the sun.
+     * Returns all objects matching filter criteria.
      *
-     * @param elevation - Elevation angle in radians (phi angle)
-     * @param azimuth - Azimuth angle in radians (theta angle)
-     * @param distance - Distance from origin in world units
+     * @param object - Root object to start from
+     * @param filter - RegExp for object names or predicate function
+     * @returns Array of matching objects
      */
-    setPosition(elevation, azimuth, distance = 1) {
-        this.position.setFromSphericalCoords(distance, elevation, azimuth);
+    static filterObjects(object, filter) {
+        let result = [];
+        if (typeof filter === "function") {
+            if (filter(object)) {
+                result.push(object);
+            }
+        }
+        else {
+            if (object.name && filter.test(object.name)) {
+                result.push(object);
+            }
+        }
+        for (const child of object.children) {
+            result = result.concat(SceneTraversal.filterObjects(child, filter));
+        }
+        return result;
     }
     /**
-     * Configures shadow camera frustum to cover bounding box.
+     * Returns all materials matching filter criteria from mesh objects.
      *
-     * @param box3 - 3D bounding box to cover with shadows
+     * @param object - Root object to start from
+     * @param filter - RegExp for material names or predicate function
+     * @returns Array of matching materials
      */
-    configureShadowsForBoundingBox(box3) {
-        const camera = this.shadow.camera;
-        this.target.updateWorldMatrix(true, false);
-        this.lookAt(this.target.getWorldPosition(this._private_tempVector3D0));
-        this.updateWorldMatrix(true, false);
-        const points = [
-            this._private_tempVector3D0.set(box3.min.x, box3.min.y, box3.min.z),
-            this._private_tempVector3D1.set(box3.min.x, box3.min.y, box3.max.z),
-            this._private_tempVector3D2.set(box3.min.x, box3.max.y, box3.min.z),
-            this._private_tempVector3D3.set(box3.min.x, box3.max.y, box3.max.z),
-            this._private_tempVector3D4.set(box3.max.x, box3.min.y, box3.min.z),
-            this._private_tempVector3D5.set(box3.max.x, box3.min.y, box3.max.z),
-            this._private_tempVector3D6.set(box3.max.x, box3.max.y, box3.min.z),
-            this._private_tempVector3D7.set(box3.max.x, box3.max.y, box3.max.z),
-        ];
-        const inverseMatrix = this.matrixWorld.clone().invert();
-        for (const point of points) {
-            point.applyMatrix4(inverseMatrix);
+    static filterMaterials(object, filter) {
+        let result = [];
+        if (object instanceof Mesh) {
+            if (Array.isArray(object.material)) {
+                for (const material of object.material) {
+                    if (typeof filter === "function") {
+                        if (filter(material)) {
+                            result.push(material);
+                        }
+                    }
+                    else if (filter.test(material.name)) {
+                        result.push(material);
+                    }
+                }
+            }
+            else if (typeof filter === "function") {
+                if (filter(object.material)) {
+                    result.push(object.material);
+                }
+            }
+            else if (filter.test(object.material.name)) {
+                result.push(object.material);
+            }
         }
-        const newBox3 = this._private_tempBox3.setFromPoints(points);
-        camera.left = newBox3.min.x;
-        camera.bottom = newBox3.min.y;
-        camera.near = -newBox3.max.z;
-        camera.right = newBox3.max.x;
-        camera.top = newBox3.max.y;
-        camera.far = -newBox3.min.z;
-        camera.updateWorldMatrix(true, false);
-        camera.updateProjectionMatrix();
+        for (const child of object.children) {
+            result = result.concat(SceneTraversal.filterMaterials(child, filter));
+        }
+        return result;
     }
     /**
-     * Sets sun direction, color and intensity based on brightest point in HDR environment map.
+     * Returns all mesh objects that use any of the specified materials.
      *
-     * @param texture - HDR texture to analyze (must have image data)
-     * @param distance - Distance to place sun from origin
-     * @param intensityScale - Multiplier for intensity derived from luminance (default: 1)
+     * @param object - Root object to start from
+     * @param materials - Array of materials to search for
+     * @returns Array of mesh objects using the materials
      */
-    setFromHDRTexture(texture, intensityScale = 1, distance = 1) {
-        this.setColorFromHDRTexture(texture);
-        this.setIntensityFromHDRTexture(texture, intensityScale);
-        this.setDirectionFromHDRTexture(texture, distance);
+    static findMaterialUsers(object, materials) {
+        let result = [];
+        if (object instanceof Mesh) {
+            let hasMatchingMaterial = false;
+            if (Array.isArray(object.material)) {
+                for (const material of object.material) {
+                    if (materials.includes(material)) {
+                        hasMatchingMaterial = true;
+                        break;
+                    }
+                }
+            }
+            else {
+                if (materials.includes(object.material)) {
+                    hasMatchingMaterial = true;
+                }
+            }
+            if (hasMatchingMaterial) {
+                result.push(object);
+            }
+        }
+        for (const child of object.children) {
+            result = result.concat(SceneTraversal.findMaterialUsers(child, materials));
+        }
+        return result;
     }
     /**
-     * Sets sun color based on brightest point in HDR environment map.
+     * Clones material by name and replaces all instances with the clone.
      *
-     * @param texture - HDR texture to analyze (must have image data)
+     * @param object - Root object to start from
+     * @param name - Material name to search for (case-sensitive)
+     * @returns Cloned material or undefined if not found
      */
-    setColorFromHDRTexture(texture) {
-        const { index } = this._private_findBrightestPixel(texture);
-        const data = texture.image.data;
-        const r = data[index];
-        const g = data[index + 1];
-        const b = data[index + 2];
-        const maxChannel = Math.max(r, g, b, 1);
-        this.color.setRGB(r / maxChannel, g / maxChannel, b / maxChannel);
+    static cloneMaterialByName(object, name) {
+        const originalMaterial = SceneTraversal.getMaterialByName(object, name);
+        if (!originalMaterial) {
+            return undefined;
+        }
+        const clonedMaterial = originalMaterial.clone();
+        SceneTraversal.replaceMaterial(object, originalMaterial, clonedMaterial);
+        return clonedMaterial;
     }
     /**
-     * Sets sun intensity based on luminance of brightest point in HDR environment map.
+     * Replaces all instances of a material with another material.
      *
-     * @param texture - HDR texture to analyze (must have image data)
-     * @param scale - Multiplier for intensity (default: 1)
+     * @param object - Root object to start from
+     * @param oldMaterial - Material to replace
+     * @param newMaterial - Material to use as replacement
      */
-    setIntensityFromHDRTexture(texture, scale = 1) {
-        const { luminance } = this._private_findBrightestPixel(texture);
-        this.intensity = luminance * scale;
+    static replaceMaterial(object, oldMaterial, newMaterial) {
+        if (object instanceof Mesh) {
+            if (Array.isArray(object.material)) {
+                object.material = object.material.map((material) => material === oldMaterial ? newMaterial : material);
+            }
+            else if (object.material === oldMaterial) {
+                object.material = newMaterial;
+            }
+        }
+        for (const child of object.children) {
+            SceneTraversal.replaceMaterial(child, oldMaterial, newMaterial);
+        }
     }
+}
+
+/** Number of components per vertex */
+const COMPONENT_COUNT = 3;
+/** Converts skinned meshes to static meshes. */
+class SkinnedMeshBaker {
     /**
-     * Sets sun direction based on brightest point in HDR environment map.
+     * Converts skinned mesh to static mesh in current pose.
      *
-     * @param texture - HDR texture to analyze (must have image data)
-     * @param distance - Distance to place sun from origin
+     * @param skinnedMesh - Mesh to convert
+     * @returns Static mesh with baked positions
      */
-    setDirectionFromHDRTexture(texture, distance = 1) {
-        const { index } = this._private_findBrightestPixel(texture);
-        const width = texture.image.width;
-        const height = texture.image.height;
-        const step = texture.format === RGBAFormat ? RGBA_CHANNEL_COUNT : RGB_CHANNEL_COUNT;
-        // Convert to spherical coordinates
-        const pixelIndex = index / step;
-        const x = pixelIndex % width;
-        const y = Math.floor(pixelIndex / width);
-        const u = x / width;
-        const v = y / height;
-        const elevation = v * Math.PI;
-        const azimuth = u * -Math.PI * 2 - Math.PI / 2;
-        this.position.setFromSphericalCoords(distance, elevation, azimuth);
+    static bakePose(skinnedMesh) {
+        const bakedGeometry = skinnedMesh.geometry.clone();
+        const position = bakedGeometry.attributes["position"];
+        const newPositions = new Float32Array(position.count * COMPONENT_COUNT);
+        const target = new Vector3();
+        for (let i = 0; i < position.count; i++) {
+            target.fromBufferAttribute(position, i);
+            skinnedMesh.applyBoneTransform(i, target);
+            newPositions[i * COMPONENT_COUNT + 0] = target.x;
+            newPositions[i * COMPONENT_COUNT + 1] = target.y;
+            newPositions[i * COMPONENT_COUNT + 2] = target.z;
+        }
+        bakedGeometry.setAttribute("position", new BufferAttribute(newPositions, COMPONENT_COUNT));
+        bakedGeometry.computeVertexNormals();
+        bakedGeometry.deleteAttribute("skinIndex");
+        bakedGeometry.deleteAttribute("skinWeight");
+        const mesh = new Mesh(bakedGeometry, skinnedMesh.material);
+        mesh.name = skinnedMesh.name;
+        return mesh;
     }
     /**
-     * Finds the brightest pixel in an HDR texture.
+     * Bakes animation frame to static mesh.
      *
-     * @param texture - HDR texture to analyze
-     * @returns Index and luminance of brightest pixel
+     * @param armature - Root object with bones
+     * @param skinnedMesh - Mesh to convert
+     * @param timeOffset - Time in seconds within animation
+     * @param clip - Animation clip for pose
+     * @returns Static mesh with baked positions
      */
-    _private_findBrightestPixel(texture) {
-        const data = texture.image.data;
-        let maxLuminance = 0;
-        let maxIndex = 0;
-        const step = texture.format === RGBAFormat ? RGBA_CHANNEL_COUNT : RGB_CHANNEL_COUNT;
-        for (let i = 0; i < data.length; i += step) {
-            const r = data[i];
-            const g = data[i + 1];
-            const b = data[i + 2];
-            const luminance = LUMINANCE_R * r + LUMINANCE_G * g + LUMINANCE_B * b;
-            if (luminance > maxLuminance) {
-                maxLuminance = luminance;
-                maxIndex = i;
-            }
-        }
-        return { index: maxIndex, luminance: maxLuminance };
+    static bakeAnimationFrame(armature, skinnedMesh, timeOffset, clip) {
+        const mixer = new AnimationMixer(armature);
+        const action = mixer.clipAction(clip);
+        action.play();
+        mixer.setTime(timeOffset);
+        armature.updateWorldMatrix(true, true);
+        skinnedMesh.skeleton.update();
+        return this.bakePose(skinnedMesh);
     }
 }