@types/three 0.150.0 → 0.150.2

three/src/objects/InstancedMesh.d.ts

@@ -5,21 +5,140 @@ import { InstancedBufferAttribute } from '../core/InstancedBufferAttribute';
 import { Mesh } from './Mesh';
 import { Matrix4 } from './../math/Matrix4';
 import { Color } from './../math/Color';
+import { Box3, Sphere } from '../Three';
 
+/**
+ * A special version of {@link THREE.Mesh | Mesh} with instanced rendering support
+ * @remarks
+ * Use {@link InstancedMesh} if you have to render a large number of objects with the same geometry and material but with different world transformations
+ * @remarks
+ * The usage of {@link InstancedMesh} will help you to reduce the number of draw calls and thus improve the overall rendering performance in your application.
+ * @see Example: {@link https://threejs.org/examples/#webgl_instancing_dynamic | WebGL / instancing / dynamic}
+ * @see Example: {@link https://threejs.org/examples/#webgl_instancing_performance | WebGL / instancing / performance}
+ * @see Example: {@link https://threejs.org/examples/#webgl_instancing_scatter | WebGL / instancing / scatter}
+ * @see Example: {@link https://threejs.org/examples/#webgl_instancing_raycast | WebGL / instancing / raycast}
+ * @see {@link https://threejs.org/docs/index.html#api/en/objects/InstancedMesh | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/InstancedMesh.js | Source}
+ */
 export class InstancedMesh<
     TGeometry extends BufferGeometry = BufferGeometry,
     TMaterial extends Material | Material[] = Material | Material[],
 > extends Mesh<TGeometry, TMaterial> {
+    /**
+     * Create a new instance of {@link InstancedMesh}
+     * @param geometry An instance of {@link THREE.BufferGeometry | BufferGeometry}.
+     * @param material A single or an array of {@link THREE.Material | Material}. Default {@link THREE.MeshBasicMaterial | `new THREE.MeshBasicMaterial()`}.
+     * @param count The **maximum** number of instances of this Mesh. Expects a `Integer`
+     */
     constructor(geometry: TGeometry | undefined, material: TMaterial | undefined, count: number);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link InstancedMesh}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isInstancedMesh: true;
+
+    /////////////////////////////////////////////////
+    // FUTURE - r151
+    /////////////////////////////////////////////////
+    // /**
+    //  * This bounding box encloses all instances of the {@link InstancedMesh},, which can be calculated with {@link computeBoundingBox | .computeBoundingBox()}.
+    //  * @remarks Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+    //  * @defaultValue `null`
+    //  */
+    // boundingBox: Box3 | null;
+
+    // /**
+    //  * This bounding sphere encloses all instances of the {@link InstancedMesh}, which can be calculated with {@link computeBoundingSphere | .computeBoundingSphere()}.
+    //  * @remarks bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+    //  * @defaultValue `null`
+    //  */
+    // boundingSphere: Sphere | null;
+    /////////////////////////////////////////////////
+
+    /**
+     * The number of instances.
+     * @remarks
+     * The `count` value passed into the {@link InstancedMesh | constructor} represents the **maximum** number of instances of this mesh.
+     * You can change the number of instances at runtime to an integer value in the range `[0, count]`.
+     * @remarks If you need more instances than the original `count` value, you have to create a new InstancedMesh.
+     * @remarks Expects a `Integer`
+     */
     count: number;
-    instanceColor: null | InstancedBufferAttribute;
+
+    /**
+     * Represents the colors of all instances.
+     * You have to set {@link InstancedBufferAttribute.needsUpdate | .instanceColor.needsUpdate()} flag to `true` if you modify instanced data via {@link setColorAt | .setColorAt()}.
+     * @defaultValue `null`
+     */
+    instanceColor: InstancedBufferAttribute | null;
+
+    /**
+     * Represents the local transformation of all instances.
+     * You have to set {@link InstancedBufferAttribute.needsUpdate | .instanceMatrix.needsUpdate()} flag to `true` if you modify instanced data via {@link setMatrixAt | .setMatrixAt()}.
+     */
     instanceMatrix: InstancedBufferAttribute;
