@types/three 0.172.0 → 0.173.0

three/src/nodes/core/StructTypeNode.d.ts

@@ -1,27 +1,46 @@
 import Node from "./Node.js";
+import NodeBuilder from "./NodeBuilder.js";
+/** @module StructTypeNode **/
+export interface MembersLayout {
+    [name: string]: string | {
+        type: string;
+        atomic?: boolean;
+    };
+}
+export interface MemberLayout {
+    name: string;
+    type: string;
+    atomic: boolean;
+}
 /**
- * {@link NodeBuilder} is going to create instances of this class during the build process
- * of nodes. They represent the final shader struct data that are going to be generated
- * by the builder. A dictionary of struct types is maintained in {@link NodeBuilder#structs}
- * for this purpose.
+ * Represents a struct type node in the node-based system.
+ * This class is used to define and manage the layout and types of struct members.
+ * It extends the base Node class and provides methods to get the length of the struct,
+ * retrieve member types, and generate the struct type for a builder.
+ *
+ * @augments Node
  */
 declare class StructTypeNode extends Node {
     static get type(): string;
-    name: string;
-    types: string[];
-    readonly isStructTypeNode: true;
+    membersLayout: MemberLayout[];
+    name: string | null;
+    readonly isStructLayoutNode: true;
     /**
-     * Constructs a new struct type node.
+     * Creates an instance of StructTypeNode.
      *
-     * @param {String} name - The name of the struct.
-     * @param {Array<String>} types - An array of types.
+     * @param {Object} membersLayout - The layout of the members for the struct.
+     * @param {string} [name=null] - The optional name of the struct.
      */
-    constructor(name: string, types: string[]);
+    constructor(membersLayout: MembersLayout, name?: string | null);
     /**
-     * Returns the member types.
+     * Returns the length of the struct.
+     * The length is calculated by summing the lengths of the struct's members.
      *
-     * @return {Array<String>} The types.
+     * @returns {Number} The length of the struct.
      */
-    getMemberTypes(): string[];
+    getLength(): number;
+    getMemberType(builder: NodeBuilder, name: string): string;
+    getNodeType(builder: NodeBuilder): string;
+    generate(builder: NodeBuilder): string;
 }
 export default StructTypeNode;

three/src/nodes/core/VarNode.d.ts

@@ -7,12 +7,19 @@ export default class VarNode extends Node {
 
     readonly isVarNode: true;
 
-    constructor(node: Node, name?: string | null);
+    readOnly: boolean;
+
+    constructor(node: Node, name?: string | null, readOnly?: boolean);
 }
 
+export const Var: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
+
+export const Const: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
+
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         toVar: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
+        toConst: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
     }
 }
 

three/src/nodes/core/VaryingNode.d.ts

@@ -18,7 +18,16 @@ export const vertexStage: (node: NodeRepresentation) => ShaderNodeObject<Varying
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
+        toVarying: typeof varying;
+        toVertexStage: typeof vertexStage;
+
+        /**
+         * @deprecated .varying() has been renamed to .toVarying().
+         */
         varying: typeof varying;
+        /**
+         * @deprecated .vertexStage() has been renamed to .toVertexStage().
+         */
         vertexStage: typeof vertexStage;
     }
 }

three/src/nodes/geometry/RangeNode.d.ts

@@ -1,19 +1,14 @@
-import { Color } from "../../math/Color.js";
-import { Vector2 } from "../../math/Vector2.js";
-import { Vector3 } from "../../math/Vector3.js";
-import { Vector4 } from "../../math/Vector4.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
-
-export type RangeModeBound = number | Color | Vector2 | Vector3 | Vector4;
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class RangeNode extends Node {
-    min: RangeModeBound;
-    max: RangeModeBound;
+    minNode: Node;
+    maxNode: Node;
+
+    constructor(minNode: Node, maxNode: Node);
 
-    constructor(min: RangeModeBound, max: RangeModeBound);
     getVectorLength(builder: NodeBuilder): number;
 }
 
