@needle-tools/three 0.169.12 → 0.169.14

package/types/src/core/Raycaster.d.ts

@@ -0,0 +1,208 @@
+import { Camera } from "../cameras/Camera.js";
+import { Ray } from "../math/Ray.js";
+import { Vector2 } from "../math/Vector2.js";
+import { Vector3 } from "../math/Vector3.js";
+import { XRTargetRaySpace } from "../renderers/webxr/WebXRController.js";
+import { Layers } from "./Layers.js";
+import { Object3D } from "./Object3D.js";
+
+export interface Face {
+    a: number;
+    b: number;
+    c: number;
+    normal: Vector3;
+    materialIndex: number;
+}
+
+export interface Intersection<TIntersected extends Object3D = Object3D> {
+    /** Distance between the origin of the ray and the intersection */
+    distance: number;
+    distanceToRay?: number | undefined;
+    /** Point of intersection, in world coordinates */
+    point: Vector3;
+    index?: number | undefined;
+    /** Intersected face */
+    face?: Face | null | undefined;
+    /** Index of the intersected face */
+    faceIndex?: number | null | undefined;
+    barycoord?: Vector3 | null;
+    /** The intersected object */
+    object: TIntersected;
+    uv?: Vector2 | undefined;
+    uv1?: Vector2 | undefined;
+    normal?: Vector3;
+    /** The index number of the instance where the ray intersects the {@link THREE.InstancedMesh | InstancedMesh } */
+    instanceId?: number | undefined;
+    pointOnLine?: Vector3;
+    batchId?: number;
+}
+
+export interface RaycasterParameters {
+    Mesh: any;
+    Line: { threshold: number };
+    Line2?: { threshold: number };
+    LOD: any;
+    Points: { threshold: number };
+    Sprite: any;
+}
+
+/**
+ * This class is designed to assist with {@link https://en.wikipedia.org/wiki/Ray_casting | raycasting}
+ * @remarks
+ * Raycasting is used for mouse picking (working out what objects in the 3d space the mouse is over) amongst other things.
+ * @example
+ * ```typescript
+ * const raycaster = new THREE.Raycaster();
+ * const pointer = new THREE.Vector2();
+ *
+ * function onPointerMove(event) {
+ *     // calculate pointer position in normalized device coordinates (-1 to +1) for both components
+ *     pointer.x = (event.clientX / window.innerWidth) * 2 - 1;
+ *     pointer.y = -(event.clientY / window.innerHeight) * 2 + 1;
+ * }
+ *
+ * function render() {
+ *     // update the picking ray with the camera and pointer position
+ *     raycaster.setFromCamera(pointer, camera);
+ *     // calculate objects intersecting the picking ray
+ *     const intersects = raycaster.intersectObjects(scene.children);
+ *     for (let i = 0; i & lt; intersects.length; i++) {
+ *         intersects[i].object.material.color.set(0xff0000);
+ *     }
+ *     renderer.render(scene, camera);
+ * }
+ * window.addEventListener('pointermove', onPointerMove);
+ * window.requestAnimationFrame(render);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_cubes | Raycasting to a Mesh}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_cubes_ortho | Raycasting to a Mesh in using an OrthographicCamera}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_buffergeometry | Raycasting to a Mesh with BufferGeometry}
+ * @see Example: {@link https://threejs.org/examples/#webgl_instancing_raycast | Raycasting to a InstancedMesh}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_lines | Raycasting to a Line}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_raycasting_points | Raycasting to Points}
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_terrain_raycast | Terrain raycasting}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_voxelpainter | Raycasting to paint voxels}
+ * @see Example: {@link https://threejs.org/examples/#webgl_raycaster_texture | Raycast to a Texture}
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/Raycaster | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/Raycaster.js | Source}
+ */
+export class Raycaster {
+    /**
+     * This creates a new {@link Raycaster} object.
+     * @param origin The origin vector where the ray casts from. Default `new Vector3()`
+     * @param direction The direction vector that gives direction to the ray. Should be normalized. Default `new Vector3(0, 0, -1)`
+     * @param near All results returned are further away than near. Near can't be negative. Expects a `Float`. Default `0`
+     * @param far All results returned are closer than far. Far can't be lower than near. Expects a `Float`. Default `Infinity`
+     */
+    constructor(origin?: Vector3, direction?: Vector3, near?: number, far?: number);
+
+    /**
+     * The {@link THREE.RaycasterRay | Ray} used for the raycasting.
+     */
+    ray: Ray;
+
+    /**
+     * The near factor of the raycaster. This value indicates which objects can be discarded based on the distance.
+     * This value shouldn't be negative and should be smaller than the far property.
+     * @remarks Expects a `Float`
+     * @defaultValue `0`
+     */
+    near: number;
+
+    /**
+     * The far factor of the raycaster. This value indicates which objects can be discarded based on the distance.
+     * This value shouldn't be negative and should be larger than the near property.
+     * @remarks Expects a `Float`
+     * @defaultValue `Infinity`
+     */
+    far: number;
+
+    /**
+     * The camera to use when raycasting against view-dependent objects such as billboarded objects like {@link THREE.Sprites | Sprites}.
+     * This field can be set manually or is set when calling  {@link setFromCamera}.
+     * @defaultValue `null`
+     */
+    camera: Camera;
+
+    /**
+     * Used by {@link Raycaster} to selectively ignore 3D objects when performing intersection tests.
+     * The following code example ensures that only 3D objects on layer `1` will be honored by the instance of Raycaster.
+     * ```
+     * raycaster.layers.set( 1 );
+     * object.layers.enable( 1 );
+     * ```
+     * @defaultValue `new THREE.Layers()` - See {@link THREE.Layers | Layers}.
+     */
+    layers: Layers;
+
+    /**
+     * An data object where threshold is the precision of the {@link Raycaster} when intersecting objects, in world units.
+     * @defaultValue `{ Mesh: {}, Line: { threshold: 1 }, LOD: {}, Points: { threshold: 1 }, Sprite: {} }`
+     */
+    params: RaycasterParameters;
+
+    /**
+     * Updates the ray with a new origin and direction
+     * @remarks
+     * Please note that this method only copies the values from the arguments.
+     * @param origin The origin vector where the ray casts from.
+     * @param direction The normalized direction vector that gives direction to the ray.
+     */
+    set(origin: Vector3, direction: Vector3): void;
+
+    /**
+     * Updates the ray with a new origin and direction.
+     * @param coords 2D coordinates of the mouse, in normalized device coordinates (NDC)---X and Y components should be between -1 and 1.
+     * @param camera camera from which the ray should originate
+     */
+    setFromCamera(coords: Vector2, camera: Camera): void;
+
+    /**
+     * Updates the ray with a new origin and direction.
+     * @param controller The controller to copy the position and direction from.
+     */
+    setFromXRController(controller: XRTargetRaySpace): this;
+
+    /**
+     * Checks all intersection between the ray and the object with or without the descendants
+     * @remarks Intersections are returned sorted by distance, closest first
+     * @remarks {@link Raycaster} delegates to the {@link Object3D.raycast | raycast} method of the passed object, when evaluating whether the ray intersects the object or not
+     * This allows {@link THREE.Mesh | meshes} to respond differently to ray casting than {@link THREE.Line | lines} and {@link THREE.Points | pointclouds}.
+     * **Note** that for meshes, faces must be pointed towards the origin of the {@link Raycaster.ray | ray} in order to be detected;
+     * intersections of the ray passing through the back of a face will not be detected
+     * To raycast against both faces of an object, you'll want to set the {@link Mesh.material | material}'s {@link Material.side | side} property to `THREE.DoubleSide`.
+     * @see {@link intersectObjects | .intersectObjects()}.
+     * @param object The object to check for intersection with the ray.
+     * @param recursive If true, it also checks all descendants. Otherwise it only checks intersection with the object. Default `true`
+     * @param optionalTarget Target to set the result. Otherwise a new {@link Array | Array} is instantiated.
+     * If set, you must clear this array prior to each call (i.e., array.length = 0;). Default `[]`
+     * @returns An array of intersections is returned.
+     */
+    intersectObject<TIntersected extends Object3D>(
+        object: Object3D,
+        recursive?: boolean,
+        optionalTarget?: Array<Intersection<TIntersected>>,
+    ): Array<Intersection<TIntersected>>;
+
+    /**
+     * Checks all intersection between the ray and the objects with or without the descendants
+     * @remarks Intersections are returned sorted by distance, closest first
+     * @remarks Intersections are of the same form as those returned by {@link intersectObject | .intersectObject()}.
+     * @remarks {@link Raycaster} delegates to the {@link Object3D.raycast | raycast} method of the passed object, when evaluating whether the ray intersects the object or not
+     * This allows {@link THREE.Mesh | meshes} to respond differently to ray casting than {@link THREE.Line | lines} and {@link THREE.Points | pointclouds}.
+     * **Note** that for meshes, faces must be pointed towards the origin of the {@link Raycaster.ray | ray} in order to be detected;
+     * intersections of the ray passing through the back of a face will not be detected
+     * To raycast against both faces of an object, you'll want to set the {@link Mesh.material | material}'s {@link Material.side | side} property to `THREE.DoubleSide`.
+     * @see {@link intersectObject | .intersectObject()}.
+     * @param objects The objects to check for intersection with the ray.
+     * @param recursive If true, it also checks all descendants of the objects. Otherwise it only checks intersection with the objects. Default `true`
+     * @param optionalTarget Target to set the result. Otherwise a new {@link Array | Array} is instantiated.
+     * If set, you must clear this array prior to each call (i.e., array.length = 0;). Default `[]`
+     * @returns An array of intersections is returned.
+     */
+    intersectObjects<TIntersected extends Object3D>(
+        objects: Object3D[],
+        recursive?: boolean,
+        optionalTarget?: Array<Intersection<TIntersected>>,
+    ): Array<Intersection<TIntersected>>;
+}

