three-zoo 0.9.2 → 0.9.4

package/dist/Sky.d.ts

@@ -0,0 +1,36 @@
+import type { Texture } from "three";
+import { HemisphereLight } from "three";
+/**
+ * Configuration options for HDR color extraction.
+ */
+export interface SkyOptions {
+    /** Number of brightest pixels to average for sky color (default: 100) */
+    skySampleCount?: number;
+    /** Number of pixels to average for ground color (default: 100) */
+    groundSampleCount?: number;
+    /** Apply gamma correction to extracted colors (default: true) */
+    applyGamma?: boolean;
+    /** Gamma value for correction (default: 2.2) */
+    gamma?: number;
+}
+/**
+ * Hemisphere light with HDR environment map support for automatic sky/ground color extraction.
+ */
+export declare class Sky extends HemisphereLight {
+    /**
+     * Sets sky and ground colors from an HDR texture.
+     * Analyzes upper hemisphere for sky color and lower hemisphere for ground color.
+     *
+     * @param texture - HDR texture to analyze (must have image data)
+     * @param options - Configuration options for color extraction
+     */
+    setColorsFromHDRTexture(texture: Texture, options?: SkyOptions): void;
+    /**
+     * Inserts pixel into sorted array, maintaining size limit.
+     */
+    private insertSorted;
+    /**
+     * Calculates average color from pixel array.
+     */
+    private averagePixels;
+}

package/dist/Sun.d.ts

@@ -39,6 +39,14 @@ export declare class Sun extends DirectionalLight {
      * @param value - New azimuth angle in radians (theta angle)
      */
     set azimuth(value: number);
+    /**
+     * Sets spherical position of the sun.
+     *
+     * @param elevation - Elevation angle in radians (phi angle)
+     * @param azimuth - Azimuth angle in radians (theta angle)
+     * @param distance - Distance from origin in world units
+     */
+    setPosition(elevation: number, azimuth: number, distance?: number): void;
     /**
      * Configures shadow camera frustum to cover bounding box.
      *

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { DualFovCamera } from "./DualFovCamera";
 export { SceneTraversal } from "./SceneTraversal";
 export { SkinnedMeshBaker } from "./SkinnedMeshBaker";
+export { Sky } from "./Sky";
 export { StandardToBasicConverter } from "./StandardToBasicConverter";
 export { StandardToLambertConverter } from "./StandardToLambertConverter";
 export { StandardToPhongConverter } from "./StandardToPhongConverter";

package/dist/index.js

@@ -1,4 +1,4 @@
-import { PerspectiveCamera, MathUtils, Vector3, Mesh, BufferAttribute, AnimationMixer, MeshBasicMaterial, MeshLambertMaterial, MeshPhongMaterial, Color, MeshPhysicalMaterial, MeshToonMaterial, DirectionalLight, Box3, Spherical, RGBAFormat } from 'three';
+import { PerspectiveCamera, MathUtils, Vector3, Mesh, BufferAttribute, AnimationMixer, HemisphereLight, RGBAFormat, MeshBasicMaterial, MeshLambertMaterial, MeshPhongMaterial, Color, MeshPhysicalMaterial, MeshToonMaterial, DirectionalLight, Box3, Spherical } from 'three';
 
 /** Default horizontal field of view in degrees */
 const DEFAULT_HORIZONTAL_FOV = 90;
@@ -552,6 +552,121 @@ class SkinnedMeshBaker {
     }
 }
 
