three-stdlib 2.35.11 → 2.35.12

package/animation/MMDPhysics.d.cts

@@ -1,119 +0,0 @@
-import type { Bone, Euler, Matrix4, MeshBasicMaterial, Object3D, Quaternion, SkinnedMesh, Vector3 } from 'three'
-
-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: SkinnedMesh
-  physics: MMDPhysics
-  materials: [MeshBasicMaterial, MeshBasicMaterial, MeshBasicMaterial]
-
-  constructor(mesh: SkinnedMesh, physics: MMDPhysics)
-  dispose(): void
-}

package/cameras/CinematicCamera.d.cts

@@ -1,34 +0,0 @@
-import type { PerspectiveCamera, ShaderMaterial, Scene, WebGLRenderer, OrthographicCamera, WebGLRenderTarget } from 'three'
-
-import type { BokehShader2Uniforms } from './../shaders/BokehShader2.d.cts'
-
-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: BokehShader2Uniforms
-  }
-  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
-}

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;
-}