opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/renderers/webgpu/nodes/WebGPUNodeBuilder.js

@@ -0,0 +1,619 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./WebGPUNodeUniformsGroup.js", "./WebGPUNodeUniform.js", "./WebGPUNodeSampler.js", "./WebGPUNodeSampledTexture.js", "../WebGPUUniformBuffer.js", "../WebGPUBufferUtils.js", "../../nodes/core/VarNode.js", "../../nodes/core/CodeNode.js", "../../nodes/core/BypassNode.js", "../../nodes/core/ExpressionNode.js", "../../nodes/core/NodeBuilder.js", "../../nodes/accessors/MaterialNode.js", "../../nodes/accessors/PositionNode.js", "../../nodes/accessors/NormalNode.js", "../../nodes/accessors/ModelViewProjectionNode.js", "../../nodes/accessors/SkinningNode.js", "../../nodes/lights/LightContextNode.js", "../../nodes/math/OperatorNode.js", "../../nodes/parsers/WGSLNodeParser.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./WebGPUNodeUniformsGroup.js"), require("./WebGPUNodeUniform.js"), require("./WebGPUNodeSampler.js"), require("./WebGPUNodeSampledTexture.js"), require("../WebGPUUniformBuffer.js"), require("../WebGPUBufferUtils.js"), require("../../nodes/core/VarNode.js"), require("../../nodes/core/CodeNode.js"), require("../../nodes/core/BypassNode.js"), require("../../nodes/core/ExpressionNode.js"), require("../../nodes/core/NodeBuilder.js"), require("../../nodes/accessors/MaterialNode.js"), require("../../nodes/accessors/PositionNode.js"), require("../../nodes/accessors/NormalNode.js"), require("../../nodes/accessors/ModelViewProjectionNode.js"), require("../../nodes/accessors/SkinningNode.js"), require("../../nodes/lights/LightContextNode.js"), require("../../nodes/math/OperatorNode.js"), require("../../nodes/parsers/WGSLNodeParser.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.WebGPUNodeUniformsGroup, global.WebGPUNodeUniform, global.WebGPUNodeSampler, global.WebGPUNodeSampledTexture, global.WebGPUUniformBuffer, global.WebGPUBufferUtils, global.VarNode, global.CodeNode, global.BypassNode, global.ExpressionNode, global.NodeBuilder, global.MaterialNode, global.PositionNode, global.NormalNode, global.ModelViewProjectionNode, global.SkinningNode, global.LightContextNode, global.OperatorNode, global.WGSLNodeParser);
+    global.WebGPUNodeBuilder = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _WebGPUNodeUniformsGroup, _WebGPUNodeUniform, _WebGPUNodeSampler, _WebGPUNodeSampledTexture, _WebGPUUniformBuffer, _WebGPUBufferUtils, _VarNode, _CodeNode, _BypassNode, _ExpressionNode, _NodeBuilder2, _MaterialNode, _PositionNode, _NormalNode, _ModelViewProjectionNode, _SkinningNode, _LightContextNode, _OperatorNode, _WGSLNodeParser) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _WebGPUNodeUniformsGroup = _interopRequireDefault(_WebGPUNodeUniformsGroup);
+  _WebGPUNodeSampler = _interopRequireDefault(_WebGPUNodeSampler);
+  _WebGPUUniformBuffer = _interopRequireDefault(_WebGPUUniformBuffer);
+  _VarNode = _interopRequireDefault(_VarNode);
+  _CodeNode = _interopRequireDefault(_CodeNode);
+  _BypassNode = _interopRequireDefault(_BypassNode);
+  _ExpressionNode = _interopRequireDefault(_ExpressionNode);
+  _NodeBuilder2 = _interopRequireDefault(_NodeBuilder2);
+  _MaterialNode = _interopRequireDefault(_MaterialNode);
+  _PositionNode = _interopRequireDefault(_PositionNode);
+  _NormalNode = _interopRequireDefault(_NormalNode);
+  _ModelViewProjectionNode = _interopRequireDefault(_ModelViewProjectionNode);
+  _SkinningNode = _interopRequireDefault(_SkinningNode);
+  _LightContextNode = _interopRequireDefault(_LightContextNode);
+  _OperatorNode = _interopRequireDefault(_OperatorNode);
+  _WGSLNodeParser = _interopRequireDefault(_WGSLNodeParser);
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+  function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+  function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+  function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+  function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+  function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+  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; }
+
+  function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+
+  function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var wgslTypeLib = {
+    float: 'f32',
+    int: 'i32',
+    vec2: 'vec2<f32>',
+    vec3: 'vec3<f32>',
+    vec4: 'vec4<f32>',
+    uvec4: 'vec4<u32>',
+    mat3: 'mat3x3<f32>',
+    mat4: 'mat4x4<f32>'
+  };
+  var wgslMethods = {
+    dFdx: 'dpdx',
+    dFdy: 'dpdy'
+  };
+  var wgslPolyfill = {
+    mod: new _CodeNode.default("\nfn mod( x : f32, y : f32 ) -> f32 {\n\n\treturn x - y * floor( x / y );\n\n}\n"),
+    repeatWrapping: new _CodeNode.default("\nfn repeatWrapping( uv : vec2<f32>, dimension : vec2<i32> ) -> vec2<i32> {\n\n\tlet uvScaled = vec2<i32>( uv * vec2<f32>( dimension ) );\n\n\treturn ( ( uvScaled % dimension ) + dimension ) % dimension;\n\n}\n"),
+    inversesqrt: new _CodeNode.default("\nfn inversesqrt( x : f32 ) -> f32 {\n\n\treturn 1.0 / sqrt( x );\n\n}\n")
+  };
+
+  var WebGPUNodeBuilder = /*#__PURE__*/function (_NodeBuilder) {
+    _inherits(WebGPUNodeBuilder, _NodeBuilder);
+
+    var _super = _createSuper(WebGPUNodeBuilder);
+
+    function WebGPUNodeBuilder(object, renderer) {
+      var _this;
+
+      var lightNode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+
+      _classCallCheck(this, WebGPUNodeBuilder);
+
+      _this = _super.call(this, object, renderer, new _WGSLNodeParser.default());
+      _this.lightNode = lightNode;
+      _this.bindings = {
+        vertex: [],
+        fragment: []
+      };
+      _this.bindingsOffset = {
+        vertex: 0,
+        fragment: 0
+      };
+      _this.uniformsGroup = {};
+
+      _this._parseObject();
+
+      return _this;
+    }
+
+    _createClass(WebGPUNodeBuilder, [{
+      key: "_parseObject",
+      value: function _parseObject() {
+        var object = this.object;
+        var material = this.material; // parse inputs
+
+        if (material.isMeshStandardMaterial || material.isMeshBasicMaterial || material.isPointsMaterial || material.isLineBasicMaterial) {
+          var lightNode = material.lightNode; // VERTEX STAGE
+
+          var vertex = new _PositionNode.default(_PositionNode.default.GEOMETRY);
+
+          if (lightNode === null && this.lightNode && this.lightNode.hasLights === true) {
+            lightNode = this.lightNode;
+          }
+
+          if (material.positionNode && material.positionNode.isNode) {
+            var assignPositionNode = new _OperatorNode.default('=', new _PositionNode.default(_PositionNode.default.LOCAL), material.positionNode);
+            vertex = new _BypassNode.default(vertex, assignPositionNode);
+          }
+
+          if (object.isSkinnedMesh === true) {
+            vertex = new _BypassNode.default(vertex, new _SkinningNode.default(object));
+          }
+
+          this.context.vertex = vertex;
+          this.addFlow('vertex', new _VarNode.default(new _ModelViewProjectionNode.default(), 'MVP', 'vec4')); // COLOR
+
+          var colorNode = null;
+
+          if (material.colorNode && material.colorNode.isNode) {
+            colorNode = material.colorNode;
+          } else {
+            colorNode = new _MaterialNode.default(_MaterialNode.default.COLOR);
+          }
+
+          colorNode = this.addFlow('fragment', new _VarNode.default(colorNode, 'DiffuseColor', 'vec4')); // OPACITY
+
+          var opacityNode = null;
+
+          if (material.opacityNode && material.opacityNode.isNode) {
+            opacityNode = material.opacityNode;
+          } else {
+            opacityNode = new _VarNode.default(new _MaterialNode.default(_MaterialNode.default.OPACITY));
+          }
+
+          this.addFlow('fragment', new _VarNode.default(opacityNode, 'OPACITY', 'float'));
+          this.addFlow('fragment', new _ExpressionNode.default('DiffuseColor.a = DiffuseColor.a * OPACITY;')); // ALPHA TEST
+
+          var alphaTest = null;
+
+          if (material.alphaTestNode && material.alphaTestNode.isNode) {
+            alphaTest = material.alphaTestNode;
+          } else if (material.alphaTest > 0) {
+            alphaTest = new _MaterialNode.default(_MaterialNode.default.ALPHA_TEST);
+          }
+
+          if (alphaTest !== null) {
+            this.addFlow('fragment', new _VarNode.default(alphaTest, 'AlphaTest', 'float'));
+            this.addFlow('fragment', new _ExpressionNode.default('if ( DiffuseColor.a <= AlphaTest ) { discard; }'));
+          }
+
+          if (material.isMeshStandardMaterial) {
+            // METALNESS
+            var metalnessNode = null;
+
+            if (material.metalnessNode && material.metalnessNode.isNode) {
+              metalnessNode = material.metalnessNode;
+            } else {
+              metalnessNode = new _MaterialNode.default(_MaterialNode.default.METALNESS);
+            }
+
+            this.addFlow('fragment', new _VarNode.default(metalnessNode, 'Metalness', 'float'));
+            this.addFlow('fragment', new _ExpressionNode.default('DiffuseColor = vec4<f32>( DiffuseColor.rgb * ( 1.0 - Metalness ), DiffuseColor.a );')); // ROUGHNESS
+
+            var roughnessNode = null;
+
+            if (material.roughnessNode && material.roughnessNode.isNode) {
+              roughnessNode = material.roughnessNode;
+            } else {
+              roughnessNode = new _MaterialNode.default(_MaterialNode.default.ROUGHNESS);
+            }
+
+            this.addFlow('fragment', new _VarNode.default(roughnessNode, 'Roughness', 'float')); // SPECULAR_TINT
+
+            this.addFlow('fragment', new _VarNode.default(new _ExpressionNode.default('mix( vec3<f32>( 0.04 ), DiffuseColor.rgb, Metalness )', 'vec3'), 'SpecularColor', 'color')); // NORMAL_VIEW
+
+            var normalNode = null;
+
+            if (material.normalNode && material.normalNode.isNode) {
+              normalNode = material.normalNode;
+            } else {
+              normalNode = new _NormalNode.default(_NormalNode.default.VIEW);
+            }
+
+            this.addFlow('fragment', new _VarNode.default(normalNode, 'TransformedNormalView', 'vec3'));
+          } // LIGHT
+
+
+          var outputNode = colorNode;
+
+          if (lightNode && lightNode.isNode) {
+            var lightContextNode = new _LightContextNode.default(lightNode);
+            outputNode = this.addFlow('fragment', new _VarNode.default(lightContextNode, 'Light', 'vec3'));
+          } // RESULT
+
+
+          this.addFlow('fragment', new _VarNode.default(outputNode, 'Output', 'vec4'));
+        }
+      }
+    }, {
+      key: "addFlowCode",
+      value: function addFlowCode(code) {
+        if (!/;\s*$/.test(code)) {
+          code += ';';
+        }
+
+        _get(_getPrototypeOf(WebGPUNodeBuilder.prototype), "addFlowCode", this).call(this, code + '\n\t');
+      }
+    }, {
+      key: "getTexture",
+      value: function getTexture(textureProperty, uvSnippet) {
+        var biasSnippet = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+        var shaderStage = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : this.shaderStage;
+
+        if (shaderStage === 'fragment') {
+          return "textureSample( ".concat(textureProperty, ", ").concat(textureProperty, "_sampler, ").concat(uvSnippet, " )");
+        } else {
+          this._include('repeatWrapping');
+
+          var dimension = "textureDimensions( ".concat(textureProperty, ", 0 )");
+          return "textureLoad( ".concat(textureProperty, ", repeatWrapping( ").concat(uvSnippet, ", ").concat(dimension, " ), 0 )");
+        }
+      }
+    }, {
+      key: "getPropertyName",
+      value: function getPropertyName(node) {
+        var shaderStage = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.shaderStage;
+
+        if (node.isNodeVary === true) {
+          if (shaderStage === 'vertex') {
+            return "NodeVarys.".concat(node.name);
+          }
+        } else if (node.isNodeUniform === true) {
+          var name = node.name;
+          var type = node.type;
+
+          if (type === 'texture') {
+            return name;
+          } else if (type === 'buffer') {
+            return "NodeBuffer.".concat(name);
+          } else {
+            return "NodeUniforms.".concat(name);
+          }
+        }
+
+        return _get(_getPrototypeOf(WebGPUNodeBuilder.prototype), "getPropertyName", this).call(this, node);
+      }
+    }, {
+      key: "getBindings",
+      value: function getBindings() {
+        var bindings = this.bindings;
+        return [].concat(_toConsumableArray(bindings.vertex), _toConsumableArray(bindings.fragment));
+      }
+    }, {
+      key: "getUniformFromNode",
+      value: function getUniformFromNode(node, shaderStage, type) {
+        var uniformNode = _get(_getPrototypeOf(WebGPUNodeBuilder.prototype), "getUniformFromNode", this).call(this, node, shaderStage, type);
+
+        var nodeData = this.getDataFromNode(node, shaderStage);
+
+        if (nodeData.uniformGPU === undefined) {
+          var uniformGPU;
+          var bindings = this.bindings[shaderStage];
+
+          if (type === 'texture') {
+            var sampler = new _WebGPUNodeSampler.default("".concat(uniformNode.name, "_sampler"), uniformNode.node);
+            var texture = new _WebGPUNodeSampledTexture.WebGPUNodeSampledTexture(uniformNode.name, uniformNode.node); // add first textures in sequence and group for last
+
+            var lastBinding = bindings[bindings.length - 1];
+            var index = lastBinding && lastBinding.isUniformsGroup ? bindings.length - 1 : bindings.length;
+
+            if (shaderStage === 'fragment') {
+              bindings.splice(index, 0, sampler, texture);
+              uniformGPU = [sampler, texture];
+            } else {
+              bindings.splice(index, 0, texture);
+              uniformGPU = [texture];
+            }
+          } else if (type === 'buffer') {
+            var buffer = new _WebGPUUniformBuffer.default('NodeBuffer', node.value); // add first textures in sequence and group for last
+
+            var _lastBinding = bindings[bindings.length - 1];
+
+            var _index = _lastBinding && _lastBinding.isUniformsGroup ? bindings.length - 1 : bindings.length;
+
+            bindings.splice(_index, 0, buffer);
+            uniformGPU = buffer;
+          } else {
+            var uniformsGroup = this.uniformsGroup[shaderStage];
+
+            if (uniformsGroup === undefined) {
+              uniformsGroup = new _WebGPUNodeUniformsGroup.default(shaderStage);
+              this.uniformsGroup[shaderStage] = uniformsGroup;
+              bindings.push(uniformsGroup);
+            }
+
+            if (node.isArrayInputNode === true) {
+              uniformGPU = [];
+
+              var _iterator = _createForOfIteratorHelper(node.nodes),
+                  _step;
+
+              try {
+                for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                  var inputNode = _step.value;
+
+                  var uniformNodeGPU = this._getNodeUniform(inputNode, type); // fit bounds to buffer
+
+
+                  uniformNodeGPU.boundary = (0, _WebGPUBufferUtils.getVectorLength)(uniformNodeGPU.itemSize);
+                  uniformNodeGPU.itemSize = (0, _WebGPUBufferUtils.getStrideLength)(uniformNodeGPU.itemSize);
+                  uniformsGroup.addUniform(uniformNodeGPU);
+                  uniformGPU.push(uniformNodeGPU);
+                }
+              } catch (err) {
+                _iterator.e(err);
+              } finally {
+                _iterator.f();
+              }
+            } else {
+              uniformGPU = this._getNodeUniform(uniformNode, type);
+              uniformsGroup.addUniform(uniformGPU);
+            }
+          }
+
+          nodeData.uniformGPU = uniformGPU;
+
+          if (shaderStage === 'vertex') {
+            this.bindingsOffset['fragment'] = bindings.length;
+          }
+        }
+
+        return uniformNode;
+      }
+    }, {
+      key: "getAttributes",
+      value: function getAttributes(shaderStage) {
+        var snippet = '';
+
+        if (shaderStage === 'vertex') {
+          var attributes = this.attributes;
+          var length = attributes.length;
+          snippet += '\n';
+
+          for (var index = 0; index < length; index++) {
+            var attribute = attributes[index];
+            var name = attribute.name;
+            var type = this.getType(attribute.type);
+            snippet += "\t[[ location( ".concat(index, " ) ]] ").concat(name, " : ").concat(type);
+
+            if (index + 1 < length) {
+              snippet += ',\n';
+            }
+          }
+
+          snippet += '\n';
+        }
+
+        return snippet;
+      }
+    }, {
+      key: "getVars",
+      value: function getVars(shaderStage) {
+        var snippet = '';
+        var vars = this.vars[shaderStage];
+
+        for (var index = 0; index < vars.length; index++) {
+          var variable = vars[index];
+          var name = variable.name;
+          var type = this.getType(variable.type);
+          snippet += "var ".concat(name, " : ").concat(type, "; ");
+        }
+
+        return snippet;
+      }
+    }, {
+      key: "getVarys",
+      value: function getVarys(shaderStage) {
+        var snippet = '';
+
+        if (shaderStage === 'vertex') {
+          snippet += '\t[[ builtin( position ) ]] Vertex: vec4<f32>;\n';
+          var varys = this.varys;
+
+          for (var index = 0; index < varys.length; index++) {
+            var vary = varys[index];
+            snippet += "\t[[ location( ".concat(index, " ) ]] ").concat(vary.name, " : ").concat(this.getType(vary.type), ";\n");
+          }
+
+          snippet = this._getWGSLStruct('NodeVarysStruct', snippet);
+        } else if (shaderStage === 'fragment') {
+          var _varys = this.varys;
+          snippet += '\n';
+
+          for (var _index2 = 0; _index2 < _varys.length; _index2++) {
+            var _vary = _varys[_index2];
+            snippet += "\t[[ location( ".concat(_index2, " ) ]] ").concat(_vary.name, " : ").concat(this.getType(_vary.type));
+
+            if (_index2 + 1 < _varys.length) {
+              snippet += ',\n';
+            }
+          }
+
+          snippet += '\n';
+        }
+
+        return snippet;
+      }
+    }, {
+      key: "getUniforms",
+      value: function getUniforms(shaderStage) {
+        var uniforms = this.uniforms[shaderStage];
+        var snippet = '';
+        var groupSnippet = '';
+        var index = this.bindingsOffset[shaderStage];
+
+        var _iterator2 = _createForOfIteratorHelper(uniforms),
+            _step2;
+
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var uniform = _step2.value;
+
+            if (uniform.type === 'texture') {
+              if (shaderStage === 'fragment') {
+                snippet += "[[ group( 0 ), binding( ".concat(index++, " ) ]] var ").concat(uniform.name, "_sampler : sampler; ");
+              }
+
+              snippet += "[[ group( 0 ), binding( ".concat(index++, " ) ]] var ").concat(uniform.name, " : texture_2d<f32>; ");
+            } else if (uniform.type === 'buffer') {
+              var bufferNode = uniform.node;
+              var bufferType = this.getType(bufferNode.bufferType);
+              var bufferCount = bufferNode.bufferCount;
+              var bufferSnippet = "\t".concat(uniform.name, " : array< ").concat(bufferType, ", ").concat(bufferCount, " >;\n");
+              snippet += this._getWGSLUniforms('NodeBuffer', bufferSnippet, index++) + '\n\n';
+            } else {
+              var vectorType = this.getType(this.getVectorType(uniform.type));
+
+              if (Array.isArray(uniform.value) === true) {
+                var length = uniform.value.length;
+                groupSnippet += "uniform ".concat(vectorType, "[ ").concat(length, " ] ").concat(uniform.name, "; ");
+              } else {
+                groupSnippet += "\t".concat(uniform.name, " : ").concat(vectorType, ";\n");
+              }
+            }
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+
+        if (groupSnippet) {
+          snippet += this._getWGSLUniforms('NodeUniforms', groupSnippet, index++);
+        }
+
+        return snippet;
+      }
+    }, {
+      key: "buildCode",
+      value: function buildCode() {
+        var shadersData = {
+          fragment: {},
+          vertex: {}
+        };
+
+        for (var shaderStage in shadersData) {
+          var flow = '// code\n';
+          flow += "\t".concat(this.flowCode[shaderStage]);
+          flow += '\n';
+          var flowNodes = this.flowNodes[shaderStage];
+          var mainNode = flowNodes[flowNodes.length - 1];
+
+          var _iterator3 = _createForOfIteratorHelper(flowNodes),
+              _step3;
+
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var node = _step3.value;
+              var flowSlotData = this.getFlowData(shaderStage, node);
+              var slotName = node.name;
+
+              if (slotName) {
+                if (flow.length > 0) flow += '\n';
+                flow += "\t// FLOW -> ".concat(slotName, "\n\t");
+              }
+
+              flow += "".concat(flowSlotData.code, "\n\t");
+
+              if (node === mainNode) {
+                flow += '// FLOW RESULT\n\t';
+
+                if (shaderStage === 'vertex') {
+                  flow += 'NodeVarys.Vertex = ';
+                } else if (shaderStage === 'fragment') {
+                  flow += 'return ';
+                }
+
+                flow += "".concat(flowSlotData.result, ";");
+              }
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+
+          var stageData = shadersData[shaderStage];
+          stageData.uniforms = this.getUniforms(shaderStage);
+          stageData.attributes = this.getAttributes(shaderStage);
+          stageData.varys = this.getVarys(shaderStage);
+          stageData.vars = this.getVars(shaderStage);
+          stageData.codes = this.getCodes(shaderStage);
+          stageData.flow = flow;
+        }
+
+        this.vertexShader = this._getWGSLVertexCode(shadersData.vertex);
+        this.fragmentShader = this._getWGSLFragmentCode(shadersData.fragment);
+      }
+    }, {
+      key: "getMethod",
+      value: function getMethod(method) {
+        if (wgslPolyfill[method] !== undefined) {
+          this._include(method);
+        }
+
+        return wgslMethods[method] || method;
+      }
+    }, {
+      key: "getType",
+      value: function getType(type) {
+        return wgslTypeLib[type] || type;
+      }
+    }, {
+      key: "_include",
+      value: function _include(name) {
+        wgslPolyfill[name].build(this);
+      }
+    }, {
+      key: "_getNodeUniform",
+      value: function _getNodeUniform(uniformNode, type) {
+        if (type === 'float') return new _WebGPUNodeUniform.FloatNodeUniform(uniformNode);
+        if (type === 'vec2') return new _WebGPUNodeUniform.Vector2NodeUniform(uniformNode);
+        if (type === 'vec3') return new _WebGPUNodeUniform.Vector3NodeUniform(uniformNode);
+        if (type === 'vec4') return new _WebGPUNodeUniform.Vector4NodeUniform(uniformNode);
+        if (type === 'color') return new _WebGPUNodeUniform.ColorNodeUniform(uniformNode);
+        if (type === 'mat3') return new _WebGPUNodeUniform.Matrix3NodeUniform(uniformNode);
+        if (type === 'mat4') return new _WebGPUNodeUniform.Matrix4NodeUniform(uniformNode);
+        throw new Error("Uniform \"".concat(type, "\" not declared."));
+      }
+    }, {
+      key: "_getWGSLVertexCode",
+      value: function _getWGSLVertexCode(shaderData) {
+        return "".concat(this.getSignature(), "\n\n// uniforms\n").concat(shaderData.uniforms, "\n\n// varys\n").concat(shaderData.varys, "\n\n// codes\n").concat(shaderData.codes, "\n\n[[ stage( vertex ) ]]\nfn main( ").concat(shaderData.attributes, " ) -> NodeVarysStruct {\n\n\t// system\n\tvar NodeVarys: NodeVarysStruct;\n\n\t// vars\n\t").concat(shaderData.vars, "\n\n\t// flow\n\t").concat(shaderData.flow, "\n\n\treturn NodeVarys;\n\n}\n");
+      }
+    }, {
+      key: "_getWGSLFragmentCode",
+      value: function _getWGSLFragmentCode(shaderData) {
+        return "".concat(this.getSignature(), "\n\n// uniforms\n").concat(shaderData.uniforms, "\n\n// codes\n").concat(shaderData.codes, "\n\n[[ stage( fragment ) ]]\nfn main( ").concat(shaderData.varys, " ) -> [[ location( 0 ) ]] vec4<f32> {\n\n\t// vars\n\t").concat(shaderData.vars, "\n\n\t// flow\n\t").concat(shaderData.flow, "\n\n}\n");
+      }
+    }, {
+      key: "_getWGSLStruct",
+      value: function _getWGSLStruct(name, vars) {
+        return "[[ block ]]\nstruct ".concat(name, " {\n\n").concat(vars, "\n};");
+      }
+    }, {
+      key: "_getWGSLUniforms",
+      value: function _getWGSLUniforms(name, vars) {
+        var binding = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+        var group = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+        var structName = name + 'Struct';
+
+        var structSnippet = this._getWGSLStruct(structName, vars);
+
+        return "".concat(structSnippet, "\n[[ binding( ").concat(binding, " ), group( ").concat(group, " ) ]]\nvar<uniform> ").concat(name, " : ").concat(structName, ";");
+      }
+    }]);
+
+    return WebGPUNodeBuilder;
+  }(_NodeBuilder2.default);
+
+  var _default = WebGPUNodeBuilder;
+  _exports.default = _default;
+});