opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/nodes/core/NodeBuilder.js

@@ -0,0 +1,782 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "./NodeUniform.js", "./NodeUtils.js", "./NodeLib.js", "./FunctionNode.js", "./ConstNode.js", "./StructNode.js", "../inputs/Vector2Node.js", "../inputs/Vector3Node.js", "../inputs/Vector4Node.js", "../inputs/TextureNode.js", "../inputs/CubeTextureNode.js", "../misc/TextureCubeNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("./NodeUniform.js"), require("./NodeUtils.js"), require("./NodeLib.js"), require("./FunctionNode.js"), require("./ConstNode.js"), require("./StructNode.js"), require("../inputs/Vector2Node.js"), require("../inputs/Vector3Node.js"), require("../inputs/Vector4Node.js"), require("../inputs/TextureNode.js"), require("../inputs/CubeTextureNode.js"), require("../misc/TextureCubeNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.NodeUniform, global.NodeUtils, global.NodeLib, global.FunctionNode, global.ConstNode, global.StructNode, global.Vector2Node, global.Vector3Node, global.Vector4Node, global.TextureNode, global.CubeTextureNode, global.TextureCubeNode);
+    global.NodeBuilder = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _NodeUniform, _NodeUtils, _NodeLib, _FunctionNode, _ConstNode, _StructNode, _Vector2Node, _Vector3Node, _Vector4Node, _TextureNode, _CubeTextureNode, _TextureCubeNode) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.NodeBuilder = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  var elements = _NodeUtils.NodeUtils.elements,
+      constructors = ['float', 'vec2', 'vec3', 'vec4'],
+      convertFormatToType = {
+    float: 'f',
+    vec2: 'v2',
+    vec3: 'v3',
+    vec4: 'v4',
+    mat4: 'v4',
+    int: 'i',
+    bool: 'b'
+  },
+      convertTypeToFormat = {
+    t: 'sampler2D',
+    tc: 'samplerCube',
+    b: 'bool',
+    i: 'int',
+    f: 'float',
+    c: 'vec3',
+    v2: 'vec2',
+    v3: 'vec3',
+    v4: 'vec4',
+    m3: 'mat3',
+    m4: 'mat4'
+  };
+
+  var NodeBuilder = /*#__PURE__*/function () {
+    function NodeBuilder() {
+      _classCallCheck(this, NodeBuilder);
+
+      this.slots = [];
+      this.caches = [];
+      this.contexts = [];
+      this.keywords = {};
+      this.nodeData = {};
+      this.requires = {
+        uv: [],
+        color: [],
+        lights: false,
+        fog: false,
+        transparent: false,
+        irradiance: false
+      };
+      this.includes = {
+        consts: [],
+        functions: [],
+        structs: []
+      };
+      this.attributes = {};
+      this.prefixCode =
+      /* glsl */
+      "\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\n\t\t\t\t#define texCube(a, b) textureCube(a, b)\n\t\t\t\t#define texCubeBias(a, b, c) textureCubeLodEXT(a, b, c)\n\n\t\t\t\t#define tex2D(a, b) texture2D(a, b)\n\t\t\t\t#define tex2DBias(a, b, c) texture2DLodEXT(a, b, c)\n\n\t\t\t#else\n\n\t\t\t\t#define texCube(a, b) textureCube(a, b)\n\t\t\t\t#define texCubeBias(a, b, c) textureCube(a, b, c)\n\n\t\t\t\t#define tex2D(a, b) texture2D(a, b)\n\t\t\t\t#define tex2DBias(a, b, c) texture2D(a, b, c)\n\n\t\t\t#endif\n\n\t\t\t#include <packing>\n\t\t\t#include <common>";
+      this.parsCode = {
+        vertex: '',
+        fragment: ''
+      };
+      this.code = {
+        vertex: '',
+        fragment: ''
+      };
+      this.nodeCode = {
+        vertex: '',
+        fragment: ''
+      };
+      this.resultCode = {
+        vertex: '',
+        fragment: ''
+      };
+      this.finalCode = {
+        vertex: '',
+        fragment: ''
+      };
+      this.inputs = {
+        uniforms: {
+          list: [],
+          vertex: [],
+          fragment: []
+        },
+        vars: {
+          varying: [],
+          vertex: [],
+          fragment: []
+        }
+      }; // send to material
+
+      this.defines = {};
+      this.uniforms = {};
+      this.extensions = {};
+      this.updaters = [];
+      this.nodes = []; // --
+
+      this.analyzing = false;
+    }
+
+    _createClass(NodeBuilder, [{
+      key: "build",
+      value: function build(vertex, fragment) {
+        this.buildShader('vertex', vertex);
+        this.buildShader('fragment', fragment);
+
+        for (var i = 0; i < this.requires.uv.length; i++) {
+          if (this.requires.uv[i]) {
+            var uvIndex = i > 0 ? i + 1 : '';
+            this.addVaryCode('varying vec2 vUv' + uvIndex + ';');
+
+            if (i > 0) {
+              this.addVertexParsCode('attribute vec2 uv' + uvIndex + ';');
+            }
+
+            this.addVertexFinalCode('vUv' + uvIndex + ' = uv' + uvIndex + ';');
+          }
+        }
+
+        if (this.requires.color[0]) {
+          this.addVaryCode('varying vec4 vColor;');
+          this.addVertexParsCode('attribute vec4 color;');
+          this.addVertexFinalCode('vColor = color;');
+        }
+
+        if (this.requires.color[1]) {
+          this.addVaryCode('varying vec4 vColor2;');
+          this.addVertexParsCode('attribute vec4 color2;');
+          this.addVertexFinalCode('vColor2 = color2;');
+        }
+
+        if (this.requires.position) {
+          this.addVaryCode('varying vec3 vPosition;');
+          this.addVertexFinalCode('vPosition = transformed;');
+        }
+
+        if (this.requires.worldPosition) {
+          this.addVaryCode('varying vec3 vWPosition;');
+          this.addVertexFinalCode('vWPosition = ( modelMatrix * vec4( transformed, 1.0 ) ).xyz;');
+        }
+
+        if (this.requires.normal) {
+          this.addVaryCode('varying vec3 vObjectNormal;');
+          this.addVertexFinalCode('vObjectNormal = normal;');
+        }
+
+        if (this.requires.worldNormal) {
+          this.addVaryCode('varying vec3 vWNormal;');
+          this.addVertexFinalCode('vWNormal = inverseTransformDirection( transformedNormal, viewMatrix ).xyz;');
+        }
+
+        return this;
+      }
+    }, {
+      key: "buildShader",
+      value: function buildShader(shader, node) {
+        this.resultCode[shader] = node.build(this.setShader(shader), 'v4');
+      }
+    }, {
+      key: "setMaterial",
+      value: function setMaterial(material, renderer) {
+        this.material = material;
+        this.renderer = renderer;
+        this.requires.lights = material.lights;
+        this.requires.fog = material.fog;
+        this.mergeDefines(material.defines);
+        return this;
+      }
+    }, {
+      key: "addFlow",
+      value: function addFlow(slot, cache, context) {
+        return this.addSlot(slot).addCache(cache).addContext(context);
+      }
+    }, {
+      key: "removeFlow",
+      value: function removeFlow() {
+        return this.removeSlot().removeCache().removeContext();
+      }
+    }, {
+      key: "addCache",
+      value: function addCache(name) {
+        this.cache = name || '';
+        this.caches.push(this.cache);
+        return this;
+      }
+    }, {
+      key: "removeCache",
+      value: function removeCache() {
+        this.caches.pop();
+        this.cache = this.caches[this.caches.length - 1] || '';
+        return this;
+      }
+    }, {
+      key: "addContext",
+      value: function addContext(context) {
+        this.context = Object.assign({}, this.context, context);
+        this.context.extra = this.context.extra || {};
+        this.contexts.push(this.context);
+        return this;
+      }
+    }, {
+      key: "removeContext",
+      value: function removeContext() {
+        this.contexts.pop();
+        this.context = this.contexts[this.contexts.length - 1] || {};
+        return this;
+      }
+    }, {
+      key: "addSlot",
+      value: function addSlot() {
+        var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+        this.slot = name;
+        this.slots.push(this.slot);
+        return this;
+      }
+    }, {
+      key: "removeSlot",
+      value: function removeSlot() {
+        this.slots.pop();
+        this.slot = this.slots[this.slots.length - 1] || '';
+        return this;
+      }
+    }, {
+      key: "addVertexCode",
+      value: function addVertexCode(code) {
+        this.addCode(code, 'vertex');
+      }
+    }, {
+      key: "addFragmentCode",
+      value: function addFragmentCode(code) {
+        this.addCode(code, 'fragment');
+      }
+    }, {
+      key: "addCode",
+      value: function addCode(code, shader) {
+        this.code[shader || this.shader] += code + '\n';
+      }
+    }, {
+      key: "addVertexNodeCode",
+      value: function addVertexNodeCode(code) {
+        this.addNodeCode(code, 'vertex');
+      }
+    }, {
+      key: "addFragmentNodeCode",
+      value: function addFragmentNodeCode(code) {
+        this.addNodeCode(code, 'fragment');
+      }
+    }, {
+      key: "addNodeCode",
+      value: function addNodeCode(code, shader) {
+        this.nodeCode[shader || this.shader] += code + '\n';
+      }
+    }, {
+      key: "clearNodeCode",
+      value: function clearNodeCode(shader) {
+        shader = shader || this.shader;
+        var code = this.nodeCode[shader];
+        this.nodeCode[shader] = '';
+        return code;
+      }
+    }, {
+      key: "clearVertexNodeCode",
+      value: function clearVertexNodeCode() {
+        return this.clearNodeCode('vertex');
+      }
+    }, {
+      key: "clearFragmentNodeCode",
+      value: function clearFragmentNodeCode() {
+        return this.clearNodeCode('fragment');
+      }
+    }, {
+      key: "addVertexFinalCode",
+      value: function addVertexFinalCode(code) {
+        this.addFinalCode(code, 'vertex');
+      }
+    }, {
+      key: "addFragmentFinalCode",
+      value: function addFragmentFinalCode(code) {
+        this.addFinalCode(code, 'fragment');
+      }
+    }, {
+      key: "addFinalCode",
+      value: function addFinalCode(code, shader) {
+        this.finalCode[shader || this.shader] += code + '\n';
+      }
+    }, {
+      key: "addVertexParsCode",
+      value: function addVertexParsCode(code) {
+        this.addParsCode(code, 'vertex');
+      }
+    }, {
+      key: "addFragmentParsCode",
+      value: function addFragmentParsCode(code) {
+        this.addParsCode(code, 'fragment');
+      }
+    }, {
+      key: "addParsCode",
+      value: function addParsCode(code, shader) {
+        this.parsCode[shader || this.shader] += code + '\n';
+      }
+    }, {
+      key: "addVaryCode",
+      value: function addVaryCode(code) {
+        this.addVertexParsCode(code);
+        this.addFragmentParsCode(code);
+      }
+    }, {
+      key: "isCache",
+      value: function isCache(name) {
+        return this.caches.indexOf(name) !== -1;
+      }
+    }, {
+      key: "isSlot",
+      value: function isSlot(name) {
+        return this.slots.indexOf(name) !== -1;
+      }
+    }, {
+      key: "define",
+      value: function define(name, value) {
+        this.defines[name] = value === undefined ? 1 : value;
+      }
+    }, {
+      key: "require",
+      value: function require(name) {
+        this.requires[name] = true;
+      }
+    }, {
+      key: "isDefined",
+      value: function isDefined(name) {
+        return this.defines[name] !== undefined;
+      }
+    }, {
+      key: "getVar",
+      value: function getVar(uuid, type, ns) {
+        var shader = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'varying';
+        var prefix = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'V';
+        var label = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : '';
+        var vars = this.getVars(shader);
+        var data = vars[uuid];
+
+        if (!data) {
+          var index = vars.length,
+              name = ns ? ns : 'node' + prefix + index + (label ? '_' + label : '');
+          data = {
+            name: name,
+            type: type
+          };
+          vars.push(data);
+          vars[uuid] = data;
+        }
+
+        return data;
+      }
+    }, {
+      key: "getTempVar",
+      value: function getTempVar(uuid, type, ns, label) {
+        return this.getVar(uuid, type, ns, this.shader, 'T', label);
+      }
+    }, {
+      key: "getAttribute",
+      value: function getAttribute(name, type) {
+        if (!this.attributes[name]) {
+          var varying = this.getVar(name, type);
+          this.addVertexParsCode('attribute ' + type + ' ' + name + ';');
+          this.addVertexFinalCode(varying.name + ' = ' + name + ';');
+          this.attributes[name] = {
+            varying: varying,
+            name: name,
+            type: type
+          };
+        }
+
+        return this.attributes[name];
+      }
+    }, {
+      key: "getCode",
+      value: function getCode(shader) {
+        return [this.prefixCode, this.parsCode[shader], this.getVarListCode(this.getVars('varying'), 'varying'), this.getVarListCode(this.inputs.uniforms[shader], 'uniform'), this.getIncludesCode('consts', shader), this.getIncludesCode('structs', shader), this.getIncludesCode('functions', shader), 'void main() {', this.getVarListCode(this.getVars(shader)), this.code[shader], this.resultCode[shader], this.finalCode[shader], '}'].join('\n');
+      }
+    }, {
+      key: "getVarListCode",
+      value: function getVarListCode(vars) {
+        var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+        var code = '';
+
+        for (var i = 0, l = vars.length; i < l; ++i) {
+          var nVar = vars[i],
+              type = nVar.type,
+              name = nVar.name;
+          var formatType = this.getFormatByType(type);
+
+          if (formatType === undefined) {
+            throw new Error('Node pars ' + formatType + ' not found.');
+          }
+
+          code += prefix + ' ' + formatType + ' ' + name + ';\n';
+        }
+
+        return code;
+      }
+    }, {
+      key: "getVars",
+      value: function getVars(shader) {
+        return this.inputs.vars[shader || this.shader];
+      }
+    }, {
+      key: "getNodeData",
+      value: function getNodeData(node) {
+        var uuid = node.isNode ? node.uuid : node;
+        return this.nodeData[uuid] = this.nodeData[uuid] || {};
+      }
+    }, {
+      key: "createUniform",
+      value: function createUniform(shader, type, node, ns, needsUpdate, label) {
+        var uniforms = this.inputs.uniforms,
+            index = uniforms.list.length;
+        var uniform = new _NodeUniform.NodeUniform({
+          type: type,
+          name: ns ? ns : 'nodeU' + index + (label ? '_' + label : ''),
+          node: node,
+          needsUpdate: needsUpdate
+        });
+        uniforms.list.push(uniform);
+        uniforms[shader].push(uniform);
+        uniforms[shader][uniform.name] = uniform;
+        this.uniforms[uniform.name] = uniform;
+        return uniform;
+      }
+    }, {
+      key: "createVertexUniform",
+      value: function createVertexUniform(type, node, ns, needsUpdate, label) {
+        return this.createUniform('vertex', type, node, ns, needsUpdate, label);
+      }
+    }, {
+      key: "createFragmentUniform",
+      value: function createFragmentUniform(type, node, ns, needsUpdate, label) {
+        return this.createUniform('fragment', type, node, ns, needsUpdate, label);
+      }
+    }, {
+      key: "include",
+      value: function include(node, parent, source) {
+        var includesStruct;
+        node = typeof node === 'string' ? _NodeLib.NodeLib.get(node) : node;
+
+        if (this.context.include === false) {
+          return node.name;
+        }
+
+        if (node instanceof _FunctionNode.FunctionNode) {
+          includesStruct = this.includes.functions;
+        } else if (node instanceof _ConstNode.ConstNode) {
+          includesStruct = this.includes.consts;
+        } else if (node instanceof _StructNode.StructNode) {
+          includesStruct = this.includes.structs;
+        }
+
+        var includes = includesStruct[this.shader] = includesStruct[this.shader] || [];
+
+        if (node) {
+          var included = includes[node.name];
+
+          if (!included) {
+            included = includes[node.name] = {
+              node: node,
+              deps: []
+            };
+            includes.push(included);
+            included.src = node.build(this, 'source');
+          }
+
+          if (node instanceof _FunctionNode.FunctionNode && parent && includes[parent.name] && includes[parent.name].deps.indexOf(node) == -1) {
+            includes[parent.name].deps.push(node);
+
+            if (node.includes && node.includes.length) {
+              var i = 0;
+
+              do {
+                this.include(node.includes[i++], parent);
+              } while (i < node.includes.length);
+            }
+          }
+
+          if (source) {
+            included.src = source;
+          }
+
+          return node.name;
+        } else {
+          throw new Error('Include not found.');
+        }
+      }
+    }, {
+      key: "colorToVectorProperties",
+      value: function colorToVectorProperties(color) {
+        return color.replace('r', 'x').replace('g', 'y').replace('b', 'z').replace('a', 'w');
+      }
+    }, {
+      key: "colorToVector",
+      value: function colorToVector(color) {
+        return color.replace(/c/g, 'v3');
+      }
+    }, {
+      key: "getIncludes",
+      value: function getIncludes(type, shader) {
+        return this.includes[type][shader || this.shader];
+      }
+    }, {
+      key: "getIncludesCode",
+      value: function getIncludesCode(type, shader) {
+        var includes = this.getIncludes(type, shader);
+        if (!includes) return '';
+        var code = '';
+        includes = includes.sort(sortByPosition);
+
+        for (var i = 0; i < includes.length; i++) {
+          if (includes[i].src) code += includes[i].src + '\n';
+        }
+
+        return code;
+      }
+    }, {
+      key: "getConstructorFromLength",
+      value: function getConstructorFromLength(len) {
+        return constructors[len - 1];
+      }
+    }, {
+      key: "isTypeMatrix",
+      value: function isTypeMatrix(format) {
+        return /^m/.test(format);
+      }
+    }, {
+      key: "getTypeLength",
+      value: function getTypeLength(type) {
+        if (type === 'f') return 1;
+        return parseInt(this.colorToVector(type).substr(1));
+      }
+    }, {
+      key: "getTypeFromLength",
+      value: function getTypeFromLength(len) {
+        if (len === 1) return 'f';
+        return 'v' + len;
+      }
+    }, {
+      key: "findNode",
+      value: function findNode() {
+        for (var i = 0; i < arguments.length; i++) {
+          var nodeCandidate = arguments[i];
+
+          if (nodeCandidate !== undefined && nodeCandidate.isNode) {
+            return nodeCandidate;
+          }
+        }
+      }
+    }, {
+      key: "resolve",
+      value: function resolve() {
+        for (var i = 0; i < arguments.length; i++) {
+          var nodeCandidate = arguments[i];
+
+          if (nodeCandidate !== undefined) {
+            if (nodeCandidate.isNode) {
+              return nodeCandidate;
+            } else if (nodeCandidate.isTexture) {
+              switch (nodeCandidate.mapping) {
+                case _three.CubeReflectionMapping:
+                case _three.CubeRefractionMapping:
+                  return new _CubeTextureNode.CubeTextureNode(nodeCandidate);
+                  break;
+
+                case _three.CubeUVReflectionMapping:
+                case _three.CubeUVRefractionMapping:
+                  return new _TextureCubeNode.TextureCubeNode(new _TextureNode.TextureNode(nodeCandidate));
+                  break;
+
+                default:
+                  return new _TextureNode.TextureNode(nodeCandidate);
+              }
+            } else if (nodeCandidate.isVector2) {
+              return new _Vector2Node.Vector2Node(nodeCandidate);
+            } else if (nodeCandidate.isVector3) {
+              return new _Vector3Node.Vector3Node(nodeCandidate);
+            } else if (nodeCandidate.isVector4) {
+              return new _Vector4Node.Vector4Node(nodeCandidate);
+            }
+          }
+        }
+      }
+    }, {
+      key: "format",
+      value: function format(code, from, to) {
+        var typeToType = this.colorToVector(to + ' <- ' + from);
+
+        switch (typeToType) {
+          case 'f <- v2':
+            return code + '.x';
+
+          case 'f <- v3':
+            return code + '.x';
+
+          case 'f <- v4':
+            return code + '.x';
+
+          case 'f <- i':
+          case 'f <- b':
+            return 'float( ' + code + ' )';
+
+          case 'v2 <- f':
+            return 'vec2( ' + code + ' )';
+
+          case 'v2 <- v3':
+            return code + '.xy';
+
+          case 'v2 <- v4':
+            return code + '.xy';
+
+          case 'v2 <- i':
+          case 'v2 <- b':
+            return 'vec2( float( ' + code + ' ) )';
+
+          case 'v3 <- f':
+            return 'vec3( ' + code + ' )';
+
+          case 'v3 <- v2':
+            return 'vec3( ' + code + ', 0.0 )';
+
+          case 'v3 <- v4':
+            return code + '.xyz';
+
+          case 'v3 <- i':
+          case 'v3 <- b':
+            return 'vec2( float( ' + code + ' ) )';
+
+          case 'v4 <- f':
+            return 'vec4( ' + code + ' )';
+
+          case 'v4 <- v2':
+            return 'vec4( ' + code + ', 0.0, 1.0 )';
+
+          case 'v4 <- v3':
+            return 'vec4( ' + code + ', 1.0 )';
+
+          case 'v4 <- i':
+          case 'v4 <- b':
+            return 'vec4( float( ' + code + ' ) )';
+
+          case 'i <- f':
+          case 'i <- b':
+            return 'int( ' + code + ' )';
+
+          case 'i <- v2':
+            return 'int( ' + code + '.x )';
+
+          case 'i <- v3':
+            return 'int( ' + code + '.x )';
+
+          case 'i <- v4':
+            return 'int( ' + code + '.x )';
+
+          case 'b <- f':
+            return '( ' + code + ' != 0.0 )';
+
+          case 'b <- v2':
+            return '( ' + code + ' != vec2( 0.0 ) )';
+
+          case 'b <- v3':
+            return '( ' + code + ' != vec3( 0.0 ) )';
+
+          case 'b <- v4':
+            return '( ' + code + ' != vec4( 0.0 ) )';
+
+          case 'b <- i':
+            return '( ' + code + ' != 0 )';
+        }
+
+        return code;
+      }
+    }, {
+      key: "getTypeByFormat",
+      value: function getTypeByFormat(format) {
+        return convertFormatToType[format] || format;
+      }
+    }, {
+      key: "getFormatByType",
+      value: function getFormatByType(type) {
+        return convertTypeToFormat[type] || type;
+      }
+    }, {
+      key: "getUuid",
+      value: function getUuid(uuid, useCache) {
+        useCache = useCache !== undefined ? useCache : true;
+        if (useCache && this.cache) uuid = this.cache + '-' + uuid;
+        return uuid;
+      }
+    }, {
+      key: "getElementByIndex",
+      value: function getElementByIndex(index) {
+        return elements[index];
+      }
+    }, {
+      key: "getIndexByElement",
+      value: function getIndexByElement(elm) {
+        return elements.indexOf(elm);
+      }
+    }, {
+      key: "isShader",
+      value: function isShader(shader) {
+        return this.shader === shader;
+      }
+    }, {
+      key: "setShader",
+      value: function setShader(shader) {
+        this.shader = shader;
+        return this;
+      }
+    }, {
+      key: "mergeDefines",
+      value: function mergeDefines(defines) {
+        for (var name in defines) {
+          this.defines[name] = defines[name];
+        }
+
+        return this.defines;
+      }
+    }, {
+      key: "mergeUniform",
+      value: function mergeUniform(uniforms) {
+        for (var name in uniforms) {
+          this.uniforms[name] = uniforms[name];
+        }
+
+        return this.uniforms;
+      }
+    }, {
+      key: "getTextureEncodingFromMap",
+      value: function getTextureEncodingFromMap(map) {
+        var encoding;
+
+        if (!map) {
+          encoding = _three.LinearEncoding;
+        } else if (map.isTexture) {
+          encoding = map.encoding;
+        } else if (map.isWebGLRenderTarget) {
+          console.warn('THREE.WebGLPrograms.getTextureEncodingFromMap: don\'t use render targets as textures. Use their .texture property instead.');
+          encoding = map.texture.encoding;
+        }
+
+        if (encoding === _three.LinearEncoding && this.context.gamma) {
+          encoding = _three.GammaEncoding;
+        }
+
+        return encoding;
+      }
+    }]);
+
+    return NodeBuilder;
+  }();
+
+  _exports.NodeBuilder = NodeBuilder;
+
+  function sortByPosition(a, b) {
+    return a.deps.length - b.deps.length;
+  }
+});