opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/renderers/nodes/inputs/Vector3Node.js

@@ -0,0 +1,67 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/InputNode.js", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/InputNode.js"), require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.InputNode, global.three);
+    global.Vector3Node = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _InputNode2, _three) {
+  "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 _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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  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 Vector3Node = /*#__PURE__*/function (_InputNode) {
+    _inherits(Vector3Node, _InputNode);
+
+    var _super = _createSuper(Vector3Node);
+
+    function Vector3Node() {
+      var _this;
+
+      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new _three.Vector3();
+
+      _classCallCheck(this, Vector3Node);
+
+      _this = _super.call(this, 'vec3');
+      _this.value = value;
+      return _this;
+    }
+
+    return _createClass(Vector3Node);
+  }(_InputNode2.default);
+
+  Vector3Node.prototype.isVector3Node = true;
+  var _default = Vector3Node;
+  _exports.default = _default;
+});

data/lib-opal/js_wrap/three/renderers/nodes/inputs/Vector4Node.js

@@ -0,0 +1,67 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/InputNode.js", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/InputNode.js"), require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.InputNode, global.three);
+    global.Vector4Node = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _InputNode2, _three) {
+  "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 _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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  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 Vector4Node = /*#__PURE__*/function (_InputNode) {
+    _inherits(Vector4Node, _InputNode);
+
+    var _super = _createSuper(Vector4Node);
+
+    function Vector4Node() {
+      var _this;
+
+      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new _three.Vector4();
+
+      _classCallCheck(this, Vector4Node);
+
+      _this = _super.call(this, 'vec4');
+      _this.value = value;
+      return _this;
+    }
+
+    return _createClass(Vector4Node);
+  }(_InputNode2.default);
+
+  Vector4Node.prototype.isVector4Node = true;
+  var _default = Vector4Node;
+  _exports.default = _default;
+});

data/lib-opal/js_wrap/three/renderers/nodes/lights/LightContextNode.js

@@ -0,0 +1,103 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/ContextNode.js", "../core/VarNode.js", "../inputs/Vector3Node.js", "../math/OperatorNode.js", "../functions/BSDFs.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/ContextNode.js"), require("../core/VarNode.js"), require("../inputs/Vector3Node.js"), require("../math/OperatorNode.js"), require("../functions/BSDFs.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.ContextNode, global.VarNode, global.Vector3Node, global.OperatorNode, global.BSDFs);
+    global.LightContextNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _ContextNode2, _VarNode, _Vector3Node, _OperatorNode, _BSDFs) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _ContextNode2 = _interopRequireDefault(_ContextNode2);
+  _VarNode = _interopRequireDefault(_VarNode);
+  _Vector3Node = _interopRequireDefault(_Vector3Node);
+  _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 _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 LightContextNode = /*#__PURE__*/function (_ContextNode) {
+    _inherits(LightContextNode, _ContextNode);
+
+    var _super = _createSuper(LightContextNode);
+
+    function LightContextNode(node) {
+      _classCallCheck(this, LightContextNode);
+
+      return _super.call(this, node);
+    }
+
+    _createClass(LightContextNode, [{
+      key: "getNodeType",
+      value: function
+        /*builder*/
+      getNodeType() {
+        return 'vec3';
+      }
+    }, {
+      key: "generate",
+      value: function generate(builder) {
+        var material = builder.material;
+        var lightingModel = null;
+
+        if (material.isMeshStandardMaterial === true) {
+          lightingModel = _BSDFs.PhysicalLightingModel;
+        }
+
+        var directDiffuse = new _VarNode.default(new _Vector3Node.default(), 'DirectDiffuse', 'vec3');
+        var directSpecular = new _VarNode.default(new _Vector3Node.default(), 'DirectSpecular', 'vec3');
+        this.context.directDiffuse = directDiffuse;
+        this.context.directSpecular = directSpecular;
+
+        if (lightingModel !== null) {
+          this.context.lightingModel = lightingModel;
+        } // add code
+
+
+        var type = this.getNodeType(builder);
+
+        _get(_getPrototypeOf(LightContextNode.prototype), "generate", this).call(this, builder, type);
+
+        var totalLight = new _OperatorNode.default('+', directDiffuse, directSpecular);
+        return totalLight.build(builder, type);
+      }
+    }]);
+
+    return LightContextNode;
+  }(_ContextNode2.default);
+
+  var _default = LightContextNode;
+  _exports.default = _default;
+});

data/lib-opal/js_wrap/three/renderers/nodes/lights/LightNode.js

