three-zoo 0.4.1 → 0.4.2

package/dist/index.js

@@ -1,51 +1,254 @@
-import { Box3, Vector3, PerspectiveCamera, MathUtils, Mesh, InstancedMesh, FrontSide, BufferAttribute, AnimationMixer, DirectionalLight, Spherical, RGBAFormat } from 'three';
+import { PerspectiveCamera, MathUtils, Box3, Vector3, Mesh, InstancedMesh, FrontSide, BufferAttribute, AnimationMixer, DirectionalLight, Spherical, RGBAFormat } from 'three';
+
+/**
+ * Default camera settings
+ */
+const DEFAULT_HORIZONTAL_FOV = 90;
+const DEFAULT_VERTICAL_FOV = 90;
+const DEFAULT_ASPECT = 1;
+const DEFAULT_NEAR = 1;
+const DEFAULT_FAR = 1000;
+/**
+ * BiFovCamera - A specialized PerspectiveCamera that supports independent horizontal and vertical FOV settings
+ *
+ * This camera extends Three.js PerspectiveCamera to provide better control over the field of view,
+ * allowing separate horizontal and vertical FOV values. The camera automatically adjusts its projection
+ * matrix based on the aspect ratio to maintain proper perspective.
+ *
+ * @extends PerspectiveCamera
+ */
+class BiFovCamera extends PerspectiveCamera {
+    /**
+     * Creates a new BiFovCamera instance
+     *
+     * @param horizontalFov - Horizontal field of view in degrees (default: 90)
+     * @param verticalFov - Vertical field of view in degrees (default: 90)
+     * @param aspect - Aspect ratio (width/height) of the viewport (default: 1)
+     * @param near - Near clipping plane distance (default: 1)
+     * @param far - Far clipping plane distance (default: 1000)
+     */
+    constructor(horizontalFov = DEFAULT_HORIZONTAL_FOV, verticalFov = DEFAULT_VERTICAL_FOV, aspect = DEFAULT_ASPECT, near = DEFAULT_NEAR, far = DEFAULT_FAR) {
+        super(verticalFov, aspect, near, far);
+        this.horizontalFovInternal = horizontalFov;
+        this.verticalFovInternal = verticalFov;
+        this.updateProjectionMatrix();
+    }
+    /**
+     * Gets the horizontal field of view in degrees
+     */
+    get horizontalFov() {
+        return this.horizontalFovInternal;
+    }
+    /**
+     * Gets the vertical field of view in degrees
+     */
+    get verticalFov() {
+        return this.verticalFovInternal;
+    }
+    /**
+     * Sets the horizontal field of view in degrees
+     * @param value - The new horizontal FOV value
+     */
+    set horizontalFov(value) {
+        this.horizontalFovInternal = MathUtils.clamp(value, 1, 179);
+        this.updateProjectionMatrix();
+    }
+    /**
+     * Sets the vertical field of view in degrees
+     * @param value - The new vertical FOV value
+     */
+    set verticalFov(value) {
+        this.verticalFovInternal = MathUtils.clamp(value, 1, 179);
+        this.updateProjectionMatrix();
+    }
+    /**
+     * Updates both horizontal and vertical FOV simultaneously
+     * @param horizontal - New horizontal FOV in degrees
+     * @param vertical - New vertical FOV in degrees
+     */
+    setFov(horizontal, vertical) {
+        this.horizontalFovInternal = MathUtils.clamp(horizontal, 1, 179);
+        this.verticalFovInternal = MathUtils.clamp(vertical, 1, 179);
+        this.updateProjectionMatrix();
+    }
+    /**
+     * Copies FOV settings from another BiFovCamera
+     * @param source - The camera to copy settings from
+     */
+    copyFovSettings(source) {
+        this.horizontalFovInternal = source.horizontalFov;
+        this.verticalFovInternal = source.verticalFov;
+        this.updateProjectionMatrix();
+    }
+    /**
+     * Updates the projection matrix based on current FOV settings and aspect ratio
+     * For aspect ratios >= 1 (landscape), horizontal FOV is preserved
+     * For aspect ratios < 1 (portrait), vertical FOV is preserved
+     */
+    updateProjectionMatrix() {
+        if (this.aspect >= 1) {
+            // Landscape orientation: preserve horizontal FOV
+            const radians = MathUtils.degToRad(this.horizontalFovInternal);
+            this.fov = MathUtils.radToDeg(Math.atan(Math.tan(radians / 2) / this.aspect) * 2);
+        }
+        else {
+            // Portrait orientation: preserve vertical FOV
+            this.fov = this.verticalFovInternal;
+        }
+        super.updateProjectionMatrix();
+    }
+    /**
+     * Returns the actual horizontal FOV after aspect ratio adjustments
+     */
+    getEffectiveHorizontalFov() {
+        if (this.aspect >= 1) {
+            return this.horizontalFovInternal;
+        }
+        const verticalRadians = MathUtils.degToRad(this.verticalFovInternal);
+        return MathUtils.radToDeg(Math.atan(Math.tan(verticalRadians / 2) * this.aspect) * 2);
+    }
+    /**
+     * Returns the actual vertical FOV after aspect ratio adjustments
+     */
+    getEffectiveVerticalFov() {
+        if (this.aspect < 1) {
+            return this.verticalFovInternal;
+        }
+        const horizontalRadians = MathUtils.degToRad(this.horizontalFovInternal);
+        return MathUtils.radToDeg(Math.atan(Math.tan(horizontalRadians / 2) / this.aspect) * 2);
+    }
+    /**
+     * Creates a clone of this camera with the same properties
+     */
+    clone() {
+        const camera = new BiFovCamera(this.horizontalFovInternal, this.verticalFovInternal, this.aspect, this.near, this.far);
+        camera.copy(this, true);
+        return camera;
+    }
+}
 
 class Bounds extends Box3 {
     constructor() {
         super(...arguments);
-        this.tempVector3 = new Vector3();
+        this.tempVector3A = new Vector3();
     }
+    /**
+     * Gets the width (x-axis length) of the bounding box
+     */
     get width() {
         return this.max.x - this.min.x;
     }
+    /**
+     * Gets the height (y-axis length) of the bounding box
+     */
     get height() {
         return this.max.y - this.min.y;
     }
+    /**
+     * Gets the depth (z-axis length) of the bounding box
+     */
     get depth() {
         return this.max.z - this.min.z;
     }
+    /**
+     * Gets the length of the box's diagonal
+     */
     get diagonal() {
-        this.tempVector3.subVectors(this.max, this.min);
-        return this.tempVector3.length();
+        return this.tempVector3A.subVectors(this.max, this.min).length();
+    }
+    /**
+     * Gets the volume of the bounding box
+     */
+    getVolume() {
+        return this.width * this.height * this.depth;
+    }
+    /**
+     * Gets the surface area of the bounding box
+     */
+    getSurfaceArea() {
+        const w = this.width;
+        const h = this.height;
+        const d = this.depth;
+        return 2 * (w * h + h * d + d * w);
     }
 }
 