-export const range: (min: RangeModeBound, max: RangeModeBound) => ShaderNodeObject<RangeNode>;
+export const range: (minNode: NodeRepresentation, maxNode: NodeRepresentation) => ShaderNodeObject<RangeNode>;

three/src/nodes/gpgpu/AtomicFunctionNode.d.ts

@@ -39,6 +39,11 @@ export const atomicFunc: (
     storeNode?: NodeRepresentation | null,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
+export const atomicLoad: (
+    pointerNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
 export const atomicStore: (
     pointerNode: NodeRepresentation,
     valueNode: NodeRepresentation,

three/src/nodes/gpgpu/ComputeBuiltinNode.d.ts

@@ -9,5 +9,6 @@ export default ComputeBuiltinNode;
 
 export const numWorkgroups: ShaderNodeObject<ComputeBuiltinNode>;
 export const workgroupId: ShaderNodeObject<ComputeBuiltinNode>;
+export const globalId: ShaderNodeObject<ComputeBuiltinNode>;
 export const localId: ShaderNodeObject<ComputeBuiltinNode>;
 export const subgroupSize: ShaderNodeObject<ComputeBuiltinNode>;

three/src/nodes/math/MathNode.d.ts

@@ -122,6 +122,8 @@ export default class MathNode extends TempNode {
     bNode: Node | null;
     cNode: Node | null;
 
+    readonly isMathNode: true;
+
     constructor(method: MathNodeMethod1, aNode: Node);
     constructor(method: MathNodeMethod2, aNode: Node, bNode: Node);
     constructor(method: MathNodeMethod3, aNode: Node, bNode: Node, cNode: Node);

three/src/nodes/math/OperatorNode.d.ts

@@ -28,6 +28,8 @@ export default class OperatorNode extends TempNode {
     bNode: Node;
     op: OperatorNodeOp;
 
+    readonly isOperatorNode: true;
+
     constructor(op: OperatorNodeOp, ...params: [Node, Node, ...Node[]]);
 }
 

three/src/nodes/shapes/Shapes.d.ts

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

three/src/nodes/tsl/TSLBase.d.ts

@@ -1,6 +1,7 @@
 export * from "../accessors/BufferAttributeNode.js";
 export * from "../code/ExpressionNode.js";
 export * from "../code/FunctionCallNode.js";
+export * from "../core/ArrayNode.js";
 export * from "../core/AssignNode.js";
 export * from "../core/BypassNode.js";
 export * from "../core/CacheNode.js";

three/src/nodes/tsl/TSLCore.d.ts

@@ -1,7 +1,10 @@
+import { Color, ColorRepresentation } from "../../math/Color.js";
+import { Vector3 } from "../../math/Vector3.js";
 import ConstNode from "../core/ConstNode.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import StackNode from "../core/StackNode.js";
+import ConvertNode from "../utils/ConvertNode.js";
 
 export interface NodeElements {
     toGlobal: (node: Node) => Node;
@@ -84,7 +87,7 @@ export type ShaderNodeObject<T extends Node> =
     & Swizzable<T>;
 
 /** anything that can be passed to {@link nodeObject} and returns a proxy */
-export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | ShaderNodeObject<T>;
+export type NodeRepresentation<T extends Node = Node> = number | boolean | Vector3 | Node | ShaderNodeObject<T>;
 
 /** anything that can be passed to {@link nodeObject} */
 export type NodeObjectOption = NodeRepresentation | string;
@@ -231,7 +234,11 @@ export function nodeImmutable<T>(
 interface Layout {
     name: string;
     type: string;
-    inputs: { name: string; type: string }[];
+    inputs: {
+        name: string;
+        type: string;
+        qualifier?: "in" | "out" | "inout";
+    }[];
 }
 
 interface ShaderNodeFn<Args extends readonly unknown[]> {
@@ -274,7 +281,13 @@ export const If: (boolNode: Node, method: () => void) => StackNode;
 
 export function append(node: Node): Node;
 
-export const color: ConvertType;
+interface ColorFunction {
+    (color?: ColorRepresentation): ShaderNodeObject<ConstNode<Color>>;
+    (r: number, g: number, b: number): ShaderNodeObject<ConstNode<Color>>;
+    (node: Node): ShaderNodeObject<ConvertNode>;
+}
+
+export const color: ColorFunction;
 
 export const float: ConvertType;
 export const int: ConvertType;

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

@@ -0,0 +1,11 @@
+import Node from "../core/Node.js";
+
+declare class MemberNode extends Node {
+    node: Node;
+    property: string;
+    readonly isMemberNode: true;
+
+    constructor(node: Node, property: string);
+}
+
+export default MemberNode;

three/src/objects/BatchedMesh.d.ts

@@ -186,6 +186,7 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
 
     /**
      * Sets the given local transformation matrix to the defined instance.
+     * Negatively scaled matrices are not supported.
      * @param instanceId The id of an instance to set the matrix of.
      * @param matrix A 4x4 matrix representing the local transformation of a single instance.
      */

three/src/objects/InstancedMesh.d.ts

@@ -145,9 +145,10 @@ export class InstancedMesh<
     getMorphAt(index: number, mesh: Mesh): void;
 
     /**
-     * Sets the given local transformation matrix to the defined instance.
-     * @remarks
-     * Make sure you set {@link InstancedBufferAttribute.needsUpdate | .instanceMatrix.needsUpdate()} flag to `true` after updating all the matrices.
+     * Sets the given local transformation matrix to the defined instance. Make sure you set
+     * {@link InstancedBufferAttribute.needsUpdate | .instanceMatrix.needsUpdate()} flag to `true` after updating all
+     * the matrices.
+     * Negatively scaled matrices are not supported.
      * @param index The index of an instance. Values have to be in the range `[0, count]`. Expects a `Integer`
      * @param matrix A 4x4 matrix representing the local transformation of a single instance.
      */

three/src/renderers/WebGLRenderer.d.ts

@@ -278,12 +278,12 @@ export class WebGLRenderer {
     /**
      * Sets the custom opaque sort function for the WebGLRenderLists. Pass null to use the default painterSortStable function.
      */
-    setOpaqueSort(method: (a: any, b: any) => number): void;
+    setOpaqueSort(method: ((a: any, b: any) => number) | null): void;
 
     /**
      * Sets the custom transparent sort function for the WebGLRenderLists. Pass null to use the default reversePainterSortStable function.
      */
-    setTransparentSort(method: (a: any, b: any) => number): void;
+    setTransparentSort(method: ((a: any, b: any) => number) | null): void;
 
     /**
      * Returns a THREE.Color instance with the current clear color.

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

@@ -1,6 +1,6 @@
 import Info from "./Info.js";
 import Nodes from "./nodes/Nodes.js";
-interface AnimationContext {
+export interface AnimationContext {
     requestAnimationFrame(callback: FrameRequestCallback, frame?: XRFrame): number;
     cancelAnimationFrame(handle: number): void;
 }
@@ -30,12 +30,24 @@ declare class Animation {
      * Stops the internal animation loop.
      */
     stop(): void;
+    /**
+     * Returns the user-level animation loop.
+     *
+     * @return {Function} The animation loop.
+     */
+    getAnimationLoop(): ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null;
     /**
      * Defines the user-level animation loop.
      *
      * @param {Function} callback - The animation loop.
      */
     setAnimationLoop(callback: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null): void;
+    /**
+     * Returns the animation context.
+     *
+     * @return {Window|XRSession} The animation context.
+     */
+    getContext(): AnimationContext;
     /**
      * Defines the context in which `requestAnimationFrame()` is executed.
      *

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

@@ -1,7 +1,7 @@
 /** @module BufferUtils **/
 /**
  * This function is usually called with the length in bytes of an array buffer.
- * It returns an padded value whic ensure chunk size alignment according to STD140 layout.
+ * It returns an padded value which ensure chunk size alignment according to STD140 layout.
  *
  * @function
  * @param {Number} floatLength - The buffer length.

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

@@ -1,6 +1,6 @@
 import { Group } from "../../objects/Group.js";
 /**
- * A specialized group which eanbles applications access to the
+ * A specialized group which enables applications access to the
  * Render Bundle API of WebGPU. The group with all its descendant nodes
  * are considered as one render bundle and processed as such by
  * the renderer.

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

@@ -3,14 +3,14 @@ type RecursiveWeakMap<K extends readonly object[], V> = WeakMap<K[number], V | R
  * Data structure for the renderer. It allows defining values
  * with chained, hierarchical keys. Keys are meant to be
  * objects since the module internally works with Weak Maps
- * for perforamnce reasons.
+ * for performance reasons.
  *
  * @private
  */
-export default class ChainMap<K extends readonly object[], V> {
+declare class ChainMap<K extends readonly object[], V> {
     weakMap: RecursiveWeakMap<K, V>;
     /**
-     * Constructs a new chained map.
+     * Constructs a new Chain Map.
      */
     constructor();
     /**
@@ -25,7 +25,7 @@ export default class ChainMap<K extends readonly object[], V> {
      *
      * @param {Array<Object>} keys - List of keys.
      * @param {Any} value - The value to set.
-     * @return {ChainMap} A reference to this chain map.
+     * @return {ChainMap} A reference to this Chain Map.
      */
     set(keys: K, value: V): this;
     /**
@@ -36,4 +36,4 @@ export default class ChainMap<K extends readonly object[], V> {
      */
     delete(keys: K): boolean;
 }
-export {};
+export default ChainMap;

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

@@ -11,16 +11,20 @@ declare class Color4 extends Color {
     a: number;
     /**
      * Constructs a new four-component color.
+     * You can also pass a single THREE.Color, hex or
+     * string argument to this constructor.
      *
-     * @param {Number|String} r - The red value.
-     * @param {Number} g - The green value.
-     * @param {Number} b - The blue value.
+     * @param {Number|String} [r=1] - The red value.
+     * @param {Number} [g=1] - The green value.
+     * @param {Number} [b=1] - The blue value.
      * @param {Number} [a=1] - The alpha value.
      */
     constructor(color?: ColorRepresentation);
     constructor(r: number, g: number, b: number, a?: number);
     /**
      * Overwrites the default to honor alpha.
+     * You can also pass a single THREE.Color, hex or
+     * string argument to this method.
      *
      * @param {Number|String} r - The red value.
      * @param {Number} g - The green value.

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

@@ -16,15 +16,11 @@ declare class Info {
         points: number;
         lines: number;
         timestamp: number;
-        previousFrameCalls: number;
-        timestampCalls: number;
     };
     compute: {
         calls: number;
         frameCalls: number;
         timestamp: number;
-        previousFrameCalls: number;
-        timestampCalls: number;
     };
     memory: {
         geometries: number;
@@ -42,13 +38,6 @@ declare class Info {
      * @param {Number} instanceCount - The instance count.
      */
     update(object: Object3D, count: number, instanceCount: number): void;
-    /**
-     * Used by async render methods to updated timestamp metrics.
-     *
-     * @param {('render'|'compute')} type - The type of render call.
-     * @param {Number} time - The duration of the compute/render call in milliseconds.
-     */
-    updateTimestamp(type: "render" | "compute", time: number): void;
     /**
      * Resets frame related metrics.
      */

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

@@ -105,7 +105,7 @@ declare class Pipelines extends DataMap<{
      * @param {ProgrammableStage} stageVertex - The programmable stage representing the vertex shader.
      * @param {ProgrammableStage} stageFragment - The programmable stage representing the fragment shader.
      * @param {String} cacheKey - The cache key.
-     * @param {Array} promises - An array of compilation promises which is only relevant in context of `Renderer.compileAsync()`.
+     * @param {Array<Promise>?} promises - An array of compilation promises which is only relevant in context of `Renderer.compileAsync()`.
      * @return {ComputePipeline} The compute pipeline.
      */
     _getRenderPipeline(
@@ -149,7 +149,7 @@ declare class Pipelines extends DataMap<{
      * Releases the shader program.
      *
      * @private
-     * @param {Object} program - The shdaer program to release.
+     * @param {Object} program - The shader program to release.
      */
     _releaseProgram(program: ProgrammableStage): void;
     /**

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

@@ -13,7 +13,7 @@ declare class PostProcessing {
 
     render(): void;
 
-    update(): void;
+    dispose(): void;
 
     renderAsync(): Promise<void>;
 }

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

@@ -31,19 +31,19 @@ declare class RenderContext {
     viewportValue: Vector4;
     scissor: boolean;
     scissorValue: Vector4;
+    renderTarget: RenderTarget | null;
     textures: Texture[] | null;
     depthTexture: DepthTexture | null;
     activeCubeFace: number;
     sampleCount: number;
     width: number;
     height: number;
+    occlusionQueryCount: number;
+    clippingContext: ClippingContext | null;
     readonly isRenderContext: true;
-    clippingContext?: ClippingContext | undefined;
     depthClearValue?: number | undefined;
     stencilClearValue?: number | undefined;
-    renderTarget?: RenderTarget | undefined;
     activeMipmapLevel?: number | undefined;
-    occlusionQueryCount?: number | undefined;
     /**
      * Constructs a new render context.
      */
@@ -56,7 +56,9 @@ declare class RenderContext {
     getCacheKey(): number;
 }
 /**
- * Computes a cache key for the given render context.
+ * Computes a cache key for the given render context. This key
+ * should identify the render target state so it is possible to
+ * configure the correct attachments in the respective backend.
  *
  * @param {RenderContext} renderContext - The render context.
  * @return {Number} The cache key.

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

@@ -1,6 +1,6 @@
 import { Camera } from "../../cameras/Camera.js";
-import { Object3D } from "../../core/Object3D.js";
 import { RenderTarget } from "../../core/RenderTarget.js";
+import { Scene } from "../../scenes/Scene.js";
 import ChainMap from "./ChainMap.js";
 import RenderContext from "./RenderContext.js";
 /**
@@ -10,15 +10,7 @@ import RenderContext from "./RenderContext.js";
  */
 declare class RenderContexts {
     chainMaps: {
-        [attachmentState: string]:
-            | ChainMap<
-                | readonly [Object3D, Camera]
-                | readonly [Object3D, Camera, {
-                    id: "default";
-                }],
-                RenderContext
-            >
-            | undefined;
+        [attachmentState: string]: ChainMap<readonly [Scene, Camera], RenderContext> | undefined;
     };
     /**
      * Constructs a new render context management component.
@@ -27,27 +19,27 @@ declare class RenderContexts {
     /**
      * Returns a render context for the given scene, camera and render target.
      *
-     * @param {Scene?} [scene=null] - The scene. The parameter can become `null` e.g. when the renderer clears a render target.
-     * @param {Camera?} [camera=null] - The camera that is used to render the scene. The parameter can become `null` e.g. when the renderer clears a render target.
+     * @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.
      * @return {RenderContext} The render context.
      */
-    get(scene?: Object3D | null, camera?: Camera | null, renderTarget?: RenderTarget | null): RenderContext;
+    get(scene: Scene, camera: Camera, renderTarget?: RenderTarget | null): RenderContext;
+    /**
+     * Returns a render context intended for clear operations.
+     *
+     * @param {RenderTarget?} [renderTarget=null] - The active render target.
+     * @return {RenderContext} The render context.
+     */
+    getForClear(renderTarget?: RenderTarget | null): RenderContext;
     /**
      * Returns a chain map for the given attachment state.
      *
+     * @private
      * @param {String} attachmentState - The attachment state.
      * @return {ChainMap} The chain map.
      */
-    getChainMap(
-        attachmentState: string,
-    ): ChainMap<
-        | readonly [Object3D<import("../../core/Object3D.js").Object3DEventMap>, Camera]
-        | readonly [Object3D<import("../../core/Object3D.js").Object3DEventMap>, Camera, {
-            id: "default";
-        }],
-        RenderContext
-    >;
+    _getChainMap(attachmentState: string): ChainMap<readonly [Scene, Camera], RenderContext>;
     /**
      * Frees internal resources.
      */

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

@@ -144,8 +144,8 @@ declare class RenderList {
     /**
      * Sorts the internal render lists.
      *
-     * @param {Function} customOpaqueSort - A custom sort function for opaque objects.
-     * @param {Function} customTransparentSort -  A custom sort function for transparent objects.
+     * @param {function(Any, Any): Number} customOpaqueSort - A custom sort function for opaque objects.
+     * @param {function(Any, Any): Number} customTransparentSort -  A custom sort function for transparent objects.
      */
     sort(
         customOpaqueSort: ((a: RenderItem, b: RenderItem) => number) | null,

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

@@ -35,7 +35,7 @@ import RenderPipeline from "./RenderPipeline.js";
  *
  * @private
  */
-export default class RenderObject {
+declare class RenderObject {
     _nodes: Nodes;
     _geometries: Geometries;
     id: number;
@@ -121,7 +121,7 @@ export default class RenderObject {
     /**
      * Returns the node builder state of this render object.
      *
-     * @return {NodeBuilderState} The node buider state.
+     * @return {NodeBuilderState} The node builder state.
      */
     getNodeBuilderState(): NodeBuilderState;
     /**
@@ -136,6 +136,13 @@ export default class RenderObject {
      * @return {Array<BindGroup>} The bindings.
      */
     getBindings(): BindGroup[];
+    /**
+     * Returns a binding group by group name of this render object.
+     *
+     * @param {String} name - The name of the binding group.
+     * @return {BindGroup?} The bindings.
+     */
+    getBindingGroup(name: string): BindGroup | undefined;
     /**
      * Returns the index of the render object's geometry.
      *
@@ -203,7 +210,7 @@ export default class RenderObject {
      *
      * The material cache key is part of the render object cache key.
      *
-     * @return {String} The material cache key.
+     * @return {Number} The material cache key.
      */
     getMaterialCacheKey(): number;
     /**
@@ -224,7 +231,7 @@ export default class RenderObject {
      * `RenderObjects.get()`. The render object's NodeMaterialObserver is then used to detect
      * a need for a refresh due to material, geometry or object related value changes.
      *
-     * TODO: Investigate if it's possible to merge boths steps so there is only a single place
+     * TODO: Investigate if it's possible to merge both steps so there is only a single place
      * that performs the 'needsUpdate' check.
      *
      * @type {Boolean}
@@ -234,17 +241,18 @@ export default class RenderObject {
     /**
      * Returns the dynamic cache key which represents a key that is computed per draw command.
      *
-     * @return {String} The cache key.
+     * @return {Number} The cache key.
      */
-    getDynamicCacheKey(): string;
+    getDynamicCacheKey(): number;
     /**
      * Returns the render object's cache key.
      *
-     * @return {String} The cache key.
+     * @return {Number} The cache key.
      */
-    getCacheKey(): string;
+    getCacheKey(): number;
     /**
      * Frees internal resources.
      */
     dispose(): void;
 }
+export default RenderObject;