Merge pull request #17045 from Mugen87/dev36

JSM: More TS files for NodeMaterial.

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

+import { Camera } from '../../../../src/Three';
+
+import { NodeBuilder } from '../core/NodeBuilder';
+import { NodeFrame } from '../core/NodeFrame';
+import { TempNode } from '../core/TempNode';
+import { FunctionNode } from '../core/FunctionNode';
+import { FloatNode } from '../inputs/FloatNode';
+
+export class CameraNode extends TempNode {
+  constructor(scope?: string, camera?: Camera);
+
+  scope: string;
+  near: FloatNode | undefined;
+  far: FloatNode | undefined;
+  camera: Camera | undefined;
+  updateFrame: boolean | undefined;
+  nodeType: string;
+
+  setCamera(camera: Camera): void;
+  setScope(scope: string): void;
+  generate(builder: NodeBuilder, output: string): string;
+  onUpdateFrame(frame: NodeFrame): void;
+  copy(source: CameraNode): this;
+
+  static Nodes: {
+    depthColor: FunctionNode;
+  };
+  static POSITION: string;
+  static DEPTH: string;
+  static TO_VERTEX: string;
+}

examples/jsm/nodes/accessors/ColorsNode.d.ts

+import { NodeBuilder } from '../core/NodeBuilder';
+import { TempNode } from '../core/TempNode';
+
+export class ColorsNode extends TempNode {
+  constructor(index?: number);
+
+  index: number;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: ColorsNode): this;
+}

examples/jsm/nodes/accessors/LightNode.d.ts

+import { NodeBuilder } from '../core/NodeBuilder';
+import { TempNode } from '../core/TempNode';
+
+export class LightNode extends TempNode {
+  constructor(scope?: string);
+
+  scope: string;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: LightNode): this;
+
+  static TOTAL: string;
+}

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

+import { NodeBuilder } from '../core/NodeBuilder';
+import { TempNode } from '../core/TempNode';
+
+export class NormalNode extends TempNode {
+  constructor(scope?: string);
+
+  scope: string;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: NormalNode): this;
+
+  static LOCAL: string;
+  static WORLD: string;
+  static VIEW: string;
+}

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

+import { NodeBuilder } from '../core/NodeBuilder';
+import { TempNode } from '../core/TempNode';
+
+export class PositionNode extends TempNode {
+  constructor(scope?: string);
+
+  scope: string;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: PositionNode): this;
+
+  static LOCAL: string;
+  static WORLD: string;
+  static VIEW: string;
+  static PROJECTION: string;
+}

examples/jsm/nodes/accessors/ReflectNode.d.ts

+import { Vector2 } from '../../../../src/Three';
+
+import { NodeBuilder } from '../core/NodeBuilder';
+import { TempNode } from '../core/TempNode';
+
+export class ReflectNode extends TempNode {
+  constructor(scope?: string);
+
+  scope: string;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+
+  static CUBE: string;
+  static SPHERE: string;
+  static VECTOR: string;
+}
\ No newline at end of file

examples/jsm/nodes/accessors/ResolutionNode.d.ts

+import { Vector2 } from '../../../../src/Three';
+
+import { NodeBuilder } from '../core/NodeBuilder';
+import { NodeFrame } from '../core/NodeFrame';
+import { Vector2Node } from '../inputs/Vector2Node';
+
+export class ResolutionNode extends Vector2Node {
+  constructor();
+
+  size: Vector2;
+  nodeType: string;
+
+  updateFrame(frame: NodeFrame): void;
+  copy(source: ResolutionNode): this;
+}

examples/jsm/nodes/accessors/ScreenUVNode.d.ts

+import { NodeBuilder } from '../core/NodeBuilder';
+import { TempNode } from '../core/TempNode';
+import { ResolutionNode } from './ResolutionNode';
+
+export class ScreenUVNode extends TempNode {
+  constructor(resolution?: ResolutionNode);
+
+  resolution: ResolutionNode;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: ScreenUVNode): this;
+}

examples/jsm/nodes/accessors/UVNode.d.ts

+import { NodeBuilder } from '../core/NodeBuilder';
+import { TempNode } from '../core/TempNode';
+
+export class UVNode extends TempNode {
+  constructor(index?: number);
+
+  index: number;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: UVNode): this;
+}

