@types/three 0.150.0 → 0.150.1

three/src/geometries/TubeGeometry.d.ts

@@ -2,37 +2,85 @@ import { Curve } from './../extras/core/Curve';
 import { Vector3 } from './../math/Vector3';
 import { BufferGeometry } from './../core/BufferGeometry';
 
+/**
+ * Creates a tube that extrudes along a 3d curve.
+ * @example
+ * ```typescript
+ * class CustomSinCurve extends THREE.Curve {
+ *     constructor(scale = 1) {
+ *         super();
+ *         this.scale = scale;
+ *     }
+ *     getPoint(t, optionalTarget = new THREE.Vector3()) {
+ *         const tx = t * 3 - 1.5;
+ *         const ty = Math.sin(2 * Math.PI * t);
+ *         const tz = 0;
+ *         return optionalTarget.set(tx, ty, tz).multiplyScalar(this.scale);
+ *     }
+ * }
+ * const path = new CustomSinCurve(10);
+ * const geometry = new THREE.TubeGeometry(path, 20, 2, 8, false);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0x00ff00
+ * });
+ * const mesh = new THREE.Mesh(geometry, material);
+ * scene.add(mesh);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/TubeGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/TubeGeometry.js | Source}
+ */
 export class TubeGeometry extends BufferGeometry {
     /**
-     * @param path
-     * @param [tubularSegments=64]
-     * @param [radius=1]
-     * @param [radiusSegments=8]
-     * @param [closed=false]
+     * Create a new instance of {@link TubeGeometry}
+     * @param path A 3D path that inherits from the {@link THREE.Curve | Curve} base class.
+     *             Default {@link THREE.QuadraticBezierCurve3 | new THREE.QuadraticBezierCurve3(new Vector3(-1, -1, 0 ), new Vector3(-1, 1, 0), new Vector3(1, 1, 0))}.
+     * @param tubularSegments The number of segments that make up the tube. Expects a `Integer`. Default `64`.
+     * @param radius The radius of the tube. Expects a `Float`. Default `1`.
+     * @param radialSegments The number of segments that make up the cross-section. Expects a `Integer`. Default `8`.
+     * @param closed Is the tube open or closed. Default `false`.
      */
     constructor(
         path?: Curve<Vector3>,
         tubularSegments?: number,
         radius?: number,
-        radiusSegments?: number,
+        radialSegments?: number,
         closed?: boolean,
     );
 
     /**
-     * @default 'TubeGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `TubeGeometry`
      */
-    type: string;
+    override readonly type: string | 'TubeGeometry';
 
-    parameters: {
-        path: Curve<Vector3>;
-        tubularSegments: number;
-        radius: number;
-        radialSegments: number;
-        closed: boolean;
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly path: Curve<Vector3>;
+        readonly tubularSegments: number;
+        readonly radius: number;
+        readonly radialSegments: number;
+        readonly closed: boolean;
     };
+
+    /**
+     * An array of {@link THREE.Vector3 | Vector3} tangents
+     */
     tangents: Vector3[];
+
+    /**
+     * An array of {@link THREE.Vector3 | Vector3} normals
+     */
     normals: Vector3[];
+
+    /**
+     * An array of {@link THREE.Vector3 | Vector3} binormals
+     */
     binormals: Vector3[];
 
-    static fromJSON(data: any): TubeGeometry;
+    /** @internal */
+    static fromJSON(data: {}): TubeGeometry;
 }

three/src/geometries/WireframeGeometry.d.ts

@@ -1,14 +1,40 @@
 import { BufferGeometry } from './../core/BufferGeometry';
 
