@types/three 0.159.0 → 0.161.0

three/examples/jsm/renderers/common/Renderer.d.ts

@@ -1,42 +1,281 @@
-import { Camera, ColorSpace, CoordinateSystem, Scene, ToneMapping } from '../../../../src/Three.js';
+import {
+    Camera,
+    ColorSpace,
+    CoordinateSystem,
+    Scene,
+    ToneMapping,
+    Vector2,
+    Vector4,
+    Color,
+    Object3D,
+    RenderTarget,
+    FramebufferTexture,
+    BufferGeometry,
+    Material,
+    Group,
+} from '../../../../src/Three.js';
 import Backend from './Backend.js';
 import Info from './Info.js';
+import Color4 from './../common/Color4.js';
+import ComputeNode from '../../nodes/gpgpu/ComputeNode.js';
+import LightsNode from '../../nodes/lighting/LightsNode.js';
 
+export interface RendererParameters {
+    logarithmicDepthBuffer?: boolean | undefined;
+    alpha?: boolean | undefined;
+}
+
+/**
+ * Generic Renderer interface containing either a WebGL or WebGPU backend.
+ */
 export default class Renderer {
-    isRenderer: true;
+    /**
+     * @default true
+     */
+    readonly isRenderer: true;
 
     domElement: HTMLCanvasElement;
 
+    /**
+     * The renderer backend; could be WebGLBackend or WebGPUBackend
+     */
     backend: Backend;
 
+    /**
+     * @default true
+     */
     autoClear: boolean;
+
+    /**
+     * @default true
+     */
     autoClearColor: boolean;
+
+    /**
+     * @default true
+     */
     autoClearDepth: boolean;
+
+    /**
+     * @default true
+     */
     autoClearStencil: boolean;
 
+    /**
+     * @default SRGBColorSpace
+     */
     outputColorSpace: ColorSpace;
 
+    /**
+     * @default NoToneMapping
+     */
     toneMapping: ToneMapping;
+
+    /**
+     * @default 1.0
+     */
     toneMappingExposure: number;
 
+    /**
+     * @default true
+     */
     sortObjects: boolean;
 
+    /**
+     * @default true
+     */
     depth: boolean;
+
+    /**
+     * @default true
+     */
     stencil: boolean;
 
     info: Info;
 
-    constructor(backend: Backend, parameters?: { logarithmicDepthBuffer?: boolean | undefined });
+    constructor(backend: Backend, parameters?: RendererParameters);
 
     init(): Promise<void>;
 
     get coordinateSystem(): CoordinateSystem;
 
-    render(scene: Scene, camera: Camera): Promise<void>;
+    compileAsync(scene: Scene, camera: Camera, targetScene?: Scene | null): Promise<void>;
+
+    renderAsync(scene: Scene, camera: Camera): Promise<void>;
+
+    getMaxAnisotropy(): number;
+
+    getActiveCubeFace(): number;
+
+    getActiveMipmapLevel(): number;
 
     setAnimationLoop(callback: ((time: DOMHighResTimeStamp) => void) | null): Promise<void>;
 
+    /**
+     * Sets the pixel ratio of the Renderer.
+     */
     setPixelRatio(value?: number): void;
 
+    /**
+     * Sets the width and height of the output canvas and optionally updates the CSS style on the DOM element.
+     */
     setSize(width: number, height: number, updateStyle?: boolean): void;
+
+    /**
+     * Gets the Rendering Context of the renderer.
+     */
+    getContext(): RenderingContext;
+
+    /**
+     * Gets the current pixel ratio of the renderer.
+     */
+    getPixelRatio(): number;
+
+    getDrawingBufferSize(target: Vector2): Vector2;
+
+    getSize(target: Vector2): Vector2;
+
+    setDrawingBufferSize(width: number, height: number, pixelRatio: number): void;
+
+    /**
+     * Sets the custom opaque sort function for the RenderLists. Pass null to use the default painterSortStable function.
+     */
+    setOpaqueSort(method: (a: unknown, b: unknown) => number): void;
+
+    /**
+     * Sets the custom transparent sort function for the RenderLists. Pass null to use the default reversePainterSortStable function.
+     */
+    setTransparentSort(method: (a: unknown, b: unknown) => number): void;
+
+    /**
+     * Copies the scissor area into target.
+     */
+    getScissor(target: Vector4): Vector4;
+
+    /**
+     * Sets the scissor area from (x, y) to (x + width, y + height).
+     */
+    setScissor(x: number, y: number, width: number, height: number): void;
+
+    /**
+     * Returns true if scissor test is enabled; returns false otherwise.
+     */
+    getScissorTest(): boolean;
+
+    /**
+     * Enable the scissor test. When this is enabled, only the pixels within the defined scissor area will be affected by further renderer actions.
+     */
+    setScissorTest(boolean: boolean): void;
+
+    /**
+     * Copies the viewport into target.
+     */
+    getViewport(target: Vector4): Vector4;
+
+    /**
+     * Sets the viewport to render from (x, y) to (x + width, y + height).
+     * (x, y) is the lower-left corner of the region.
+     */
+    setViewport(x: number, y: number, width: number, height: number, minDepth?: number, maxDepth?: number): void;
+
+    /**
+     * Returns a Color4 instance with the current clear color.
+     */
+    getClearColor(target: Color4): Color4;
+
+    /**
+     * Sets the clear color, using color for the color and alpha for the opacity.
+     */
+    setClearColor(color: Color, alpha?: number): void;
+
+    /**
+     * Returns a float with the current clear alpha. Ranges from 0 to 1.
+     */
+    getClearAlpha(): number;
+
+    setClearAlpha(alpha: number): void;
+
+    getClearDepth(): number;
+
+    setClearDepth(depth: number): void;
+
+    getClearStencil(): number;
+
+    setClearStencil(stencil: number): void;
+
+    isOccluded(object: Object3D): boolean;
+
+    /**
+     * Tells the renderer to clear its color, depth or stencil drawing buffer(s).
+     * Arguments default to true
+     */
+    clearAsync(color?: boolean, depth?: boolean, stencil?: boolean): Promise<void>;
+
+    /**
+     * Clear the color buffer. Equivalent to calling .clear( true, false, false ).
+     */
+    clearColorAsync(): Promise<void>;
+
+    /**
+     * Clear the depth buffer. Equivalent to calling .clear( false, true, false ).
+     */
+    clearDepthAsync(): Promise<void>;
+
+    /**
+     * Clear the stencil buffer. Equivalent to calling .clear( false, false, true ).
+     */
+    clearStencilAsync(): Promise<void>;
+
+    get currentColorSpace(): ColorSpace;
+
+    dispose(): void;
+
+    setRenderTarget(renderTarget: RenderTarget, activeCubeFace?: number, activeMipmapLevel?: number): void;
+
+    getRenderTarget(): RenderTarget;
+
+    setRenderObjectFunction(renderObjectFunction: () => {}): void;
+
+    getRenderObjectFunction(): () => {};
+
+    /**
+     * Runs a compute pipeline
+     */
+    computeAsync(computeNodes: ComputeNode | ComputeNode[]): Promise<void>;
+
+    hasFeature(name: string): boolean;
+
+    copyFramebufferToTexture(framebufferTexture: FramebufferTexture): void;
+
+    readRenderTargetPixelsAsync(
+        renderTarget: RenderTarget,
+        x: number,
+        y: number,
+        width: number,
+        height: number,
+    ): Promise<Float32Array | Uint16Array | Uint8Array | Int8Array | Int16Array | Uint32Array | Int32Array>;
+
+    renderObject(
+        object: Object3D,
+        scene: Scene,
+        camera: Camera,
+        geometry: BufferGeometry,
+        material: Material,
+        group: Group,
+        lightsNode: LightsNode,
+    ): void;
+
+    get compute(): (computeNodes: ComputeNode | ComputeNode[]) => Promise<void>;
+
+    get compile(): (scene: Scene, camera: Camera, targetScene?: Scene | null) => Promise<void>;
+
+    get render(): (scene: Scene, camera: Camera) => Promise<void>;
+
+    get clear(): (color?: boolean, depth?: boolean, stencil?: boolean) => Promise<void>;
+
+    get clearColor(): () => Promise<void>;
+
+    get clearDepth(): () => Promise<void>;
+
+    get clearStencil(): () => Promise<void>;
 }

