three-zoo 0.12.0 → 0.13.0

package/README.md

@@ -1,152 +1,210 @@
 <p align="center">
-  <h1 align="center">🦁 three-zoo</h1>
-  <p align="center">
-    A small collection of Three.js utilities I use in my daily work with 3D development.
-  </p>
+  <h1 align="center">🦁 🐘 🦊 three-zoo</h1>
+  <p align="center">Reusable Three.js utilities.</p>
 </p>
 
 <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://bundlephobia.com/package/three-zoo"><img src="https://badgen.net/bundlephobia/min/three-zoo" alt="bundle size (min)"></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>
 
-## What's included
-
-- 📷 **DualFovCamera** - Camera with separate horizontal and vertical FOV controls
-- ☀️ **Sun** - Directional light with spherical positioning
-- 🔍 **SceneTraversal** - Helper functions for finding objects and materials in scenes
-- 🎭 **SkinnedMeshBaker** - Converts animated meshes to static geometry
-- 🎨 **StandardToLambertConverter** - Converts PBR materials to Lambert materials
-- ✨ **StandardToBasicConverter** - Converts PBR materials to Basic materials
-
 ## Installation
 
 ```bash
 npm install three-zoo
 ```
 
-## DualFovCamera
+## Contents
 
-A camera that lets you control horizontal and vertical field of view separately:
+- **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`
 
-```typescript
-const camera = new DualFovCamera(90, 60);
+---
 
-// Set FOV values independently
-camera.horizontalFov = 100;
-camera.verticalFov = 70;
+## IK
 
-// Fit objects in view
-camera.fitVerticalFovToPoints(vertices);
-camera.fitVerticalFovToBox(boundingBox);
-camera.fitVerticalFovToMesh(skinnedMesh);
+### TwoBoneIK
 
-// Position camera based on mesh center
-camera.lookAtMeshCenterOfMass(skinnedMesh);
+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;
 ```
 
-## Sun
+### AimChainIK
 
-A directional light with spherical positioning:
+Distributes aim rotation across a bone chain according to per-bone weights.
 
 ```typescript
-const sun = new Sun();
+const aimChainIK = new AimChainIK([spine1, spine2, spine3, head]);
 
-// Position using spherical coordinates
-sun.elevation = Math.PI / 4;  // 45° above horizon
-sun.azimuth = Math.PI / 2;    // 90° rotation
-sun.distance = 100;           // Distance from origin
+aimChainIK.curve = [0.2, 0.5, 0.8, 1.0]; // root gets least, tip gets most
+aimChainIK.weight = 0.8;                 // global blend
 
-// Set up shadows for a bounding box
-sun.configureShadowsForBoundingBox(sceneBounds);
+// sample directions before calling - mutates bone quaternions
+aimChainIK.solve(currentForward, targetDirection);
+```
 
-// Position based on HDR environment map
-sun.setDirectionFromHDRTexture(hdrTexture, 50);
+---
+
+## 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();
 ```
 
-## SceneTraversal
+---
+
+## Lighting
 
-Functions for working with Three.js scene graphs:
+### Sun
+
+`DirectionalLight` with spherical positioning and shadow auto-configuration.
 
 ```typescript
-// Find by name
-const player = SceneTraversal.getObjectByName(scene, 'Player');
-const metal = SceneTraversal.getMaterialByName(scene, 'MetalMaterial');
+const sun = new Sun();
+sun.elevation = Math.PI / 4;
+sun.azimuth = Math.PI / 2;
+sun.distance = 100;
 
-// Find with patterns
-const enemies = SceneTraversal.filterObjects(scene, /^enemy_/);
-const glassMats = SceneTraversal.filterMaterials(scene, /glass/i);
+sun.configureShadowsForBoundingBox(sceneBounds);
+sun.setDirectionFromHDRTexture(hdrTexture, 50);
+```
 
-// Find objects using specific materials
-const glassObjects = SceneTraversal.findMaterialUsers(scene, /glass/i);
+### SkyLight
 