examples/jsm/nodes/bsdfs/BlinnExponentToRoughnessNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { BlinnShininessExponentNode } from './BlinnShininessExponentNode';
+
+export class BlinnExponentToRoughnessNode extends TempNode {
+  constructor(blinnExponent?: BlinnShininessExponentNode);
+
+  blinnExponent: BlinnShininessExponentNode;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: BlinnExponentToRoughnessNode): this;
+}

examples/jsm/nodes/bsdfs/BlinnShininessExponentNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class BlinnShininessExponentNode extends TempNode {
+  constructor();
+
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+}

examples/jsm/nodes/bsdfs/RoughnessToBlinnExponentNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { MaxMIPLevelNode } from '../utils/MaxMIPLevelNode';
+import { BlinnShininessExponentNode } from './BlinnShininessExponentNode';
+import { FunctionNode } from '../core/FunctionNode';
+
+export class RoughnessToBlinnExponentNode extends TempNode {
+  constructor(texture: Node);
+
+  texture: Node;
+  maxMIPLevel: MaxMIPLevelNode;
+  blinnShininessExponent: BlinnShininessExponentNode;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: RoughnessToBlinnExponentNode): this;
+
+  static Nodes: {
+    getSpecularMIPLevel: FunctionNode;
+  };
+}

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

@@ -3,7 +3,7 @@ import {
   Texture,
   TextureEncoding,
   WebGLRenderer
-} from "../../../../build/three.module.js";
+} from '../../../../src/Three';
 
 import { Node } from './Node';
 import { NodeUniform } from './NodeUniform';
@@ -80,7 +80,7 @@ export class NodeBuilder {
 
   analyzing: boolean;
 
-  build(vertex: Node, fragment: node): this;
+  build(vertex: Node, fragment: Node): this;
   buildShader(shader: string, node: Node): void;
   setMaterial(material: Material, renderer: WebGLRenderer): this;
   addFlow(slot: string, cache?: string, context?: object): this;
@@ -141,6 +141,6 @@ export class NodeBuilder {
   isShader(shader: string): boolean;
   setShader(shader: string): this;
   mergeDefines(defines: object): object;
-  mergeUniform(uniforms: object): uniforms;
+  mergeUniform(uniforms: object): object;
   getTextureEncodingFromMap(map: Texture, gammaOverrideLinear?: boolean): TextureEncoding;
 }

examples/jsm/nodes/core/NodeFrame.d.ts

 import {
-    Texture,
-	WebGLRenderer
-} from "../../../../build/three.module.js";
+  Texture,
+  WebGLRenderer
+} from '../../../../src/Three';
 
 import { Node } from './Node';
 
 export class NodeFrame {
-    constructor(time: number);
-    time: number;
-    id: number;
-    delta: number | undefined;
-    renderer: WebGLRenderer | undefined;
-    renderTexture: Texture | undefined;
-
-    update(delta: number): this;
-    setRenderer(renderer: WebGLRenderer): this;
-    setRenderTexture(renderTexture: Texture): this;
-    updateNode(node: Node): this;
+  constructor(time: number);
+  time: number;
+  id: number;
+  delta: number | undefined;
+  renderer: WebGLRenderer | undefined;
+  renderTexture: Texture | undefined;
+  
+  update(delta: number): this;
+  setRenderer(renderer: WebGLRenderer): this;
+  setRenderTexture(renderTexture: Texture): this;
+  updateNode(node: Node): this;
 }

examples/jsm/nodes/effects/BlurNode.d.ts

+import { Vector2 } from '../../../../src/Three';
+
+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { NodeFrame } from '../core/NodeFrame';
+import { UVNode } from '../accessors/UVNode';
+import { Vector2Node } from '../inputs/Vector2Node';
+import { FloatNode } from '../inputs/FloatNode';
+import { FunctionNode } from '../core/FunctionNode';
+import { TextureNode } from '../inputs/TextureNode';
+
+export class BlurNode extends TempNode {
+  constructor(value: TextureNode, uv?: UVNode, radius?: number, size?: Vector2);
+
+  value: TextureNode;
+  uv: UVNode;
+  radius: Vector2Node;
+  size: Vector2;
+  blurX: boolean;
+  blurY: boolean;
+  horizontal: FloatNode;
+  vertical: FloatNode;
+  nodeType: string;
+
+  updateFrame(frame: NodeFrame): void;
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: BlurNode): this;
+
+  static Nodes: {
+    blurX: FunctionNode;
+    blurY: FunctionNode;
+  }
+}

