@types/three 0.180.0 → 0.182.0

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

@@ -8,11 +8,18 @@ type RecursiveWeakMap<K extends readonly object[], V> = WeakMap<K[number], V | R
  * @private
  */
 declare class ChainMap<K extends readonly object[], V> {
-    weakMap: RecursiveWeakMap<K, V>;
+    weakMaps: Record<number, RecursiveWeakMap<K, V>>;
     /**
      * Constructs a new Chain Map.
      */
     constructor();
+    /**
+     * Returns the Weak Map for the given keys.
+     *
+     * @param {Array<Object>} keys - List of keys.
+     * @return {WeakMap} The weak map.
+     */
+    _getWeakMap(keys: K): RecursiveWeakMap<K, V>;
     /**
      * Returns the value for the given array of keys.
      *

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

@@ -72,6 +72,13 @@ declare class Geometries extends DataMap<{
      * @return {?BufferAttribute} The indirect attribute. `null` if no indirect drawing is used.
      */
     getIndirect(renderObject: RenderObject): import("./IndirectStorageBufferAttribute.js").default | null;
+    /**
+     * Returns the byte offset into the indirect attribute buffer of the given render object.
+     *
+     * @param {RenderObject} renderObject - The render object.
+     * @return {number} The byte offset into the indirect attribute buffer.
+     */
+    getIndirectOffset(renderObject: RenderObject): number | number[];
     /**
      * Returns the index of the given render object's geometry. This is implemented
      * in a method to return a wireframe index if necessary.
@@ -80,5 +87,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;

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

@@ -0,0 +1,105 @@
+import { Camera } from "../../cameras/Camera.js";
+import { RenderTarget } from "../../core/RenderTarget.js";
+import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
+import { Scene } from "../../scenes/Scene.js";
+import { Texture } from "../../textures/Texture.js";
+import Renderer from "./Renderer.js";
+/**
+ * InspectorBase is the base class for all inspectors.
+ *
+ * @class InspectorBase
+ */
+declare class InspectorBase {
+    _renderer: Renderer | null;
+    /**
+     * Creates a new InspectorBase.
+     */
+    constructor();
+    /**
+     * Returns the node frame for the current renderer.
+     *
+     * @return {Object} The node frame.
+     */
+    get nodeFrame(): import("../../Three.WebGPU.Nodes.js").NodeFrame;
+    /**
+     * Sets the renderer for this inspector.
+     *
+     * @param {WebGLRenderer} renderer - The renderer to associate with this inspector.
+     * @return {InspectorBase} This inspector instance.
+     */
+    setRenderer(renderer: Renderer | null): this;
+    /**
+     * Returns the renderer associated with this inspector.
+     *
+     * @return {WebGLRenderer} The associated renderer.
+     */
+    getRenderer(): Renderer | null;
+    /**
+     * Initializes the inspector.
+     */
+    init(): void;
+    /**
+     * Called when a frame begins.
+     */
+    begin(): void;
+    /**
+     * Called when a frame ends.
+     */
+    finish(): void;
+    /**
+     * Inspects a node.
+     *
+     * @param {Node} node - The node to inspect.
+     */
+    inspect(): void;
+    /**
+     * When a compute operation is performed.
+     *
+     * @param {ComputeNode} computeNode - The compute node being executed.
+     * @param {number|Array<number>} dispatchSizeOrCount - The dispatch size or count.
+     */
+    computeAsync(computeNode: ComputeNode, dispatchSizeOrCount: number | number[]): void;
+    /**
+     * Called when a compute operation begins.
+     *
+     * @param {string} uid - A unique identifier for the render context.
+     * @param {ComputeNode} computeNode - The compute node being executed.
+     */
+    beginCompute(uid: string, computeNode: ComputeNode): void;
+    /**
+     * Called when a compute operation ends.
+     *
+     * @param {string} uid - A unique identifier for the render context.
+     * @param {ComputeNode} computeNode - The compute node being executed.
+     */
+    finishCompute(uid: string): void;
+    /**
+     * Called when a render operation begins.
+     *
+     * @param {string} uid - A unique identifier for the render context.
+     * @param {Scene} scene - The scene being rendered.
+     * @param {Camera} camera - The camera being used for rendering.
+     * @param {?WebGLRenderTarget} renderTarget - The render target, if any.
+     */
+    beginRender(uid: string, scene: Scene, camera: Camera, renderTarget: RenderTarget): void;
+    /**
+     * Called when an animation loop ends.
+     *
+     * @param {string} uid - A unique identifier for the render context.
+     */
+    finishRender(uid: string): void;
+    /**
+     * Called when a texture copy operation is performed.
+     *
+     * @param {Texture} srcTexture - The source texture.
+     * @param {Texture} dstTexture - The destination texture.
+     */
+    copyTextureToTexture(srcTexture: Texture, dstTexture: Texture): void;
+    /**
+     * Called when a framebuffer copy operation is performed.
+     *
+     * @param {Texture} framebufferTexture - The texture associated with the framebuffer.
+     */
+    copyFramebufferToTexture(framebufferTexture: Texture): void;
+}
+export default InspectorBase;

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

@@ -15,6 +15,9 @@ declare class PostProcessing {
 
     dispose(): void;
 
+    /**
+     * @deprecated "renderAsync()" has been deprecated. Use "render()" and "await renderer.init();" when creating the renderer.
+     */
     renderAsync(): Promise<void>;
 }
 

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

@@ -10,6 +10,9 @@ export default class QuadMesh extends Mesh {
 
     constructor(material?: Material | null);
 
+    /**
+     * @deprecated "renderAsync()" has been deprecated. Use "render()" and "await renderer.init();" when creating the renderer.
+     */
     renderAsync(renderer: Renderer): Promise<void>;
 
     render(renderer: Renderer): void;

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

@@ -1,5 +1,6 @@
 import { Camera } from "../../cameras/Camera.js";
 import { RenderTarget } from "../../core/RenderTarget.js";
+import MRTNode from "../../nodes/core/MRTNode.js";
 import { Scene } from "../../scenes/Scene.js";
 import ChainMap from "./ChainMap.js";
 import RenderContext from "./RenderContext.js";
@@ -22,9 +23,10 @@ declare class RenderContexts {
      * @param {Scene} scene - The scene.
      * @param {Camera} camera - The camera that is used to render the scene.
      * @param {?RenderTarget} [renderTarget=null] - The active render target.
+     * @param {?MRT} [mrt=null] - The active multiple render target.
      * @return {RenderContext} The render context.
      */
-    get(scene: Scene, camera: Camera, renderTarget?: RenderTarget | null): RenderContext;
+    get(scene: Scene, camera: Camera, renderTarget?: RenderTarget | null, mrt?: MRTNode | null): RenderContext;
     /**
      * Returns a render context intended for clear operations.
      *
@@ -39,7 +41,9 @@ declare class RenderContexts {
      * @param {string} attachmentState - The attachment state.
      * @return {ChainMap} The chain map.
      */
-    _getChainMap(attachmentState: string): ChainMap<readonly [Scene, Camera], RenderContext>;
+    _getChainMap(
+        attachmentState: string,
+    ): ChainMap<readonly [Scene<import("../../Three.Core.js").Object3DEventMap>, Camera], RenderContext>;
     /**
      * Frees internal resources.
      */

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

@@ -163,6 +163,12 @@ declare class RenderObject {
      * @return {?BufferAttribute} The indirect attribute. `null` if no indirect drawing is used.
      */
     getIndirect(): import("./IndirectStorageBufferAttribute.js").default | null;
+    /**
+     * Returns the byte offset into the indirect attribute buffer.
+     *
+     * @return {number|Array<number>} The byte offset into the indirect attribute buffer.
+     */
+    getIndirectOffset(): number | number[];
     /**
      * Returns an array that acts as a key for identifying the render object in a chain map.
      *