three-zoo 0.11.13 → 0.11.15

package/dist/index.js

@@ -1,4 +1,4 @@
-import { Object3D, Vector3, Quaternion, Matrix4, InstancedMesh, HemisphereLight, RGBAFormat, DirectionalLight, Box3, Spherical, MeshPhysicalMaterial, Color, MeshBasicMaterial, MeshLambertMaterial, MeshPhongMaterial, MeshToonMaterial, PerspectiveCamera, MathUtils, Mesh, BufferAttribute, AnimationMixer } from 'three';
+import { Object3D, Vector3, Quaternion, Matrix4, InstancedMesh, HemisphereLight, RGBAFormat, DirectionalLight, Box3, Spherical, PerspectiveCamera, MeshPhysicalMaterial, Color, MeshBasicMaterial, MeshLambertMaterial, MeshPhongMaterial, MeshToonMaterial, MathUtils, Mesh, BufferAttribute, AnimationMixer } from 'three';
 
 class InstancedMeshGroup extends Object3D {
     constructor(_private_instances) {
@@ -434,6 +434,8 @@ class SkyLight extends HemisphereLight {
     }
 }
 
+/** Radians-per-degree conversion factor */
+const DEG2RAD = Math.PI / 180;
 /** Number of color channels in RGBA format */
 const RGBA_CHANNEL_COUNT = 4;
 /** Number of color channels in RGB format */
@@ -545,6 +547,48 @@ class Sun extends DirectionalLight {
         camera.updateWorldMatrix(true, false);
         camera.updateProjectionMatrix();
     }
+    /**
+     * Configures shadow camera frustum to cover the visible volume of a scene camera.
+     * Supports both perspective (frustum) and orthographic (box) cameras.
+     *
+     * @param sceneCamera - PerspectiveCamera or OrthographicCamera whose visible volume defines the shadow region
+     */
+    configureShadowsForCamera(sceneCamera) {
+        const shadowCamera = this.shadow.camera;
+        this.target.updateWorldMatrix(true, false);
+        this.lookAt(this.target.getWorldPosition(this._private_tempVector3D0));
+        this.updateWorldMatrix(true, false);
+        sceneCamera.updateWorldMatrix(true, false);
+        if (sceneCamera instanceof PerspectiveCamera) {
+            this._private_computeFrustumPoints(sceneCamera);
+        }
+        else {
+            this._private_computeOrthographicPoints(sceneCamera);
+        }
+        const inverseMatrix = this.matrixWorld.clone().invert();
+        const points = [
+            this._private_tempVector3D0,
+            this._private_tempVector3D1,
+            this._private_tempVector3D2,
+            this._private_tempVector3D3,
+            this._private_tempVector3D4,
+            this._private_tempVector3D5,
+            this._private_tempVector3D6,
+            this._private_tempVector3D7,
+        ];
+        for (const point of points) {
+            point.applyMatrix4(inverseMatrix);
+        }
+        const newBox3 = this._private_tempBox3.setFromPoints(points);
+        shadowCamera.left = newBox3.min.x;
+        shadowCamera.bottom = newBox3.min.y;
+        shadowCamera.near = -newBox3.max.z;
+        shadowCamera.right = newBox3.max.x;
+        shadowCamera.top = newBox3.max.y;
+        shadowCamera.far = -newBox3.min.z;
+        shadowCamera.updateWorldMatrix(true, false);
+        shadowCamera.updateProjectionMatrix();
+    }
     /**
      * Sets sun direction, color and intensity based on brightest point in HDR environment map.
      *
@@ -625,6 +669,60 @@ class Sun extends DirectionalLight {
         }
         return { index: maxIndex, luminance: maxLuminance };
     }
+    /**
+     * Computes the 8 frustum corner points of a perspective camera in world space,
+     * storing them in the temporary Vector3 members.
+     *
+     * @param camera - The perspective camera to compute frustum points for
+     */
+    _private_computeFrustumPoints(camera) {
+        const fovRad = camera.fov * DEG2RAD;
+        const halfTanFov = Math.tan(fovRad / 2);
+        const nearHalfH = camera.near * halfTanFov;
+        const nearHalfW = nearHalfH * camera.aspect;
+        const farHalfH = camera.far * halfTanFov;
+        const farHalfW = farHalfH * camera.aspect;
+        this._private_tempVector3D0.set(-nearHalfW, -nearHalfH, -camera.near);
+        this._private_tempVector3D1.set(nearHalfW, -nearHalfH, -camera.near);
+        this._private_tempVector3D2.set(-nearHalfW, nearHalfH, -camera.near);
+        this._private_tempVector3D3.set(nearHalfW, nearHalfH, -camera.near);
+        this._private_tempVector3D4.set(-farHalfW, -farHalfH, -camera.far);
+        this._private_tempVector3D5.set(farHalfW, -farHalfH, -camera.far);
+        this._private_tempVector3D6.set(-farHalfW, farHalfH, -camera.far);
+        this._private_tempVector3D7.set(farHalfW, farHalfH, -camera.far);
+        this._private_tempVector3D0.applyMatrix4(camera.matrixWorld);
+        this._private_tempVector3D1.applyMatrix4(camera.matrixWorld);
+        this._private_tempVector3D2.applyMatrix4(camera.matrixWorld);
+        this._private_tempVector3D3.applyMatrix4(camera.matrixWorld);
+        this._private_tempVector3D4.applyMatrix4(camera.matrixWorld);
+        this._private_tempVector3D5.applyMatrix4(camera.matrixWorld);
+        this._private_tempVector3D6.applyMatrix4(camera.matrixWorld);
+        this._private_tempVector3D7.applyMatrix4(camera.matrixWorld);
+    }
+    /**
+     * Computes the 8 corner points of an orthographic camera's visible box in world space,
+     * storing them in the temporary Vector3 members.
+     *
+     * @param camera - The orthographic camera to compute box points for
+     */
+    _private_computeOrthographicPoints(camera) {
+        this._private_tempVector3D0.set(camera.left, camera.bottom, -camera.near);
+        this._private_tempVector3D1.set(camera.right, camera.bottom, -camera.near);
+        this._private_tempVector3D2.set(camera.left, camera.top, -camera.near);
+        this._private_tempVector3D3.set(camera.right, camera.top, -camera.near);
+        this._private_tempVector3D4.set(camera.left, camera.bottom, -camera.far);
+        this._private_tempVector3D5.set(camera.right, camera.bottom, -camera.far);
+        this._private_tempVector3D6.set(camera.left, camera.top, -camera.far);
+        this._private_tempVector3D7.set(camera.right, camera.top, -camera.far);
+        this._private_tempVector3D0.applyMatrix4(camera.matrixWorld);
+        this._private_tempVector3D1.applyMatrix4(camera.matrixWorld);
+        this._private_tempVector3D2.applyMatrix4(camera.matrixWorld);
+        this._private_tempVector3D3.applyMatrix4(camera.matrixWorld);
+        this._private_tempVector3D4.applyMatrix4(camera.matrixWorld);
+        this._private_tempVector3D5.applyMatrix4(camera.matrixWorld);
+        this._private_tempVector3D6.applyMatrix4(camera.matrixWorld);
+        this._private_tempVector3D7.applyMatrix4(camera.matrixWorld);
+    }
 }
 
 class BasicToPhysicalConverter {
@@ -2089,7 +2187,18 @@ class SceneTraversal {
 
 const TEMP_VECTOR = new Vector3();
 const TEMP_BOX3 = new Box3();
+/**
+ * Static utilities for sorting scene objects.
+ */
 class SceneSorter {
+    /**
+     * Sorts all meshes in the hierarchy by distance to a point,
+     * assigning sequential `renderOrder` values starting from `baseRenderOrder`.
+     *
+     * @param object - Root object to start from
+     * @param point - Reference point to measure distances against
+     * @param baseRenderOrder - Starting render order value
+     */
     static sortByDistanceToPoint(object, point, baseRenderOrder) {
         object.updateWorldMatrix(true, true);
         const meshes = [];