three-stdlib 2.35.11 → 2.35.13

package/controls/ArcballControls.d.cts

@@ -1,376 +0,0 @@
-import type { Vector3, Scene, PerspectiveCamera, OrthographicCamera } from 'three';
-import type { EventDispatcher } from './EventDispatcher.d.cts';
-import type { StandardControlsEventMap } from './StandardControlsEventMap.d.cts';
-type Camera = OrthographicCamera | PerspectiveCamera;
-/**
- *
- * @param {CamOrthographicCamera | PerspectiveCameraera} camera Virtual camera used in the scene
- * @param {HTMLElement=null} domElement Renderer's dom element
- * @param {Scene=null} scene The scene to be rendered
- */
-declare class ArcballControls extends EventDispatcher<StandardControlsEventMap> {
-    private camera;
-    private domElement;
-    private scene;
-    private mouseActions;
-    private _mouseOp;
-    private _v2_1;
-    private _v3_1;
-    private _v3_2;
-    private _m4_1;
-    private _m4_2;
-    private _quat;
-    private _translationMatrix;
-    private _rotationMatrix;
-    private _scaleMatrix;
-    private _rotationAxis;
-    private _cameraMatrixState;
-    private _cameraProjectionState;
-    private _fovState;
-    private _upState;
-    private _zoomState;
-    private _nearPos;
-    private _farPos;
-    private _gizmoMatrixState;
-    private _up0;
-    private _zoom0;
-    private _fov0;
-    private _initialNear;
-    private _nearPos0;
-    private _initialFar;
-    private _farPos0;
-    private _cameraMatrixState0;
-    private _gizmoMatrixState0;
-    private _button;
-    private _touchStart;
-    private _touchCurrent;
-    private _input;
-    private _switchSensibility;
-    private _startFingerDistance;
-    private _currentFingerDistance;
-    private _startFingerRotation;
-    private _currentFingerRotation;
-    private _devPxRatio;
-    private _downValid;
-    private _nclicks;
-    private _downEvents;
-    private _clickStart;
-    private _maxDownTime;
-    private _maxInterval;
-    private _posThreshold;
-    private _movementThreshold;
-    private _currentCursorPosition;
-    private _startCursorPosition;
-    private _grid;
-    private _gridPosition;
-    private _gizmos;
-    private _curvePts;
-    private _timeStart;
-    private _animationId;
-    focusAnimationTime: number;
-    private _timePrev;
-    private _timeCurrent;
-    private _anglePrev;
-    private _angleCurrent;
-    private _cursorPosPrev;
-    private _cursorPosCurr;
-    private _wPrev;
-    private _wCurr;
-    adjustNearFar: boolean;
-    scaleFactor: number;
-    dampingFactor: number;
-    wMax: number;
-    enableAnimations: boolean;
-    enableGrid: boolean;
-    cursorZoom: boolean;
-    minFov: number;
-    maxFov: number;
-    enabled: boolean;
-    enablePan: boolean;
-    enableRotate: boolean;
-    enableZoom: boolean;
-    minDistance: number;
-    maxDistance: number;
-    minZoom: number;
-    maxZoom: number;
-    readonly target: Vector3;
-    private _currentTarget;
-    private _tbRadius;
-    private _state;
-    constructor(camera: Camera | null, domElement?: HTMLElement | null | undefined, scene?: Scene | null | undefined);
-    private onWindowResize;
-    private onContextMenu;
-    private onPointerCancel;
-    private onPointerDown;
-    private onPointerMove;
-    private onPointerUp;
-    private onWheel;
-    private onSinglePanStart;
-    private onSinglePanMove;
-    private onSinglePanEnd;
-    private onDoubleTap;
-    private onDoublePanStart;
-    private onDoublePanMove;
-    private onDoublePanEnd;
-    private onRotateStart;
-    private onRotateMove;
-    private onRotateEnd;
-    private onPinchStart;
-    private onPinchMove;
-    private onPinchEnd;
-    private onTriplePanStart;
-    private onTriplePanMove;
-    private onTriplePanEnd;
-    /**
-     * Set _center's x/y coordinates
-     * @param {Number} clientX
-     * @param {Number} clientY
-     */
-    private setCenter;
-    /**
-     * Set default mouse actions
-     */
-    private initializeMouseActions;
-    /**
-     * Set a new mouse action by specifying the operation to be performed and a mouse/key combination. In case of conflict, replaces the existing one
-     * @param {String} operation The operation to be performed ('PAN', 'ROTATE', 'ZOOM', 'FOV)
-     * @param {*} mouse A mouse button (0, 1, 2) or 'WHEEL' for wheel notches
-     * @param {*} key The keyboard modifier ('CTRL', 'SHIFT') or null if key is not needed
-     * @returns {Boolean} True if the mouse action has been successfully added, false otherwise
-     */
-    private setMouseAction;
-    /**
-     * Return the operation associated to a mouse/keyboard combination
-     * @param {*} mouse A mouse button (0, 1, 2) or 'WHEEL' for wheel notches
-     * @param {*} key The keyboard modifier ('CTRL', 'SHIFT') or null if key is not needed
-     * @returns The operation if it has been found, null otherwise
-     */
-    private getOpFromAction;
-    /**
-     * Get the operation associated to mouse and key combination and returns the corresponding FSA state
-     * @param {Number} mouse Mouse button
-     * @param {String} key Keyboard modifier
-     * @returns The FSA state obtained from the operation associated to mouse/keyboard combination
-     */
-    private getOpStateFromAction;
-    /**
-     * Calculate the angle between two pointers
-     * @param {PointerEvent} p1
-     * @param {PointerEvent} p2
-     * @returns {Number} The angle between two pointers in degrees
-     */
-    private getAngle;
-    /**
-     * Update a PointerEvent inside current pointerevents array
-     * @param {PointerEvent} event
-     */
-    private updateTouchEvent;
-    /**
-     * Apply a transformation matrix, to the camera and gizmos
-     * @param {Object} transformation Object containing matrices to apply to camera and gizmos
-     */
-    private applyTransformMatrix;
-    /**
-     * Calculate the angular speed
-     * @param {Number} p0 Position at t0
-     * @param {Number} p1 Position at t1
-     * @param {Number} t0 Initial time in milliseconds
-     * @param {Number} t1 Ending time in milliseconds
-     */
-    private calculateAngularSpeed;
-    /**
-     * Calculate the distance between two pointers
-     * @param {PointerEvent} p0 The first pointer
-     * @param {PointerEvent} p1 The second pointer
-     * @returns {number} The distance between the two pointers
-     */
-    private calculatePointersDistance;
-    /**
-     * Calculate the rotation axis as the vector perpendicular between two vectors
-     * @param {Vector3} vec1 The first vector
-     * @param {Vector3} vec2 The second vector
-     * @returns {Vector3} The normalized rotation axis
-     */
-    private calculateRotationAxis;
-    /**
-     * Calculate the trackball radius so that gizmo's diamater will be 2/3 of the minimum side of the camera frustum
-     * @param {Camera} camera
-     * @returns {Number} The trackball radius
-     */
-    private calculateTbRadius;
-    /**
-     * Focus operation consist of positioning the point of interest in front of the camera and a slightly zoom in
-     * @param {Vector3} point The point of interest
-     * @param {Number} size Scale factor
-     * @param {Number} amount Amount of operation to be completed (used for focus animations, default is complete full operation)
-     */
-    private focus;
-    /**
-     * Draw a grid and add it to the scene
-     */
-    private drawGrid;
-    connect: (domElement: HTMLElement) => void;
-    /**
-     * Remove all listeners, stop animations and clean scene
-     */
-    dispose: () => void;
-    /**
-     * remove the grid from the scene
-     */
-    private disposeGrid;
-    /**
-     * Compute the easing out cubic function for ease out effect in animation
-     * @param {Number} t The absolute progress of the animation in the bound of 0 (beginning of the) and 1 (ending of animation)
-     * @returns {Number} Result of easing out cubic at time t
-     */
-    private easeOutCubic;
-    /**
-     * Make rotation gizmos more or less visible
-     * @param {Boolean} isActive If true, make gizmos more visible
-     */
-    private activateGizmos;
-    /**
-     * Calculate the cursor position in NDC
-     * @param {number} x Cursor horizontal coordinate within the canvas
-     * @param {number} y Cursor vertical coordinate within the canvas
-     * @param {HTMLElement} canvas The canvas where the renderer draws its output
-     * @returns {Vector2} Cursor normalized position inside the canvas
-     */
-    private getCursorNDC;
-    /**
-     * Calculate the cursor position inside the canvas x/y coordinates with the origin being in the center of the canvas
-     * @param {Number} x Cursor horizontal coordinate within the canvas
-     * @param {Number} y Cursor vertical coordinate within the canvas
-     * @param {HTMLElement} canvas The canvas where the renderer draws its output
-     * @returns {Vector2} Cursor position inside the canvas
-     */
-    private getCursorPosition;
-    /**
-     * Set the camera to be controlled
-     * @param {Camera} camera The virtual camera to be controlled
-     */
-    private setCamera;
-    /**
-     * Set gizmos visibility
-     * @param {Boolean} value Value of gizmos visibility
-     */
-    setGizmosVisible(value: boolean): void;
-    /**
-     * Creates the rotation gizmos matching trackball center and radius
-     * @param {Vector3} tbCenter The trackball center
-     * @param {number} tbRadius The trackball radius
-     */
-    private makeGizmos;
-    /**
-     * Perform animation for focus operation
-     * @param {Number} time Instant in which this function is called as performance.now()
-     * @param {Vector3} point Point of interest for focus operation
-     * @param {Matrix4} cameraMatrix Camera matrix
-     * @param {Matrix4} gizmoMatrix Gizmos matrix
-     */
-    private onFocusAnim;
-    /**
-     * Perform animation for rotation operation
-     * @param {Number} time Instant in which this function is called as performance.now()
-     * @param {Vector3} rotationAxis Rotation axis
-     * @param {number} w0 Initial angular velocity
-     */
-    private onRotationAnim;
-    /**
-     * Perform pan operation moving camera between two points
-     * @param {Vector3} p0 Initial point
-     * @param {Vector3} p1 Ending point
-     * @param {Boolean} adjust If movement should be adjusted considering camera distance (Perspective only)
-     */
-    private pan;
-    /**
-     * Reset trackball
-     */
-    reset: () => void;
-    /**
-     * Rotate the camera around an axis passing by trackball's center
-     * @param {Vector3} axis Rotation axis
-     * @param {number} angle Angle in radians
-     * @returns {Object} Object with 'camera' field containing transformation matrix resulting from the operation to be applied to the camera
-     */
-    private rotate;
-    copyState: () => void;
-    pasteState: () => void;
-    /**
-     * Save the current state of the control. This can later be recovered with .reset
-     */
-    saveState: () => void;
-    /**
-     * Perform uniform scale operation around a given point
-     * @param {Number} size Scale factor
-     * @param {Vector3} point Point around which scale
-     * @param {Boolean} scaleGizmos If gizmos should be scaled (Perspective only)
-     * @returns {Object} Object with 'camera' and 'gizmo' fields containing transformation matrices resulting from the operation to be applied to the camera and gizmos
-     */
-    private applyScale;
-    /**
-     * Set camera fov
-     * @param {Number} value fov to be setted
-     */
-    private setFov;
-    /**
-     * Set the trackball's center point
-     * @param {Number} x X coordinate
-     * @param {Number} y Y coordinate
-     * @param {Number} z Z coordinate
-     */
-    setTarget: (x: number, y: number, z: number) => void;
-    /**
-     * Set values in transformation object
-     * @param {Matrix4} camera Transformation to be applied to the camera
-     * @param {Matrix4} gizmos Transformation to be applied to gizmos
-     */
-    private setTransformationMatrices;
-    /**
-     * Rotate camera around its direction axis passing by a given point by a given angle
-     * @param {Vector3} point The point where the rotation axis is passing trough
-     * @param {Number} angle Angle in radians
-     * @returns The computed transormation matix
-     */
-    private zRotate;
-    /**
-     * Unproject the cursor on the 3D object surface
-     * @param {Vector2} cursor Cursor coordinates in NDC
-     * @param {Camera} camera Virtual camera
-     * @returns {Vector3} The point of intersection with the model, if exist, null otherwise
-     */
-    private unprojectOnObj;
-    /**
-     * Unproject the cursor on the trackball surface
-     * @param {Camera} camera The virtual camera
-     * @param {Number} cursorX Cursor horizontal coordinate on screen
-     * @param {Number} cursorY Cursor vertical coordinate on screen
-     * @param {HTMLElement} canvas The canvas where the renderer draws its output
-     * @param {number} tbRadius The trackball radius
-     * @returns {Vector3} The unprojected point on the trackball surface
-     */
-    private unprojectOnTbSurface;
-    /**
-     * Unproject the cursor on the plane passing through the center of the trackball orthogonal to the camera
-     * @param {Camera} camera The virtual camera
-     * @param {Number} cursorX Cursor horizontal coordinate on screen
-     * @param {Number} cursorY Cursor vertical coordinate on screen
-     * @param {HTMLElement} canvas The canvas where the renderer draws its output
-     * @param {Boolean} initialDistance If initial distance between camera and gizmos should be used for calculations instead of current (Perspective only)
-     * @returns {Vector3} The unprojected point on the trackball plane
-     */
-    private unprojectOnTbPlane;
-    /**
-     * Update camera and gizmos state
-     */
-    private updateMatrixState;
-    /**
-     * Update the trackball FSA
-     * @param {STATE} newState New state of the FSA
-     * @param {Boolean} updateMatrices If matriices state should be updated
-     */
-    private updateTbState;
-    update: () => void;
-    private setStateFromJSON;
-}
-export type { ArcballControls };