-class DoubleFOVCamera extends PerspectiveCamera {
-    constructor(horizontalFov = 90, verticalFov = 90, aspect = 1, near = 1, far = 1000) {
-        super(verticalFov, aspect, near, far);
-        this.horizontalFov = horizontalFov;
-        this.verticalFov = verticalFov;
+/**
+ * Utility class for comparing and hashing BufferGeometry instances with tolerance support.
+ */
+class GeometryHasher {
+    /**
+     * Generates a consistent hash for a BufferGeometry based on its contents and tolerance.
+     *
+     * @param geometry - The geometry to hash
+     * @param tolerance - Precision level for number comparison (values within tolerance are considered equal)
+     * @returns A string hash that will be identical for geometrically equivalent geometries
+     */
+    static getGeometryHash(geometry, tolerance = 1e-6) {
+        const hashParts = [];
+        // Process attributes
+        const attributes = geometry.attributes;
+        const attributeNames = Object.keys(attributes).sort(); // Sort for consistent order
+        for (const name of attributeNames) {
+            const attribute = attributes[name];
+            hashParts.push(`${name}:${attribute.itemSize}:${this.getAttributeHash(attribute, tolerance)}`);
+        }
+        // Process index if present
+        if (geometry.index) {
+            hashParts.push(`index:${this.getAttributeHash(geometry.index, tolerance)}`);
+        }
+        return hashParts.join("|");
     }
-    updateProjectionMatrix() {
-        if (this.aspect >= 1) {
-            const radians = MathUtils.degToRad(this.horizontalFov);
-            this.fov = MathUtils.radToDeg(Math.atan(Math.tan(radians / 2) / this.aspect) * 2);
+    /**
+     * Compares two BufferGeometry instances for approximate equality.
+     * Early exit if UUIDs match (same object or cloned geometry).
+     */
+    static compare(firstGeometry, secondGeometry, tolerance = 1e-6) {
+        if (firstGeometry.uuid === secondGeometry.uuid) {
+            return true;
         }
-        else {
-            this.fov = this.verticalFov;
+        // Use hash comparison for consistent results
+        return (this.getGeometryHash(firstGeometry, tolerance) ===
+            this.getGeometryHash(secondGeometry, tolerance));
+    }
+    /**
+     * Generates a hash for a buffer attribute with tolerance.
+     */
+    static getAttributeHash(attribute, tolerance) {
+        const array = attribute.array;
+        const itemSize = "itemSize" in attribute ? attribute.itemSize : 1;
+        const hashParts = [];
+        // Group values by their "tolerance buckets"
+        for (let i = 0; i < array.length; i += itemSize) {
+            const itemValues = [];
+            for (let j = 0; j < itemSize; j++) {
+                const val = array[i + j];
+                // Round to nearest tolerance multiple to group similar values
+                itemValues.push(Math.round(val / tolerance) * tolerance);
+            }
+            hashParts.push(itemValues.join(","));
         }
-        super.updateProjectionMatrix();
+        return hashParts.join(";");
+    }
+    /**
+     * Compares two buffer attributes with tolerance.
+     */
+    static compareBufferAttributes(firstAttribute, secondAttribute, tolerance) {
+        return (this.getAttributeHash(firstAttribute, tolerance) ===
+            this.getAttributeHash(secondAttribute, tolerance));
     }
 }
 
-class Enumerator {
+class SceneTraversal {
     static getObjectByName(object, name) {
-        if (object.name === name)
+        if (object.name === name) {
             return object;
+        }
         for (const child of object.children) {
-            const result = Enumerator.getObjectByName(child, name);
-            if (result)
+            const result = SceneTraversal.getObjectByName(child, name);
+            if (result) {
                 return result;
+            }
         }
         return null;
     }
@@ -53,8 +256,9 @@ class Enumerator {
         if (object instanceof Mesh) {
             if (Array.isArray(object.material)) {
                 for (const material of object.material) {
-                    if (material.name === name)
+                    if (material.name === name) {
                         return material;
+                    }
                 }
             }
             else if (object.material.name === name) {
@@ -62,9 +266,10 @@ class Enumerator {
             }
         }
         for (const child of object.children) {
-            const material = Enumerator.getMaterialByName(child, name);
-            if (material)
+            const material = SceneTraversal.getMaterialByName(child, name);
+            if (material) {
                 return material;
+            }
         }
         return null;
     }
@@ -73,7 +278,7 @@ class Enumerator {
             callback(object);
         }
         for (const child of object.children) {
-            Enumerator.enumerateObjectsByType(child, type, callback);
+            SceneTraversal.enumerateObjectsByType(child, type, callback);
         }
     }
     static enumerateMaterials(object, callback) {
@@ -88,7 +293,7 @@ class Enumerator {
             }
         }
         for (const child of object.children) {
-            Enumerator.enumerateMaterials(child, callback);
+            SceneTraversal.enumerateMaterials(child, callback);
         }
     }
     static filterObjects(object, name) {
@@ -97,7 +302,7 @@ class Enumerator {
             result.push(object);
         }
         for (const child of object.children) {
-            result = result.concat(Enumerator.filterObjects(child, name));
+            result = result.concat(SceneTraversal.filterObjects(child, name));
         }
         return result;
     }
@@ -118,7 +323,7 @@ class Enumerator {
             }
         }
         for (const child of object.children) {
-            result = result.concat(Enumerator.filterMaterials(child, name));
+            result = result.concat(SceneTraversal.filterMaterials(child, name));
         }
         return result;
     }
@@ -128,176 +333,11 @@ class Enumerator {
             object.receiveShadow = receiveShadow;
         }
         for (const child of object.children) {
-            Enumerator.setShadowRecursive(child, castShadow, receiveShadow);
+            SceneTraversal.setShadowRecursive(child, castShadow, receiveShadow);
         }
     }
 }
 
-/**
- * Utility class for comparing and hashing BufferGeometry instances with tolerance support.
- */
-class GeometryComparator {
-    /**
-     * Generates a consistent hash for a BufferGeometry based on its contents and tolerance.
-     *
-     * @param geometry - The geometry to hash
-     * @param tolerance - Precision level for number comparison (values within tolerance are considered equal)
-     * @returns A string hash that will be identical for geometrically equivalent geometries
-     */
-    static getGeometryHash(geometry, tolerance = 1e-6) {
-        const hashParts = [];
-        // Process attributes
-        const attributes = geometry.attributes;
-        const attributeNames = Object.keys(attributes).sort(); // Sort for consistent order
-        for (const name of attributeNames) {
-            const attribute = attributes[name];
-            hashParts.push(`${name}:${attribute.itemSize}:${this.getAttributeHash(attribute, tolerance)}`);
-        }
-        // Process index if present
-        if (geometry.index) {
-            hashParts.push(`index:${this.getAttributeHash(geometry.index, tolerance)}`);
-        }
-        return hashParts.join("|");
-    }
-    /**
-     * Compares two BufferGeometry instances for approximate equality.
-     * Early exit if UUIDs match (same object or cloned geometry).
-     */
-    static compare(firstGeometry, secondGeometry, tolerance = 1e-6) {
-        if (firstGeometry.uuid === secondGeometry.uuid) {
-            return true;
-        }
-        // Use hash comparison for consistent results
-        return (this.getGeometryHash(firstGeometry, tolerance) ===
-            this.getGeometryHash(secondGeometry, tolerance));
-    }
-    /**
-     * Generates a hash for a buffer attribute with tolerance.
-     */
-    static getAttributeHash(attribute, tolerance) {
-        const array = attribute.array;
-        const itemSize = "itemSize" in attribute ? attribute.itemSize : 1;
-        const hashParts = [];
-        // Group values by their "tolerance buckets"
-        for (let i = 0; i < array.length; i += itemSize) {
-            const itemValues = [];
-            for (let j = 0; j < itemSize; j++) {
-                const val = array[i + j];
-                // Round to nearest tolerance multiple to group similar values
-                itemValues.push(Math.round(val / tolerance) * tolerance);
-            }
-            hashParts.push(itemValues.join(","));
-        }
-        return hashParts.join(";");
-    }
-    /**
-     * Compares two buffer attributes with tolerance.
-     */
-    static compareBufferAttributes(firstAttribute, secondAttribute, tolerance) {
-        return (this.getAttributeHash(firstAttribute, tolerance) ===
-            this.getAttributeHash(secondAttribute, tolerance));
-    }
-}
-// import {
-//   BufferAttribute,
-//   BufferGeometry,
-//   InterleavedBufferAttribute,
-// } from "three";
-// type AnySuitableAttribute = BufferAttribute | InterleavedBufferAttribute;
-// /**
-//  * Utility class for comparing two BufferGeometry instances with tolerance support.
-//  * Checks geometry attributes (positions, normals, UVs, etc.) and indices (if present).
-//  */
-// export class GeometryComparator {
-//   /**
-//    * Compares two BufferGeometry instances for approximate equality.
-//    * Early exit if UUIDs match (same object or cloned geometry).
-//    *
-//    * @param firstGeometry - The first geometry to compare.
-//    * @param secondGeometry - The second geometry to compare.
-//    * @param tolerance - Maximum allowed difference between numeric values (default: 1e-6).
-//    * @returns `true` if geometries are equivalent within tolerance, otherwise `false`.
-//    */
-//   public static compare(
-//     firstGeometry: BufferGeometry,
-//     secondGeometry: BufferGeometry,
-//     tolerance = 1e-6,
-//   ): boolean {
-//     if (firstGeometry.uuid === secondGeometry.uuid) {
-//       return true;
-//     }
-//     const firstAttributes = firstGeometry.attributes;
-//     const secondAttributes = secondGeometry.attributes;
-//     const firstAttributeNames = Object.keys(firstAttributes);
-//     const secondAttributeNames = Object.keys(secondAttributes);
-//     if (firstAttributeNames.length !== secondAttributeNames.length) {
-//       return false;
-//     }
-//     for (const attributeName of firstAttributeNames) {
-//       if (!secondAttributes[attributeName]) {
-//         return false;
-//       }
-//       const firstAttribute = firstAttributes[
-//         attributeName
-//       ] as AnySuitableAttribute;
-//       const secondAttribute = secondAttributes[
-//         attributeName
-//       ] as AnySuitableAttribute;
-//       if (
-//         firstAttribute.count !== secondAttribute.count ||
-//         firstAttribute.itemSize !== secondAttribute.itemSize ||
-//         !this.compareBufferAttributes(
-//           firstAttribute,
-//           secondAttribute,
-//           tolerance,
-//         )
-//       ) {
-//         return false;
-//       }
-//     }
-//     if (firstGeometry.index || secondGeometry.index) {
-//       if (!firstGeometry.index || !secondGeometry.index) {
-//         return false;
-//       }
-//       if (
-//         !this.compareBufferAttributes(
-//           firstGeometry.index,
-//           secondGeometry.index,
-//           tolerance,
-//         )
-//       ) {
-//         return false;
-//       }
-//     }
-//     return true;
-//   }
-//   /**
-//    * Compares two buffer attributes (or index buffers) with tolerance.
-//    *
-//    * @param firstAttribute - First attribute/indices to compare.
-//    * @param secondAttribute - Second attribute/indices to compare.
-//    * @param tolerance - Maximum allowed difference between array elements.
-//    * @returns `true` if arrays are equal within tolerance, otherwise `false`.
-//    */
-//   private static compareBufferAttributes(
-//     firstAttribute: AnySuitableAttribute,
-//     secondAttribute: AnySuitableAttribute,
-//     tolerance: number,
-//   ): boolean {
-//     const firstArray = firstAttribute.array;
-//     const secondArray = secondAttribute.array;
-//     if (firstArray.length !== secondArray.length) {
-//       return false;
-//     }
-//     for (let index = 0; index < firstArray.length; index++) {
-//       if (Math.abs(firstArray[index] - secondArray[index]) > tolerance) {
-//         return false;
-//       }
-//     }
-//     return true;
-//   }
-// }
-
 class InstanceAssembler {
     static assemble(options) {
         var _a, _b;
@@ -305,7 +345,7 @@ class InstanceAssembler {
         const instancedMeshes = [];
         const tolerance = (_a = options.geometryTolerance) !== null && _a !== void 0 ? _a : 1e-6;
         const geometryHashCache = new Map();
-        Enumerator.enumerateObjectsByType(options.container, Mesh, (child) => {
+        SceneTraversal.enumerateObjectsByType(options.container, Mesh, (child) => {
             var _a;
             if (child.children.length === 0 &&
                 (!options.filter || options.filter(child))) {
@@ -314,7 +354,7 @@ class InstanceAssembler {
                     : [child.material];
                 let geometryHash = geometryHashCache.get(child.geometry.uuid);
                 if (!geometryHash) {
-                    geometryHash = GeometryComparator.getGeometryHash(child.geometry, tolerance);
+                    geometryHash = GeometryHasher.getGeometryHash(child.geometry, tolerance);
                     geometryHashCache.set(child.geometry.uuid, geometryHash);
                 }
                 const materialKey = materials.map((m) => m.uuid).join(",");
@@ -325,17 +365,20 @@ class InstanceAssembler {
                     castShadow: false,
                     receiveShadow: false,
                 };
-                if (child.castShadow)
+                if (child.castShadow) {
                     entry.castShadow = true;
-                if (child.receiveShadow)
+                }
+                if (child.receiveShadow) {
                     entry.receiveShadow = true;
+                }
                 entry.meshes.push(child);
                 dictionary.set(compositeKey, entry);
             }
         });
         for (const descriptor of dictionary.values()) {
-            if (descriptor.meshes.length < 2)
+            if (descriptor.meshes.length < 2) {
                 continue;
+            }
             const { meshes, materials, castShadow, receiveShadow } = descriptor;
             const sortedMeshes = meshes.sort((a, b) => a.name.localeCompare(b.name));
             const defaultMesh = sortedMeshes[0];
@@ -365,14 +408,14 @@ class SceneProcessor {
     static process(options) {
         const container = options.asset.clone();
         InstanceAssembler.assemble({ container: container });
-        Enumerator.enumerateMaterials(container, (material) => {
+        SceneTraversal.enumerateMaterials(container, (material) => {
             material.transparent = SceneProcessor.matchesAny(material.name, options.transparentMaterialNames);
             material.depthWrite = !SceneProcessor.matchesAny(material.name, options.noDepthWriteMaterialNames);
             material.side = FrontSide;
             material.forceSinglePass = true;
             material.depthTest = true;
         });
-        Enumerator.enumerateObjectsByType(container, Mesh, (child) => {
+        SceneTraversal.enumerateObjectsByType(container, Mesh, (child) => {
             child.castShadow = SceneProcessor.matchesAny(child.name, options.castShadowMeshNames);
             child.receiveShadow = SceneProcessor.matchesAny(child.name, options.receiveShadowMeshNames);
         });
@@ -434,9 +477,22 @@ class SkinnedMeshBaker {
     }
 }
 
+/**
+ * Sun extends Three.js DirectionalLight to provide a specialized light source that simulates
+ * sunlight with advanced positioning and shadow controls.
+ *
+ * Features:
+ * - Spherical coordinate control (distance, elevation, azimuth)
+ * - Automatic shadow map configuration based on bounding boxes
+ * - HDR environment map-based positioning
+ * - Efficient temporary vector management for calculations
+ *
+ * @extends DirectionalLight
+ */
 class Sun extends DirectionalLight {
     constructor() {
         super(...arguments);
+        // Temporary vectors for calculations to avoid garbage collection
         this.tempVector3D0 = new Vector3();
         this.tempVector3D1 = new Vector3();
         this.tempVector3D2 = new Vector3();
@@ -448,27 +504,57 @@ class Sun extends DirectionalLight {
         this.tempBox3 = new Box3();
         this.tempSpherical = new Spherical();
     }
+    /**
+     * Gets the distance of the sun from its target (radius in spherical coordinates)
+     * @returns The distance in world units
+     */
     get distance() {
         return this.position.length();
     }
+    /**
+     * Gets the elevation angle of the sun (phi in spherical coordinates)
+     * @returns The elevation in radians
+     */
     get elevation() {
         return this.tempSpherical.setFromVector3(this.position).phi;
     }
+    /**
+     * Gets the azimuth angle of the sun (theta in spherical coordinates)
+     * @returns The azimuth in radians
+     */
     get azimuth() {
         return this.tempSpherical.setFromVector3(this.position).theta;
     }
+    /**
+     * Sets the distance of the sun from its target while maintaining current angles
+     * @param value - The new distance in world units
+     */
     set distance(value) {
         this.tempSpherical.setFromVector3(this.position);
         this.position.setFromSphericalCoords(value, this.tempSpherical.phi, this.tempSpherical.theta);
     }
+    /**
+     * Sets the elevation angle of the sun while maintaining current distance and azimuth
+     * @param value - The new elevation in radians
+     */
     set elevation(value) {
         this.tempSpherical.setFromVector3(this.position);
         this.position.setFromSphericalCoords(this.tempSpherical.radius, value, this.tempSpherical.theta);
     }
+    /**
+     * Sets the azimuth angle of the sun while maintaining current distance and elevation
+     * @param value - The new azimuth in radians
+     */
     set azimuth(value) {
         this.tempSpherical.setFromVector3(this.position);
         this.position.setFromSphericalCoords(this.tempSpherical.radius, this.tempSpherical.phi, value);
     }
+    /**
+     * Configures the shadow camera's frustum to encompass the given bounding box
+     * This ensures that shadows are cast correctly for objects within the box
+     *
+     * @param box3 - The bounding box to configure shadows for
+     */
     setShadowMapFromBox3(box3) {
         const camera = this.shadow.camera;
         this.target.updateWorldMatrix(true, false);
@@ -498,23 +584,33 @@ class Sun extends DirectionalLight {
         camera.updateWorldMatrix(true, false);
         camera.updateProjectionMatrix();
     }
+    /**
+     * Sets the sun's direction based on the brightest point in an HDR texture
+     * This is useful for matching the sun's position to an environment map
+     *
+     * @param texture - The HDR texture to analyze (must be loaded and have valid image data)
+     * @param distance - Optional distance to position the sun from its target (default: 1)
+     */
     setDirectionFromHDR(texture, distance = 1) {
         const data = texture.image.data;
         const width = texture.image.width;
         const height = texture.image.height;
         let maxLuminance = 0;
         let maxIndex = 0;
+        // Find the brightest pixel in the HDR texture
         const step = texture.format === RGBAFormat ? 4 : 3;
         for (let i = 0; i < data.length; i += step) {
             const r = data[i];
             const g = data[i + 1];
             const b = data[i + 2];
+            // Calculate luminance using the Rec. 709 coefficients
             const luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b;
             if (luminance > maxLuminance) {
                 maxLuminance = luminance;
                 maxIndex = i;
             }
         }
+        // Convert pixel coordinates to spherical coordinates
         const pixelIndex = maxIndex / step;
         const x = pixelIndex % width;
         const y = Math.floor(pixelIndex / width);
@@ -526,5 +622,5 @@ class Sun extends DirectionalLight {
     }
 }
 
-export { Bounds, DoubleFOVCamera, Enumerator, InstanceAssembler, SceneProcessor, SkinnedMeshBaker, Sun };
+export { BiFovCamera, Bounds, InstanceAssembler, SceneProcessor, SceneTraversal, SkinnedMeshBaker, Sun };
 //# sourceMappingURL=index.js.map