opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/renderers/nodes/accessors/PositionNode.js

@@ -0,0 +1,117 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/Node.js", "../core/AttributeNode.js", "../core/VaryNode.js", "../accessors/ModelNode.js", "../math/MathNode.js", "../math/OperatorNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/Node.js"), require("../core/AttributeNode.js"), require("../core/VaryNode.js"), require("../accessors/ModelNode.js"), require("../math/MathNode.js"), require("../math/OperatorNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.Node, global.AttributeNode, global.VaryNode, global.ModelNode, global.MathNode, global.OperatorNode);
+    global.PositionNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _Node2, _AttributeNode, _VaryNode, _ModelNode, _MathNode, _OperatorNode) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _Node2 = _interopRequireDefault(_Node2);
+  _AttributeNode = _interopRequireDefault(_AttributeNode);
+  _VaryNode = _interopRequireDefault(_VaryNode);
+  _ModelNode = _interopRequireDefault(_ModelNode);
+  _MathNode = _interopRequireDefault(_MathNode);
+  _OperatorNode = _interopRequireDefault(_OperatorNode);
+
+  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); }
+
+  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+  var PositionNode = /*#__PURE__*/function (_Node) {
+    _inherits(PositionNode, _Node);
+
+    var _super = _createSuper(PositionNode);
+
+    function PositionNode() {
+      var _this;
+
+      var scope = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : PositionNode.LOCAL;
+
+      _classCallCheck(this, PositionNode);
+
+      _this = _super.call(this, 'vec3');
+      _this.scope = scope;
+      return _this;
+    }
+
+    _createClass(PositionNode, [{
+      key: "getHash",
+      value: function
+        /*builder*/
+      getHash() {
+        return "position-".concat(this.scope);
+      }
+    }, {
+      key: "generate",
+      value: function generate(builder) {
+        var scope = this.scope;
+        var outputNode = null;
+
+        if (scope === PositionNode.GEOMETRY) {
+          outputNode = new _AttributeNode.default('position', 'vec3');
+        } else if (scope === PositionNode.LOCAL) {
+          outputNode = new _VaryNode.default(new PositionNode(PositionNode.GEOMETRY));
+        } else if (scope === PositionNode.WORLD) {
+          var vertexPositionNode = new _MathNode.default(_MathNode.default.TRANSFORM_DIRECTION, new _ModelNode.default(_ModelNode.default.WORLD_MATRIX), new PositionNode(PositionNode.LOCAL));
+          outputNode = new _VaryNode.default(vertexPositionNode);
+        } else if (scope === PositionNode.VIEW) {
+          var _vertexPositionNode = new _OperatorNode.default('*', new _ModelNode.default(_ModelNode.default.VIEW_MATRIX), new PositionNode(PositionNode.LOCAL));
+
+          outputNode = new _VaryNode.default(_vertexPositionNode);
+        } else if (scope === PositionNode.VIEW_DIRECTION) {
+          var _vertexPositionNode2 = new _MathNode.default(_MathNode.default.NEGATE, new PositionNode(PositionNode.VIEW));
+
+          outputNode = new _MathNode.default(_MathNode.default.NORMALIZE, new _VaryNode.default(_vertexPositionNode2));
+        }
+
+        return outputNode.build(builder, this.getNodeType(builder));
+      }
+    }]);
+
+    return PositionNode;
+  }(_Node2.default);
+
+  _defineProperty(PositionNode, "GEOMETRY", 'geometry');
+
+  _defineProperty(PositionNode, "LOCAL", 'local');
+
+  _defineProperty(PositionNode, "WORLD", 'world');
+
+  _defineProperty(PositionNode, "VIEW", 'view');
+
+  _defineProperty(PositionNode, "VIEW_DIRECTION", 'viewDirection');
+
+  var _default = PositionNode;
+  _exports.default = _default;
+});

data/lib-opal/js_wrap/three/renderers/nodes/accessors/ReferenceNode.js