+/** Number of color channels in RGBA format */
+const RGBA_CHANNEL_COUNT$1 = 4;
+/** Number of color channels in RGB format */
+const RGB_CHANNEL_COUNT$1 = 3;
+/** Red channel weight for luminance calculation (ITU-R BT.709) */
+const LUMINANCE_R$1 = 0.2126;
+/** Green channel weight for luminance calculation (ITU-R BT.709) */
+const LUMINANCE_G$1 = 0.7152;
+/** Blue channel weight for luminance calculation (ITU-R BT.709) */
+const LUMINANCE_B$1 = 0.0722;
+/** Threshold for upper hemisphere sampling (0 = equator, 1 = top) */
+const SKY_SAMPLE_THRESHOLD = 0.25;
+/** Threshold for lower hemisphere sampling (0 = equator, 1 = bottom) */
+const GROUND_SAMPLE_THRESHOLD = 0.75;
+/**
+ * Hemisphere light with HDR environment map support for automatic sky/ground color extraction.
+ */
+class Sky extends HemisphereLight {
+    /**
+     * Sets sky and ground colors from an HDR texture.
+     * Analyzes upper hemisphere for sky color and lower hemisphere for ground color.
+     *
+     * @param texture - HDR texture to analyze (must have image data)
+     * @param options - Configuration options for color extraction
+     */
+    setColorsFromHDRTexture(texture, options = {}) {
+        const { skySampleCount = 100, groundSampleCount = 100, applyGamma = true, gamma = 2.2, } = options;
+        const data = texture.image.data;
+        const width = texture.image.width;
+        const height = texture.image.height;
+        const step = texture.format === RGBAFormat ? RGBA_CHANNEL_COUNT$1 : RGB_CHANNEL_COUNT$1;
+        const skyPixels = [];
+        const groundPixels = [];
+        // Sample pixels from upper and lower hemispheres
+        for (let i = 0; i < data.length; i += step) {
+            const pixelIndex = i / step;
+            const y = Math.floor(pixelIndex / width);
+            const v = y / height;
+            const r = data[i];
+            const g = data[i + 1];
+            const b = data[i + 2];
+            const luminance = LUMINANCE_R$1 * r + LUMINANCE_G$1 * g + LUMINANCE_B$1 * b;
+            const pixel = { r, g, b, lum: luminance };
+            // Upper hemisphere (sky)
+            if (v < SKY_SAMPLE_THRESHOLD) {
+                this._private_insertSorted(skyPixels, pixel, skySampleCount, true);
+            }
+            // Lower hemisphere (ground)
+            else if (v > GROUND_SAMPLE_THRESHOLD) {
+                this._private_insertSorted(groundPixels, pixel, groundSampleCount, false);
+            }
+        }
+        // Calculate average sky color from brightest samples
+        const skyColor = this._private_averagePixels(skyPixels);
+        // Calculate average ground color
+        const groundColor = this._private_averagePixels(groundPixels);
+        // Apply gamma correction if needed
+        if (applyGamma) {
+            const invGamma = 1 / gamma;
+            skyColor.r = Math.pow(skyColor.r, invGamma);
+            skyColor.g = Math.pow(skyColor.g, invGamma);
+            skyColor.b = Math.pow(skyColor.b, invGamma);
+            groundColor.r = Math.pow(groundColor.r, invGamma);
+            groundColor.g = Math.pow(groundColor.g, invGamma);
+            groundColor.b = Math.pow(groundColor.b, invGamma);
+        }
+        // Normalize HDR values to [0, 1] range
+        const maxSky = Math.max(skyColor.r, skyColor.g, skyColor.b, 1);
+        const maxGround = Math.max(groundColor.r, groundColor.g, groundColor.b, 1);
+        this.color.setRGB(skyColor.r / maxSky, skyColor.g / maxSky, skyColor.b / maxSky);
+        this.groundColor.setRGB(groundColor.r / maxGround, groundColor.g / maxGround, groundColor.b / maxGround);
+    }
+    /**
+     * Inserts pixel into sorted array, maintaining size limit.
+     */
+    _private_insertSorted(array, pixel, maxSize, sortDescending) {
+        if (array.length < maxSize) {
+            array.push(pixel);
+            array.sort((a, b) => (sortDescending ? b.lum - a.lum : a.lum - b.lum));
+        }
+        else {
+            const threshold = array[array.length - 1].lum;
+            const shouldInsert = sortDescending
+                ? pixel.lum > threshold
+                : pixel.lum < threshold;
+            if (shouldInsert) {
+                array.pop();
+                array.push(pixel);
+                array.sort((a, b) => (sortDescending ? b.lum - a.lum : a.lum - b.lum));
+            }
+        }
+    }
+    /**
+     * Calculates average color from pixel array.
+     */
+    _private_averagePixels(pixels) {
+        if (pixels.length === 0) {
+            return { r: 0.5, g: 0.5, b: 0.5 };
+        }
+        let totalR = 0;
+        let totalG = 0;
+        let totalB = 0;
+        for (const pixel of pixels) {
+            totalR += pixel.r;
+            totalG += pixel.g;
+            totalB += pixel.b;
+        }
+        return {
+            r: totalR / pixels.length,
+            g: totalG / pixels.length,
+            b: totalB / pixels.length,
+        };
+    }
+}
+
 /** Factor for metalness brightness adjustment */
 const METALNESS_BRIGHTNESS_FACTOR = 0.3;
 /** Factor for emissive color contribution when combining with base color */
@@ -1428,6 +1543,16 @@ class Sun extends DirectionalLight {
         this._private_tempSpherical.setFromVector3(this.position);
         this.position.setFromSphericalCoords(this._private_tempSpherical.radius, this._private_tempSpherical.phi, value);
     }
+    /**
+     * Sets spherical position of the sun.
+     *
+     * @param elevation - Elevation angle in radians (phi angle)
+     * @param azimuth - Azimuth angle in radians (theta angle)
+     * @param distance - Distance from origin in world units
+     */
+    setPosition(elevation, azimuth, distance = 1) {
+        this.position.setFromSphericalCoords(distance, elevation, azimuth);
+    }
     /**
      * Configures shadow camera frustum to cover bounding box.
      *
@@ -1498,5 +1623,5 @@ class Sun extends DirectionalLight {
     }
 }
 
-export { DualFovCamera, SceneTraversal, SkinnedMeshBaker, StandardToBasicConverter, StandardToLambertConverter, StandardToPhongConverter, StandardToPhysicalConverter, StandardToToonConverter, Sun };
+export { DualFovCamera, SceneTraversal, SkinnedMeshBaker, Sky, StandardToBasicConverter, StandardToLambertConverter, StandardToPhongConverter, StandardToPhysicalConverter, StandardToToonConverter, Sun };
 //# sourceMappingURL=index.js.map