@types/three 0.158.0 → 0.158.2

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, 27 Oct 2023 18:16:28 GMT
+ * Last updated: Tue, 07 Nov 2023 15:11:36 GMT
  * Dependencies: [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/webxr](https://npmjs.com/package/@types/webxr), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
 
 # Credits

three/examples/jsm/capabilities/WebGPU.d.ts

@@ -0,0 +1,5 @@
+// tslint:disable-next-line:no-unnecessary-class
+export default class WebGPU {
+    static isAvailable(): boolean;
+    static getErrorMessage(): HTMLElement;
+}

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

@@ -0,0 +1,31 @@
+import { Camera, Vector3 } from '../../../src/Three.js';
+
+export class FirstPersonControls {
+    constructor(object: Camera, domElement?: HTMLElement);
+
+    object: Camera;
+    domElement: HTMLElement | Document;
+
+    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;
+
+    handleResize(): void;
+
+    lookAt(x: Vector3): this;
+    lookAt(x: number, y: number, z: number): this;
+
+    update(delta: number): this;
+    dispose(): void;
+}

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

@@ -0,0 +1,16 @@
+import { BufferGeometry, WebGLRenderer, WebGLRenderTarget } from '../../../src/Three.js';
+
+export class SDFGeometryGenerator {
+    constructor(renderer: WebGLRenderer);
+
+    generate(res?: number, distFunc?: string, bounds?: number): BufferGeometry;
+
+    computeSDF(
+        width: number,
+        height: number,
+        tilesX: number,
+        tilesY: number,
+        bounds: number,
+        shader: string,
+    ): WebGLRenderTarget;
+}

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

@@ -0,0 +1,115 @@
+import { ExtrudeGeometry, ExtrudeGeometryOptions, Shape } from '../../../src/Three.js';
+
+import { Font } from '../loaders/FontLoader.js';
+
+export interface TextGeometryParameters extends ExtrudeGeometryOptions {
+    font: Font;
+
+    /**
+     * Size of the text
+     * Expects a `Float`.
+     * @defaultValue `100`
+     */
+    size?: number | undefined;
+
+    /**
+     * Thickness to extrude text.
+     * Expects a `Float`.
+     * @defaultValue `50`
+     */
+    height?: number | undefined;
+
+    /**
+     * @override
+     * @defaultValue `12`
+     */
+    curveSegments?: number | undefined;
+
+    /**
+     * @defaultValue `false`
+     */
+    bevelEnabled?: boolean | undefined;
+
+    /**
+     * How deep into text bevel goes.
+     * Expects a `Float`.
+     * @override
+     * @defaultValue `10`
+     */
+    bevelThickness?: number | undefined;
+
+    /**
+     * How far from text outline is bevel.
+     * Expects a `Float`.
+     * @override
+     * @defaultValue `8`
+     */
+    bevelSize?: number | undefined;
+
+    /**
+     * How far from text outline bevel starts.
+     * Expects a `Float`.
+     * @override
+     * @defaultValue `0`
+     */
+    bevelOffset?: number | undefined;
+
+    /**
+     * @override
+     * @defaultValue `3`
+     */
+    bevelSegments?: number | undefined;
+}
+
+/**
+ * A class for generating text as a single geometry
+ * @remarks
+ * It is constructed by providing a string of text, and a set of parameters consisting of a loaded font and settings for the geometry's parent {@link THREE.ExtrudeGeometry | ExtrudeGeometry}
+ * See the {@link THREE.FontLoader | FontLoader} page for additional details.
+ * @example
+ * ```typescript
+ * const loader = new FontLoader();
+ * loader.load('fonts/helvetiker_regular.typeface.json', function (font) {
+ *     const geometry = new TextGeometry('Hello three.js!', {
+ *         font: font,
+ *         size: 80,
+ *         height: 5,
+ *         curveSegments: 12,
+ *         bevelEnabled: true,
+ *         bevelThickness: 10,
+ *         bevelSize: 8,
+ *         bevelOffset: 0,
+ *         bevelSegments: 5
+ *     });
+ * });
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_text | geometry / text }
+ * @see {@link https://threejs.org/docs/index.html#api/en/C:/rafaelsc/Source/threejs/three.js/docs/examples/en/geometries/TextGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/examples/jsm/geometries/TextGeometry.js | Source}
+ */
+export class TextGeometry extends ExtrudeGeometry {
+    /**
+     * Create a new instance of {@link TextGeometry}
+     * @param text The text that needs to be shown.
+     * @param parameters Object that can contain the following parameters. @see {@link TextGeometryParameters} for defaults.
+     */
+    constructor(text: string, parameters?: TextGeometryParameters);
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `TextGeometry`
+     */
+    override readonly type: string | 'TextGeometry';
+
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly shapes: Shape | Shape[];
+        readonly options: TextGeometryParameters;
+    };
+}
+
+export { TextGeometry as TextBufferGeometry };