package/types/src/core/RenderTarget.d.ts

@@ -0,0 +1,96 @@
+import {
+    ColorSpace,
+    MagnificationTextureFilter,
+    MinificationTextureFilter,
+    PixelFormatGPU,
+    TextureDataType,
+    Wrapping,
+} from "../constants.js";
+import { Vector4 } from "../math/Vector4.js";
+import { DepthTexture } from "../textures/DepthTexture.js";
+import { Texture } from "../textures/Texture.js";
+import { EventDispatcher } from "./EventDispatcher.js";
+
+export interface RenderTargetOptions {
+    wrapS?: Wrapping | undefined;
+    wrapT?: Wrapping | undefined;
+    magFilter?: MagnificationTextureFilter | undefined;
+    minFilter?: MinificationTextureFilter | undefined;
+    generateMipmaps?: boolean | undefined; // true
+    format?: number | undefined; // RGBAFormat
+    type?: TextureDataType | undefined; // UnsignedByteType
+    anisotropy?: number | undefined; // 1
+    colorSpace?: ColorSpace | undefined;
+    internalFormat?: PixelFormatGPU | null | undefined; // null
+    depthBuffer?: boolean | undefined; // true
+    stencilBuffer?: boolean | undefined; // false
+    resolveDepthBuffer?: boolean | undefined; // true
+    resolveStencilBuffer?: boolean | undefined; // true
+    depthTexture?: DepthTexture | null | undefined; // null
+    /**
+     * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.
+     * @default 0
+     */
+    samples?: number | undefined;
+    count?: number | undefined;
+}
+
+export class RenderTarget<TTexture extends Texture | Texture[] = Texture> extends EventDispatcher<{ dispose: {} }> {
+    readonly isRenderTarget: true;
+
+    width: number;
+    height: number;
+    depth: number;
+
+    scissor: Vector4;
+    /**
+     * @default false
+     */
+    scissorTest: boolean;
+    viewport: Vector4;
+    textures: TTexture[];
+
+    /**
+     * @default true
+     */
+    depthBuffer: boolean;
+
+    /**
+     * @default false
+     */
+    stencilBuffer: boolean;
+
+    /**
+     * Defines whether the depth buffer should be resolved when rendering into a multisampled render target.
+     * @default true
+     */
+    resolveDepthBuffer: boolean;
+
+    /**
+     * Defines whether the stencil buffer should be resolved when rendering into a multisampled render target.
+     * This property has no effect when {@link .resolveDepthBuffer} is set to `false`.
+     * @default true
+     */
+    resolveStencilBuffer: boolean;
+
+    /**
+     * @default null
+     */
+    depthTexture: DepthTexture | null;
+
+    /**
+     * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.
+     * @default 0
+     */
+    samples: number;
+
+    constructor(width?: number, height?: number, options?: RenderTargetOptions);
+
+    get texture(): TTexture;
+    set texture(value: TTexture);
+
+    setSize(width: number, height: number, depth?: number): void;
+    clone(): this;
+    copy(source: RenderTarget): this;
+    dispose(): void;
+}

