@types/three 0.182.0 → 0.183.1

three/src/helpers/SpotLightHelper.d.ts

@@ -1,77 +1,50 @@
 import { Object3D } from "../core/Object3D.js";
-import { Light } from "../lights/Light.js";
+import { SpotLight } from "../lights/SpotLight.js";
 import { ColorRepresentation } from "../math/Color.js";
-import { Matrix4 } from "../math/Matrix4.js";
 import { LineSegments } from "../objects/LineSegments.js";
 
 /**
- * This displays a cone shaped helper object for a {@link THREE.SpotLight | SpotLight}.
- * @example
- * ```typescript
- * const spotLight = new THREE.SpotLight(0xffffff);
- * spotLight.position.set(10, 10, 10);
- * scene.add(spotLight);
- * const {@link SpotLightHelper} = new THREE.SpotLightHelper(spotLight);
- * scene.add(spotLightHelper);
+ * This displays a cone shaped helper object for a {@link SpotLight}.
+ *
+ * When the spot light or its target are transformed or light properties are
+ * changed, it's necessary to call the `update()` method of the respective helper.
+ *
+ * ```js
+ * const spotLight = new THREE.SpotLight( 0xffffff );
+ * spotLight.position.set( 10, 10, 10 );
+ * scene.add( spotLight );
+ *
+ * const spotLightHelper = new THREE.SpotLightHelper( spotLight );
+ * scene.add( spotLightHelper );
  * ```
- * @see Example: {@link https://threejs.org/examples/#webgl_lights_spotlights | WebGL/ lights / spotlights }
- * @see {@link https://threejs.org/docs/index.html#api/en/helpers/SpotLightHelper | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/helpers/SpotLightHelper.js | Source}
  */
 export class SpotLightHelper extends Object3D {
     /**
-     * Create a new instance of {@link SpotLightHelper}
-     * @param light The {@link THREE.SpotLight | SpotLight} to be visualized.
-     * @param color If this is not the set the helper will take the color of the light. Default `light.color`
+     * Constructs a new spot light helper.
+     *
+     * @param {HemisphereLight} light - The light to be visualized.
+     * @param {number|Color|string} [color] - The helper's color. If not set, the helper will take
+     * the color of the light.
      */
-    constructor(light: Light, color?: ColorRepresentation);
-
-    /**
-     * A Read-only _string_ to check if `this` object type.
-     * @remarks Sub-classes will update this value.
-     * @override
-     * @defaultValue `SpotLightHelper`
-     */
-    override readonly type: string | "SpotLightHelper";
-
-    /**
-     * {@link THREE.LineSegments | LineSegments} used to visualize the light.
-     */
-    cone: LineSegments;
-
-    /**
-     * Reference to the {@link THREE.SpotLight | SpotLight} being visualized.
-     */
-    light: Light;
-
+    constructor(light: SpotLight, color?: ColorRepresentation);
     /**
-     * Reference to the spotLight's {@link Object3D.matrixWorld | matrixWorld}.
+     * The light being visualized.
      */
-    matrix: Matrix4;
-
+    light: SpotLight;
     /**
      * The color parameter passed in the constructor.
-     * If this is changed, the helper's color will update the next time {@link SpotLightHelper.update | update} is called.
-     * @defaultValue `undefined`
+     * If not set, the helper will take the color of the light.
      */
     color: ColorRepresentation | undefined;
-
+    cone: LineSegments;
     /**
-     * Is set to `false`, as the helper is using the {@link THREE.Light.matrixWorld | light.matrixWorld}.
-     * @see {@link THREE.Object3D.matrixAutoUpdate | Object3D.matrixAutoUpdate}.
-     * @defaultValue `false`.
+     * Frees the GPU-related resources allocated by this instance. Call this
+     * method whenever this instance is no longer used in your app.
      */
-    override matrixAutoUpdate: boolean;
-
+    dispose(): void;
     /**
-     * Updates the light helper.
+     * Updates the helper to match the position and direction of the
+     * light being visualized.
      */
     update(): void;
-
-    /**
-     * Frees the GPU-related resources allocated by this instance
-     * @remarks
-     * Call this method whenever this instance is no longer used in your app.
-     */
-    dispose(): void;
 }