package/controls/DeviceOrientationControls.d.cts

@@ -1,29 +0,0 @@
-import type { Camera } from 'three';
-import type { EventDispatcher } from './EventDispatcher.d.cts';
-import type { StandardControlsEventMap } from './StandardControlsEventMap.d.cts';
-/**
- * W3C Device Orientation control (http://w3c.github.io/deviceorientation/spec-source-orientation.html)
- */
-declare class DeviceOrientationControls extends EventDispatcher<StandardControlsEventMap> {
-    object: Camera;
-    private changeEvent;
-    private EPS;
-    enabled: boolean;
-    deviceOrientation: Partial<DeviceOrientationEvent>;
-    screenOrientation: string | number;
-    alphaOffset: number;
-    constructor(object: Camera);
-    private onDeviceOrientationChangeEvent;
-    private onScreenOrientationChangeEvent;
-    private zee;
-    private euler;
-    private q0;
-    private q1;
-    private setObjectQuaternion;
-    connect: () => void;
-    disconnect: () => void;
-    private lastQuaternion;
-    update: () => void;
-    dispose: () => void;
-}
-export type { DeviceOrientationControls };

package/controls/DragControls.d.cts

@@ -1,67 +0,0 @@
-import type { Camera, Object3D, Raycaster } from 'three';
-import type { EventDispatcher } from './EventDispatcher.d.cts';
-export interface DragControlsEventMap {
-    /**
-     * Fires when the pointer is moved onto a 3D object, or onto one of its children.
-     */
-    hoveron: {
-        object: Object3D;
-    };
-    /**
-     * Fires when the pointer is moved out of a 3D object.
-     */
-    hoveroff: {
-        object: Object3D;
-    };
-    /**
-     * Fires when the user starts to drag a 3D object.
-     */
-    dragstart: {
-        object: Object3D;
-    };
-    /**
-     * Fires when the user drags a 3D object.
-     */
-    drag: {
-        object: Object3D;
-    };
-    /**
-     * Fires when the user has finished dragging a 3D object.
-     */
-    dragend: {
-        object: Object3D;
-    };
-}
-declare class DragControls extends EventDispatcher<DragControlsEventMap> {
-    enabled: boolean;
-    transformGroup: boolean;
-    private _objects;
-    private _camera;
-    private _domElement;
-    private _plane;
-    private _raycaster;
-    private _mouse;
-    private _offset;
-    private _intersection;
-    private _worldPosition;
-    private _inverseMatrix;
-    private _intersections;
-    private _selected;
-    private _hovered;
-    constructor(_objects: Object3D[], _camera: Camera, _domElement: HTMLElement);
-    activate: () => void;
-    deactivate: () => void;
-    dispose: () => void;
-    getObjects: () => Object3D[];
-    getRaycaster: () => Raycaster;
-    private onMouseMove;
-    private onMouseDown;
-    private onMouseCancel;
-    private onPointerMove;
-    private onPointerDown;
-    private onPointerCancel;
-    private onTouchMove;
-    private onTouchStart;
-    private onTouchEnd;
-}
-export type { DragControls };

