@types/three 0.180.0 → 0.182.0

three/src/materials/MeshStandardMaterial.d.ts

@@ -249,9 +249,9 @@ export interface MeshStandardMaterialParameters
  * A standard physically based material, using Metallic-Roughness workflow.
  *
  * Physically based rendering (PBR) has recently become the standard in many
- * 3D applications, such as [Unity]{@link https://blogs.unity3d.com/2014/10/29/physically-based-shading-in-unity-5-a-primer/},
- * [Unreal]{@link https://docs.unrealengine.com/latest/INT/Engine/Rendering/Materials/PhysicallyBased/} and
- * [3D Studio Max]{@link http://area.autodesk.com/blogs/the-3ds-max-blog/what039s-new-for-rendering-in-3ds-max-2017}.
+ * 3D applications, such as [Unity](https://blogs.unity3d.com/2014/10/29/physically-based-shading-in-unity-5-a-primer/),
+ * [Unreal](https://docs.unrealengine.com/latest/INT/Engine/Rendering/Materials/PhysicallyBased/) and
+ * [3D Studio Max](http://area.autodesk.com/blogs/the-3ds-max-blog/what039s-new-for-rendering-in-3ds-max-2017).
  *
  * This approach differs from older approaches in that instead of using
  * approximations for the way in which light interacts with a surface, a
@@ -267,13 +267,13 @@ export interface MeshStandardMaterialParameters
  * Note that for best results you should always specify an environment map when using this material.
  *
  * For a non-technical introduction to the concept of PBR and how to set up a
- * PBR material, check out these articles by the people at [marmoset]{@link https://www.marmoset.co}:
+ * PBR material, check out these articles by the people at [marmoset](https://www.marmoset.co):
  *
- * - [Basic Theory of Physically Based Rendering]{@link https://www.marmoset.co/posts/basic-theory-of-physically-based-rendering/}
- * - [Physically Based Rendering and You Can Too]{@link https://www.marmoset.co/posts/physically-based-rendering-and-you-can-too/}
+ * - [Basic Theory of Physically Based Rendering](https://www.marmoset.co/posts/basic-theory-of-physically-based-rendering/)
+ * - [Physically Based Rendering and You Can Too](https://www.marmoset.co/posts/physically-based-rendering-and-you-can-too/)
  *
  * Technical details of the approach used in three.js (and most other PBR systems) can be found is this
- * [paper from Disney]{@link https://media.disneyanimation.com/uploads/production/publication_asset/48/asset/s2012_pbs_disney_brdf_notes_v3.pdf}
+ * [paper from Disney](https://media.disneyanimation.com/uploads/production/publication_asset/48/asset/s2012_pbs_disney_brdf_notes_v3.pdf)
  * (pdf), by Brent Burley.
  */
 export class MeshStandardMaterial extends Material {

three/src/materials/PointsMaterial.d.ts

@@ -33,7 +33,7 @@ export interface PointsMaterialProperties extends MaterialProperties {
     /**
      * Defines the size of the points in pixels.
      *
-     * Might be capped if the value exceeds hardware dependent parameters like [gl.ALIASED_POINT_SIZE_RANGE]{@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/getParamete}.
+     * Might be capped if the value exceeds hardware dependent parameters like [gl.ALIASED_POINT_SIZE_RANGE](https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/getParamete).
      *
      * @default 1
      */

three/src/materials/ShaderMaterial.d.ts

@@ -26,7 +26,7 @@ export interface ShaderMaterialProperties extends MaterialProperties {
      * #define BAR true
      * ```
      */
-    defines: { [key: string]: any };
+    defines: Record<string, unknown>;
     /**
      * An object of the form:
      * ```js
@@ -85,9 +85,22 @@ export interface ShaderMaterialProperties extends MaterialProperties {
      */
     wireframeLinewidth: number;
     /**
-     * Define whether the material color is affected by global fog settings; `true`
+     * Defines whether the material color is affected by global fog settings; `true`
      * to pass fog uniforms to the shader.
      *
+     * Setting this property to `true` requires the definition of fog uniforms. It is
+     * recommended to use `UniformsUtils.merge()` to combine the custom shader uniforms
+     * with predefined fog uniforms.
+     *
+     * ```js
+     * const material = new ShaderMaterial( {
+     *     uniforms: UniformsUtils.merge( [ UniformsLib[ 'fog' ], shaderUniforms ] );
+     *     vertexShader: vertexShader,
+     *     fragmentShader: fragmentShader,
+     *     fog: true
+     * } );
+     * ```
+     *
      * @default false
      */
     fog: boolean;
@@ -130,7 +143,7 @@ export interface ShaderMaterialProperties extends MaterialProperties {
         uv1: [number, number];
     };
     /**
-     * If set, this calls [gl.bindAttribLocation]{@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/bindAttribLocation}
+     * If set, this calls [gl.bindAttribLocation](https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/bindAttribLocation)
      * to bind a generic vertex index to an attribute variable.
      *
      * @default undefined
@@ -209,7 +222,7 @@ export interface ShaderMaterialJSON extends MaterialJSON {
  * - You can use the directive `#pragma unroll_loop_start` and `#pragma unroll_loop_end`
  * in order to unroll a `for` loop in GLSL by the shader preprocessor. The directive has
  * to be placed right above the loop. The loop formatting has to correspond to a defined standard.
- *   - The loop has to be [normalized]{@link https://en.wikipedia.org/wiki/Normalized_loop}.
+ *   - The loop has to be [normalized](https://en.wikipedia.org/wiki/Normalized_loop).
  *   - The loop variable has to be *i*.
  *   - The value `UNROLLED_LOOP_INDEX` will be replaced with the explicitly
  * value of *i* for the given iteration and can be used in preprocessor
@@ -217,12 +230,12 @@ export interface ShaderMaterialJSON extends MaterialJSON {
  *
  * ```js
  * const material = new THREE.ShaderMaterial( {
- * 	uniforms: {
- * 		time: { value: 1.0 },
- * 		resolution: { value: new THREE.Vector2() }
- * 	},
- * 	vertexShader: document.getElementById( 'vertexShader' ).textContent,
- * 	fragmentShader: document.getElementById( 'fragmentShader' ).textContent
+ *    uniforms: {
+ *        time: { value: 1.0 },
+ *        resolution: { value: new THREE.Vector2() }
+ *    },
+ *    vertexShader: document.getElementById( 'vertexShader' ).textContent,
+ *    fragmentShader: document.getElementById( 'fragmentShader' ).textContent
  * } );
  * ```
  */
@@ -248,4 +261,6 @@ export class ShaderMaterial extends Material {
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface ShaderMaterial extends ShaderMaterialProperties {}
+export interface ShaderMaterial extends ShaderMaterialProperties {
+    defines: Record<string, unknown>;
+}

three/src/materials/nodes/MeshSSSNodeMaterial.d.ts

@@ -40,7 +40,7 @@ declare class SSSLightingModel extends PhysicalLightingModel {
     /**
      * Extends the default implementation with a SSS term.
      *
-     * Reference: [Approximating Translucency for a Fast, Cheap and Convincing Subsurface Scattering Look]{@link https://colinbarrebrisebois.com/2011/03/07/gdc-2011-approximating-translucency-for-a-fast-cheap-and-convincing-subsurface-scattering-look/}
+     * Reference: [Approximating Translucency for a Fast, Cheap and Convincing Subsurface Scattering Look](https://colinbarrebrisebois.com/2011/03/07/gdc-2011-approximating-translucency-for-a-fast-cheap-and-convincing-subsurface-scattering-look/)
      *
      * @param {Object} input - The input data.
      * @param {NodeBuilder} builder - The current node builder.

three/src/materials/nodes/NodeMaterial.d.ts

@@ -1,10 +1,10 @@
 import ClippingNode from "../../nodes/accessors/ClippingNode.js";
+import ContextNode from "../../nodes/core/ContextNode.js";
 import LightingModel from "../../nodes/core/LightingModel.js";
 import MRTNode from "../../nodes/core/MRTNode.js";
 import Node from "../../nodes/core/Node.js";
 import NodeBuilder from "../../nodes/core/NodeBuilder.js";
 import LightsNode from "../../nodes/lighting/LightsNode.js";
-import { ShaderNodeObject } from "../../nodes/tsl/TSLCore.js";
 import { MapColorPropertiesToColorRepresentations, Material, MaterialParameters } from "../Material.js";
 import NodeMaterialObserver from "./manager/NodeMaterialObserver.js";
 
@@ -105,7 +105,7 @@ export interface NodeMaterialNodeProperties {
      * and `alphaMap` properties. This node property allows to overwrite the default
      * and define the opacity with a node instead.
      *
-     * If you don't want to overwrite the normals but modify the existing
+     * If you don't want to overwrite the opacity but modify the existing
      * value instead, use {@link materialOpacity}.
      *
      * @default null
@@ -273,6 +273,12 @@ export interface NodeMaterialNodeProperties {
      * @default null
      */
     vertexNode: Node | null;
+    /**
+     * This node can be used as a global context management component for this material.
+     *
+     * @default null
+     */
+    contextNode: ContextNode | null;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
@@ -385,7 +391,7 @@ declare class NodeMaterial extends Material {
      *
      * @return {Node<vec3>} The normal node.
      */
-    setupNormal(): ShaderNodeObject<Node>;
+    setupNormal(): Node;
     /**
      * Setups the environment node from the material.
      *

three/src/materials/nodes/VolumeNodeMaterial.d.ts

@@ -1,6 +1,5 @@
 import Node from "../../nodes/core/Node.js";
 import VolumetricLightingModel from "../../nodes/functions/VolumetricLightingModel.js";
-import { ShaderNodeObject } from "../../nodes/tsl/TSLCore.js";
 import { MapColorPropertiesToColorRepresentations, MaterialParameters, MaterialProperties } from "../Material.js";
 import NodeMaterial, { NodeMaterialNodeProperties } from "./NodeMaterial.js";
 
@@ -23,7 +22,7 @@ export interface VolumeNodeMaterialNodeProperties extends NodeMaterialNodeProper
      *
      * @default null
      */
-    scatteringNode: (params: { positionRay: ShaderNodeObject<Node> }) => Node | null;
+    scatteringNode: (params: { positionRay: Node }) => Node | null;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface

three/src/math/Vector3.d.ts

@@ -103,7 +103,7 @@ export class Vector3 {
     /**
      * Subtracts v from this vector.
      */
-    sub(a: Vector3Like): this;
+    sub(v: Vector3Like): this;
 
     subScalar(s: number): this;
 
@@ -208,7 +208,7 @@ export class Vector3 {
     /**
      * Sets this vector to cross product of itself and v.
      */
-    cross(a: Vector3Like): this;
+    cross(v: Vector3Like): this;
 
     /**
      * Sets this vector to cross product of a and b.

three/src/nodes/Nodes.d.ts

@@ -6,10 +6,10 @@ export { default as ArrayNode } from "./core/ArrayNode.js";
 export { default as AssignNode } from "./core/AssignNode.js";
 export { default as AttributeNode } from "./core/AttributeNode.js";
 export { default as BypassNode } from "./core/BypassNode.js";
-export { default as CacheNode } from "./core/CacheNode.js";
 export { default as ConstNode } from "./core/ConstNode.js";
 export { default as ContextNode } from "./core/ContextNode.js";
 export { default as IndexNode, IndexNodeScope } from "./core/IndexNode.js";
+export { default as IsolateNode } from "./core/IsolateNode.js";
 export {
     default as LightingModel,
     LightingModelDirectInput,

three/src/nodes/TSL.d.ts

@@ -5,9 +5,9 @@ export * from "./core/constants.js";
 export * from "./core/AssignNode.js";
 export * from "./core/AttributeNode.js";
 export * from "./core/BypassNode.js";
-export * from "./core/CacheNode.js";
 export * from "./core/ContextNode.js";
 export * from "./core/IndexNode.js";
+export * from "./core/IsolateNode.js";
 export * from "./core/MRTNode.js";
 export * from "./core/OutputStructNode.js";
 export * from "./core/ParameterNode.js";
@@ -20,9 +20,12 @@ export * from "./core/VaryingNode.js";
 
 // math
 export * from "./math/BitcastNode.js";
+export * from "./math/BitcountNode.js";
 export * from "./math/Hash.js";
 export * from "./math/MathUtils.js";
+export * from "./math/PackFloatNode.js";
 export * from "./math/TriNoise3D.js";
+export * from "./math/UnpackFloatNode.js";
 
 // utils
 export * from "./utils/EquirectUV.js";
@@ -160,7 +163,7 @@ export * from "./materialx/MaterialXNodes.js";
 export { default as BRDF_GGX } from "./functions/BSDF/BRDF_GGX.js";
 export { default as BRDF_Lambert } from "./functions/BSDF/BRDF_Lambert.js";
 export { default as D_GGX } from "./functions/BSDF/D_GGX.js";
-export { default as DFGApprox } from "./functions/BSDF/DFGApprox.js";
+export { default as DFGLUT } from "./functions/BSDF/DFGLUT.js";
 export { default as F_Schlick } from "./functions/BSDF/F_Schlick.js";
 export { default as Schlick_to_F0 } from "./functions/BSDF/Schlick_to_F0.js";
 export { default as V_GGX_SmithCorrelated } from "./functions/BSDF/V_GGX_SmithCorrelated.js";

three/src/nodes/accessors/AccessorsUtils.d.ts

@@ -1,9 +1,8 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const TBNViewMatrix: ShaderNodeObject<Node>;
+export const TBNViewMatrix: Node;
 
-export const parallaxDirection: ShaderNodeObject<Node>;
-export const parallaxUV: (uv: ShaderNodeObject<Node>, scale: Node) => ShaderNodeObject<Node>;
+export const parallaxDirection: Node;
+export const parallaxUV: (uv: Node, scale: Node) => Node;
 
-export const bentNormalView: ShaderNodeObject<Node>;
+export const bentNormalView: Node;

three/src/nodes/accessors/Arrays.d.ts

@@ -1,14 +1,13 @@
 import { TypedArray } from "../../core/BufferAttribute.js";
 import { Struct } from "../core/StructNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import StorageBufferNode from "./StorageBufferNode.js";
 
 export const attributeArray: (
     count: TypedArray | number,
     type?: string | Struct,
-) => ShaderNodeObject<StorageBufferNode>;
+) => StorageBufferNode;
 
 export const instancedArray: (
     count: TypedArray | number,
     type?: string | Struct,
-) => ShaderNodeObject<StorageBufferNode>;
+) => StorageBufferNode;

three/src/nodes/accessors/BatchNode.d.ts

@@ -1,6 +1,5 @@
 import { BatchedMesh } from "../../objects/BatchedMesh.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class BatchNode extends Node {
     batchMesh: BatchedMesh;
@@ -10,4 +9,4 @@ export default class BatchNode extends Node {
     constructor(batchMesh: BatchedMesh);
 }
 
-export const batch: (batchMesh: BatchedMesh) => ShaderNodeObject<BatchNode>;
+export const batch: (batchMesh: BatchedMesh) => BatchNode;

three/src/nodes/accessors/Bitangent.d.ts

@@ -1,7 +1,6 @@
 import MathNode from "../math/MathNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const bitangentGeometry: ShaderNodeObject<MathNode>;
-export const bitangentLocal: ShaderNodeObject<MathNode>;
-export const bitangentView: ShaderNodeObject<MathNode>;
-export const bitangentWorld: ShaderNodeObject<MathNode>;
+export const bitangentGeometry: MathNode;
+export const bitangentLocal: MathNode;
+export const bitangentView: MathNode;
+export const bitangentWorld: MathNode;

three/src/nodes/accessors/BufferAttributeNode.d.ts

@@ -3,9 +3,8 @@ import { BufferAttribute, TypedArray } from "../../core/BufferAttribute.js";
 import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
 import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
 import InputNode from "../core/InputNode.js";
+import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
-import BufferNode from "./BufferNode.js";
 /**
  * In earlier `three.js` versions it was only possible to define attribute data
  * on geometry level. With `BufferAttributeNode`, it is also possible to do this
@@ -114,14 +113,14 @@ export default BufferAttributeNode;
  * @param {?string} [type=null] - The buffer type (e.g. `'vec3'`).
  * @param {number} [stride=0] - The buffer stride.
  * @param {number} [offset=0] - The buffer offset.
- * @returns {BufferAttributeNode}
+ * @returns {BufferAttributeNode|Node}
  */
 export declare const bufferAttribute: (
-    array: TypedArray | InterleavedBuffer | BufferAttribute,
+    array: BufferAttribute | InterleavedBuffer | TypedArray,
     type?: string | null,
     stride?: number,
     offset?: number,
-) => ShaderNodeObject<BufferAttributeNode>;
+) => Node;
 /**
  * TSL function for creating a buffer attribute node but with dynamic draw usage.
  * Use this function if attribute data are updated per frame.
@@ -132,14 +131,14 @@ export declare const bufferAttribute: (
  * @param {?string} [type=null] - The buffer type (e.g. `'vec3'`).
  * @param {number} [stride=0] - The buffer stride.
  * @param {number} [offset=0] - The buffer offset.
- * @returns {BufferAttributeNode}
+ * @returns {BufferAttributeNode|Node}
  */
 export declare const dynamicBufferAttribute: (
-    array: TypedArray | InterleavedBuffer | BufferAttribute,
+    array: BufferAttribute | InterleavedBuffer | TypedArray,
     type?: string | null,
     stride?: number,
     offset?: number,
-) => ShaderNodeObject<BufferAttributeNode>;
+) => Node;
 /**
  * TSL function for creating a buffer attribute node but with enabled instancing
  *
@@ -149,14 +148,14 @@ export declare const dynamicBufferAttribute: (
  * @param {?string} [type=null] - The buffer type (e.g. `'vec3'`).
  * @param {number} [stride=0] - The buffer stride.
  * @param {number} [offset=0] - The buffer offset.
- * @returns {BufferAttributeNode}
+ * @returns {BufferAttributeNode|Node}
  */
 export declare const instancedBufferAttribute: (
-    array: TypedArray | InterleavedBuffer | BufferAttribute,
+    array: BufferAttribute | InterleavedBuffer | TypedArray,
     type?: string | null,
     stride?: number,
     offset?: number,
-) => ShaderNodeObject<BufferAttributeNode>;
+) => Node;
 /**
  * TSL function for creating a buffer attribute node but with dynamic draw usage and enabled instancing
  *
@@ -166,16 +165,17 @@ export declare const instancedBufferAttribute: (
  * @param {?string} [type=null] - The buffer type (e.g. `'vec3'`).
  * @param {number} [stride=0] - The buffer stride.
  * @param {number} [offset=0] - The buffer offset.
- * @returns {BufferAttributeNode}
+ * @returns {BufferAttributeNode|Node}
  */
 export declare const instancedDynamicBufferAttribute: (
-    array: TypedArray | InterleavedBuffer | BufferAttribute,
+    array: BufferAttribute | InterleavedBuffer | TypedArray,
     type?: string | null,
     stride?: number,
     offset?: number,
-) => ShaderNodeObject<BufferAttributeNode>;
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        toAttribute: <TValue>(bufferNode: BufferNode<TValue>) => ShaderNodeObject<BufferAttributeNode>;
+) => Node;
+declare module "../Nodes.js" {
+    interface BufferNode<TValue> {
+        toAttribute: () => BufferAttributeNode;
+        toAttributeAssign: () => this;
     }
 }

three/src/nodes/accessors/BufferNode.d.ts

@@ -1,5 +1,5 @@
 import UniformNode from "../core/UniformNode.js";
-import { NodeOrType, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeOrType } from "../tsl/TSLCore.js";
 
 export default class BufferNode<TValue> extends UniformNode<TValue> {
     isBufferNode: true;
@@ -14,4 +14,4 @@ export const buffer: <TValue>(
     value: unknown,
     nodeOrType: NodeOrType,
     count: number,
-) => ShaderNodeObject<BufferNode<TValue>>;
+) => BufferNode<TValue>;

three/src/nodes/accessors/BuiltinNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class BuiltinNode extends Node {
     name: string;
@@ -11,4 +10,4 @@ declare class BuiltinNode extends Node {
 
 export default BuiltinNode;
 
-export const builtin: (name: string) => ShaderNodeObject<BuiltinNode>;
+export const builtin: (name: string) => BuiltinNode;

three/src/nodes/accessors/Camera.d.ts

@@ -3,15 +3,14 @@ import { Matrix4 } from "../../math/Matrix4.js";
 import { Vector3 } from "../../math/Vector3.js";
 import { Vector4 } from "../../math/Vector4.js";
 import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const cameraIndex: ShaderNodeObject<UniformNode<number>>;
-export const cameraNear: ShaderNodeObject<UniformNode<number>>;
-export const cameraFar: ShaderNodeObject<UniformNode<number>>;
-export const cameraProjectionMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
-export const cameraProjectionMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;
-export const cameraViewMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
-export const cameraWorldMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
-export const cameraNormalMatrix: ShaderNodeObject<UniformNode<Matrix3>>;
-export const cameraPosition: ShaderNodeObject<UniformNode<Vector3>>;
-export const cameraViewport: ShaderNodeObject<UniformNode<Vector4>>;
+export const cameraIndex: UniformNode<number>;
+export const cameraNear: UniformNode<number>;
+export const cameraFar: UniformNode<number>;
+export const cameraProjectionMatrix: UniformNode<Matrix4>;
+export const cameraProjectionMatrixInverse: UniformNode<Matrix4>;
+export const cameraViewMatrix: UniformNode<Matrix4>;
+export const cameraWorldMatrix: UniformNode<Matrix4>;
+export const cameraNormalMatrix: UniformNode<Matrix3>;
+export const cameraPosition: UniformNode<Vector3>;
+export const cameraViewport: UniformNode<Vector4>;

three/src/nodes/accessors/ClippingNode.d.ts

@@ -1,7 +1,4 @@
-import { Plane } from "../../math/Plane.js";
 import Node from "../core/Node.js";
-import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type ClippingNodeScope = typeof ClippingNode.ALPHA_TO_COVERAGE | typeof ClippingNode.DEFAULT;
 
@@ -17,6 +14,6 @@ export default class ClippingNode extends Node {
     static HARDWARE: "hardware";
 }
 
-export const clipping: () => ShaderNodeObject<ClippingNode>;
-export const clippingAlpha: () => ShaderNodeObject<ClippingNode>;
-export const hardwareClipping: () => ShaderNodeObject<ClippingNode>;
+export const clipping: () => ClippingNode;
+export const clippingAlpha: () => ClippingNode;
+export const hardwareClipping: () => ClippingNode;

three/src/nodes/accessors/CubeTextureNode.d.ts

@@ -1,18 +1,17 @@
 import { CubeTexture } from "../../textures/CubeTexture.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import TextureNode from "./TextureNode.js";
 
 declare class CubeTextureNode extends TextureNode {
     isCubeTextureNode: boolean;
-    uvNode: ShaderNodeObject<Node> | null;
-    levelNode: ShaderNodeObject<Node> | null;
+    uvNode: Node | null;
+    levelNode: Node | null;
 
     constructor(
         value: CubeTexture,
-        uvNode?: ShaderNodeObject<Node> | null,
-        levelNode?: ShaderNodeObject<Node> | null,
-        biasNode?: ShaderNodeObject<Node> | null,
+        uvNode?: Node | null,
+        levelNode?: Node | null,
+        biasNode?: Node | null,
     );
 
     getDefaultUV(): Node;
@@ -25,15 +24,15 @@ export const cubeTextureBase: (
     uvNode?: Node,
     levelNode?: Node,
     biasNode?: Node,
-) => ShaderNodeObject<CubeTextureNode>;
+) => CubeTextureNode;
 
 export const cubeTexture: (
     value?: CubeTexture,
     uvNode?: Node | null,
     levelNode?: Node | null,
     biasNode?: Node | null,
-) => ShaderNodeObject<CubeTextureNode>;
+) => CubeTextureNode;
 
 export const uniformCubeTexture: (
     value?: CubeTexture,
-) => ShaderNodeObject<CubeTextureNode>;
+) => CubeTextureNode;

three/src/nodes/accessors/InstanceNode.d.ts

@@ -1,24 +1,24 @@
 import { InstancedBufferAttribute } from "../../core/InstancedBufferAttribute.js";
+import StorageInstancedBufferAttribute from "../../renderers/common/StorageInstancedBufferAttribute.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class InstanceNode extends Node {
     count: number;
-    instanceMatrix: InstancedBufferAttribute;
-    instanceColor: InstancedBufferAttribute | null;
+    instanceMatrix: InstancedBufferAttribute | StorageInstancedBufferAttribute;
+    instanceColor: InstancedBufferAttribute | StorageInstancedBufferAttribute | null;
 
     instanceMatrixNode: Node | null;
     instanceColorNode: Node | null;
 
     constructor(
         count: number,
-        instanceMatrix: InstancedBufferAttribute,
-        instanceColor?: InstancedBufferAttribute | null,
+        instanceMatrix: InstancedBufferAttribute | StorageInstancedBufferAttribute,
+        instanceColor?: InstancedBufferAttribute | StorageInstancedBufferAttribute | null,
     );
 }
 
 export const instance: (
     count: number,
-    instanceMatrix: InstancedBufferAttribute,
-    instanceColor?: InstancedBufferAttribute | null,
-) => ShaderNodeObject<InstanceNode>;
+    instanceMatrix: InstancedBufferAttribute | StorageInstancedBufferAttribute,
+    instanceColor?: InstancedBufferAttribute | StorageInstancedBufferAttribute | null,
+) => InstanceNode;

three/src/nodes/accessors/InstancedMeshNode.d.ts

@@ -1,5 +1,4 @@
 import { InstancedMesh } from "../../objects/InstancedMesh.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import InstanceNode from "./InstanceNode.js";
 
 declare class InstancedMeshNode extends InstanceNode {
@@ -8,4 +7,4 @@ declare class InstancedMeshNode extends InstanceNode {
 
 export default InstancedMeshNode;
 
-export const instancedMesh: (instancedMesh: InstancedMesh) => ShaderNodeObject<InstancedMeshNode>;
+export const instancedMesh: (instancedMesh: InstancedMesh) => InstancedMeshNode;

three/src/nodes/accessors/Lights.d.ts

@@ -1,15 +1,14 @@
 import { Light } from "../../lights/Light.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export function lightShadowMatrix(light: Light): ShaderNodeObject<Node>;
+export function lightShadowMatrix(light: Light): Node;
 
-export function lightProjectionUV(light: Light, position?: Node): ShaderNodeObject<Node>;
+export function lightProjectionUV(light: Light, position?: Node): Node;
 
-export function lightPosition(light: Light): ShaderNodeObject<Node>;
+export function lightPosition(light: Light): Node;
 
-export function lightTargetPosition(light: Light): ShaderNodeObject<Node>;
+export function lightTargetPosition(light: Light): Node;
 
-export function lightViewPosition(light: Light): ShaderNodeObject<Node>;
+export function lightViewPosition(light: Light): Node;
 
-export const lightTargetDirection: (light: Light) => ShaderNodeObject<Node>;
+export const lightTargetDirection: (light: Light) => Node;