@types/three 0.180.0 → 0.181.0

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

@@ -1,11 +1,11 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const Discard: (conditional?: Node) => ShaderNodeObject<Node>;
-export const Return: () => ShaderNodeObject<Node>;
+export const Discard: (conditional?: Node) => Node;
+export const Return: () => Node;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        discard: typeof Discard;
+declare module "../Nodes.js" {
+    interface Node {
+        discard: () => Node;
+        discardAssign: () => this;
     }
 }

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

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

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

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
 import NodeFrame from "../core/NodeFrame.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type EventNodeType = typeof EventNode.OBJECT | typeof EventNode.MATERIAL;
 
@@ -12,10 +11,16 @@ declare class EventNode extends Node {
 
     static OBJECT: "object";
     static MATERIAL: "material";
+    static BEFORE_OBJECT: "beforeObject";
+    static BEFORE_MATERIAL: "beforeMaterial";
 }
 
 export default EventNode;
 
-export const OnObjectUpdate: (callback: (frame: NodeFrame) => void) => ShaderNodeObject<Node>;
+export const OnObjectUpdate: (callback: (frame: NodeFrame) => void) => Node;
 
-export const OnMaterialUpdate: (callback: (frame: NodeFrame) => void) => ShaderNodeObject<Node>;
+export const OnMaterialUpdate: (callback: (frame: NodeFrame) => void) => Node;
+
+export const OnBeforeObjectUpdate: (callback: (frame: NodeFrame) => void) => Node;
+
+export const OnBeforeMaterialUpdate: (callback: (frame: NodeFrame) => void) => Node;

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class FunctionOverloadingNode extends Node {
     functionNodes: Node[];
@@ -10,4 +9,4 @@ declare class FunctionOverloadingNode extends Node {
 
 export default FunctionOverloadingNode;
 
-export const overloadingFn: (functionNodes: Node[]) => (...params: Node[]) => ShaderNodeObject<FunctionOverloadingNode>;
+export const overloadingFn: (functionNodes: Node[]) => (...params: Node[]) => FunctionOverloadingNode;

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,7 +3,6 @@ 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;
@@ -25,7 +24,7 @@ declare class ReflectorNode extends TextureNode {
 
     get target(): Object3D;
 
-    getDepthNode(): ShaderNodeObject<ReflectorNode>;
+    getDepthNode(): ReflectorNode;
 }
 
 declare class ReflectorBaseNode extends Node {
@@ -57,6 +56,6 @@ declare class ReflectorBaseNode extends Node {
     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,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class SampleNode extends Node {
     callback: (uv: Node) => Node;
@@ -14,4 +13,4 @@ declare class SampleNode extends Node {
 
 export default SampleNode;
 
-export const sample: (callback: (uv: Node) => Node, uv?: Node | null) => 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,6 +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>;
+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/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/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;