-    readonly isInstancedMesh: true;
 
+    /////////////////////////////////////////////////
+    // FUTURE - r151
+    /////////////////////////////////////////////////
+    // /**
+    //  * Computes bounding box of the all instances, updating {@link boundingBox | .boundingBox} attribute.
+    //  * @remarks Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+    //  */
+    // computeBoundingBox(): void;
+
+    // /**
+    //  * Computes bounding sphere of the all instances, updating {@link boundingSphere | .boundingSphere} attribute.
+    //  * @remarks bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+    //  */
+    // computeBoundingSphere(): void;
+    /////////////////////////////////////////////////
+
+    /**
+     * Get the color of the defined instance.
+     * @param index The index of an instance. Values have to be in the range `[0, count]`. Expects a `Integer`
+     * @param color This color object will be set to the color of the defined instance.
+     */
     getColorAt(index: number, color: Color): void;
-    getMatrixAt(index: number, matrix: Matrix4): void;
+
+    /**
+     * Sets the given color to the defined instance
+     * @remarks
+     * Make sure you set {@link InstancedBufferAttribute.needsUpdate | .instanceColor.needsUpdate()} to `true` after updating all the colors.
+     * @param index The index of an instance. Values have to be in the range `[0, count]`. Expects a `Integer`
+     * @param color The color of a single instance.
+     */
     setColorAt(index: number, color: Color): void;
+
+    /**
+     * Get the local transformation matrix of the defined instance.
+     * @param index The index of an instance Values have to be in the range `[0, count]`. Expects a `Integer`
+     * @param matrix This 4x4 matrix will be set to the local transformation matrix of the defined instance.
+     */
+    getMatrixAt(index: number, matrix: Matrix4): void;
+
+    /**
+     * Sets the given local transformation matrix to the defined instance.
+     * @remarks
+     * Make sure you set {@link InstancedBufferAttribute.needsUpdate | .instanceMatrix.needsUpdate()} flag to `true` after updating all the matrices.
+     * @param index The index of an instance. Values have to be in the range `[0, count]`. Expects a `Integer`
+     * @param matrix A 4x4 matrix representing the local transformation of a single instance.
+     */
     setMatrixAt(index: number, matrix: Matrix4): void;
+
+    /**
+     * No effect in {@link InstancedMesh}.
+     * @ignore
+     * @hidden
+     */
+    override updateMorphTargets(): 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/objects/LOD.d.ts

@@ -3,44 +3,88 @@ import { Raycaster } from './../core/Raycaster';
 import { Camera } from './../cameras/Camera';
 import { Intersection } from '../core/Raycaster';
 
