@types/three 0.157.1 → 0.157.2

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

@@ -0,0 +1,76 @@
+import { BufferGeometry, Material, Mesh, Color } from '../../../src/Three.js';
+
+export class MarchingCubes extends Mesh {
+    constructor(
+        resolution: number,
+        material: Material,
+        enableUvs?: boolean,
+        enableColors?: boolean,
+        maxPolyCount?: number,
+    );
+
+    enableUvs: boolean;
+    enableColors: boolean;
+
+    resolution: number;
+
+    // parameters
+
+    isolation: number;
+
+    // size of field, 32 is pushing it in Javascript :)
+
+    size: number;
+    size2: number;
+    size3: number;
+    halfsize: number;
+
+    // deltas
+
+    delta: number;
+    yd: number;
+    zd: number;
+
+    field: Float32Array;
+    normal_cache: Float32Array;
+    palette: Float32Array;
+
+    maxCount: number;
+    count: number;
+
+    hasPositions: boolean;
+    hasNormals: boolean;
+    hasColors: boolean;
+    hasUvs: boolean;
+
+    positionArray: Float32Array;
+    normalArray: Float32Array;
+
+    uvArray: Float32Array;
+    colorArray: Float32Array;
+
+    begin(): void;
+    end(): void;
+
+    init(resolution: number): 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;
+    addPlaneZ(strength: number, subtract: number): void;
+
+    setCell(x: number, y: number, z: number, value: number): void;
+    getCell(x: number, y: number, z: number): number;
+
+    blur(intensity: number): void;
+
+    reset(): void;
+    update(): void;
+    render(renderCallback: any): void;
+    generateGeometry(): BufferGeometry;
+    generateBufferGeometry(): BufferGeometry;
+}
+
+export const edgeTable: Int32Array[];
+export const triTable: Int32Array[];

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

@@ -0,0 +1,29 @@
+import {
+    Mesh,
+    BufferGeometry,
+    ColorRepresentation,
+    TextureEncoding,
+    WebGLRenderTarget,
+    PerspectiveCamera,
+} from '../../../src/Three.js';
+
+export interface ReflectorOptions {
+    color?: ColorRepresentation;
+    textureWidth?: number;
+    textureHeight?: number;
+    clipBias?: number;
+    shader?: object;
+    encoding?: TextureEncoding;
+    multisample?: number;
+}
+
+export class Reflector extends Mesh {
+    type: 'Reflector';
+    camera: PerspectiveCamera;
+
+    constructor(geometry?: BufferGeometry, options?: ReflectorOptions);
+
+    getRenderTarget(): WebGLRenderTarget;
+
+    dispose(): void;
+}

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