package/controls/EventDispatcher.d.cts

@@ -1,41 +0,0 @@
-/**
- * The minimal basic Event that can be dispatched by a {@link EventDispatcher<>}.
- */
-export interface BaseEvent<TEventType extends string = string> {
-    readonly type: TEventType;
-    target: any;
-}
-/**
- * The minimal expected contract of a fired Event that was dispatched by a {@link EventDispatcher<>}.
- */
-export interface Event<TEventType extends string = string, TTarget = unknown> {
-    readonly type: TEventType;
-    readonly target: TTarget;
-}
-export type EventListener<TEventData, TEventType extends string, TTarget> = (event: TEventData & Event<TEventType, TTarget>) => void;
-export declare class EventDispatcher<TEventMap extends {} = {}> {
-    private _listeners;
-    /**
-     * Adds a listener to an event type.
-     * @param type The type of event to listen to.
-     * @param listener The function that gets called when the event is fired.
-     */
-    addEventListener<T extends Extract<keyof TEventMap, string>>(type: T, listener: EventListener<TEventMap[T], T, this>): void;
-    /**
-     * Checks if listener is added to an event type.
-     * @param type The type of event to listen to.
-     * @param listener The function that gets called when the event is fired.
-     */
-    hasEventListener<T extends Extract<keyof TEventMap, string>>(type: T, listener: EventListener<TEventMap[T], T, this>): boolean;
-    /**
-     * Removes a listener from an event type.
-     * @param type The type of the listener that gets removed.
-     * @param listener The listener function that gets removed.
-     */
-    removeEventListener<T extends Extract<keyof TEventMap, string>>(type: T, listener: EventListener<TEventMap[T], T, this>): void;
-    /**
-     * Fire an event type.
-     * @param event The event that gets fired.
-     */
-    dispatchEvent<T extends Extract<keyof TEventMap, string>>(event: BaseEvent<T> & TEventMap[T]): void;
-}

