three-zoo 0.11.15 → 0.11.17

package/dist/index.d.ts

@@ -13,3 +13,4 @@ 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

@@ -2198,8 +2198,9 @@ class SceneSorter {
      * @param object - Root object to start from
      * @param point - Reference point to measure distances against
      * @param baseRenderOrder - Starting render order value
+     * @param reverseOrder - Back-to-front order: closer objects get higher renderOrder (for transparent meshes)
      */
-    static sortByDistanceToPoint(object, point, baseRenderOrder) {
+    static sortByDistanceToPoint(object, point, baseRenderOrder, reverseOrder = false) {
         object.updateWorldMatrix(true, true);
         const meshes = [];
         SceneTraversal.enumerateObjectsByType(object, Mesh, (mesh) => meshes.push(mesh));
@@ -2213,7 +2214,7 @@ class SceneSorter {
             const distanceB = TEMP_BOX3.setFromObject(b)
                 .getCenter(TEMP_VECTOR)
                 .distanceToSquared(point);
-            return distanceA - distanceB;
+            return reverseOrder ? distanceB - distanceA : distanceA - distanceB;
         });
         for (let i = 0; i < meshes.length; i++) {
             meshes[i].renderOrder = baseRenderOrder + i;
@@ -2271,5 +2272,130 @@ class SkinnedMeshBaker {
     }
 }
 
-export { BasicToPhysicalConverter, DualFovCamera, InstancedMeshGroup, InstancedMeshInstance, InstancedMeshPool, SceneSorter, SceneTraversal, SkinnedMeshBaker, SkyLight, StandardToBasicConverter, StandardToLambertConverter, StandardToPhongConverter, StandardToPhysicalConverter, StandardToToonConverter, Sun };
+/**
+ * Analytical two-bone IK solver operating in world space.
+ *
+ * Solves a three-bone chain (root → middle → end) so that the end bone
+ * reaches the target position, with the pole controlling middle-joint
+ * bend direction.
+ *
+ * Writes local quaternions to `root` and `middle` bones.
+ * Does not modify the `end` bone.
+ *
+ * Call `solve()` after AnimationMixer update each frame.
+ */
+class TwoBoneIK {
+    constructor(
+    /** First bone in the chain (e.g. upper leg, upper arm). */
+    root, 
+    /** Second bone in the chain (e.g. lower leg, forearm). */
+    middle, 
+    /** Terminal bone (e.g. foot, hand). Not rotated by the solver. */
+    end, 
+    /** Controls the bend direction of the middle joint. */
+    pole, 
+    /** Solve target. When undefined, `solve()` is a no-op. */
+    target) {
+        this.root = root;
+        this.middle = middle;
+        this.end = end;
+        this.pole = pole;
+        this.target = target;
+        /** Numerical stability threshold. */
+        this.epsilon = 1e-5;
+        this._private_rootPosition = new Vector3();
+        this._private_middlePosition = new Vector3();
+        this._private_endPosition = new Vector3();
+        this._private_targetPosition = new Vector3();
+        this._private_polePosition = new Vector3();
+        this._private_chainDirection = new Vector3();
+        this._private_perpendicularDirection = new Vector3();
+        this._private_middleTarget = new Vector3();
+        this._private_currentDirection = new Vector3();
+        this._private_desiredDirection = new Vector3();
+        this._private_bonePosition = new Vector3();
+        this._private_childPosition = new Vector3();
+        this._private_deltaRotation = new Quaternion();
+        this._private_boneWorldQuaternion = new Quaternion();
+        this._private_parentWorldQuaternion = new Quaternion();
+    }
+    /**
+     * Solve IK for the current frame.
+     * No-op when `target` is undefined.
+     */
+    solve() {
+        if (!this.target) {
+            return;
+        }
+        const epsilon = this.epsilon;
+        this.target.getWorldPosition(this._private_targetPosition);
+        this.pole.getWorldPosition(this._private_polePosition);
+        this.root.getWorldPosition(this._private_rootPosition);
+        this.middle.getWorldPosition(this._private_middlePosition);
+        this.end.getWorldPosition(this._private_endPosition);
+        const upperLength = this._private_rootPosition.distanceTo(this._private_middlePosition);
+        const lowerLength = this._private_middlePosition.distanceTo(this._private_endPosition);
+        const chainLength = upperLength + lowerLength;
+        this._private_chainDirection.subVectors(this._private_targetPosition, this._private_rootPosition);
+        const targetDistance = MathUtils.clamp(this._private_chainDirection.length(), Math.abs(upperLength - lowerLength) + epsilon, chainLength - epsilon);
+        this._private_chainDirection.normalize();
+        // Law of cosines: angle at root joint
+        const cosineRoot = (upperLength * upperLength +
+            targetDistance * targetDistance -
+            lowerLength * lowerLength) /
+            (2 * upperLength * targetDistance);
+        const angleRoot = Math.acos(MathUtils.clamp(cosineRoot, -1, 1));
+        const middleAlongChain = upperLength * Math.cos(angleRoot);
+        const middlePerpendicular = upperLength * Math.sin(angleRoot);
+        // Project pole onto plane perpendicular to chain
+        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 (this._private_perpendicularDirection.lengthSq() < epsilon) {
+            this._private_perpendicularDirection.set(0, 1, 0);
+            this._private_perpendicularDirection.addScaledVector(this._private_chainDirection, -this._private_perpendicularDirection.dot(this._private_chainDirection));
+            if (this._private_perpendicularDirection.lengthSq() < epsilon) {
+                this._private_perpendicularDirection.set(1, 0, 0);
+            }
+        }
+        this._private_perpendicularDirection.normalize();
+        // Ideal middle-joint world position
+        this._private_middleTarget.copy(this._private_rootPosition)
+            .addScaledVector(this._private_chainDirection, middleAlongChain)
+            .addScaledVector(this._private_perpendicularDirection, middlePerpendicular);
+        // Aim root bone → middle target
+        this._private_aimBone(this.root, this.middle, this._private_middleTarget);
+        // Aim middle bone → end target
+        this._private_aimBone(this.middle, this.end, this._private_targetPosition);
+    }
+    /**
+     * Rotate `bone` so that `child` points toward `worldTarget`.
+     * Writes `bone.quaternion` in local space.
+     */
+    _private_aimBone(bone, child, worldTarget) {
+        bone.getWorldPosition(this._private_bonePosition);
+        child.getWorldPosition(this._private_childPosition);
+        this._private_currentDirection.subVectors(this._private_childPosition, this._private_bonePosition);
+        this._private_desiredDirection.subVectors(worldTarget, this._private_bonePosition);
+        if (this._private_currentDirection.lengthSq() < this.epsilon ||
+            this._private_desiredDirection.lengthSq() < this.epsilon) {
+            return;
+        }
+        this._private_currentDirection.normalize();
+        this._private_desiredDirection.normalize();
+        this._private_deltaRotation.setFromUnitVectors(this._private_currentDirection, this._private_desiredDirection);
+        bone.getWorldQuaternion(this._private_boneWorldQuaternion);
+        this._private_deltaRotation.multiply(this._private_boneWorldQuaternion);
+        if (bone.parent) {
+            bone.parent.getWorldQuaternion(this._private_parentWorldQuaternion);
+            bone.quaternion.copy(this._private_parentWorldQuaternion.invert().multiply(this._private_deltaRotation));
+        }
+        else {
+            bone.quaternion.copy(this._private_deltaRotation);
+        }
+    }
+}
+
+export { BasicToPhysicalConverter, DualFovCamera, InstancedMeshGroup, InstancedMeshInstance, InstancedMeshPool, SceneSorter, SceneTraversal, SkinnedMeshBaker, SkyLight, StandardToBasicConverter, StandardToLambertConverter, StandardToPhongConverter, StandardToPhysicalConverter, StandardToToonConverter, Sun, TwoBoneIK };
 //# sourceMappingURL=index.js.map