examples/jsm/nodes/effects/ColorAdjustmentNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { FloatNode } from '../inputs/FloatNode';
+import { FunctionNode } from '../core/FunctionNode';
+import { Node } from '../core/Node';
+
+export class ColorAdjustmentNode extends TempNode {
+  constructor(rgb: Node, adjustment?: FloatNode, method?: string);
+
+  rgb: Node;
+  adjustment: FloatNode | undefined;
+  method: string;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: ColorAdjustmentNode): this;
+
+  static Nodes: {
+    hue: FunctionNode;
+    saturation: FunctionNode;
+    vibrance: FunctionNode;
+  }
+
+  static SATURATION: string;
+  static HUE: string;
+  static VIBRANCE: string;
+  static BRIGHTNESS: string;
+  static CONTRAST: string;
+
+}

examples/jsm/nodes/effects/LuminanceNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { FunctionNode } from '../core/FunctionNode';
+import { ConstNode } from '../core/ConstNode';
+import { Node } from '../core/Node';
+
+export class LuminanceNode extends TempNode {
+  constructor(rgb: Node);
+
+  rgb: Node;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: LuminanceNode): this;
+
+  static Nodes: {
+    LUMA: ConstNode;
+    luminance: FunctionNode;
+  }
+
+}

examples/jsm/nodes/inputs/BoolNode.d.ts

+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class BoolNode extends InputNode {
+  constructor(value?: boolean);
+
+  value: boolean;
+  nodeType: string;
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: BoolNode): this;
+}

examples/jsm/nodes/inputs/ColorNode.d.ts

+import { Color } from '../../../../src/Three';
+
+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class ColorNode extends InputNode {
+  constructor(color: Color | number | string, g?: number, b?: number);
+
+  value: Color;
+  nodeType: string;
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: ColorNode): this;
+}

examples/jsm/nodes/inputs/CubeTextureNode.d.ts

+import { CubeTexture } from '../../../../src/Three';
+
+import { InputNode } from '../core/InputNode';
+import { Node } from '../core/Node';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class CubeTextureNode extends InputNode {
+  constructor(value: CubeTexture, uv?: Node, bias?: Node);
+
+  value: CubeTexture;
+  uv: Node | undefined;
+  bias: Node | undefined;
+  nodeType: string;
+
+  getTexture(builder: NodeBuilder, output: string): string;
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: CubeTextureNode): this;
+}

examples/jsm/nodes/inputs/FloatNode.d.ts

+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class FloatNode extends InputNode {
+  constructor(value?: number);
+
+  value: number;
+  nodeType: string;
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: FloatNode): this;
+}

examples/jsm/nodes/inputs/IntNode.d.ts

+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class IntNode extends InputNode {
+  constructor(value?: number);
+
+  value: number;
+  nodeType: string;
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: IntNode): this;
+}

examples/jsm/nodes/inputs/Matrix3Node.d.ts

+import { Matrix3 } from '../../../../src/Three';
+
+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class Matrix3Node extends InputNode {
+  constructor(matrix?: Matrix3);
+
+  value: Matrix3;
+  nodeType: string;
+  elements: number[];
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: Matrix3Node): this;
+}

examples/jsm/nodes/inputs/Matrix4Node.d.ts

+import { Matrix4 } from '../../../../src/Three';
+
+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class Matrix4Node extends InputNode {
+  constructor(matrix?: Matrix4);
+
+  value: Matrix4;
+  nodeType: string;
+  elements: number[];
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: Matrix4Node): this;
+}

examples/jsm/nodes/inputs/PropertyNode.d.ts

+import { InputNode } from '../core/InputNode';
+
+export class PropertyNode extends InputNode {
+  constructor(object: object, property: string, type: string);
+
+  object: object;
+  property: string;
+  nodeType: string;
+  value: any;
+}

examples/jsm/nodes/inputs/RTTNode.d.ts

+import { 
+  Mesh,
+  OrthographicCamera,
+  SceneUtils,
+  WebGLRenderTarget,
+  WebGLRenderTargetOptions
+} from '../../../../src/Three';
+
+import { NodeBuilder } from '../core/NodeBuilder';
+import { NodeFrame } from '../core/NodeFrame';
+import { TextureNode } from './TextureNode';
+
+export interface RTTNodeOptions extends WebGLRenderTargetOptions {
+  clear?: boolean;
+}
+
+export class RTTNode extends TextureNode {
+  constructor(width: number, height: number, input: TextureNode, options?: RTTNodeOptions);
+
+  input: TextureNode;
+  clear: boolean;
+  renderTarget: WebGLRenderTarget;
+  material: object; // NodeMaterial
+  camera: OrthographicCamera;
+  scene: Scene;
+  quad: Mesh;
+  render: boolean;
+
+  build(builder: NodeBuilder, output: string, uuid?: string): string;
+  updateFramesaveTo(frame: NodeFrame): void;
+  updateFrame(frame: NodeFrame): void;
+  copy(source: RTTNode): this;
+}

