@types/three 0.179.0 → 0.181.0

three/src/nodes/utils/LoopNode.d.ts

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import { VarNode } from "../Nodes.js";
 
 interface LoopNodeObjectParameter {
     // TODO Expand to other types and update loop function types appropriately
@@ -10,6 +10,7 @@ interface LoopNodeObjectParameter {
     start: number | Node;
     end: number | Node;
     condition?: string;
+    update?: VarNode | number | string;
 }
 
 type LoopNodeParameter = Node | number | LoopNodeObjectParameter;
@@ -25,14 +26,14 @@ declare class LoopNode extends Node {
 export default LoopNode;
 
 interface Loop {
-    (i: LoopNodeParameter, func: (inputs: { readonly i: number }) => void): ShaderNodeObject<Node>;
+    (i: LoopNodeParameter, func: (inputs: { readonly i: Node }) => void): Node;
     (
         i: LoopNodeParameter,
         j: LoopNodeParameter,
-        func: (inputs: { readonly i: number; readonly j: number }) => void,
-    ): ShaderNodeObject<Node>;
+        func: (inputs: { readonly i: Node; readonly j: Node }) => void,
+    ): Node;
 }
 
 export const Loop: Loop;
-export const Continue: () => ShaderNodeObject<Node>;
-export const Break: () => ShaderNodeObject<Node>;
+export const Continue: () => Node;
+export const Break: () => Node;

three/src/nodes/utils/MatcapUV.d.ts

@@ -1,4 +1,3 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const matcapUV: ShaderNodeObject<Node>;
+export const matcapUV: Node;

three/src/nodes/utils/MaxMipLevelNode.d.ts

@@ -1,7 +1,6 @@
 import { Texture } from "../../textures/Texture.js";
 import TextureNode from "../accessors/TextureNode.js";
 import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class MaxMipLevelNode extends UniformNode<0> {
     constructor(textureNode: TextureNode);
@@ -11,4 +10,4 @@ export default class MaxMipLevelNode extends UniformNode<0> {
     get texture(): Texture;
 }
 
-export const maxMipLevel: (texture: Texture) => ShaderNodeObject<MaxMipLevelNode>;
+export const maxMipLevel: (texture: Texture) => MaxMipLevelNode;

three/src/nodes/utils/Oscillators.d.ts

@@ -1,7 +1,6 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const oscSine: (timeNode?: Node) => ShaderNodeObject<Node>;
-export const oscSquare: (timeNode?: Node) => ShaderNodeObject<Node>;
-export const oscTriangle: (timeNode?: Node) => ShaderNodeObject<Node>;
-export const oscSawtooth: (timeNode?: Node) => ShaderNodeObject<Node>;
+export const oscSine: (timeNode?: Node) => Node;
+export const oscSquare: (timeNode?: Node) => Node;
+export const oscTriangle: (timeNode?: Node) => Node;
+export const oscSawtooth: (timeNode?: Node) => Node;

three/src/nodes/utils/Packing.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const directionToColor: (node: Node) => ShaderNodeObject<Node>;
-export const colorToDirection: (node: Node) => ShaderNodeObject<Node>;
+export const directionToColor: (node: Node) => Node;
+export const colorToDirection: (node: Node) => Node;

three/src/nodes/utils/PostProcessingUtils.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 /**
  * Computes a position in view space based on a fragment's screen position expressed as uv coordinates, the fragments
@@ -14,7 +13,7 @@ export const getViewPosition: (
     screenPosition: Node,
     depth: Node,
     projectionMatrixInverse: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 /**
  * Computes a screen position expressed as uv coordinates based on a fragment's position in view space and the camera's
@@ -27,7 +26,7 @@ export const getViewPosition: (
 export const getScreenPosition: (
     viewPosition: Node,
     projectionMatrix: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 /**
  * Computes a normal vector based on depth data. Can be used as a fallback when no normal render target is available or
@@ -42,4 +41,6 @@ export const getNormalFromDepth: (
     uv: Node,
     depthTexture: Node,
     projectionMatrixInverse: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
+
+export const interleavedGradientNoise: (position: Node) => Node;

three/src/nodes/utils/RTTNode.d.ts

@@ -2,7 +2,6 @@ import { TextureDataType } from "../../constants.js";
 import { RenderTarget } from "../../core/RenderTarget.js";
 import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export interface RTTNodeOptions {
     type: TextureDataType;
@@ -38,10 +37,10 @@ export const rtt: (
     width?: number | null,
     height?: number | null,
     options?: RTTNodeOptions,
-) => ShaderNodeObject<RTTNode>;
+) => RTTNode;
 export const convertToTexture: (
     node: Node,
     width?: number | null,
     height?: number | null,
     options?: RTTNodeOptions,
-) => ShaderNodeObject<RTTNode>;
+) => RTTNode;

three/src/nodes/utils/ReflectorNode.d.ts

@@ -3,13 +3,18 @@ import { Object3D } from "../../core/Object3D.js";
 import { RenderTarget } from "../../core/RenderTarget.js";
 import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export interface ReflectorNodeParameters {
     target?: Object3D | undefined;
+    /**
+     * @deprecated The "resolution" parameter has been renamed to "resolutionScale".
+     */
     resolution?: number | undefined;
+    resolutionScale?: number | undefined;
     generateMipmaps?: boolean | undefined;
     bounces?: boolean | undefined;
+    depth?: boolean | undefined;
+    samples?: number | undefined;
 }
 
 declare class ReflectorNode extends TextureNode {
@@ -19,14 +24,14 @@ declare class ReflectorNode extends TextureNode {
 
     get target(): Object3D;
 
-    getDepthNode(): ShaderNodeObject<ReflectorNode>;
+    getDepthNode(): ReflectorNode;
 }
 
 declare class ReflectorBaseNode extends Node {
     textureNode: TextureNode;
 
     target: Object3D;
-    resolution: number;
+    resolutionScale: number;
     generateMipmaps: boolean;
     bounces: boolean;
 
@@ -40,8 +45,17 @@ declare class ReflectorBaseNode extends Node {
     getVirtualCamera(camera: Camera): Camera;
 
     getRenderTarget(camera: Camera): RenderTarget;
+
+    /**
+     * @deprecated The "resolution" property has been renamed to "resolutionScale" and is now of type `number`.
+     */
+    get resolution(): number;
+    /**
+     * @deprecated The "resolution" property has been renamed to "resolutionScale" and is now of type `number`.
+     */
+    set resolution(value: number);
 }
 
-export const reflector: (parameters?: ReflectorNodeParameters) => ShaderNodeObject<ReflectorNode>;
+export const reflector: (parameters?: ReflectorNodeParameters) => ReflectorNode;
 
 export default ReflectorNode;

three/src/nodes/utils/RemapNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class RemapNode extends Node {
     node: Node;
@@ -19,18 +18,41 @@ export const remap: (
     inHighNode: Node | number,
     outLowNode?: Node | number,
     outHighNode?: Node | number,
-) => ShaderNodeObject<RemapNode>;
+) => RemapNode;
 export const remapClamp: (
     node: Node,
     inLowNode: Node | number,
     inHighNode: Node | number,
     outLowNode?: Node | number,
     outHighNode?: Node | number,
-) => ShaderNodeObject<RemapNode>;
+) => RemapNode;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        remap: typeof remap;
-        remapClamp: typeof remapClamp;
+declare module "../Nodes.js" {
+    interface Node {
+        remap: (
+            inLowNode: Node | number,
+            inHighNode: Node | number,
+            outLowNode?: Node | number,
+            outHighNode?: Node | number,
+        ) => RemapNode;
+        remapAssign: (
+            inLowNode: Node | number,
+            inHighNode: Node | number,
+            outLowNode?: Node | number,
+            outHighNode?: Node | number,
+        ) => this;
+
+        remapClamp: (
+            inLowNode: Node | number,
+            inHighNode: Node | number,
+            outLowNode?: Node | number,
+            outHighNode?: Node | number,
+        ) => RemapNode;
+        remapClampAssign: (
+            inLowNode: Node | number,
+            inHighNode: Node | number,
+            outLowNode?: Node | number,
+            outHighNode?: Node | number,
+        ) => this;
     }
 }

three/src/nodes/utils/RotateNode.d.ts

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class RotateNode extends TempNode {
     positionNode: Node;
@@ -12,4 +11,4 @@ export default class RotateNode extends TempNode {
 export const rotate: (
     positionNode: Node,
     rotationNode: Node | number,
-) => ShaderNodeObject<RotateNode>;
+) => RotateNode;

three/src/nodes/utils/SampleNode.d.ts

@@ -1,16 +1,16 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class SampleNode extends Node {
     callback: (uv: Node) => Node;
+    uvNode: Node | null;
 
     readonly isSampleNode: true;
 
-    constructor(callback: (uv: Node) => Node);
+    constructor(callback: (uv: Node) => Node, uvNode?: Node | null);
 
     sample(uv: Node): Node;
 }
 
 export default SampleNode;
 
-export const sample: (callback: (uv: Node) => Node) => ShaderNodeObject<SampleNode>;
+export const sample: (callback: (uv: Node) => Node, uv?: Node | null) => SampleNode;

three/src/nodes/utils/SpriteSheetUVNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class SpriteSheetUVNode extends Node {
     countNode: Node;
@@ -13,4 +12,4 @@ export const spritesheetUV: (
     countNode: Node,
     uvNode: Node | null,
     frameNode: Node | null,
-) => ShaderNodeObject<SpriteSheetUVNode>;
+) => SpriteSheetUVNode;

three/src/nodes/utils/SpriteUtils.d.ts

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export const billboarding: (
     args?: { position?: Node | null; horizontal?: boolean; vertical?: boolean },
-) => ShaderNodeObject<Node>;
+) => Node;

three/src/nodes/utils/StorageArrayElementNode.d.ts

@@ -1,6 +1,5 @@
 import StorageBufferNode from "../accessors/StorageBufferNode.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ArrayElementNode from "./ArrayElementNode.js";
 
 export default class StorageArrayElementNode extends ArrayElementNode {
@@ -17,4 +16,4 @@ export default class StorageArrayElementNode extends ArrayElementNode {
 export const storageElement: (
     storageBufferNode: Node,
     indexNode: Node,
-) => ShaderNodeObject<StorageArrayElementNode>;
+) => StorageArrayElementNode;

three/src/nodes/utils/Timer.d.ts

@@ -1,21 +1,5 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const time: ShaderNodeObject<Node>;
-export const deltaTime: ShaderNodeObject<Node>;
-export const frameId: ShaderNodeObject<Node>;
-
-/**
- * @deprecated Use "time" instead.
- */
-export const timerLocal: (timeScale?: number) => ShaderNodeObject<Node>;
-
-/**
- * @deprecated Use "time" instead.
- */
-export const timerGlobal: (timeScale?: number) => ShaderNodeObject<Node>;
-
-/**
- * @deprecated Use "deltaTime" instead.
- */
-export const timerDelta: (timeScale?: number) => ShaderNodeObject<Node>;
+export const time: Node;
+export const deltaTime: Node;
+export const frameId: Node;

three/src/nodes/utils/TriplanarTextures.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export const triplanarTextures: (
     textureXNode: Node,
@@ -8,7 +7,7 @@ export const triplanarTextures: (
     scaleNode?: Node,
     positionNode?: Node,
     normalNode?: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export const triplanarTexture: (
     textureXNode: Node,
@@ -17,4 +16,4 @@ export const triplanarTexture: (
     scaleNode?: Node,
     positionNode?: Node,
     normalNode?: Node,
-) => ShaderNodeObject<Node>;
+) => Node;

three/src/nodes/utils/UVUtils.d.ts

@@ -1,15 +1,14 @@
 import Node from "../core/Node.js";
 import OperatorNode from "../math/OperatorNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export const rotateUV: (
     uv: Node,
     rotation: Node,
     center?: Node,
-) => ShaderNodeObject<OperatorNode>;
+) => OperatorNode;
 
 export const spherizeUV: (
     uv: Node,
     strength: Node | number,
     center?: Node,
-) => ShaderNodeObject<OperatorNode>;
+) => OperatorNode;

three/src/nodes/utils/ViewportUtils.d.ts

@@ -1,4 +1,3 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const viewportSafeUV: (uv?: Node | null) => ShaderNodeObject<Node>;
+export const viewportSafeUV: (uv?: Node | null) => Node;

three/src/objects/InstancedMesh.d.ts

@@ -28,7 +28,6 @@ export interface InstancedMeshEventMap extends Object3DEventMap {
  * A special version of {@link THREE.Mesh | Mesh} with instanced rendering support
  * @remarks
  * Use {@link InstancedMesh} if you have to render a large number of objects with the same geometry and material(s) but with different world transformations
- * @remarks
  * The usage of {@link InstancedMesh} will help you to reduce the number of draw calls and thus improve the overall rendering performance in your application.
  * @see Example: {@link https://threejs.org/examples/#webgl_instancing_dynamic | WebGL / instancing / dynamic}
  * @see Example: {@link https://threejs.org/examples/#webgl_instancing_performance | WebGL / instancing / performance}
@@ -76,8 +75,8 @@ export class InstancedMesh<
      * @remarks
      * The `count` value passed into the {@link InstancedMesh | constructor} represents the **maximum** number of instances of this mesh.
      * You can change the number of instances at runtime to an integer value in the range `[0, count]`.
-     * @remarks If you need more instances than the original `count` value, you have to create a new InstancedMesh.
-     * @remarks Expects a `Integer`
+     * If you need more instances than the original `count` value, you have to create a new InstancedMesh.
+     * Expects a `Integer`
      */
     count: number;
 

three/src/renderers/WebGLRenderer.d.ts

@@ -12,8 +12,6 @@ import { Vector2 } from "../math/Vector2.js";
 import { Vector3 } from "../math/Vector3.js";
 import { Vector4 } from "../math/Vector4.js";
 import { Scene } from "../scenes/Scene.js";
-import { Data3DTexture } from "../textures/Data3DTexture.js";
-import { DataArrayTexture } from "../textures/DataArrayTexture.js";
 import { OffscreenCanvas, Texture } from "../textures/Texture.js";
 import { WebGLCapabilities, WebGLCapabilitiesParameters } from "./webgl/WebGLCapabilities.js";
 import { WebGLExtensions } from "./webgl/WebGLExtensions.js";
@@ -456,29 +454,6 @@ export class WebGLRenderer {
         dstLevel?: number,
     ): void;
 
-    /**
-     * @deprecated Use "copyTextureToTexture" instead.
-     *
-     * Copies the pixels of a texture in the bounds `srcRegion` in the destination texture starting from the given
-     * position. The `depthTexture` and `texture` property of 3D render targets are supported as well.
-     *
-     * When using render target textures as `srcTexture` and `dstTexture`, you must make sure both render targets are
-     * initialized e.g. via {@link .initRenderTarget}().
-     *
-     * @param srcTexture Specifies the source texture.
-     * @param dstTexture Specifies the destination texture.
-     * @param srcRegion Specifies the bounds
-     * @param dstPosition Specifies the pixel offset into the dstTexture where the copy will occur.
-     * @param level Specifies the destination mipmap level of the texture.
-     */
-    copyTextureToTexture3D(
-        srcTexture: Texture,
-        dstTexture: Data3DTexture | DataArrayTexture,
-        srcRegion?: Box3 | null,
-        dstPosition?: Vector3 | null,
-        level?: number,
-    ): void;
-
     /**
      * Initializes the given WebGLRenderTarget memory. Useful for initializing a render target so data can be copied
      * into it using {@link WebGLRenderer.copyTextureToTexture} before it has been rendered to.

three/src/renderers/common/Animation.d.ts

@@ -1,5 +1,6 @@
 import Info from "./Info.js";
 import Nodes from "./nodes/Nodes.js";
+import Renderer from "./Renderer.js";
 export interface AnimationContext {
     requestAnimationFrame(callback: FrameRequestCallback, xrFrame?: XRFrame): number;
     cancelAnimationFrame(handle: number): void;
@@ -10,6 +11,7 @@ export interface AnimationContext {
  * @private
  */
 declare class Animation {
+    renderer: Renderer;
     nodes: Nodes;
     info: Info;
     _context: AnimationContext | null;
@@ -18,10 +20,11 @@ declare class Animation {
     /**
      * Constructs a new animation loop management component.
      *
+     * @param {Renderer} renderer - A reference to the main renderer.
      * @param {Nodes} nodes - Renderer component for managing nodes related logic.
      * @param {Info} info - Renderer component for managing metrics and monitoring data.
      */
-    constructor(nodes: Nodes, info: Info);
+    constructor(renderer: Renderer, nodes: Nodes, info: Info);
     /**
      * Starts the internal animation loop.
      */

three/src/renderers/common/Attributes.d.ts

@@ -30,7 +30,7 @@ declare class Attributes extends DataMap<{
      * Deletes the data for the given attribute.
      *
      * @param {BufferAttribute} attribute - The attribute.
-     * @return {Object|null} The deleted attribute data.
+     * @return {?Object} The deleted attribute data.
      */
     delete(attribute: BufferAttribute | InterleavedBufferAttribute): Data;
     /**

three/src/renderers/common/Bindings.d.ts

@@ -73,6 +73,18 @@ declare class Bindings extends DataMap<{
      * @param {RenderObject} renderObject - The render object.
      */
     updateForRender(renderObject: RenderObject): void;
+    /**
+     * Deletes the bindings for the given compute node.
+     *
+     * @param {Node} computeNode - The compute node.
+     */
+    deleteForCompute(computeNode: ComputeNode): void;
+    /**
+     * Deletes the bindings for the given renderObject node.
+     *
+     * @param {RenderObject} renderObject - The renderObject.
+     */
+    deleteForRender(renderObject: RenderObject): void;
     /**
      * Updates the given array of bindings.
      *

three/src/renderers/common/CanvasTarget.d.ts

@@ -0,0 +1,142 @@
+import { EventDispatcher } from "../../core/EventDispatcher.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Vector4 } from "../../math/Vector4.js";
+import { DepthTexture } from "../../textures/DepthTexture.js";
+import { FramebufferTexture } from "../../textures/FramebufferTexture.js";
+export interface CanvasTargetEventMap {
+    resize: {};
+    dispose: {};
+}
+/**
+ * CanvasTarget is a class that represents the final output destination of the renderer.
+ *
+ * @augments EventDispatcher
+ */
+declare class CanvasTarget extends EventDispatcher<CanvasTargetEventMap> {
+    domElement: HTMLCanvasElement;
+    _pixelRatio: number;
+    _width: number;
+    _height: number;
+    _viewport: Vector4;
+    _scissor: Vector4;
+    _scissorTest: boolean;
+    colorTexture: FramebufferTexture;
+    depthTexture: DepthTexture;
+    /**
+     * Constructs a new CanvasTarget.
+     *
+     * @param {HTMLCanvasElement|OffscreenCanvas} domElement - The canvas element to render to.
+     */
+    constructor(domElement: HTMLCanvasElement);
+    /**
+     * Returns the pixel ratio.
+     *
+     * @return {number} The pixel ratio.
+     */
+    getPixelRatio(): number;
+    /**
+     * Returns the drawing buffer size in physical pixels. This method honors the pixel ratio.
+     *
+     * @param {Vector2} target - The method writes the result in this target object.
+     * @return {Vector2} The drawing buffer size.
+     */
+    getDrawingBufferSize(target: Vector2): Vector2;
+    /**
+     * Returns the renderer's size in logical pixels. This method does not honor the pixel ratio.
+     *
+     * @param {Vector2} target - The method writes the result in this target object.
+     * @return {Vector2} The renderer's size in logical pixels.
+     */
+    getSize(target: Vector2): Vector2;
+    /**
+     * Sets the given pixel ratio and resizes the canvas if necessary.
+     *
+     * @param {number} [value=1] - The pixel ratio.
+     */
+    setPixelRatio(value?: number): void;
+    /**
+     * This method allows to define the drawing buffer size by specifying
+     * width, height and pixel ratio all at once. The size of the drawing
+     * buffer is computed with this formula:
+     * ```js
+     * size.x = width * pixelRatio;
+     * size.y = height * pixelRatio;
+     * ```
+     *
+     * @param {number} width - The width in logical pixels.
+     * @param {number} height - The height in logical pixels.
+     * @param {number} pixelRatio - The pixel ratio.
+     */
+    setDrawingBufferSize(width: number, height: number, pixelRatio: number): void;
+    /**
+     * Sets the size of the renderer.
+     *
+     * @param {number} width - The width in logical pixels.
+     * @param {number} height - The height in logical pixels.
+     * @param {boolean} [updateStyle=true] - Whether to update the `style` attribute of the canvas or not.
+     */
+    setSize(width: number, height: number, updateStyle?: boolean): void;
+    /**
+     * Returns the scissor rectangle.
+     *
+     * @param {Vector4} target - The method writes the result in this target object.
+     * @return {Vector4} The scissor rectangle.
+     */
+    getScissor(target: Vector4): Vector4;
+    /**
+     * Defines the scissor rectangle.
+     *
+     * @param {number | Vector4} x - The horizontal coordinate for the lower left corner of the box in logical pixel unit.
+     * Instead of passing four arguments, the method also works with a single four-dimensional vector.
+     * @param {number} y - The vertical coordinate for the lower left corner of the box in logical pixel unit.
+     * @param {number} width - The width of the scissor box in logical pixel unit.
+     * @param {number} height - The height of the scissor box in logical pixel unit.
+     */
+    setScissor(x: Vector4): void;
+    setScissor(x: number, y: number, width: number, height: number): void;
+    /**
+     * Returns the scissor test value.
+     *
+     * @return {boolean} Whether the scissor test should be enabled or not.
+     */
+    getScissorTest(): boolean;
+    /**
+     * Defines the scissor test.
+     *
+     * @param {boolean} boolean - Whether the scissor test should be enabled or not.
+     */
+    setScissorTest(boolean: boolean): void;
+    /**
+     * Returns the viewport definition.
+     *
+     * @param {Vector4} target - The method writes the result in this target object.
+     * @return {Vector4} The viewport definition.
+     */
+    getViewport(target: Vector4): Vector4;
+    /**
+     * Defines the viewport.
+     *
+     * @param {number | Vector4} x - The horizontal coordinate for the lower left corner of the viewport origin in logical pixel unit.
+     * @param {number} y - The vertical coordinate for the lower left corner of the viewport origin  in logical pixel unit.
+     * @param {number} width - The width of the viewport in logical pixel unit.
+     * @param {number} height - The height of the viewport in logical pixel unit.
+     * @param {number} minDepth - The minimum depth value of the viewport. WebGPU only.
+     * @param {number} maxDepth - The maximum depth value of the viewport. WebGPU only.
+     */
+    setViewport(x: Vector4): void;
+    setViewport(x: number, y: number, width: number, height: number, minDepth?: number, maxDepth?: number): void;
+    /**
+     * Dispatches the resize event.
+     *
+     * @private
+     */
+    _dispatchResize(): void;
+    /**
+     * Frees the GPU-related resources allocated by this instance. Call this
+     * method whenever this instance is no longer used in your app.
+     *
+     * @fires RenderTarget#dispose
+     */
+    dispose(): void;
+}
+export default CanvasTarget;

three/src/renderers/common/Geometries.d.ts

@@ -80,5 +80,6 @@ declare class Geometries extends DataMap<{
      * @return {?BufferAttribute} The index. Returns `null` for non-indexed geometries.
      */
     getIndex(renderObject: RenderObject): BufferAttribute | null;
+    dispose(): void;
 }
 export default Geometries;