@needle-tools/three 0.169.12 → 0.169.13

package/types/src/objects/Line.d.ts

@@ -0,0 +1,87 @@
+import { BufferGeometry } from "../core/BufferGeometry.js";
+import { Object3D, Object3DEventMap } from "../core/Object3D.js";
+import { Material } from "../materials/Material.js";
+
+/**
+ * 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[],
+    TEventMap extends Object3DEventMap = Object3DEventMap,
+> extends Object3D<TEventMap> {
+    /**
+     * 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 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;
+
+    /**
+     * Updates the morphTargets to have no influence on the object
+     * @remarks
+     * Resets the {@link morphTargetInfluences | .morphTargetInfluences} and {@link morphTargetDictionary | .morphTargetDictionary} properties.
+     */
+    updateMorphTargets(): void;
+}

package/types/src/objects/LineLoop.d.ts

@@ -0,0 +1,40 @@
+import { BufferGeometry } from "../core/BufferGeometry.js";
+import { Object3DEventMap } from "../core/Object3D.js";
+import { Material } from "../materials/Material.js";
+import { Line } from "./Line.js";
+
+/**
+ * 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[],
+    TEventMap extends Object3DEventMap = Object3DEventMap,
+> extends Line<TGeometry, TMaterial, TEventMap> {
+    /**
+     * 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);
+
+    /**
+     * 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";
+}

package/types/src/objects/LineSegments.d.ts

@@ -0,0 +1,41 @@
+import { BufferGeometry } from "../core/BufferGeometry.js";
+import { Object3DEventMap } from "../core/Object3D.js";
+import { Material } from "../materials/Material.js";
+import { Line } from "./Line.js";
+
+/**
+ * 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 class LineSegments<
+    TGeometry extends BufferGeometry = BufferGeometry,
+    TMaterial extends Material | Material[] = Material | Material[],
+    TEventMap extends Object3DEventMap = Object3DEventMap,
+> extends Line<TGeometry, TMaterial, TEventMap> {
+    /**
+     * 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);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link LineSegments}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isLineSegments: true;
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @override
+     * @defaultValue `LineSegments`
+     */
+    override readonly type: string | "LineSegments";
+}

package/types/src/objects/Mesh.d.ts

@@ -0,0 +1,94 @@
+import { BufferGeometry } from "../core/BufferGeometry.js";
+import { JSONMeta, Object3D, Object3DEventMap, Object3DJSON, Object3DJSONObject } from "../core/Object3D.js";
+import { Material } from "../materials/Material.js";
+import { Vector3 } from "../math/Vector3.js";
+
+export interface MeshJSONObject extends Object3DJSONObject {
+    geometry: string;
+}
+
+export interface MeshJSON extends Object3DJSON {
+    object: MeshJSONObject;
+}
+
+/**
+ * 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[],
+    TEventMap extends Object3DEventMap = Object3DEventMap,
+> extends Object3D<TEventMap> {
+    /**
+     * 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;
+
+    /**
+     * 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;
+
+    toJSON(meta?: JSONMeta): MeshJSON;
+}

package/types/src/objects/Points.d.ts

@@ -0,0 +1,66 @@
+import { BufferGeometry, NormalOrGLBufferAttributes } from "../core/BufferGeometry.js";
+import { Object3D, Object3DEventMap } from "../core/Object3D.js";
+import { Material } from "../materials/Material.js";
+
+/**
+ * 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<NormalOrGLBufferAttributes> = BufferGeometry,
+    TMaterial extends Material | Material[] = Material | Material[],
+    TEventMap extends Object3DEventMap = Object3DEventMap,
+> extends Object3D<TEventMap> {
+    /**
+     * 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);
+
+    /**
+     * 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;
+
+    /**
+     * 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 {@link THREE.Material | Material}, defining the object's appearance.
+     * @defaultValue {@link THREE.PointsMaterial | `new THREE.PointsMaterial()`}, _with randomised colour_.
+     */
+    material: TMaterial;
+
+    /**
+     * Updates the morphTargets to have no influence on the object
+     * @remarks Resets the {@link morphTargetInfluences} and {@link morphTargetDictionary} properties.
+     */
+    updateMorphTargets(): void;
+}

package/types/src/objects/Skeleton.d.ts