examples/jsm/nodes/inputs/ReflectorNode.d.ts

+import { NodeBuilder } from '../core/NodeBuilder';
+import { TempNode } from '../core/TempNode';
+import { Matrix4Node } from './Matrix4Node';
+import { OperatorNode } from '../math/OperatorNode';
+import { ReflectorRTT } from '../../objects/ReflectorRTT';
+import { TextureNode } from './TextureNode';
+import { PositionNode } from '../accessors/PositionNode';
+
+export class ReflectorNode extends TempNode {
+  constructor(mirror?: ReflectorRTT);
+
+  mirror: ReflectorRTT;
+  textureMatrix: Matrix4Node;
+  localPosition: PositionNode;
+  uv: OperatorNode;
+  uvResult: OperatorNode;
+  texture: TextureNode;
+
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: ReflectorNode): this;
+}

examples/jsm/nodes/inputs/ScreenNode.d.ts

+import { NodeBuilder } from '../core/NodeBuilder';
+import { TextureNode } from './TextureNode';
+import { UVNode } from '../accessors/UVNode';
+
+export class ScreenNode extends TextureNode {
+  constructor(uv?: UVNode);
+
+  nodeType: string;
+
+  getTexture(builder: NodeBuilder, output: string): string;
+}

examples/jsm/nodes/inputs/TextureNode.d.ts

+import {
+  Matrix4,
+  Texture 
+} from '../../../../src/Three';
+
+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { Node } from '../core/Node';
+import { UVNode } from '../accessors/UVNode';
+
+export class TextureNode extends InputNode {
+  constructor(value: Texture, uv?: UVNode, bias?: Node, project?: boolean);
+
+  value: Matrix4;
+  uv: UVNode;
+  bias: Matrix4;
+  project: boolean;
+  nodeType: string;
+
+  getTexture(builder: NodeBuilder, output: string): string;
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: TextureNode): this;
+}

examples/jsm/nodes/inputs/Vector2Node.d.ts

+import { Vector2 } from '../../../../src/Three';
+
+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class Vector2Node extends InputNode {
+  constructor(x: Vector2 | number, y?: number);
+
+  value: Vector2;
+  nodeType: string;
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: Vector2Node): this;
+}

examples/jsm/nodes/inputs/Vector3Node.d.ts

+import { Vector3 } from '../../../../src/Three';
+
+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class Vector3Node extends InputNode {
+  constructor(x: Vector3 | number, y?: number, z?: number);
+
+  value: Vector3;
+  nodeType: string;
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: Vector3Node): this;
+}

examples/jsm/nodes/inputs/Vector4Node.d.ts

+import { Vector4 } from '../../../../src/Three';
+
+import { InputNode } from '../core/InputNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class Vector4Node extends InputNode {
+  constructor(x: Vector4 | number, y?: number, z?: number, w?: number);
+
+  value: Vector4;
+  nodeType: string;
+
+  generateReadonly(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+  copy(source: Vector4Node): this;
+}

examples/jsm/nodes/materials/MeshStandardNodeMaterial.d.ts

+import { NodeMaterial } from './NodeMaterial';
+
+export class MeshStandardNodeMaterial extends NodeMaterial {
+  constructor();
+}
\ No newline at end of file

examples/jsm/nodes/materials/NodeMaterial.d.ts

+import {
+  ShaderMaterial,
+  WebGLRenderer
+} from '../../../../src/Three';
+
+import { NodeBuilder } from '../core/NodeBuilder';
+import { NodeFrame } from '../core/NodeFrame';
+import { StandardNode } from './nodes/StandardNode';
+import { PropertyNode } from '../inputs/PropertyNode';
+import { MeshStandardNode } from './nodes/MeshStandardNode';
+import { RawNode } from './nodes/RawNode';
+
+export interface NodeMaterialBuildParams {
+  builder?: NodeBuilder;
+  renderer?: WebGLRenderer;
+}
+
+export class NodeMaterial extends ShaderMaterial {
+  constructor(vertex: MeshStandardNode, fragment: MeshStandardNode);
+
+  vertex: MeshStandardNode | RawNode;
+  fragment: MeshStandardNode | RawNode;
+
+  updaters: object[];
+
+  isNodeMaterial: boolean;
+  properties: object;
+
+  updateFrame(frame: NodeFrame): void;
+  build(params?: NodeMaterialBuildParams): this;
+  copy(source: NodeMaterial): this;
+}