@@ -0,0 +1,124 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/Node.js", "../inputs/FloatNode.js", "../inputs/Vector2Node.js", "../inputs/Vector3Node.js", "../inputs/Vector4Node.js", "../inputs/ColorNode.js", "../inputs/TextureNode.js", "../core/constants.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/Node.js"), require("../inputs/FloatNode.js"), require("../inputs/Vector2Node.js"), require("../inputs/Vector3Node.js"), require("../inputs/Vector4Node.js"), require("../inputs/ColorNode.js"), require("../inputs/TextureNode.js"), require("../core/constants.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.Node, global.FloatNode, global.Vector2Node, global.Vector3Node, global.Vector4Node, global.ColorNode, global.TextureNode, global.constants);
+    global.ReferenceNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _Node2, _FloatNode, _Vector2Node, _Vector3Node, _Vector4Node, _ColorNode, _TextureNode, _constants) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _Node2 = _interopRequireDefault(_Node2);
+  _FloatNode = _interopRequireDefault(_FloatNode);
+  _Vector2Node = _interopRequireDefault(_Vector2Node);
+  _Vector3Node = _interopRequireDefault(_Vector3Node);
+  _Vector4Node = _interopRequireDefault(_Vector4Node);
+  _ColorNode = _interopRequireDefault(_ColorNode);
+  _TextureNode = _interopRequireDefault(_TextureNode);
+
+  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 ReferenceNode = /*#__PURE__*/function (_Node) {
+    _inherits(ReferenceNode, _Node);
+
+    var _super = _createSuper(ReferenceNode);
+
+    function ReferenceNode(property, inputType) {
+      var _this;
+
+      var object = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+
+      _classCallCheck(this, ReferenceNode);
+
+      _this = _super.call(this);
+      _this.property = property;
+      _this.inputType = inputType;
+      _this.object = object;
+      _this.node = null;
+      _this.updateType = _constants.NodeUpdateType.Object;
+
+      _this.setNodeType(inputType);
+
+      return _this;
+    }
+
+    _createClass(ReferenceNode, [{
+      key: "setNodeType",
+      value: function setNodeType(inputType) {
+        var node = null;
+        var nodeType = inputType;
+
+        if (nodeType === 'float') {
+          node = new _FloatNode.default();
+        } else if (nodeType === 'vec2') {
+          node = new _Vector2Node.default(null);
+        } else if (nodeType === 'vec3') {
+          node = new _Vector3Node.default(null);
+        } else if (nodeType === 'vec4') {
+          node = new _Vector4Node.default(null);
+        } else if (nodeType === 'color') {
+          node = new _ColorNode.default(null);
+          nodeType = 'vec3';
+        } else if (nodeType === 'texture') {
+          node = new _TextureNode.default();
+          nodeType = 'vec4';
+        }
+
+        this.node = node;
+        this.nodeType = nodeType;
+        this.inputType = inputType;
+      }
+    }, {
+      key: "getNodeType",
+      value: function getNodeType() {
+        return this.inputType;
+      }
+    }, {
+      key: "update",
+      value: function update(frame) {
+        var object = this.object !== null ? this.object : frame.object;
+        var value = object[this.property];
+        this.node.value = value;
+      }
+    }, {
+      key: "generate",
+      value: function generate(builder) {
+        return this.node.build(builder, this.getNodeType(builder));
+      }
+    }]);
+
+    return ReferenceNode;
+  }(_Node2.default);
+
+  var _default = ReferenceNode;
+  _exports.default = _default;
+});

data/lib-opal/js_wrap/three/renderers/nodes/accessors/SkinningNode.js

@@ -0,0 +1,129 @@
+(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;
+});

data/lib-opal/js_wrap/three/renderers/nodes/accessors/UVNode.js

