three-zoo 0.13.0 → 0.14.0

package/README.md

@@ -1,211 +1,30 @@
-<p align="center">
-  <h1 align="center">🦁 🐘 🦊 three-zoo</h1>
-  <p align="center">Reusable Three.js utilities.</p>
-</p>
+# three-zoo
 
-<p align="center">
-<a href="https://www.npmjs.com/package/three-zoo"><img src="https://img.shields.io/npm/v/three-zoo.svg" alt="npm version"></a>
-<a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
-<a href="https://www.typescriptlang.org/"><img src="https://img.shields.io/badge/TypeScript-%5E5.8.0-blue" alt="TypeScript"></a>
-<a href="https://threejs.org/"><img src="https://img.shields.io/badge/Three.js-%5E0.175.0-green" alt="Three.js"></a>
-</p>
+[![npm](https://img.shields.io/npm/v/three-zoo.svg)](https://www.npmjs.com/package/three-zoo)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-## Installation
+Reusable Three.js utilities. WebGL 1 compatible.
 
-```bash
-npm install three-zoo
-```
-
-## Contents
-
-- **IK** - `TwoBoneIK`, `AimChainIK`
-- **Instanced Mesh Pool** - `InstancedMeshPool`, `InstancedMeshInstance`, `InstancedMeshGroup`
-- **Lighting** - `Sun`, `SkyLight`
-- **Material Converters** - Standard to Basic / Lambert / Phong / Toon / Physical, Basic to Physical
-- **Miscellaneous** - `DualFovCamera`, `SceneTraversal`, `SceneSorter`, `SkinnedMeshBaker`
-
----
-
-## IK
-
-### TwoBoneIK
-
-Analytical two-bone IK solver. Chain: `root -> middle -> end`. Pole controls bend direction. Writes local quaternions to `root` and `middle`.
-
-```typescript
-const twoBoneIK = new TwoBoneIK(upperArm, foreArm, hand, poleObject, targetObject);
-
-// call after AnimationMixer.update() each frame
-twoBoneIK.solve();
-
-// tune pole twist per bone
-twoBoneIK.rootPoleAxis.set(0, 1, 0);
-twoBoneIK.middlePoleTwist = false;
-```
-
-### AimChainIK
-
-Distributes aim rotation across a bone chain according to per-bone weights.
-
-```typescript
-const aimChainIK = new AimChainIK([spine1, spine2, spine3, head]);
-
-aimChainIK.curve = [0.2, 0.5, 0.8, 1.0]; // root gets least, tip gets most
-aimChainIK.weight = 0.8;                 // global blend
-
-// sample directions before calling - mutates bone quaternions
-aimChainIK.solve(currentForward, targetDirection);
-```
-
----
-
-## Instanced Mesh Pool
-
-Manages `InstancedMesh` instances keyed by geometry+material. Grows capacity automatically.
-
-```typescript
-const pool = new InstancedMeshPool(scene, { initialCapacity: 32, capacityStep: 16 });
-
-// allocate / update / release individual instances
-const instance = new InstancedMeshInstance(pool, geometry, material);
-instance.setPosition3f(1, 0, 0).setScale3f(2, 2, 2).flushTransform();
-instance.destroy();
-
-// group multiple instances under a shared Object3D transform
-const group = new InstancedMeshGroup([instanceA, instanceB]);
-scene.add(group);
-group.position.set(10, 0, 0);
-group.flushTransform(); // propagates group world matrix to all instances
-group.destroy();
-```
-
----
-
-## Lighting
-
-### Sun
-
-`DirectionalLight` with spherical positioning and shadow auto-configuration.
-
-```typescript
-const sun = new Sun();
-sun.elevation = Math.PI / 4;
-sun.azimuth = Math.PI / 2;
-sun.distance = 100;
-
-sun.configureShadowsForBoundingBox(sceneBounds);
-sun.setDirectionFromHDRTexture(hdrTexture, 50);
-```
-
-### SkyLight
+## API
 
-`HemisphereLight` that extracts sky and ground colors from an HDR environment map.
+- **IK**: `TwoBoneIK` (analytical two-bone solver), `AimChainIK` (distributes aim across a bone chain with per-bone weights).
+- **Instanced Mesh Pool**: `InstancedMeshPool`, `InstancedMeshInstance`, `InstancedMeshGroup`. Keyed by geometry+material, auto-grows capacity.
+- **Lighting**: `Sun` (DirectionalLight with spherical positioning, shadow auto-config from bounding box or HDR), `SkyLight` (HemisphereLight that samples sky/ground from HDR).
+- **Material Converters**: Standard to Basic/Lambert/Phong/Toon/Physical, Basic to Physical. Single static `convert()` call each.
+- **DualFovCamera**: PerspectiveCamera with independent horizontal and vertical FOV. Can fit FOV to points, boxes, or skinned meshes.
+- **EnhancedPerspectiveCamera**: PerspectiveCamera whose vertical FOV is derived from a `FovPolicy` and the current aspect ratio. Policies: `FovPolicyFixedVertical`, `FovPolicyFixedHorizontal`, `FovPolicyHybrid`, `FovPolicyHybridInverted`, `FovPolicyCover`, `FovPolicyFit`.
+- **SceneTraversal**: static helpers for finding/filtering objects and materials by name, regex, or predicate.
+- **SceneSorter**: assigns `renderOrder` by distance to a point (front-to-back or back-to-front).
+- **SkinnedMeshBaker**: bakes a SkinnedMesh to static geometry at current pose or a specific animation frame.
 
-```typescript
-const skyLight = new SkyLight();
-skyLight.setColorsFromHDRTexture(hdrTexture, {
-  skySampleCount: 100,
-  groundSampleCount: 100,
-});
-```
-
----
-
-## Material Converters
-
-All converters expose a single static `convert(material, options?)`. Common options:
-
-| Option           | Default | Description                          |
-|------------------|---------|--------------------------------------|
-| `preserveName`   | `true`  | Copy `.name` to the new material     |
-| `copyUserData`   | `true`  | Copy `.userData`                     |
-| `disposeOriginal`| `false` | Dispose source material after conversion |
+## Install
 
-```typescript
-// Standard -> unlit
-const basicMaterial = StandardToBasicConverter.convert(standardMaterial, { brightnessFactor: 1.3, combineEmissive: true });
-
-// Standard -> diffuse-only lit
-const lambertMaterial  = StandardToLambertConverter.convert(standardMaterial);
-const phongMaterial    = StandardToPhongConverter.convert(standardMaterial);
-const toonMaterial     = StandardToToonConverter.convert(standardMaterial);
-
-// Standard <-> Physical
-const physicalMaterial  = StandardToPhysicalConverter.convert(standardMaterial);
-const standardMaterial2 = BasicToPhysicalConverter.convert(basicMaterial);
 ```
-
----
-
-## Miscellaneous
-
-### DualFovCamera
-
-`PerspectiveCamera` with independent horizontal and vertical FOV.
-
-```typescript
-const camera = new DualFovCamera(90, 60);
-camera.horizontalFov = 100;
-camera.verticalFov = 70;
-
-camera.fitVerticalFovToPoints(vertices);
-camera.fitVerticalFovToBox(boundingBox);
-camera.fitVerticalFovToMesh(skinnedMesh);
-camera.lookAtMeshCenterOfMass(skinnedMesh);
-```
-
-### SceneTraversal
-
-Static helpers for depth-first scene graph traversal.
-
-```typescript
-// find by name
-const playerObject  = SceneTraversal.getObjectByName(scene, 'Player');
-const metalMaterial = SceneTraversal.getMaterialByName(scene, 'Metal');
-
-// filter by regex or predicate
-const enemies         = SceneTraversal.filterObjects(scene, /^enemy_/);
-const glassMaterials  = SceneTraversal.filterMaterials(scene, /glass/i);
-
-// enumerate with callback
-SceneTraversal.enumerateMaterials(scene, (material) => {
-  material.needsUpdate = true;
-});
-
-// find meshes that use specific materials
-const glassMeshes = SceneTraversal.findMaterialUsers(scene, glassMaterials);
-```
-
-### SceneSorter
-
-Assigns sequential `renderOrder` values sorted by distance to a point. Useful for transparent meshes.
-
-```typescript
-// front-to-back
-SceneSorter.sortByDistanceToPoint(object, cameraPosition, 0);
-
-// back-to-front (transparent objects)
-SceneSorter.sortByDistanceToPoint(object, cameraPosition, 0, true);
-```
-
-### SkinnedMeshBaker
-
-Bakes a `SkinnedMesh` to static geometry.
-
-```typescript
-// current pose
-const staticMesh = SkinnedMeshBaker.bakePose(skinnedMesh);
-
-// specific animation frame
-const frameMesh = SkinnedMeshBaker.bakeAnimationFrame(armature, skinnedMesh, 1.5, animationClip);
+npm install three-zoo
 ```
 
----
-
-## Requirements
-
-- `three` >=0.157.0 <0.180.0 (peer dependency)
+Peer dep: `three` >=0.157.0 <0.180.0
 
 ## License
 
-MIT © [jango](https://github.com/jango-git)
+MIT

package/dist/camera/EnhancedPerspectiveCamera.d.ts

@@ -0,0 +1,23 @@
+import type { SkinnedMesh } from "three";
+import { PerspectiveCamera } from "three";
+import type { FovPolicy } from "./fovPolicies/FovPolicy";
+/**
+ * PerspectiveCamera whose vertical FOV is derived from a {@link FovPolicy} and the current aspect
+ * ratio. The policy is applied on every `updateProjectionMatrix()` call, so the standard resize
+ * flow (`camera.aspect = w / h; camera.updateProjectionMatrix()`) is all that is needed.
+ */
+export declare class EnhancedPerspectiveCamera extends PerspectiveCamera {
+    private fovPolicyInternal;
+    constructor(fovPolicy: FovPolicy, aspect?: number, near?: number, far?: number);
+    get fovPolicy(): FovPolicy;
+    /** Replacing the policy re-applies it immediately. */
+    set fovPolicy(value: FovPolicy);
+    /** @override */
+    updateProjectionMatrix(): void;
+    /**
+     * Orients the camera toward the mesh's vertex centroid (mean of the skinned vertices in world
+     * space). Calls `skeleton.update()` internally before sampling vertices.
+     */
+    lookAtMeshCenterOfMass(skinnedMesh: SkinnedMesh): void;
+    clone(): this;
+}

package/dist/camera/EnhancedPerspectiveCamera.js

@@ -0,0 +1,66 @@
+import { PerspectiveCamera, Vector3 } from 'three';
+import { clampFov } from './fovPolicies/fovMath.js';
+
+const DEFAULT_ASPECT = 1;
+const DEFAULT_NEAR = 1;
+const DEFAULT_FAR = 1000;
+/**
+ * PerspectiveCamera whose vertical FOV is derived from a {@link FovPolicy} and the current aspect
+ * ratio. The policy is applied on every `updateProjectionMatrix()` call, so the standard resize
+ * flow (`camera.aspect = w / h; camera.updateProjectionMatrix()`) is all that is needed.
+ */
+class EnhancedPerspectiveCamera extends PerspectiveCamera {
+    constructor(fovPolicy, aspect = DEFAULT_ASPECT, near = DEFAULT_NEAR, far = DEFAULT_FAR) {
+        super(clampFov(fovPolicy.calculateFov(aspect)), aspect, near, far);
+        this._private_fovPolicyInternal = fovPolicy;
+        this.updateProjectionMatrix();
+    }
+    get fovPolicy() {
+        return this._private_fovPolicyInternal;
+    }
+    /** Replacing the policy re-applies it immediately. */
+    set fovPolicy(value) {
+        this._private_fovPolicyInternal = value;
+        this.updateProjectionMatrix();
+    }
+    /** @override */
+    updateProjectionMatrix() {
+        // The PerspectiveCamera constructor calls this before fovPolicyInternal is assigned, so the
+        // field may briefly be undefined despite its declared type.
+        const policy = this._private_fovPolicyInternal;
+        if (policy !== undefined) {
+            this.fov = clampFov(policy.calculateFov(this.aspect));
+        }
+        super.updateProjectionMatrix();
+    }
+    /**
+     * Orients the camera toward the mesh's vertex centroid (mean of the skinned vertices in world
+     * space). Calls `skeleton.update()` internally before sampling vertices.
+     */
+    lookAtMeshCenterOfMass(skinnedMesh) {
+        skinnedMesh.updateWorldMatrix(true, true);
+        skinnedMesh.skeleton.update();
+        const position = skinnedMesh.geometry.attributes["position"];
+        if (position.count === 0) {
+            return;
+        }
+        const vertex = new Vector3();
+        const centroid = new Vector3();
+        for (let i = 0; i < position.count; i++) {
+            vertex.fromBufferAttribute(position, i);
+            skinnedMesh.applyBoneTransform(i, vertex);
+            vertex.applyMatrix4(skinnedMesh.matrixWorld);
+            centroid.add(vertex);
+        }
+        centroid.divideScalar(position.count);
+        this.lookAt(centroid);
+    }
+    clone() {
+        const camera = new EnhancedPerspectiveCamera(this._private_fovPolicyInternal.clone(), this.aspect, this.near, this.far);
+        camera.copy(this, true);
+        camera.updateProjectionMatrix();
+        return camera;
+    }
+}
+
+export { EnhancedPerspectiveCamera };

package/dist/camera/fovPolicies/FovPolicy.d.ts

@@ -0,0 +1,4 @@
+/** Base class for FOV policies that derive a vertical FOV from the current aspect ratio. */
+export declare abstract class FovPolicy {
+    abstract clone(): FovPolicy;
+}

package/dist/camera/fovPolicies/FovPolicy.js

@@ -0,0 +1,5 @@
+/** Base class for FOV policies that derive a vertical FOV from the current aspect ratio. */
+class FovPolicy {
+}
+
+export { FovPolicy };

package/dist/camera/fovPolicies/FovPolicyCover.d.ts

@@ -0,0 +1,26 @@
+import { FovPolicy } from "./FovPolicy";
+/**
+ * Guarantees the target frustum is fully visible at any aspect ratio.
+ *
+ * Takes the wider of the two vertical FOVs implied by the horizontal and vertical targets, so
+ * both target angles are always contained (the view may show more than the target rect).
+ */
+export declare class FovPolicyCover extends FovPolicy {
+    private fovHorizontalInternal;
+    private fovVerticalInternal;
+    /**
+     * @param fovHorizontal - Target horizontal FOV. Clamped to 1-179 degrees.
+     * @param fovVertical - Target vertical FOV. Clamped to 1-179 degrees.
+     */
+    constructor(fovHorizontal: number, fovVertical: number);
+    /** Target horizontal FOV. */
+    get fovHorizontal(): number;
+    /** Target vertical FOV. */
+    get fovVertical(): number;
+    /** Clamped to 1-179 degrees. */
+    set fovHorizontal(value: number);
+    /** Clamped to 1-179 degrees. */
+    set fovVertical(value: number);
+    calculateFov(aspect: number): number;
+    clone(): FovPolicyCover;
+}

package/dist/camera/fovPolicies/FovPolicyCover.js

@@ -0,0 +1,44 @@
+import { clampFov, verticalFovFromHorizontal } from './fovMath.js';
+import { FovPolicy } from './FovPolicy.js';
+
+/**
+ * Guarantees the target frustum is fully visible at any aspect ratio.
+ *
+ * Takes the wider of the two vertical FOVs implied by the horizontal and vertical targets, so
+ * both target angles are always contained (the view may show more than the target rect).
+ */
+class FovPolicyCover extends FovPolicy {
+    /**
+     * @param fovHorizontal - Target horizontal FOV. Clamped to 1-179 degrees.
+     * @param fovVertical - Target vertical FOV. Clamped to 1-179 degrees.
+     */
+    constructor(fovHorizontal, fovVertical) {
+        super();
+        this._private_fovHorizontalInternal = clampFov(fovHorizontal);
+        this._private_fovVerticalInternal = clampFov(fovVertical);
+    }
+    /** Target horizontal FOV. */
+    get fovHorizontal() {
+        return this._private_fovHorizontalInternal;
+    }
+    /** Target vertical FOV. */
+    get fovVertical() {
+        return this._private_fovVerticalInternal;
+    }
+    /** Clamped to 1-179 degrees. */
+    set fovHorizontal(value) {
+        this._private_fovHorizontalInternal = clampFov(value);
+    }
+    /** Clamped to 1-179 degrees. */
+    set fovVertical(value) {
+        this._private_fovVerticalInternal = clampFov(value);
+    }
+    calculateFov(aspect) {
+        return Math.max(this._private_fovVerticalInternal, verticalFovFromHorizontal(this._private_fovHorizontalInternal, aspect));
+    }
+    clone() {
+        return new FovPolicyCover(this._private_fovHorizontalInternal, this._private_fovVerticalInternal);
+    }
+}
+
+export { FovPolicyCover };

package/dist/camera/fovPolicies/FovPolicyFit.d.ts

@@ -0,0 +1,26 @@
+import { FovPolicy } from "./FovPolicy";
+/**
+ * Fills the viewport with the target frustum at any aspect ratio.
+ *
+ * Takes the narrower of the two vertical FOVs implied by the horizontal and vertical targets, so
+ * neither target angle is ever exceeded (content outside the target rect is cropped).
+ */
+export declare class FovPolicyFit extends FovPolicy {
+    private fovHorizontalInternal;
+    private fovVerticalInternal;
+    /**
+     * @param fovHorizontal - Target horizontal FOV. Clamped to 1-179 degrees.
+     * @param fovVertical - Target vertical FOV. Clamped to 1-179 degrees.
+     */
+    constructor(fovHorizontal: number, fovVertical: number);
+    /** Target horizontal FOV. */
+    get fovHorizontal(): number;
+    /** Target vertical FOV. */
+    get fovVertical(): number;
+    /** Clamped to 1-179 degrees. */
+    set fovHorizontal(value: number);
+    /** Clamped to 1-179 degrees. */
+    set fovVertical(value: number);
+    calculateFov(aspect: number): number;
+    clone(): FovPolicyFit;
+}

package/dist/camera/fovPolicies/FovPolicyFit.js

@@ -0,0 +1,44 @@
+import { clampFov, verticalFovFromHorizontal } from './fovMath.js';
+import { FovPolicy } from './FovPolicy.js';
+
+/**
+ * Fills the viewport with the target frustum at any aspect ratio.
+ *
+ * Takes the narrower of the two vertical FOVs implied by the horizontal and vertical targets, so
+ * neither target angle is ever exceeded (content outside the target rect is cropped).
+ */
+class FovPolicyFit extends FovPolicy {
+    /**
+     * @param fovHorizontal - Target horizontal FOV. Clamped to 1-179 degrees.
+     * @param fovVertical - Target vertical FOV. Clamped to 1-179 degrees.
+     */
+    constructor(fovHorizontal, fovVertical) {
+        super();
+        this._private_fovHorizontalInternal = clampFov(fovHorizontal);
+        this._private_fovVerticalInternal = clampFov(fovVertical);
+    }
+    /** Target horizontal FOV. */
+    get fovHorizontal() {
+        return this._private_fovHorizontalInternal;
+    }
+    /** Target vertical FOV. */
+    get fovVertical() {
+        return this._private_fovVerticalInternal;
+    }
+    /** Clamped to 1-179 degrees. */
+    set fovHorizontal(value) {
+        this._private_fovHorizontalInternal = clampFov(value);
+    }
+    /** Clamped to 1-179 degrees. */
+    set fovVertical(value) {
+        this._private_fovVerticalInternal = clampFov(value);
+    }
+    calculateFov(aspect) {
+        return Math.min(this._private_fovVerticalInternal, verticalFovFromHorizontal(this._private_fovHorizontalInternal, aspect));
+    }
+    clone() {
+        return new FovPolicyFit(this._private_fovHorizontalInternal, this._private_fovVerticalInternal);
+    }
+}
+
+export { FovPolicyFit };

package/dist/camera/fovPolicies/FovPolicyFixedHorizontal.d.ts

@@ -0,0 +1,13 @@
+import { FovPolicy } from "./FovPolicy";
+/** Keeps the horizontal FOV constant; derives the vertical FOV from the aspect ratio. */
+export declare class FovPolicyFixedHorizontal extends FovPolicy {
+    private fovHorizontalInternal;
+    /** @param fovHorizontal - Clamped to 1-179 degrees. */
+    constructor(fovHorizontal: number);
+    /** Target horizontal FOV. */
+    get fovHorizontal(): number;
+    /** Clamped to 1-179 degrees. */
+    set fovHorizontal(value: number);
+    calculateFov(aspect: number): number;
+    clone(): FovPolicyFixedHorizontal;
+}

package/dist/camera/fovPolicies/FovPolicyFixedHorizontal.js

@@ -0,0 +1,27 @@
+import { clampFov, verticalFovFromHorizontal } from './fovMath.js';
+import { FovPolicy } from './FovPolicy.js';
+
+/** Keeps the horizontal FOV constant; derives the vertical FOV from the aspect ratio. */
+class FovPolicyFixedHorizontal extends FovPolicy {
+    /** @param fovHorizontal - Clamped to 1-179 degrees. */
+    constructor(fovHorizontal) {
+        super();
+        this._private_fovHorizontalInternal = clampFov(fovHorizontal);
+    }
+    /** Target horizontal FOV. */
+    get fovHorizontal() {
+        return this._private_fovHorizontalInternal;
+    }
+    /** Clamped to 1-179 degrees. */
+    set fovHorizontal(value) {
+        this._private_fovHorizontalInternal = clampFov(value);
+    }
+    calculateFov(aspect) {
+        return verticalFovFromHorizontal(this._private_fovHorizontalInternal, aspect);
+    }
+    clone() {
+        return new FovPolicyFixedHorizontal(this._private_fovHorizontalInternal);
+    }
+}
+
+export { FovPolicyFixedHorizontal };

package/dist/camera/fovPolicies/FovPolicyFixedVertical.d.ts

@@ -0,0 +1,13 @@
+import { FovPolicy } from "./FovPolicy";
+/** Keeps the vertical FOV constant regardless of aspect (default three.js behavior). */
+export declare class FovPolicyFixedVertical extends FovPolicy {
+    private fovVerticalInternal;
+    /** @param fovVertical - Clamped to 1-179 degrees. */
+    constructor(fovVertical: number);
+    /** Target vertical FOV. */
+    get fovVertical(): number;
+    /** Clamped to 1-179 degrees. */
+    set fovVertical(value: number);
+    calculateFov(): number;
+    clone(): FovPolicyFixedVertical;
+}

package/dist/camera/fovPolicies/FovPolicyFixedVertical.js

@@ -0,0 +1,27 @@
+import { clampFov } from './fovMath.js';
+import { FovPolicy } from './FovPolicy.js';
+
+/** Keeps the vertical FOV constant regardless of aspect (default three.js behavior). */
+class FovPolicyFixedVertical extends FovPolicy {
+    /** @param fovVertical - Clamped to 1-179 degrees. */
+    constructor(fovVertical) {
+        super();
+        this._private_fovVerticalInternal = clampFov(fovVertical);
+    }
+    /** Target vertical FOV. */
+    get fovVertical() {
+        return this._private_fovVerticalInternal;
+    }
+    /** Clamped to 1-179 degrees. */
+    set fovVertical(value) {
+        this._private_fovVerticalInternal = clampFov(value);
+    }
+    calculateFov() {
+        return this._private_fovVerticalInternal;
+    }
+    clone() {
+        return new FovPolicyFixedVertical(this._private_fovVerticalInternal);
+    }
+}
+
+export { FovPolicyFixedVertical };

package/dist/camera/fovPolicies/FovPolicyHybrid.d.ts

@@ -0,0 +1,25 @@
+import { FovPolicy } from "./FovPolicy";
+/**
+ * Preserves the horizontal FOV in landscape (aspect > 1) and the vertical FOV in portrait.
+ *
+ * Equivalent to DualFovCamera's projection behavior.
+ */
+export declare class FovPolicyHybrid extends FovPolicy {
+    private fovHorizontalInternal;
+    private fovVerticalInternal;
+    /**
+     * @param fovHorizontal - Preserved in landscape. Clamped to 1-179 degrees.
+     * @param fovVertical - Preserved in portrait. Clamped to 1-179 degrees.
+     */
+    constructor(fovHorizontal: number, fovVertical: number);
+    /** Horizontal FOV preserved in landscape. */
+    get fovHorizontal(): number;
+    /** Vertical FOV preserved in portrait. */
+    get fovVertical(): number;
+    /** Clamped to 1-179 degrees. */
+    set fovHorizontal(value: number);
+    /** Clamped to 1-179 degrees. */
+    set fovVertical(value: number);
+    calculateFov(aspect: number): number;
+    clone(): FovPolicyHybrid;
+}

package/dist/camera/fovPolicies/FovPolicyHybrid.js

@@ -0,0 +1,45 @@
+import { clampFov, verticalFovFromHorizontal } from './fovMath.js';
+import { FovPolicy } from './FovPolicy.js';
+
+/**
+ * Preserves the horizontal FOV in landscape (aspect > 1) and the vertical FOV in portrait.
+ *
+ * Equivalent to DualFovCamera's projection behavior.
+ */
+class FovPolicyHybrid extends FovPolicy {
+    /**
+     * @param fovHorizontal - Preserved in landscape. Clamped to 1-179 degrees.
+     * @param fovVertical - Preserved in portrait. Clamped to 1-179 degrees.
+     */
+    constructor(fovHorizontal, fovVertical) {
+        super();
+        this._private_fovHorizontalInternal = clampFov(fovHorizontal);
+        this._private_fovVerticalInternal = clampFov(fovVertical);
+    }
+    /** Horizontal FOV preserved in landscape. */
+    get fovHorizontal() {
+        return this._private_fovHorizontalInternal;
+    }
+    /** Vertical FOV preserved in portrait. */
+    get fovVertical() {
+        return this._private_fovVerticalInternal;
+    }
+    /** Clamped to 1-179 degrees. */
+    set fovHorizontal(value) {
+        this._private_fovHorizontalInternal = clampFov(value);
+    }
+    /** Clamped to 1-179 degrees. */
+    set fovVertical(value) {
+        this._private_fovVerticalInternal = clampFov(value);
+    }
+    calculateFov(aspect) {
+        return aspect > 1
+            ? verticalFovFromHorizontal(this._private_fovHorizontalInternal, aspect)
+            : this._private_fovVerticalInternal;
+    }
+    clone() {
+        return new FovPolicyHybrid(this._private_fovHorizontalInternal, this._private_fovVerticalInternal);
+    }
+}
+
+export { FovPolicyHybrid };

package/dist/camera/fovPolicies/FovPolicyHybridInverted.d.ts

@@ -0,0 +1,21 @@
+import { FovPolicy } from "./FovPolicy";
+/** Preserves the vertical FOV in landscape (aspect > 1) and the horizontal FOV in portrait. */
+export declare class FovPolicyHybridInverted extends FovPolicy {
+    private fovHorizontalInternal;
+    private fovVerticalInternal;
+    /**
+     * @param fovHorizontal - Preserved in portrait. Clamped to 1-179 degrees.
+     * @param fovVertical - Preserved in landscape. Clamped to 1-179 degrees.
+     */
+    constructor(fovHorizontal: number, fovVertical: number);
+    /** Horizontal FOV preserved in portrait. */
+    get fovHorizontal(): number;
+    /** Vertical FOV preserved in landscape. */
+    get fovVertical(): number;
+    /** Clamped to 1-179 degrees. */
+    set fovHorizontal(value: number);
+    /** Clamped to 1-179 degrees. */
+    set fovVertical(value: number);
+    calculateFov(aspect: number): number;
+    clone(): FovPolicyHybridInverted;
+}

package/dist/camera/fovPolicies/FovPolicyHybridInverted.js

@@ -0,0 +1,40 @@
+import { clampFov, verticalFovFromHorizontal } from './fovMath.js';
+import { FovPolicy } from './FovPolicy.js';
+
+/** Preserves the vertical FOV in landscape (aspect > 1) and the horizontal FOV in portrait. */
+class FovPolicyHybridInverted extends FovPolicy {
+    /**
+     * @param fovHorizontal - Preserved in portrait. Clamped to 1-179 degrees.
+     * @param fovVertical - Preserved in landscape. Clamped to 1-179 degrees.
+     */
+    constructor(fovHorizontal, fovVertical) {
+        super();
+        this._private_fovHorizontalInternal = clampFov(fovHorizontal);
+        this._private_fovVerticalInternal = clampFov(fovVertical);
+    }
+    /** Horizontal FOV preserved in portrait. */
+    get fovHorizontal() {
+        return this._private_fovHorizontalInternal;
+    }
+    /** Vertical FOV preserved in landscape. */
+    get fovVertical() {
+        return this._private_fovVerticalInternal;
+    }
+    /** Clamped to 1-179 degrees. */
+    set fovHorizontal(value) {
+        this._private_fovHorizontalInternal = clampFov(value);
+    }
+    /** Clamped to 1-179 degrees. */
+    set fovVertical(value) {
+        this._private_fovVerticalInternal = clampFov(value);
+    }
+    calculateFov(aspect) {
+        return aspect > 1
+            ? this._private_fovVerticalInternal : verticalFovFromHorizontal(this._private_fovHorizontalInternal, aspect);
+    }
+    clone() {
+        return new FovPolicyHybridInverted(this._private_fovHorizontalInternal, this._private_fovVerticalInternal);
+    }
+}
+
+export { FovPolicyHybridInverted };

package/dist/camera/fovPolicies/fovMath.d.ts

@@ -0,0 +1,5 @@
+export declare const MIN_FOV = 1;
+export declare const MAX_FOV = 179;
+export declare function clampFov(value: number): number;
+/** Vertical FOV (degrees) that yields the given horizontal FOV (degrees) at aspect = width / height. */
+export declare function verticalFovFromHorizontal(horizontalFov: number, aspect: number): number;

package/dist/camera/fovPolicies/fovMath.js

@@ -0,0 +1,14 @@
+import { MathUtils } from 'three';
+
+const MIN_FOV = 1;
+const MAX_FOV = 179;
+function clampFov(value) {
+    return MathUtils.clamp(value, MIN_FOV, MAX_FOV);
+}
+/** Vertical FOV (degrees) that yields the given horizontal FOV (degrees) at aspect = width / height. */
+function verticalFovFromHorizontal(horizontalFov, aspect) {
+    const radians = MathUtils.degToRad(horizontalFov);
+    return MathUtils.radToDeg(Math.atan(Math.tan(radians / 2) / aspect) * 2);
+}
+
+export { MAX_FOV, MIN_FOV, clampFov, verticalFovFromHorizontal };

package/dist/ik/AimChainIK.d.ts

@@ -14,7 +14,7 @@ export declare class AimChainIK {
     epsilon: number;
     /**
      * Global blend weight. 0 = solver has no effect, 1 = full effect.
-     * Clamped to 0–1 internally.
+     * Clamped to 0-1 internally.
      */
     weight: number;
     /**
@@ -22,7 +22,7 @@ export declare class AimChainIK {
      *
      * `[1, 1, 1, 1]` = uniform. `[0.2, 0.5, 0.8, 1.0]` = root gets least, tip gets most.
      *
-     * Compared by reference — mutating values in-place won't trigger
+     * Compared by reference - mutating values in-place won't trigger
      * renormalization. Assign a new array to update.
      *
      * Length must match bone count; mismatches throw on `solve()`.
@@ -43,7 +43,7 @@ export declare class AimChainIK {
      *
      * Both vectors are in world space and are not mutated.
      *
-     * Sample directions **before** calling — this method mutates bone quaternions,
+     * Sample directions **before** calling - this method mutates bone quaternions,
      * so any direction derived from the chain will be stale after the call.
      *
      * @param currentDirection - Where the chain currently aims.

package/dist/ik/AimChainIK.js

@@ -18,7 +18,7 @@ class AimChainIK {
         this.epsilon = 1e-5;
         /**
          * Global blend weight. 0 = solver has no effect, 1 = full effect.
-         * Clamped to 0–1 internally.
+         * Clamped to 0-1 internally.
          */
         this.weight = 1;
         this._private_swingAxis = new Vector3();
@@ -38,7 +38,7 @@ class AimChainIK {
      *
      * Both vectors are in world space and are not mutated.
      *
-     * Sample directions **before** calling — this method mutates bone quaternions,
+     * Sample directions **before** calling - this method mutates bone quaternions,
      * so any direction derived from the chain will be stale after the call.
      *
      * @param currentDirection - Where the chain currently aims.

package/dist/index.d.ts

@@ -1,3 +1,11 @@
+export { EnhancedPerspectiveCamera } from "./camera/EnhancedPerspectiveCamera";
+export { FovPolicy } from "./camera/fovPolicies/FovPolicy";
+export { FovPolicyCover } from "./camera/fovPolicies/FovPolicyCover";
+export { FovPolicyFit } from "./camera/fovPolicies/FovPolicyFit";
+export { FovPolicyFixedHorizontal } from "./camera/fovPolicies/FovPolicyFixedHorizontal";
+export { FovPolicyFixedVertical } from "./camera/fovPolicies/FovPolicyFixedVertical";
+export { FovPolicyHybrid } from "./camera/fovPolicies/FovPolicyHybrid";
+export { FovPolicyHybridInverted } from "./camera/fovPolicies/FovPolicyHybridInverted";
 export { AimChainIK } from "./ik/AimChainIK";
 export { TwoBoneIK } from "./ik/TwoBoneIK";
 export { InstancedMeshGroup } from "./instancedMeshPool/InstancedMeshGroup";
@@ -11,7 +19,6 @@ export { StandardToLambertConverter } from "./materialConverters/StandardToLambe
 export { StandardToPhongConverter } from "./materialConverters/StandardToPhongConverter";
 export { StandardToPhysicalConverter } from "./materialConverters/StandardToPhysicalConverter";
 export { StandardToToonConverter } from "./materialConverters/StandardToToonConverter";
-export { DualFovCamera } from "./miscellaneous/DualFovCamera";
 export { SceneSorter } from "./miscellaneous/SceneSorter";
 export { SceneTraversal } from "./miscellaneous/SceneTraversal";
 export { SkinnedMeshBaker } from "./miscellaneous/SkinnedMeshBaker";

package/dist/index.js

@@ -1,3 +1,11 @@
+export { EnhancedPerspectiveCamera } from './camera/EnhancedPerspectiveCamera.js';
+export { FovPolicy } from './camera/fovPolicies/FovPolicy.js';
+export { FovPolicyCover } from './camera/fovPolicies/FovPolicyCover.js';
+export { FovPolicyFit } from './camera/fovPolicies/FovPolicyFit.js';
+export { FovPolicyFixedHorizontal } from './camera/fovPolicies/FovPolicyFixedHorizontal.js';
+export { FovPolicyFixedVertical } from './camera/fovPolicies/FovPolicyFixedVertical.js';
+export { FovPolicyHybrid } from './camera/fovPolicies/FovPolicyHybrid.js';
+export { FovPolicyHybridInverted } from './camera/fovPolicies/FovPolicyHybridInverted.js';
 export { AimChainIK } from './ik/AimChainIK.js';
 export { TwoBoneIK } from './ik/TwoBoneIK.js';
 export { InstancedMeshGroup } from './instancedMeshPool/InstancedMeshGroup.js';
@@ -11,7 +19,6 @@ export { StandardToLambertConverter } from './materialConverters/StandardToLambe
 export { StandardToPhongConverter } from './materialConverters/StandardToPhongConverter.js';
 export { StandardToPhysicalConverter } from './materialConverters/StandardToPhysicalConverter.js';
 export { StandardToToonConverter } from './materialConverters/StandardToToonConverter.js';
-export { DualFovCamera } from './miscellaneous/DualFovCamera.js';
 export { SceneSorter } from './miscellaneous/SceneSorter.js';
 export { SceneTraversal } from './miscellaneous/SceneTraversal.js';
 export { SkinnedMeshBaker } from './miscellaneous/SkinnedMeshBaker.js';

package/dist/instancedMeshPool/InstancedMeshInstance.d.ts

@@ -12,9 +12,9 @@ export declare class InstancedMeshInstance {
     private needsUpdateInstancedMatrixFromLocalMatrix;
     private handler;
     constructor(pool: InstancedMeshPool, geometry: BufferGeometry, material: Material, tag?: string);
+    get isAlive(): boolean;
     static fromInstancedMesh(pool: InstancedMeshPool, mesh: InstancedMesh<BufferGeometry, Material>, tag?: string): InstancedMeshInstance[];
     destroy(): void;
-    isDestroyed(): boolean;
     setPosition(source: Vector3, flushTransform?: boolean): this;
     setPosition3f(x: number, y: number, z: number, flushTransform?: boolean): this;
     setQuaternion(source: Quaternion, flushTransform?: boolean): this;

package/dist/instancedMeshPool/InstancedMeshInstance.js

@@ -12,6 +12,9 @@ class InstancedMeshInstance {
         this._private_needsUpdateInstancedMatrixFromLocalMatrix = false;
         this._private_handler = this._private_pool.allocate(geometry, material, tag);
     }
+    get isAlive() {
+        return this._private_handler >= 0;
+    }
     static fromInstancedMesh(pool, mesh, tag = "") {
         const matrix = new Matrix4();
         const instances = [];
@@ -24,14 +27,11 @@ class InstancedMeshInstance {
         return instances;
     }
     destroy() {
-        if (this._private_handler >= 0) {
+        if (this.isAlive) {
             this._private_pool.deallocate(this._private_handler);
             this._private_handler = -1;
         }
     }
-    isDestroyed() {
-        return this._private_handler < 0;
-    }
     setPosition(source, flushTransform = false) {
         this._private_updateTransformFromMatrix();
         if (!this._private_position.equals(source)) {
@@ -114,7 +114,7 @@ class InstancedMeshInstance {
         return this;
     }
     flushTransform() {
-        if (this._private_handler < 0) {
+        if (!this.isAlive) {
             return;
         }
         this._private_updateMatrixFromTransform();

package/dist/instancedMeshPool/InstancedMeshPool.d.ts

@@ -15,8 +15,7 @@ export declare class InstancedMeshPool {
     isValidHandler(handler: number): boolean;
     sortMeshes(baseRenderOrder: number, compare: (a: InstancedMesh, aTag: string, b: InstancedMesh, bTag: string) => number): void;
     sortInstances(compare: (matrixA: Matrix4, matrixB: Matrix4, tag: string) => number): void;
-    dispose(): void;
-    protected getTransformMatrix(handler: number, target: Matrix4): Matrix4 | undefined;
+    destroy(): void;
     private getOrCreateEntry;
     private growEntry;
     private sortEntryInstances;

package/dist/instancedMeshPool/InstancedMeshPool.js

@@ -33,7 +33,7 @@ class InstancedMeshPool {
             this._private_sortEntryInstances(entry, compare);
         }
     }
-    dispose() {
+    destroy() {
         for (const entry of this._private_entries.values()) {
             this._private_scene.remove(entry.mesh);
             entry.mesh.dispose();
@@ -87,6 +87,7 @@ class InstancedMeshPool {
         descriptor.entry.mesh.setMatrixAt(descriptor.index, matrix);
         descriptor.entry.mesh.instanceMatrix.needsUpdate = true;
     }
+    /** @internal */
     getTransformMatrix(handler, target) {
         const descriptor = this._private_descriptors.get(handler);
         if (descriptor === undefined) {
@@ -150,6 +151,7 @@ class InstancedMeshPool {
             }
             return result;
         });
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- needsReorder is set by the sort callback
         if (!needsReorder) {
             return;
         }

package/dist/lighting/Sun.d.ts

@@ -50,8 +50,8 @@ export declare class Sun extends DirectionalLight {
     /** @param texture - Must have image data. */
     setDirectionFromHDRTexture(texture: Texture, distance?: number): void;
     private findBrightestPixel;
-    /** Stores world-space frustum corners in `tempVector3D0`–`tempVector3D7`. */
+    /** Stores world-space frustum corners in `tempVector3D0`-`tempVector3D7`. */
     private computeFrustumPoints;
-    /** Stores world-space frustum corners in `tempVector3D0`–`tempVector3D7`. */
+    /** Stores world-space frustum corners in `tempVector3D0`-`tempVector3D7`. */
     private computeOrthographicPoints;
 }

package/dist/lighting/Sun.js

@@ -186,7 +186,7 @@ class Sun extends DirectionalLight {
         }
         return { index: maxIndex, luminance: maxLuminance };
     }
-    /** Stores world-space frustum corners in `tempVector3D0`–`tempVector3D7`. */
+    /** Stores world-space frustum corners in `tempVector3D0`-`tempVector3D7`. */
     _private_computeFrustumPoints(camera) {
         const fovRad = camera.fov * MathUtils.DEG2RAD;
         const halfTanFov = Math.tan(fovRad / 2);
@@ -211,7 +211,7 @@ class Sun extends DirectionalLight {
         this._private_tempVector3D6.applyMatrix4(camera.matrixWorld);
         this._private_tempVector3D7.applyMatrix4(camera.matrixWorld);
     }
-    /** Stores world-space frustum corners in `tempVector3D0`–`tempVector3D7`. */
+    /** Stores world-space frustum corners in `tempVector3D0`-`tempVector3D7`. */
     _private_computeOrthographicPoints(camera) {
         this._private_tempVector3D0.set(camera.left, camera.bottom, -camera.near);
         this._private_tempVector3D1.set(camera.right, camera.bottom, -camera.near);

package/dist/miscellaneous/SceneResolver.d.ts

@@ -0,0 +1,6 @@
+import { Material, Mesh, Object3D } from "three";
+export declare class SceneResolver {
+    static resolveObject3DByName(scene: Object3D, name: string): Object3D;
+    static resolveMeshByName(scene: Object3D, name: string): Mesh;
+    static resolveMaterialByName(scene: Object3D, name: string): Material;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-zoo",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Some reusable bits for building things with Three.js",
   "keywords": [
     "three.js",

package/dist/miscellaneous/DualFovCamera.d.ts

@@ -1,43 +0,0 @@
-import type { Box3, SkinnedMesh } from "three";
-import { PerspectiveCamera, Vector3 } from "three";
-/**
- * Camera with independent horizontal and vertical FOV settings.
- */
-export declare class DualFovCamera extends PerspectiveCamera {
-    private horizontalFovInternal;
-    private verticalFovInternal;
-    /**
-     * @param horizontalFov - Clamped to 1–179°.
-     * @param verticalFov - Clamped to 1–179°.
-     */
-    constructor(horizontalFov?: number, verticalFov?: number, aspect?: number, near?: number, far?: number);
-    get horizontalFov(): number;
-    get verticalFov(): number;
-    /** Clamped to 1–179°. */
-    set horizontalFov(value: number);
-    /** Clamped to 1–179°. */
-    set verticalFov(value: number);
-    /** Both values clamped to 1–179°. */
-    setFov(horizontal: number, vertical: number): void;
-    copyFovSettings(source: DualFovCamera): void;
-    /**
-     * Landscape (aspect > 1): preserves horizontal FOV.
-     * Portrait (aspect ≤ 1): preserves vertical FOV.
-     *
-     * @override
-     */
-    updateProjectionMatrix(): void;
-    /** Effective horizontal FOV accounting for current aspect ratio. */
-    getActualHorizontalFov(): number;
-    /** Effective vertical FOV accounting for current aspect ratio. */
-    getActualVerticalFov(): number;
-    /** @param vertices - World-space points. */
-    fitVerticalFovToPoints(vertices: Vector3[]): void;
-    /** @param box - World-space box. */
-    fitVerticalFovToBox(box: Box3): void;
-    /** Calls `skeleton.update()` internally before sampling vertices. */
-    fitVerticalFovToMesh(skinnedMesh: SkinnedMesh): void;
-    /** Uses iterative vertex clustering to approximate center of mass. */
-    lookAtMeshCenterOfMass(skinnedMesh: SkinnedMesh): void;
-    clone(): this;
-}

package/dist/miscellaneous/DualFovCamera.js

@@ -1,170 +0,0 @@
-import { PerspectiveCamera, MathUtils, Vector3 } from 'three';
-
-const DEFAULT_HORIZONTAL_FOV = 90;
-const DEFAULT_VERTICAL_FOV = 90;
-const DEFAULT_ASPECT = 1;
-const DEFAULT_NEAR = 1;
-const DEFAULT_FAR = 1000;
-const MIN_FOV = 1;
-const MAX_FOV = 179;
-/**
- * Camera with independent horizontal and vertical FOV settings.
- */
-class DualFovCamera extends PerspectiveCamera {
-    /**
-     * @param horizontalFov - Clamped to 1–179°.
-     * @param verticalFov - Clamped to 1–179°.
-     */
-    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();
-    }
-    get horizontalFov() {
-        return this._private_horizontalFovInternal;
-    }
-    get verticalFov() {
-        return this._private_verticalFovInternal;
-    }
-    /** Clamped to 1–179°. */
-    set horizontalFov(value) {
-        this._private_horizontalFovInternal = MathUtils.clamp(value, MIN_FOV, MAX_FOV);
-        this.updateProjectionMatrix();
-    }
-    /** Clamped to 1–179°. */
-    set verticalFov(value) {
-        this._private_verticalFovInternal = MathUtils.clamp(value, MIN_FOV, MAX_FOV);
-        this.updateProjectionMatrix();
-    }
-    /** Both values clamped to 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();
-    }
-    copyFovSettings(source) {
-        this._private_horizontalFovInternal = source.horizontalFov;
-        this._private_verticalFovInternal = source.verticalFov;
-        this.updateProjectionMatrix();
-    }
-    /**
-     * Landscape (aspect > 1): preserves horizontal FOV.
-     * Portrait (aspect ≤ 1): preserves vertical FOV.
-     *
-     * @override
-     */
-    updateProjectionMatrix() {
-        if (this.aspect > 1) {
-            const radians = MathUtils.degToRad(this._private_horizontalFovInternal);
-            this.fov = MathUtils.radToDeg(Math.atan(Math.tan(radians / 2) / this.aspect) * 2);
-        }
-        else {
-            this.fov = this._private_verticalFovInternal;
-        }
-        super.updateProjectionMatrix();
-    }
-    /** Effective horizontal FOV accounting for current aspect ratio. */
-    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);
-    }
-    /** Effective vertical FOV accounting for current aspect ratio. */
-    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);
-    }
-    /** @param vertices - World-space points. */
-    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();
-    }
-    /** @param box - World-space box. */
-    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),
-        ]);
-    }
-    /** Calls `skeleton.update()` internally before sampling vertices. */
-    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);
-    }
-    /** Uses iterative vertex clustering to approximate center of mass. */
-    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());
-        }
-        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);
-    }
-    clone() {
-        const camera = new DualFovCamera(this._private_horizontalFovInternal, this._private_verticalFovInternal, this.aspect, this.near, this.far);
-        camera.copy(this, true);
-        return camera;
-    }
-}
-
-export { DualFovCamera };