@types/three 0.132.2 → 0.135.0

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Fri, 01 Oct 2021 09:01:18 GMT
+ * Last updated: Mon, 06 Dec 2021 23:31:03 GMT
  * Dependencies: none
  * Global values: `THREE`
 

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

@@ -0,0 +1,160 @@
+import { EventDispatcher, Camera, Scene, Vector3, Raycaster } from '../../../src/Three';
+
+export enum ArcballControlsMouseActionOperations {
+    PAN = 'PAN',
+    ROTATE = 'ROTATE',
+    ZOOM = 'ZOOM',
+    FOV = 'FOV',
+}
+
+export type ArcballControlsMouseActionMouse = 0 | 1 | 2 | 'WHEEL';
+
+export enum ArcballControlsMouseActionKeys {
+    SHIFT = 'SHIFT',
+    CTRL = 'CTRL',
+}
+
+export class ArcballControls extends EventDispatcher {
+    camera: Camera | null;
+    domElement: HTMLElement;
+    scene?: Scene | null | undefined;
+
+    /**
+     * @default 500
+     */
+    focusAnimationTime: number;
+
+    /**
+     * @default true
+     */
+    enabled: boolean;
+
+    /**
+     * @default true
+     */
+    enablePan: boolean;
+
+    /**
+     * @default true
+     */
+    enableRotate: boolean;
+
+    /**
+     * @default true
+     */
+    enableZoom: boolean;
+
+    /**
+     * @default true
+     */
+    enableGizmos: boolean;
+
+    /**
+     * @default true
+     */
+    adjustNearFar: boolean;
+
+    /**
+     * @default 1.1
+     */
+    scaleFactor: number;
+
+    /**
+     * @default 25
+     */
+    dampingFactor: number;
+
+    /**
+     * @default 20
+     */
+    wMax: number; // maximum angular velocity allowed
+
+    /**
+     * @default true
+     */
+    enableAnimations: boolean; // if animations should be performed
+
+    /**
+     * @default false
+     */
+    enableGrid: boolean; // if grid should be showed during pan operation
+
+    /**
+     * @default false
+     */
+    cursorZoom: boolean; // if wheel zoom should be cursor centered
+
+    /**
+     * @default 5
+     */
+    minFov: number;
+
+    /**
+     * @default 90
+     */
+    maxFov: number;
+
+    /**
+     * @default 0
+     */
+    minDistance: number;
+
+    /**
+     * @default Infinity
+     */
+    maxDistance: number;
+
+    /**
+     * @default 0
+     */
+    minZoom: number;
+
+    /**
+     * @default Infinity
+     */
+    maxZoom: number;
+
+    /**
+     * @default Vector3(0,0,0)
+     */
+    target: Vector3;
+
+    /**
+     * @default 0.67
+     */
+    radiusFactor: number;
+
+    constructor(camera: Camera, domElement: HTMLElement, scene?: Scene | null);
+
+    getRaycaster(): Raycaster;
+
+    activateGizmos(isActive: boolean): void;
+
+    copyState(): void;
+
+    pasteState(): void;
+
+    saveState(): void;
+
+    reset(): void;
+
+    setCamera(camera: Camera): void;
+
+    setGizmosVisible(value: boolean): void;
+
+    setTbRadius(value: number): void;
+
+    setMouseAction(
+        operation: ArcballControlsMouseActionOperations,
+        mouse: ArcballControlsMouseActionMouse,
+        key?: ArcballControlsMouseActionKeys,
+    ): boolean;
+
+    unsetMouseAction(mouse: ArcballControlsMouseActionMouse, key?: ArcballControlsMouseActionKeys): boolean;
+
+    setTarget(x: number, y: number, z: number): void;
+
+    update(): void;
+
+    dispose(): void;
+}

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

