@types/three 0.167.2 → 0.168.0

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

@@ -1,49 +1,32 @@
-import { Camera, EventDispatcher, MOUSE, TOUCH, Vector3 } from "three";
+import { Camera, Controls, MOUSE, TOUCH, Vector3 } from "three";
 
 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.
+     * Fires when the camera has been transformed by the controls.
      */
-    object: Camera;
+    change: {};
 
     /**
-     * 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.
+     * Fires when an interaction was initiated.
      */
-    domElement: HTMLElement | Document;
+    start: {};
 
     /**
-     * When set to `false`, the controls will not respond to user input.
-     * @default true
+     * Fires when an interaction has finished.
      */
-    enabled: boolean;
+    end: {};
+}
 
+/**
+ * Orbit controls allow the camera to orbit around a target.
+ */
+declare class OrbitControls extends Controls<OrbitControlsEventMap> {
     /**
-     * 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.
+     * The focus point of the controls, the {@link .object} orbits around this. It can be updated manually at any point
+     * to change the focus of the controls.
      */
     target: Vector3;
 
-    /** @deprecated */
-    center: Vector3;
-
     /**
      * The focus point of the {@link .minTargetRadius} and {@link .maxTargetRadius} limits. It can be updated manually
      * at any point to change the center of interest for the {@link .target}.
@@ -51,178 +34,141 @@ export class OrbitControls extends EventDispatcher<OrbitControlsEventMap> {
     cursor: Vector3;
 
     /**
-     * How far you can dolly in ( PerspectiveCamera only ).
-     * @default 0
+     * How far you can dolly in ( {@link PerspectiveCamera} only ). Default is 0.
      */
     minDistance: number;
 
     /**
-     * How far you can dolly out ( PerspectiveCamera only ).
-     * @default Infinity
+     * How far you can dolly out ( {@link PerspectiveCamera} only ). Default is Infinity.
      */
     maxDistance: number;
 
     /**
-     * How far you can zoom in ( OrthographicCamera only ).
-     * @default 0
+     * How far you can zoom in ( {@link OrthographicCamera} only ). Default is 0.
      */
     minZoom: number;
 
     /**
-     * How far you can zoom out ( OrthographicCamera only ).
-     * @default Infinity
+     * How far you can zoom out ( {@link OrthographicCamera} only ). Default is Infinity.
      */
     maxZoom: number;
 
     /**
-     * How close you can get the target to the 3D {@link .cursor}.
-     * @default 0
+     * How close you can get the target to the 3D {@link .cursor}. Default is 0.
      */
     minTargetRadius: number;
 
     /**
-     * How far you can move the target from the 3D {@link .cursor}.
-     * @default Infinity
+     * How far you can move the target from the 3D {@link .cursor}. Default is Infinity.
      */
     maxTargetRadius: number;
 
     /**
-     * How far you can orbit vertically, lower limit.
-     * Range is 0 to Math.PI radians.
-     * @default 0
+     * How far you can orbit vertically, lower limit. Range is 0 to Math.PI radians, and default is 0.
      */
     minPolarAngle: number;
 
     /**
-     * How far you can orbit vertically, upper limit.
-     * Range is 0 to Math.PI radians.
-     * @default Math.PI.
+     * How far you can orbit vertically, upper limit. Range is 0 to Math.PI radians, and default is 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
+     * 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 is 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
+     * 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 is 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
+     * Set to true to enable damping (inertia), which can be used to give a sense of weight to the controls. Default is
+     * false.
+     * Note that if this is enabled, you must call {@link .update}() in your animation loop.
      */
     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
+     * The damping inertia used if .enableDamping is set to true. Default is `0.05`.
+     * Note that for this to work, you must call {@link .update}() in your animation loop.
      */
     dampingFactor: number;
 
     /**
      * Enable or disable zooming (dollying) of the camera.
-     * @default true
      */
     enableZoom: boolean;
 
     /**
-     * Speed of zooming / dollying.
-     * @default 1
+     * Speed of zooming / dollying. Default is 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
+     * Enable or disable horizontal and vertical rotation of the camera. Default is true.
+     * Note that it is possible to disable a single axis by setting the min and max of the
+     * [polar angle]{@link .minPolarAngle} or [azimuth angle]{@link .minAzimuthAngle} to the same value, which will
+     * cause the vertical or horizontal rotation to be fixed at that value.
      */
     enableRotate: boolean;
 
     /**
-     * Speed of rotation.
-     * @default 1
+     * Speed of rotation. Default is 1.
      */
     rotateSpeed: number;
 
     /**
-     * Enable or disable camera panning.
-     * @default true
+     * Enable or disable camera panning. Default is true.
      */
     enablePan: boolean;
 
     /**
-     * Speed of panning.
-     * @default 1
+     * Speed of panning. Default is 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
+     * 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`.
      */
     screenSpacePanning: boolean;
 
     /**
-     * How fast to pan the camera when the keyboard is used.
-     * Default is 7.0 pixels per keypress.
-     * @default 7
+     * How fast to pan the camera when the keyboard is used. Default is 7.0 pixels per keypress.
      */
     keyPanSpeed: number;
 
+    /**
+     * Setting this property to `true` allows to zoom to the cursor's position. Default is `false`.
+     */
+    zoomToCursor: boolean;
+
     /**
      * 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
+     * Note that if this is enabled, you must call {@link .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().
+     * seconds, to {@link .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
+     * How fast to rotate around the target if {@link .autoRotate} is true. Default is 2.0, which equates to 30 seconds
+     * per orbit at 60fps.
+     * Note that if {@link .autoRotate} is enabled, you must call {@link .update}() in your animation loop.
      */
     autoRotateSpeed: number;
 
     /**
-     * This object contains references to the keycodes for controlling
-     * camera panning. Default is the 4 arrow keys.
+     * 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.
+     * This object contains references to the mouse actions used by the controls.
      */
     mouseButtons: {
         LEFT?: MOUSE | null | undefined;
@@ -231,74 +177,75 @@ export class OrbitControls extends EventDispatcher<OrbitControlsEventMap> {
     };
 
     /**
-     * This object contains references to the touch actions used by
-     * the controls.
+     * 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.
+     * Used internally by the {@link .saveState} and {@link .reset} methods.
      */
     target0: Vector3;
 
     /**
-     * Used internally by the .saveState and .reset methods.
+     * Used internally by the {@link .saveState} and {@link .reset} methods.
      */
     position0: Vector3;
 
     /**
-     * Used internally by the .saveState and .reset methods.
+     * Used internally by the {@link .saveState} and {@link .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).
+     * @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. (optional)
      */
-    update(deltaTime?: number): boolean;
+    constructor(object: Camera, domElement?: HTMLElement | null);
 
     /**
-     * Adds key event listeners to the given DOM element. `window`
-     * is a recommended argument for using this method.
-     * @param domElement
+     * Get the current vertical rotation, in radians.
      */
-    listenToKeyEvents(domElement: HTMLElement | Window): void;
+    getPolarAngle(): number;
 
     /**
-     * Removes the key event listener previously defined with {@link listenToKeyEvents}.
+     * Get the current horizontal rotation, in radians.
      */
-    stopListenToKeyEvents(): void;
+    getAzimuthalAngle(): number;
 
     /**
-     * Save the current state of the controls. This can later be
-     * recovered with .reset.
+     * Returns the distance from the camera to the target.
      */
-    saveState(): void;
+    getDistance(): number;
 
     /**
-     * Reset the controls to their state from either the last time
-     * the .saveState was called, or the initial state.
+     * Adds key event listeners to the given DOM element. `window` is a recommended argument for using this method.
+     * @param domElement
      */
-    reset(): void;
+    listenToKeyEvents(domElement: HTMLElement | Window): void;
 
     /**
-     * Remove all the event listeners.
+     * Removes the key event listener previously defined with {@link .listenToKeyEvents}().
      */
-    dispose(): void;
+    stopListenToKeyEvents(): void;
 
     /**
-     * Get the current vertical rotation, in radians.
+     * Save the current state of the controls. This can later be recovered with {@link .reset}.
      */
-    getPolarAngle(): number;
+    saveState(): void;
 
     /**
-     * Get the current horizontal rotation, in radians.
+     * Reset the controls to their state from either the last time the {@link .saveState} was called, or the initial
+     * state.
      */
-    getAzimuthalAngle(): number;
+    reset(): void;
 
     /**
-     * Returns the distance from the camera to the target.
+     * Update the controls. Must be called after any manual changes to the camera's transform, or in the update loop if
+     * {@link .autoRotate} or {@link .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).
      */
-    getDistance(): number;
+    update(deltaTime?: number | null): boolean;
 }
+
+export { OrbitControls };

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

@@ -1,27 +1,86 @@
-import { Camera, EventDispatcher, Vector3 } from "three";
+import { Camera, Controls, Vector3 } from "three";
 
-export class PointerLockControls extends EventDispatcher {
-    constructor(camera: Camera, domElement?: HTMLElement);
+export interface PointerLockControlsEventMap {
+    /**
+     * Fires when the user moves the mouse.
+     */
+    change: {};
 
-    camera: Camera;
-    domElement: HTMLElement;
+    /**
+     * Fires when the pointer lock status is "locked" (in other words: the mouse is captured).
+     */
+    lock: {};
 
-    // API
+    /**
+     * Fires when the pointer lock status is "unlocked" (in other words: the mouse is not captured anymore).
+     */
+    unlock: {};
+}
 
+/**
+ * The implementation of this class is based on the [Pointer Lock API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Pointer_Lock_API}.
+ * {@link PointerLockControls} is a perfect choice for first person 3D games.
+ */
+declare class PointerLockControls extends Controls<PointerLockControlsEventMap> {
+    /**
+     * Whether or not the controls are locked.
+     */
     isLocked: boolean;
 
+    /**
+     * Camera pitch, lower limit. Range is 0 to Math.PI radians. Default is 0.
+     */
     minPolarAngle: number;
+
+    /**
+     * Camera pitch, upper limit. Range is 0 to Math.PI radians. Default is Math.PI.
+     */
     maxPolarAngle: number;
 
+    /**
+     * Multiplier for how much the pointer movement influences the camera rotation. Default is 1.
+     */
     pointerSpeed: number;
 
-    connect(): void;
-    disconnect(): void;
-    dispose(): void;
+    /**
+     * Creates a new instance of {@link PointerLockControls}.
+     * @param camera The camera of the rendered scene.
+     * @param domElement The HTML element used for event listeners.
+     */
+    constructor(camera: Camera, domElement?: HTMLElement | null);
+
+    /**
+     * @deprecated getObject() has been deprecated. Use controls.object instead.
+     */
     getObject(): Camera;
+
+    /**
+     * Returns the look direction of the camera.
+     * @param v The target vector.
+     */
     getDirection(v: Vector3): Vector3;
+
+    /**
+     * Moves the camera forward parallel to the xz-plane. Assumes camera.up is y-up.
+     * @param distance The signed distance.
+     */
     moveForward(distance: number): void;
+
+    /**
+     * Moves the camera sidewards parallel to the xz-plane.
+     * @param distance The signed distance.
+     */
     moveRight(distance: number): void;
+
+    /**
+     * Activates the pointer lock.
+     */
     lock(): void;
+
+    /**
+     * Exits the pointer lock.
+     */
     unlock(): void;
 }
+
+export { PointerLockControls };

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

@@ -1,58 +1,142 @@
-import { Camera, EventDispatcher, MOUSE, Vector3 } from "three";
+import { Camera, Controls, MOUSE, Vector3 } from "three";
 
 export interface TrackballControlsEventMap {
+    /**
+     * Fires when the camera has been transformed by the controls.
+     */
     change: {};
+
+    /**
+     * Fires when an interaction (e.g. touch) was initiated.
+     */
     start: {};
+
+    /**
+     * Fires when an interaction has finished.
+     */
     end: {};
 }
 
-export class TrackballControls extends EventDispatcher<TrackballControlsEventMap> {
-    constructor(object: Camera, domElement?: HTMLElement);
-
-    object: Camera;
-    domElement: HTMLElement;
-
-    // API
-    enabled: boolean;
+/**
+ * TrackballControls is similar to {@link OrbitControls}. However, it does not maintain a constant camera
+ * [up]{@link Object3D.up} vector. That means if the camera orbits over the “north” and “south” poles, it does not flip
+ * to stay "right side up".
+ */
+declare class TrackballControls extends Controls<TrackballControlsEventMap> {
+    /**
+     * Represents the properties of the screen. Automatically set when {@link .handleResize}() is called.
+     *  - left: Represents the offset in pixels to the screen's left boundary.
+     *  - top: Represents the offset in pixels to the screen's top boundary.
+     *  - width: Represents the screen width in pixels.
+     *  - height: Represents the screen height in pixels.
+     */
     screen: { left: number; top: number; width: number; height: number };
+
+    /**
+     * The rotation speed. Default is `1.0`.
+     */
     rotateSpeed: number;
+
+    /**
+     * The zoom speed. Default is `1.2`.
+     */
     zoomSpeed: number;
+
+    /**
+     * The pan speed. Default is `0.3`.
+     */
     panSpeed: number;
+
+    /**
+     * Whether or not rotation is disabled. Default is `false`.
+     */
     noRotate: boolean;
+
+    /**
+     * Whether or not zooming is disabled. Default is `false`.
+     */
     noZoom: boolean;
+
+    /**
+     * Whether or not panning is disabled. Default is `false`.
+     */
     noPan: boolean;
-    noRoll: boolean;
+
+    /**
+     * Whether or not damping is disabled. Default is `false`.
+     */
     staticMoving: boolean;
+
+    /**
+     * Defines the intensity of damping. Only considered if {@link .staticMoving} is set to `false`. Default is `0.2`.
+     */
     dynamicDampingFactor: number;
+
+    /**
+     * How far you can dolly in ( {@link PerspectiveCamera} only ). Default is *0*.
+     */
     minDistance: number;
+
+    /**
+     * How far you can dolly out ( {@link PerspectiveCamera} only ). Default is `Infinity`.
+     */
     maxDistance: number;
+
+    /**
+     * How far you can zoom out ( {@link OrthographicCamera} only ). Default is `Infinity`.
+     */
     minZoom: number;
+
+    /**
+     * How far you can zoom in ( {@link OrthographicCamera} only ). Default is *0*.
+     */
     maxZoom: number;
-    keys: string[];
+
+    /**
+     * This array holds keycodes for controlling interactions.
+     *  - When the first defined key is pressed, all mouse interactions (left, middle, right) performs orbiting.
+     *  - When the second defined key is pressed, all mouse interactions (left, middle, right) performs zooming.
+     *  - When the third defined key is pressed, all mouse interactions (left, middle, right) performs panning.
+     *
+     * Default is *KeyA, KeyS, KeyD* which represents A, S, D.
+     */
+    keys: [string, string, string];
+
+    /**
+     * This object contains references to the mouse actions used by the controls.
+     *  - .LEFT is assigned with `THREE.MOUSE.ROTATE`
+     *  - .MIDDLE is assigned with `THREE.MOUSE.ZOOM`
+     *  - .RIGHT is assigned with `THREE.MOUSE.PAN`
+     */
     mouseButtons: {
         LEFT?: MOUSE | null | undefined;
         MIDDLE?: MOUSE | null | undefined;
         RIGHT?: MOUSE | null | undefined;
     };
 
+    /**
+     * The focus point of the controls.
+     */
     target: Vector3;
-    position0: Vector3;
-    target0: Vector3;
-    up0: Vector3;
-
-    update(): void;
-
-    reset(): void;
 
-    dispose(): void;
+    /**
+     * Creates a new instance of TrackballControls.
+     * @param camera The camera of the rendered scene.
+     * @param domElement The HTML element used for event listeners. (optional)
+     */
+    constructor(camera: Camera, domElement?: HTMLElement | null);
 
-    checkDistances(): void;
-
-    zoomCamera(): void;
-
-    panCamera(): void;
+    /**
+     * Should be called if the application window is resized.
+     */
+    handleResize(): void;
 
-    rotateCamera(): void;
+    update(): void;
 
-    handleResize(): void;
+    /**
+     * Resets the controls to its initial state.
+     */
+    reset(): void;
 }
+
+export { TrackballControls };

three/examples/jsm/effects/AnaglyphEffect.d.ts

@@ -1,11 +1,17 @@
 import { Camera, Matrix3, Scene, WebGLRenderer } from "three";
 
-export class AnaglyphEffect {
-    constructor(renderer: WebGLRenderer, width?: number, height?: number);
+declare class AnaglyphEffect {
     colorMatrixLeft: Matrix3;
+
     colorMatrixRight: Matrix3;
 
-    dispose(): void;
-    render(scene: Scene, camera: Camera): void;
-    setSize(width: number, height: number): void;
+    setSize: (width: number, height: number) => void;
+
+    render: (scene: Scene, camera: Camera) => void;
+
+    dispose: () => void;
+
+    constructor(renderer: WebGLRenderer, width?: number, height?: number);
 }
+
+export { AnaglyphEffect };