-// Process all materials in a scene
-SceneTraversal.enumerateMaterials(scene, (material) => {
-  if ('roughness' in material) material.roughness = 0.8;
+`HemisphereLight` that extracts sky and ground colors from an HDR environment map.
+
+```typescript
+const skyLight = new SkyLight();
+skyLight.setColorsFromHDRTexture(hdrTexture, {
+  skySampleCount: 100,
+  groundSampleCount: 100,
 });
 ```
 
-## SkinnedMeshBaker
+---
+
+## Material Converters
+
+All converters expose a single static `convert(material, options?)`. Common options:
 
-Convert animated meshes to static geometry:
+| Option           | Default | Description                          |
+|------------------|---------|--------------------------------------|
+| `preserveName`   | `true`  | Copy `.name` to the new material     |
+| `copyUserData`   | `true`  | Copy `.userData`                     |
+| `disposeOriginal`| `false` | Dispose source material after conversion |
 
 ```typescript
-// Bake current pose
-const staticMesh = SkinnedMeshBaker.bakePose(skinnedMesh);
+// 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);
 
-// Bake specific animation frame
-const frameMesh = SkinnedMeshBaker.bakeAnimationFrame(
-  armature,
-  skinnedMesh,
-  1.5,              // Time in seconds
-  animationClip
-);
+// Standard <-> Physical
+const physicalMaterial  = StandardToPhysicalConverter.convert(standardMaterial);
+const standardMaterial2 = BasicToPhysicalConverter.convert(basicMaterial);
 ```
 
-## Material Converters
+---
+
+## Miscellaneous
 
-Convert PBR materials to simpler types. Useful for performance optimization:
+### DualFovCamera
 
-### StandardToLambertConverter
+`PerspectiveCamera` with independent horizontal and vertical FOV.
 
 ```typescript
-// Basic conversion
-const lambertMaterial = StandardToLambertConverter.convert(standardMaterial);
-
-// With options
-const lambertMaterial = StandardToLambertConverter.convert(standardMaterial, {
-  preserveName: true,
-  roughnessColorFactor: 0.9,
-  disposeOriginal: true
-});
+const camera = new DualFovCamera(90, 60);
+camera.horizontalFov = 100;
+camera.verticalFov = 70;
+
+camera.fitVerticalFovToPoints(vertices);
+camera.fitVerticalFovToBox(boundingBox);
+camera.fitVerticalFovToMesh(skinnedMesh);
+camera.lookAtMeshCenterOfMass(skinnedMesh);
 ```
 
-### StandardToBasicConverter
+### SceneTraversal
+
+Static helpers for depth-first scene graph traversal.
 
 ```typescript
-// Convert to unlit material
-const basicMaterial = StandardToBasicConverter.convert(standardMaterial);
-
-// With brightness adjustment
-const basicMaterial = StandardToBasicConverter.convert(standardMaterial, {
-  brightnessFactor: 1.5,
-  combineEmissive: true,
-  preserveName: true,
-  disposeOriginal: false
+// 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);
 ```
 
-## Requirements
+### 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);
+```
 
-- Three.js ^0.175.0 (peer dependency)
-- TypeScript support included
+### SkinnedMeshBaker
 
-## Contributing
+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);
+```
+
+---
+
+## Requirements
 
-Feel free to submit issues and pull requests if you find these utilities helpful.
+- `three` >=0.157.0 <0.180.0 (peer dependency)
 
 ## License
 

package/dist/ik/AimChainIK.d.ts

@@ -0,0 +1,58 @@
+import type { Object3D } from "three";
+import { Vector3 } from "three";
+/**
+ * Distributes aim rotation across a chain of bones.
+ *
+ * Computes the swing rotation from `currentDirection` to `targetDirection`
+ * and splits it across bones according to `curve` weights.
+ *
+ * Mutates `bone.quaternion` directly. Call after AnimationMixer update.
+ */
+export declare class AimChainIK {
+    readonly bones: readonly Object3D[];
+    /** Numerical stability threshold. */
+    epsilon: number;
+    /**
+     * Global blend weight. 0 = solver has no effect, 1 = full effect.
+     * Clamped to 0–1 internally.
+     */
+    weight: number;
+    /**
+     * Per-bone rotation weights. Normalized internally so their sum equals 1.
+     *
+     * `[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
+     * renormalization. Assign a new array to update.
+     *
+     * Length must match bone count; mismatches throw on `solve()`.
+     */
+    curve: readonly number[];
+    private readonly swingAxis;
+    private readonly deltaRotation;
+    private readonly boneWorldQuaternion;
+    private readonly parentWorldQuaternion;
+    private normalizedCurve;
+    private lastCurveReference;
+    /**
+     * @param bones - Ordered from root to tip. Must contain at least one bone.
+     */
+    constructor(bones: readonly Object3D[]);
+    /**
+     * Rotate the chain so that `currentDirection` aligns with `targetDirection`.
+     *
+     * Both vectors are in world space and are not mutated.
+     *
+     * 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.
+     * @param targetDirection - Where it should aim.
+     */
+    solve(currentDirection: Vector3, targetDirection: Vector3): void;
+    /**
+     * Returns normalized curve (sums to 1).
+     * Rebuilds only when the `curve` reference changes.
+     */
+    private getNormalizedCurve;
+}

package/dist/ik/AimChainIK.js

@@ -0,0 +1,130 @@
+import { Vector3, Quaternion, MathUtils } from 'three';
+
+/**
+ * Distributes aim rotation across a chain of bones.
+ *
+ * Computes the swing rotation from `currentDirection` to `targetDirection`
+ * and splits it across bones according to `curve` weights.
+ *
+ * Mutates `bone.quaternion` directly. Call after AnimationMixer update.
+ */
+class AimChainIK {
+    /**
+     * @param bones - Ordered from root to tip. Must contain at least one bone.
+     */
+    constructor(bones) {
+        this.bones = bones;
+        /** Numerical stability threshold. */
+        this.epsilon = 1e-5;
+        /**
+         * Global blend weight. 0 = solver has no effect, 1 = full effect.
+         * Clamped to 0–1 internally.
+         */
+        this.weight = 1;
+        this._private_swingAxis = new Vector3();
+        this._private_deltaRotation = new Quaternion();
+        this._private_boneWorldQuaternion = new Quaternion();
+        this._private_parentWorldQuaternion = new Quaternion();
+        this._private_normalizedCurve = [];
+        this._private_lastCurveReference = undefined;
+        if (bones.length === 0) {
+            throw new Error("AimChainIK requires at least one bone.");
+        }
+        const uniform = Array(bones.length).fill(1);
+        this.curve = uniform;
+    }
+    /**
+     * Rotate the chain so that `currentDirection` aligns with `targetDirection`.
+     *
+     * Both vectors are in world space and are not mutated.
+     *
+     * 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.
+     * @param targetDirection - Where it should aim.
+     */
+    solve(currentDirection, targetDirection) {
+        const effectiveWeight = MathUtils.clamp(this.weight, 0, 1);
+        if (effectiveWeight < this.epsilon) {
+            return;
+        }
+        const currentLength = currentDirection.length();
+        const targetLength = targetDirection.length();
+        if (currentLength < this.epsilon || targetLength < this.epsilon) {
+            return;
+        }
+        const dotProduct = MathUtils.clamp(currentDirection.dot(targetDirection) / (currentLength * targetLength), -1, 1);
+        const totalAngle = Math.acos(dotProduct);
+        if (totalAngle < this.epsilon) {
+            return;
+        }
+        this._private_swingAxis.copy(currentDirection).cross(targetDirection).normalize();
+        // Near-opposite directions: pick an arbitrary perpendicular axis.
+        if (this._private_swingAxis.lengthSq() < this.epsilon) {
+            this._private_swingAxis.set(0, 1, 0);
+            this._private_swingAxis.addScaledVector(currentDirection, -this._private_swingAxis.dot(currentDirection) / (currentLength * currentLength));
+            if (this._private_swingAxis.lengthSq() < this.epsilon) {
+                this._private_swingAxis.set(1, 0, 0);
+            }
+            this._private_swingAxis.normalize();
+        }
+        const curve = this._private_getNormalizedCurve();
+        const weightedAngle = totalAngle * effectiveWeight;
+        for (let index = 0; index < this.bones.length; index++) {
+            const bone = this.bones[index];
+            const boneAngle = weightedAngle * curve[index];
+            if (boneAngle < this.epsilon) {
+                continue;
+            }
+            this._private_deltaRotation.setFromAxisAngle(this._private_swingAxis, boneAngle);
+            if (bone.parent) {
+                bone.parent.getWorldQuaternion(this._private_parentWorldQuaternion);
+            }
+            else {
+                this._private_parentWorldQuaternion.identity();
+            }
+            // localDelta = parentInverse * worldDelta * parentWorld
+            this._private_boneWorldQuaternion.copy(this._private_parentWorldQuaternion)
+                .invert()
+                .multiply(this._private_deltaRotation)
+                .multiply(this._private_parentWorldQuaternion);
+            bone.quaternion.premultiply(this._private_boneWorldQuaternion);
+        }
+    }
+    /**
+     * Returns normalized curve (sums to 1).
+     * Rebuilds only when the `curve` reference changes.
+     */
+    _private_getNormalizedCurve() {
+        if (this._private_lastCurveReference === this.curve) {
+            return this._private_normalizedCurve;
+        }
+        if (this.curve.length !== this.bones.length) {
+            throw new Error(`AimChainIK: curve length (${this.curve.length}) must match bone count (${this.bones.length}).`);
+        }
+        let sum = 0;
+        for (const value of this.curve) {
+            sum += value;
+        }
+        if (this._private_normalizedCurve.length !== this.curve.length) {
+            this._private_normalizedCurve = new Array(this.curve.length);
+        }
+        if (sum < this.epsilon) {
+            const uniform = 1 / this.bones.length;
+            for (let index = 0; index < this._private_normalizedCurve.length; index++) {
+                this._private_normalizedCurve[index] = uniform;
+            }
+        }
+        else {
+            const inverseSum = 1 / sum;
+            for (let index = 0; index < this.curve.length; index++) {
+                this._private_normalizedCurve[index] = this.curve[index] * inverseSum;
+            }
+        }
+        this._private_lastCurveReference = this.curve;
+        return this._private_normalizedCurve;
+    }
+}
+
+export { AimChainIK };

package/dist/{miscellaneous → ik}/TwoBoneIK.js

@@ -91,8 +91,7 @@ class TwoBoneIK {
         const middlePerpendicular = upperLength * Math.sin(angleRoot);
         this._private_perpendicularDirection.subVectors(this._private_polePosition, this._private_rootPosition);
         this._private_perpendicularDirection.addScaledVector(this._private_chainDirection, -this._private_perpendicularDirection.dot(this._private_chainDirection));
-        // Guard: pole collinear with chain — perpendicular is degenerate.
-        // Pick an arbitrary axis perpendicular to chain.
+        // If the pole is collinear with the chain then we must choose an arbitrary axis perpendicular to the chain.
         if (this._private_perpendicularDirection.lengthSq() < this.epsilon) {
             this._private_perpendicularDirection.set(0, 1, 0);
             this._private_perpendicularDirection.addScaledVector(this._private_chainDirection, -this._private_perpendicularDirection.dot(this._private_chainDirection));
@@ -121,11 +120,10 @@ class TwoBoneIK {
      * which constrains aim direction but not roll.
      */
     _private_twistBoneTowardPole(bone, child, poleAxis) {
-        const epsilon = this.epsilon;
         bone.getWorldPosition(this._private_bonePosition);
         child.getWorldPosition(this._private_childPosition);
         this._private_aimAxis.subVectors(this._private_childPosition, this._private_bonePosition);
-        if (this._private_aimAxis.lengthSq() < epsilon) {
+        if (this._private_aimAxis.lengthSq() < this.epsilon) {
             return;
         }
         this._private_aimAxis.normalize();
@@ -133,12 +131,12 @@ class TwoBoneIK {
         this._private_currentUp.copy(poleAxis).applyQuaternion(this._private_boneWorldQuaternion);
         this._private_desiredUp.subVectors(this._private_polePosition, this._private_bonePosition);
         this._private_desiredUp.addScaledVector(this._private_aimAxis, -this._private_desiredUp.dot(this._private_aimAxis));
-        if (this._private_desiredUp.lengthSq() < epsilon) {
+        if (this._private_desiredUp.lengthSq() < this.epsilon) {
             return;
         }
         this._private_desiredUp.normalize();
         this._private_currentUp.addScaledVector(this._private_aimAxis, -this._private_currentUp.dot(this._private_aimAxis));
-        if (this._private_currentUp.lengthSq() < epsilon) {
+        if (this._private_currentUp.lengthSq() < this.epsilon) {
             console.warn(`TwoBoneIK: poleAxis is parallel to bone's aim axis - twist is undefined.`);
             return;
         }
@@ -148,7 +146,7 @@ class TwoBoneIK {
         if (this._private_currentDirection.dot(this._private_aimAxis) < 0) {
             angle = -angle;
         }
-        if (Math.abs(angle) < epsilon) {
+        if (Math.abs(angle) < this.epsilon) {
             return;
         }
         this._private_twistRotation.setFromAxisAngle(this._private_aimAxis, angle);

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+export { AimChainIK } from "./ik/AimChainIK";
+export { TwoBoneIK } from "./ik/TwoBoneIK";
 export { InstancedMeshGroup } from "./instancedMeshPool/InstancedMeshGroup";
 export { InstancedMeshInstance } from "./instancedMeshPool/InstancedMeshInstance";
 export { InstancedMeshPool } from "./instancedMeshPool/InstancedMeshPool";
@@ -13,4 +15,3 @@ export { DualFovCamera } from "./miscellaneous/DualFovCamera";
 export { SceneSorter } from "./miscellaneous/SceneSorter";
 export { SceneTraversal } from "./miscellaneous/SceneTraversal";
 export { SkinnedMeshBaker } from "./miscellaneous/SkinnedMeshBaker";
-export { TwoBoneIK } from "./miscellaneous/TwoBoneIK";

package/dist/index.js

@@ -1,3 +1,5 @@
+export { AimChainIK } from './ik/AimChainIK.js';
+export { TwoBoneIK } from './ik/TwoBoneIK.js';
 export { InstancedMeshGroup } from './instancedMeshPool/InstancedMeshGroup.js';
 export { InstancedMeshInstance } from './instancedMeshPool/InstancedMeshInstance.js';
 export { InstancedMeshPool } from './instancedMeshPool/InstancedMeshPool.js';
@@ -13,4 +15,3 @@ export { DualFovCamera } from './miscellaneous/DualFovCamera.js';
 export { SceneSorter } from './miscellaneous/SceneSorter.js';
 export { SceneTraversal } from './miscellaneous/SceneTraversal.js';
 export { SkinnedMeshBaker } from './miscellaneous/SkinnedMeshBaker.js';
-export { TwoBoneIK } from './miscellaneous/TwoBoneIK.js';

package/dist/instancedMeshPool/InstancedMeshInstance.d.ts

@@ -1,4 +1,4 @@
-import type { BufferGeometry, Material } from "three";
+import type { BufferGeometry, InstancedMesh, Material } from "three";
 import { Matrix4, Quaternion, Vector3 } from "three";
 import type { InstancedMeshPool } from "./InstancedMeshPool";
 export declare class InstancedMeshInstance {
@@ -12,6 +12,7 @@ export declare class InstancedMeshInstance {
     private needsUpdateInstancedMatrixFromLocalMatrix;
     private handler;
     constructor(pool: InstancedMeshPool, geometry: BufferGeometry, material: Material, tag?: string);
+    static fromInstancedMesh(pool: InstancedMeshPool, mesh: InstancedMesh<BufferGeometry, Material>, tag?: string): InstancedMeshInstance[];
     destroy(): void;
     isDestroyed(): boolean;
     setPosition(source: Vector3, flushTransform?: boolean): this;

package/dist/instancedMeshPool/InstancedMeshInstance.js

@@ -12,6 +12,17 @@ class InstancedMeshInstance {
         this._private_needsUpdateInstancedMatrixFromLocalMatrix = false;
         this._private_handler = this._private_pool.allocate(geometry, material, tag);
     }
+    static fromInstancedMesh(pool, mesh, tag = "") {
+        const matrix = new Matrix4();
+        const instances = [];
+        for (let i = 0; i < mesh.count; i++) {
+            const instance = new InstancedMeshInstance(pool, mesh.geometry, mesh.material, tag);
+            mesh.getMatrixAt(i, matrix);
+            instance.setTransform(matrix, true);
+            instances.push(instance);
+        }
+        return instances;
+    }
     destroy() {
         if (this._private_handler >= 0) {
             this._private_pool.deallocate(this._private_handler);

package/dist/miscellaneous/SkinnedMeshBaker.d.ts

@@ -2,8 +2,7 @@ import type { AnimationClip, Object3D, SkinnedMesh } from "three";
 import { Mesh } from "three";
 export declare class SkinnedMeshBaker {
     /**
-     * Does not call `skeleton.update()` internally — skeleton must be up to date before calling.
-     * The returned mesh shares the original material (not cloned).
+     * Does not call the skeleton update, assuming it is already in a state ready for baking.
      */
     static bakePose(skinnedMesh: SkinnedMesh): Mesh;
     /**

package/dist/miscellaneous/SkinnedMeshBaker.js

@@ -3,8 +3,7 @@ import { Vector3, BufferAttribute, Mesh, AnimationMixer } from 'three';
 const COMPONENT_COUNT = 3;
 class SkinnedMeshBaker {
     /**
-     * Does not call `skeleton.update()` internally — skeleton must be up to date before calling.
-     * The returned mesh shares the original material (not cloned).
+     * Does not call the skeleton update, assuming it is already in a state ready for baking.
      */
     static bakePose(skinnedMesh) {
         const bakedGeometry = skinnedMesh.geometry.clone();

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "three-zoo",
-  "version": "0.12.0",
-  "description": "Some reusable bits for building things with Three.js ",
+  "version": "0.13.0",
+  "description": "Some reusable bits for building things with Three.js",
   "keywords": [
     "three.js",
     "typescript",
-    "3d"
+    "3d",
+    "webgl",
+    "ik",
+    "inverse-kinematics",
+    "instanced-mesh",
+    "material",
+    "scene",
+    "lighting"
   ],
   "author": "jango",
   "license": "MIT",