package/types/src/core/Uniform.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Uniforms are global GLSL variables.
+ * They are passed to shader programs.
+ * @example
+ * When declaring a uniform of a {@link THREE.ShaderMaterial | ShaderMaterial}, it is declared by value or by object.
+ * ```typescript
+ * uniforms: {
+ *     time: {
+ *         value: 1.0
+ *     },
+ *     resolution: new Uniform(new Vector2())
+ * };
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_nodes_materials_instance_uniform | WebGL2 / nodes / materials / instance / uniform}
+ * @see Example: {@link https://threejs.org/examples/#webgpu_instance_uniform| WebGPU / instance / uniform}
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/Uniform | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/Uniform.js | Source}
+ */
+export class Uniform<T = any> {
+    /**
+     * Create a new instance of {@link THREE.Uniform | Uniform}
+     * @param value An object containing the value to set up the uniform. It's type must be one of the Uniform Types described above.
+     */
+    constructor(value: T);
+
+    /**
+     * Current value of the uniform.
+     */
+    value: T;
+
+    /**
+     * Returns a clone of this uniform.
+     * @remarks
+     * If the uniform's {@link value} property is an {@link Object | Object} with a `clone()` method, this is used,
+     * otherwise the value is copied by assignment Array values are **shared** between cloned {@link THREE.UniformUniform | Uniform}s.
+     */
+    clone(): Uniform<T>;
+}

package/types/src/core/UniformsGroup.d.ts

@@ -0,0 +1,33 @@
+import { Usage } from "../constants.js";
+import { EventDispatcher } from "./EventDispatcher.js";
+import { Uniform } from "./Uniform.js";
+
+/**
+ * @see Example: {@link https://threejs.org/examples/#webgl2_ubo | WebGL2 / UBO}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/UniformsGroup.js | Source}
+ */
+export class UniformsGroup extends EventDispatcher<{ dispose: {} }> {
+    constructor();
+
+    readonly isUniformsGroup: true;
+
+    id: number;
+
+    usage: Usage;
+
+    uniforms: Array<Uniform | Uniform[]>;
+
+    add(uniform: Uniform | Uniform[]): this;
+
+    remove(uniform: Uniform | Uniform[]): this;
+
+    setName(name: string): this;
+
+    setUsage(value: Usage): this;
+
+    dispose(): this;
+
+    copy(source: UniformsGroup): this;
+
+    clone(): UniformsGroup;
+}

package/types/src/extras/Controls.d.ts

@@ -0,0 +1,54 @@
+import { EventDispatcher } from "../core/EventDispatcher.js";
+import { Object3D } from "../core/Object3D.js";
+
+/**
+ * Abstract base class for controls.
+ */
+declare abstract class Controls<TEventMap extends {}> extends EventDispatcher<TEventMap> {
+    /**
+     * The 3D object that is managed by the controls.
+     */
+    object: Object3D;
+
+    /**
+     * The HTML element used for event listeners. If not provided via the constructor, {@link .connect} must be called
+     * after `domElement` has been set.
+     */
+    domElement: HTMLElement | null;
+
+    /**
+     * When set to `false`, the controls will not respond to user input. Default is `true`.
+     */
+    enabled: boolean;
+
+    /**
+     * Creates a new instance of {@link Controls}.
+     * @param object The object the controls should manage (usually the camera).
+     * @param domElement The HTML element used for event listeners. (optional)
+     */
+    constructor(object: Object3D, domElement?: HTMLElement | null);
+
+    /**
+     * Connects the controls to the DOM. This method has so called "side effects" since it adds the module's event
+     * listeners to the DOM.
+     */
+    connect(): void;
+
+    /**
+     * Disconnects the controls from the DOM.
+     */
+    disconnect(): void;
+
+    /**
+     * Call this method if you no longer want use to the controls. It frees all internal resources and removes all event
+     * listeners.
+     */
+    dispose(): void;
+
+    /**
+     * Controls should implement this method if they have to update their internal state per simulation step.
+     */
+    update(delta: number): void;
+}
+
+export { Controls };

package/types/src/extras/DataUtils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Returns a half precision floating point value from the given single precision floating point value.
+ * @param val A single precision floating point value.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/DataUtils | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/DataUtils.js | Source}
+ */
+declare function toHalfFloat(val: number): number;
+
+/**
+ * Returns a single precision floating point value from the given half precision floating point value.
+ * @param val A half precision floating point value.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/DataUtils | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/DataUtils.js | Source}
+ */
+declare function fromHalfFloat(val: number): number;
+
+declare const DataUtils: {
+    toHalfFloat: typeof toHalfFloat;
+    fromHalfFloat: typeof fromHalfFloat;
+};
+
+export { DataUtils, fromHalfFloat, toHalfFloat };

package/types/src/extras/Earcut.d.ts

@@ -0,0 +1,15 @@
+/**
+ * An implementation of the {@link Earcut} polygon triangulation algorithm
+ * @remarks
+ * The code is a port of {@link https://github.com/mapbox/earcut | mapbox/earcut}.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/Earcut | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/Earcut.js | Source}
+ */
+export const Earcut: {
+    /**
+     * Triangulates the given shape definition by returning an array of triangles
+     * @remarks
+     * A triangle is defined by three consecutive integers representing vertex indices.
+     */
+    triangulate(data: number[], holeIndices?: number[], dim?: number): number[];
+};

package/types/src/extras/ImageUtils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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}
+ */
+declare class ImageUtils {
+    /**
+     * Returns a data URI containing a representation of the given image.
+     * @param image The image object.
+     */
+    static getDataURL(
+        image: HTMLImageElement | HTMLCanvasElement | CanvasImageSource | ImageBitmap | ImageData,
+    ): string;
+
+    /**
+     * Converts the given sRGB image data to linear color space.
+     * @param image
+     */
+    static sRGBToLinear(image: HTMLImageElement | HTMLCanvasElement | ImageBitmap): HTMLCanvasElement;
+
+    /**
+     * Converts the given sRGB image data to linear color space.
+     * @param image
+     */
+    static sRGBToLinear(image: ImageData): {
+        data: ImageData["data"];
+        width: ImageData["width"];
+        height: ImageData["height"];
+    };
+}
+
+export { ImageUtils };

package/types/src/extras/PMREMGenerator.d.ts

@@ -0,0 +1,82 @@
+import { WebGLRenderer } from "../renderers/WebGLRenderer.js";
+import { WebGLRenderTarget } from "../renderers/WebGLRenderTarget.js";
+import { Scene } from "../scenes/Scene.js";
+import { CubeTexture } from "../textures/CubeTexture.js";
+import { Texture } from "../textures/Texture.js";
+
+/**
+ * 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, which can be either LDR or HDR. The ideal input image size is
+     * 1k (1024 x 512), as this matches best with the 256 x 256 cubemap output. The smallest supported equirectangular
+     * image size is 64 x 32.
+     */
+    fromEquirectangular(equirectangular: Texture, renderTarget?: WebGLRenderTarget | null): WebGLRenderTarget;
+
+    /**
+     * Generates a PMREM from an cubemap texture, which can be either LDR or HDR. The ideal input cube size is
+     * 256 x 256, as this matches best with the 256 x 256 cubemap output. The smallest supported cube size is 16 x 16.
+     */
+    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;
+}

package/types/src/extras/ShapeUtils.d.ts

@@ -0,0 +1,25 @@
+import { Vector2Like } from "../math/Vector2.js";
+
+/**
+ * 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 class ShapeUtils {
+    /**
+     * Calculate area of a ( 2D ) contour polygon.
+     */
+    static area(contour: readonly Vector2Like[]): 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}.
+     */
+    static isClockWise(pts: readonly Vector2Like[]): boolean;
+
+    /**
+     * Used internally by {@link THREE.ExtrudeGeometry | ExtrudeGeometry} and {@link THREE.ShapeGeometry | ShapeGeometry} to calculate faces in shapes with holes.
+     */
+    static triangulateShape(contour: Vector2Like[], holes: Vector2Like[][]): number[][];
+}

package/types/src/extras/TextureUtils.d.ts

@@ -0,0 +1,42 @@
+import { CompressedPixelFormat, PixelFormat, TextureDataType } from "../constants.js";
+import { Texture } from "../textures/Texture.js";
+
+/**
+ * Scales the texture as large as possible within its surface without cropping or stretching the texture. The method
+ * preserves the original aspect ratio of the texture. Akin to CSS `object-fit: contain`.
+ */
+declare function contain(texture: Texture, aspect: number): Texture;
+
+/**
+ * Scales the texture to the smallest possible size to fill the surface, leaving no empty space. The method preserves
+ * the original aspect ratio of the texture. Akin to CSS `object-fit: cover`.
+ */
+declare function cover(texture: Texture, aspect: number): Texture;
+
+/**
+ * Configures the texture to the default transformation. Akin to CSS `object-fit: fill`.
+ */
+declare function fill(texture: Texture): Texture;
+
+/**
+ * Given the width, height, format, and type of a texture. Determines how many bytes must be used to represent the
+ * texture.
+ */
+declare function getByteLength(
+    width: number,
+    height: number,
+    format: PixelFormat | CompressedPixelFormat,
+    type: TextureDataType,
+): number;
+
+/**
+ * A class containing utility functions for textures.
+ */
+declare const TextureUtils: {
+    contain: typeof contain;
+    cover: typeof cover;
+    fill: typeof fill;
+    getByteLength: typeof getByteLength;
+};
+
+export { contain, cover, fill, getByteLength, TextureUtils };