examples/jsm/nodes/materials/PhongNodeMaterial.d.ts

+import { NodeMaterial } from './NodeMaterial';
+
+export class PhongNodeMaterial extends NodeMaterial {
+  constructor();
+}
\ No newline at end of file

examples/jsm/nodes/materials/SpriteNodeMaterial.d.ts

+import { NodeMaterial } from './NodeMaterial';
+
+export class SpriteNodeMaterial extends NodeMaterial {
+  constructor();
+}

examples/jsm/nodes/materials/StandardNodeMaterial.d.ts

+import { NodeMaterial } from './NodeMaterial';
+
+export class StandardNodeMaterial extends NodeMaterial {
+  constructor();
+}

examples/jsm/nodes/materials/nodes/MeshStandardNode.d.ts

+import {
+  Color,
+  Vector2
+} from '../../../../../src/Three';
+
+import { NodeBuilder } from '../../core/NodeBuilder';
+import { StandardNode } from './StandardNode';
+import { PropertyNode } from "../../inputs/PropertyNode";
+
+export class MeshStandardNode extends StandardNode {
+  constructor(value: Node);
+
+  properties: {
+    color: Color;
+    roughness: number;
+    metalness: number;
+    normalScale: Vector2;
+  }
+
+  inputs: {
+    color: PropertyNode
+    roughness: PropertyNode
+    metalness: PropertyNode
+    normalScale: PropertyNode
+  }
+
+  build(builder: NodeBuilder): string;
+}

examples/jsm/nodes/materials/nodes/PhongNode.d.ts

+import { NodeBuilder } from '../../core/NodeBuilder';
+import { Node } from '../../core/Node';
+import { ColorNode } from '../../inputs/ColorNode';
+import { FloatNode } from '../../inputs/FloatNode';
+
+export class PhongNode extends Node {
+  constructor(value: Node);
+
+  color: ColorNode;
+  specular: ColorNode;
+  shininess: FloatNode;
+  nodeType: string;
+
+  build(builder: NodeBuilder): string;
+  copy(source: PhongNode): this;
+}

examples/jsm/nodes/materials/nodes/RawNode.d.ts

+import { NodeBuilder } from '../../core/NodeBuilder';
+import { Node } from '../../core/Node';
+
+export class RawNode extends Node {
+  constructor(value: Node);
+
+  value: Node;
+  nodeType: string;
+
+  generate(builder: NodeBuilder): string;
+  copy(source: RawNode): this;
+}
\ No newline at end of file

examples/jsm/nodes/materials/nodes/SpriteNode.d.ts

+import { NodeBuilder } from '../../core/NodeBuilder';
+import { Node } from '../../core/Node';
+import { ColorNode } from '../../inputs/ColorNode';
+
+export class SpriteNode extends Node {
+  constructor(value: Node);
+
+  color: ColorNode;
+  spherical: true;
+  nodeType: string;
+
+  build(builder: NodeBuilder): string;
+  copy(source: SpriteNode): this;
+}

examples/jsm/nodes/materials/nodes/StandardNode.d.ts

+import { NodeBuilder } from '../../core/NodeBuilder';
+import { Node } from '../../core/Node';
+import { ColorNode } from '../../inputs/ColorNode';
+import { FloatNode } from '../../inputs/FloatNode';
+
+export class StandardNode extends Node {
+  constructor();
+
+  color: ColorNode;
+  roughness: FloatNode;
+  metalness: FloatNode;
+  nodeType: string;
+
+  build(builder: NodeBuilder): string;
+  copy(source: StandardNode): this;
+
+}

examples/jsm/nodes/math/CondNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { Node } from '../core/Node';
+
+export class CondNode extends TempNode {
+  constructor(a: Node, b: Node, op: string, ifNode: Node, elseNode: Node);
+
+  a: Node;
+  b: Node;
+  op: string;
+  ifNode: Node;
+  elseNode: Node;
+  nodeType: string;
+
+  getCondType(builder: NodeBuilder): string;
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: CondNode): this;
+
+  static EQUAL: string;
+  static NOT_EQUAL: string;
+  static GREATER: string;
+  static GREATER_EQUAL: string;
+  static LESS: string;
+  static LESS_EQUAL: string;
+}