three/examples/jsm/renderers/common/StorageTexture.d.ts

@@ -0,0 +1,5 @@
+import { Texture } from '../../../../src/Three.js';
+
+export default class StorageTexture extends Texture {
+    constructor(width?: number, height?: number);
+}

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

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

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

@@ -2,7 +2,7 @@ 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';
+import { NodeShaderStage } from '../../../nodes/core/constants.js';
 
 export class WebGLNodeBuilder extends NodeBuilder {
     constructor(
@@ -11,7 +11,7 @@ export class WebGLNodeBuilder extends NodeBuilder {
         shader: { uniforms: any; vertexShader: any; fragmentShader: any },
     );
 
-    addSlot(shaderStage: NodeShaderStageOption, slotNode: SlotNode): Node;
+    addSlot(shaderStage: NodeShaderStage, slotNode: SlotNode): Node;
 
     getUniforms(shaderStage: string): string;
 

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

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

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

@@ -1,12 +1,21 @@
 import { CoordinateSystem } from '../../../../src/Three.js';
-import Backend from '../common/Backend.js';
+import Backend, { BackendParameters } from '../common/Backend.js';
+
+export interface WebGPUBackendParameters extends BackendParameters {
+    alpha?: boolean | undefined;
+    antialias?: boolean | undefined;
+    sampleCount?: number | undefined;
+    trackTimestamp?: boolean | undefined;
+}
 
 export default class WebGPUBackend extends Backend {
-    constructor(parameters?: {
-        canvas?: HTMLCanvasElement | undefined;
-        antialias?: boolean | undefined;
-        sampleCount?: number | undefined;
-    });
+    readonly isWebGPUBackend: true;
+
+    constructor(parameters?: WebGPUBackendParameters);
 
     get coordinateSystem(): CoordinateSystem;
+
+    // utils public
+
+    getMaxAnisotropy(): number;
 }

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

@@ -1,10 +1,10 @@
-import Renderer from '../common/Renderer.js';
+import Renderer, { RendererParameters } from '../common/Renderer.js';
+import { WebGPUBackendParameters } from './WebGPUBackend.js';
+
+export interface WebGPURendererParameters extends RendererParameters, WebGPUBackendParameters {
+    forceWebGL?: boolean | undefined;
+}
 
 export default class WebGPURenderer extends Renderer {
-    constructor(parameters?: {
-        canvas?: HTMLCanvasElement | undefined;
-        antialias?: boolean | undefined;
-        sampleCount?: number | undefined;
-        logarithmicDepthBuffer?: boolean | undefined;
-    });
+    constructor(parameters?: WebGPURendererParameters);
 }

three/examples/jsm/shaders/{HBAOShader.d.ts → GTAOShader.d.ts}

@@ -1,14 +1,15 @@
-import { IUniform, Matrix4, Vector2 } from '../../../src/Three.js';
+import { DataTexture, IUniform, Matrix4, Vector2, Vector3 } from '../../../src/Three.js';
 
-export const HBAOShader: {
+export const GTAOShader: {
     name: string;
     defines: {
         PERSPECTIVE_CAMERA: number;
         SAMPLES: number;
-        SAMPLE_VECTORS: string;
         NORMAL_VECTOR_TYPE: number;
-        DEPTH_VALUE_SOURCE: number;
-        SAMPLING_FROM_NOISE: number;
+        DEPTH_SWIZZLING: string;
+        SCREEN_SPACE_RADIUS: number;
+        SCREEN_SPACE_RADIUS_SCALE: number;
+        SCENE_CLIP_BOX: number;
     };
     uniforms: {
         tNormal: IUniform;
@@ -21,13 +22,17 @@ export const HBAOShader: {
         cameraProjectionMatrixInverse: IUniform<Matrix4>;
         radius: IUniform<number>;
         distanceExponent: IUniform<number>;
-        bias: IUniform<number>;
+        thickness: IUniform<number>;
+        distanceFallOff: IUniform<number>;
+        scale: IUniform<number>;
+        sceneBoxMin: IUniform<Vector3>;
+        sceneBoxMax: IUniform<Vector3>;
     };
     vertexShader: string;
     fragmentShader: string;
 };
 
-export const HBAODepthShader: {
+export const GTAODepthShader: {
     name: string;
     defines: {
         PERSPECTIVE_CAMERA: number;
@@ -41,4 +46,14 @@ export const HBAODepthShader: {
     fragmentShader: string;
 };
 
-export function generateHaboSampleKernelInitializer(samples: number): string;
+export const GTAOBlendShader: {
+    name: string;
+    uniforms: {
+        tDiffuse: IUniform;
+        intensity: IUniform<number>;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+
+export function generateMagicSquareNoise(samples?: number): DataTexture;

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

@@ -25,4 +25,4 @@ export const PoissonDenoiseShader: {
     fragmentShader: string;
 };
 
-export function generatePdSamplePointInitializer(samples: number, rings: number): string;
+export function generatePdSamplePointInitializer(samples: number, rings: number, radiusExponent: number): string;

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

@@ -35,13 +35,3 @@ export function deinterleaveGeometry(geometry: BufferGeometry): void;
  * @param creaseAngle The crease angle in radians.
  */
 export function toCreasedNormals(geometry: BufferGeometry, creaseAngle?: number): BufferGeometry;
-
-/**
- * @deprecated Use mergeGeometries instead.
- */
-export function mergeBufferGeometries(geometries: BufferGeometry[], useGroups?: boolean): BufferGeometry;
-
-/**
- * @deprecated Use mergeAttributes instead.
- */
-export function mergeBufferAttributes(attributes: BufferAttribute[]): BufferAttribute;

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

@@ -1,6 +1,5 @@
-import { Group, Object3D, Texture } from '../../../src/Three.js';
-
-import { GLTFLoader } from '../loaders/GLTFLoader.js';
+import { Group, Loader, Object3D, Texture } from '../../../src/Three.js';
+import { GLTF } from '../loaders/GLTFLoader.js';
 
 export class XRControllerModel extends Object3D {
     constructor();
@@ -13,9 +12,11 @@ export class XRControllerModel extends Object3D {
 }
 
 export class XRControllerModelFactory {
-    constructor(gltfLoader?: GLTFLoader);
-    gltfLoader: GLTFLoader | null;
+    gltfLoader: Loader<GLTF> | null;
     path: string;
+    onLoad: ((scene: Group) => void) | null;
+
+    constructor(gltfLoader?: Loader<GLTF> | null, onLoad?: ((scene: Group) => void) | null);
 
     createControllerModel(controller: Group): XRControllerModel;
 }

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

@@ -1,11 +1,19 @@
-import { Object3D } from '../../../src/Three.js';
+import { Loader, Object3D } from '../../../src/Three.js';
+import { GLTF } from '../loaders/GLTFLoader.js';
 
 export class XRHandMeshModel {
     controller: Object3D;
     handModel: Object3D;
     bones: Object3D[];
 
-    constructor(handModel: Object3D, controller: Object3D, path: string, handedness: string);
+    constructor(
+        handModel: Object3D,
+        controller: Object3D,
+        path: string,
+        handedness: string,
+        loader?: Loader<GLTF> | null,
+        onLoad?: ((object: Object3D) => void) | null,
+    );
 
     updateMesh(): void;
 }

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.159.0",
+    "version": "0.161.0",
     "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": "00146f19c0acfa1923520aa89574fd3c011b0b97251b16d57b2bc5999534c2c9",
+    "typesPublisherContentHash": "3aa24058634b97c18523562ed8a4194a3a400d891c67daa36884efcbc24b62ef",
     "typeScriptVersion": "4.6"
 }

three/src/Three.d.ts

@@ -223,6 +223,7 @@ export * from './scenes/Scene.js';
  */
 export * from './textures/VideoTexture.js';
 export * from './textures/CompressedArrayTexture.js';
+export * from './textures/CompressedCubeTexture.js';
 export * from './textures/DataTexture.js';
 export * from './textures/CompressedTexture.js';
 export * from './textures/CubeTexture.js';

three/src/cameras/PerspectiveCamera.d.ts

@@ -1,4 +1,5 @@
 import { Camera } from './Camera.js';
+import { Vector2 } from '../math/Vector2.js';
 
 /**
  * Camera that uses {@link https://en.wikipedia.org/wiki/Perspective_(graphical) | perspective projection}.
@@ -148,6 +149,18 @@ export class PerspectiveCamera extends Camera {
      */
     getFilmHeight(): number;
 
+    /**
+     * Computes the 2D bounds of the camera's viewable rectangle at a given distance along the viewing direction.
+     * Sets minTarget and maxTarget to the coordinates of the lower-left and upper-right corners of the view rectangle.
+     */
+    getViewBounds(distance: number, minTarget: Vector2, maxTarget: Vector2): void;
+
+    /**
+     * Computes the width and height of the camera's viewable rectangle at a given distance along the viewing direction.
+     * Copies the result into the target Vector2, where x is width and y is height.
+     */
+    getViewSize(distance: number, minTarget: Vector2, maxTarget: Vector2): void;
+
     /**
      * Sets an offset in a larger frustum.
      * @remarks

three/src/constants.d.ts

@@ -37,12 +37,11 @@ export type ShadowMapType = typeof BasicShadowMap | typeof PCFShadowMap | typeof
 export const FrontSide: 0;
 export const BackSide: 1;
 export const DoubleSide: 2;
-export const TwoPassDoubleSide: 2;
 /**
  * Defines which side of faces will be rendered - front, back or both.
  * Default is {@link FrontSide}.
  */
-export type Side = typeof FrontSide | typeof BackSide | typeof DoubleSide | typeof TwoPassDoubleSide;
+export type Side = typeof FrontSide | typeof BackSide | typeof DoubleSide;
 
 // blending modes
 export const NoBlending: 0;
@@ -140,13 +139,15 @@ export const ReinhardToneMapping: 2;
 export const CineonToneMapping: 3;
 export const ACESFilmicToneMapping: 4;
 export const CustomToneMapping: 5;
+export const AgXToneMapping: 6;
 export type ToneMapping =
     | typeof NoToneMapping
     | typeof LinearToneMapping
     | typeof ReinhardToneMapping
     | typeof CineonToneMapping
     | typeof ACESFilmicToneMapping
-    | typeof CustomToneMapping;
+    | typeof CustomToneMapping
+    | typeof AgXToneMapping;
 
 // Bind modes
 export const AttachedBindMode: 'attached';

three/src/core/InterleavedBufferAttribute.d.ts

@@ -84,13 +84,23 @@ export class InterleavedBufferAttribute {
      * Applies normal matrix {@link Matrix3 | m} to every Vector3 element of this InterleavedBufferAttribute.
      * @param m
      */
-    applyNormalMatrix(matrix: Matrix): this;
+    applyNormalMatrix(m: Matrix): this;
 
     /**
      * Applies matrix {@link Matrix4 | m} to every Vector3 element of this InterleavedBufferAttribute, interpreting the elements as a direction vectors.
      * @param m
      */
-    transformDirection(matrix: Matrix): this;
+    transformDirection(m: Matrix): this;
+
+    /**
+     * Returns the given component of the vector at the given index.
+     */
+    getComponent(index: number, component: number): number;
+
+    /**
+     * Sets the given component of the vector at the given index.
+     */
+    setComponent(index: number, component: number, value: number): this;
 
     /**
      * Returns the x component of the item at the given index.