three/src/lights/AmbientLight.d.ts

@@ -3,34 +3,26 @@ import { Light } from "./Light.js";
 
 /**
  * This light globally illuminates all objects in the scene equally.
- * @remarks This light cannot be used to cast shadows as it does not have a direction.
- * @example
- * ```typescript
- * const light = new THREE.AmbientLight(0x404040); // soft white light
- * scene.add(light);
+ *
+ * It cannot be used to cast shadows as it does not have a direction.
+ *
+ * ```js
+ * const light = new THREE.AmbientLight( 0x404040 ); // soft white light
+ * scene.add( light );
  * ```
- * @see {@link https://threejs.org/docs/index.html#api/en/lights/AmbientLight | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/AmbientLight.js | Source}
  */
-export class AmbientLight extends Light<undefined> {
+export class AmbientLight extends Light {
     /**
-     * Creates a new {@link AmbientLight}.
-     * @param color Numeric value of the RGB component of the color. Default `0xffffff`
-     * @param intensity Numeric value of the light's strength/intensity. Expects a `Float`. Default `1`
+     * Constructs a new ambient light.
+     *
+     * @param {(number|Color|string)} [color=0xffffff] - The light's color.
+     * @param {number} [intensity=1] - The light's strength/intensity.
      */
     constructor(color?: ColorRepresentation, intensity?: number);
-
-    /**
-     * Read-only flag to check if a given object is of type {@link AmbientLight}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
-     */
-    readonly isAmbientLight: true;
-
     /**
-     * A Read-only _string_ to check if `this` object type.
-     * @remarks Sub-classes will update this value.
-     * @defaultValue `AmbientLight`
+     * This flag can be used for type testing.
+     *
+     * @default true
      */
-    override readonly type: string | "AmbientLight";
+    readonly isAmbientLight: boolean;
 }

three/src/lights/DirectionalLight.d.ts

@@ -1,6 +1,5 @@
 import { JSONMeta, Object3D } from "../core/Object3D.js";
 import { ColorRepresentation } from "../math/Color.js";
-import { Vector3 } from "../math/Vector3.js";
 import { DirectionalLightShadow } from "./DirectionalLightShadow.js";
 import { Light, LightJSON } from "./Light.js";
 import { LightShadowJSON } from "./LightShadow.js";
@@ -11,100 +10,59 @@ export interface DirectionalLightJSON extends LightJSON {
 }
 
 /**
- * A light that gets emitted in a specific direction
- * @remarks
- * This light will behave as though it is infinitely far away and the rays produced from it are all parallel
- * The common use case for this is to simulate daylight; the sun is far enough away that its position can be considered to be infinite, and all light rays coming from it are parallel.
- * A common point of confusion for directional lights is that setting the rotation has no effect
- * This is because three.js's {@link DirectionalLight} is the equivalent to what is often called a 'Target Direct Light' in other applications.
- * This means that its direction is calculated as pointing from the light's {@link THREE.Object3D.position | position} to the {@link THREE.DirectionalLight.target | target}'s
- * position (as opposed to a 'Free Direct Light' that just has a rotation component).
- * See the {@link THREE.DirectionalLight.target | target} property below for details on updating the target.
- * @example
- * ```typescript
+ * A light that gets emitted in a specific direction. This light will behave
+ * as though it is infinitely far away and the rays produced from it are all
+ * parallel. The common use case for this is to simulate daylight; the sun is
+ * far enough away that its position can be considered to be infinite, and
+ * all light rays coming from it are parallel.
+ *
+ * A common point of confusion for directional lights is that setting the
+ * rotation has no effect. This is because three.js's DirectionalLight is the
+ * equivalent to what is often called a 'Target Direct Light' in other
+ * applications.
+ *
+ * This means that its direction is calculated as pointing from the light's
+ * {@link Object3D#position} to the {@link DirectionalLight#target} position
+ * (as opposed to a 'Free Direct Light' that just has a rotation
+ * component).
+ *
+ * This light can cast shadows - see the {@link DirectionalLightShadow} for details.
+ *
+ * ```js
  * // White directional light at half intensity shining from the top.
- * const {@link DirectionalLight} = new THREE.DirectionalLight(0xffffff, 0.5);
- * scene.add(directionalLight);
+ * const directionalLight = new THREE.DirectionalLight( 0xffffff, 0.5 );
+ * scene.add( directionalLight );
  * ```
- * @see Example: {@link https://threejs.org/examples/#misc_controls_fly | controls / fly }
- * @see Example: {@link https://threejs.org/examples/#webgl_effects_parallaxbarrier | effects / parallaxbarrier }
- * @see Example: {@link https://threejs.org/examples/#webgl_effects_stereo | effects / stereo }
- * @see Example: {@link https://threejs.org/examples/#webgl_geometry_extrude_splines | geometry / extrude / splines }
- * @see Example: {@link https://threejs.org/examples/#webgl_materials_bumpmap | materials / bumpmap }
- * @see {@link https://threejs.org/docs/index.html#api/en/lights/DirectionalLight | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/DirectionalLight.js | Source}
  */
-export class DirectionalLight extends Light<DirectionalLightShadow> {
+export class DirectionalLight extends Light {
     /**
-     * Creates a new {@link DirectionalLight}.
-     * @param color Hexadecimal color of the light. Default `0xffffff` _(white)_.
-     * @param intensity Numeric value of the light's strength/intensity. Expects a `Float`. Default `1`
+     * Constructs a new directional light.
+     *
+     * @param {(number|Color|string)} [color=0xffffff] - The light's color.
+     * @param {number} [intensity=1] - The light's strength/intensity.
      */
     constructor(color?: ColorRepresentation, intensity?: number);
-
-    /**
-     * Read-only flag to check if a given object is of type {@link DirectionalLight}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
-     */
-    readonly isDirectionalLight: true;
-
-    /**
-     * A Read-only _string_ to check if `this` object type.
-     * @remarks Sub-classes will update this value.
-     * @defaultValue `DirectionalLight`
-     */
-    override readonly type: string | "DirectionalLight";
-
-    /**
-     * Whether the object gets rendered into shadow map.
-     * @remarks
-     * If set to `true` light will cast dynamic shadows.
-     * **Warning**: This is expensive and requires tweaking to get shadows looking right.
-     * @see {@link THREE.DirectionalLightShadow | DirectionalLightShadow} for details.
-     * @defaultValue `false`
-     */
-    override castShadow: boolean;
-
     /**
-     * This is set equal to {@link THREE.Object3D.DEFAULT_UP}, so that the light shines from the top down.
-     * @defaultValue {@link Object3D.DEFAULT_UP} _(0, 1, 0)_
-     */
-    override readonly position: Vector3;
-
-    /**
-     * A {@link THREE.DirectionalLightShadow | DirectionalLightShadow} used to calculate shadows for this light.
-     * @defaultValue `new THREE.DirectionalLightShadow()`
+     * This flag can be used for type testing.
+     *
+     * @default true
      */
-    shadow: DirectionalLightShadow;
-
+    readonly isDirectionalLight: boolean;
     /**
-     * The {@link DirectionalLight} points from its {@link DirectionalLight.position | position} to target.position.
-     * @remarks **Note**: For the target's position to be changed to anything other than the default,
-     * it must be added to the {@link THREE.Scene | scene} using
-     * ```typescript
-     * Scene.add( light.target );
-     * ```
-     * This is so that the target's {@link THREE.Object3D.matrixWorld | matrixWorld} gets automatically updated each frame.
+     * The directional light points from its position to the
+     * target's position.
+     *
+     * For the target's position to be changed to anything other
+     * than the default, it must be added to the scene.
      *
-     * It is also possible to set the target to be another object in the scene (anything with a {@link THREE.Object3D.position | position} property),
-     * like so:
-     * ```typescript
-     * const targetObject = new THREE.Object3D();
-     * scene.add(targetObject);
-     * light.target = targetObject;
-     * ```
-     * The {@link DirectionalLight} will now track the target object.
-     * @defaultValue `new THREE.Object3D()` at _(0, 0, 0)_
+     * It is also possible to set the target to be another 3D object
+     * in the scene. The light will now track the target object.
      */
     target: Object3D;
-
     /**
-     * Frees the GPU-related resources allocated by this instance
-     * @remarks
-     * Call this method whenever this instance is no longer used in your app.
+     * This property holds the light's shadow configuration.
      */
-    dispose(): void;
-
+    shadow: DirectionalLightShadow;
+    copy(source: DirectionalLight): this;
     toJSON(meta?: JSONMeta): DirectionalLightJSON;
 }

three/src/lights/DirectionalLightShadow.d.ts

@@ -2,72 +2,17 @@ import { OrthographicCamera } from "../cameras/OrthographicCamera.js";
 import { LightShadow } from "./LightShadow.js";
 
 /**
- * This is used internally by {@link DirectionalLight | DirectionalLights} for calculating shadows.
- * Unlike the other shadow classes, this uses an {@link THREE.OrthographicCamera | OrthographicCamera} to calculate the shadows,
- * rather than a {@link THREE.PerspectiveCamera | PerspectiveCamera}
- * @remarks
- * This is because light rays from a {@link THREE.DirectionalLight | DirectionalLight} are parallel.
- * @example
- * ```typescript
- * //Create a WebGLRenderer and turn on shadows in the renderer
- * const renderer = new THREE.WebGLRenderer();
- * renderer.shadowMap.enabled = true;
- * renderer.shadowMap.type = THREE.PCFSoftShadowMap; // default THREE.PCFShadowMap
- * //Create a DirectionalLight and turn on shadows for the light
- * const light = new THREE.DirectionalLight(0xffffff, 1);
- * light.position.set(0, 1, 0); //default; light shining from top
- * light.castShadow = true; // default false
- * scene.add(light);
- * //Set up shadow properties for the light
- * light.shadow.mapSize.width = 512; // default
- * light.shadow.mapSize.height = 512; // default
- * light.shadow.camera.near = 0.5; // default
- * light.shadow.camera.far = 500; // default
- * //Create a sphere that cast shadows (but does not receive them)
- * const sphereGeometry = new THREE.SphereGeometry(5, 32, 32);
- * const sphereMaterial = new THREE.MeshStandardMaterial({
- *     color: 0xff0000
- * });
- * const sphere = new THREE.Mesh(sphereGeometry, sphereMaterial);
- * sphere.castShadow = true; //default is false
- * sphere.receiveShadow = false; //default
- * scene.add(sphere);
- * //Create a plane that receives shadows (but does not cast them)
- * const planeGeometry = new THREE.PlaneGeometry(20, 20, 32, 32);
- * const planeMaterial = new THREE.MeshStandardMaterial({
- *     color: 0x00ff00
- * })
- * const plane = new THREE.Mesh(planeGeometry, planeMaterial);
- * plane.receiveShadow = true;
- * scene.add(plane);
- * //Create a helper for the shadow camera (optional)
- * const helper = new THREE.CameraHelper(light.shadow.camera);
- * scene.add(helper);
- * ```
- * @see {@link https://threejs.org/docs/index.html#api/en/lights/shadows/DirectionalLightShadow | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/DirectionalLightShadow.js | Source}
+ * Represents the shadow configuration of directional lights.
  */
 export class DirectionalLightShadow extends LightShadow<OrthographicCamera> {
     /**
-     * Create a new instance of {@link DirectionalLightShadow}
+     * Constructs a new directional light shadow.
      */
     constructor();
-
-    /**
-     * Read-only flag to check if a given object is of type {@link DirectionalLightShadow}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
-     */
-    readonly isDirectionalLightShadow: true;
-
     /**
-     * The light's view of the world.
-     * @remarks This is used to generate a depth map of the scene; objects behind other objects from the light's perspective will be in shadow.
-     * @defaultValue is an {@link THREE.OrthographicCamera | OrthographicCamera} with
-     * {@link OrthographicCamera.left | left} and {@link OrthographicCamera.bottom | bottom} set to -5,
-     * {@link OrthographicCamera.right | right} and {@link OrthographicCamera.top | top} set to 5,
-     * the {@link OrthographicCamera.near | near} clipping plane at 0.5 and
-     * the {@link OrthographicCamera.far | far} clipping plane at 500.
+     * This flag can be used for type testing.
+     *
+     * @default true
      */
-    camera: OrthographicCamera;
+    readonly isDirectionalLightShadow: boolean;
 }

three/src/lights/HemisphereLight.d.ts

@@ -1,6 +1,5 @@
 import { JSONMeta } from "../core/Object3D.js";
 import { Color, ColorRepresentation } from "../math/Color.js";
-import { Vector3 } from "../math/Vector3.js";
 import { Light, LightJSON } from "./Light.js";
 
 export interface HemisphereLightJSON extends LightJSON {
@@ -8,61 +7,35 @@ export interface HemisphereLightJSON extends LightJSON {
 }
 
 /**
- * A light source positioned directly above the scene, with color fading from the sky color to the ground color.
- * @remarks This light cannot be used to cast shadows.
- * @example
- * ```typescript
- * const light = new THREE.HemisphereLight(0xffffbb, 0x080820, 1);
- * scene.add(light);
+ * A light source positioned directly above the scene, with color fading from
+ * the sky color to the ground color.
+ *
+ * This light cannot be used to cast shadows.
+ *
+ * ```js
+ * const light = new THREE.HemisphereLight( 0xffffbb, 0x080820, 1 );
+ * scene.add( light );
  * ```
- * @see Example: {@link https://threejs.org/examples/#webgl_animation_skinning_blending | animation / skinning / blending }
- * @see Example: {@link https://threejs.org/examples/#webgl_lights_hemisphere | lights / hemisphere }
- * @see Example: {@link https://threejs.org/examples/#misc_controls_pointerlock | controls / pointerlock }
- * @see Example: {@link https://threejs.org/examples/#webgl_loader_collada_kinematics | loader / collada / kinematics }
- * @see Example: {@link https://threejs.org/examples/#webgl_loader_stl | loader / stl }
- * @see {@link https://threejs.org/docs/index.html#api/en/lights/HemisphereLight | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/HemisphereLight.js | Source}
  */
-export class HemisphereLight extends Light<undefined> {
+export class HemisphereLight extends Light {
     /**
-     * Creates a new {@link HemisphereLight}.
-     * @param skyColor Hexadecimal color of the sky. Expects a `Integer`. Default `0xffffff` _(white)_.
-     * @param groundColor Hexadecimal color of the ground. Expects a `Integer`. Default `0xffffff` _(white)_.
-     * @param intensity Numeric value of the light's strength/intensity. Expects a `Float`. Default `1`.
+     * Constructs a new hemisphere light.
+     *
+     * @param {(number|Color|string)} [skyColor=0xffffff] - The light's sky color.
+     * @param {(number|Color|string)} [groundColor=0xffffff] - The light's ground color.
+     * @param {number} [intensity=1] - The light's strength/intensity.
      */
     constructor(skyColor?: ColorRepresentation, groundColor?: ColorRepresentation, intensity?: number);
-
-    /**
-     * Read-only flag to check if a given object is of type {@link HemisphereLight}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
-     */
-    readonly isHemisphereLight: true;
-
-    /**
-     * A Read-only _string_ to check if `this` object type.
-     * @remarks Sub-classes will update this value.
-     * @defaultValue `HemisphereLight`
-     */
-    override readonly type: string | "HemisphereLight";
-
-    /**
-     * This is set equal to {@link THREE.Object3D.DEFAULT_UP}, so that the light shines from the top down.
-     * @defaultValue {@link Object3D.DEFAULT_UP} _(0, 1, 0)_
-     */
-    override readonly position: Vector3;
-
     /**
-     * The light's sky color, as passed in the constructor.
-     * @defaultValue `new THREE.Color()` set to white _(0xffffff)_.
+     * This flag can be used for type testing.
+     *
+     * @default true
      */
-    override color: Color;
-
+    readonly isHemisphereLight: boolean;
     /**
-     * The light's ground color, as passed in the constructor.
-     * @defaultValue `new THREE.Color()` set to white _(0xffffff)_.
+     * The light's ground color.
      */
     groundColor: Color;
-
+    copy(source: HemisphereLight, recursive?: boolean): this;
     toJSON(meta?: JSONMeta): HemisphereLightJSON;
 }

three/src/lights/Light.d.ts

@@ -1,6 +1,5 @@
 import { JSONMeta, Object3D, Object3DEventMap, Object3DJSON } from "../core/Object3D.js";
 import { Color, ColorRepresentation } from "../math/Color.js";
-import { LightShadow } from "./LightShadow.js";
 
 export interface LightJSON extends Object3DJSON {
     color: number;
@@ -12,67 +11,38 @@ export interface LightEventMap extends Object3DEventMap {
 }
 
 /**
- * Abstract base class for lights.
- * @remarks All other light types inherit the properties and methods described here.
+ * Abstract base class for lights - all other light types inherit the
+ * properties and methods described here.
  */
-export abstract class Light<TShadowSupport extends LightShadow | undefined = LightShadow | undefined>
-    extends Object3D<LightEventMap>
-{
+export abstract class Light extends Object3D<LightEventMap> {
     /**
-     * Creates a new {@link Light}
-     * @remarks
-     * **Note** that this is not intended to be called directly (use one of derived classes instead).
-     * @param color Hexadecimal color of the light. Default `0xffffff` _(white)_.
-     * @param intensity Numeric value of the light's strength/intensity. Expects a `Float`. Default `1`.
+     * Constructs a new light.
+     *
+     * @param {(number|Color|string)} [color=0xffffff] - The light's color.
+     * @param {number} [intensity=1] - The light's strength/intensity.
      */
     constructor(color?: ColorRepresentation, intensity?: number);
-
     /**
-     * Read-only flag to check if a given object is of type {@link HemisphereLight}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
+     * This flag can be used for type testing.
+     *
+     * @default true
      */
-    readonly isLight: true;
-
+    readonly isLight: boolean;
     /**
-     * A Read-only _string_ to check if `this` object type.
-     * @remarks Sub-classes will update this value.
-     * @defaultValue `Light`
-     */
-    override readonly type: string | "Light";
-
-    /**
-     * Color of the light. \
-     * @defaultValue `new THREE.Color(0xffffff)` _(white)_.
+     * The light's color.
      */
     color: Color;
-
     /**
-     * The light's intensity, or strength.
-     * The units of intensity depend on the type of light.
-     * @defaultValue `1`
+     * The light's intensity.
+     *
+     * @default 1
      */
     intensity: number;
-
     /**
-     * A {@link THREE.LightShadow | LightShadow} used to calculate shadows for this light.
-     * @remarks Available only on Light's that support shadows.
-     */
-    shadow: TShadowSupport;
-
-    /**
-     * Copies value of all the properties from the {@link Light | source} to this instance.
-     * @param source
-     * @param recursive
-     */
-    copy(source: this, recursive?: boolean): this;
-
-    /**
-     * Frees the GPU-related resources allocated by this instance
-     * @remarks
-     * Call this method whenever this instance is no longer used in your app.
+     * Frees the GPU-related resources allocated by this instance. Call this
+     * method whenever this instance is no longer used in your app.
      */
     dispose(): void;
-
+    copy(source: Light, recursive?: boolean): this;
     toJSON(meta?: JSONMeta): LightJSON;
 }

three/src/lights/LightProbe.d.ts

@@ -7,45 +7,40 @@ export interface LightProbeJSON extends LightJSON {
 }
 
 /**
- * Light probes are an alternative way of adding light to a 3D scene.
- * @remarks
- * Unlike classical light sources (e.g
- * directional, point or spot lights), light probes do not emit light
- * Instead they store information about light passing through 3D space
- * During rendering, the light that hits a 3D object is approximated by using the data from the light probe.
- * Light probes are usually created from (radiance) environment maps
- * The class {@link THREE.LightProbeGenerator | LightProbeGenerator} can be used to create light probes from
- * instances of {@link THREE.CubeTexture | CubeTexture} or {@link THREE.WebGLCubeRenderTarget | WebGLCubeRenderTarget}
- * However, light estimation data could also be provided in other forms e.g
- * by WebXR
- * This enables the rendering of augmented reality content that reacts to real world lighting.
- * The current probe implementation in three.js supports so-called diffuse light probes
- * This type of light probe is functionally equivalent to an irradiance environment map.
- * @see Example: {@link https://threejs.org/examples/#webgl_lightprobe | WebGL / light probe }
- * @see Example: {@link https://threejs.org/examples/#webgl_lightprobe_cubecamera | WebGL / light probe / cube camera }
- * @see {@link https://threejs.org/docs/index.html#api/en/lights/LightProbe | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/LightProbe.js | Source}
+ * Light probes are an alternative way of adding light to a 3D scene. Unlike
+ * classical light sources (e.g. directional, point or spot lights), light
+ * probes do not emit light. Instead they store information about light
+ * passing through 3D space. During rendering, the light that hits a 3D
+ * object is approximated by using the data from the light probe.
+ *
+ * Light probes are usually created from (radiance) environment maps. The
+ * class {@link LightProbeGenerator} can be used to create light probes from
+ * cube textures or render targets. However, light estimation data could also
+ * be provided in other forms e.g. by WebXR. This enables the rendering of
+ * augmented reality content that reacts to real world lighting.
+ *
+ * The current probe implementation in three.js supports so-called diffuse
+ * light probes. This type of light probe is functionally equivalent to an
+ * irradiance environment map.
  */
 export class LightProbe extends Light {
     /**
-     * Creates a new LightProbe.
-     * @param sh An instance of {@link THREE.SphericalHarmonics3 | SphericalHarmonics3}. Default `new THREE.SphericalHarmonics3()``.
-     * @param intensity Numeric value of the light probe's intensity. Expects a `Float`. Default `1`.
+     * Constructs a new light probe.
+     *
+     * @param {SphericalHarmonics3} sh - The spherical harmonics which represents encoded lighting information.
+     * @param {number} [intensity=1] - The light's strength/intensity.
      */
     constructor(sh?: SphericalHarmonics3, intensity?: number);
-
     /**
-     * Read-only flag to check if a given object is of type {@link DirectionalLight}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
+     * This flag can be used for type testing.
+     *
+     * @default true
      */
-    readonly isLightProbe: true;
-
+    readonly isLightProbe: boolean;
     /**
      * A light probe uses spherical harmonics to encode lighting information.
-     * @defaultValue `new THREE.SphericalHarmonics3()`
      */
     sh: SphericalHarmonics3;
-
+    copy(source: LightProbe): this;
     toJSON(meta?: JSONMeta): LightProbeJSON;
 }