Merge pull request #17039 from Mugen87/dev36

JSM: Added TS files for NodeMaterial core classes.

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

@@ -0,0 +1,14 @@
+import { TempNode } from './TempNode';
+import { NodeBuilder } from './NodeBuilder';
+
+export class AttributeNode extends TempNode {
+  constructor(name: string, type?: string);
+
+  name: string;
+  nodeType: string;
+
+  getAttributeType(builder: NodeBuilder): string;
+  getType(builder: NodeBuilder): string;
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: AttributeNode): this;
+}

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

@@ -0,0 +1,23 @@
+import { TempNode } from './TempNode';
+import { NodeBuilder } from './NodeBuilder';
+
+export class ConstNode extends TempNode {
+  constructor(src: string, useDefine?: boolean);
+
+  src: string;
+  useDefine: boolean;
+  nodeType: string;
+
+  getType(builder: NodeBuilder): string;
+  parse(src: string, useDefine?: boolean): void;
+  build(builder: NodeBuilder, output: string): string;
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: ConstNode): this;
+
+  static PI: string;
+  static PI2: string;
+  static RECIPROCAL_PI: string;
+  static RECIPROCAL_PI2: string;
+  static LOG2: string;
+  static EPSILON: string;
+}

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

@@ -0,0 +1,5 @@
+import { FunctionNode } from './FunctionNode';
+
+export class ExpressionNode extends FunctionNode {
+  constructor(src: string, includes?: object[], extensions?: object, keywords?: object, type?: string);
+}

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

@@ -0,0 +1,19 @@
+import { Node } from './Node';
+import { FunctionNode } from './FunctionNode';
+import { TempNode } from './TempNode';
+import { NodeBuilder } from './NodeBuilder';
+
+export class FunctionCallNode extends TempNode {
+  constructor(func: FunctionNode, inputs?: Node[]);
+
+  nodeType: string;
+
+  value: FunctionNode;
+  inputs: Node[];
+
+  setFunction(func: FunctionNode, inputs?: Node[]): void;
+  getFunction(): FunctionNode;
+  getType(): string;
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: FunctionCallNode): this;
+}

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

@@ -0,0 +1,29 @@
+import { TempNode } from './TempNode';
+import { NodeBuilder } from './NodeBuilder';
+
+export interface FunctionNodeInput {
+    name: string;
+    type: string;
+    qualifier: string;
+}
+
+export class FunctionNode extends TempNode {
+  constructor(src: string, includes?: object[], extensions?: object, keywords?: object, type?: string);
+
+  isMethod: boolean;
+  nodeType: string;
+  useKeywords: boolean;
+
+  inputs: FunctionNodeInput[] | undefined;
+  includes: object[] | undefined;
+  extensions: object | undefined;
+  keywords: object | undefined;
+
+  getShared(builder: NodeBuilder, output: string): boolean;
+  getType(builder: NodeBuilder): string;
+  getInputByName(name: string): FunctionNodeInput | undefined;
+  getIncludeByName(name: string): object | undefined;
+  generate(builder: NodeBuilder, output: string): string;
+  parse(src: string, includes?: object[], extensions?: object, keywords?: object): void;
+  copy(source: FunctionNode): this;
+}

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

@@ -0,0 +1,13 @@
+import { TempNode, TempNodeParams } from './TempNode';
+import { NodeBuilder } from './NodeBuilder';
+
+export class InputNode extends TempNode {
+  constructor(type: string, params?: TempNodeParams);
+
+  readonly: boolean;
+
+  setReadonly(value: boolean): this;
+  getReadonly(builder: NodeBuilder): boolean;
+  copy(source: InputNode): this;
+  generate(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string, needsUpdate?: boolean): string;
+}

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

@@ -0,0 +1,25 @@
+import { NodeBuilder } from './NodeBuilder';
+
+export class Node {
+  constructor(type?: string);
+
+  uuid: string;
+  name: string;
+  type: string | undefined;
+  userData: object;
+  isNode: boolean;
+  frameId: number | undefined;
+
+  analyze(builder: NodeBuilder, settings?: object): void;
+  analyzeAndFlow(builder: NodeBuilder, output: string, settings?: object): object;
+  flow(builder: NodeBuilder, output: string, settings?: object): object;
+  build(builder: NodeBuilder, output: string, uuid?: string): string;
+  appendDepsNode(builder: NodeBuilder, data: object, output: string): void;
+  setName(name: string): this;
+  getName(builder: NodeBuilder): string;
+  getType(builder: NodeBuilder, output?: string): string;
+  getJSONNode(meta?: object | string): object | undefined;
+  copy(source: Node): this;
+  createJSONNode(meta?: object | string): object;
+  toJSON(meta?: object | string): object;
+}

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