three/examples/jsm/lights/IESSpotLight.d.ts

@@ -0,0 +1,5 @@
+import { SpotLight, Texture } from 'three';
+
+export default class IESSpotLight extends SpotLight {
+    iesMap: Texture | null;
+}

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

@@ -0,0 +1,27 @@
+import { Shape, Loader, LoadingManager } from '../../../src/Three.js';
+
+export class FontLoader extends Loader<Font> {
+    constructor(manager?: LoadingManager);
+
+    load(
+        url: string,
+        onLoad?: (data: Font) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): void;
+
+    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/HDRCubeTextureLoader.d.ts

@@ -0,0 +1,18 @@
+import { CubeTexture, Loader, LoadingManager, TextureDataType } from '../../../src/Three.js';
+
+import { RGBELoader } from './RGBELoader.js';
+
+export class HDRCubeTextureLoader extends Loader<CubeTexture, readonly string[]> {
+    constructor(manager?: LoadingManager);
+    hdrLoader: RGBELoader;
+    type: TextureDataType;
+
+    load(
+        url: readonly string[],
+        onLoad?: (data: CubeTexture) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): CubeTexture;
+
+    setDataType(type: TextureDataType): this;
+}

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

@@ -0,0 +1,5 @@
+import { DataTexture, Loader } from 'three';
+
+export class IESLoader extends Loader<DataTexture> {
+    parse(text: string): DataTexture;
+}

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

@@ -0,0 +1,32 @@
+import { CubeTexture, LoadingManager, DataTextureLoader, PixelFormat, TextureDataType } from '../../../src/Three.js';
+
+export interface RGBM {
+    width: number;
+    height: number;
+    data: Uint16Array | Float32Array;
+    header: string;
+    format: PixelFormat;
+    type: TextureDataType;
+    flipY: boolean;
+}
+
+export class RGBMLoader extends DataTextureLoader {
+    type: TextureDataType;
+
+    maxRange: number;
+
+    constructor(manager?: LoadingManager);
+
+    loadCubemap(
+        urls: string[],
+        onLoad?: (texture: CubeTexture) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (event: ErrorEvent) => void,
+    ): CubeTexture;
+
+    parse(buffer: ArrayBuffer): RGBM;
+
+    setDataType(dataType: TextureDataType): this;
+
+    setMaxRange(value: number): this;
+}

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

@@ -0,0 +1,9 @@
+import { BufferGeometry } from '../../../src/Three.js';
+
+export class TessellateModifier {
+    constructor(maxEdgeLength?: number, maxIterations?: number);
+    maxEdgeLength: number;
+    maxIterations: number;
+
+    modify<TGeometry extends BufferGeometry>(geometry: TGeometry): TGeometry;
+}

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

@@ -0,0 +1,57 @@
+import { Matrix4, Mesh, BufferGeometry, Material, DataTexture, IUniform } from '../../../src/Three.js';
+
+declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
+    _vertexStarts: number[];
+    _vertexCounts: number[];
+    _indexStarts: number[];
+    _indexCounts: number[];
+
+    _visible: boolean[];
+    _active: boolean[];
+
+    _maxGeometryCount: number;
+    _maxVertexCount: number;
+    _maxIndexCount: number;
+
+    _geometryInitialized: boolean;
+    _geometryCount: number;
+    _vertexCount: number;
+    _indexCount: number;
+
+    _matrices: Matrix4[];
+    _matricesTexture: DataTexture | null;
+
+    _customUniforms: Record<string, IUniform>;
+
+    constructor(maxGeometryCount: number, maxVertexCount: number, maxIndexCount?: number, material?: Material);
+
+    _initMatricesTexture(): void;
+
+    _initShader(): void;
+
+    _initializeGeometry(reference: BufferGeometry): void;
+
+    getGeometryCount(): number;
+
+    getVertexCount(): number;
+
+    getIndexCount(): number;
+
+    applyGeometry(geometry: BufferGeometry): number;
+
+    deleteGeometry(geometryId: number): this;
+
+    optimize(): never;
+
+    setMatrixAt(geometryId: number, matrix: Matrix4): this;
+
+    getMatrixAt(geometryId: number, matrix: Matrix4): Matrix4;
+
+    setVisibleAt(geometryId: number, value: boolean): this;
+
+    getVisibleAt(geometryId: number): boolean;
+
+    dispose(): this;
+}
+
+export { BatchedMesh };

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

@@ -0,0 +1,13 @@
+import { Mesh, IcosahedronGeometry, ShaderMaterial, Texture } from '../../../src/Three.js';
+
+export class GroundProjectedSkybox extends Mesh<IcosahedronGeometry, ShaderMaterial> {
+    constructor(texture: Texture, options?: { height?: number; radius?: number });
+
+    set radius(radius: number);
+
+    get radius(): number;
+
+    set height(height: number);
+
+    get height(): number;
+}

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/renderers/common/Animation.d.ts