+/**
+ * Every level is associated with an object, and rendering can be switched between them at the distances specified
+ * @remarks
+ * Typically you would create, say, three meshes, one for far away (low detail), one for mid range (medium detail) and one for close up (high detail).
+ * @example
+ * ```typescript
+ * const {@link LOD} = new THREE.LOD();
+ * //Create spheres with 3 levels of detail and create new {@link LOD} levels for them
+ * for (let i = 0; i & lt; 3; i++) {
+ *     const geometry = new THREE.IcosahedronGeometry(10, 3 - i)
+ *     const mesh = new THREE.Mesh(geometry, material);
+ *     lod.addLevel(mesh, i * 75);
+ * }
+ * scene.add(lod);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_lod | webgl / {@link LOD} }
+ * @see {@link https://threejs.org/docs/index.html#api/en/objects/LOD | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/LOD.js | Source}
+ */
 export class LOD extends Object3D {
+    /**
+     * Creates a new {@link LOD}.
+     */
     constructor();
 
-    type: 'LOD';
+    /**
+     * Read-only flag to check if a given object is of type {@link LOD}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isLOD: true;
+
+    /**
+     * @override
+     * @defaultValue `LOD`
+     */
+    override readonly type: string | 'LOD';
 
     /**
-     *
      * An array of level objects
-     *
-     * Each level is an object with the following properties:
-     *
-     * - object - The Object3D to display at this level.
-     * - distance - The distance at which to display this level of detail.
-     * - hysteresis - Threshold used to avoid flickering at LOD boundaries, as a fraction of distance.
      */
-    levels: Array<{ distance: number; hysteresis: number; object: Object3D }>;
+    levels: Array<{
+        /** The Object3D to display at this level. */
+        object: Object3D;
+        /** The distance at which to display this level of detail. Expects a `Float`. */
+        distance: number;
+        /** Threshold used to avoid flickering at LOD boundaries, as a fraction of distance. Expects a `Float`. */
+        hysteresis: number;
+    }>;
 
+    /**
+     * Whether the {@link LOD} object is updated automatically by the renderer per frame or not.
+     * If set to `false`, you have to call {@link update | .update()} in the render loop by yourself.
+     * @defaultValue `true`
+     */
     autoUpdate: boolean;
-    readonly isLOD: true;
 
     /**
      * Adds a mesh that will display at a certain distance and greater. Typically the further away the distance, the lower the detail on the mesh.
      *
      * @param object The Object3D to display at this level.
-     * @param distance The distance at which to display this level of detail. Default 0.0.
-     * @param hysteresis Threshold used to avoid flickering at LOD boundaries, as a fraction of distance. Default 0.0.
+     * @param distance The distance at which to display this level of detail. Expects a `Float`. Default `0.0`.
+     * @param hysteresis Threshold used to avoid flickering at LOD boundaries, as a fraction of distance. Expects a `Float`. Default `0.0`.
      */
     addLevel(object: Object3D, distance?: number, hysteresis?: number): this;
 
+    /**
+     * Get the currently active {@link LOD} level
+     * @remarks
+     * As index of the levels array.
+     */
     getCurrentLevel(): number;
+
+    /**
+     * Get a reference to the first {@link THREE.Object3D | Object3D} (mesh) that is greater than {@link distance}.
+     * @param distance Expects a `Float`
+     */
     getObjectForDistance(distance: number): Object3D | null;
-    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
-    update(camera: Camera): void;
-    toJSON(meta: any): any;
 
-    // TODO: Remove this
     /**
-     * @deprecated Use {@link LOD#levels .levels} instead.
+     * Set the visibility of each {@link levels | level}'s {@link THREE.Object3D | object} based on distance from the {@link THREE.Camera | camera}.
+     * @param camera
      */
-    objects: any[];
+    update(camera: Camera): void;
 }

three/src/objects/Line.d.ts

@@ -4,22 +4,85 @@ import { Object3D } from './../core/Object3D';
 import { BufferGeometry } from '../core/BufferGeometry';
 import { Intersection } from '../core/Raycaster';
 
+/**
+ * A continuous line.
+ * @remarks
+ * This is nearly the same as {@link THREE.LineSegments | LineSegments},
+ * the only difference is that it is rendered using {@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements | gl.LINE_STRIP}
+ * instead of {@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements | gl.LINES}
+ * @example
+ * ```typescript
+ * const material = new THREE.LineBasicMaterial({
+ *     color: 0x0000ff
+ * });
+ * const points = [];
+ * points.push(new THREE.Vector3(-10, 0, 0));
+ * points.push(new THREE.Vector3(0, 10, 0));
+ * points.push(new THREE.Vector3(10, 0, 0));
+ * const geometry = new THREE.BufferGeometry().setFromPoints(points);
+ * const {@link Line} = new THREE.Line(geometry, material);
+ * scene.add(line);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/objects/Line | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/Line.js | Source}
+ */
 export class Line<
     TGeometry extends BufferGeometry = BufferGeometry,
     TMaterial extends Material | Material[] = Material | Material[],
 > extends Object3D {
+    /**
+     * Create a new instance of {@link Line}
+     * @param geometry Vertices representing the {@link Line} segment(s). Default {@link THREE.BufferGeometry | `new THREE.BufferGeometry()`}.
+     * @param material Material for the line. Default {@link THREE.LineBasicMaterial | `new THREE.LineBasicMaterial()`}.
+     */
     constructor(geometry?: TGeometry, material?: TMaterial);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link Line}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isLine: true;