@@ -0,0 +1,115 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/Node.js", "../accessors/Object3DNode.js", "../accessors/PositionNode.js", "../inputs/ColorNode.js", "../inputs/FloatNode.js", "../math/OperatorNode.js", "../math/MathNode.js", "../core/constants.js", "../functions/BSDFs.js", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/Node.js"), require("../accessors/Object3DNode.js"), require("../accessors/PositionNode.js"), require("../inputs/ColorNode.js"), require("../inputs/FloatNode.js"), require("../math/OperatorNode.js"), require("../math/MathNode.js"), require("../core/constants.js"), require("../functions/BSDFs.js"), require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.Node, global.Object3DNode, global.PositionNode, global.ColorNode, global.FloatNode, global.OperatorNode, global.MathNode, global.constants, global.BSDFs, global.three);
+    global.LightNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _Node2, _Object3DNode, _PositionNode, _ColorNode, _FloatNode, _OperatorNode, _MathNode, _constants, _BSDFs, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _Node2 = _interopRequireDefault(_Node2);
+  _Object3DNode = _interopRequireDefault(_Object3DNode);
+  _PositionNode = _interopRequireDefault(_PositionNode);
+  _ColorNode = _interopRequireDefault(_ColorNode);
+  _FloatNode = _interopRequireDefault(_FloatNode);
+  _OperatorNode = _interopRequireDefault(_OperatorNode);
+  _MathNode = _interopRequireDefault(_MathNode);
+
+  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 LightNode = /*#__PURE__*/function (_Node) {
+    _inherits(LightNode, _Node);
+
+    var _super = _createSuper(LightNode);
+
+    function LightNode() {
+      var _this;
+
+      var light = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+
+      _classCallCheck(this, LightNode);
+
+      _this = _super.call(this, 'vec3');
+      _this.updateType = _constants.NodeUpdateType.Object;
+      _this.light = light;
+      _this.colorNode = new _ColorNode.default(new _three.Color());
+      _this.lightCutoffDistanceNode = new _FloatNode.default(0);
+      _this.lightDecayExponentNode = new _FloatNode.default(0);
+      return _this;
+    }
+
+    _createClass(LightNode, [{
+      key: "update",
+      value: function
+        /* frame */
+      update() {
+        this.colorNode.value.copy(this.light.color).multiplyScalar(this.light.intensity);
+        this.lightCutoffDistanceNode.value = this.light.distance;
+        this.lightDecayExponentNode.value = this.light.decay;
+      }
+    }, {
+      key: "generate",
+      value: function generate(builder) {
+        var lightPositionView = new _Object3DNode.default(_Object3DNode.default.VIEW_POSITION);
+        var positionView = new _PositionNode.default(_PositionNode.default.VIEW);
+        var lVector = new _OperatorNode.default('-', lightPositionView, positionView);
+        var lightDirection = new _MathNode.default(_MathNode.default.NORMALIZE, lVector);
+        var lightDistance = new _MathNode.default(_MathNode.default.LENGTH, lVector);
+        var lightAttenuation = (0, _BSDFs.getDistanceAttenuation)({
+          lightDistance: lightDistance,
+          cutoffDistance: this.lightCutoffDistanceNode,
+          decayExponent: this.lightDecayExponentNode
+        });
+        var lightColor = new _OperatorNode.default('*', this.colorNode, lightAttenuation);
+        lightPositionView.object3d = this.light;
+        var lightingModelFunction = builder.context.lightingModel;
+
+        if (lightingModelFunction !== undefined) {
+          var directDiffuse = builder.context.directDiffuse;
+          var directSpecular = builder.context.directSpecular;
+          lightingModelFunction({
+            lightDirection: lightDirection,
+            lightColor: lightColor,
+            directDiffuse: directDiffuse,
+            directSpecular: directSpecular
+          }, builder);
+        }
+      }
+    }]);
+
+    return LightNode;
+  }(_Node2.default);
+
+  var _default = LightNode;
+  _exports.default = _default;
+});

data/lib-opal/js_wrap/three/renderers/nodes/lights/LightsNode.js