package/controls/FirstPersonControls.d.cts

@@ -1,49 +0,0 @@
-import type { Vector3, Camera } from 'three';
-import type { EventDispatcher } from './EventDispatcher.d.cts';
-export declare class FirstPersonControls extends EventDispatcher<{}> {
-    object: Camera;
-    domElement?: HTMLElement | null;
-    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;
-    private autoSpeedFactor;
-    private mouseX;
-    private mouseY;
-    private moveForward;
-    private moveBackward;
-    private moveLeft;
-    private moveRight;
-    private moveUp;
-    private moveDown;
-    private viewHalfX;
-    private viewHalfY;
-    private lat;
-    private lon;
-    private lookDirection;
-    private spherical;
-    readonly target: Vector3;
-    constructor(object: Camera, domElement?: HTMLElement | null);
-    connect: (domElement: HTMLElement) => void;
-    dispose: () => void;
-    handleResize: () => void;
-    private onMouseDown;
-    private onMouseUp;
-    private onMouseMove;
-    private onKeyDown;
-    private onKeyUp;
-    lookAt: (x: Vector3 | number, y?: number, z?: number) => this;
-    update: (delta: number) => void;
-    private contextmenu;
-    private setOrientation;
-}

package/controls/FlyControls.d.cts

@@ -1,39 +0,0 @@
-import type { Camera } from 'three';
-import type { EventDispatcher } from './EventDispatcher.d.cts';
-export interface FlyControlsEventMap {
-    /**
-     * Fires when the camera has been transformed by the controls.
-     */
-    change: {};
-}
-declare class FlyControls extends EventDispatcher<FlyControlsEventMap> {
-    object: Camera;
-    domElement: HTMLElement | Document;
-    movementSpeed: number;
-    rollSpeed: number;
-    dragToLook: boolean;
-    autoForward: boolean;
-    private changeEvent;
-    private EPS;
-    private tmpQuaternion;
-    private mouseStatus;
-    private movementSpeedMultiplier;
-    private moveState;
-    private moveVector;
-    private rotationVector;
-    constructor(object: Camera, domElement?: HTMLElement | Document);
-    private keydown;
-    private keyup;
-    private pointerdown;
-    private pointermove;
-    private pointerup;
-    private lastQuaternion;
-    private lastPosition;
-    update: (delta: number) => void;
-    private updateMovementVector;
-    private updateRotationVector;
-    private getContainerDimensions;
-    connect: (domElement: HTMLElement | Document) => void;
-    dispose: () => void;
-}
-export type { FlyControls };

package/controls/OrbitControls.d.cts

@@ -1,74 +0,0 @@
-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 };