@types/three 0.150.2 → 0.152.0

three/src/extras/ImageUtils.d.ts

@@ -1,33 +1,33 @@
 import { Mapping } from '../constants';
 import { Texture } from '../textures/Texture';
 
+/**
+ * A class containing utility functions for images.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/ImageUtils | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/ImageUtils.js | Source}
+ */
 export namespace ImageUtils {
-    function getDataURL(image: any): string;
-
     /**
-     * @deprecated
+     * Returns a data URI containing a representation of the given image.
+     * @param image The image object.
      */
-    let crossOrigin: string;
+    function getDataURL(
+        image: HTMLImageElement | HTMLCanvasElement | CanvasImageSource | ImageBitmap | ImageData,
+    ): string;
 
     /**
-     * @deprecated Use {@link TextureLoader THREE.TextureLoader()} instead.
+     * Converts the given sRGB image data to linear color space.
+     * @param image
      */
-    function loadTexture(
-        url: string,
-        mapping?: Mapping,
-        onLoad?: (texture: Texture) => void,
-        onError?: (message: string) => void,
-    ): Texture;
+    function sRGBToLinear(image: HTMLImageElement | HTMLCanvasElement | ImageBitmap): HTMLCanvasElement;
 
     /**
-     * @deprecated Use {@link CubeTextureLoader THREE.CubeTextureLoader()} instead.
+     * Converts the given sRGB image data to linear color space.
+     * @param image
      */
-    function loadTextureCube(
-        array: string[],
-        mapping?: Mapping,
-        onLoad?: (texture: Texture) => void,
-        onError?: (message: string) => void,
-    ): Texture;
-
-    function sRGBToLinear(image: any): HTMLCanvasElement | { data: number[]; width: number; height: number };
+    function sRGBToLinear(image: ImageData): {
+        data: ImageData['data'];
+        width: ImageData['width'];
+        height: ImageData['height'];
+    };
 }

three/src/extras/PMREMGenerator.d.ts

@@ -4,12 +4,78 @@ import { Texture } from '../textures/Texture';
 import { CubeTexture } from '../textures/CubeTexture';
 import { Scene } from '../scenes/Scene';
 