examples/jsm/nodes/math/MathNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { Node } from '../core/Node';
+
+export class MathNode extends TempNode {
+  constructor(a: Node, bOrMethod: Node | string, cOrMethod?: Node | string, method?: string);
+
+  a: Node;
+  b: Node | string | undefined;
+  c: Node | string | undefined;
+  method: string;
+  nodeType: string;
+
+  getNumInputs(builder: NodeBuilder): number;
+  getInputType(builder: NodeBuilder): string;
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: MathNode): this;
+
+  static RAD: string;
+  static DEG: string;
+  static EXP: string;
+  static EXP2: string;
+  static LOG: string;
+  static LOG2: string;
+  static SQRT: string;
+  static INV_SQRT: string;
+  static FLOOR: string;
+  static CEIL: string;
+  static NORMALIZE: string;
+  static SATURATE: string;
+  static SIN: string;
+  static COS: string;
+  static TAN: string;
+  static ASIN: string;
+  static ACOS: string;
+  static ARCTAN: string;
+  static ABS: string;
+  static SIGN: string;
+  static LENGTH: string;
+  static NEGATE: string;
+  static INVERT: string;
+
+  static MIN: string;
+  static MAX: string;
+  static MOD: string;
+  static STEP: string;
+  static REFLECT: string;
+  static DISTANCE: string;
+  static DOT: string;
+  static CROSS: string;
+  static POW: string;
+
+  static MIX: string;
+  static CLAMP: string;
+  static REFRACT: string;
+  static SMOOTHSTEP: string;
+  static FACEFORWARD: string;
+}

examples/jsm/nodes/math/OperatorNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { Node } from '../core/Node';
+
+export class OperatorNode extends TempNode {
+  constructor(a: Node, b: Node, op: string);
+
+  a: Node;
+  b: Node;
+  op: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: OperatorNode): this;
+
+  static ADD: string;
+  static SUB: string;
+  static MUL: string;
+  static DIV: string;
+}

examples/jsm/nodes/misc/BumpMapNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { FloatNode } from '../inputs/FloatNode';
+import { FunctionNode } from '../core/FunctionNode';
+import { TextureNode } from '../inputs/TextureNode';
+
+export class BumpMapNode extends TempNode {
+  constructor(value: TextureNode, scale?: FloatNode);
+
+  value: TextureNode;
+  scale: FloatNode;
+  toNormalMap: boolean;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: BumpMapNode): this;
+
+  static Nodes: {
+    dHdxy_fwd: FunctionNode;
+    perturbNormalArb: FunctionNode;
+    bumpToNormal: FunctionNode;
+  }
+}

examples/jsm/nodes/misc/NormalMapNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { FunctionNode } from '../core/FunctionNode';
+import { TextureNode } from '../inputs/TextureNode';
+import { Vector2Node } from '../inputs/Vector2Node';
+
+export class NormalMapNode extends TempNode {
+  constructor(value: TextureNode, scale?: Vector2Node);
+
+  value: TextureNode;
+  scale: Vector2Node;
+  toNormalMap: boolean;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: NormalMapNode): this;
+
+  static Nodes: {
+    perturbNormal2Arb: FunctionNode;
+  }
+}

examples/jsm/nodes/misc/TextureCubeNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { TextureNode } from '../inputs/TextureNode';
+import { FloatNode } from '../inputs/FloatNode';
+import { TextureCubeUVNode } from './TextureCubeUVNode';
+
+export class TextureCubeNode extends TempNode {
+  constructor(value: TextureNode, textureSize?: FloatNode);
+
+  value: TextureNode;
+  textureSize: FloatNode;
+  radianceCache: {
+      uv: TextureCubeUVNode
+  };
+  irradianceCache: {
+      uv: TextureCubeUVNode
+  };
+  nodeType: string;
+
+  generateTextureCubeUV(builder: NodeBuilder, output: string): string;
+  generate(builder: NodeBuilder, output: string): string;
+
+}

examples/jsm/nodes/misc/TextureCubeUVNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { FloatNode } from '../inputs/FloatNode';
+import { StructNode } from '../core/StructNode';
+import { FunctionNode } from '../core/FunctionNode';
+import { BlinnExponentToRoughnessNode } from '../bsdfs/BlinnExponentToRoughnessNode';
+import { Node } from '../core/Node';
+
+export class TextureCubeUVNode extends TempNode {
+  constructor(uv: Node, textureSize: FloatNode, blinnExponentToRoughness: BlinnExponentToRoughnessNode);
+
+  uv: Node;
+  textureSize: FloatNode;
+  blinnExponentToRoughness: BlinnExponentToRoughnessNode;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+
+  static Nodes: {
+    TextureCubeUVData: StructNode;
+    textureCubeUV: FunctionNode;
+  }
+
+}