+/**
+ * This can be used as a helper object to view a {@link BufferGeometry | geometry} as a wireframe.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.SphereGeometry(100, 100, 100);
+ * const wireframe = new THREE.WireframeGeometry(geometry);
+ * const line = new THREE.LineSegments(wireframe);
+ * line.material.depthTest = false;
+ * line.material.opacity = 0.25;
+ * line.material.transparent = true;
+ * scene.add(line);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_helpers | helpers}
+ * @see {@link https://threejs.org/docs/index.html#api/en/geometries/WireframeGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/geometries/WireframeGeometry.js | Source}
+ */
 export class WireframeGeometry<TBufferGeometry extends BufferGeometry = BufferGeometry> extends BufferGeometry {
+    /**
+     * Create a new instance of {@link WireframeGeometry}
+     * @param geometry Any geometry object. Default `null`.
+     */
     constructor(geometry?: TBufferGeometry);
 
     /**
-     * @default 'WireframeGeometry'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `WireframeGeometry`
      */
-    type: string;
+    override readonly type: string | 'WireframeGeometry';
 
-    parameters: {
-        geometry: TBufferGeometry;
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly geometry: TBufferGeometry;
     };
 }

three/src/math/ColorManagement.d.ts

@@ -24,11 +24,11 @@ export namespace ColorManagement {
 
     function fromWorkingColorSpace(
         color: Color,
-        targetColorSpace: typeof SRGBColorSpace | typeof LinearSRGBColorSpace,
+        targetColorSpace: typeof SRGBColorSpace | typeof LinearSRGBColorSpace | typeof DisplayP3ColorSpace,
     ): Color;
 
     function toWorkingColorSpace(
         color: Color,
-        sourceColorSpace: typeof SRGBColorSpace | typeof LinearSRGBColorSpace,
+        sourceColorSpace: typeof SRGBColorSpace | typeof LinearSRGBColorSpace | typeof DisplayP3ColorSpace,
     ): Color;
 }

three/src/objects/Bone.d.ts

@@ -1,9 +1,36 @@
 import { Object3D } from './../core/Object3D';
 
-// Objects //////////////////////////////////////////////////////////////////////////////////
-
+/**
+ * A {@link Bone} which is part of a {@link THREE.Skeleton | Skeleton}
+ * @remarks
+ * The skeleton in turn is used by the {@link THREE.SkinnedMesh | SkinnedMesh}
+ * Bones are almost identical to a blank {@link THREE.Object3D | Object3D}.
+ * @example
+ * ```typescript
+ * const root = new THREE.Bone();
+ * const child = new THREE.Bone();
+ * root.add(child);
+ * child.position.y = 5;
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/objects/Bone | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/Bone.js | Source}
+ */
 export class Bone extends Object3D {
+    /**
+     * Creates a new {@link Bone}.
+     */
     constructor();
+
+    /**
+     * Read-only flag to check if a given object is of type {@link Bone}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
     readonly isBone: true;
-    type: 'Bone';
+
+    /**
+     * @override
+     * @defaultValue `Bone`
+     */
+    override readonly type: string | 'Bone';
 }

three/src/objects/Group.d.ts

@@ -1,7 +1,43 @@
 import { Object3D } from './../core/Object3D';
 
+/**
+ * Its purpose is to make working with groups of objects syntactically clearer.
+ * @remarks This is almost identical to an {@link Object3D | Object3D}
+ * @example
+ * ```typescript
+ * const geometry = new THREE.BoxGeometry(1, 1, 1);
+ * const material = new THREE.MeshBasicMaterial({
+ *     color: 0x00ff00
+ * });
+ * const cubeA = new THREE.Mesh(geometry, material);
+ * cubeA.position.set(100, 100, 0);
+ * const cubeB = new THREE.Mesh(geometry, material);
+ * cubeB.position.set(-100, -100, 0);
+ * //create a {@link Group} and add the two cubes
+ * //These cubes can now be rotated / scaled etc as a {@link Group}  * const {@link Group} = new THREE.Group();
+ * group.add(cubeA);
+ * group.add(cubeB);
+ * scene.add(group);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/objects/Group | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/Group.js | Source}
+ */
 export class Group extends Object3D {
+    /**
+     * Creates a new {@link Bone}.
+     */
     constructor();
-    type: 'Group';
+
+    /**
+     * Read-only flag to check if a given object is of type {@link Group}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
     readonly isGroup: true;
+
+    /**
+     * @override
+     * @defaultValue `Group`
+     */
+    override readonly type: string | 'Group';
 }

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';
 }