@@ -0,0 +1,120 @@
+import { Matrix4, Matrix4Tuple } from "../math/Matrix4.js";
+import { DataTexture } from "../textures/DataTexture.js";
+import { Bone } from "./Bone.js";
+
+export interface SkeletonJSON {
+    metadata: { version: number; type: string; generator: string };
+    bones: string[];
+    boneInverses: Matrix4Tuple[];
+    uuid: string;
+}
+
+/**
+ * Use an array of {@link Bone | bones} to create a {@link Skeleton} that can be used by a {@link THREE.SkinnedMesh | SkinnedMesh}.
+ * @example
+ * ```typescript
+ * // Create a simple "arm"
+ * const bones = [];
+ * const shoulder = new THREE.Bone();
+ * const elbow = new THREE.Bone();
+ * const hand = new THREE.Bone();
+ * shoulder.add(elbow);
+ * elbow.add(hand);
+ * bones.push(shoulder);
+ * bones.push(elbow);
+ * bones.push(hand);
+ * shoulder.position.y = -5;
+ * elbow.position.y = 0;
+ * hand.position.y = 5;
+ * const armSkeleton = new THREE.Skeleton(bones);
+ * See the[page: SkinnedMesh] page
+ * for an example of usage with standard[page: BufferGeometry].
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/objects/Skeleton | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/Skeleton.js | Source}
+ */
+export class Skeleton {
+    /**
+     * Creates a new Skeleton.
+     * @param bones The array of {@link THREE.Bone | bones}. Default `[]`.
+     * @param boneInverses An array of {@link THREE.Matrix4 | Matrix4s}. Default `[]`.
+     */
+    constructor(bones?: Bone[], boneInverses?: Matrix4[]);
+
+    /**
+     * {@link http://en.wikipedia.org/wiki/Universally_unique_identifier | UUID} of this object instance.
+     * @remarks This gets automatically assigned and shouldn't be edited.
+     */
+    uuid: string;
+
+    /**
+     * The array of {@link THREE.Bone | Bones}.
+     * @remarks Note this is a copy of the original array, not a reference, so you can modify the original array without effecting this one.
+     */
+    bones: Bone[];
+
+    /**
+     * An array of {@link Matrix4 | Matrix4s} that represent the inverse of the {@link THREE.Matrix4 | matrixWorld} of the individual bones.
+     */
+    boneInverses: Matrix4[];
+
+    /**
+     * The array buffer holding the bone data when using a vertex texture.
+     */
+    boneMatrices: Float32Array;
+
+    /**
+     * The {@link THREE.DataTexture | DataTexture} holding the bone data when using a vertex texture.
+     */
+    boneTexture: null | DataTexture;
+
+    frame: number;
+
+    init(): void;
+
+    /**
+     * Generates the {@link boneInverses} array if not provided in the constructor.
+     */
+    calculateInverses(): void;
+
+    /**
+     * Computes an instance of {@link THREE.DataTexture | DataTexture} in order to pass the bone data more efficiently to the shader
+     * @remarks
+     * The texture is assigned to {@link boneTexture}.
+     */
+    computeBoneTexture(): this;
+
+    /**
+     * Returns the skeleton to the base pose.
+     */
+    pose(): void;
+
+    /**
+     * Updates the {@link boneMatrices} and {@link boneTexture} after changing the bones
+     * @remarks
+     * This is called automatically by the {@link THREE.WebGLRenderer | WebGLRenderer} if the {@link Skeleton} is used with a {@link THREE.SkinnedMesh | SkinnedMesh}.
+     */
+    update(): void;
+
+    /**
+     * Returns a clone of this {@link Skeleton} object.
+     */
+    clone(): Skeleton;
+
+    /**
+     * Searches through the skeleton's bone array and returns the first with a matching name.
+     * @param name String to match to the Bone's {@link THREE.Bone.name | .name} property.
+     */
+    getBoneByName(name: string): undefined | Bone;
+
+    /**
+     * 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;
+
+    toJSON(): SkeletonJSON;
+
+    fromJSON(json: SkeletonJSON, bones: Record<string, Bone>): void;
+}

package/types/src/objects/SkinnedMesh.d.ts

@@ -0,0 +1,160 @@
+import { BindMode } from "../constants.js";
+import { BufferGeometry } from "../core/BufferGeometry.js";
+import { JSONMeta, Object3DEventMap } from "../core/Object3D.js";
+import { Material } from "../materials/Material.js";
+import { Box3 } from "../math/Box3.js";
+import { Matrix4, Matrix4Tuple } from "../math/Matrix4.js";
+import { Sphere } from "../math/Sphere.js";
+import { Vector3 } from "../math/Vector3.js";
+import { Mesh, MeshJSON, MeshJSONObject } from "./Mesh.js";
+import { Skeleton } from "./Skeleton.js";
+
+export interface SkinnedMeshJSONObject extends MeshJSONObject {
+    bindMode: BindMode;
+    bindMatrix: Matrix4Tuple;
+    skeleton?: string;
+}
+
+export interface SkinnedMeshJSON extends MeshJSON {
+    object: SkinnedMeshJSONObject;
+}
+
+/**
+ * A mesh that has a {@link THREE.Skeleton | Skeleton} with {@link Bone | bones} that can then be used to animate the vertices of the geometry.
+ * @example
+ * ```typescript
+ * const geometry = new THREE.CylinderGeometry(5, 5, 5, 5, 15, 5, 30);
+ * // create the skin indices and skin weights manually
+ * // (typically a loader would read this data from a 3D model for you)
+ * const position = geometry.attributes.position;
+ * const vertex = new THREE.Vector3();
+ * const skinIndices = [];
+ * const skinWeights = [];
+ * for (let i = 0; i & lt; position.count; i++) {
+ *     vertex.fromBufferAttribute(position, i);
+ *     // compute skinIndex and skinWeight based on some configuration data
+ *     const y = (vertex.y + sizing.halfHeight);
+ *     const skinIndex = Math.floor(y / sizing.segmentHeight);
+ *     const skinWeight = (y % sizing.segmentHeight) / sizing.segmentHeight;
+ *     skinIndices.push(skinIndex, skinIndex + 1, 0, 0);
+ *     skinWeights.push(1 - skinWeight, skinWeight, 0, 0);
+ * }
+ * geometry.setAttribute('skinIndex', new THREE.Uint16BufferAttribute(skinIndices, 4));
+ * geometry.setAttribute('skinWeight', new THREE.Float32BufferAttribute(skinWeights, 4));
+ * // create skinned mesh and skeleton
+ * const mesh = new THREE.SkinnedMesh(geometry, material);
+ * const skeleton = new THREE.Skeleton(bones);
+ * // see example from THREE.Skeleton
+ * const rootBone = skeleton.bones[0];
+ * mesh.add(rootBone);
+ * // bind the skeleton to the mesh
+ * mesh.bind(skeleton);
+ * // move the bones and manipulate the model
+ * skeleton.bones[0].rotation.x = -0.1;
+ * skeleton.bones[1].rotation.x = 0.2;
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/objects/SkinnedMesh | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/SkinnedMesh.js | Source}
+ */
+export class SkinnedMesh<
+    TGeometry extends BufferGeometry = BufferGeometry,
+    TMaterial extends Material | Material[] = Material | Material[],
+    TEventMap extends Object3DEventMap = Object3DEventMap,
+> extends Mesh<TGeometry, TMaterial, TEventMap> {
+    /**
+     * Create a new instance of {@link SkinnedMesh}
+     * @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, useVertexTexture?: boolean);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link SkinnedMesh}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isSkinnedMesh: true;
+
+    /**
+     * @override
+     * @defaultValue `SkinnedMesh`
+     */
+    override readonly type: string | "SkinnedMesh";
+
+    /**
+     * Either {@link AttachedBindMode} or {@link DetachedBindMode}. {@link AttachedBindMode} means the skinned mesh
+     * shares the same world space as the skeleton. This is not true when using {@link DetachedBindMode} which is useful
+     * when sharing a skeleton across multiple skinned meshes.
+     * @defaultValue `AttachedBindMode`
+     */
+    bindMode: BindMode;
+
+    /**
+     * The base matrix that is used for the bound bone transforms.
+     */
+    bindMatrix: Matrix4;
+    /**
+     * The base matrix that is used for resetting the bound bone transforms.
+     */
+    bindMatrixInverse: Matrix4;
+
+    /**
+     * The bounding box of the SkinnedMesh. Can be calculated with {@link computeBoundingBox | .computeBoundingBox()}.
+     * @default `null`
+     */
+    boundingBox: Box3;
+
+    /**
+     * The bounding box of the SkinnedMesh. Can be calculated with {@link computeBoundingSphere | .computeBoundingSphere()}.
+     * @default `null`
+     */
+    boundingSphere: Sphere;
+
+    /**
+     * {@link THREE.Skeleton | Skeleton} representing the bone hierarchy of the skinned mesh.
+     */
+    skeleton: Skeleton;
+
+    /**
+     * Bind a skeleton to the skinned mesh
+     * @remarks
+     * The bindMatrix gets saved to .bindMatrix property and the .bindMatrixInverse gets calculated.
+     * @param skeleton {@link THREE.Skeleton | Skeleton} created from a {@link Bone | Bones} tree.
+     * @param bindMatrix {@link THREE.Matrix4 | Matrix4} that represents the base transform of the skeleton.
+     */
+    bind(skeleton: Skeleton, bindMatrix?: Matrix4): void;
+
+    /**
+     * Computes the bounding box of the skinned mesh, and updates the {@link .boundingBox} attribute. The bounding box
+     * is not computed by the engine; it must be computed by your app. If the skinned mesh is animated, the bounding box
+     * should be recomputed per frame.
+     */
+    computeBoundingBox(): void;
+
+    /**
+     * Computes the bounding sphere of the skinned mesh, and updates the {@link .boundingSphere} attribute. The bounding
+     * sphere is automatically computed by the engine when it is needed, e.g., for ray casting and view frustum culling.
+     * If the skinned mesh is animated, the bounding sphere should be recomputed per frame.
+     */
+    computeBoundingSphere(): void;
+
+    /**
+     * This method sets the skinned mesh in the rest pose (resets the pose).
+     */
+    pose(): void;
+
+    /**
+     * Normalizes the skin weights.
+     */
+    normalizeSkinWeights(): void;
+
+    /**
+     * Applies the bone transform associated with the given index to the given position vector
+     * @remarks Returns the updated vector.
+     * @param index Expects a `Integer`
+     * @param vector
+     */
+    applyBoneTransform(index: number, vector: Vector3): Vector3;
+
+    toJSON(meta?: JSONMeta): SkinnedMeshJSON;
+}

package/types/src/objects/Sprite.d.ts

@@ -0,0 +1,65 @@
+import { BufferGeometry } from "../core/BufferGeometry.js";
+import { Object3D, Object3DEventMap } from "../core/Object3D.js";
+import { SpriteMaterial } from "../materials/Materials.js";
+import { Vector2 } from "../math/Vector2.js";
+
+/**
+ * A {@link Sprite} is a plane that always faces towards the camera, generally with a partially transparent texture applied.
+ * @remarks Sprites do not cast shadows, setting `castShadow = true` will have no effect.
+ * @example
+ * ```typescript
+ * const map = new THREE.TextureLoader().load('sprite.png');
+ * const material = new THREE.SpriteMaterial({
+ *     map: map
+ * });
+ * const {@link Sprite} = new THREE.Sprite(material);
+ * scene.add(sprite);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/objects/Sprite | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/Sprite.js | Source}
+ */
+export class Sprite<TEventMap extends Object3DEventMap = Object3DEventMap> extends Object3D<TEventMap> {
+    /**
+     * Creates a new Sprite.
+     * @param material An instance of {@link THREE.SpriteMaterial | SpriteMaterial}. Default {@link THREE.SpriteMaterial | `new SpriteMaterial()`}, _with white color_.
+     */
+    constructor(material?: SpriteMaterial);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link Sprite}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isSprite: true;
+
+    /**
+     * @override
+     * @defaultValue `Sprite`
+     */
+    override readonly type: string | "Sprite";
+
+    /**
+     * Whether the object gets rendered into shadow map.
+     * No effect in {@link Sprite}.
+     * @ignore
+     * @hidden
+     * @defaultValue `false`
+     */
+    override castShadow: false;
+
+    geometry: BufferGeometry;
+
+    /**
+     * An instance of {@link THREE.SpriteMaterial | SpriteMaterial}, defining the object's appearance.
+     * @defaultValue {@link THREE.SpriteMaterial | `new SpriteMaterial()`}, _with white color_.
+     */
+    material: SpriteMaterial;
+
+    /**
+     * The sprite's anchor point, and the point around which the {@link Sprite} rotates.
+     * A value of (0.5, 0.5) corresponds to the midpoint of the sprite.
+     * A value of (0, 0) corresponds to the lower left corner of the sprite.
+     * @defaultValue {@link THREE.Vector2 | `new Vector2(0.5, 0.5)`}.
+     */
+    center: Vector2;
+}