@types/three 0.164.1 → 0.166.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, 28 Jun 2024 21:35:38 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/GLTFExporter.d.ts

@@ -82,6 +82,12 @@ export class GLTFExporter {
         options?: GLTFExporterOptions,
     ): void;
 
+    /**
+     * Generates a .gltf (JSON) or .glb (binary) output from the input (Scenes or Objects).
+     *
+     * This is just like the {@link parse}() method, but instead of accepting callbacks it returns a promise that
+     * resolves with the result, and otherwise accepts the same options.
+     */
     parseAsync(
         input: Object3D | Object3D[],
         options?: GLTFExporterOptions,

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

@@ -1,6 +1,30 @@
 import { BufferGeometry } from "three";
 
+/**
+ * {@link TeapotGeometry} tesselates the famous Utah teapot database by Martin Newell.
+ *
+ * {@link TeapotGeometry} is an add-on, and must be imported explicitly. See
+ * [Installation / Addons]{@link https://threejs.org/docs/#manual/en/introduction/Installation}.
+ *
+ * @example
+ * import { TeapotGeometry } from 'three/addons/geometries/TeapotGeometry.js';
+ *
+ * const geometry = new TeapotGeometry( 50, 18 );
+ * const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
+ * const teapot = new THREE.Mesh( geometry, material );
+ * scene.add( teapot );
+ */
 export class TeapotGeometry extends BufferGeometry {
+    /**
+     * @param size Relative scale of the teapot. Optional; Defaults to `50`.
+     * @param segments Number of line segments to subdivide each patch edge. Optional; Defaults to `10`.
+     * @param bottom Whether the bottom of the teapot is generated or not. Optional; Defaults to `true`.
+     * @param lid Whether the lid is generated or not. Optional; Defaults to `true`.
+     * @param body Whether the body is generated or not. Optional; Defaults to `true`.
+     * @param fitLid Whether the lid is slightly stretched to prevent gaps between the body and lid or not. Optional;
+     * Defaults to `true`.
+     * @param blinn Whether the teapot is scaled vertically for better aesthetics or not. Optional; Defaults to `true`.
+     */
     constructor(
         size?: number,
         segments?: number,

three/examples/jsm/helpers/ViewHelper.d.ts

@@ -1,15 +1,17 @@
 import { Camera, Object3D, Vector3, WebGLRenderer } from "three";
 
 export class ViewHelper extends Object3D {
+    readonly isViewHelper: true;
+
     animating: boolean;
     center: Vector3;
 
-    readonly isViewHelper: true;
+    render: (renderer: WebGLRenderer) => void;
+    handleClick: (event: MouseEvent) => boolean;
+    setLabels: (labelX?: string, labelY?: string, labelZ?: string) => void;
+    setLabelStyle: (font?: string, color?: string, radius?: number) => void;
+    update: (delta: number) => void;
+    dispose: () => void;
 
     constructor(camera: Camera, domElement: HTMLElement);
-
-    render(renderer: WebGLRenderer): void;
-    handleClick(event: MouseEvent): boolean;
-    update(delta: number): void;
-    dispose(): void;
 }

three/examples/jsm/lines/LineMaterial.d.ts

@@ -1,6 +1,6 @@
-import { Color, ColorRepresentation, MaterialParameters, ShaderMaterial, Vector2 } from "three";
+import { Color, ColorRepresentation, ShaderMaterial, ShaderMaterialParameters, Vector2 } from "three";
 
-export interface LineMaterialParameters extends MaterialParameters {
+export interface LineMaterialParameters extends ShaderMaterialParameters {
     alphaToCoverage?: boolean | undefined;
     color?: ColorRepresentation | undefined;
     dashed?: boolean | undefined;
@@ -8,9 +8,7 @@ export interface LineMaterialParameters extends MaterialParameters {
     dashSize?: number | undefined;
     dashOffset?: number | undefined;
     gapSize?: number | undefined;
-    linewidth?: number | undefined;
     resolution?: Vector2 | undefined;
-    wireframe?: boolean | undefined;
     worldUnits?: boolean | undefined;
 }
 

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

@@ -1,7 +1,13 @@
-import { CompressedPixelFormat, CompressedTextureLoader, LoadingManager, PixelFormat } from "three";
+import {
+    CompressedPixelFormat,
+    CompressedTextureLoader,
+    CompressedTextureMipmap,
+    LoadingManager,
+    PixelFormat,
+} from "three";
 
 export interface DDS {
-    mipmaps: object[];
+    mipmaps: CompressedTextureMipmap[];
     width: number;
     height: number;
     format: PixelFormat | CompressedPixelFormat;

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

@@ -3,6 +3,7 @@ import {
     BufferAttribute,
     BufferGeometry,
     Camera,
+    ColorSpace,
     FileLoader,
     Group,
     ImageBitmapLoader,
@@ -19,6 +20,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 +42,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,
@@ -109,7 +113,8 @@ export class GLTFParser {
             texCoord?: number | undefined;
             extensions?: any;
         },
-    ) => Promise<void>;
+        colorSpace?: ColorSpace | undefined,
+    ) => Promise<Texture | null>;
     assignFinalMaterial: (object: Mesh) => void;
     getMaterialType: () => typeof MeshStandardMaterial;
     loadMaterial: (materialIndex: number) => Promise<Material>;

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

@@ -1,7 +1,13 @@
-import { CompressedPixelFormat, CompressedTextureLoader, LoadingManager, PixelFormat } from "three";
+import {
+    CompressedPixelFormat,
+    CompressedTextureLoader,
+    CompressedTextureMipmap,
+    LoadingManager,
+    PixelFormat,
+} from "three";
 
 export interface KTX {
-    mipmaps: object[];
+    mipmaps: CompressedTextureMipmap[];
     width: number;
     height: number;
     format: PixelFormat | CompressedPixelFormat;

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

@@ -1,7 +1,7 @@
-import { CompressedPixelFormat, CompressedTextureLoader, LoadingManager } from "three";
+import { CompressedPixelFormat, CompressedTextureLoader, CompressedTextureMipmap, LoadingManager } from "three";
 
 export interface PVR {
-    mipmaps: object[];
+    mipmaps: CompressedTextureMipmap[];
     width: number;
     height: number;
     format: CompressedPixelFormat;

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

@@ -127,6 +127,7 @@ export {
     step,
     tan,
     transformDirection,
+    transpose,
     trunc,
 } from "./math/MathNode.js";
 
@@ -164,7 +165,7 @@ export { triNoise3D } from "./math/TriNoise3D.js";
 // utils
 export { default as ArrayElementNode } from "./utils/ArrayElementNode.js";
 export { default as ConvertNode } from "./utils/ConvertNode.js";
-export { default as DiscardNode, discard } from "./utils/DiscardNode.js";
+export { default as DiscardNode, discard, Return } from "./utils/DiscardNode.js";
 export { default as EquirectUVNode, equirectUV } from "./utils/EquirectUVNode.js";
 export { default as JoinNode } from "./utils/JoinNode.js";
 export { default as MatcapUVNode, matcapUV } from "./utils/MatcapUVNode.js";
@@ -197,29 +198,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 +212,7 @@ export {
     materialClearcoatNormal,
     materialClearcoatRoughness,
     materialColor,
+    materialDispersion,
     materialEmissive,
     materialIridescence,
     materialIridescenceIOR,
@@ -264,17 +246,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 +261,20 @@ 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 { default as StorageTextureNode, storageTexture, textureStore } from "./accessors/StorageTextureNode.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
@@ -340,19 +299,23 @@ export {
     linearTosRGB,
     sRGBToLinear,
 } from "./display/ColorSpaceNode.js";
+export { default as DepthOfFieldNode, dof } from "./display/DepthOfFieldNode.js";
+export { default as DotScreenNode, dotScreen } from "./display/DotScreenNode.js";
 export { default as FrontFacingNode, faceDirection, frontFacing } from "./display/FrontFacingNode.js";
 export { default as GaussianBlurNode, gaussianBlur } from "./display/GaussianBlurNode.js";
 export { default as NormalMapNode, normalMap } from "./display/NormalMapNode.js";
 export { default as PosterizeNode, posterize } from "./display/PosterizeNode.js";
+export { default as RGBShiftNode, rgbShift } from "./display/RGBShiftNode.js";
+export { default as SobelOperatorNode, sobel } from "./display/SobelOperatorNode.js";
 export { default as ToneMappingNode, toneMapping } from "./display/ToneMappingNode.js";
 export {
     default as ViewportDepthNode,
     depth,
-    depthPixel,
-    depthTexture,
+    linearDepth,
     orthographicDepthToViewZ,
     perspectiveDepthToViewZ,
     ViewportDepthNodeScope,
+    viewportLinearDepth,
     viewZToOrthographicDepth,
     viewZToPerspectiveDepth,
 } from "./display/ViewportDepthNode.js";
@@ -369,7 +332,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";
@@ -398,6 +361,7 @@ export { default as LightingContextNode, lightingContext } from "./lighting/Ligh
 export { default as LightingNode } from "./lighting/LightingNode.js";
 export { default as LightsNode, lights } from "./lighting/LightsNode.js";
 export { default as PointLightNode } from "./lighting/PointLightNode.js";
+export { default as RectAreaLightNode } from "./lighting/RectAreaLightNode.js";
 export { default as SpotLightNode } from "./lighting/SpotLightNode.js";
 
 // pmrem

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,50 @@
+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,
+    );
+    getHash(builder: NodeBuilder): string;
+    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>>;