+/**
+ * This class generates a Prefiltered, Mipmapped Radiance Environment Map (PMREM) from a cubeMap environment texture.
+ * @remarks
+ * This allows different levels of blur to be quickly accessed based on material roughness
+ * Unlike a traditional mipmap chain, it only goes down to the LOD_MIN level (above), and then creates extra even more filtered 'mips' at the same LOD_MIN resolution,
+ * associated with higher roughness levels
+ * In this way we maintain resolution to smoothly interpolate diffuse lighting while limiting sampling computation.
+ * @remarks
+ * Note: The minimum {@link THREE.MeshStandardMaterial | MeshStandardMaterial}'s roughness depends on the size of the provided texture
+ * If your render has small dimensions or the shiny parts have a lot of curvature, you may still be able to get away with a smaller texture size.
+ *
+ * | texture size | minimum roughness  |
+ * |--------------|--------------------|
+ * | 16           | 0.21               |
+ * | 32           | 0.15               |
+ * | 64           | 0.11               |
+ * | 128          | 0.076              |
+ * | 256          | 0.054              |
+ * | 512          | 0.038              |
+ * | 1024         | 0.027              |
+ *
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/PMREMGenerator | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/PMREMGenerator.js | Source}
+ */
 export class PMREMGenerator {
+    /**
+     * This constructor creates a new PMREMGenerator.
+     * @param renderer
+     */
     constructor(renderer: WebGLRenderer);
+
+    /**
+     * Generates a PMREM from a supplied Scene, which can be faster than using an image if networking bandwidth is low
+     * @remarks
+     * Optional near and far planes ensure the scene is rendered in its entirety (the cubeCamera is placed at the origin).
+     * @param scene The given scene.
+     * @param sigma Specifies a blur radius in radians to be applied to the scene before PMREM generation. Default `0`.
+     * @param near The near plane value. Default `0.1`.
+     * @param far The far plane value. Default `100`.
+     */
     fromScene(scene: Scene, sigma?: number, near?: number, far?: number): WebGLRenderTarget;
+
+    /**
+     * Generates a PMREM from an equirectangular texture.
+     * @param equirectangular The equirectangular texture.
+     */
     fromEquirectangular(equirectangular: Texture, renderTarget?: WebGLRenderTarget | null): WebGLRenderTarget;
+
+    /**
+     * Generates a PMREM from an cubemap texture.
+     * @param cubemap The cubemap texture.
+     */
     fromCubemap(cubemap: CubeTexture, renderTarget?: WebGLRenderTarget | null): WebGLRenderTarget;
+
+    /**
+     * Pre-compiles the cubemap shader
+     * @remarks
+     * You can get faster start-up by invoking this method during your texture's network fetch for increased concurrency.
+     */
     compileCubemapShader(): void;
+
+    /**
+     * Pre-compiles the equirectangular shader
+     * @remarks
+     * You can get faster start-up by invoking this method during your texture's network fetch for increased concurrency.
+     */
     compileEquirectangularShader(): 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/extras/ShapeUtils.d.ts

@@ -3,8 +3,26 @@ export interface Vec2 {
     y: number;
 }
 
+/**
+ * A class containing utility functions for shapes.
+ * @remarks Note that these are all linear functions so it is necessary to calculate separately for x, y (and z, w if present) components of a vector.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/ShapeUtils | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/ShapeUtils.js | Source}
+ */
 export namespace ShapeUtils {
+    /**
+     * Calculate area of a ( 2D ) contour polygon.
+     */
     function area(contour: Vec2[]): number;
-    function triangulateShape(contour: Vec2[], holes: Vec2[][]): number[][];
+
+    /**
+     * Note that this is a linear function so it is necessary to calculate separately for x, y components of a polygon.
+     * @remarks Used internally by {@link THREE.Path | Path}, {@link THREE.ExtrudeGeometry | ExtrudeGeometry} and {@link THREE.ShapeGeometry | ShapeGeometry}.
+     */
     function isClockWise(pts: Vec2[]): boolean;
+
+    /**
+     * Used internally by {@link THREE.ExtrudeGeometry | ExtrudeGeometry} and {@link THREE.ShapeGeometry | ShapeGeometry} to calculate faces in shapes with holes.
+     */
+    function triangulateShape(contour: Vec2[], holes: Vec2[][]): number[][];
 }

three/src/extras/core/Curve.d.ts

@@ -1,84 +1,128 @@
 import { Vector } from './../../math/Vector2';
 import { Vector3 } from './../../math/Vector3';
 
-// Extras / Core /////////////////////////////////////////////////////////////////////
-
 /**
- * An extensible curve object which contains methods for interpolation
- * class Curve<T extends Vector>
+ * An abstract base class for creating a {@link Curve} object that contains methods for interpolation
+ * @remarks
+ * For an array of Curves see {@link THREE.CurvePath | CurvePath}.
+ * @remarks
+ * This following curves inherit from THREE.Curve:
+ *
+ * **2D curves**
+ *  - {@link THREE.ArcCurve}
+ *  - {@link THREE.CubicBezierCurve}
+ *  - {@link THREE.EllipseCurve}
+ *  - {@link THREE.LineCurve}
+ *  - {@link THREE.QuadraticBezierCurve}
+ *  - {@link THREE.SplineCurve}
+ *
+ * **3D curves**
+ *  - {@link THREE.CatmullRomCurve3}
+ *  - {@link THREE.CubicBezierCurve3}
+ *  - {@link THREE.LineCurve3}
+ *  - {@link THREE.QuadraticBezierCurve3}
+ *
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/Curve | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/Curve.js | Source}
  */
-export class Curve<T extends Vector> {
+export abstract class Curve<T extends Vector> {
+    protected constructor();
+
     /**
-     * @default 'Curve'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `Curve`
      */
-    type: string;
+    readonly type: string | 'Curve';
 
     /**
-     * This value determines the amount of divisions when calculating the cumulative segment lengths of a curve via .getLengths.
-     * To ensure precision when using methods like .getSpacedPoints, it is recommended to increase .arcLengthDivisions if the curve is very large.
-     * @default 200
+     * This value determines the amount of divisions when calculating the cumulative segment lengths of a {@link Curve}
+     * via {@link .getLengths}.
+     * To ensure precision when using methods like {@link .getSpacedPoints}, it is recommended to increase {@link .arcLengthDivisions} if the {@link Curve} is very large.
+     * @defaultValue `200`
+     * @remarks Expects a `Integer`
      */
     arcLengthDivisions: number;
 
     /**
-     * Returns a vector for point t of the curve where t is between 0 and 1
-     * getPoint(t: number, optionalTarget?: T): T;
+     * Returns a vector for a given position on the curve.
+     * @param t A position on the curve. Must be in the range `[ 0, 1 ]`. Expects a `Float`
+     * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created. Default `new T`.
      */
     getPoint(t: number, optionalTarget?: T): T;
 
     /**
-     * Returns a vector for point at relative position in curve according to arc length
-     * getPointAt(u: number, optionalTarget?: T): T;
+     * Returns a vector for a given position on the {@link Curve} according to the arc length.
+     * @param u A position on the {@link Curve} according to the arc length. Must be in the range `[ 0, 1 ]`. Expects a `Float`
+     * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created. Default `new T`.
      */
     getPointAt(u: number, optionalTarget?: T): T;
 
     /**
-     * Get sequence of points using getPoint( t )
-     * getPoints(divisions?: number): T[];
+     * Returns a set of divisions `+1` points using {@link .getPoint | getPoint(t)}.
+     * @param divisions Number of pieces to divide the {@link Curve} into. Expects a `Integer`. Default `5`
      */
     getPoints(divisions?: number): T[];
 
     /**
-     * Get sequence of equi-spaced points using getPointAt( u )
-     * getSpacedPoints(divisions?: number): T[];
+     * Returns a set of divisions `+1` equi-spaced points using {@link .getPointAt | getPointAt(u)}.
+     * @param divisions Number of pieces to divide the {@link Curve} into. Expects a `Integer`. Default `5`
      */
     getSpacedPoints(divisions?: number): T[];
 
     /**
-     * Get total curve arc length
+     * Get total {@link Curve} arc length.
      */
     getLength(): number;
 
     /**
-     * Get list of cumulative segment lengths
+     * Get list of cumulative segment lengths.
+     * @param divisions Expects a `Integer`
      */
     getLengths(divisions?: number): number[];
 
     /**
      * Update the cumlative segment distance cache
+     * @remarks
+     * The method must be called every time {@link Curve} parameters are changed
+     * If an updated {@link Curve} is part of a composed {@link Curve} like {@link THREE.CurvePath | CurvePath},
+     * {@link .updateArcLengths}() must be called on the composed curve, too.
      */
     updateArcLengths(): void;
 
     /**
-     * Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equi distance
+     * Given u in the range `[ 0, 1 ]`,
+     * @remarks
+     * `u` and `t` can then be used to give you points which are equidistant from the ends of the curve, using {@link .getPoint}.
+     * @param u Expects a `Float`
+     * @param distance Expects a `Float`
+     * @returns `t` also in the range `[ 0, 1 ]`. Expects a `Float`.
      */
     getUtoTmapping(u: number, distance: number): number;
 
     /**
-     * Returns a unit vector tangent at t. If the subclassed curve do not implement its tangent derivation, 2 points a
-     * small delta apart will be used to find its gradient which seems to give a reasonable approximation
-     * getTangent(t: number, optionalTarget?: T): T;
+     * Returns a unit vector tangent at t
+     * @remarks
+     * If the derived {@link Curve} does not implement its tangent derivation, two points a small delta apart will be used to find its gradient which seems to give a reasonable approximation.
+     * @param t A position on the curve. Must be in the range `[ 0, 1 ]`. Expects a `Float`
+     * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created.
      */
     getTangent(t: number, optionalTarget?: T): T;
 
     /**
-     * Returns tangent at equidistance point u on the curve
-     * getTangentAt(u: number, optionalTarget?: T): T;
+     * Returns tangent at a point which is equidistant to the ends of the {@link Curve} from the point given in {@link .getTangent}.
+     * @param u A position on the {@link Curve} according to the arc length. Must be in the range `[ 0, 1 ]`. Expects a `Float`
+     * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created.
      */
     getTangentAt(u: number, optionalTarget?: T): T;
 
     /**
-     * Generate Frenet frames of the curve
+     * Generates the Frenet Frames
+     * @remarks
+     * Requires a {@link Curve} definition in 3D space
+     * Used in geometries like {@link THREE.TubeGeometry | TubeGeometry} or {@link THREE.ExtrudeGeometry | ExtrudeGeometry}.
+     * @param segments Expects a `Integer`
+     * @param closed
      */
     computeFrenetFrames(
         segments: number,
@@ -89,13 +133,24 @@ export class Curve<T extends Vector> {
         binormals: Vector3[];
     };
 
+    /**
+     * Creates a clone of this instance.
+     */
     clone(): this;
+    /**
+     * Copies another {@link Curve} object to this instance.
+     * @param source
+     */
     copy(source: Curve<T>): this;
-    toJSON(): object;
-    fromJSON(json: object): this;
 
     /**
-     * @deprecated since r84.
+     * Returns a JSON object representation of this instance.
+     */
+    toJSON(): {};
+
+    /**
+     * Copies the data from the given JSON object to this instance.
+     * @param json
      */
-    static create(constructorFunc: () => void, getPointFunc: () => void): () => void;
+    fromJSON(json: {}): this;
 }

three/src/extras/core/CurvePath.d.ts

@@ -1,26 +1,68 @@
 import { Curve } from './Curve';
 import { Vector } from './../../math/Vector2';
 
+/**
+ * Curved Path - a curve path is simply a array of connected curves, but retains the api of a curve.
+ * @remarks
+ * A {@link CurvePath} is simply an array of connected curves, but retains the api of a curve.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/CurvePath | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/CurvePath.js | Source}
+ */
 export class CurvePath<T extends Vector> extends Curve<T> {
+    /**
+     * The constructor take no parameters.
+     */
     constructor();
 
     /**
-     * @default 'CurvePath'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `CurvePath`
      */
-    type: string;
+    override readonly type: string | 'CurvePath';
 
     /**
-     * @default []
+     * The array of {@link Curve | Curves}.
+     * @defaultValue `[]`
      */
     curves: Array<Curve<T>>;
 
     /**
-     * @default false
+     * Whether or not to automatically close the path.
+     * @defaultValue false
      */
     autoClose: boolean;
 
+    /**
+     * Add a curve to the {@link .curves} array.
+     * @param curve
+     */
     add(curve: Curve<T>): void;
+    /**
+     * Adds a {@link LineCurve | lineCurve} to close the path.
+     */
     closePath(): void;
+
     getPoint(t: number, optionalTarget?: T): T;
+
+    /**
+     * Get list of cumulative curve lengths of the curves in the {@link .curves} array.
+     */
     getCurveLengths(): number[];
+
+    /**
+     * Returns an array of points representing a sequence of curves
+     * @remarks
+     * The `division` parameter defines the number of pieces each curve is divided into
+     * However, for optimization and quality purposes, the actual sampling resolution for each curve depends on its type
+     * For example, for a {@link THREE.LineCurve | LineCurve}, the returned number of points is always just 2.
+     * @param divisions Number of pieces to divide the curve into. Expects a `Integer`. Default `12`
+     */
+    override getPoints(divisions?: number): T[];
+
+    /**
+     * Returns a set of divisions `+1` equi-spaced points using {@link .getPointAt | getPointAt(u)}.
+     * @param divisions Number of pieces to divide the curve into. Expects a `Integer`. Default `40`
+     */
+    override getSpacedPoints(divisions?: number): T[];
 }

three/src/extras/core/Interpolations.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Used internally by {@link THREE.SplineCurve | SplineCurve}.
+ * @param t Interpolation weight. Expects a `Float`
+ * @param p0 Expects a `Float`
+ * @param p1 Expects a `Float`
+ * @param p2 Expects a `Float`
+ * @param p3 P0, p1, p2, the points defining the spline curve. Expects a `Float`
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/Interpolations | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/Interpolations.js | Source}
+ */
+declare function CatmullRom(t: number, p0: number, p1: number, p2: number, p3: number): number;
+
+/**
+ * Used internally by {@link THREE.QuadraticBezierCurve3 | QuadraticBezierCurve3} and {@link THREE.QuadraticBezierCurve | QuadraticBezierCurve}.
+ * @param t Interpolation weight. Expects a `Float`
+ * @param p0 Expects a `Float`
+ * @param p1 Expects a `Float`
+ * @param p2 P0, p1, the starting, control and end points defining the curve. Expects a `Float`
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/Interpolations | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/Interpolations.js | Source}
+ */
+declare function QuadraticBezier(t: number, p0: number, p1: number, p2: number): number;
+
+/**
+ * Used internally by {@link THREE.CubicBezierCurve3 | CubicBezierCurve3} and {@link THREE.CubicBezierCurve | CubicBezierCurve}.
+ * @param t Interpolation weight. Expects a `Float`
+ * @param p0 Expects a `Float`
+ * @param p1 Expects a `Float`
+ * @param p2 Expects a `Float`
+ * @param p3 P0, p1, p2, the starting, control(twice) and end points defining the curve. Expects a `Float`
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/Interpolations | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/Interpolations.js | Source}
+ */
+declare function CubicBezier(t: number, p0: number, p1: number, p2: number, p3: number): number;
+
+export { CatmullRom, QuadraticBezier, CubicBezier };

three/src/extras/core/Path.d.ts

@@ -2,34 +2,72 @@ import { Vector2 } from './../../math/Vector2';
 import { CurvePath } from './CurvePath';
 
 /**
- * a 2d path representation, comprising of points, lines, and cubes, similar to the html5 2d canvas api. It extends CurvePath.
+ * A 2D {@link Path} representation.
+ * @remarks
+ * The class provides methods for creating paths and contours of 2D shapes similar to the 2D Canvas API.
+ * @example
+ * ```typescript
+ * const {@link Path} = new THREE.Path();
+ * path.lineTo(0, 0.8);
+ * path.quadraticCurveTo(0, 1, 0.2, 1);
+ * path.lineTo(1, 1);
+ * const points = path.getPoints();
+ * const geometry = new THREE.BufferGeometry().setFromPoints(points);
+ * const material = new THREE.LineBasicMaterial({
+ *     color: 0xffffff
+ * });
+ * const line = new THREE.Line(geometry, material);
+ * scene.add(line);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/Path | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/Path.js | Source}
  */
 export class Path extends CurvePath<Vector2> {
+    /**
+     * Creates a {@link Path} from the points
+     * @remarks
+     * The first point defines the offset, then successive points are added to the {@link CurvePath.curves | curves} array as {@link LineCurve | LineCurves}.
+     * If no points are specified, an empty {@link Path} is created and the {@link .currentPoint} is set to the origin.
+     * @param points Array of {@link Vector2 | Vector2s}.
+     */
     constructor(points?: Vector2[]);
 
     /**
-     * @default 'Path'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `Path`
      */
-    type: string;
+    override readonly type: string | 'Path';
 
     /**
-     * @default new THREE.Vector2()
+     * The current offset of the path. Any new {@link THREE.Curve | Curve} added will start here.
+     * @defaultValue `new THREE.Vector2()`
      */
     currentPoint: Vector2;
 
     /**
-     * @deprecated Use {@link Path#setFromPoints .setFromPoints()} instead.
+     * Adds an absolutely positioned {@link THREE.EllipseCurve | EllipseCurve} to the path.
+     * @param x Expects a `Float`
+     * @param y X, The absolute center of the arc. Expects a `Float`
+     * @param radius The radius of the arc. Expects a `Float`
+     * @param startAngle The start angle in radians. Expects a `Float`
+     * @param endAngle The end angle in radians. Expects a `Float`
+     * @param clockwise Sweep the arc clockwise. . Default `false`
      */
-    fromPoints(vectors: Vector2[]): this;
-    setFromPoints(vectors: Vector2[]): this;
-    moveTo(x: number, y: number): this;
-    lineTo(x: number, y: number): this;
-    quadraticCurveTo(aCPx: number, aCPy: number, aX: number, aY: number): this;
-    bezierCurveTo(aCP1x: number, aCP1y: number, aCP2x: number, aCP2y: number, aX: number, aY: number): this;
-    splineThru(pts: Vector2[]): this;
-    arc(aX: number, aY: number, aRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean): this;
     absarc(aX: number, aY: number, aRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean): this;
-    ellipse(
+
+    /**
+     * Adds an absolutely positioned {@link THREE.EllipseCurve | EllipseCurve} to the path.
+     * @param x Expects a `Float`
+     * @param y X, The absolute center of the ellipse. Expects a `Float`
+     * @param xRadius The radius of the ellipse in the x axis. Expects a `Float`
+     * @param yRadius The radius of the ellipse in the y axis. Expects a `Float`
+     * @param startAngle The start angle in radians. Expects a `Float`
+     * @param endAngle The end angle in radians. Expects a `Float`
+     * @param clockwise Sweep the ellipse clockwise. . Default `false`
+     * @param rotation The rotation angle of the ellipse in radians, counterclockwise from the positive X axis. Optional, Expects a `Float`. Default `0`
+     */
+    absellipse(
         aX: number,
         aY: number,
         xRadius: number,
@@ -39,7 +77,41 @@ export class Path extends CurvePath<Vector2> {
         aClockwise: boolean,
         aRotation: number,
     ): this;
-    absellipse(
+
+    /**
+     * Adds an {@link THREE.EllipseCurve | EllipseCurve} to the path, positioned relative to {@link .currentPoint}.
+     * @param x Expects a `Float`
+     * @param y X, The center of the arc offset from the last call. Expects a `Float`
+     * @param radius The radius of the arc. Expects a `Float`
+     * @param startAngle The start angle in radians. Expects a `Float`
+     * @param endAngle The end angle in radians. Expects a `Float`
+     * @param clockwise Sweep the arc clockwise. . Default `false`
+     */
+    arc(aX: number, aY: number, aRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean): this;
+
+    /**
+     * This creates a bezier curve from {@link .currentPoint} with (cp1X, cp1Y) and (cp2X, cp2Y) as control points and updates {@link .currentPoint} to x and y.
+     * @param cp1X Expects a `Float`
+     * @param cp1Y Expects a `Float`
+     * @param cp2X Expects a `Float`
+     * @param cp2Y Expects a `Float`
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
+    bezierCurveTo(aCP1x: number, aCP1y: number, aCP2x: number, aCP2y: number, aX: number, aY: number): this;
+
+    /**
+     * Adds an {@link THREE.EllipseCurve | EllipseCurve} to the path, positioned relative to {@link .currentPoint}.
+     * @param x Expects a `Float`
+     * @param y X, The center of the ellipse offset from the last call. Expects a `Float`
+     * @param xRadius The radius of the ellipse in the x axis. Expects a `Float`
+     * @param yRadius The radius of the ellipse in the y axis. Expects a `Float`
+     * @param startAngle The start angle in radians. Expects a `Float`
+     * @param endAngle The end angle in radians. Expects a `Float`
+     * @param clockwise Sweep the ellipse clockwise. . Default `false`
+     * @param rotation The rotation angle of the ellipse in radians, counterclockwise from the positive X axis. Optional, Expects a `Float`. Default `0`
+     */
+    ellipse(
         aX: number,
         aY: number,
         xRadius: number,
@@ -49,4 +121,39 @@ export class Path extends CurvePath<Vector2> {
         aClockwise: boolean,
         aRotation: number,
     ): this;
+
+    /**
+     * Connects a {@link THREE.LineCurve | LineCurve} from {@link .currentPoint} to x, y onto the path.
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
+    lineTo(x: number, y: number): this;
+
+    /**
+     * Move the {@link .currentPoint} to x, y.
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
+    moveTo(x: number, y: number): this;
+
+    /**
+     * Creates a quadratic curve from {@link .currentPoint} with cpX and cpY as control point and updates {@link .currentPoint} to x and y.
+     * @param cpX Expects a `Float`
+     * @param cpY Expects a `Float`
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
+    quadraticCurveTo(aCPx: number, aCPy: number, aX: number, aY: number): this;
+
+    /**
+     * Points are added to the {@link CurvePath.curves | curves} array as {@link THREE.LineCurve | LineCurves}.
+     * @param vector2s
+     */
+    setFromPoints(vectors: Vector2[]): this;
+
+    /**
+     * Connects a new {@link THREE.SplineCurve | SplineCurve} onto the path.
+     * @param points An array of {@link Vector2 | Vector2's}
+     */
+    splineThru(pts: Vector2[]): this;
 }