+
+    /**
+     * @override
+     * @defaultValue `Line`
+     */
+    override readonly type: string | 'Line';
+
+    /**
+     * Vertices representing the {@link Line} segment(s).
+     */
     geometry: TGeometry;
-    material: TMaterial;
 
-    type: 'Line' | 'LineLoop' | 'LineSegments' | string;
-    readonly isLine: true;
+    /**
+     * Material for the line.
+     */
+    material: TMaterial;
 
+    /**
+     * An array of weights typically from `0-1` that specify how much of the morph is applied.
+     * @defaultValue `undefined`, but reset to a blank array by {@link updateMorphTargets | .updateMorphTargets()}.
+     */
     morphTargetInfluences?: number[] | undefined;
+
+    /**
+     * A dictionary of morphTargets based on the `morphTarget.name` property.
+     * @defaultValue `undefined`, but reset to a blank array by {@link updateMorphTargets | .updateMorphTargets()}.
+     */
     morphTargetDictionary?: { [key: string]: number } | undefined;
 
+    /**
+     * Computes an array of distance values which are necessary for {@link THREE.LineDashedMaterial | LineDashedMaterial}
+     * @remarks
+     * For each vertex in the geometry, the method calculates the cumulative length from the current point to the very beginning of the line.
+     */
     computeLineDistances(): this;
-    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
+
+    /**
+     * Updates the morphTargets to have no influence on the object
+     * @remarks
+     * Resets the {@link morphTargetInfluences | .morphTargetInfluences} and {@link morphTargetDictionary | .morphTargetDictionary} properties.
+     */
     updateMorphTargets(): void;
 }

three/src/objects/LineLoop.d.ts

@@ -2,12 +2,37 @@ import { Line } from './Line';
 import { Material } from './../materials/Material';
 import { BufferGeometry } from '../core/BufferGeometry';
 
+/**
+ * A continuous line that connects back to the start.
+ * @remarks
+ * This is nearly the same as {@link THREE.Line | Line},
+ * the only difference is that it is rendered using {@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements | gl.LINE_LOOP}
+ * instead of {@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements | gl.LINE_STRIP},
+ * which draws a straight line to the next vertex, and connects the last vertex back to the first.
+ * @see {@link https://threejs.org/docs/index.html#api/en/objects/LineLoop | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/LineLoop.js | Source}
+ */
 export class LineLoop<
     TGeometry extends BufferGeometry = BufferGeometry,
     TMaterial extends Material | Material[] = Material | Material[],
 > extends Line<TGeometry, TMaterial> {
+    /**
+     * Create a new instance of {@link LineLoop}
+     * @param geometry  List of vertices representing points on the line loop. Default {@link THREE.BufferGeometry | `new THREE.BufferGeometry()`}.
+     * @param material Material for the line. Default {@link THREE.LineBasicMaterial | `new THREE.LineBasicMaterial()`}.
+     */
     constructor(geometry?: TGeometry, material?: TMaterial);
 
-    type: 'LineLoop';
+    /**
+     * Read-only flag to check if a given object is of type {@link LineLoop}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
     readonly isLineLoop: true;
+
+    /**
+     * @override
+     * @defaultValue `LineLoop`
+     */
+    override readonly type: string | 'LineLoop';
 }

three/src/objects/LineSegments.d.ts

