three-zoo 0.4.1 → 0.4.2

package/dist/BiFovCamera.d.ts

@@ -0,0 +1,71 @@
+import { PerspectiveCamera } from "three";
+/**
+ * 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
+ */
+export declare class BiFovCamera extends PerspectiveCamera {
+    private horizontalFovInternal;
+    private verticalFovInternal;
+    /**
+     * 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?: number, verticalFov?: number, aspect?: number, near?: number, far?: number);
+    /**
+     * Gets the horizontal field of view in degrees
+     */
+    get horizontalFov(): number;
+    /**
+     * Gets the vertical field of view in degrees
+     */
+    get verticalFov(): number;
+    /**
+     * Sets the horizontal field of view in degrees
+     * @param value - The new horizontal FOV value
+     */
+    set horizontalFov(value: number);
+    /**
+     * Sets the vertical field of view in degrees
+     * @param value - The new vertical FOV value
+     */
+    set verticalFov(value: number);
+    /**
+     * Updates both horizontal and vertical FOV simultaneously
+     * @param horizontal - New horizontal FOV in degrees
+     * @param vertical - New vertical FOV in degrees
+     */
+    setFov(horizontal: number, vertical: number): void;
+    /**
+     * Copies FOV settings from another BiFovCamera
+     * @param source - The camera to copy settings from
+     */
+    copyFovSettings(source: BiFovCamera): void;
+    /**
+     * 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(): void;
+    /**
+     * Returns the actual horizontal FOV after aspect ratio adjustments
+     */
+    getEffectiveHorizontalFov(): number;
+    /**
+     * Returns the actual vertical FOV after aspect ratio adjustments
+     */
+    getEffectiveVerticalFov(): number;
+    /**
+     * Creates a clone of this camera with the same properties
+     */
+    clone(): this;
+}

package/dist/Bounds.d.ts

@@ -1,8 +1,28 @@
 import { Box3 } from "three";
 export declare class Bounds extends Box3 {
-    private readonly tempVector3;
+    private readonly tempVector3A;
+    /**
+     * Gets the width (x-axis length) of the bounding box
+     */
     get width(): number;
+    /**
+     * Gets the height (y-axis length) of the bounding box
+     */
     get height(): number;
+    /**
+     * Gets the depth (z-axis length) of the bounding box
+     */
     get depth(): number;
+    /**
+     * Gets the length of the box's diagonal
+     */
     get diagonal(): number;
+    /**
+     * Gets the volume of the bounding box
+     */
+    getVolume(): number;
+    /**
+     * Gets the surface area of the bounding box
+     */
+    getSurfaceArea(): number;
 }

package/dist/{GeometryComparator.d.ts → GeometryHasher.d.ts}

@@ -1,8 +1,8 @@
-import { BufferGeometry } from "three";
+import type { BufferGeometry } from "three";
 /**
  * Utility class for comparing and hashing BufferGeometry instances with tolerance support.
  */
-export declare class GeometryComparator {
+export declare class GeometryHasher {
     /**
      * Generates a consistent hash for a BufferGeometry based on its contents and tolerance.
      *

package/dist/InstanceAssembler.d.ts

@@ -1,4 +1,5 @@
-import { Mesh, Object3D } from "three";
+import type { Object3D } from "three";
+import { Mesh } from "three";
 interface IOptions {
     container: Object3D;
     filter?: (child: Mesh) => boolean;

package/dist/SceneProcessor.d.ts

@@ -1,4 +1,4 @@
-import { Object3D } from "three";
+import type { Object3D } from "three";
 type IPattern = string | RegExp;
 interface IOptions {
     asset: Object3D;

package/dist/{Enumerator.d.ts → SceneTraversal.d.ts}

@@ -1,6 +1,6 @@
-import { Material, Object3D } from "three";
+import type { Material, Object3D } from "three";
 type Constructor<T> = abstract new (...args: never[]) => T;
-export declare class Enumerator {
+export declare class SceneTraversal {
     static getObjectByName(object: Object3D, name: string): Object3D | null;
     static getMaterialByName(object: Object3D, name: string): Material | null;
     static enumerateObjectsByType<T>(object: Object3D, type: Constructor<T>, callback: (instance: T) => void): void;

package/dist/SkinnedMeshBaker.d.ts

@@ -1,4 +1,5 @@
-import { AnimationClip, Mesh, Object3D, SkinnedMesh } from "three";
+import type { AnimationClip, Object3D, SkinnedMesh } from "three";
+import { Mesh } from "three";
 /**
  * Utilities for baking poses and animations from SkinnedMesh into a regular static Mesh.
  */

package/dist/Sun.d.ts

@@ -1,21 +1,71 @@
-import { Box3, DirectionalLight, Texture } from "three";
+import type { Texture } from "three";
+import { Box3, DirectionalLight } from "three";
+/**
+ * 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
+ */
 export declare class Sun extends DirectionalLight {
-    private tempVector3D0;
-    private tempVector3D1;
-    private tempVector3D2;
-    private tempVector3D3;
-    private tempVector3D4;
-    private tempVector3D5;
-    private tempVector3D6;
-    private tempVector3D7;
-    private tempBox3;
-    private tempSpherical;
+    private readonly tempVector3D0;
+    private readonly tempVector3D1;
+    private readonly tempVector3D2;
+    private readonly tempVector3D3;
+    private readonly tempVector3D4;
+    private readonly tempVector3D5;
+    private readonly tempVector3D6;
+    private readonly tempVector3D7;
+    private readonly tempBox3;
+    private readonly tempSpherical;
+    /**
+     * Gets the distance of the sun from its target (radius in spherical coordinates)
+     * @returns The distance in world units
+     */
     get distance(): number;
+    /**
+     * Gets the elevation angle of the sun (phi in spherical coordinates)
+     * @returns The elevation in radians
+     */
     get elevation(): number;
+    /**
+     * Gets the azimuth angle of the sun (theta in spherical coordinates)
+     * @returns The azimuth in radians
+     */
     get azimuth(): number;
+    /**
+     * Sets the distance of the sun from its target while maintaining current angles
+     * @param value - The new distance in world units
+     */
     set distance(value: number);
+    /**
+     * Sets the elevation angle of the sun while maintaining current distance and azimuth
+     * @param value - The new elevation in radians
+     */
     set elevation(value: number);
+    /**
+     * Sets the azimuth angle of the sun while maintaining current distance and elevation
+     * @param value - The new azimuth in radians
+     */
     set azimuth(value: number);
+    /**
+     * 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: Box3): void;
+    /**
+     * 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: Texture, distance?: number): void;
 }

package/dist/index.d.ts

@@ -1,7 +1,7 @@
+export * from "./BiFovCamera";
 export * from "./Bounds";
-export * from "./DoubleFOVCamera";
-export * from "./Enumerator";
 export * from "./InstanceAssembler";
 export * from "./SceneProcessor";
+export * from "./SceneTraversal";
 export * from "./SkinnedMeshBaker";
 export * from "./Sun";