examples/jsm/nodes/postprocessing/NodePass.d.ts

+import { NodeMaterial } from './NodeMaterial';
+import { ShaderPass } from '../../postprocessing/ShaderPass';
+import { ScreenNode } from '../inputs/ScreenNode';
+
+export class NodePass extends ShaderPass {
+  constructor();
+
+  name: string;
+  uuid: string;
+  userData: object;
+  input: ScreenNode;
+  needsUpdate: boolean;
+
+  copy(source: NodePass): this;
+  toJSON(meta?: object | string): object;
+}
\ No newline at end of file

examples/jsm/nodes/postprocessing/NodePostProcessing.d.ts

+import {
+  Camera,
+  Mesh,
+  OrthographicCamera,
+  Scene,
+  WebGLRenderer, 
+  WebGLRenderTarget, 
+} from '../../../../src/Three';
+
+import { ScreenNode } from '../inputs/ScreenNode';
+import { NodeMaterial } from '../materials/NodeMaterial';
+import { NodeFrame } from '../core/NodeFrame';
+
+export class NodePostProcessing {
+  constructor(renderer: WebGLRenderer, renderTarget?: WebGLRenderTarget);
+
+  renderer: WebGLRenderer;
+  renderTarget: WebGLRenderTarget;
+
+  output: ScreenNode;
+  material: NodeMaterial
+
+  camera: OrthographicCamera;
+  scene: Scene;
+
+  quad: Mesh;
+  needsUpdate: boolean;
+
+  render(scene: Scene, camera: Camera, frame: NodeFrame): void;
+  setSize(width: number, height: number): void;
+  copy(source: NodePostProcessing): this;
+  toJSON(meta?: object | string): object;
+}
\ No newline at end of file

examples/jsm/nodes/procedural/CheckerNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { FunctionNode } from '../core/FunctionNode';
+import { UVNode } from '../accessors/UVNode';
+import { UVTransformNode } from '../utils/UVTransformNode';
+
+export class CheckerNode extends TempNode {
+  constructor(uv?: UVNode | UVTransformNode);
+
+  uv: UVNode | UVTransformNode;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: CheckerNode): this;
+
+  static Nodes: {
+    checker: FunctionNode;
+  };
+}

examples/jsm/nodes/procedural/NoiseNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { FunctionNode } from '../core/FunctionNode';
+import { UVNode } from '../accessors/UVNode';
+import { UVTransformNode } from '../utils/UVTransformNode';
+
+export class NoiseNode extends TempNode {
+  constructor(uv?: UVNode | UVTransformNode);
+
+  uv: UVNode | UVTransformNode;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: NoiseNode): this;
+
+  static Nodes: {
+    snoise: FunctionNode;
+  };
+}

examples/jsm/nodes/utils/BypassNode.d.ts

+import { Node } from '../core/Node';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class BypassNode extends Node {
+  constructor(code: Node, value?: Node);
+
+  code: Node;
+  value: Node | undefined;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: BypassNode): this;
+}

examples/jsm/nodes/utils/ColorSpaceNode.d.ts

+import { Node } from '../core/Node';
+import { TempNode } from '../core/TempNode';
+import { FunctionNode } from '../core/FunctionNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class ColorSpaceNode extends TempNode {
+  constructor(input: Node, method?: string);
+
+  input: Node;
+  method: string | undefined;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  fromEncoding(encoding: number);
+  fromDecoding(encoding: number);
+  copy(source: ColorSpaceNode): this;
+
+  static Nodes: {
+    LinearToLinear: FunctionNode;
+    GammaToLinear: FunctionNode;
+    LinearToGamma: FunctionNode;
+    sRGBToLinear: FunctionNode;
+    LinearTosRGB: FunctionNode;
+    RGBEToLinear: FunctionNode;
+    LinearToRGBE: FunctionNode;
+    RGBMToLinear: FunctionNode;
+    LinearToRGBM: FunctionNode;
+    RGBDToLinear: FunctionNode;
+    LinearToRGBD: FunctionNode;
+    cLogLuvM: FunctionNode;
+    LinearToLogLuv: FunctionNode;
+    cLogLuvInverseM: FunctionNode;
+    LogLuvToLinear: FunctionNode;
+  };
+
+  static LINEAR_TO_LINEAR: string;
+
+  static GAMMA_TO_LINEAR: string;
+  static LINEAR_TO_GAMMA: string;
+
+  static SRGB_TO_LINEAR: string;
+  static LINEAR_TO_SRGB: string;
+
+  static RGBE_TO_LINEAR: string;
+  static LINEAR_TO_RGBE: string;
+
+  static RGBM_TO_LINEAR: string;
+  static LINEAR_TO_RGBM: string;
+
+  static RGBD_TO_LINEAR: string;
+  static LINEAR_TO_RGBD: string;
+
+  static LINEAR_TO_LOG_LUV: string;
+  static LOG_LUV_TO_LINEAR: string;
+
+  static getEncodingComponents(encoding: number): any[];
+}