@@ -0,0 +1,31 @@
+import { Clock, WebGLRenderer, WebGLRenderTarget } from '../../../src/Three.js';
+
+import { Pass, FullScreenQuad } from './Pass.js';
+import { ShaderPass } from './ShaderPass.js';
+
+export { FullScreenQuad } from './Pass.js';
+export { Pass };
+
+export class EffectComposer {
+    constructor(renderer: WebGLRenderer, renderTarget?: WebGLRenderTarget);
+    renderer: WebGLRenderer;
+    renderTarget1: WebGLRenderTarget;
+    renderTarget2: WebGLRenderTarget;
+    writeBuffer: WebGLRenderTarget;
+    readBuffer: WebGLRenderTarget;
+    passes: Pass[];
+    copyPass: ShaderPass;
+    clock: Clock;
+    renderToScreen: boolean;
+
+    swapBuffers(): void;
+    addPass(pass: Pass): void;
+    insertPass(pass: Pass, index: number): void;
+    removePass(pass: Pass): void;
+    isLastEnabledPass(passIndex: number): boolean;
+    render(deltaTime?: number): void;
+    reset(renderTarget?: WebGLRenderTarget): void;
+    setSize(width: number, height: number): void;
+    setPixelRatio(pixelRatio: number): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,31 @@
+import { Material, WebGLRenderer, WebGLRenderTarget } from '../../../src/Three.js';
+
+export class Pass {
+    constructor();
+
+    isPass: boolean;
+    enabled: boolean;
+    needsSwap: boolean;
+    clear: boolean;
+    renderToScreen: boolean;
+
+    setSize(width: number, height: number): void;
+    render(
+        renderer: WebGLRenderer,
+        writeBuffer: WebGLRenderTarget,
+        readBuffer: WebGLRenderTarget,
+        deltaTime: number,
+        maskActive: boolean,
+    ): void;
+
+    dispose(): void;
+}
+
+export class FullScreenQuad {
+    constructor(material?: Material);
+
+    render(renderer: WebGLRenderer): void;
+    dispose(): void;
+
+    material: Material;
+}

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

@@ -0,0 +1,12 @@
+import { ShaderMaterial, WebGLRenderTarget } from '../../../src/Three.js';
+
+import { Pass, FullScreenQuad } from './Pass.js';
+
+export class SavePass extends Pass {
+    constructor(renderTarget?: WebGLRenderTarget);
+    textureID: string;
+    renderTarget: WebGLRenderTarget;
+    uniforms: object;
+    material: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+}

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

@@ -0,0 +1,11 @@
+import { ShaderMaterial } from '../../../src/Three.js';
+
+import { Pass, FullScreenQuad } from './Pass.js';
+
+export class ShaderPass extends Pass {
+    constructor(shader: object, textureID?: string);
+    textureID: string;
+    uniforms: { [name: string]: { value: any } };
+    material: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+}

three/examples/jsm/renderers/CSS3DRenderer.d.ts

@@ -0,0 +1,26 @@
+import { Object3D, Scene, Camera } from '../../../src/Three.js';
+
+export class CSS3DObject extends Object3D {
+    constructor(element: HTMLElement);
+    element: HTMLElement;
+
+    onBeforeRender: (renderer: unknown, scene: Scene, camera: Camera) => void;
+    onAfterRender: (renderer: unknown, scene: Scene, camera: Camera) => void;
+}
+
+export class CSS3DSprite extends CSS3DObject {
+    constructor(element: HTMLElement);
+}
+
+export interface CSS3DParameters {
+    element?: HTMLElement;
+}
+
+export class CSS3DRenderer {
+    constructor(parameters?: CSS3DParameters);
+    domElement: HTMLElement;
+
+    getSize(): { width: number; height: number };
+    setSize(width: number, height: number): void;
+    render(scene: Scene, camera: Camera): void;
+}

three/examples/jsm/renderers/webgl/nodes/SlotNode.d.ts

@@ -0,0 +1,17 @@
+import Node from '../../../nodes/core/Node.js';
+
+export interface SlotNodeParameters<TNode extends Node = Node> {
+    node?: TNode;
+    nodeType?: string;
+    source?: string | null;
+    target?: string | null;
+}
+
+export default class SlotNode<TNode extends Node = Node> extends Node {
+    inclusionType: 'replace';
+    node: TNode | null;
+    source: null;
+    target: null;
+
+    constructor(params: SlotNodeParameters<TNode>);
+}

three/examples/jsm/renderers/webgl/nodes/WebGLNodeBuilder.d.ts

@@ -0,0 +1,37 @@
+import NodeBuilder from '../../../nodes/core/NodeBuilder.js';
+import { Renderer, Object3D } from '../../../../../src/Three.js';
+import Node from '../../../nodes/core/Node.js';
+import SlotNode from './SlotNode.js';
+import { NodeShaderStageOption } from '../../../nodes/core/constants.js';
+
+export class WebGLNodeBuilder extends NodeBuilder {
+    constructor(
+        object: Object3D,
+        renderer: Renderer,
+        shader: { uniforms: any; vertexShader: any; fragmentShader: any },
+    );
+
+    addSlot(shaderStage: NodeShaderStageOption, slotNode: SlotNode): Node;
+
+    getUniforms(shaderStage: string): string;
+
+    getAttributes(shaderStage: string): string;
+
+    getVarys(shaderStage: string): string;
+
+    addCode(shaderStage: string, source: string, code: string, scope?: this): string;
+    addCodeAfterInclude(shaderStage: string, snippet: string, code: string): string;
+
+    replaceCode(shaderStage: string, source: string, target: string, scope?: this): void;
+    parseInclude(shaderStage: string, ...includes: string[]): void;
+
+    getInstanceIndex(): string;
+    getFrontFacing(): string;
+    getFragCoord(): 'gl_FragCoord';
+    isFlipY(): true;
+
+    buildCode(): void;
+    build(): this;
+
+    getSlot(shaderStage: string, name: string): Node;
+}

three/examples/jsm/renderers/webgl/nodes/WebGLNodes.d.ts

@@ -0,0 +1,3 @@
+import NodeFrame from '../../../nodes/core/NodeFrame.js';
+
+export const nodeFrame: NodeFrame;

three/examples/jsm/shaders/ACESFilmicToneMappingShader.d.ts

@@ -0,0 +1,10 @@
+import { IUniform, Texture } from '../../../src/Three.js';
+
+export const ACESFilmicToneMappingShader: {
+    uniforms: {
+        tDiffuse: IUniform<Texture>;
+        exposure: IUniform<number>;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

three/examples/jsm/shaders/BokehShader2.d.ts

@@ -0,0 +1,42 @@
+import { IUniform } from '../../../src/Three.js';
+
+export interface BokehShaderUniforms {
+    textureWidth: IUniform;
+    textureHeight: IUniform;
+    focalDepth: IUniform;
+    focalLength: IUniform;
+    fstop: IUniform;
+    tColor: IUniform;
+    tDepth: IUniform;
+    maxblur: IUniform;
+    showFocus: IUniform;
+    manualdof: IUniform;
+    vignetting: IUniform;
+    depthblur: IUniform;
+    threshold: IUniform;
+    gain: IUniform;
+    bias: IUniform;
+    fringe: IUniform;
+    znear: IUniform;
+    zfar: IUniform;
+    noise: IUniform;
+    dithering: IUniform;
+    pentagon: IUniform;
+    shaderFocus: IUniform;
+    focusCoords: IUniform;
+}
+
+export const BokehShader: {
+    uniforms: BokehShaderUniforms;
+    vertexShader: string;
+    fragmentShader: string;
+};
+
+export const BokehDepthShader: {
+    uniforms: {
+        mNear: IUniform;
+        mFar: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

three/examples/jsm/shaders/ToonShader.d.ts

@@ -0,0 +1,54 @@
+import { IUniform } from '../../../src/Three.js';
+
+export const ToonShader1: {
+    uniforms: {
+        uDirLightPos: IUniform;
+        uDirLightColor: IUniform;
+        uAmbientLightColor: IUniform;
+        uBaseColor: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+
+export const ToonShader2: {
+    uniforms: {
+        uDirLightPos: IUniform;
+        uDirLightColor: IUniform;
+        uAmbientLightColor: IUniform;
+        uBaseColor: IUniform;
+        uLineColor1: IUniform;
+        uLineColor2: IUniform;
+        uLineColor3: IUniform;
+        uLineColor4: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+
+export const ToonShaderHatching: {
+    uniforms: {
+        uDirLightPos: IUniform;
+        uDirLightColor: IUniform;
+        uAmbientLightColor: IUniform;
+        uBaseColor: IUniform;
+        uLineColor1: IUniform;
+        uLineColor2: IUniform;
+        uLineColor3: IUniform;
+        uLineColor4: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+
+export const ToonShaderDotted: {
+    uniforms: {
+        uDirLightPos: IUniform;
+        uDirLightColor: IUniform;
+        uAmbientLightColor: IUniform;
+        uBaseColor: IUniform;
+        uLineColor1: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

three/examples/jsm/shaders/VelocityShader.d.ts

@@ -0,0 +1,13 @@
+import { IUniform, UniformsLib } from '../../../src/Three.js';
+
+export const VelocityShader: {
+    uniforms: (typeof UniformsLib)['common'] &
+        (typeof UniformsLib)['displacementmap'] & {
+            modelMatrixPrev: IUniform;
+            currentProjectionViewMatrix: IUniform;
+            previousProjectionViewMatrix: IUniform;
+        };
+
+    fragmentShader: string;
+    vertexShader: string;
+};

three/examples/jsm/textures/FlakesTexture.d.ts

@@ -0,0 +1,3 @@
+export class FlakesTexture extends HTMLCanvasElement {
+    constructor(width?: number, height?: number);
+}

three/examples/jsm/utils/CameraUtils.d.ts

@@ -0,0 +1,9 @@
+import { PerspectiveCamera, Vector3 } from '../../../src/Three.js';
+
+export function frameCorners(
+    camera: PerspectiveCamera,
+    bottomLeftCorner: Vector3,
+    bottomRightCorner: Vector3,
+    topLeftCorner: Vector3,
+    estimateViewFrustum?: boolean,
+): void;

three/examples/jsm/utils/GeometryUtils.d.ts

@@ -0,0 +1,25 @@
+import { Vector3 } from '../../../src/Three.js';
+
+export function hilbert2D(
+    center?: Vector3,
+    size?: number,
+    iterations?: number,
+    v0?: number,
+    v1?: number,
+    v2?: number,
+    v3?: number,
+): Vector3[];
+export function hilbert3D(
+    center?: Vector3,
+    size?: number,
+    iterations?: number,
+    v0?: number,
+    v1?: number,
+    v2?: number,
+    v3?: number,
+    v4?: number,
+    v5?: number,
+    v6?: number,
+    v7?: number,
+): Vector3[];
+export function gosper(size?: number): number[];

three/examples/jsm/utils/LDrawUtils.d.ts

@@ -0,0 +1,5 @@
+import { Group, Object3D } from '../../../src/Three.js';
+
+export namespace LDrawUtils {
+    function mergeObject(object: Object3D): Group;
+}

three/examples/jsm/utils/ShadowMapViewer.d.ts

@@ -0,0 +1,24 @@
+import { Light, Renderer } from '../../../src/Three.js';
+
+export interface Size {
+    width: number;
+    height: number;
+    set: (width: number, height: number) => void;
+}
+
+export interface Position {
+    x: number;
+    y: number;
+    set: (x: number, y: number) => void;
+}
+
+export class ShadowMapViewer {
+    constructor(light: Light);
+
+    enabled: boolean;
+    size: Size;
+    position: Position;
+    render(renderer: Renderer): void;
+    updateForWindowResize(): void;
+    update(): void;
+}

three/examples/jsm/webxr/VRButton.d.ts

@@ -0,0 +1,5 @@
+import { WebGLRenderer } from '../../../src/Three.js';
+
+export namespace VRButton {
+    function createButton(renderer: WebGLRenderer): HTMLElement;
+}

three/examples/jsm/webxr/XRButton.d.ts

@@ -0,0 +1,6 @@
+import { WebGLRenderer } from '../../../src/Three.js';
+
+// tslint:disable-next-line:no-unnecessary-class
+export class XRButton {
+    static createButton(renderer: WebGLRenderer): HTMLElement;
+}

three/examples/jsm/webxr/XRControllerModelFactory.d.ts

@@ -0,0 +1,21 @@
+import { Group, Object3D, Texture } from '../../../src/Three.js';
+
+import { GLTFLoader } from '../loaders/GLTFLoader.js';
+
+export class XRControllerModel extends Object3D {
+    constructor();
+
+    motionController: any;
+
+    envMap: Texture;
+
+    setEnvironmentMap(envMap: Texture): XRControllerModel;
+}
+
+export class XRControllerModelFactory {
+    constructor(gltfLoader?: GLTFLoader);
+    gltfLoader: GLTFLoader | null;
+    path: string;
+
+    createControllerModel(controller: Group): XRControllerModel;
+}

three/examples/jsm/webxr/XRHandMeshModel.d.ts

@@ -0,0 +1,11 @@
+import { Object3D } from '../../../src/Three.js';
+
+export class XRHandMeshModel {
+    controller: Object3D;
+    handModel: Object3D;
+    bones: Object3D[];
+
+    constructor(handModel: Object3D, controller: Object3D, path: string, handedness: string);
+
+    updateMesh(): void;
+}

three/examples/jsm/webxr/XRHandModelFactory.d.ts

@@ -0,0 +1,25 @@
+import { Group, Object3D } from '../../../src/Three.js';
+
+import { XRHandPrimitiveModel, XRHandPrimitiveModelOptions } from './XRHandPrimitiveModel.js';
+import { XRHandMeshModel } from './XRHandMeshModel.js';
+
+export type XRHandModelHandedness = 'left' | 'right';
+
+export class XRHandModel extends Object3D {
+    constructor();
+
+    motionController: XRHandPrimitiveModel | XRHandMeshModel;
+}
+
+export class XRHandModelFactory {
+    constructor();
+    path: string;
+
+    setPath(path: string): XRHandModelFactory;
+
+    createHandModel(
+        controller: Group,
+        profile?: 'spheres' | 'boxes' | 'mesh',
+        options?: XRHandPrimitiveModelOptions,
+    ): XRHandModel;
+}

three/examples/jsm/webxr/XRHandPrimitiveModel.d.ts

@@ -0,0 +1,24 @@
+import { Group, Texture } from '../../../src/Three.js';
+
+import { XRHandModel, XRHandModelHandedness } from './XRHandModelFactory.js';
+
+export interface XRHandPrimitiveModelOptions {
+    primitive?: 'sphere' | 'box' | undefined;
+}
+
+export class XRHandPrimitiveModel {
+    controller: Group;
+    handModel: XRHandModel;
+    envMap: Texture | null;
+    handMesh: Group;
+
+    constructor(
+        handModel: XRHandModel,
+        controller: Group,
+        path: string,
+        handedness: XRHandModelHandedness,
+        options: XRHandPrimitiveModelOptions,
+    );
+
+    updateMesh: () => void;
+}

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.157.1",
+    "version": "0.157.2",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -43,6 +43,6 @@
         "fflate": "~0.6.10",
         "meshoptimizer": "~0.18.1"
     },
-    "typesPublisherContentHash": "d9388a18bbcf88aa18fface6fb06534b21e5cbb2b9d6df028f4c585cfc72e00c",
+    "typesPublisherContentHash": "793c51304c26c918dd5ee5b103fbcbcf8155af7cb9cceb2837b49309565f40d6",
     "typeScriptVersion": "4.5"
 }

three/src/extras/Earcut.d.ts

@@ -0,0 +1,15 @@
+/**
+ * An implementation of the {@link Earcut} polygon triangulation algorithm
+ * @remarks
+ * The code is a port of {@link https://github.com/mapbox/earcut | mapbox/earcut}.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/Earcut | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/Earcut.js | Source}
+ */
+export const Earcut: {
+    /**
+     * Triangulates the given shape definition by returning an array of triangles
+     * @remarks
+     * A triangle is defined by three consecutive integers representing vertex indices.
+     */
+    triangulate(data: number[], holeIndices?: number[], dim?: number): number[];
+};