@types/three 0.164.1 → 0.165.0

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Tue, 21 May 2024 21:07:11 GMT
+ * Last updated: Fri, 31 May 2024 15:07:05 GMT
  * Dependencies: [@tweenjs/tween.js](https://npmjs.com/package/@tweenjs/tween.js), [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/webxr](https://npmjs.com/package/@types/webxr), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
 
 # Credits

three/examples/jsm/controls/TransformControls.d.ts

@@ -1,9 +1,11 @@
 import { Camera, Mesh, MOUSE, Object3D, Object3DEventMap, Quaternion, Raycaster, Vector3 } from "three";
 
+type TransformControlsMode = "translate" | "rotate" | "scale";
+
 export interface TransformControlsEventMap extends Object3DEventMap {
     change: {};
-    mouseDown: {};
-    mouseUp: {};
+    mouseDown: { mode: TransformControlsMode };
+    mouseUp: { mode: TransformControlsMode };
     objectChange: {};
     "camera-changed": { value: unknown };
     "object-changed": { value: unknown };
@@ -43,7 +45,7 @@ export class TransformControls extends Object3D<TransformControlsEventMap> {
     object: Object3D | undefined;
     enabled: boolean;
     axis: "X" | "Y" | "Z" | "E" | "XY" | "YZ" | "XZ" | "XYZ" | "XYZE" | null;
-    mode: "translate" | "rotate" | "scale";
+    mode: TransformControlsMode;
     translationSnap: number | null;
     rotationSnap: number | null;
     space: "world" | "local";
@@ -67,9 +69,9 @@ export class TransformControls extends Object3D<TransformControlsEventMap> {
 
     attach(object: Object3D): this;
     detach(): this;
-    getMode(): "translate" | "rotate" | "scale";
+    getMode(): TransformControlsMode;
     getRaycaster(): Raycaster;
-    setMode(mode: "translate" | "rotate" | "scale"): void;
+    setMode(mode: TransformControlsMode): void;
     setTranslationSnap(translationSnap: number | null): void;
     setRotationSnap(rotationSnap: number | null): void;
     setScaleSnap(scaleSnap: number | null): void;
@@ -108,7 +110,7 @@ export class TransformControlsPlane extends Mesh {
 
     constructor();
 
-    mode: "translate" | "scale" | "rotate";
+    mode: TransformControlsMode;
 
     axis: "X" | "Y" | "Z" | "XY" | "YZ" | "XZ" | "XYZ" | "E";
 

three/examples/jsm/exporters/USDZExporter.d.ts

@@ -1,8 +1,10 @@
 import { Object3D } from "three";
 
 export interface USDZExporterOptions {
-    quickLookCompatible?: boolean;
-    maxTextureSize?: number;
+    ar?: { anchoring: { type: "plane" }; planeAnchoring: { alignment: "horizontal" | "vertical" | "any" } } | undefined;
+    includeAnchoringProperties?: boolean | undefined;
+    quickLookCompatible?: boolean | undefined;
+    maxTextureSize?: number | undefined;
 }
 
 export class USDZExporter {

three/examples/jsm/loaders/FontLoader.d.ts

@@ -1,7 +1,7 @@
 import { Loader, LoadingManager, Shape } from "three";
 
 export interface FontData {
-    glyphs: Record<string, { ha: number; x_min: number; x_max: number; o: string }>;
+    glyphs: Record<string, { ha: number; x_min: number; x_max: number; o?: string | undefined }>;
     familyName: string;
     ascender: number;
     descender: number;

three/examples/jsm/loaders/GLTFLoader.d.ts

@@ -19,6 +19,7 @@ import {
     TextureLoader,
 } from "three";
 
+import { MeshoptDecoder } from "../libs/meshopt_decoder.module.js";
 import { DRACOLoader } from "./DRACOLoader.js";
 import { KTX2Loader } from "./KTX2Loader.js";
 
@@ -40,16 +41,18 @@ export interface GLTF {
 }
 
 export class GLTFLoader extends Loader<GLTF> {
-    constructor(manager?: LoadingManager);
     dracoLoader: DRACOLoader | null;
+    ktx2Loader: KTX2Loader | null;
+    meshoptDecoder: typeof MeshoptDecoder | null;
 
-    setDRACOLoader(dracoLoader: DRACOLoader): GLTFLoader;
+    constructor(manager?: LoadingManager);
 
-    register(callback: (parser: GLTFParser) => GLTFLoaderPlugin): GLTFLoader;
-    unregister(callback: (parser: GLTFParser) => GLTFLoaderPlugin): GLTFLoader;
+    setDRACOLoader(dracoLoader: DRACOLoader): this;
+    setKTX2Loader(ktx2Loader: KTX2Loader | null): this;
+    setMeshoptDecoder(meshoptDecoder: typeof MeshoptDecoder | null): this;
 
-    setKTX2Loader(ktx2Loader: KTX2Loader): GLTFLoader;
-    setMeshoptDecoder(meshoptDecoder: /* MeshoptDecoder */ any): GLTFLoader;
+    register(callback: (parser: GLTFParser) => GLTFLoaderPlugin): this;
+    unregister(callback: (parser: GLTFParser) => GLTFLoaderPlugin): this;
 
     parse(
         data: ArrayBuffer | string,

three/examples/jsm/loaders/LDrawLoader.d.ts

@@ -12,7 +12,7 @@ export class LDrawLoader extends Loader<Group> {
     setFileMap(fileMap: Record<string, string>): void;
     setMaterials(materials: Material[]): void;
 
-    parse(text: string, path: string, onLoad: (data: Group) => void): void;
+    parse(text: string, path: string, onLoad: (data: Group) => void, onError?: (error: unknown) => void): void;
 
     addMaterial(material: Material): void;
     getMaterial(colourCode: string): Material | null;

three/examples/jsm/modifiers/EdgeSplitModifier.d.ts

@@ -1,19 +1,26 @@
 import { BufferGeometry } from "three";
 
+/**
+ * {@link EdgeSplitModifier} is intended to modify the geometry "dissolving" the edges to give a smoother look.
+ *
+ * @example
+ * const geometry = new THREE.IcosahedronGeometry( 10, 3 );
+ * const modifier = new EdgeSplitModifier();
+ * const cutOffAngle = 0.5;
+ * const tryKeepNormals = false;
+ *
+ * modifier.modify( geometry, cutOffAngle, tryKeepNormals );
+ */
 export class EdgeSplitModifier {
+    /**
+     * Create a new {@link EdgeSplitModifier} object.
+     */
     constructor();
 
     /**
-     * @param geometry					The geometry to modify by splitting edges.
-     * 									This geometry can be any of any type: Geometry or BufferGeometry, indexed or
-     * 									not...
-     *
-     * @param cutOffPoint				The cutoff angle in radians. If the angle between two face normals is higher
-     * 									than this value, a split will be made.
-     *
-     * @param [tryKeepNormals = true]	Set to true to keep the normal values for vertices that won't be split.
-     * 									To use this feature, you also need to pass an indexed geometry with a 'normal'
-     * 									BufferAttribute.
+     * Using interpolated vertex normals, the mesh faces will blur at the edges and appear smooth.
+     * You can control the smoothness by setting the `cutOffAngle`.
+     * To try to keep the original normals, set `tryKeepNormals` to `true`.
      */
     modify(geometry: BufferGeometry, cutOffPoint: number, tryKeepNormals: boolean): BufferGeometry;
 }

three/examples/jsm/nodes/Nodes.d.ts

@@ -197,29 +197,9 @@ export * from "./shadernode/ShaderNode.js";
 // accessors
 export { parallaxDirection, parallaxUV, TBNViewMatrix, transformedBentNormalView } from "./accessors/AccessorsUtils.js";
 export { batch, default as BatchNode } from "./accessors/BatchNode.js";
-export {
-    bitangentGeometry,
-    bitangentLocal,
-    BitangentNodeScope,
-    bitangentView,
-    bitangentWorld,
-    default as BitangentNode,
-    transformedBitangentView,
-    transformedBitangentWorld,
-} from "./accessors/BitangentNode.js";
+export * from "./accessors/BitangentNode.js";
 export { buffer, default as BufferNode } from "./accessors/BufferNode.js";
-export {
-    cameraFar,
-    cameraLogDepth,
-    cameraNear,
-    cameraNormalMatrix,
-    cameraPosition,
-    cameraProjectionMatrix,
-    cameraProjectionMatrixInverse,
-    cameraViewMatrix,
-    cameraWorldMatrix,
-    default as CameraNode,
-} from "./accessors/CameraNode.js";
+export * from "./accessors/CameraNode.js";
 export { cubeTexture, default as CubeTextureNode } from "./accessors/CubeTextureNode.js";
 export { default as InstanceNode, instance } from "./accessors/InstanceNode.js";
 export {
@@ -231,6 +211,7 @@ export {
     materialClearcoatNormal,
     materialClearcoatRoughness,
     materialColor,
+    materialDispersion,
     materialEmissive,
     materialIridescence,
     materialIridescenceIOR,
@@ -264,17 +245,10 @@ export {
     modelViewMatrix,
     modelViewPosition,
     modelWorldMatrix,
+    modelWorldMatrixInverse,
 } from "./accessors/ModelNode.js";
 export { default as ModelViewProjectionNode, modelViewProjection } from "./accessors/ModelViewProjectionNode.js";
-export {
-    default as NormalNode,
-    normalGeometry,
-    normalLocal,
-    NormalNodeScope,
-    normalView,
-    normalWorld,
-    transformedNormalView,
-} from "./accessors/NormalNode.js";
+export * from "./accessors/NormalNode.js";
 export {
     default as Object3DNode,
     objectDirection,
@@ -286,36 +260,19 @@ export {
     objectWorldMatrix,
 } from "./accessors/Object3DNode.js";
 export { default as PointUVNode, pointUV } from "./accessors/PointUVNode.js";
-export {
-    default as PositionNode,
-    positionGeometry,
-    positionLocal,
-    PositionNodeScope,
-    positionView,
-    positionViewDirection,
-    positionWorld,
-    positionWorldDirection,
-} from "./accessors/PositionNode.js";
+export * from "./accessors/PositionNode.js";
 export { default as ReferenceNode, reference, referenceBuffer } from "./accessors/ReferenceNode.js";
-export { default as ReflectVectorNode, reflectVector } from "./accessors/ReflectVectorNode.js";
+export * from "./accessors/ReflectVectorNode.js";
 export { default as RendererReferenceNode, rendererReference } from "./accessors/RendererReferenceNode.js";
 export { default as SkinningNode, skinning } from "./accessors/SkinningNode.js";
 export { default as StorageBufferNode, storage, storageObject } from "./accessors/StorageBufferNode.js";
-export {
-    default as TangentNode,
-    tangentGeometry,
-    tangentLocal,
-    TangentNodeScope,
-    tangentView,
-    tangentWorld,
-    transformedTangentView,
-    transformedTangentWorld,
-} from "./accessors/TangentNode.js";
+export * from "./accessors/TangentNode.js";
+export { default as Texture3DNode, texture3D } from "./accessors/Texture3DNode.js";
 export { default as TextureBicubicNode, textureBicubic } from "./accessors/TextureBicubicNode.js";
 export { default as TextureNode, sampler, texture } from "./accessors/TextureNode.js";
 export { default as UniformsNode, uniforms } from "./accessors/UniformsNode.js";
 export { default as UserDataNode, userData } from "./accessors/UserDataNode.js";
-export { default as UVNode, uv } from "./accessors/UVNode.js";
+export * from "./accessors/UVNode.js";
 export { default as VertexColorNode, vertexColor } from "./accessors/VertexColorNode.js";
 
 // display
@@ -369,7 +326,7 @@ export {
 export { default as ViewportSharedTextureNode, viewportSharedTexture } from "./display/ViewportSharedTextureNode.js";
 export { default as ViewportTextureNode, viewportMipTexture, viewportTexture } from "./display/ViewportTextureNode.js";
 
-export { default as PassNode, depthPass, pass, PassNodeScope } from "./display/PassNode.js";
+export { default as PassNode, depthPass, pass, PassNodeScope, texturePass } from "./display/PassNode.js";
 
 // code
 export { code, CodeNodeInclude, default as CodeNode, glsl, js, wgsl } from "./code/CodeNode.js";

three/examples/jsm/nodes/accessors/BitangentNode.d.ts

@@ -1,27 +1,9 @@
-import Node from "../core/Node.js";
 import MathNode from "../math/MathNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
-export type BitangentNodeScope =
-    | typeof BitangentNode.LOCAL
-    | typeof BitangentNode.VIEW
-    | typeof BitangentNode.WORLD
-    | typeof BitangentNode.GEOMETRY;
-
-export default class BitangentNode extends Node {
-    static GEOMETRY: "geometry";
-    static LOCAL: "local";
-    static VIEW: "view";
-    static WORLD: "world";
-
-    scope: BitangentNodeScope;
-
-    constructor(scope?: BitangentNodeScope);
-}
-
-export const bitangentGeometry: ShaderNodeObject<BitangentNode>;
-export const bitangentLocal: ShaderNodeObject<BitangentNode>;
-export const bitangentView: ShaderNodeObject<BitangentNode>;
-export const bitangentWorld: ShaderNodeObject<BitangentNode>;
+export const bitangentGeometry: ShaderNodeObject<MathNode>;
+export const bitangentLocal: ShaderNodeObject<MathNode>;
+export const bitangentView: ShaderNodeObject<MathNode>;
+export const bitangentWorld: ShaderNodeObject<MathNode>;
 export const transformedBitangentView: ShaderNodeObject<MathNode>;
 export const transformedBitangentWorld: ShaderNodeObject<MathNode>;

three/examples/jsm/nodes/accessors/BufferAttributeNode.d.ts

@@ -0,0 +1,49 @@
+import { BufferAttribute, InterleavedBuffer, InterleavedBufferAttribute, TypedArray, Usage } from "three";
+import InputNode from "../core/InputNode.js";
+import NodeBuilder from "../core/NodeBuilder.js";
+declare class BufferAttributeNode extends InputNode<TypedArray | InterleavedBuffer | BufferAttribute> {
+    readonly isBufferNode: true;
+    bufferType: string | null;
+    bufferStride: number;
+    bufferOffset: number;
+    usage: Usage;
+    instanced: boolean;
+    attribute: BufferAttribute | InterleavedBufferAttribute | null;
+    constructor(
+        value: TypedArray | InterleavedBuffer | BufferAttribute,
+        bufferType?: string | null,
+        bufferStride?: number,
+        bufferOffset?: number,
+    );
+    getNodeType(builder: NodeBuilder): string | null;
+    setup(builder: NodeBuilder): void;
+    generate(builder: NodeBuilder): string | null | undefined;
+    getInputType(): string;
+    setUsage(value: Usage): this;
+    setInstanced(value: boolean): this;
+}
+export default BufferAttributeNode;
+export declare const bufferAttribute: (
+    array: TypedArray | InterleavedBuffer | BufferAttribute,
+    type?: string | null,
+    stride?: number,
+    offset?: number,
+) => import("../shadernode/ShaderNode.js").ShaderNodeObject<BufferAttributeNode>;
+export declare const dynamicBufferAttribute: (
+    array: TypedArray | InterleavedBuffer | BufferAttribute,
+    type?: string | null,
+    stride?: number,
+    offset?: number,
+) => import("../shadernode/ShaderNode.js").ShaderNodeObject<BufferAttributeNode>;
+export declare const instancedBufferAttribute: (
+    array: TypedArray | InterleavedBuffer | BufferAttribute,
+    type?: string | null,
+    stride?: number,
+    offset?: number,
+) => import("../shadernode/ShaderNode.js").ShaderNodeObject<BufferAttributeNode>;
+export declare const instancedDynamicBufferAttribute: (
+    array: TypedArray | InterleavedBuffer | BufferAttribute,
+    type?: string | null,
+    stride?: number,
+    offset?: number,
+) => import("../shadernode/ShaderNode.js").ShaderNodeObject<BufferAttributeNode>;

three/examples/jsm/nodes/accessors/BufferNode.d.ts

@@ -1,18 +1,17 @@
-import { NodeTypeOption } from "../core/constants.js";
 import UniformNode from "../core/UniformNode.js";
 import { NodeOrType, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
-export default class BufferNode extends UniformNode<ArrayLike<number> | null> {
+export default class BufferNode extends UniformNode<unknown> {
     isBufferNode: true;
 
     bufferType: string;
     bufferCount: number;
 
-    constructor(value: ArrayLike<number> | null, bufferType: NodeTypeOption, bufferCount?: number);
+    constructor(value: unknown, bufferType: string, bufferCount?: number);
 }
 
 export const buffer: (
-    value: ArrayLike<number> | null,
+    value: unknown,
     nodeOrType: NodeOrType,
     count: number,
 ) => ShaderNodeObject<BufferNode>;

three/examples/jsm/nodes/accessors/CameraNode.d.ts

@@ -1,22 +1,13 @@
+import { Matrix3, Matrix4, Vector3 } from "three";
+import UniformNode from "../core/UniformNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import Object3DNode from "./Object3DNode.js";
 
-export default class CameraNode extends Object3DNode {
-    constructor(scope?: string);
-
-    static PROJECTION_MATRIX: "projectionMatrix";
-    static PROJECTION_MATRIX_INVERSE: "projectionMatrixInverse";
-    static NEAR: "near";
-    static FAR: "far";
-    static LOG_DEPTH: "logDepth";
-}
-
-export const cameraProjectionMatrix: ShaderNodeObject<CameraNode>;
-export const cameraProjectionMatrixInverse: ShaderNodeObject<CameraNode>;
-export const cameraNear: ShaderNodeObject<CameraNode>;
-export const cameraFar: ShaderNodeObject<CameraNode>;
-export const cameraLogDepth: ShaderNodeObject<CameraNode>;
-export const cameraViewMatrix: ShaderNodeObject<CameraNode>;
-export const cameraNormalMatrix: ShaderNodeObject<CameraNode>;
-export const cameraWorldMatrix: ShaderNodeObject<CameraNode>;
-export const cameraPosition: ShaderNodeObject<CameraNode>;
+export const cameraNear: ShaderNodeObject<UniformNode<number>>;
+export const cameraFar: ShaderNodeObject<UniformNode<number>>;
+export const cameraLogDepth: 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>>;

three/examples/jsm/nodes/accessors/CubeTextureNode.d.ts

@@ -8,7 +8,7 @@ export default class CubeTextureNode extends TextureNode {
     uvNode: ShaderNodeObject<Node> | null;
     levelNode: ShaderNodeObject<Node> | null;
 
-    constructor(value: CubeTexture, uvNode?: Node | null, levelNode?: Node | null);
+    constructor(value: CubeTexture, uvNode?: ShaderNodeObject<Node> | null, levelNode?: ShaderNodeObject<Node> | null);
 
     getDefaultUV(): Node;
 }

three/examples/jsm/nodes/accessors/MaterialNode.d.ts

@@ -37,7 +37,8 @@ export type MaterialNodeScope =
     | typeof MaterialNode.LINE_GAP_SIZE
     | typeof MaterialNode.LINE_WIDTH
     | typeof MaterialNode.LINE_DASH_OFFSET
-    | typeof MaterialNode.POINT_WIDTH;
+    | typeof MaterialNode.POINT_WIDTH
+    | typeof MaterialNode.DISPERSION;
 
 export default class MaterialNode extends Node {
     static ALPHA_TEST: "alphaTest";
@@ -74,6 +75,7 @@ export default class MaterialNode extends Node {
     static LINE_WIDTH: "linewidth";
     static LINE_DASH_OFFSET: "dashOffset";
     static POINT_WIDTH: "pointWidth";
+    static DISPERSION: "dispersion";
 
     scope: MaterialNodeScope;
     constructor(scope?: MaterialNodeScope);
@@ -115,4 +117,5 @@ export const materialLineGapSize: ShaderNodeObject<MaterialNode>;
 export const materialLineWidth: ShaderNodeObject<MaterialNode>;
 export const materialLineDashOffset: ShaderNodeObject<MaterialNode>;
 export const materialPointWidth: ShaderNodeObject<MaterialNode>;
+export const materialDispersion: ShaderNodeObject<MaterialNode>;
 export const materialAnisotropyVector: ShaderNodeObject<UniformNode<Vector2>>;

three/examples/jsm/nodes/accessors/ModelNode.d.ts

@@ -1,3 +1,5 @@
+import { Matrix4 } from "three/src/Three.js";
+import { UniformNode } from "../Nodes.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import Object3DNode from "./Object3DNode.js";
 
@@ -15,3 +17,4 @@ export const modelWorldMatrix: ShaderNodeObject<ModelNode>;
 export const modelPosition: ShaderNodeObject<ModelNode>;
 export const modelScale: ShaderNodeObject<ModelNode>;
 export const modelViewPosition: ShaderNodeObject<ModelNode>;
+export const modelWorldMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;

three/examples/jsm/nodes/accessors/ModelViewProjectionNode.d.ts

@@ -1,9 +1,8 @@
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import PositionNode from "./PositionNode.js";
 
 export default class ModelViewProjectionNode extends Node {
-    constructor(positionNode?: PositionNode);
+    constructor(positionNode?: Node);
 }
 
 export const modelViewProjection: (position?: NodeRepresentation) => ShaderNodeObject<ModelViewProjectionNode>;

three/examples/jsm/nodes/accessors/NormalNode.d.ts

@@ -1,20 +1,12 @@
-import Node from "../core/Node.js";
+import AttributeNode from "../core/AttributeNode.js";
+import PropertyNode from "../core/PropertyNode.js";
 import VarNode from "../core/VarNode.js";
+import MathNode from "../math/MathNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
-export type NormalNodeScope = typeof NormalNode.GEOMETRY | typeof NormalNode.LOCAL | typeof NormalNode.VIEW;
-
-export default class NormalNode extends Node {
-    static GEOMETRY: "geometry";
-    static LOCAL: "local";
-    static VIEW: "view";
-    scope: NormalNodeScope;
-
-    constructor(scope?: NormalNodeScope);
-}
-
-export const normalGeometry: ShaderNodeObject<NormalNode>;
-export const normalLocal: ShaderNodeObject<NormalNode>;
-export const normalView: ShaderNodeObject<NormalNode>;
-export const normalWorld: ShaderNodeObject<NormalNode>;
-export const transformedNormalView: ShaderNodeObject<VarNode>;
+export const normalGeometry: ShaderNodeObject<AttributeNode>;
+export const normalLocal: ShaderNodeObject<VarNode>;
+export const normalView: ShaderNodeObject<MathNode>;
+export const normalWorld: ShaderNodeObject<MathNode>;
+export const transformedNormalView: ShaderNodeObject<PropertyNode>;
+export const transformedClearcoatNormalView: ShaderNodeObject<PropertyNode>;

three/examples/jsm/nodes/accessors/PositionNode.d.ts

@@ -1,29 +1,9 @@
 import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
-export type PositionNodeScope =
-    | typeof PositionNode.GEOMETRY
-    | typeof PositionNode.LOCAL
-    | typeof PositionNode.WORLD
-    | typeof PositionNode.WORLD_DIRECTION
-    | typeof PositionNode.VIEW
-    | typeof PositionNode.VIEW_DIRECTION;
-
-export default class PositionNode extends Node {
-    static GEOMETRY: "geometry";
-    static LOCAL: "local";
-    static WORLD: "world";
-    static WORLD_DIRECTION: "worldDirection";
-    static VIEW: "view";
-    static VIEW_DIRECTION: "viewDirection";
-    scope: PositionNodeScope;
-
-    constructor(scope?: PositionNodeScope);
-}
-
-export const positionGeometry: ShaderNodeObject<PositionNode>;
-export const positionLocal: ShaderNodeObject<PositionNode>;
-export const positionWorld: ShaderNodeObject<PositionNode>;
-export const positionWorldDirection: ShaderNodeObject<PositionNode>;
-export const positionView: ShaderNodeObject<PositionNode>;
-export const positionViewDirection: ShaderNodeObject<PositionNode>;
+export const positionGeometry: ShaderNodeObject<Node>;
+export const positionLocal: ShaderNodeObject<Node>;
+export const positionWorld: ShaderNodeObject<Node>;
+export const positionWorldDirection: ShaderNodeObject<Node>;
+export const positionView: ShaderNodeObject<Node>;
+export const positionViewDirection: ShaderNodeObject<Node>;

three/examples/jsm/nodes/accessors/ReferenceNode.d.ts

@@ -1,11 +1,10 @@
-import { NodeTypeOption } from "../core/constants.js";
 import Node from "../core/Node.js";
 import { NodeOrType, NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class ReferenceNode<T> extends Node {
     property: string;
 
-    uniformType: NodeTypeOption;
+    uniformType: string;
 
     object: T;
     count: number | null;
@@ -14,9 +13,9 @@ export default class ReferenceNode<T> extends Node {
     reference: T | null;
     node: Node | null;
 
-    constructor(property: string, uniformType: NodeTypeOption, object?: T | null, count?: number | null);
+    constructor(property: string, uniformType: string, object?: T | null, count?: number | null);
 
-    setNodeType(uniformType: NodeTypeOption): void;
+    setNodeType(uniformType: string): void;
 }
 
 export const reference: <T>(name: string, nodeOrType: NodeOrType, object: T) => ShaderNodeObject<ReferenceNode<T>>;

three/examples/jsm/nodes/accessors/ReflectVectorNode.d.ts

@@ -1,11 +1,6 @@
 import Node from "../core/Node.js";
+import VarNode from "../core/VarNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
-export default class ReflectVectorNode extends Node {
-    constructor();
-
-    getHash(): "reflectVector";
-    setup(): Node;
-}
-
-export const reflectVector: ShaderNodeObject<ReflectVectorNode>;
+export const reflectView: ShaderNodeObject<Node>;
+export const reflectVector: ShaderNodeObject<VarNode>;

three/examples/jsm/nodes/accessors/RendererReferenceNode.d.ts

@@ -1,16 +1,15 @@
 import Renderer from "../../renderers/common/Renderer.js";
-import { NodeTypeOption } from "../core/constants.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import ReferenceNode from "./ReferenceNode.js";
 
 export default class RendererReferenceNode extends ReferenceNode<Renderer> {
     renderer: Renderer | null;
 
-    constructor(property: string, inputType: NodeTypeOption, renderer?: Renderer | null);
+    constructor(property: string, inputType: string, renderer?: Renderer | null);
 }
 
 export const rendererReference: (
     name: string,
-    type: NodeTypeOption,
+    type: string,
     renderer?: Renderer | null,
 ) => ShaderNodeObject<RendererReferenceNode>;

three/examples/jsm/nodes/accessors/StorageBufferNode.d.ts

@@ -1,4 +1,5 @@
-import { NodeTypeOption } from "../core/constants.js";
+import StorageBufferAttribute from "../../renderers/common/StorageBufferAttribute.js";
+import StorageInstancedBufferAttribute from "../../renderers/common/StorageInstancedBufferAttribute.js";
 import { NodeOrType, NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import StorageArrayElementNode from "../utils/StoargeArrayElementNode.js";
 import BufferNode from "./BufferNode.js";
@@ -7,7 +8,11 @@ export default class StorageBufferNode extends BufferNode {
     readonly isStorageBufferNode: true;
     bufferObject: boolean;
 
-    constructor(value: ArrayLike<number>, bufferType: NodeTypeOption, bufferCount?: number);
+    constructor(
+        value: StorageBufferAttribute | StorageInstancedBufferAttribute,
+        bufferType: string,
+        bufferCount?: number,
+    );
 
     element(indexNode: NodeRepresentation): ShaderNodeObject<StorageArrayElementNode>;
 
@@ -15,12 +20,12 @@ export default class StorageBufferNode extends BufferNode {
 }
 
 export const storage: (
-    value: ArrayLike<number>,
+    value: StorageBufferAttribute | StorageInstancedBufferAttribute,
     nodeOrType: NodeOrType,
     count: number,
 ) => ShaderNodeObject<StorageBufferNode>;
 export const storageObject: (
-    value: ArrayLike<number>,
+    value: StorageBufferAttribute | StorageInstancedBufferAttribute,
     nodeOrType: NodeOrType,
     count: number,
 ) => ShaderNodeObject<StorageBufferNode>;