@@ -0,0 +1,16 @@
+export default class Animation {
+    animationLoop: ((time: DOMHighResTimeStamp) => void) | null;
+    requestId: number | null;
+
+    isAnimating: boolean;
+
+    context: Window;
+
+    constructor();
+
+    start(): void;
+
+    stop(): void;
+
+    setAnimationLoop(callback: ((time: DOMHighResTimeStamp) => void) | null): void;
+}

three/examples/jsm/renderers/webgl/WebGLBackend.d.ts

@@ -0,0 +1,8 @@
+import { CoordinateSystem } from '../../../../src/Three.js';
+import Backend from '../common/Backend.js';
+
+export default class WebGLBackend extends Backend {
+    constructor(parameters?: { canvas?: HTMLCanvasElement | undefined });
+
+    get coordinateSystem(): CoordinateSystem;
+}

three/examples/jsm/renderers/webgpu/WebGPUBackend.d.ts

@@ -0,0 +1,12 @@
+import { CoordinateSystem } from '../../../../src/Three.js';
+import Backend from '../common/Backend.js';
+
+export default class WebGPUBackend extends Backend {
+    constructor(parameters?: {
+        canvas?: HTMLCanvasElement | undefined;
+        antialias?: boolean | undefined;
+        sampleCount?: number | undefined;
+    });
+
+    get coordinateSystem(): CoordinateSystem;
+}

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

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

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

@@ -0,0 +1,15 @@
+import { IUniform } from '../../../src/Three.js';
+
+export const MMDToonShader: {
+    name: string;
+    defines: {
+        TOON: boolean;
+        MATCAP: boolean;
+        MATCAP_BLENDING_ADD: boolean;
+    };
+    uniforms: {
+        [key: string]: 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/textures/FlakesTexture.d.ts

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

three/examples/jsm/transpiler/AST.d.ts

@@ -0,0 +1,7 @@
+export class Program {
+    body: unknown[];
+
+    isProgram: true;
+
+    constructor();
+}

three/examples/jsm/transpiler/GLSLDecoder.d.ts

@@ -0,0 +1,7 @@
+import { Program } from './AST.js';
+
+export default class GLSLDecoder {
+    constructor();
+
+    parse(source: string): Program;
+}

three/examples/jsm/transpiler/ShaderToyDecoder.d.ts

@@ -0,0 +1,3 @@
+import GLSLDecoder from './GLSLDecoder.js';
+
+export default class ShaderToyDecoder extends GLSLDecoder {}

three/examples/jsm/transpiler/TSLEncoder.d.ts

@@ -0,0 +1,7 @@
+import { Program } from './AST.js';
+
+export default class TSLEncoder {
+    constructor();
+
+    emit(ast: Program): string;
+}

three/examples/jsm/transpiler/Transpiler.d.ts

@@ -0,0 +1,5 @@
+export default class Transpiler<U, V> {
+    constructor(decoder: { parse(source: string): U }, encoder: { emit(decoded: U): V });
+
+    parse(source: string): V;
+}

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/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/utils/TextureUtils.d.ts

@@ -0,0 +1,3 @@
+import { Texture, WebGLRenderer } from 'three';
+
+export function decompress(texture: Texture, maxTextureSize?: number, renderer?: WebGLRenderer): Texture;

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

@@ -0,0 +1,26 @@
+/**
+ * @author Deepkolos / https://github.com/deepkolos
+ */
+
+export class WorkerPool {
+    pool: number;
+    quene: Array<{
+        resolve: (e: any) => void;
+        msg: any;
+        transfer: Array<Transferable>;
+    }>;
+    workers: Array<Worker>;
+    workersResolve: Array<(e: any) => void>;
+    workerStatus: number;
+
+    constructor(pool?: number);
+
+    _initWorker(workerId: number): void;
+    workerCreator(): Worker;
+    _getIdleWorker(): void;
+    _onMessage(workerId: number, msg: any): void;
+    setWorkerCreator(workerCreator: () => Worker): void;
+    setWorkerLimit(pool: number): void;
+    postMessage(msg: any, transfer?: Array<Transferable>): Promise<MessageEvent>;
+    dispose(): void;
+}

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.158.0",
+    "version": "0.158.2",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -44,6 +44,6 @@
         "fflate": "~0.6.10",
         "meshoptimizer": "~0.18.1"
     },
-    "typesPublisherContentHash": "255a6a1803d2017678c3abe305771d2dc7b3a2db590cb731e2a0f99e04dfcc14",
+    "typesPublisherContentHash": "bd30f665c4aae2d34cec74eb774bbf624c68e8e74c75646018eab04f646058f2",
     "typeScriptVersion": "4.5"
 }