@types/three 0.174.0 → 0.176.0

three/src/animation/AnimationObjectGroup.d.ts

@@ -1,17 +1,58 @@
-export class AnimationObjectGroup {
-    constructor(...args: any[]);
+import { Object3D } from "../core/Object3D.js";
 
-    uuid: string;
-    stats: {
-        bindingsPerObject: number;
-        objects: {
-            total: number;
-            inUse: number;
-        };
-    };
+/**
+ * A group of objects that receives a shared animation state.
+ *
+ * Usage:
+ *
+ * - Add objects you would otherwise pass as 'root' to the
+ * constructor or the .clipAction method of AnimationMixer.
+ * - Instead pass this object as 'root'.
+ * - You can also add and remove objects later when the mixer is running.
+ *
+ * Note:
+ *
+ * - Objects of this class appear as one object to the mixer,
+ * so cache control of the individual objects must be done on the group.
+ *
+ * Limitation:
+ *
+ * - The animated properties must be compatible among the all objects in the group.
+ * - A single property can either be controlled through a target group or directly, but not both.
+ */
+export class AnimationObjectGroup {
+    /**
+     * Constructs a new animation group.
+     *
+     * @param {...Object3D} arguments - An arbitrary number of 3D objects that share the same animation state.
+     */
+    constructor(...args: Object3D[]);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @default true
+     */
     readonly isAnimationObjectGroup: true;
-
-    add(...args: any[]): void;
-    remove(...args: any[]): void;
-    uncache(...args: any[]): void;
+    /**
+     * The UUID of the 3D object.
+     */
+    readonly uuid: string;
+    /**
+     * Adds an arbitrary number of objects to this animation group.
+     *
+     * @param {...Object3D} arguments - The 3D objects to add.
+     */
+    add(...args: Object3D[]): void;
+    /**
+     * Removes an arbitrary number of objects to this animation group
+     *
+     * @param {...Object3D} arguments - The 3D objects to remove.
+     */
+    remove(...args: Object3D[]): void;
+    /**
+     * Deallocates all memory resources for the passed 3D objects of this animation group.
+     *
+     * @param {...Object3D} arguments - The 3D objects to uncache.
+     */
+    uncache(...args: Object3D[]): void;
 }

three/src/animation/AnimationUtils.d.ts

@@ -1,60 +1,171 @@
+import { TypedArray, TypedArrayConstructor } from "../core/BufferAttribute.js";
 import { AnimationClip } from "./AnimationClip.js";
 
-declare function convertArray(array: any, type: any, forceClone: boolean): any;
-
-declare function isTypedArray(object: any): boolean;
-
-declare function getKeyframeOrder(times: number[]): number[];
-
-declare function sortedArray(values: any[], stride: number, order: number[]): any[];
-
-declare function flattenJSON(jsonKeys: string[], times: any[], values: any[], valuePropertyName: string): void;
-
 /**
- * @param sourceClip
- * @param name
- * @param startFrame
- * @param endFrame
- * @param [fps=30]
+ * Converts an array to a specific type.
+ *
+ * @param {TypedArray|Array} array - The array to convert.
+ * @param {TypedArray.constructor} type - The constructor of a typed array that defines the new type.
+ * @return {TypedArray} The converted array.
+ */
+export function convertArray(array: TypedArray | number[], type: TypedArrayConstructor): TypedArray | number[];
+/**
+ * Returns `true` if the given object is a typed array.
+ *
+ * @param {any} object - The object to check.
+ * @return {boolean} Whether the given object is a typed array.
+ */
+export function isTypedArray(object: unknown): boolean;
+/**
+ * Returns an array by which times and values can be sorted.
+ *
+ * @param {Array<number>} times - The keyframe time values.
+ * @return {Array<number>} The array.
+ */
+export function getKeyframeOrder(times: Array<number>): Array<number>;
+/**
+ * Sorts the given array by the previously computed order via `getKeyframeOrder()`.
+ *
+ * @param {Array<number>} values - The values to sort.
+ * @param {number} stride - The stride.
+ * @param {Array<number>} order - The sort order.
+ * @return {Array<number>} The sorted values.
+ */
+export function sortedArray(values: Array<number>, stride: number, order: Array<number>): Array<number>;
+/**
+ * Used for parsing AOS keyframe formats.
+ *
+ * @param {Array<number>} jsonKeys - A list of JSON keyframes.
+ * @param {Array<number>} times - This array will be filled with keyframe times by this function.
+ * @param {Array<number>} values - This array will be filled with keyframe values by this function.
+ * @param {string} valuePropertyName - The name of the property to use.
+ */
+export function flattenJSON(
+    jsonKeys: Array<number>,
+    times: Array<number>,
+    values: Array<number>,
+    valuePropertyName: string,
+): void;
+/**
+ * Creates a new clip, containing only the segment of the original clip between the given frames.
+ *
+ * @param {AnimationClip} sourceClip - The values to sort.
+ * @param {string} name - The name of the clip.
+ * @param {number} startFrame - The start frame.
+ * @param {number} endFrame - The end frame.
+ * @param {number} [fps=30] - The FPS.
+ * @return {AnimationClip} The new sub clip.
  */
-declare function subclip(
+export function subclip(
     sourceClip: AnimationClip,
     name: string,
     startFrame: number,
     endFrame: number,
     fps?: number,
 ): AnimationClip;
-
 /**
- * @param targetClip
- * @param [referenceFrame=0]
- * @param [referenceClip=targetClip]
- * @param [fps=30]
+ * Converts the keyframes of the given animation clip to an additive format.
+ *
+ * @param {AnimationClip} targetClip - The clip to make additive.
+ * @param {number} [referenceFrame=0] - The reference frame.
+ * @param {AnimationClip} [referenceClip=targetClip] - The reference clip.
+ * @param {number} [fps=30] - The FPS.
+ * @return {AnimationClip} The updated clip which is now additive.
  */
-declare function makeClipAdditive(
+export function makeClipAdditive(
     targetClip: AnimationClip,
     referenceFrame?: number,
     referenceClip?: AnimationClip,
     fps?: number,
 ): AnimationClip;
-
-declare const AnimationUtils: {
-    convertArray: typeof convertArray;
-    isTypedArray: typeof isTypedArray;
-    getKeyframeOrder: typeof getKeyframeOrder;
-    sortedArray: typeof sortedArray;
-    flattenJSON: typeof flattenJSON;
-    subclip: typeof subclip;
-    makeClipAdditive: typeof makeClipAdditive;
-};
-
-export {
-    AnimationUtils,
-    convertArray,
-    flattenJSON,
-    getKeyframeOrder,
-    isTypedArray,
-    makeClipAdditive,
-    sortedArray,
-    subclip,
-};
+/**
+ * A class with various methods to assist with animations.
+ *
+ * @hideconstructor
+ */
+export class AnimationUtils {
+    /**
+     * Converts an array to a specific type
+     *
+     * @static
+     * @param {TypedArray|Array} array - The array to convert.
+     * @param {TypedArray.constructor} type - The constructor of a type array.
+     * @return {TypedArray} The converted array
+     */
+    static convertArray(array: TypedArray | number[], type: TypedArrayConstructor): TypedArray | number[];
+    /**
+     * Returns `true` if the given object is a typed array.
+     *
+     * @static
+     * @param {any} object - The object to check.
+     * @return {boolean} Whether the given object is a typed array.
+     */
+    static isTypedArray(object: unknown): boolean;
+    /**
+     * Returns an array by which times and values can be sorted.
+     *
+     * @static
+     * @param {Array<number>} times - The keyframe time values.
+     * @return {Array<number>} The array.
+     */
+    static getKeyframeOrder(times: Array<number>): Array<number>;
+    /**
+     * Sorts the given array by the previously computed order via `getKeyframeOrder()`.
+     *
+     * @static
+     * @param {Array<number>} values - The values to sort.
+     * @param {number} stride - The stride.
+     * @param {Array<number>} order - The sort order.
+     * @return {Array<number>} The sorted values.
+     */
+    static sortedArray(values: Array<number>, stride: number, order: Array<number>): Array<number>;
+    /**
+     * Used for parsing AOS keyframe formats.
+     *
+     * @static
+     * @param {Array<number>} jsonKeys - A list of JSON keyframes.
+     * @param {Array<number>} times - This array will be filled with keyframe times by this method.
+     * @param {Array<number>} values - This array will be filled with keyframe values by this method.
+     * @param {string} valuePropertyName - The name of the property to use.
+     */
+    static flattenJSON(
+        jsonKeys: Array<number>,
+        times: Array<number>,
+        values: Array<number>,
+        valuePropertyName: string,
+    ): void;
+    /**
+     * Creates a new clip, containing only the segment of the original clip between the given frames.
+     *
+     * @static
+     * @param {AnimationClip} sourceClip - The values to sort.
+     * @param {string} name - The name of the clip.
+     * @param {number} startFrame - The start frame.
+     * @param {number} endFrame - The end frame.
+     * @param {number} [fps=30] - The FPS.
+     * @return {AnimationClip} The new sub clip.
+     */
+    static subclip(
+        sourceClip: AnimationClip,
+        name: string,
+        startFrame: number,
+        endFrame: number,
+        fps?: number,
+    ): AnimationClip;
+    /**
+     * Converts the keyframes of the given animation clip to an additive format.
+     *
+     * @static
+     * @param {AnimationClip} targetClip - The clip to make additive.
+     * @param {number} [referenceFrame=0] - The reference frame.
+     * @param {AnimationClip} [referenceClip=targetClip] - The reference clip.
+     * @param {number} [fps=30] - The FPS.
+     * @return {AnimationClip} The updated clip which is now additive.
+     */
+    static makeClipAdditive(
+        targetClip: AnimationClip,
+        referenceFrame?: number,
+        referenceClip?: AnimationClip,
+        fps?: number,
+    ): AnimationClip;
+}

three/src/animation/KeyframeTrack.d.ts

@@ -1,5 +1,5 @@
 import { InterpolationModes } from "../constants.js";
-import { Interpolant } from "../math/Interpolant.js";
+import { TypedArray, TypedArrayConstructor } from "../core/BufferAttribute.js";
 import { CubicInterpolant } from "../math/interpolants/CubicInterpolant.js";
 import { DiscreteInterpolant } from "../math/interpolants/DiscreteInterpolant.js";
 import { LinearInterpolant } from "../math/interpolants/LinearInterpolant.js";
@@ -12,44 +12,153 @@ export interface KeyframeTrackJSON {
     type: string;
 }
 
+/**
+ * Represents s a timed sequence of keyframes, which are composed of lists of
+ * times and related values, and which are used to animate a specific property
+ * of an object.
+ */
 export class KeyframeTrack {
     /**
-     * @param name
-     * @param times
-     * @param values
-     * @param [interpolation=THREE.InterpolateLinear]
+     * Converts the keyframe track to JSON.
+     *
+     * @static
+     * @param {KeyframeTrack} track - The keyframe track to serialize.
+     * @return {Object} The serialized keyframe track as JSON.
+     */
+    static toJSON(track: KeyframeTrack): KeyframeTrackJSON;
+    /**
+     * Constructs a new keyframe track.
+     *
+     * @param {string} name - The keyframe track's name.
+     * @param {Array<number>} times - A list of keyframe times.
+     * @param {Array<number>} values - A list of keyframe values.
+     * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
+     */
+    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<number>, interpolation?: InterpolationModes);
+    /**
+     * The track's name can refer to morph targets or bones or
+     * possibly other values within an animated object. See {@link PropertyBinding#parseTrackName}
+     * for the forms of strings that can be parsed for property binding.
      */
-    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<any>, interpolation?: InterpolationModes);
-
     name: string;
+    /**
+     * The keyframe times.
+     */
     times: Float32Array;
+    /**
+     * The keyframe values.
+     */
     values: Float32Array;
-
-    ValueTypeName: string;
-    TimeBufferType: Float32Array;
-    ValueBufferType: Float32Array;
-
     /**
-     * @default THREE.InterpolateLinear
+     * Factory method for creating a new discrete interpolant.
+     *
+     * @static
+     * @param {TypedArray} [result] - The result buffer.
+     * @return {DiscreteInterpolant} The new interpolant.
+     */
+    InterpolantFactoryMethodDiscrete(result?: TypedArray): DiscreteInterpolant;
+    /**
+     * Factory method for creating a new linear interpolant.
+     *
+     * @static
+     * @param {TypedArray} [result] - The result buffer.
+     * @return {LinearInterpolant} The new interpolant.
+     */
+    InterpolantFactoryMethodLinear(result?: TypedArray): LinearInterpolant;
+    /**
+     * Factory method for creating a new smooth interpolant.
+     *
+     * @static
+     * @param {TypedArray} [result] - The result buffer.
+     * @return {CubicInterpolant} The new interpolant.
+     */
+    InterpolantFactoryMethodSmooth(result?: TypedArray): CubicInterpolant;
+    /**
+     * Defines the interpolation factor method for this keyframe track.
+     *
+     * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} interpolation - The interpolation type.
+     * @return {KeyframeTrack} A reference to this keyframe track.
      */
-    DefaultInterpolation: InterpolationModes;
-
-    InterpolantFactoryMethodDiscrete(result: any): DiscreteInterpolant;
-    InterpolantFactoryMethodLinear(result: any): LinearInterpolant;
-    InterpolantFactoryMethodSmooth(result: any): CubicInterpolant;
-
     setInterpolation(interpolation: InterpolationModes): KeyframeTrack;
+    /**
+     * Returns the current interpolation type.
+     *
+     * @return {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} The interpolation type.
+     */
     getInterpolation(): InterpolationModes;
-    createInterpolant(): Interpolant;
-
+    /**
+     * Returns the value size.
+     *
+     * @return {number} The value size.
+     */
     getValueSize(): number;
-
+    /**
+     * Moves all keyframes either forward or backward in time.
+     *
+     * @param {number} timeOffset - The offset to move the time values.
+     * @return {KeyframeTrack} A reference to this keyframe track.
+     */
     shift(timeOffset: number): KeyframeTrack;
+    /**
+     * Scale all keyframe times by a factor (useful for frame - seconds conversions).
+     *
+     * @param {number} timeScale - The time scale.
+     * @return {KeyframeTrack} A reference to this keyframe track.
+     */
     scale(timeScale: number): KeyframeTrack;
+    /**
+     * Removes keyframes before and after animation without changing any values within the defined time range.
+     *
+     * Note: The method does not shift around keys to the start of the track time, because for interpolated
+     * keys this will change their values
+     *
+     * @param {number} startTime - The start time.
+     * @param {number} endTime - The end time.
+     * @return {KeyframeTrack} A reference to this keyframe track.
+     */
     trim(startTime: number, endTime: number): KeyframeTrack;
+    /**
+     * Performs minimal validation on the keyframe track. Returns `true` if the values
+     * are valid.
+     *
+     * @return {boolean} Whether the keyframes are valid or not.
+     */
     validate(): boolean;
-    optimize(): KeyframeTrack;
+    /**
+     * Optimizes this keyframe track by removing equivalent sequential keys (which are
+     * common in morph target sequences).
+     *
+     * @return {AnimationClip} A reference to this animation clip.
+     */
+    optimize(): this;
+    /**
+     * Returns a new keyframe track with copied values from this instance.
+     *
+     * @return {KeyframeTrack} A clone of this instance.
+     */
     clone(): this;
-
-    static toJSON(track: KeyframeTrack): KeyframeTrackJSON;
+    /**
+     * The value type name.
+     *
+     * @default ''
+     */
+    ValueTypeName: string;
+    /**
+     * The time buffer type of this keyframe track.
+     *
+     * @default Float32Array.constructor
+     */
+    TimeBufferType: TypedArrayConstructor | ArrayConstructor;
+    /**
+     * The value buffer type of this keyframe track.
+     *
+     * @default Float32Array.constructor
+     */
+    ValueBufferType: TypedArrayConstructor | ArrayConstructor;
+    /**
+     * The default interpolation type of this keyframe track.
+     *
+     * @default InterpolateLinear
+     */
+    DefaultInterpolation: InterpolationModes;
 }

three/src/animation/PropertyBinding.d.ts

@@ -1,3 +1,6 @@
+import { Object3D } from "../core/Object3D.js";
+import { Skeleton } from "../objects/Skeleton.js";
+
 export interface ParseTrackNameResults {
     nodeName: string;
     objectName: string;
@@ -6,38 +9,93 @@ export interface ParseTrackNameResults {
     propertyIndex: string;
 }
 
-declare class Composite {
-    constructor(targetGroup: any, path: any, parsedPath?: any);
-
-    getValue(array: any, offset: number): any;
-    setValue(array: any, offset: number): void;
-    bind(): void;
-    unbind(): void;
-}
-
-declare class PropertyBinding {
-    constructor(rootNode: any, path: string, parsedPath?: any);
-
+/**
+ * This holds a reference to a real property in the scene graph; used internally.
+ */
+export class PropertyBinding {
+    /**
+     * Factory method for creating a property binding from the given parameters.
+     *
+     * @static
+     * @param {Object} root - The root node.
+     * @param {string} path - The path.
+     * @param {?Object} [parsedPath] - The parsed path.
+     * @return {PropertyBinding|Composite} The created property binding or composite.
+     */
+    static create(root: object, path: string, parsedPath?: object | null): PropertyBinding | Composite;
+    /**
+     * Replaces spaces with underscores and removes unsupported characters from
+     * node names, to ensure compatibility with parseTrackName().
+     *
+     * @param {string} name - Node name to be sanitized.
+     * @return {string} The sanitized node name.
+     */
+    static sanitizeNodeName(name: string): string;
+    /**
+     * Parses the given track name (an object path to an animated property) and
+     * returns an object with information about the path. Matches strings in the following forms:
+     *
+     * - nodeName.property
+     * - nodeName.property[accessor]
+     * - nodeName.material.property[accessor]
+     * - uuid.property[accessor]
+     * - uuid.objectName[objectIndex].propertyName[propertyIndex]
+     * - parentName/nodeName.property
+     * - parentName/parentName/nodeName.property[index]
+     * - .bone[Armature.DEF_cog].position
+     * - scene:helium_balloon_model:helium_balloon_model.position
+     *
+     * @static
+     * @param {string} trackName - The track name to parse.
+     * @return {Object} The parsed track name as an object.
+     */
+    static parseTrackName(trackName: string): ParseTrackNameResults;
+    /**
+     * Searches for a node in the hierarchy of the given root object by the given
+     * node name.
+     *
+     * @static
+     * @param {Object} root - The root object.
+     * @param {string|number} nodeName - The name of the node.
+     * @return {?Object} The found node. Returns `null` if no object was found.
+     */
+    static findNode(root: object, nodeName: string | number): object | null;
+    /**
+     * Constructs a new property binding.
+     *
+     * @param {Object} rootNode - The root node.
+     * @param {string} path - The path.
+     * @param {?Object} [parsedPath] - The parsed path.
+     */
+    constructor(rootNode: Object3D | Skeleton, path: string, parsedPath?: object | null);
+    /**
+     * The object path to the animated property.
+     */
     path: string;
-    parsedPath: any;
-    node: any;
-    rootNode: any;
-
-    getValue(targetArray: any, offset: number): any;
-    setValue(sourceArray: any, offset: number): void;
+    /**
+     * An object holding information about the path.
+     */
+    parsedPath: object;
+    /**
+     * The object owns the animated property.
+     */
+    node: object | null;
+    /**
+     * The root node.
+     */
+    rootNode: Object3D | Skeleton;
+    /**
+     * Creates a getter / setter pair for the property tracked by this binding.
+     */
     bind(): void;
+    /**
+     * Unbinds the property.
+     */
     unbind(): void;
-
-    BindingType: { [bindingType: string]: number };
-    Versioning: { [versioning: string]: number };
-
-    GetterByBindingType: Array<() => void>;
-    SetterByBindingTypeAndVersioning: Array<Array<() => void>>;
-
-    static create(root: any, path: any, parsedPath?: any): PropertyBinding | Composite;
-    static sanitizeNodeName(name: string): string;
-    static parseTrackName(trackName: string): ParseTrackNameResults;
-    static findNode(root: any, nodeName: string): any;
 }
-
-export { PropertyBinding };
+export namespace PropertyBinding {
+    export { Composite };
+}
+declare class Composite {
+}
+export {};

three/src/animation/PropertyMixer.d.ts

@@ -1,17 +1,74 @@
-export class PropertyMixer {
-    constructor(binding: any, typeName: string, valueSize: number);
+import { PropertyBinding } from "./PropertyBinding.js";
 
-    binding: any;
+/**
+ * Buffered scene graph property that allows weighted accumulation; used internally.
+ */
+export class PropertyMixer {
+    /**
+     * Constructs a new property mixer.
+     *
+     * @param {PropertyBinding} binding - The property binding.
+     * @param {string} typeName - The keyframe track type name.
+     * @param {number} valueSize - The keyframe track value size.
+     */
+    constructor(binding: PropertyBinding, typeName: string, valueSize: number);
+    /**
+     * The property binding.
+     */
+    binding: PropertyBinding;
+    /**
+     * The keyframe track value size.
+     */
     valueSize: number;
-    buffer: any;
+    /**
+     * TODO
+     *
+     * @default 0
+     */
     cumulativeWeight: number;
+    /**
+     * TODO
+     *
+     * @default 0
+     */
     cumulativeWeightAdditive: number;
+    /**
+     * TODO
+     *
+     * @default 0
+     */
     useCount: number;
+    /**
+     * TODO
+     *
+     * @default 0
+     */
     referenceCount: number;
-
+    /**
+     * Accumulates data in the `incoming` region into `accu<i>`.
+     *
+     * @param {number} accuIndex - The accumulation index.
+     * @param {number} weight - The weight.
+     */
     accumulate(accuIndex: number, weight: number): void;
+    /**
+     * Accumulates data in the `incoming` region into `add`.
+     *
+     * @param {number} weight - The weight.
+     */
     accumulateAdditive(weight: number): void;
+    /**
+     * Applies the state of `accu<i>` to the binding when accus differ.
+     *
+     * @param {number} accuIndex - The accumulation index.
+     */
     apply(accuIndex: number): void;
+    /**
+     * Remembers the state of the bound property and copy it to both accus.
+     */
     saveOriginalState(): void;
+    /**
+     * Applies the state previously taken via {@link PropertyMixer#saveOriginalState} to the binding.
+     */
     restoreOriginalState(): void;
 }