(function (global, factory) {
  if (typeof define === "function" && define.amd) {
    define(["exports", "../core/Node.js", "../core/AttributeNode.js", "../accessors/PositionNode.js", "../accessors/NormalNode.js", "../inputs/Matrix4Node.js", "../inputs/BufferNode.js", "../ShaderNode.js", "../core/constants.js"], factory);
  } else if (typeof exports !== "undefined") {
    factory(exports, require("../core/Node.js"), require("../core/AttributeNode.js"), require("../accessors/PositionNode.js"), require("../accessors/NormalNode.js"), require("../inputs/Matrix4Node.js"), require("../inputs/BufferNode.js"), require("../ShaderNode.js"), require("../core/constants.js"));
  } else {
    var mod = {
      exports: {}
    };
    factory(mod.exports, global.Node, global.AttributeNode, global.PositionNode, global.NormalNode, global.Matrix4Node, global.BufferNode, global.ShaderNode, global.constants);
    global.SkinningNode = mod.exports;
  }
})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _Node2, _AttributeNode, _PositionNode, _NormalNode, _Matrix4Node, _BufferNode, _ShaderNode, _constants) {
  "use strict";

  Object.defineProperty(_exports, "__esModule", {
    value: true
  });
  _exports.default = void 0;
  _Node2 = _interopRequireDefault(_Node2);
  _AttributeNode = _interopRequireDefault(_AttributeNode);
  _PositionNode = _interopRequireDefault(_PositionNode);
  _NormalNode = _interopRequireDefault(_NormalNode);
  _Matrix4Node = _interopRequireDefault(_Matrix4Node);
  _BufferNode = _interopRequireDefault(_BufferNode);

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  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 _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 Skinning = new _ShaderNode.ShaderNode(function (inputs, builder) {
    var position = inputs.position,
        normal = inputs.normal,
        index = inputs.index,
        weight = inputs.weight,
        bindMatrix = inputs.bindMatrix,
        bindMatrixInverse = inputs.bindMatrixInverse,
        boneMatrices = inputs.boneMatrices;
    var boneMatX = (0, _ShaderNode.element)(boneMatrices, index.x);
    var boneMatY = (0, _ShaderNode.element)(boneMatrices, index.y);
    var boneMatZ = (0, _ShaderNode.element)(boneMatrices, index.z);
    var boneMatW = (0, _ShaderNode.element)(boneMatrices, index.w); // POSITION

    var skinVertex = (0, _ShaderNode.mul)(bindMatrix, position);
    var skinned = (0, _ShaderNode.add)((0, _ShaderNode.mul)((0, _ShaderNode.mul)(boneMatX, skinVertex), weight.x), (0, _ShaderNode.mul)((0, _ShaderNode.mul)(boneMatY, skinVertex), weight.y), (0, _ShaderNode.mul)((0, _ShaderNode.mul)(boneMatZ, skinVertex), weight.z), (0, _ShaderNode.mul)((0, _ShaderNode.mul)(boneMatW, skinVertex), weight.w));
    var skinPosition = (0, _ShaderNode.mul)(bindMatrixInverse, skinned).xyz; // NORMAL

    var skinMatrix = (0, _ShaderNode.add)((0, _ShaderNode.mul)(weight.x, boneMatX), (0, _ShaderNode.mul)(weight.y, boneMatY), (0, _ShaderNode.mul)(weight.z, boneMatZ), (0, _ShaderNode.mul)(weight.w, boneMatW));
    skinMatrix = (0, _ShaderNode.mul)((0, _ShaderNode.mul)(bindMatrixInverse, skinMatrix), bindMatrix);
    var skinNormal = (0, _ShaderNode.transformDirection)(skinMatrix, normal).xyz; // ASSIGNS

    (0, _ShaderNode.assign)(position, skinPosition).build(builder);
    (0, _ShaderNode.assign)(normal, skinNormal).build(builder);
  });

  var SkinningNode = /*#__PURE__*/function (_Node) {
    _inherits(SkinningNode, _Node);

    var _super = _createSuper(SkinningNode);

    function SkinningNode(skinnedMesh) {
      var _this;

      _classCallCheck(this, SkinningNode);

      _this = _super.call(this, 'void');
      _this.skinnedMesh = skinnedMesh;
      _this.updateType = _constants.NodeUpdateType.Object; //

      _this.skinIndexNode = new _AttributeNode.default('skinIndex', 'uvec4');
      _this.skinWeightNode = new _AttributeNode.default('skinWeight', 'vec4');
      _this.bindMatrixNode = new _Matrix4Node.default(skinnedMesh.bindMatrix);
      _this.bindMatrixInverseNode = new _Matrix4Node.default(skinnedMesh.bindMatrixInverse);
      _this.boneMatricesNode = new _BufferNode.default(skinnedMesh.skeleton.boneMatrices, 'mat4', skinnedMesh.skeleton.bones.length);
      return _this;
    }

    _createClass(SkinningNode, [{
      key: "generate",
      value: function generate(builder) {
        // inout nodes
        var position = new _PositionNode.default(_PositionNode.default.LOCAL);
        var normal = new _NormalNode.default(_NormalNode.default.LOCAL);
        var index = this.skinIndexNode;
        var weight = this.skinWeightNode;
        var bindMatrix = this.bindMatrixNode;
        var bindMatrixInverse = this.bindMatrixInverseNode;
        var boneMatrices = this.boneMatricesNode;
        Skinning({
          position: position,
          normal: normal,
          index: index,
          weight: weight,
          bindMatrix: bindMatrix,
          bindMatrixInverse: bindMatrixInverse,
          boneMatrices: boneMatrices
        }, builder);
      }
    }, {
      key: "update",
      value: function update() {
        this.skinnedMesh.skeleton.update();
      }
    }]);

    return SkinningNode;
  }(_Node2.default);

  var _default = SkinningNode;
  _exports.default = _default;
});