@@ -3,23 +3,35 @@ import { Line } from './Line';
 import { BufferGeometry } from '../core/BufferGeometry';
 
 /**
- * @deprecated
+ * A series of lines drawn between pairs of vertices.
+ * @remarks
+ * This is nearly the same as {@link THREE.Line | Line},
+ * the only difference is that it is rendered using {@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements | gl.LINES}
+ * instead of {@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements | gl.LINE_STRIP}.
+ * @see {@link https://threejs.org/docs/index.html#api/en/objects/LineSegments | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/LineSegments.js | Source}
  */
-export const LineStrip: number;
-/**
- * @deprecated
- */
-export const LinePieces: number;
-
 export class LineSegments<
     TGeometry extends BufferGeometry = BufferGeometry,
     TMaterial extends Material | Material[] = Material | Material[],
 > extends Line<TGeometry, TMaterial> {
+    /**
+     * Create a new instance of {@link LineSegments}
+     * @param geometry Pair(s) of vertices representing each line segment(s). Default {@link THREE.BufferGeometry | `new THREE.BufferGeometry()`}.
+     * @param material Material for the line. Default {@link THREE.LineBasicMaterial | `new THREE.LineBasicMaterial()`}.
+     */
     constructor(geometry?: TGeometry, material?: TMaterial);
 
     /**
-     * @default 'LineSegments'
+     * Read-only flag to check if a given object is of type {@link LineSegments}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
      */
-    type: 'LineSegments' | string;
     readonly isLineSegments: true;
+
+    /**
+     * @override
+     * @defaultValue `LineSegments`
+     */
+    override readonly type: string | 'LineSegments';
 }

three/src/objects/Mesh.d.ts

@@ -5,26 +5,82 @@ import { BufferGeometry } from '../core/BufferGeometry';
 import { Intersection } from '../core/Raycaster';
 import { Vector3 } from '../math/Vector3';
 
+/**
+ * Class representing triangular {@link https://en.wikipedia.org/wiki/Polygon_mesh | polygon mesh} based objects.
+ * @remarks
+ * Also serves as a base for other classes such as {@link THREE.SkinnedMesh | SkinnedMesh},  {@link THREE.InstancedMesh | InstancedMesh}.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.BoxGeometry(1, 1, 1);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0xffff00
+ * });
+ * const {@link Mesh} = new THREE.Mesh(geometry, material);
+ * scene.add(mesh);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/objects/Mesh | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/Mesh.js | Source}
+ */
 export class Mesh<
     TGeometry extends BufferGeometry = BufferGeometry,
     TMaterial extends Material | Material[] = Material | Material[],
 > extends Object3D {
+    /**
+     * Create a new instance of {@link Mesh}
+     * @param geometry An instance of {@link THREE.BufferGeometry | BufferGeometry}. Default {@link THREE.BufferGeometry | `new THREE.BufferGeometry()`}.
+     * @param material A single or an array of {@link THREE.Material | Material}. Default {@link THREE.MeshBasicMaterial | `new THREE.MeshBasicMaterial()`}.
+     */
     constructor(geometry?: TGeometry, material?: TMaterial);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link Mesh}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isMesh: true;
+
+    /**
+     * @override
+     * @defaultValue `Mesh`
+     */
+    override readonly type: string | 'Mesh';
+
+    /**
+     * An instance of {@link THREE.BufferGeometry | BufferGeometry} (or derived classes), defining the object's structure.
+     * @defaultValue {@link THREE.BufferGeometry | `new THREE.BufferGeometry()`}.
+     */
     geometry: TGeometry;
+
+    /**
+     * An instance of material derived from the {@link THREE.Material | Material} base class or an array of materials, defining the object's appearance.
+     * @defaultValue {@link THREE.MeshBasicMaterial | `new THREE.MeshBasicMaterial()`}.
+     */
     material: TMaterial;
+
+    /**
+     * An array of weights typically from `0-1` that specify how much of the morph is applied.
+     * @defaultValue `undefined`, _but reset to a blank array by {@link updateMorphTargets | .updateMorphTargets()}._
+     */
     morphTargetInfluences?: number[] | undefined;
