@types/three 0.157.1 → 0.157.2

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Wed, 18 Oct 2023 11:45:06 GMT
+ * Last updated: Wed, 18 Oct 2023 18:04:04 GMT
  * Dependencies: [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/webxr](https://npmjs.com/package/@types/webxr), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
 
 # Credits

three/examples/jsm/animation/CCDIKSolver.d.ts

@@ -0,0 +1,30 @@
+import { Object3D, SkinnedMesh, Vector3 } from '../../../src/Three.js';
+
+// tslint:disable-next-line:interface-name
+export interface IKS {
+    effector: number;
+    iteration?: number | undefined;
+    links: Array<{
+        enabled?: boolean | undefined;
+        index: number;
+        limitation?: Vector3 | undefined;
+        rotationMin?: Vector3 | undefined;
+        rotationMax?: Vector3 | undefined;
+    }>;
+    minAngle?: number | undefined;
+    maxAngle?: number | undefined;
+    target: number;
+}
+
+export class CCDIKSolver {
+    constructor(mesh: SkinnedMesh, iks: IKS[]);
+
+    update(): this;
+    updateOne(iks: IKS): this;
+    createHelper(): CCDIKHelper;
+}
+
+export class CCDIKHelper extends Object3D {
+    constructor(mesh: SkinnedMesh, iks?: IKS[], sphereSize?: number);
+    dispose(): void;
+}

three/examples/jsm/animation/MMDAnimationHelper.d.ts

@@ -0,0 +1,105 @@
+import {
+    AnimationClip,
+    Audio,
+    Camera,
+    Mesh,
+    Object3D,
+    Quaternion,
+    SkinnedMesh,
+    Bone,
+    AnimationMixer,
+} from '../../../src/Three.js';
+
+import { CCDIKSolver } from './CCDIKSolver.js';
+import { MMDPhysics } from './MMDPhysics.js';
+
+export interface MMDAnimationHelperParameter {
+    sync?: boolean | undefined;
+    afterglow?: number | undefined;
+    resetPhysicsOnLoop?: boolean | undefined;
+    pmxAnimation?: boolean | undefined;
+}
+
+export interface MMDAnimationHelperAddParameter {
+    animation?: AnimationClip | AnimationClip[] | undefined;
+    physics?: boolean | undefined;
+    warmup?: number | undefined;
+    unitStep?: number | undefined;
+    maxStepNum?: number | undefined;
+    gravity?: number | undefined;
+    delayTime?: number | undefined;
+}
+
+export interface MMDAnimationHelperPoseParameter {
+    resetPose?: boolean | undefined;
+    ik?: boolean | undefined;
+    grant?: boolean | undefined;
+}
+
+export interface MMDAnimationHelperMixer {
+    looped: boolean;
+    mixer?: AnimationMixer | undefined;
+    ikSolver: CCDIKSolver;
+    grantSolver: GrantSolver;
+    physics?: MMDPhysics | undefined;
+    duration?: number | undefined;
+}
+
+export class MMDAnimationHelper {
+    constructor(params?: MMDAnimationHelperParameter);
+    meshes: SkinnedMesh[];
+    camera: Camera | null;
+    cameraTarget: Object3D;
+    audio: Audio;
+    audioManager: AudioManager;
+    configuration: {
+        sync: boolean;
+        afterglow: number;
+        resetPhysicsOnLoop: boolean;
+        pmxAnimation: boolean;
+    };
+    enabled: {
+        animation: boolean;
+        ik: boolean;
+        grant: boolean;
+        physics: boolean;
+        cameraAnimation: boolean;
+    };
+    objects: WeakMap<SkinnedMesh | Camera | AudioManager, MMDAnimationHelperMixer>;
+    onBeforePhysics: (mesh: SkinnedMesh) => void;
+    sharedPhysics: boolean;
+    masterPhysics: null;
+
+    add(object: SkinnedMesh | Camera | Audio, params?: MMDAnimationHelperAddParameter): this;
+    remove(object: SkinnedMesh | Camera | Audio): this;
+    update(delta: number): this;
+    pose(mesh: SkinnedMesh, vpd: object, params?: MMDAnimationHelperPoseParameter): this;
+    enable(key: string, enabled: boolean): this;
+    createGrantSolver(mesh: SkinnedMesh): GrantSolver;
+}
+
+export interface AudioManagerParameter {
+    delayTime?: number | undefined;
+}
+
+export class AudioManager {
+    constructor(audio: Audio, params?: AudioManagerParameter);
+    audio: Audio;
+    elapsedTime: number;
+    currentTime: number;
+    delayTime: number;
+    audioDuration: number;
+    duration: number;
+
+    control(delta: number): this;
+}
+
+export class GrantSolver {
+    constructor(mesh: SkinnedMesh, grants: object[]);
+    mesh: SkinnedMesh;
+    grants: object[];
+
+    update(): this;
+    updateOne(gran: object[]): this;
+    addGrantRotation(bone: Bone, q: Quaternion, ratio: number): this;
+}

three/examples/jsm/animation/MMDPhysics.d.ts

@@ -0,0 +1,124 @@
+import { Bone, Euler, Matrix4, Object3D, Quaternion, SkinnedMesh, Vector3 } from '../../../src/Three.js';
+
+export interface MMDPhysicsParameter {
+    unitStep?: number | undefined;
+    maxStepNum?: number | undefined;
+    gravity?: Vector3 | undefined;
+}
+
+export class MMDPhysics {
+    constructor(
+        mesh: SkinnedMesh,
+        rigidBodyParams: object[],
+        constraintParams?: object[],
+        params?: MMDPhysicsParameter,
+    );
+    manager: ResourceManager;
+    mesh: SkinnedMesh;
+    unitStep: number;
+    maxStepNum: number;
+    gravity: Vector3;
+    world: null;
+    bodies: RigidBody[];
+    constraints: Constraint[];
+
+    update(delta: number): this;
+    reset(): this;
+    warmup(cycles: number): this;
+    setGravity(gravity: Vector3): this;
+    createHelper(): MMDPhysicsHelper;
+}
+
+export class ResourceManager {
+    constructor();
+    threeVector3s: Vector3[];
+    threeMatrix4s: Matrix4[];
+    threeQuaternions: Quaternion[];
+    threeEulers: Euler[];
+    transforms: object[];
+    quaternions: object[];
+    vector3s: object[];
+
+    allocThreeVector3(): void;
+    freeThreeVector3(v: Vector3): void;
+    allocThreeMatrix4(): void;
+    freeThreeMatrix4(m: Matrix4): void;
+    allocThreeQuaternion(): void;
+    freeThreeQuaternion(q: Quaternion): void;
+    allocThreeEuler(): void;
+    freeThreeEuler(e: Euler): void;
+    allocTransform(): void;
+    freeTransform(t: object): void;
+    allocQuaternion(): void;
+    freeQuaternion(q: object): void;
+    allocVector3(): void;
+    freeVector3(v: object): void;
+    setIdentity(): void;
+    getBasis(t: object): object;
+    getBasisAsMatrix3(t: object): object;
+    getOrigin(t: object): object;
+    setOrigin(t: object, v: object): void;
+    copyOrigin(t1: object, t2: object): void;
+    setBasis(t: object, q: object): void;
+    setBasisFromMatrix3(t: object, m: object): void;
+    setOriginFromArray3(t: object, a: number[]): void;
+    setOriginFromThreeVector3(t: object, v: Vector3): void;
+    setBasisFromArray3(t: object, a: number[]): void;
+    setBasisFromThreeQuaternion(t: object, a: Quaternion): void;
+    multiplyTransforms(t1: object, t2: object): object;
+    inverseTransform(t: object): object;
+    multiplyMatrices3(m1: object, m2: object): object;
+    addVector3(v1: object, v2: object): object;
+    dotVectors3(v1: object, v2: object): number;
+    rowOfMatrix3(m: object, i: number): object;
+    columnOfMatrix3(m: object, i: number): object;
+    negativeVector3(v: object): object;
+    multiplyMatrix3ByVector3(m: object, v: object): object;
+    transposeMatrix3(m: object): object;
+    quaternionToMatrix3(q: object): object;
+    matrix3ToQuaternion(m: object): object;
+}
+
+export class RigidBody {
+    constructor(mesh: SkinnedMesh, world: object, params: object, manager: ResourceManager);
+    mesh: SkinnedMesh;
+    world: object;
+    params: object;
+    manager: ResourceManager;
+
+    body: object;
+    bone: Bone;
+    boneOffsetForm: object;
+    boneOffsetFormInverse: object;
+
+    reset(): this;
+    updateFromBone(): this;
+    updateBone(): this;
+}
+
+export class Constraint {
+    constructor(
+        mesh: SkinnedMesh,
+        world: object,
+        bodyA: RigidBody,
+        bodyB: RigidBody,
+        params: object,
+        manager: ResourceManager,
+    );
+
+    mesh: SkinnedMesh;
+    world: object;
+    bodyA: RigidBody;
+    bodyB: RigidBody;
+    params: object;
+    manager: ResourceManager;
+}
+
+export class MMDPhysicsHelper extends Object3D {
+    mesh: THREE.SkinnedMesh;
+    physics: MMDPhysics;
+    materials: [THREE.MeshBasicMaterial, THREE.MeshBasicMaterial, THREE.MeshBasicMaterial];
+
+    constructor(mesh: THREE.SkinnedMesh, physics: MMDPhysics);
+    dispose(): void;
+}

three/examples/jsm/cameras/CinematicCamera.d.ts

@@ -0,0 +1,41 @@
+import {
+    PerspectiveCamera,
+    ShaderMaterial,
+    Scene,
+    WebGLRenderer,
+    OrthographicCamera,
+    WebGLRenderTarget,
+} from '../../../src/Three.js';
+
+import { BokehShaderUniforms } from './../shaders/BokehShader2.js';
+
+export class CinematicCamera extends PerspectiveCamera {
+    constructor(fov: number, aspect: number, near: number, far: number);
+
+    postprocessing: {
+        enabled: boolean;
+        scene: Scene;
+        camera: OrthographicCamera;
+        rtTextureDepth: WebGLRenderTarget;
+        rtTextureColor: WebGLRenderTarget;
+        bokeh_uniforms: BokehShaderUniforms;
+    };
+    shaderSettings: {
+        rings: number;
+        samples: number;
+    };
+    materialDepth: ShaderMaterial;
+    coc: number;
+    aperture: number;
+    fNumber: number;
+    hyperFocal: number;
+    filmGauge: number;
+
+    linearize(depth: number): number;
+    smoothstep(near: number, far: number, depth: number): number;
+    saturate(x: number): number;
+    focusAt(focusDistance: number): void;
+    initPostProcessing(): void;
+    renderCinematic(scene: Scene, renderer: WebGLRenderer): void;
+    setLens(focalLength: number, frameHeight?: number, fNumber?: number, coc?: number): void;
+}

three/examples/jsm/capabilities/WebGL.d.ts

@@ -0,0 +1,9 @@
+// tslint:disable-next-line:no-unnecessary-class
+export default class WebGL {
+    static isWebGLAvailable(): boolean;
+    static isWebGL2Available(): boolean;
+    static isColorSpaceAvailable(colorSpace: PredefinedColorSpace): boolean;
+    static getWebGLErrorMessage(): HTMLElement;
+    static getWebGL2ErrorMessage(): HTMLElement;
+    static getErrorMessage(version: number): HTMLElement;
+}

three/examples/jsm/controls/FirstPersonControls.d.ts

@@ -0,0 +1,31 @@
+import { Camera, Vector3 } from '../../../src/Three.js';
+
+export class FirstPersonControls {
+    constructor(object: Camera, domElement?: HTMLElement);
+
+    object: Camera;
+    domElement: HTMLElement | Document;
+
+    enabled: boolean;
+    movementSpeed: number;
+    lookSpeed: number;
+    lookVertical: boolean;
+    autoForward: boolean;
+    activeLook: boolean;
+    heightSpeed: boolean;
+    heightCoef: number;
+    heightMin: number;
+    heightMax: number;
+    constrainVertical: boolean;
+    verticalMin: number;
+    verticalMax: number;
+    mouseDragOn: boolean;
+
+    handleResize(): void;
+
+    lookAt(x: Vector3): this;
+    lookAt(x: number, y: number, z: number): this;
+
+    update(delta: number): this;
+    dispose(): void;
+}

three/examples/jsm/controls/OrbitControls.d.ts

@@ -0,0 +1,286 @@
+import { Camera, EventDispatcher, MOUSE, TOUCH, Vector3 } from '../../../src/Three.js';
+
+export interface OrbitControlsEventMap {
+    change: {};
+    start: {};
+    end: {};
+}
+
+/**
+ * Orbit controls allow the camera to orbit around a target.
+ * @param object - The camera to be controlled. The camera must not
+ * be a child of another object, unless that object is the scene itself.
+ * @param domElement - The HTML element used for
+ * event listeners.
+ */
+export class OrbitControls extends EventDispatcher<OrbitControlsEventMap> {
+    constructor(object: Camera, domElement?: HTMLElement);
+
+    /**
+     * The camera being controlled.
+     */
+    object: Camera;
+
+    /**
+     * The HTMLElement used to listen for mouse / touch events.
+     * This must be passed in the constructor;
+     * changing it here will not set up new event listeners.
+     */
+    domElement: HTMLElement | Document;
+
+    /**
+     * When set to `false`, the controls will not respond to user input.
+     * @default true
+     */
+    enabled: boolean;
+
+    /**
+     * The focus point of the controls, the .object orbits around this.
+     * It can be updated manually at any point to change the focus
+     * of the controls.
+     */
+    target: Vector3;
+
+    /** @deprecated */
+    center: Vector3;
+
+    /**
+     * How far you can dolly in ( PerspectiveCamera only ).
+     * @default 0
+     */
+    minDistance: number;
+
+    /**
+     * How far you can dolly out ( PerspectiveCamera only ).
+     * @default Infinity
+     */
+    maxDistance: number;
+
+    /**
+     * How far you can zoom in ( OrthographicCamera only ).
+     * @default 0
+     */
+    minZoom: number;
+
+    /**
+     * How far you can zoom out ( OrthographicCamera only ).
+     * @default Infinity
+     */
+    maxZoom: number;
+
+    /**
+     * How far you can orbit vertically, lower limit.
+     * Range is 0 to Math.PI radians.
+     * @default 0
+     */
+    minPolarAngle: number;
+
+    /**
+     * How far you can orbit vertically, upper limit.
+     * Range is 0 to Math.PI radians.
+     * @default Math.PI.
+     */
+    maxPolarAngle: number;
+
+    /**
+     * How far you can orbit horizontally, lower limit.
+     * If set, the interval [ min, max ]
+     * must be a sub-interval of [ - 2 PI, 2 PI ],
+     * with ( max - min < 2 PI ).
+     * @default Infinity
+     */
+    minAzimuthAngle: number;
+
+    /**
+     * How far you can orbit horizontally, upper limit.
+     * If set, the interval [ min, max ] must be a sub-interval
+     * of [ - 2 PI, 2 PI ], with ( max - min < 2 PI ).
+     * @default Infinity
+     */
+    maxAzimuthAngle: number;
+
+    /**
+     * Set to true to enable damping (inertia), which can
+     * be used to give a sense of weight to the controls.
+     * Note that if this is enabled, you must call
+     * .update () in your animation loop.
+     * @default false
+     */
+    enableDamping: boolean;
+
+    /**
+     * The damping inertia used if .enableDamping is set to true.
+     * Note that for this to work,
+     * you must call .update () in your animation loop.
+     * @default 0.05
+     */
+    dampingFactor: number;
+
+    /**
+     * Enable or disable zooming (dollying) of the camera.
+     * @default true
+     */
+    enableZoom: boolean;
+
+    /**
+     * Speed of zooming / dollying.
+     * @default 1
+     */
+    zoomSpeed: number;
+
+    /**
+     * Setting this property to `true` allows to zoom to the cursor's position.
+     * @default false
+     */
+    zoomToCursor: boolean;
+
+    /**
+     * Enable or disable horizontal and
+     * vertical rotation of the camera.
+     * Note that it is possible to disable a single axis
+     * by setting the min and max of the polar angle or
+     * azimuth angle to the same value, which will cause
+     * the vertical or horizontal rotation to be fixed at that value.
+     * @default true
+     */
+    enableRotate: boolean;
+
+    /**
+     * Speed of rotation.
+     * @default 1
+     */
+    rotateSpeed: number;
+
+    /**
+     * Enable or disable camera panning.
+     * @default true
+     */
+    enablePan: boolean;
+
+    /**
+     * Speed of panning.
+     * @default 1
+     */
+    panSpeed: number;
+
+    /**
+     * Defines how the camera's position is translated when panning.
+     * If true, the camera pans in screen space. Otherwise,
+     * the camera pans in the plane orthogonal to the camera's
+     * up direction. Default is true for OrbitControls; false for MapControls.
+     * @default true
+     */
+    screenSpacePanning: boolean;
+
+    /**
+     * How fast to pan the camera when the keyboard is used.
+     * Default is 7.0 pixels per keypress.
+     * @default 7
+     */
+    keyPanSpeed: number;
+
+    /**
+     * Set to true to automatically rotate around the target.
+     * Note that if this is enabled, you must call .update() in your animation loop. If you want the auto-rotate speed
+     * to be independent of the frame rate (the refresh rate of the display), you must pass the time `deltaTime`, in
+     * seconds, to .update().
+     */
+    autoRotate: boolean;
+
+    /**
+     * How fast to rotate around the target if .autoRotate is true.
+     * Default is 2.0, which equates to 30 seconds per orbit at 60fps.
+     * Note that if .autoRotate is enabled, you must call
+     * .update () in your animation loop.
+     * @default 2
+     */
+    autoRotateSpeed: number;
+
+    /**
+     * This object contains references to the keycodes for controlling
+     * camera panning. Default is the 4 arrow keys.
+     */
+    keys: { LEFT: string; UP: string; RIGHT: string; BOTTOM: string };
+
+    /**
+     * This object contains references to the mouse actions used
+     * by the controls.
+     */
+    mouseButtons: {
+        LEFT?: MOUSE | null | undefined;
+        MIDDLE?: MOUSE | null | undefined;
+        RIGHT?: MOUSE | null | undefined;
+    };
+
+    /**
+     * This object contains references to the touch actions used by
+     * the controls.
+     */
+    touches: { ONE?: TOUCH | null | undefined; TWO?: TOUCH | null | undefined };
+
+    /**
+     * Used internally by the .saveState and .reset methods.
+     */
+    target0: Vector3;
+
+    /**
+     * Used internally by the .saveState and .reset methods.
+     */
+    position0: Vector3;
+
+    /**
+     * Used internally by the .saveState and .reset methods.
+     */
+    zoom0: number;
+
+    /**
+     * Update the controls. Must be called after any manual changes to the camera's transform, or in the update loop if
+     * .autoRotate or .enableDamping are set. `deltaTime`, in seconds, is optional, and is only required if you want the
+     * auto-rotate speed to be independent of the frame rate (the refresh rate of the display).
+     */
+    update(deltaTime?: number): boolean;
+
+    /**
+     * Adds key event listeners to the given DOM element. `window`
+     * is a recommended argument for using this method.
+     * @param domElement
+     */
+    listenToKeyEvents(domElement: HTMLElement | Window): void;
+
+    /**
+     * Removes the key event listener previously defined with {@link listenToKeyEvents}.
+     */
+    stopListenToKeyEvents(): void;
+
+    /**
+     * Save the current state of the controls. This can later be
+     * recovered with .reset.
+     */
+    saveState(): void;
+
+    /**
+     * Reset the controls to their state from either the last time
+     * the .saveState was called, or the initial state.
+     */
+    reset(): void;
+
+    /**
+     * Remove all the event listeners.
+     */
+    dispose(): void;
+
+    /**
+     * Get the current vertical rotation, in radians.
+     */
+    getPolarAngle(): number;
+
+    /**
+     * Get the current horizontal rotation, in radians.
+     */
+    getAzimuthalAngle(): number;
+
+    /**
+     * Returns the distance from the camera to the target.
+     */
+    getDistance(): number;
+}

three/examples/jsm/controls/TrackballControls.d.ts

@@ -0,0 +1,58 @@
+import { Camera, EventDispatcher, MOUSE, Vector3 } from '../../../src/Three.js';
+
+export interface TrackballControlsEventMap {
+    change: {};
+    start: {};
+    end: {};
+}
+
+export class TrackballControls extends EventDispatcher<TrackballControlsEventMap> {
+    constructor(object: Camera, domElement?: HTMLElement);
+
+    object: Camera;
+    domElement: HTMLElement;
+
+    // API
+    enabled: boolean;
+    screen: { left: number; top: number; width: number; height: number };
+    rotateSpeed: number;
+    zoomSpeed: number;
+    panSpeed: number;
+    noRotate: boolean;
+    noZoom: boolean;
+    noPan: boolean;
+    noRoll: boolean;
+    staticMoving: boolean;
+    dynamicDampingFactor: number;
+    minDistance: number;
+    maxDistance: number;
+    minZoom: number;
+    maxZoom: number;
+    keys: string[];
+    mouseButtons: {
+        LEFT?: MOUSE | null | undefined;
+        MIDDLE?: MOUSE | null | undefined;
+        RIGHT?: MOUSE | null | undefined;
+    };
+
+    target: Vector3;
+    position0: Vector3;
+    target0: Vector3;
+    up0: Vector3;
+
+    update(): void;
+
+    reset(): void;
+
+    dispose(): void;
+
+    checkDistances(): void;
+
+    zoomCamera(): void;
+
+    panCamera(): void;
+
+    rotateCamera(): void;
+
+    handleResize(): void;
+}