@@ -0,0 +1,146 @@
+import {
+  Material,
+  Texture,
+  TextureEncoding,
+  WebGLRenderer
+} from "../../../../build/three.module.js";
+
+import { Node } from './Node';
+import { NodeUniform } from './NodeUniform';
+
+export class NodeBuilder {
+  constructor();
+
+  slots: string[];
+  caches: string[];
+  contexts: object[];
+
+  keywords: object;
+  nodeData: object;
+
+  requires: {
+    uv: boolean[];
+    color: boolean[];
+    lights: boolean;
+    fog: boolean;
+  };
+
+  includes: {
+    consts: object[];
+    functions: object[];
+    structs: object[];
+  };
+
+  attributes: object;
+  prefixCode: string;
+
+  parsCode: {
+    vertex: string;
+    fragment: string;
+  };
+
+  code: {
+    vertex: string;
+    fragment: string;
+  };
+
+  nodeCode: {
+    vertex: string;
+    fragment: string;
+  };
+
+  resultCode: {
+    vertex: string;
+    fragment: string;
+  };
+
+  finalCode: {
+    vertex: string;
+    fragment: string;
+  };
+
+  inputs: {
+    uniforms: {
+      list: object[];
+      vertex: object[];
+      fragment: object[];
+    };
+    vars: {
+      varying: object[];
+      vertex: object[];
+      fragment: object[];
+    }
+  };
+
+  defines: object;
+  uniforms: object;
+  extensions: object;
+  updaters: object[];
+  nodes: object[];
+
+  analyzing: boolean;
+
+  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;
+  removeFlow(): this;
+  addCache(name: string): this;
+  removeCache(): this;
+  addContext(context: object): this;
+  removeContext(): this;
+  addSlot(name: string): this;
+  removeSlot(): this;
+  addVertexCode(code: string): void;
+  addFragmentCode(code: string): void;
+  addCode(code: string, shader: string): void;
+  addVertexNodeCode(code: string): void;
+  addFragmentNodeCode(code: string): void;
+  addNodeCode(code: string, shader: string): void;
+  clearNodeCode(shader: string): string;
+  clearVertexNodeCode(): string;
+  clearFragmentNodeCode(): string;
+  addVertexFinalCode(code: string): void;
+  addFragmentFinalCode(code: string): void;
+  addFinalCode(code: string, shader: string): void;
+  addVertexParsCode(code: string): void;
+  addFragmentParsCode(code: string): void;
+  addParsCode(code: string, shader: string): void;
+  addVaryCode(code: string): void;
+  isCache(name: string): boolean;
+  isSlot(name: string): boolean;
+  define(name: string, value: any): void;
+  isDefined(name: string): boolean;
+  getVar(uuid: string, type: string, ns: string, shader?: string, prefix?: string, label?: string): object;
+  getVar(uuid: string, type: string, ns: string, label: string): object;
+  getAttribute(name: string, type: string);
+  getCode(shader: string): string;
+  getVarListCode(vars: object[], prefix?: string): string;
+  getVars(shader: string): object[];
+  getNodeData(node: Node): object;
+  createUniform(shader: string, type: string, node: Node, ns?: string, needsUpdate?: boolean, label?: string): NodeUniform;
+  createVertexUniform(type: string, node: Node, ns?: string, needsUpdate?: boolean, label?: string): NodeUniform;
+  createFragmentUniform(type: string, node: Node, ns?: string, needsUpdate?: boolean, label?: string): NodeUniform;
+  include(node: Node, parent?: boolean, source?: string): void;
+  colorToVectorProperties(color: string): string;
+  colorToVector(color: string): string;
+  getIncludes(type: string, shader: string): object[];
+  getIncludesCode(type: string, shader: string): string;
+  getConstructorFromLength(len: number): string;
+  isTypeMatrix(format: string): boolean;
+  getTypeLength(type: string): number;
+  getTypeFromLength(len: number): string;
+  findNode(): Node;
+  resolve(): void;
+  format(code: string, from: string, to: string): string;
+  getTypeByFormat(format: string): string;
+  getFormatByType(type: string): string;
+  getUuid(uuid: string, useCache?: boolean): string;
+  getElementByIndex(index: number): string;
+  getIndexByElement(elm: string): number;
+  isShader(shader: string): boolean;
+  setShader(shader: string): this;
+  mergeDefines(defines: object): object;
+  mergeUniform(uniforms: object): uniforms;
+  getTextureEncodingFromMap(map: Texture, gammaOverrideLinear?: boolean): TextureEncoding;
+}

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