examples/jsm/nodes/utils/JoinNode.d.ts

+import { TempNode } from '../core/TempNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class JoinNode extends TempNode {
+  constructor(x: Node, y: Node, z?: Node, w?: Node);
+
+  x: Node;
+  y: Node;
+  z: Node | undefined;
+  w: Node | undefined;
+  nodeType: string;
+
+  getNumElements(): number;
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: JoinNode): this;
+}

examples/jsm/nodes/utils/MaxMIPLevelNode.d.ts

+import { FloatNode } from '../inputs/FloatNode';
+import { Node } from '../core/Node';
+
+export class MaxMIPLevelNode extends FloatNode {
+  constructor(texture: Node);
+
+  texture: Node;
+  maxMIPLevel: number;
+  nodeType: string;
+  value: number;
+}

examples/jsm/nodes/utils/SwitchNode.d.ts

+import { Node } from '../core/Node';
+import { NodeBuilder } from '../core/NodeBuilder';
+
+export class SwitchNode extends Node {
+  constructor(node: Node, components?: string);
+
+  node: Node;
+  components: string;
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: SwitchNode): this;
+}

examples/jsm/nodes/utils/TimerNode.d.ts

+import { NodeFrame } from '../core/NodeFrame';
+import { FloatNode } from '../inputs/FloatNode';
+
+export class TimerNode extends FloatNode {
+  constructor(scale?: number, scope?: string, timeScale?: boolean);
+
+  scale: number;
+  scope: string;
+  timeScale: boolean;
+  nodeType: string;
+
+  getUnique(): boolean;
+  updateFrame(frame: NodeFrame): void;
+  copy(source: TimerNode): this;
+
+  static GLOBAL: string;
+  static LOCAL: string;
+  static DELTA: string;
+}

examples/jsm/nodes/utils/UVTransformNode.d.ts

+import { ExpressionNode } from '../core/ExpressionNode';
+import { NodeBuilder } from '../core/NodeBuilder';
+import { Matrix3Node } from '../inputs/Matrix3Node';
+import { UVNode } from '../accessors/UVNode';
+  
+export class UVTransformNode extends ExpressionNode {
+  constructor(uv?: UVNode, position?: Matrix3Node);
+
+  uv: UVNode;
+  position: Matrix3Node;
+
+  nodeType: string;
+
+  generate(builder: NodeBuilder, output: string): string;
+  setUvTransform(tx: number, ty: number, sx: number, sy: number, rotation: number, cx?: number, cy?: number): void;
+  copy(source: UVTransformNode): this;
+
+}
+  
\ No newline at end of file

examples/jsm/nodes/utils/VelocityNode.d.ts

+import { 
+  Object3D,
+  Vector3
+} from '../../../../src/Three';
+
+import { NodeFrame } from '../core/NodeFrame';
+import { Vector3Node } from '../inputs/Vector3Node';
+
+export interface VelocityNodeParams {
+  damping: number;
+  spring: number;
+  type: string;
+}
+
+export class VelocityNode extends Vector3Node {
+  constructor(target: Object3D, params?: VelocityNodeParams);
+
+  velocity: Vector3;
+  moment: Vector3 | undefined;
+  speed: Vector3 | undefined;
+  springVelocity: Vector3 | undefined;
+  lastVelocity: Vector3 | undefined;
+
+  nodeType: string;
+
+  setParams(params: VelocityNodeParams): void;
+  setTarget(target: Object3D): void;
+  updateFrameVelocity(frame: NodeFrame): void;
+  updateFrame(frame: NodeFrame): void;
+  copy(source: VelocityNode): this;
+
+}