@@ -1,4 +1,4 @@
-import { Camera, EventDispatcher, Object3D } from '../../../src/Three';
+import { Camera, EventDispatcher, Object3D, Raycaster } from '../../../src/Three';
 
 export class DragControls extends EventDispatcher {
     constructor(objects: Object3D[], camera: Camera, domElement?: HTMLElement);
@@ -14,4 +14,5 @@ export class DragControls extends EventDispatcher {
     deactivate(): void;
     dispose(): void;
     getObjects(): Object3D[];
+    getRaycaster(): Raycaster;
 }

three/examples/jsm/csm/CSM.d.ts

@@ -1,36 +1,61 @@
+import { Camera, Vector3, DirectionalLight, Material, Vector2, Object3D } from '../../../src/Three';
+
+export enum CMSMode {
+    practical = 'practical',
+    uniform = 'uniform',
+    logarithmic = 'logarithmic',
+    custom = 'custom',
+}
+
+export interface CMSParameters {
+    camera?: Camera;
+    parent?: Object3D;
+    cascades?: number;
+    maxFar?: number;
+    mode?: CMSMode;
+    shadowMapSize?: number;
+    shadowBias?: number;
+    lightDirection?: Vector3;
+    lightIntensity?: number;
+    lightNear?: number;
+    lightFar?: number;
+    lightMargin?: number;
+    customSplitsCallback?: (cascades: number, cameraNear: number, cameraFar: number, breaks: number[]) => void;
+}
+
 export class CSM {
-    constructor(data: any);
-    camera: any;
-    parent: any;
-    cascades: any;
-    maxFar: any;
-    mode: any;
-    shadowMapSize: any;
-    shadowBias: any;
-    lightDirection: any;
-    lightIntensity: any;
-    lightNear: any;
-    lightFar: any;
-    lightMargin: any;
-    customSplitsCallback: any;
+    constructor(data?: CMSParameters);
+    camera: Camera;
+    parent: Object3D;
+    cascades: number;
+    maxFar: number;
+    mode: CMSMode;
+    shadowMapSize: number;
+    shadowBias: number;
+    lightDirection: Vector3;
+    lightIntensity: number;
+    lightNear: number;
+    lightFar: number;
+    lightMargin: number;
+    customSplitsCallback: (cascades: number, cameraNear: number, cameraFar: number, breaks: number[]) => void;
     fade: boolean;
-    mainFrustum: Frustum;
-    frustums: any[];
-    breaks: any[];
-    lights: any[];
-    shaders: Map<any, any>;
+    mainFrustum: CSMFrustrum;
+    frustums: CSMFrustrum[];
+    breaks: number[];
+    lights: DirectionalLight[];
+    shaders: Map<unknown, string>;
     createLights(): void;
     initCascades(): void;
     updateShadowBounds(): void;
     getBreaks(): void;
     update(): void;
     injectInclude(): void;
-    setupMaterial(material: any): void;
+    setupMaterial(material: Material): void;
     updateUniforms(): void;
-    getExtendedBreaks(target: any): void;
+    getExtendedBreaks(target: Vector2[]): void;
     updateFrustums(): void;
     remove(): void;
     dispose(): void;
 }
 
-import Frustum from './Frustum.js';
+import CSMFrustrum from './CSMFrustum.js';

three/examples/jsm/csm/CSMFrustum.d.ts

@@ -0,0 +1,19 @@
+import { Matrix4, Vector3 } from '../../../src/Three';
+
+export interface CSMFrustumVerticies {
+    near: Vector3[];
+    far: Vector3[];
+}
+
+export interface CSMFrustumParameters {
+    projectionMatrix?: Matrix4;
+    maxFar?: number;
+}
+
+export default class CSMFrustum {
+    constructor(data?: CSMFrustumParameters);
+    vertices: CSMFrustumVerticies;
+    setFromProjectionMatrix(projectionMatrix: Matrix4, maxFar: number): CSMFrustumVerticies;
+    split(breaks: number[], target: CSMFrustum[]): void;
+    toSpace(cameraMatrix: Matrix4, target: CSMFrustum): void;
+}

three/examples/jsm/csm/CSMHelper.d.ts

@@ -1,13 +1,26 @@
-export class CSMHelper {
-    constructor(csm: any);
-    csm: any;
+import {
+    Box3Helper,
+    BufferGeometry,
+    Group,
+    LineBasicMaterial,
+    LineSegments,
+    Mesh,
+    MeshBasicMaterial,
+    PlaneGeometry,
+} from '../../../src/Three';
+
+import { CSM } from './CSM';
+
+export class CSMHelper<TCSM extends CSM = CSM> extends Group {
+    constructor(csm: TCSM);
+    csm: TCSM;
     displayFrustum: boolean;
     displayPlanes: boolean;
     displayShadowBounds: boolean;
-    frustumLines: any;
-    cascadeLines: any[];
-    cascadePlanes: any[];
-    shadowLines: any[];
+    frustumLines: LineSegments<BufferGeometry, LineBasicMaterial>;
+    cascadeLines: Box3Helper[];
+    cascadePlanes: Array<Mesh<PlaneGeometry, MeshBasicMaterial>>;
+    shadowLines: Box3Helper[];
     updateVisibility(): void;
     update(): void;
 }

three/examples/jsm/csm/CSMShader.d.ts

@@ -0,0 +1,4 @@
+export interface CSMShader {
+    lights_fragment_begin: string;
+    lights_pars_begin: string;
+}

three/examples/jsm/exporters/GLTFExporter.d.ts

@@ -16,4 +16,5 @@ export class GLTFExporter {
     constructor();
 
     parse(input: Object3D, onCompleted: (gltf: object) => void, options: GLTFExporterOptions): void;
+    parseAsync(input: Object3D, options: GLTFExporterOptions): Promise<void>;
 }

three/examples/jsm/geometries/ParametricGeometries.d.ts

@@ -1,8 +1,10 @@
-import { Curve, ParametricGeometry, Vector3 } from '../../../src/Three';
+import { Curve, Vector3 } from '../../../src/Three';
+
+import { ParametricGeometry } from './ParametricGeometry';
 
 export namespace ParametricGeometries {
     function klein(v: number, u: number, target: Vector3): Vector3;
-    function plane(width: number, height: number, target: Vector3): Vector3;
+    function plane(width: number, height: number): (u: number, v: number, target: Vector3) => Vector3;
     function mobius(u: number, t: number, target: Vector3): Vector3;
     function mobius3d(u: number, t: number, target: Vector3): Vector3;
 

three/{src → examples/jsm}/geometries/ParametricGeometry.d.ts

@@ -1,8 +1,7 @@
-import { Vector3 } from './../math/Vector3';
-import { BufferGeometry } from './../core/BufferGeometry';
+import { Vector3, BufferGeometry } from '../../../src/Three';
 
 export class ParametricGeometry extends BufferGeometry {
-    constructor(func: (u: number, v: number, dest: Vector3) => void, slices: number, stacks: number);
+    constructor(func?: (u: number, v: number, target: Vector3) => void, slices?: number, stacks?: number);
 
     /**
      * @default 'ParametricGeometry'

three/{src → examples/jsm}/geometries/TextGeometry.d.ts

@@ -1,5 +1,6 @@
-import { Font } from './../extras/core/Font';
-import { ExtrudeGeometry } from './ExtrudeGeometry';
+import { ExtrudeGeometry } from '../../../src/Three';
+
+import { Font } from '../loaders/FontLoader';
 
 export interface TextGeometryParameters {
     font: Font;

three/examples/jsm/lines/LineSegmentsGeometry.d.ts

@@ -14,10 +14,10 @@ export class LineSegmentsGeometry extends InstancedBufferGeometry {
     applyMatrix4(matrix: Matrix4): this;
     computeBoundingBox(): void;
     computeBoundingSphere(): void;
-    fromEdgesGeometry(geometry: WireframeGeometry): this;
+    fromEdgesGeometry(geometry: EdgesGeometry): this;
     fromLineSegments(lineSegments: LineSegments): this;
     fromMesh(mesh: Mesh): this;
-    fromWireframeGeometry(geometry: EdgesGeometry): this;
+    fromWireframeGeometry(geometry: WireframeGeometry): this;
     setColors(array: number[] | Float32Array): this;
     setPositions(array: number[] | Float32Array): this;
 }

three/{src → examples/jsm}/loaders/FontLoader.d.ts

@@ -1,6 +1,4 @@
-import { Loader } from './Loader';
-import { LoadingManager } from './LoadingManager';
-import { Font } from './../extras/core/Font';
+import { Shape, Loader, LoadingManager } from '../../../src/Three';
 
 export class FontLoader extends Loader {
     constructor(manager?: LoadingManager);
@@ -14,3 +12,16 @@ export class FontLoader extends Loader {
     loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Font>;
     parse(json: any): Font;
 }
+
+export class Font {
+    constructor(jsondata: any);
+
+    /**
+     * @default 'Font'
+     */
+    type: string;
+
+    data: string;
+
+    generateShapes(text: string, size: number): Shape[];
+}

three/examples/jsm/loaders/GLTFLoader.d.ts

@@ -13,6 +13,9 @@ import {
     Material,
     SkinnedMesh,
     Texture,
+    TextureLoader,
+    FileLoader,
+    ImageBitmapLoader,
 } from '../../../src/Three';
 
 import { DRACOLoader } from './DRACOLoader';
@@ -61,16 +64,35 @@ export class GLTFLoader extends Loader {
         onLoad: (gltf: GLTF) => void,
         onError?: (event: ErrorEvent) => void,
     ): void;
+
+    parseAsync(data: ArrayBuffer | string, path: string): Promise<void>;
 }
 
+export type GLTFReferenceType = 'materials' | 'nodes' | 'textures' | 'meshes';
+
 export interface GLTFReference {
-    type: 'materials' | 'nodes' | 'textures';
-    index: number;
+    materials?: number;
+    nodes?: number;
+    textures?: number;
+    meshes?: number;
 }
 
 export class GLTFParser {
     json: any;
 
+    options: {
+        path: string;
+        manager: LoadingManager;
+        ktx2Loader: KTX2Loader;
+        meshoptDecoder: /* MeshoptDecoder */ any;
+        crossOrigin: string;
+        requestHeader: { [header: string]: string };
+    };
+
+    fileLoader: FileLoader;
+    textureLoader: TextureLoader | ImageBitmapLoader;
+    plugins: GLTFLoaderPlugin;
+    extensions: { [name: string]: any };
     associations: Map<Object3D | Material | Texture, GLTFReference>;
 
     getDependency: (type: string, index: number) => Promise<any>;
@@ -131,5 +153,6 @@ export interface GLTFLoaderPlugin {
     extendMaterialParams?:
         | ((materialIndex: number, materialParams: { [key: string]: any }) => Promise<any> | null)
         | undefined;
+    createNodeMesh?: ((nodeIndex: number) => Promise<Group | Mesh | SkinnedMesh> | null) | undefined;
     createNodeAttachment?: ((nodeIndex: number) => Promise<Object3D> | null) | undefined;
 }

three/examples/jsm/loaders/LogLuvLoader.d.ts

@@ -0,0 +1,19 @@
+import { DataTextureLoader, TextureDataType, LoadingManager, PixelFormat } from '../../../src/Three';
+
+export interface LogLuv {
+    width: number;
+    height: number;
+    data: Uint16Array | Float32Array;
+    format: PixelFormat;
+    type: TextureDataType;
+    flipY: boolean;
+}
+
+export class LogLuvLoader extends DataTextureLoader {
+    type: TextureDataType;
+    constructor(manager: LoadingManager);
+
+    parse(buffer: Iterable<number>): LogLuv;
+
+    setDataType(value: TextureDataType): this;
+}

three/examples/jsm/misc/GPUComputationRenderer.d.ts

@@ -1,6 +1,6 @@
 import {
     WebGLRenderer,
-    RenderTarget,
+    WebGLRenderTarget,
     Texture,
     DataTexture,
     Material,
@@ -8,6 +8,7 @@ import {
     Wrapping,
     TextureFilter,
     TextureDataType,
+    IUniform,
 } from '../../../src/Three';
 
 export interface Variable {
@@ -15,7 +16,7 @@ export interface Variable {
     initialValueTexture: Texture;
     material: ShaderMaterial;
     dependencies: Variable[];
-    renderTargets: RenderTarget[];
+    renderTargets: WebGLRenderTarget[];
     wrapS: number;
     wrapT: number;
     minFilter: number;
@@ -33,9 +34,10 @@ export class GPUComputationRenderer {
     init(): string | null;
     compute(): void;
 
-    getCurrentRenderTarget(variable: Variable): RenderTarget;
-    getAlternateRenderTarget(variable: Variable): RenderTarget;
+    getCurrentRenderTarget(variable: Variable): WebGLRenderTarget;
+    getAlternateRenderTarget(variable: Variable): WebGLRenderTarget;
     addResolutionDefine(materialShader: ShaderMaterial): void;
+    createShaderMaterial(computeFragmentShader: string, uniforms?: { [uniform: string]: IUniform }): ShaderMaterial;
     createRenderTarget(
         sizeXTexture: number,
         sizeYTexture: number,
@@ -43,8 +45,8 @@ export class GPUComputationRenderer {
         wrapT: number,
         minFilter: TextureFilter,
         magFilter: TextureFilter,
-    ): RenderTarget;
+    ): WebGLRenderTarget;
     createTexture(): DataTexture;
     renderTexture(input: Texture, output: Texture): void;
-    doRenderTarget(material: Material, output: RenderTarget): void;
+    doRenderTarget(material: Material, output: WebGLRenderTarget): void;
 }

three/examples/jsm/modifiers/TessellateModifier.d.ts

@@ -5,5 +5,5 @@ export class TessellateModifier {
     maxEdgeLength: number;
     maxIterations: number;
 
-    modify(geometry: BufferGeometry): BufferGeometry;
+    modify<TGeometry extends BufferGeometry>(geometry: TGeometry): TGeometry;
 }

three/examples/jsm/nodes/inputs/ColorNode.d.ts

@@ -1,4 +1,4 @@
-import { Color } from '../../../../src/Three';
+import { Color, ColorRepresentation } from '../../../../src/Three';
 
 import { InputNode } from '../core/InputNode';
 import { NodeBuilder } from '../core/NodeBuilder';

three/examples/jsm/nodes/materials/StandardNodeMaterial.d.ts

@@ -21,5 +21,5 @@ export class StandardNodeMaterial extends NodeMaterial {
     environment: Node;
     mask: Node;
     position: Node;
-    sheenTint: Node;
+    sheenColor: Node;
 }

three/examples/jsm/nodes/materials/nodes/StandardNode.d.ts

@@ -8,7 +8,7 @@ export class StandardNode extends Node {
     roughness: Node;
     metalness: Node;
     nodeType: string;
-    sheenTint: Node;
+    sheenColor: Node;
 
     build(builder: NodeBuilder): string;
     copy(source: StandardNode): this;

three/examples/jsm/objects/MarchingCubes.d.ts

@@ -1,7 +1,13 @@
-import { BufferGeometry, Material, ImmediateRenderObject } from '../../../src/Three';
+import { BufferGeometry, Material, Mesh, Color } from '../../../src/Three';
 
-export class MarchingCubes extends ImmediateRenderObject {
-    constructor(resolution: number, material: Material, enableUvs?: boolean, enableColors?: boolean);
+export class MarchingCubes extends Mesh {
+    constructor(
+        resolution: number,
+        material: Material,
+        enableUvs?: boolean,
+        enableColors?: boolean,
+        maxPolyCount?: number,
+    );
 
     enableUvs: boolean;
     enableColors: boolean;
@@ -46,9 +52,9 @@ export class MarchingCubes extends ImmediateRenderObject {
     begin(): void;
     end(): void;
 
-    init(resolution: string): void;
+    init(resolution: number): void;
 
-    addBall(ballx: number, bally: number, ballz: number, strength: number, subtract: number, colors: any): void;
+    addBall(ballx: number, bally: number, ballz: number, strength: number, subtract: number, colors?: Color): void;
 
     addPlaneX(strength: number, subtract: number): void;
     addPlaneY(strength: number, subtract: number): void;

three/examples/jsm/postprocessing/SSRPass.d.ts

@@ -7,7 +7,6 @@ import {
     Scene,
     WebGLRenderer,
     Camera,
-    TextureEncoding,
     Mesh,
     Material,
     ColorRepresentation,
@@ -22,7 +21,6 @@ export interface SSRPassParams {
     width?: number | undefined;
     height?: number | undefined;
     selects: Mesh[] | null;
-    encoding: TextureEncoding;
     isPerspectiveCamera?: boolean | undefined;
     isBouncing?: boolean | undefined;
     groundReflector: Reflector | null;
@@ -40,7 +38,6 @@ export class SSRPass extends Pass {
     output: number;
     maxDistance: number;
     thickness: number;
-    encoding: TextureEncoding;
     tempColor: Color;
 
     get selects(): Mesh[] | null;

three/examples/jsm/postprocessing/SSRrPass.d.ts

@@ -1,32 +1,18 @@
 import {
-    AddEquation,
     Color,
-    NormalBlending,
-    DepthTexture,
-    SrcAlphaFactor,
-    OneMinusSrcAlphaFactor,
     MeshNormalMaterial,
     MeshBasicMaterial,
-    NearestFilter,
-    NoBlending,
-    RGBAFormat,
     ShaderMaterial,
-    UniformsUtils,
-    UnsignedShortType,
     WebGLRenderTarget,
-    HalfFloatType,
     MeshStandardMaterial,
     WebGLRenderer,
     Scene,
     Camera,
     Mesh,
-    TextureEncoding,
     Material,
     ColorRepresentation,
 } from '../../../src/Three';
 import { Pass, FullScreenQuad } from './Pass';
-import { SSRrShader, SSRrDepthShader } from '../shaders/SSRrShader';
-import { CopyShader } from '../shaders/CopyShader';
 
 export interface SSRrPassParams {
     renderer: WebGLRenderer;
@@ -35,7 +21,6 @@ export interface SSRrPassParams {
     width?: number | undefined;
     height?: number | undefined;
     selects: Mesh[] | null;
-    encoding: TextureEncoding;
 }
 
 export class SSRrPass extends Pass {
@@ -53,8 +38,6 @@ export class SSRrPass extends Pass {
     maxDistance: number;
     surfDist: number;
 
-    encoding: TextureEncoding;
-
     color: Color;
 
     seleects: Mesh[] | null;