+
+    /**
+     * A dictionary of morphTargets based on the `morphTarget.name` property.
+     * @defaultValue `undefined`, _but rebuilt by {@link updateMorphTargets | .updateMorphTargets()}._
+     *
+     */
     morphTargetDictionary?: { [key: string]: number } | undefined;
-    readonly isMesh: true;
-    type: string;
 
+    /**
+     * Updates the morphTargets to have no influence on the object
+     * @remarks Resets the {@link morphTargetInfluences} and {@link morphTargetDictionary} properties.
+     */
     updateMorphTargets(): void;
 
     /**
      * Get the local-space position of the vertex at the given index,
      * taking into account the current animation state of both morph targets and skinning.
+     * @param index Expects a `Integer`
+     * @param target
      */
     getVertexPosition(index: number, target: Vector3): Vector3;
-
-    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
 }

three/src/objects/Points.d.ts

@@ -5,33 +5,64 @@ import { BufferGeometry } from '../core/BufferGeometry';
 import { Intersection } from '../core/Raycaster';
 
 /**
- * A class for displaying points. The points are rendered by the WebGLRenderer using gl.POINTS.
+ * A class for displaying {@link Points}
+ * @remarks
+ * The {@link Points} are rendered by the {@link THREE.WebGLRenderer | WebGLRenderer} using {@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements | gl.POINTS}.
+ * @see {@link https://threejs.org/docs/index.html#api/en/objects/Points | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/Points.js | Source}
  */
 export class Points<
     TGeometry extends BufferGeometry = BufferGeometry,
     TMaterial extends Material | Material[] = Material | Material[],
 > extends Object3D {
     /**
-     * @param geometry An instance of BufferGeometry.
-     * @param material An instance of Material (optional).
+     * Create a new instance of {@link Points}
+     * @param geometry An instance of {@link THREE.BufferGeometry | BufferGeometry}. Default {@link THREE.BufferGeometry | `new THREE.BufferGeometry()`}.
+     * @param material A single or an array of {@link THREE.Material | Material}. Default {@link THREE.PointsMaterial | `new THREE.PointsMaterial()`}.
      */
     constructor(geometry?: TGeometry, material?: TMaterial);
 
-    type: 'Points';
+    /**
+     * Read-only flag to check if a given object is of type {@link Points}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isPoints: true;
+
+    /**
+     * @override
+     * @defaultValue `Points`
+     */
+    override readonly type: string | 'Points';
+
+    /**
+     * An array of weights typically from `0-1` that specify how much of the morph is applied.
+     * @defaultValue `undefined`, _but reset to a blank array by {@link updateMorphTargets | .updateMorphTargets()}._
+     */
     morphTargetInfluences?: number[] | undefined;
+
+    /**
+     * A dictionary of morphTargets based on the `morphTarget.name` property.
+     * @defaultValue `undefined`, _but rebuilt by {@link updateMorphTargets | .updateMorphTargets()}._
+     *
+     */
     morphTargetDictionary?: { [key: string]: number } | undefined;
-    readonly isPoints: true;
 
     /**
-     * An instance of BufferGeometry, where each vertex designates the position of a particle in the system.
+     * An instance of {@link THREE.BufferGeometry | BufferGeometry} (or derived classes), defining the object's structure.
+     * @remarks each vertex designates the position of a particle in the system.
      */
     geometry: TGeometry;
 
     /**
-     * An instance of Material, defining the object's appearance. Default is a PointsMaterial with randomised colour.
+     * An instance of {@link THREE.Material | Material}, defining the object's appearance.
+     * @defaultValue {@link THREE.PointsMaterial | `new THREE.PointsMaterial()`}, _with randomised colour_.
      */
     material: TMaterial;
 
-    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
+    /**
+     * Updates the morphTargets to have no influence on the object
+     * @remarks Resets the {@link morphTargetInfluences} and {@link morphTargetDictionary} properties.
+     */
     updateMorphTargets(): void;
 }