opal-js_wrap-three 0.1.1 → 0.1.2

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

@@ -0,0 +1,70 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./constants.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./constants.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.constants);
+    global.NodeFrame = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _constants) {
+  "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; }
+
+  var NodeFrame = /*#__PURE__*/function () {
+    function NodeFrame() {
+      _classCallCheck(this, NodeFrame);
+
+      this.time = 0;
+      this.deltaTime = 0;
+      this.frameId = 0;
+      this.startTime = null;
+      this.updateMap = new WeakMap();
+      this.renderer = null;
+      this.material = null;
+      this.camera = null;
+      this.object = null;
+    }
+
+    _createClass(NodeFrame, [{
+      key: "updateNode",
+      value: function updateNode(node) {
+        if (node.updateType === _constants.NodeUpdateType.Frame) {
+          if (this.updateMap.get(node) !== this.frameId) {
+            this.updateMap.set(node, this.frameId);
+            node.update(this);
+          }
+        } else if (node.updateType === _constants.NodeUpdateType.Object) {
+          node.update(this);
+        }
+      }
+    }, {
+      key: "update",
+      value: function update() {
+        this.frameId++;
+        if (this.lastTime === undefined) this.lastTime = performance.now();
+        this.deltaTime = (performance.now() - this.lastTime) / 1000;
+        this.lastTime = performance.now();
+        this.time += this.deltaTime;
+      }
+    }]);
+
+    return NodeFrame;
+  }();
+
+  var _default = NodeFrame;
+  _exports.default = _default;
+});

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

@@ -0,0 +1,55 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports);
+    global.NodeFunction = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports) {
+  "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; }
+
+  var NodeFunction = /*#__PURE__*/function () {
+    function NodeFunction(type, inputs) {
+      var name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+      var presicion = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
+
+      _classCallCheck(this, NodeFunction);
+
+      this.type = type;
+      this.inputs = inputs;
+      this.name = name;
+      this.presicion = presicion;
+    }
+
+    _createClass(NodeFunction, [{
+      key: "getCode",
+      value: function
+        /*name = this.name*/
+      getCode() {
+        console.warn('Abstract function.');
+      }
+    }]);
+
+    return NodeFunction;
+  }();
+
+  NodeFunction.isNodeFunction = true;
+  var _default = NodeFunction;
+  _exports.default = _default;
+});

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

@@ -0,0 +1,44 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports);
+    global.NodeFunctionInput = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+
+  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"); } }
+
+  var NodeFunctionInput = /*#__PURE__*/_createClass(function NodeFunctionInput(type, name) {
+    var count = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    var qualifier = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
+    var isConst = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+
+    _classCallCheck(this, NodeFunctionInput);
+
+    this.type = type;
+    this.name = name;
+    this.count = count;
+    this.qualifier = qualifier;
+    this.isConst = isConst;
+  });
+
+  NodeFunctionInput.isNodeFunctionInput = true;
+  var _default = NodeFunctionInput;
+  _exports.default = _default;
+});

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

@@ -0,0 +1,117 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports);
+    global.NodeKeywords = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+
+  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; }
+
+  var NodeKeywords = /*#__PURE__*/function () {
+    function NodeKeywords() {
+      _classCallCheck(this, NodeKeywords);
+
+      this.keywords = [];
+      this.nodes = [];
+      this.keywordsCallback = {};
+    }
+
+    _createClass(NodeKeywords, [{
+      key: "getNode",
+      value: function getNode(name) {
+        var node = this.nodes[name];
+
+        if (node === undefined && this.keywordsCallback[name] !== undefined) {
+          node = this.keywordsCallback[name](name);
+          this.nodes[name] = node;
+        }
+
+        return node;
+      }
+    }, {
+      key: "addKeyword",
+      value: function addKeyword(name, callback) {
+        this.keywords.push(name);
+        this.keywordsCallback[name] = callback;
+        return this;
+      }
+    }, {
+      key: "parse",
+      value: function parse(code) {
+        var keywordNames = this.keywords;
+        var regExp = new RegExp("\\b".concat(keywordNames.join('\\b|\\b'), "\\b"), 'g');
+        var codeKeywords = code.match(regExp);
+        var keywordNodes = [];
+
+        if (codeKeywords !== null) {
+          var _iterator = _createForOfIteratorHelper(codeKeywords),
+              _step;
+
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var keyword = _step.value;
+              var node = this.getNode(keyword);
+
+              if (node !== undefined && keywordNodes.indexOf(node) === -1) {
+                keywordNodes.push(node);
+              }
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+        }
+
+        return keywordNodes;
+      }
+    }, {
+      key: "include",
+      value: function include(builder, code) {
+        var keywordNodes = this.parse(code);
+
+        var _iterator2 = _createForOfIteratorHelper(keywordNodes),
+            _step2;
+
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var keywordNode = _step2.value;
+            keywordNode.build(builder);
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      }
+    }]);
+
+    return NodeKeywords;
+  }();
+
+  var _default = NodeKeywords;
+  _exports.default = _default;
+});

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

