(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;
});