@types/three 0.150.2 → 0.151.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, 18 Apr 2023 23:32:45 GMT
+ * Last updated: Fri, 28 Apr 2023 20:02:51 GMT
  * Dependencies: [@types/fflate](https://npmjs.com/package/@types/fflate), [@types/lil-gui](https://npmjs.com/package/@types/lil-gui), [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/webxr](https://npmjs.com/package/@types/webxr)
  * Global values: `THREE`
 

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

@@ -0,0 +1,21 @@
+import { OrbitControls } from './OrbitControls';
+import { Camera } from '../../../src/Three';
+
+/**
+ * MapControls performs orbiting, dollying (zooming), and panning.
+ * Unlike TrackballControls, it maintains the "up" direction
+ * object.up (+Y by default).
+ *
+ *    Orbit - right mouse, or left mouse + ctrl/meta/shiftKey / touch:
+ *    two-finger rotate
+ *    Zoom - middle mouse, or mousewheel / touch: two-finger spread or squish
+ *    Pan - left mouse, or arrow keys / touch: one-finger move
+ *
+ * @param object - The camera to be controlled. The camera must not
+ * be a child of another object, unless that object is the scene itself.
+ * @param domElement - The HTML element used for
+ * event listeners.
+ */
+export class MapControls extends OrbitControls {
+    constructor(object: Camera, domElement?: HTMLElement);
+}

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

@@ -214,7 +214,7 @@ export class OrbitControls {
     /**
      * Used internally by the .saveState and .reset methods.
      */
-    zoomO: number;
+    zoom0: number;
 
     /**
      * Update the controls. Must be called after any manual changes
@@ -276,7 +276,3 @@ export class OrbitControls {
 
     dispatchEvent(event: { type: string; target: any }): void;
 }
-
-export class MapControls extends OrbitControls {
-    constructor(object: Camera, domElement?: HTMLElement);
-}

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

@@ -3,6 +3,7 @@ import { Camera, EventDispatcher, Vector3 } from '../../../src/Three';
 export class PointerLockControls extends EventDispatcher {
     constructor(camera: Camera, domElement?: HTMLElement);
 
+    camera: Camera;
     domElement: HTMLElement;
 
     // API
@@ -12,6 +13,8 @@ export class PointerLockControls extends EventDispatcher {
     minPolarAngle: number;
     maxPolarAngle: number;
 
+    pointerSpeed: number;
+
     connect(): void;
     disconnect(): void;
     dispose(): void;

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

@@ -20,6 +20,8 @@ export class TrackballControls extends EventDispatcher {
     dynamicDampingFactor: number;
     minDistance: number;
     maxDistance: number;
+    minZoom: number;
+    maxZoom: number;
     keys: string[];
     mouseButtons: { LEFT: MOUSE; MIDDLE: MOUSE; RIGHT: MOUSE };
 

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

@@ -1,5 +1,4 @@
-import { Object3D, Vector3, WebGLRenderer } from '../../../src/Three';
-import { Octree } from '../math/Octree';
+import { Camera, Object3D, Vector3, WebGLRenderer } from '../../../src/Three';
 
 export class ViewHelper extends Object3D {
     animating: boolean;
@@ -7,10 +6,10 @@ export class ViewHelper extends Object3D {
 
     readonly isViewHelper: true;
 
-    constructor(camera: Octree, domElement: HTMLElement);
+    constructor(camera: Camera, domElement: HTMLElement);
 
     render(renderer: WebGLRenderer): void;
-    handleClick(event: PointerEvent): boolean;
+    handleClick(event: MouseEvent): boolean;
     update(delta: number): void;
     dispose(): void;
 }

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

@@ -16,6 +16,7 @@ import {
     TextureLoader,
     FileLoader,
     ImageBitmapLoader,
+    Skeleton,
 } from '../../../src/Three';
 
 import { DRACOLoader } from './DRACOLoader';
@@ -131,10 +132,7 @@ export class GLTFParser {
     ) => Promise<BufferGeometry[]>;
     loadMesh: (meshIndex: number) => Promise<Group | Mesh | SkinnedMesh>;
     loadCamera: (cameraIndex: number) => Promise<Camera>;
-    loadSkin: (skinIndex: number) => Promise<{
-        joints: number[];
-        inverseBindMatrices?: BufferAttribute | InterleavedBufferAttribute | undefined;
-    }>;
+    loadSkin: (skinIndex: number) => Promise<Skeleton>;
     loadAnimation: (animationIndex: number) => Promise<AnimationClip>;
     loadNode: (nodeIndex: number) => Promise<Object3D>;
     loadScene: () => Promise<Group>;

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

@@ -1,4 +1,4 @@
-import { Loader, LoadingManager, ShapePath, BufferGeometry, Vector3, Shape } from '../../../src/Three';
+import { Loader, LoadingManager, ShapePath, BufferGeometry, Vector3, Shape, Vector2 } from '../../../src/Three';
 
 export interface SVGResultPaths extends ShapePath {
     userData?:
@@ -43,14 +43,25 @@ export class SVGLoader extends Loader {
         lineCap?: string,
         miterLimit?: number,
     ): StrokeStyle;
+
+    /**
+     * Generates a stroke with some witdh around the given path.
+     * @remarks The path can be open or closed (last point equals to first point)
+     * @param points  Array of Vector2D (the path). Minimum 2 points.
+     * @param style  Object with SVG properties as returned by SVGLoader.getStrokeStyle(), or SVGLoader.parse() in the path.userData.style object
+     * @param arcDivisions Arc divisions for round joins and endcaps. (Optional)
+     * @param minDistance Points closer to this distance will be merged. (Optional)
+     * @returns BufferGeometry with stroke triangles (In plane z = 0). UV coordinates are generated ('u' along path. 'v' across it, from left to right)
+     */
     static pointsToStroke(
-        points: Vector3[],
+        points: Vector2[],
         style: StrokeStyle,
         arcDivisions?: number,
         minDistance?: number,
     ): BufferGeometry;
+
     static pointsToStrokeWithBuffers(
-        points: Vector3[],
+        points: Vector2[],
         style: StrokeStyle,
         arcDivisions?: number,
         minDistance?: number,
@@ -59,5 +70,6 @@ export class SVGLoader extends Loader {
         uvs?: number[],
         vertexOffset?: number,
     ): number;
+
     static createShapes(shapePath: ShapePath): Shape[];
 }

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

@@ -1,245 +1,149 @@
+// constants
+export * from './core/constants';
+
 // core
-import ArrayUniformNode from './core/ArrayUniformNode';
-import AttributeNode from './core/AttributeNode';
-import BypassNode from './core/BypassNode';
-import CacheNode from './core/CacheNode';
-import CodeNode, { CodeNodeInclude } from './core/CodeNode';
-import ConstNode from './core/ConstNode';
-import ContextNode from './core/ContextNode';
-import ExpressionNode from './core/ExpressionNode';
-import FunctionCallNode from './core/FunctionCallNode';
-import FunctionNode, { FunctionNodeArguments } from './core/FunctionNode';
-import InstanceIndexNode from './core/InstanceIndexNode';
-import Node from './core/Node';
-import NodeAttribute from './core/NodeAttribute';
-import NodeBuilder from './core/NodeBuilder';
-import NodeCache from './core/NodeCache';
-import NodeCode from './core/NodeCode';
-import NodeFrame from './core/NodeFrame';
-import NodeFunctionInput from './core/NodeFunctionInput';
-import NodeKeywords from './core/NodeKeywords';
-import NodeUniform from './core/NodeUniform';
-import NodeVar from './core/NodeVar';
-import NodeVarying from './core/NodeVarying';
-import PropertyNode from './core/PropertyNode';
-import StackNode from './core/StackNode';
-import TempNode from './core/TempNode';
-import UniformNode from './core/UniformNode';
-import VarNode from './core/VarNode';
-import VaryNode from './core/VaryNode';
+export { default as ArrayUniformNode } from './core/ArrayUniformNode';
+export { default as AttributeNode } from './core/AttributeNode';
+export { default as BypassNode } from './core/BypassNode';
+export { default as CacheNode } from './core/CacheNode';
+export { default as ConstNode } from './core/ConstNode';
+export { default as ContextNode } from './core/ContextNode';
+export { default as InstanceIndexNode } from './core/InstanceIndexNode';
+export { default as Node } from './core/Node';
+export { default as NodeAttribute } from './core/NodeAttribute';
+export { default as NodeBuilder } from './core/NodeBuilder';
+export { default as NodeCache } from './core/NodeCache';
+export { default as NodeCode } from './core/NodeCode';
+export { default as NodeFrame } from './core/NodeFrame';
+export { default as NodeFunctionInput } from './core/NodeFunctionInput';
+export { default as NodeKeywords } from './core/NodeKeywords';
+export { default as NodeUniform } from './core/NodeUniform';
+export { default as NodeVar } from './core/NodeVar';
+export { default as NodeVarying } from './core/NodeVarying';
+export { default as PropertyNode } from './core/PropertyNode';
+export { default as StackNode } from './core/StackNode';
+export { default as TempNode } from './core/TempNode';
+export { default as UniformNode } from './core/UniformNode';
+export { default as VarNode } from './core/VarNode';
+export { default as VaryingNode } from './core/VaryingNode';
 
-// accessors
-import BitangentNode, { BitangentNodeScope } from './accessors/BitangentNode';
-import BufferNode from './accessors/BufferNode';
-import CameraNode, { CameraNodeScope } from './accessors/CameraNode';
-import CubeTextureNode from './accessors/CubeTextureNode';
-import InstanceNode from './accessors/InstanceNode';
-import MaterialNode, { MaterialNodeScope } from './accessors/MaterialNode';
-import MaterialReferenceNode from './accessors/MaterialReferenceNode';
-import ModelNode from './accessors/ModelNode';
-import ModelViewProjectionNode from './accessors/ModelViewProjectionNode';
-import NormalNode, { NormalNodeScope } from './accessors/NormalNode';
-import Object3DNode, { Object3DNodeScope } from './accessors/Object3DNode';
-import PointUVNode from './accessors/PointUVNode';
-import PositionNode, { PositionNodeScope } from './accessors/PositionNode';
-import ReferenceNode from './accessors/ReferenceNode';
-import ReflectVectorNode from './accessors/ReflectVectorNode';
-import SkinningNode from './accessors/SkinningNode';
-import TangentNode, { TangentNodeScope } from './accessors/TangentNode';
-import TextureNode from './accessors/TextureNode';
-import UVNode from './accessors/UVNode';
-import UserDataNode from './accessors/UserDataNode';
+export * as NodeUtils from './core/NodeUtils.js';
 
-// geometry
-import RangeNode, { RangeModeBound } from './geometry/RangeNode';
+// math
+export {
+    default as MathNode,
+    MathNodeMethod1,
+    MathNodeMethod2,
+    MathNodeMethod3,
+    MathNodeMethod,
+} from './math/MathNode';
+export { default as OperatorNode, OperatorNodeOp } from './math/OperatorNode';
+export { default as CondNode } from './math/CondNode';
 
-// gpgpu
-import ComputeNode from './gpgpu/ComputeNode';
+// utils
+export { default as ArrayElementNode } from './utils/ArrayElementNode';
+export { default as ConvertNode } from './utils/ConvertNode';
+export { default as EquirectUVNode } from './utils/EquirectUVNode';
+export { default as JoinNode } from './utils/JoinNode';
+export { default as MatcapUVNode } from './utils/MatcapUVNode';
+export { default as MaxMipLevelNode } from './utils/MaxMipLevelNode';
+export { default as OscNode, OscNodeMethod } from './utils/OscNode';
+export { default as RemapNode } from './utils/RemapNode';
+export { default as RotateUVNode } from './utils/RotateUVNode';
+export { default as SpecularMIPLevelNode } from './utils/SpecularMIPLevelNode';
+export { default as SplitNode } from './utils/SplitNode';
+export { default as SpriteSheetUVNode } from './utils/SpriteSheetUVNode';
+export { default as TimerNode, TimerNodeScope } from './utils/TimerNode';
+export { default as TriplanarTexturesNode } from './utils/TriplanarTexturesNode';
+
+// shader node
+export * from './shadernode/ShaderNodeElements';
+
+// accessors
+export { default as BitangentNode, BitangentNodeScope } from './accessors/BitangentNode';
+export { default as BufferNode } from './accessors/BufferNode';
+export { default as CameraNode, CameraNodeScope } from './accessors/CameraNode';
+export { default as CubeTextureNode } from './accessors/CubeTextureNode';
+export { default as InstanceNode } from './accessors/InstanceNode';
+export { default as MaterialNode, MaterialNodeScope } from './accessors/MaterialNode';
+export { default as MaterialReferenceNode } from './accessors/MaterialReferenceNode';
+export { default as ModelNode } from './accessors/ModelNode';
+export { default as ModelViewProjectionNode } from './accessors/ModelViewProjectionNode';
+export { default as NormalNode, NormalNodeScope } from './accessors/NormalNode';
+export { default as Object3DNode, Object3DNodeScope as OObject3DNodeScope } from './accessors/Object3DNode';
+export { default as PointUVNode } from './accessors/PointUVNode';
+export { default as PositionNode, PositionNodeScope } from './accessors/PositionNode';
+export { default as ReferenceNode } from './accessors/ReferenceNode';
+export { default as ReflectVectorNode } from './accessors/ReflectVectorNode';
+export { default as SkinningNode } from './accessors/SkinningNode';
+export { default as TangentNode, TangentNodeScope } from './accessors/TangentNode';
+export { default as TextureNode } from './accessors/TextureNode';
+export { default as UVNode } from './accessors/UVNode';
+export { default as UserDataNode } from './accessors/UserDataNode';
 
 // display
-import BlendModeNode, { BlendMode } from './display/BlendModeNode';
-import ColorAdjustmentNode, { ColorAdjustmentMethod } from './display/ColorAdjustmentNode';
-import ColorSpaceNode, { ColorSpaceNodeMethod } from './display/ColorSpaceNode';
-import FrontFacingNode from './display/FrontFacingNode';
-import NormalMapNode from './display/NormalMapNode';
-import PosterizeNode from './display/PosterizeNode';
-import ToneMappingNode from './display/ToneMappingNode';
-import ViewportNode from './display/ViewportNode';
+export { default as BlendModeNode, BlendMode } from './display/BlendModeNode';
+export { default as ColorAdjustmentNode, ColorAdjustmentMethod } from './display/ColorAdjustmentNode';
+export { default as ColorSpaceNode, ColorSpaceNodeMethod } from './display/ColorSpaceNode';
+export { default as FrontFacingNode } from './display/FrontFacingNode';
+export { default as NormalMapNode } from './display/NormalMapNode';
+export { default as PosterizeNode } from './display/PosterizeNode';
+export { default as ToneMappingNode } from './display/ToneMappingNode';
+export { default as ViewportNode } from './display/ViewportNode';
 
-// math
-import MathNode, { MathNodeMethod1, MathNodeMethod2, MathNodeMethod3, MathNodeMethod } from './math/MathNode';
-import OperatorNode, { OperatorNodeOp } from './math/OperatorNode';
-import CondNode from './math/CondNode';
+// code
+export { default as ExpressionNode } from './code/ExpressionNode';
+export { default as CodeNode, CodeNodeInclude } from './code/CodeNode';
+export { default as FunctionCallNode } from './code/FunctionCallNode';
+export { default as FunctionNode, FunctionNodeArguments } from './code/FunctionNode';
 
-// lighting
-import PunctualLightNode from './lighting/PunctualLightNode';
-import LightsNode from './lighting/LightsNode';
-import LightingNode from './lighting/LightingNode';
-import LightingContextNode, { LightingModelNode } from './lighting/LightingContextNode';
-import HemisphereLightNode from './lighting/HemisphereLightNode';
-import EnvironmentNode from './lighting/EnvironmentNode';
-import AONode from './lighting/AONode';
-import AnalyticLightNode from './lighting/AnalyticLightNode';
+// fog
+export { default as FogNode } from './fog/FogNode';
+export { default as FogRangeNode } from './fog/FogRangeNode';
+export { default as FogExp2Node } from './fog/FogExp2Node';
 
-// utils
+// geometry
+export { default as RangeNode, RangeModeBound } from './geometry/RangeNode';
 
-import ArrayElementNode from './utils/ArrayElementNode';
-import ConvertNode from './utils/ConvertNode';
-import EquirectUVNode from './utils/EquirectUVNode';
-import JoinNode from './utils/JoinNode';
-import MatcapUVNode from './utils/MatcapUVNode';
-import MaxMipLevelNode from './utils/MaxMipLevelNode';
-import OscNode, { OscNodeMethod } from './utils/OscNode';
-import RemapNode from './utils/RemapNode';
-import RotateUVNode from './utils/RotateUVNode';
-import SpecularMIPLevelNode from './utils/SpecularMIPLevelNode';
-import SplitNode from './utils/SplitNode';
-import SpriteSheetUVNode from './utils/SpriteSheetUVNode';
-import TimerNode, { TimerNodeScope } from './utils/TimerNode';
-import TriplanarTexturesNode from './utils/TriplanarTexturesNode';
+// gpgpu
+export { default as ComputeNode } from './gpgpu/ComputeNode';
 
-// loaders
-import NodeLoader from './loaders/NodeLoader';
-import NodeObjectLoader from './loaders/NodeObjectLoader';
-import NodeMaterialLoader from './loaders/NodeMaterialLoader';
+// lighting
+export { default as PointLightNode } from './lighting/PointLightNode';
+export { default as SpotLightNode } from './lighting/SpotLightNode';
+export { default as LightsNode } from './lighting/LightsNode';
+export { default as LightingNode } from './lighting/LightingNode';
+export { default as LightingContextNode, LightingModelNode } from './lighting/LightingContextNode';
+export { default as HemisphereLightNode } from './lighting/HemisphereLightNode';
+export { default as EnvironmentNode } from './lighting/EnvironmentNode';
+export { default as AONode } from './lighting/AONode';
+export { default as AnalyticLightNode } from './lighting/AnalyticLightNode';
 
 // procedural
-import CheckerNode from './procedural/CheckerNode';
-// fog
-import FogNode from './fog/FogNode';
-import FogRangeNode from './fog/FogRangeNode';
-import FogExp2Node from './fog/FogExp2Node';
+export { default as CheckerNode } from './procedural/CheckerNode';
 
-// core
-export * from './core/constants';
+// loaders
+export { default as NodeLoader } from './loaders/NodeLoader';
+export { default as NodeObjectLoader } from './loaders/NodeObjectLoader';
+export { default as NodeMaterialLoader } from './loaders/NodeMaterialLoader';
 
 // materials
 export * from './materials/Materials';
 
-// shader node
-export * from './shadernode/ShaderNodeElements';
+// materialX
+export * from './materialx/MaterialXNodes';
 
-export {
-    // core
-    ArrayUniformNode,
-    AttributeNode,
-    BypassNode,
-    CacheNode,
-    CodeNode,
-    CodeNodeInclude,
-    ContextNode,
-    ConstNode,
-    ExpressionNode,
-    FunctionCallNode,
-    FunctionNode,
-    FunctionNodeArguments,
-    InstanceIndexNode,
-    Node,
-    NodeAttribute,
-    NodeBuilder,
-    NodeCache,
-    NodeCode,
-    NodeFrame,
-    NodeFunctionInput,
-    NodeKeywords,
-    NodeUniform,
-    NodeVar,
-    NodeVarying,
-    PropertyNode,
-    StackNode,
-    TempNode,
-    UniformNode,
-    VarNode,
-    VaryNode,
-    // geometry
-    RangeNode,
-    RangeModeBound,
-    // gpgpu
-    ComputeNode,
-    // accessors
-    BitangentNode,
-    BitangentNodeScope,
-    BufferNode,
-    CameraNode,
-    CameraNodeScope,
-    CubeTextureNode,
-    InstanceNode,
-    MaterialNode,
-    MaterialNodeScope,
-    MaterialReferenceNode,
-    ModelNode,
-    ModelViewProjectionNode,
-    NormalNode,
-    NormalNodeScope,
-    Object3DNode,
-    Object3DNodeScope as OObject3DNodeScope,
-    PointUVNode,
-    PositionNode,
-    PositionNodeScope,
-    ReferenceNode,
-    ReflectVectorNode,
-    SkinningNode,
-    TangentNode,
-    TangentNodeScope,
-    TextureNode,
-    UVNode,
-    UserDataNode,
-    // display
-    BlendModeNode,
-    BlendMode,
-    ColorAdjustmentNode,
-    ColorAdjustmentMethod,
-    ColorSpaceNode,
-    ColorSpaceNodeMethod,
-    FrontFacingNode,
-    NormalMapNode,
-    PosterizeNode,
-    ToneMappingNode,
-    ViewportNode,
-    // math
-    MathNode,
-    MathNodeMethod1,
-    MathNodeMethod2,
-    MathNodeMethod3,
-    MathNodeMethod,
-    OperatorNode,
-    OperatorNodeOp,
-    CondNode,
-    // lighting
-    PunctualLightNode,
-    LightsNode,
-    LightingNode,
-    LightingContextNode,
-    LightingModelNode,
-    HemisphereLightNode,
-    EnvironmentNode,
-    AONode,
-    AnalyticLightNode,
-    // utils
-    ArrayElementNode,
-    ConvertNode,
-    EquirectUVNode,
-    JoinNode,
-    MatcapUVNode,
-    MaxMipLevelNode,
-    OscNode,
-    OscNodeMethod,
-    RemapNode,
-    RotateUVNode,
-    SpecularMIPLevelNode,
-    SplitNode,
-    SpriteSheetUVNode,
-    TimerNode,
-    TimerNodeScope,
-    TriplanarTexturesNode,
-    // procedural
-    CheckerNode,
-    // fog
-    FogNode,
-    FogRangeNode,
-    FogExp2Node,
-    // loaders
-    NodeLoader,
-    NodeObjectLoader,
-    NodeMaterialLoader,
-};
+// functions
+export { default as BRDF_GGX } from './functions/BSDF/BRDF_GGX';
+export { default as BRDF_Lambert } from './functions/BSDF/BRDF_Lambert';
+export { default as D_GGX } from './functions/BSDF/D_GGX';
+export { default as DFGApprox } from './functions/BSDF/DFGApprox';
+export { default as F_Schlick } from './functions/BSDF/F_Schlick';
+export { default as V_GGX_SmithCorrelated } from './functions/BSDF/V_GGX_SmithCorrelated';
+
+export { default as getDistanceAttenuation } from './functions/light/getDistanceAttenuation';
+
+export { default as getGeometryRoughness } from './functions/material/getGeometryRoughness';
+export { default as getRoughness } from './functions/material/getRoughness';
+
+export { default as physicalLightingModel } from './functions/PhysicalLightingModel';

three/examples/jsm/nodes/{core → code}/CodeNode.d.ts

@@ -1,6 +1,5 @@
-import { NodeTypeOption } from './constants';
-import Node from './Node';
-import NodeBuilder from './NodeBuilder';
+import Node from '../core/Node';
+import NodeBuilder from '../core/NodeBuilder';
 
 export interface CodeNodeInclude {
     build(builder: NodeBuilder): void;

three/examples/jsm/nodes/{core → code}/ExpressionNode.d.ts

@@ -1,5 +1,5 @@
-import { NodeTypeOption } from './constants';
-import TempNode from './TempNode';
+import { NodeTypeOption } from '../core/constants';
+import TempNode from '../core/TempNode';
 
 export default class ExpressionNode extends TempNode {
     snipped: string; /* sic */

three/examples/jsm/nodes/{core → code}/FunctionCallNode.d.ts

@@ -1,6 +1,6 @@
 import FunctionNode from './FunctionNode';
-import TempNode from './TempNode';
-import Node from './Node';
+import TempNode from '../core/TempNode';
+import Node from '../core/Node';
 
 export default class FunctionCallNode<P extends Node[] | { [name: string]: Node }> extends TempNode {
     functionNode: FunctionNode<P>;

three/examples/jsm/nodes/{core → code}/FunctionNode.d.ts

@@ -1,9 +1,9 @@
 import CodeNode, { CodeNodeInclude } from './CodeNode';
 import FunctionCallNode from './FunctionCallNode';
-import NodeBuilder from './NodeBuilder';
-import NodeFunction from './NodeFunction';
-import NodeFunctionInput from './NodeFunctionInput';
-import Node from './Node';
+import NodeBuilder from '../core/NodeBuilder';
+import NodeFunction from '../core/NodeFunction';
+import NodeFunctionInput from '../core/NodeFunctionInput';
+import Node from '../core/Node';
 
 export type FunctionNodeArguments = Node[] | { [name: string]: Node };
 

three/examples/jsm/nodes/core/InputNode.d.ts

@@ -2,11 +2,15 @@ import { NodeTypeOption, NodeValueOption } from './constants';
 import Node from './Node';
 import NodeBuilder from './NodeBuilder';
 
+export type Precision = 'low' | 'medium' | 'high';
+
 export default abstract class InputNode extends Node {
     isInputNode: true;
     value: NodeValueOption;
+    precision: Precision | null;
 
     constructor(value: NodeValueOption, nodeType?: NodeTypeOption | null);
 
     getInputType(builder: NodeBuilder): string | null;
+    setPrecision(precision: Precision): this;
 }

three/examples/jsm/nodes/core/NodeBuilder.d.ts

@@ -64,12 +64,10 @@ export default abstract class NodeBuilder {
     shaderStage: NodeShaderStageOption | null;
     buildStage: BuildStageOption | null;
     stack: Node[];
-    get node(): Node;
 
-    addStack(node: Node): void;
-    removeStack(node: Node): void;
     setHashNode(node: Node, hash: string): void;
     addNode(node: Node): void;
+    get currentNode(): Node;
     getMethod(method: string): string;
     getNodeFromHash(hash: string): Node;
 

three/examples/jsm/nodes/core/NodeUtils.d.ts

@@ -1,7 +1,13 @@
 import { NodeValueOption } from './constants';
 import Node from './Node';
 
-export function getNodesKeys(object: Node): string[];
+export interface NodeChild {
+    property: string;
+    index?: number | string;
+    childNode: Node;
+}
+
+export function getCacheKey(object: Node): string;
+export function getNodeChildren(object: Node): Generator<NodeChild, void>;
 export function getValueType(value: NodeValueOption): string | null;
 export function getValueFromType(type: string, ...params: number[]): NodeValueOption | null;
-export function getCacheKey(object: Node): string;

three/examples/jsm/nodes/core/{VaryNode.d.ts → VaryingNode.d.ts}

@@ -1,6 +1,6 @@
 import Node from './Node';
 
-export default class VaryNode extends Node {
+export default class VaryingNode extends Node {
     node: Node;
     name: string | null;
 

three/examples/jsm/nodes/fog/FogNode.d.ts

@@ -6,5 +6,5 @@ export default class FogNode extends Node {
     factorNode: Node;
 
     constructor(colorNode: Node, factorNode: Node);
-    mix(outputNode: Node): Node;
+    mixAssign(outputNode: Node): Node;
 }