@@ -0,0 +1,77 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/AttributeNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/AttributeNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.AttributeNode);
+    global.UVNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _AttributeNode2) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _AttributeNode2 = _interopRequireDefault(_AttributeNode2);
+
+  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 UVNode = /*#__PURE__*/function (_AttributeNode) {
+    _inherits(UVNode, _AttributeNode);
+
+    var _super = _createSuper(UVNode);
+
+    function UVNode() {
+      var _this;
+
+      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+
+      _classCallCheck(this, UVNode);
+
+      _this = _super.call(this, null, 'vec2');
+      _this.value = value;
+      return _this;
+    }
+
+    _createClass(UVNode, [{
+      key: "getAttributeName",
+      value: function
+        /*builder*/
+      getAttributeName() {
+        var value = this.value;
+        return 'uv' + (value > 0 ? value + 1 : '');
+      }
+    }]);
+
+    return UVNode;
+  }(_AttributeNode2.default);
+
+  UVNode.prototype.isUVNode = true;
+  var _default = UVNode;
+  _exports.default = _default;
+});

data/lib-opal/js_wrap/three/renderers/nodes/core/ArrayInputNode.js

@@ -0,0 +1,74 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./InputNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./InputNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.InputNode);
+    global.ArrayInputNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _InputNode2) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _InputNode2 = _interopRequireDefault(_InputNode2);
+
+  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 ArrayInputNode = /*#__PURE__*/function (_InputNode) {
+    _inherits(ArrayInputNode, _InputNode);
+
+    var _super = _createSuper(ArrayInputNode);
+
+    function ArrayInputNode() {
+      var _this;
+
+      var nodes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+
+      _classCallCheck(this, ArrayInputNode);
+
+      _this = _super.call(this);
+      _this.nodes = nodes;
+      return _this;
+    }
+
+    _createClass(ArrayInputNode, [{
+      key: "getNodeType",
+      value: function getNodeType(builder) {
+        return this.nodes[0].getNodeType(builder);
+      }
+    }]);
+
+    return ArrayInputNode;
+  }(_InputNode2.default);
+
+  ArrayInputNode.prototype.isArrayInputNode = true;
+  var _default = ArrayInputNode;
+  _exports.default = _default;
+});

data/lib-opal/js_wrap/three/renderers/nodes/core/AttributeNode.js

@@ -0,0 +1,97 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./Node.js", "./VaryNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./Node.js"), require("./VaryNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.Node, global.VaryNode);
+    global.AttributeNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _Node2, _VaryNode) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _Node2 = _interopRequireDefault(_Node2);
+  _VaryNode = _interopRequireDefault(_VaryNode);
+
+  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 AttributeNode = /*#__PURE__*/function (_Node) {
+    _inherits(AttributeNode, _Node);
+
+    var _super = _createSuper(AttributeNode);
+
+    function AttributeNode(attributeName, nodeType) {
+      var _this;
+
+      _classCallCheck(this, AttributeNode);
+
+      _this = _super.call(this, nodeType);
+      _this._attributeName = attributeName;
+      return _this;
+    }
+
+    _createClass(AttributeNode, [{
+      key: "getHash",
+      value: function getHash(builder) {
+        return this.getAttributeName(builder);
+      }
+    }, {
+      key: "setAttributeName",
+      value: function setAttributeName(attributeName) {
+        this._attributeName = attributeName;
+        return this;
+      }
+    }, {
+      key: "getAttributeName",
+      value: function
+        /*builder*/
+      getAttributeName() {
+        return this._attributeName;
+      }
+    }, {
+      key: "generate",
+      value: function generate(builder) {
+        var attribute = builder.getAttribute(this.getAttributeName(builder), this.getNodeType(builder));
+
+        if (builder.isShaderStage('vertex')) {
+          return attribute.name;
+        } else {
+          var nodeVary = new _VaryNode.default(this);
+          return nodeVary.build(builder, attribute.type);
+        }
+      }
+    }]);
+
+    return AttributeNode;
+  }(_Node2.default);
+
+  var _default = AttributeNode;
+  _exports.default = _default;
+});