three-stdlib 2.35.7 → 2.35.9

package/controls/OrbitControls.d.cts

@@ -0,0 +1,74 @@
+import type { MOUSE, OrthographicCamera, PerspectiveCamera, TOUCH, Vector3 } from 'three';
+import type { EventDispatcher } from './EventDispatcher.d.cts';
+import type { StandardControlsEventMap } from './StandardControlsEventMap.d.cts';
+declare class OrbitControls extends EventDispatcher<StandardControlsEventMap> {
+    object: PerspectiveCamera | OrthographicCamera;
+    domElement: HTMLElement | undefined;
+    enabled: boolean;
+    target: Vector3;
+    minDistance: number;
+    maxDistance: number;
+    minZoom: number;
+    maxZoom: number;
+    minPolarAngle: number;
+    maxPolarAngle: number;
+    minAzimuthAngle: number;
+    maxAzimuthAngle: number;
+    enableDamping: boolean;
+    dampingFactor: number;
+    enableZoom: boolean;
+    zoomSpeed: number;
+    enableRotate: boolean;
+    rotateSpeed: number;
+    enablePan: boolean;
+    panSpeed: number;
+    screenSpacePanning: boolean;
+    keyPanSpeed: number;
+    zoomToCursor: boolean;
+    autoRotate: boolean;
+    autoRotateSpeed: number;
+    reverseOrbit: boolean;
+    reverseHorizontalOrbit: boolean;
+    reverseVerticalOrbit: boolean;
+    keys: {
+        LEFT: string;
+        UP: string;
+        RIGHT: string;
+        BOTTOM: string;
+    };
+    mouseButtons: Partial<{
+        LEFT: MOUSE;
+        MIDDLE: MOUSE;
+        RIGHT: MOUSE;
+    }>;
+    touches: Partial<{
+        ONE: TOUCH;
+        TWO: TOUCH;
+    }>;
+    target0: Vector3;
+    position0: Vector3;
+    zoom0: number;
+    _domElementKeyEvents: any;
+    getPolarAngle: () => number;
+    getAzimuthalAngle: () => number;
+    setPolarAngle: (x: number) => void;
+    setAzimuthalAngle: (x: number) => void;
+    getDistance: () => number;
+    getZoomScale: () => number;
+    listenToKeyEvents: (domElement: HTMLElement) => void;
+    stopListenToKeyEvents: () => void;
+    saveState: () => void;
+    reset: () => void;
+    update: () => void;
+    connect: (domElement: HTMLElement) => void;
+    dispose: () => void;
+    dollyIn: (dollyScale?: number) => void;
+    dollyOut: (dollyScale?: number) => void;
+    getScale: () => number;
+    setScale: (newScale: number) => void;
+    constructor(object: PerspectiveCamera | OrthographicCamera, domElement?: HTMLElement);
+}
+declare class MapControls extends OrbitControls {
+    constructor(object: PerspectiveCamera | OrthographicCamera, domElement?: HTMLElement);
+}
+export type { OrbitControls, MapControls };

package/controls/OrbitControls.d.ts

