three-zoo 0.5.4 → 0.5.6

package/dist/StandardToLambertConverter.d.ts

@@ -1,64 +1,40 @@
 import type { MeshStandardMaterial } from "three";
 import { MeshLambertMaterial } from "three";
 /**
- * Configuration options for the StandardToLambertConverter
- *
- * @interface StandardToLambertConverterOptions
+ * Configuration options for material conversion.
  */
 export interface StandardToLambertConverterOptions {
     /**
-     * Whether to preserve the original material's name
+     * Preserve original material name.
      * @defaultValue true
      */
     preserveName: boolean;
     /**
-     * Whether to copy user data from the original material
+     * Copy user data from original material.
      * @defaultValue true
      */
     copyUserData: boolean;
     /**
-     * Whether to dispose the original material after conversion
+     * Dispose original material after conversion.
      * @defaultValue false
      */
     disposeOriginal: boolean;
     /**
-     * Custom color adjustment factor for roughness compensation
+     * Color adjustment factor for roughness compensation.
      * @defaultValue 0.8
      */
     roughnessColorFactor: number;
 }
 /**
- * Converts Three.js MeshStandardMaterial to MeshLambertMaterial
- *
- * This converter handles the translation between PBR (Physically Based Rendering)
- * properties of StandardMaterial and the simpler Lambertian reflectance model
- * used by LambertMaterial. The conversion preserves visual similarity by applying
- * color compensation based on metalness and roughness values.
+ * Converts MeshStandardMaterial to MeshLambertMaterial with PBR compensation.
  */
 export declare class StandardToLambertConverter {
     /**
-     * Converts a MeshStandardMaterial to MeshLambertMaterial
+     * Converts MeshStandardMaterial to MeshLambertMaterial.
      *
-     * This method performs a comprehensive conversion from PBR StandardMaterial to
-     * the simpler Lambert lighting model while attempting to preserve visual similarity
-     * through intelligent color compensation.
-     *
-     * @param material - The source MeshStandardMaterial to convert
-     * @param options - Configuration options for the conversion
-     * @returns A new MeshLambertMaterial with properties mapped from the standard material
-     *
-     * @example
-     * ```typescript
-     * const standardMaterial = new MeshStandardMaterial({
-     *   color: 0xff0000,
-     *   metalness: 0.8,
-     *   roughness: 0.2
-     * });
-     *
-     * const lambertMaterial = StandardToLambertConverter.convert(standardMaterial);
-     * ```
-     *
-     * @see {@link StandardToLambertConverterOptions} for available configuration options
+     * @param material - Source material to convert
+     * @param options - Conversion options
+     * @returns New MeshLambertMaterial with mapped properties
      */
     static convert(material: MeshStandardMaterial, options?: Partial<StandardToLambertConverterOptions>): MeshLambertMaterial;
 }

package/dist/Sun.d.ts

@@ -1,11 +1,7 @@
 import type { Texture } from "three";
 import { Box3, DirectionalLight } from "three";
 /**
- * A directional light with spherical positioning controls and advanced shadow mapping.
- *
- * Extends Three.js DirectionalLight to provide intuitive spherical coordinate control
- * (distance, elevation, azimuth) and automatic shadow map configuration for bounding boxes.
- * Also supports automatic sun direction calculation from HDR environment maps.
+ * Directional light with spherical positioning and HDR environment support.
  */
 export declare class Sun extends DirectionalLight {
     /** Internal vectors to avoid garbage collection during calculations */
@@ -20,60 +16,40 @@ export declare class Sun extends DirectionalLight {
     private readonly tempBox3;
     private readonly tempSpherical;
     /**
-     * Gets the distance from the light to its target (origin).
-     *
-     * @returns The distance in world units
+     * @returns Distance from light position to origin
      */
     get distance(): number;
     /**
-     * Gets the elevation angle (vertical angle from the horizontal plane).
-     *
-     * @returns The elevation angle in radians (0 = horizontal, π/2 = directly above)
+     * @returns Elevation angle in radians (phi angle)
      */
     get elevation(): number;
     /**
-     * Gets the azimuth angle (horizontal rotation around the target).
-     *
-     * @returns The azimuth angle in radians (0 = positive X axis, π/2 = positive Z axis)
+     * @returns Azimuth angle in radians (theta angle)
      */
     get azimuth(): number;
     /**
-     * Sets the distance while preserving current elevation and azimuth angles.
-     *
-     * @param value - The new distance in world units
+     * @param value - New distance in world units
      */
     set distance(value: number);
     /**
-     * Sets the elevation angle while preserving current distance and azimuth.
-     *
-     * @param value - The new elevation angle in radians (0 = horizontal, π/2 = directly above)
+     * @param value - New elevation angle in radians (phi angle)
      */
     set elevation(value: number);
     /**
-     * Sets the azimuth angle while preserving current distance and elevation.
-     *
-     * @param value - The new azimuth angle in radians (0 = positive X axis, π/2 = positive Z axis)
+     * @param value - New azimuth angle in radians (theta angle)
      */
     set azimuth(value: number);
     /**
-     * Configures the shadow camera to optimally cover a bounding box.
+     * Configures shadow camera frustum to cover bounding box.
      *
-     * This method automatically adjusts the directional light's shadow camera frustum
-     * to perfectly encompass the provided bounding box, ensuring efficient shadow map
-     * usage and eliminating shadow clipping issues.
-     *
-     * @param box3 - The 3D bounding box to cover with shadows
+     * @param box3 - 3D bounding box to cover with shadows
      */
     configureShadowsForBoundingBox(box3: Box3): void;
     /**
-     * Sets the sun's direction based on the brightest point in an HDR environment map.
-     *
-     * This method analyzes an HDR texture to find the pixel with the highest luminance
-     * value and positions the sun to shine from that direction. This is useful for
-     * creating realistic lighting that matches HDR environment maps.
+     * Sets sun direction based on brightest point in HDR environment map.
      *
-     * @param texture - The HDR texture to analyze (must have image data available)
-     * @param distance - The distance to place the sun from the origin (defaults to 1)
+     * @param texture - HDR texture to analyze (must have image data)
+     * @param distance - Distance to place sun from origin
      */
     setDirectionFromHDRTexture(texture: Texture, distance?: number): void;
 }