@@ -0,0 +1,20 @@
+import {
+    Texture,
+	WebGLRenderer
+} from "../../../../build/three.module.js";
+
+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;
+}

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

@@ -0,0 +1,24 @@
+import { Node } from './Node';
+import { NodeBuilder } from './NodeBuilder';
+
+export interface NodeLibKeyword {
+  callback: (builder: NodeBuilder) => void;
+  cache?: object;
+}
+
+export namespace NodeLib {
+
+  export const nodes: object;
+  export const keywords: object;
+
+  export function add(node: Node): void;
+  export function addKeyword(name: string, callback: (builder: NodeBuilder) => void, cache?: object): void;
+  export function remove(node: Node): void;
+  export function removeKeyword(name: string): void;
+  export function get(name: string): Node;
+  export function getKeyword(name: string, builder: NodeBuilder): any;
+  export function getKeywordData(name: string): NodeLibKeyword;
+  export function contains(name: string): boolean;
+  export function containsKeyword(name: string): boolean;
+
+}

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

@@ -0,0 +1,17 @@
+import { Node } from './Node';
+
+export interface NodeUniformParams {
+  name?: string;
+  type?: string;
+  node?: Node;
+  needsUpdate?: boolean;
+}
+
+export class NodeUniform {
+  constructor(params?: NodeUniformParams);
+  name: string | undefined;
+  type: string | undefined;
+  node: Node | undefined;
+  needsUpdate: boolean | undefined;
+  value: any;
+}

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

@@ -0,0 +1,9 @@
+import { Node } from './Node';
+
+export namespace NodeUtils {
+
+  export const elements: string[];
+
+  export function addShortcuts(proto: Node, proxy: string, list: any[]): void;
+
+}

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

@@ -0,0 +1,20 @@
+import { TempNode } from './TempNode';
+import { NodeBuilder } from './NodeBuilder';
+
+export interface StructNodeInput {
+  type: string;
+  name: string;
+}
+
+export class StructNode extends TempNode {
+  constructor(src?: string);
+
+  inputs: StructNodeInput[];
+  src: string;
+  nodeType: string;
+
+  getType(builder: NodeBuilder): string;
+  getInputByName(name: string): StructNodeInput;
+  generate(builder: NodeBuilder, output: string): string;
+  parse(src: string): void;
+}

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

@@ -0,0 +1,24 @@
+import { Node } from './Node';
+import { NodeBuilder } from './NodeBuilder';
+
+export interface TempNodeParams {
+  shared?: boolean;
+  unique?: boolean;
+}
+
+export class TempNode extends Node {
+  constructor(type: string, params?: TempNodeParams);
+
+  shared: boolean;
+  unique: boolean;
+  label: string | undefined;
+
+  build(builder: NodeBuilder, output: string, uuid?: string, ns?: string): string;
+  getShared(builder: NodeBuilder, output: string): boolean;
+  getUnique(builder: NodeBuilder, output: string): boolean;
+  setLabel(name: string): this;
+  getLabel(builder: NodeBuilder): string;
+  getUuid(unique: boolean): string;
+  getTemp(builder: NodeBuilder, uuid: string): string | undefined;
+  generate(builder: NodeBuilder, output: string, uuid?: string, type?: string, ns?: string): string;
+}

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

@@ -0,0 +1,13 @@
+import { Node } from './Node';
+import { NodeBuilder } from './NodeBuilder';
+
+export class VarNode extends Node {
+  constructor(type: string, value?: any);
+
+  value: any;
+  nodeType: string;
+
+  getType(builder: NodeBuilder): string;
+  generate(builder: NodeBuilder, output: string): string;
+  copy(source: VarNode): this;
+}