@@ -0,0 +1,46 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports);
+    global.NodeParser = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports) {
+  "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; }
+
+  var NodeParser = /*#__PURE__*/function () {
+    function NodeParser() {
+      _classCallCheck(this, NodeParser);
+    }
+
+    _createClass(NodeParser, [{
+      key: "parseFunction",
+      value: function
+        /*source*/
+      parseFunction() {
+        console.warn('Abstract function.');
+      }
+    }]);
+
+    return NodeParser;
+  }();
+
+  var _default = NodeParser;
+  _exports.default = _default;
+});

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

@@ -0,0 +1,55 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports);
+    global.NodeUniform = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports) {
+  "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; }
+
+  var NodeUniform = /*#__PURE__*/function () {
+    function NodeUniform(name, type, node) {
+      var needsUpdate = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;
+
+      _classCallCheck(this, NodeUniform);
+
+      this.name = name;
+      this.type = type;
+      this.node = node;
+      this.needsUpdate = needsUpdate;
+    }
+
+    _createClass(NodeUniform, [{
+      key: "value",
+      get: function get() {
+        return this.node.value;
+      },
+      set: function set(val) {
+        this.node.value = val;
+      }
+    }]);
+
+    return NodeUniform;
+  }();
+
+  NodeUniform.prototype.isNodeUniform = true;
+  var _default = NodeUniform;
+  _exports.default = _default;
+});

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

@@ -0,0 +1,37 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports);
+    global.NodeVar = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+
+  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"); } }
+
+  var NodeVar = /*#__PURE__*/_createClass(function NodeVar(name, type) {
+    _classCallCheck(this, NodeVar);
+
+    this.name = name;
+    this.type = type;
+  });
+
+  NodeVar.prototype.isNodeVar = true;
+  var _default = NodeVar;
+  _exports.default = _default;
+});

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

@@ -0,0 +1,37 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports);
+    global.NodeVary = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+
+  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"); } }
+
+  var NodeVary = /*#__PURE__*/_createClass(function NodeVary(name, type) {
+    _classCallCheck(this, NodeVary);
+
+    this.name = name;
+    this.type = type;
+  });
+
+  NodeVary.prototype.isNodeVary = true;
+  var _default = NodeVary;
+  _exports.default = _default;
+});

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

@@ -0,0 +1,90 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./Node.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./Node.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.Node);
+    global.PropertyNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _Node2) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _Node2 = _interopRequireDefault(_Node2);
+
+  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 PropertyNode = /*#__PURE__*/function (_Node) {
+    _inherits(PropertyNode, _Node);
+
+    var _super = _createSuper(PropertyNode);
+
+    function PropertyNode() {
+      var _this;
+
+      var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      var nodeType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'vec4';
+
+      _classCallCheck(this, PropertyNode);
+
+      _this = _super.call(this, nodeType);
+      _this.name = name;
+      return _this;
+    }
+
+    _createClass(PropertyNode, [{
+      key: "getHash",
+      value: function getHash(builder) {
+        return this.name || _get(_getPrototypeOf(PropertyNode.prototype), "getHash", this).call(this, builder);
+      }
+    }, {
+      key: "generate",
+      value: function generate(builder) {
+        var nodeVary = builder.getVarFromNode(this, this.getNodeType(builder));
+        var name = this.name;
+
+        if (name !== null) {
+          nodeVary.name = name;
+        }
+
+        return builder.getPropertyName(nodeVary);
+      }
+    }]);
+
+    return PropertyNode;
+  }(_Node2.default);
+
+  var _default = PropertyNode;
+  _exports.default = _default;
+});

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

@@ -0,0 +1,89 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./Node.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./Node.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.Node);
+    global.TempNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _Node2) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _Node2 = _interopRequireDefault(_Node2);
+
+  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 TempNode = /*#__PURE__*/function (_Node) {
+    _inherits(TempNode, _Node);
+
+    var _super = _createSuper(TempNode);
+
+    function TempNode(type) {
+      _classCallCheck(this, TempNode);
+
+      return _super.call(this, type);
+    }
+
+    _createClass(TempNode, [{
+      key: "build",
+      value: function build(builder, output) {
+        var type = builder.getVectorType(this.getNodeType(builder, output));
+
+        if (builder.context.temp !== false && type !== 'void ' && output !== 'void') {
+          var nodeData = builder.getDataFromNode(this);
+
+          if (nodeData.snippet === undefined) {
+            var snippet = _get(_getPrototypeOf(TempNode.prototype), "build", this).call(this, builder, type);
+
+            var nodeVar = builder.getVarFromNode(this, type);
+            var propertyName = builder.getPropertyName(nodeVar);
+            builder.addFlowCode("".concat(propertyName, " = ").concat(snippet));
+            nodeData.snippet = snippet;
+            nodeData.propertyName = propertyName;
+          }
+
+          return builder.format(nodeData.propertyName, type, output);
+        }
+
+        return _get(_getPrototypeOf(TempNode.prototype), "build", this).call(this, builder, output);
+      }
+    }]);
+
+    return TempNode;
+  }(_Node2.default);
+
+  var _default = TempNode;
+  _exports.default = _default;
+});