@@ -1,6 +1,6 @@
-import { MOUSE, OrthographicCamera, PerspectiveCamera, TOUCH, Vector3 } from 'three';
-import { EventDispatcher } from './EventDispatcher';
-import { StandardControlsEventMap } from './StandardControlsEventMap';
+import type { MOUSE, OrthographicCamera, PerspectiveCamera, TOUCH, Vector3 } from 'three';
+import type { EventDispatcher } from './EventDispatcher.d.ts';
+import type { StandardControlsEventMap } from './StandardControlsEventMap.d.ts';
 declare class OrbitControls extends EventDispatcher<StandardControlsEventMap> {
     object: PerspectiveCamera | OrthographicCamera;
     domElement: HTMLElement | undefined;
@@ -71,4 +71,4 @@ declare class OrbitControls extends EventDispatcher<StandardControlsEventMap> {
 declare class MapControls extends OrbitControls {
     constructor(object: PerspectiveCamera | OrthographicCamera, domElement?: HTMLElement);
 }
-export { OrbitControls, MapControls };
+export type { OrbitControls, MapControls };

package/controls/PointerLockControls.d.cts

@@ -0,0 +1,39 @@
+import type { Camera, Vector3 } from 'three';
+import type { EventDispatcher } from './EventDispatcher.d.cts';
+export interface PointerLockControlsEventMap {
+    /**
+     * Fires when the user moves the mouse.
+     */
+    change: {};
+    /**
+     * Fires when the pointer lock status is "locked" (in other words: the mouse is captured).
+     */
+    lock: {};
+    /**
+     * Fires when the pointer lock status is "unlocked" (in other words: the mouse is not captured anymore).
+     */
+    unlock: {};
+}
+declare class PointerLockControls extends EventDispatcher<PointerLockControlsEventMap> {
+    camera: Camera;
+    domElement?: HTMLElement;
+    isLocked: boolean;
+    minPolarAngle: number;
+    maxPolarAngle: number;
+    pointerSpeed: number;
+    constructor(camera: Camera, domElement?: HTMLElement);
+    private onMouseMove;
+    private onPointerlockChange;
+    private onPointerlockError;
+    connect: (domElement: HTMLElement) => void;
+    disconnect: () => void;
+    dispose: () => void;
+    getObject: () => Camera;
+    private direction;
+    getDirection: (v: Vector3) => Vector3;
+    moveForward: (distance: number) => void;
+    moveRight: (distance: number) => void;
+    lock: () => void;
+    unlock: () => void;
+}
+export type { PointerLockControls };

package/controls/PointerLockControls.d.ts

@@ -1,5 +1,5 @@
-import { Camera, Vector3 } from 'three';
-import { EventDispatcher } from './EventDispatcher';
+import type { Camera, Vector3 } from 'three';
+import type { EventDispatcher } from './EventDispatcher.d.ts';
 export interface PointerLockControlsEventMap {
     /**
      * Fires when the user moves the mouse.
@@ -36,4 +36,4 @@ declare class PointerLockControls extends EventDispatcher<PointerLockControlsEve
     lock: () => void;
     unlock: () => void;
 }
-export { PointerLockControls };
+export type { PointerLockControls };

package/controls/StandardControlsEventMap.d.cts

@@ -0,0 +1,14 @@
+export interface StandardControlsEventMap {
+    /**
+     * Fires when the camera has been transformed by the controls.
+     */
+    change: {};
+    /**
+     * Fires when an interaction was initiated.
+     */
+    start: {};
+    /**
+     * Fires when an interaction has finished.
+     */
+    end: {};
+}

package/controls/TrackballControls.d.cts

@@ -0,0 +1,97 @@
+import type { MOUSE, Vector3, PerspectiveCamera, OrthographicCamera } from 'three';
+import type { EventDispatcher } from './EventDispatcher.d.cts';
+import type { StandardControlsEventMap } from './StandardControlsEventMap.d.cts';
+declare class TrackballControls extends EventDispatcher<StandardControlsEventMap> {
+    enabled: boolean;
+    screen: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    rotateSpeed: number;
+    zoomSpeed: number;
+    panSpeed: number;
+    noRotate: boolean;
+    noZoom: boolean;
+    noPan: boolean;
+    staticMoving: boolean;
+    dynamicDampingFactor: number;
+    minDistance: number;
+    maxDistance: number;
+    keys: [string, string, string];
+    mouseButtons: {
+        LEFT: MOUSE;
+        MIDDLE: MOUSE;
+        RIGHT: MOUSE;
+    };
+    object: PerspectiveCamera | OrthographicCamera;
+    domElement: HTMLElement | undefined;
+    cursorZoom: boolean;
+    readonly target: Vector3;
+    private mousePosition;
+    private STATE;
+    private EPS;
+    private lastZoom;
+    private lastPosition;
+    private cursorVector;
+    private targetVector;
+    private _state;
+    private _keyState;
+    private _eye;
+    private _movePrev;
+    private _moveCurr;
+    private _lastAxis;
+    private _lastAngle;
+    private _zoomStart;
+    private _zoomEnd;
+    private _touchZoomDistanceStart;
+    private _touchZoomDistanceEnd;
+    private _panStart;
+    private _panEnd;
+    private target0;
+    private position0;
+    private up0;
+    private zoom0;
+    private changeEvent;
+    private startEvent;
+    private endEvent;
+    constructor(object: PerspectiveCamera | OrthographicCamera, domElement?: HTMLElement);
+    private onScreenVector;
+    private getMouseOnScreen;
+    private onCircleVector;
+    private getMouseOnCircle;
+    private axis;
+    private quaternion;
+    private eyeDirection;
+    private objectUpDirection;
+    private objectSidewaysDirection;
+    private moveDirection;
+    private angle;
+    private rotateCamera;
+    private zoomCamera;
+    private mouseChange;
+    private objectUp;
+    private pan;
+    private panCamera;
+    private checkDistances;
+    handleResize: () => void;
+    update: () => void;
+    reset: () => void;
+    private keydown;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    private keyup;
+    private onMouseDown;
+    private onMouseMove;
+    private onMouseUp;
+    private mousewheel;
+    private touchstart;
+    private touchmove;
+    private touchend;
+    private contextmenu;
+    connect: (domElement: HTMLElement) => void;
+    dispose: () => void;
+}
+export type { TrackballControls };

package/controls/TrackballControls.d.ts

@@ -1,6 +1,6 @@
-import { MOUSE, Vector3, PerspectiveCamera, OrthographicCamera } from 'three';
-import { EventDispatcher } from './EventDispatcher';
-import { StandardControlsEventMap } from './StandardControlsEventMap';
+import type { MOUSE, Vector3, PerspectiveCamera, OrthographicCamera } from 'three';
+import type { EventDispatcher } from './EventDispatcher.d.ts';
+import type { StandardControlsEventMap } from './StandardControlsEventMap.d.ts';
 declare class TrackballControls extends EventDispatcher<StandardControlsEventMap> {
     enabled: boolean;
     screen: {
@@ -94,4 +94,4 @@ declare class TrackballControls extends EventDispatcher<StandardControlsEventMap
     connect: (domElement: HTMLElement) => void;
     dispose: () => void;
 }
-export { TrackballControls };
+export type { TrackballControls };

package/controls/TransformControls.d.cts

@@ -0,0 +1,151 @@
+import type { Mesh, MeshBasicMaterial, Object3D, PlaneGeometry, Camera } from 'three';
+export interface TransformControlsPointerObject {
+    x: number;
+    y: number;
+    button: number;
+}
+declare class TransformControls<TCamera extends Camera = Camera> extends Object3D {
+    readonly isTransformControls = true;
+    visible: boolean;
+    private domElement;
+    private raycaster;
+    private gizmo;
+    private plane;
+    private tempVector;
+    private tempVector2;
+    private tempQuaternion;
+    private unit;
+    private pointStart;
+    private pointEnd;
+    private offset;
+    private rotationAxis;
+    private startNorm;
+    private endNorm;
+    private rotationAngle;
+    private cameraPosition;
+    private cameraQuaternion;
+    private cameraScale;
+    private parentPosition;
+    private parentQuaternion;
+    private parentQuaternionInv;
+    private parentScale;
+    private worldPositionStart;
+    private worldQuaternionStart;
+    private worldScaleStart;
+    private worldPosition;
+    private worldQuaternion;
+    private worldQuaternionInv;
+    private worldScale;
+    private eye;
+    private positionStart;
+    private quaternionStart;
+    private scaleStart;
+    private camera;
+    private object;
+    private enabled;
+    private axis;
+    private mode;
+    private translationSnap;
+    private rotationSnap;
+    private scaleSnap;
+    private space;
+    private size;
+    private dragging;
+    private showX;
+    private showY;
+    private showZ;
+    private changeEvent;
+    private mouseDownEvent;
+    private mouseUpEvent;
+    private objectChangeEvent;
+    constructor(camera: TCamera, domElement: HTMLElement | undefined);
+    private intersectObjectWithRay;
+    attach: (object: Object3D) => this;
+    detach: () => this;
+    reset: () => this;
+    updateMatrixWorld: () => void;
+    private pointerHover;
+    private pointerDown;
+    private pointerMove;
+    private pointerUp;
+    private getPointer;
+    private onPointerHover;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    getMode: () => TransformControls['mode'];
+    setMode: (mode: TransformControls['mode']) => void;
+    setTranslationSnap: (translationSnap: number) => void;
+    setRotationSnap: (rotationSnap: number) => void;
+    setScaleSnap: (scaleSnap: number) => void;
+    setSize: (size: number) => void;
+    setSpace: (space: string) => void;
+    update: () => void;
+    connect: (domElement: HTMLElement) => void;
+    dispose: () => void;
+}
+type TransformControlsGizmoPrivateGizmos = {
+    ['translate']: Object3D;
+    ['scale']: Object3D;
+    ['rotate']: Object3D;
+    ['visible']: boolean;
+};
+declare class TransformControlsGizmo extends Object3D {
+    private isTransformControlsGizmo;
+    type: string;
+    private tempVector;
+    private tempEuler;
+    private alignVector;
+    private zeroVector;
+    private lookAtMatrix;
+    private tempQuaternion;
+    private tempQuaternion2;
+    private identityQuaternion;
+    private unitX;
+    private unitY;
+    private unitZ;
+    private gizmo;
+    picker: TransformControlsGizmoPrivateGizmos;
+    private helper;
+    private rotationAxis;
+    private cameraPosition;
+    private worldPositionStart;
+    private worldQuaternionStart;
+    private worldPosition;
+    private worldQuaternion;
+    private eye;
+    private camera;
+    private enabled;
+    private axis;
+    private mode;
+    private space;
+    private size;
+    private dragging;
+    private showX;
+    private showY;
+    private showZ;
+    constructor();
+    updateMatrixWorld: () => void;
+}
+declare class TransformControlsPlane extends Mesh<PlaneGeometry, MeshBasicMaterial> {
+    private isTransformControlsPlane;
+    type: string;
+    constructor();
+    private unitX;
+    private unitY;
+    private unitZ;
+    private tempVector;
+    private dirVector;
+    private alignVector;
+    private tempMatrix;
+    private identityQuaternion;
+    private cameraQuaternion;
+    private worldPosition;
+    private worldQuaternion;
+    private eye;
+    private axis;
+    private mode;
+    private space;
+    updateMatrixWorld: () => void;
+}
+export type { TransformControls, TransformControlsGizmo, TransformControlsPlane };

package/controls/TransformControls.d.ts

@@ -1,4 +1,4 @@
-import { Mesh, MeshBasicMaterial, Object3D, PlaneGeometry, Camera } from 'three';
+import type { Mesh, MeshBasicMaterial, Object3D, PlaneGeometry, Camera } from 'three';
 export interface TransformControlsPointerObject {
     x: number;
     y: number;
@@ -148,4 +148,4 @@ declare class TransformControlsPlane extends Mesh<PlaneGeometry, MeshBasicMateri
     private space;
     updateMatrixWorld: () => void;
 }
-export { TransformControls, TransformControlsGizmo, TransformControlsPlane };
+export type { TransformControls, TransformControlsGizmo, TransformControlsPlane };

package/controls/experimental/CameraControls.d.cts

@@ -0,0 +1,213 @@
+import type { MOUSE, OrthographicCamera, PerspectiveCamera, Quaternion, Spherical, TOUCH, Vector3 } from 'three';
+import type { EventDispatcher } from '../EventDispatcher.d.cts';
+export type CHANGE_EVENT = {
+    type: 'change' | 'start' | 'end';
+};
+export type declare const STATE: {
+    NONE: number;
+    ROTATE: number;
+    DOLLY: number;
+    PAN: number;
+    TOUCH_ROTATE: number;
+    TOUCH_PAN: number;
+    TOUCH_DOLLY_PAN: number;
+    TOUCH_DOLLY_ROTATE: number;
+};
+declare class CameraControls extends EventDispatcher<Record<string, {}>> {
+    object: PerspectiveCamera | OrthographicCamera;
+    domElement: HTMLElement;
+    /** Set to false to disable this control */
+    enabled: boolean;
+    /** "target" sets the location of focus, where the object orbits around */
+    target: Vector3;
+    /** Set to true to enable trackball behavior */
+    trackball: boolean;
+    /** How far you can dolly in ( PerspectiveCamera only ) */
+    minDistance: number;
+    /** How far you can dolly out ( PerspectiveCamera only ) */
+    maxDistance: number;
+    minZoom: number;
+    maxZoom: number;
+    minPolarAngle: number;
+    maxPolarAngle: number;
+    minAzimuthAngle: number;
+    maxAzimuthAngle: number;
+    enableDamping: boolean;
+    dampingFactor: number;
+    /**
+     * This option enables dollying in and out; property named as "zoom" for backwards compatibility
+     * Set to false to disable zooming
+     */
+    enableZoom: boolean;
+    zoomSpeed: number;
+    /** Set to false to disable rotating */
+    enableRotate: boolean;
+    rotateSpeed: number;
+    /** Set to false to disable panning */
+    enablePan: boolean;
+    panSpeed: number;
+    /** if true, pan in screen-space */
+    screenSpacePanning: boolean;
+    /** pixels moved per arrow key push */
+    keyPanSpeed: number;
+    /**
+     * Set to true to automatically rotate around the target
+     * If auto-rotate is enabled, you must call controls.update() in your animation loop
+     * auto-rotate is not supported for trackball behavior
+     */
+    autoRotate: boolean;
+    autoRotateSpeed: number;
+    /** Set to false to disable use of the keys */
+    enableKeys: boolean;
+    /** The four arrow keys */
+    keys: {
+        LEFT: string;
+        UP: string;
+        RIGHT: string;
+        BOTTOM: string;
+    };
+    mouseButtons: {
+        LEFT: MOUSE;
+        MIDDLE?: MOUSE;
+        RIGHT: MOUSE;
+    };
+    /** Touch fingers */
+    touches: {
+        ONE: TOUCH;
+        TWO: TOUCH;
+    };
+    target0: Vector3;
+    position0: Vector3;
+    quaternion0: Quaternion;
+    zoom0: number;
+    spherical: Spherical;
+    sphericalDelta: Spherical;
+    private changeEvent;
+    private startEvent;
+    private endEvent;
+    private state;
+    private EPS;
+    private scale;
+    private panOffset;
+    private zoomChanged;
+    private rotateStart;
+    private rotateEnd;
+    private rotateDelta;
+    private panStart;
+    private panEnd;
+    private panDelta;
+    private dollyStart;
+    private dollyEnd;
+    private dollyDelta;
+    private offset;
+    private lastPosition;
+    private lastQuaternion;
+    private q;
+    private v;
+    private vec;
+    private quat;
+    private quatInverse;
+    constructor(object: PerspectiveCamera | OrthographicCamera, domElement: HTMLElement);
+    getPolarAngle: () => number;
+    getAzimuthalAngle: () => number;
+    saveState: () => void;
+    reset: () => void;
+    dispose: () => void;
+    private update;
+    private getAutoRotationAngle;
+    private getZoomScale;
+    private rotateLeft;
+    private rotateUp;
+    private panLeft;
+    private panUp;
+    private pan;
+    private dollyIn;
+    private dollyOut;
+    private handleMouseDownRotate;
+    private handleMouseDownDolly;
+    private handleMouseDownPan;
+    private handleMouseMoveRotate;
+    private handleMouseMoveDolly;
+    private handleMouseMovePan;
+    private handleMouseUp;
+    private handleMouseWheel;
+    private handleKeyDown;
+    private handleTouchStartRotate;
+    private handleTouchStartPan;
+    private handleTouchStartDolly;
+    private handleTouchStartDollyPan;
+    private handleTouchStartDollyRotate;
+    private handleTouchMoveRotate;
+    private handleTouchMovePan;
+    private handleTouchMoveDolly;
+    private handleTouchMoveDollyPan;
+    private handleTouchMoveDollyRotate;
+    private handleTouchEnd;
+    private onMouseDown;
+    private onMouseMove;
+    private onMouseUp;
+    private onMouseWheel;
+    private onKeyDown;
+    private onTouchStart;
+    private onTouchMove;
+    private onTouchEnd;
+    private onContextMenu;
+}
+/**
+ * OrbitControls maintains the "up" direction, camera.up (+Y by default).
+ *
+ * @event Orbit - left mouse / touch: one-finger move
+ * @event Zoom - middle mouse, or mousewheel / touch: two-finger spread or squish
+ * @event Pan - right mouse, or left mouse + ctrl/meta/shiftKey, or arrow keys / touch: two-finger move
+ */
+declare class OrbitControlsExp extends CameraControls {
+    mouseButtons: {
+        LEFT: MOUSE;
+        RIGHT: MOUSE;
+    };
+    touches: {
+        ONE: TOUCH;
+        TWO: TOUCH;
+    };
+    constructor(object: PerspectiveCamera | OrthographicCamera, domElement: HTMLElement);
+}
+/**
+ * MapControls maintains the "up" direction, camera.up (+Y by default)
+ *
+ * @event Orbit - right mouse, or left mouse + ctrl/meta/shiftKey / touch: two-finger rotate
+ * @event Zoom - middle mouse, or mousewheel / touch: two-finger spread or squish
+ * @event Pan - left mouse, or left right + ctrl/meta/shiftKey, or arrow keys / touch: one-finger move
+ */
+declare class MapControlsExp extends CameraControls {
+    mouseButtons: {
+        LEFT: MOUSE;
+        RIGHT: MOUSE;
+    };
+    touches: {
+        ONE: TOUCH;
+        TWO: TOUCH;
+    };
+    constructor(object: PerspectiveCamera | OrthographicCamera, domElement: HTMLElement);
+}
+/**
+ * TrackballControls allows the camera to rotate over the polls and does not maintain camera.up
+ *
+ * @event Orbit - left mouse / touch: one-finger move
+ * @event Zoom - middle mouse, or mousewheel / touch: two-finger spread or squish
+ * @event Pan - right mouse, or left mouse + ctrl/meta/shiftKey, or arrow keys / touch: two-finger move
+ */
+declare class TrackballControlsExp extends CameraControls {
+    trackball: boolean;
+    screenSpacePanning: boolean;
+    autoRotate: boolean;
+    mouseButtons: {
+        LEFT: MOUSE;
+        RIGHT: MOUSE;
+    };
+    touches: {
+        ONE: TOUCH;
+        TWO: TOUCH;
+    };
+    constructor(object: PerspectiveCamera | OrthographicCamera, domElement: HTMLElement);
+}
+export type { CameraControls, OrbitControlsExp, MapControlsExp, TrackballControlsExp };

package/controls/experimental/CameraControls.d.ts

@@ -1,9 +1,9 @@
-import { MOUSE, OrthographicCamera, PerspectiveCamera, Quaternion, Spherical, TOUCH, Vector3 } from 'three';
-import { EventDispatcher } from '../EventDispatcher';
+import type { MOUSE, OrthographicCamera, PerspectiveCamera, Quaternion, Spherical, TOUCH, Vector3 } from 'three';
+import type { EventDispatcher } from '../EventDispatcher.d.ts';
 export type CHANGE_EVENT = {
     type: 'change' | 'start' | 'end';
 };
-export declare const STATE: {
+export type declare const STATE: {
     NONE: number;
     ROTATE: number;
     DOLLY: number;
@@ -210,4 +210,4 @@ declare class TrackballControlsExp extends CameraControls {
     };
     constructor(object: PerspectiveCamera | OrthographicCamera, domElement: HTMLElement);
 }
-export { CameraControls, OrbitControlsExp, MapControlsExp, TrackballControlsExp };
+export type { CameraControls, OrbitControlsExp, MapControlsExp, TrackballControlsExp };