@@ -0,0 +1,117 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/Node.js", "./LightNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/Node.js"), require("./LightNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.Node, global.LightNode);
+    global.LightsNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _Node2, _LightNode) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _Node2 = _interopRequireDefault(_Node2);
+  _LightNode = _interopRequireDefault(_LightNode);
+
+  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 _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 _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 _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 LightsNode = /*#__PURE__*/function (_Node) {
+    _inherits(LightsNode, _Node);
+
+    var _super = _createSuper(LightsNode);
+
+    function LightsNode() {
+      var _this;
+
+      var lightNodes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+
+      _classCallCheck(this, LightsNode);
+
+      _this = _super.call(this, 'vec3');
+      _this.lightNodes = lightNodes;
+      return _this;
+    }
+
+    _createClass(LightsNode, [{
+      key: "generate",
+      value: function generate(builder) {
+        var lightNodes = this.lightNodes;
+
+        var _iterator = _createForOfIteratorHelper(lightNodes),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var lightNode = _step.value;
+            lightNode.build(builder);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+
+        return 'vec3( 0.0 )';
+      }
+    }], [{
+      key: "fromLights",
+      value: function fromLights(lights) {
+        var lightNodes = [];
+
+        var _iterator2 = _createForOfIteratorHelper(lights),
+            _step2;
+
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var light = _step2.value;
+            lightNodes.push(new _LightNode.default(light));
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+
+        return new LightsNode(lightNodes);
+      }
+    }]);
+
+    return LightsNode;
+  }(_Node2.default);
+
+  var _default = LightsNode;
+  _exports.default = _default;
+});

data/lib-opal/js_wrap/three/renderers/nodes/materials/LineBasicNodeMaterial.js

@@ -0,0 +1,82 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.LineBasicNodeMaterial = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  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 LineBasicNodeMaterial = /*#__PURE__*/function (_LineBasicMaterial) {
+    _inherits(LineBasicNodeMaterial, _LineBasicMaterial);
+
+    var _super = _createSuper(LineBasicNodeMaterial);
+
+    function LineBasicNodeMaterial(parameters) {
+      var _this;
+
+      _classCallCheck(this, LineBasicNodeMaterial);
+
+      _this = _super.call(this, parameters);
+      _this.colorNode = null;
+      _this.opacityNode = null;
+      _this.alphaTestNode = null;
+      _this.lightNode = null;
+      _this.positionNode = null;
+      return _this;
+    }
+
+    _createClass(LineBasicNodeMaterial, [{
+      key: "copy",
+      value: function copy(source) {
+        this.colorNode = source.colorNode;
+        this.opacityNode = source.opacityNode;
+        this.alphaTestNode = source.alphaTestNode;
+        this.lightNode = source.lightNode;
+        this.positionNode = source.positionNode;
+        return _get(_getPrototypeOf(LineBasicNodeMaterial.prototype), "copy", this).call(this, source);
+      }
+    }]);
+
+    return LineBasicNodeMaterial;
+  }(_three.LineBasicMaterial);
+
+  LineBasicNodeMaterial.prototype.isNodeMaterial = true;
+  var _default = LineBasicNodeMaterial;
+  _exports.default = _default;
+});

data/lib-opal/js_wrap/three/renderers/nodes/materials/Materials.js

@@ -0,0 +1,49 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./LineBasicNodeMaterial.js", "./MeshBasicNodeMaterial.js", "./MeshStandardNodeMaterial.js", "./PointsNodeMaterial.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./LineBasicNodeMaterial.js"), require("./MeshBasicNodeMaterial.js"), require("./MeshStandardNodeMaterial.js"), require("./PointsNodeMaterial.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.LineBasicNodeMaterial, global.MeshBasicNodeMaterial, global.MeshStandardNodeMaterial, global.PointsNodeMaterial);
+    global.Materials = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _LineBasicNodeMaterial, _MeshBasicNodeMaterial, _MeshStandardNodeMaterial, _PointsNodeMaterial) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(_exports, "LineBasicNodeMaterial", {
+    enumerable: true,
+    get: function get() {
+      return _LineBasicNodeMaterial.default;
+    }
+  });
+  Object.defineProperty(_exports, "MeshBasicNodeMaterial", {
+    enumerable: true,
+    get: function get() {
+      return _MeshBasicNodeMaterial.default;
+    }
+  });
+  Object.defineProperty(_exports, "MeshStandardNodeMaterial", {
+    enumerable: true,
+    get: function get() {
+      return _MeshStandardNodeMaterial.default;
+    }
+  });
+  Object.defineProperty(_exports, "PointsNodeMaterial", {
+    enumerable: true,
+    get: function get() {
+      return _PointsNodeMaterial.default;
+    }
+  });
+  _LineBasicNodeMaterial = _interopRequireDefault(_LineBasicNodeMaterial);
+  _MeshBasicNodeMaterial = _interopRequireDefault(_MeshBasicNodeMaterial);
+  _MeshStandardNodeMaterial = _interopRequireDefault(_MeshStandardNodeMaterial);
+  _PointsNodeMaterial = _interopRequireDefault(_PointsNodeMaterial);
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+});