opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/nodes/utils/SpecularMIPLevelNode.js

@@ -0,0 +1,121 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/TempNode.js", "../core/FunctionNode.js", "./MaxMIPLevelNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/TempNode.js"), require("../core/FunctionNode.js"), require("./MaxMIPLevelNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.TempNode, global.FunctionNode, global.MaxMIPLevelNode);
+    global.SpecularMIPLevelNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _TempNode2, _FunctionNode, _MaxMIPLevelNode) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.SpecularMIPLevelNode = 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 SpecularMIPLevelNode = /*#__PURE__*/function (_TempNode) {
+    _inherits(SpecularMIPLevelNode, _TempNode);
+
+    var _super = _createSuper(SpecularMIPLevelNode);
+
+    function SpecularMIPLevelNode(roughness, texture) {
+      var _this;
+
+      _classCallCheck(this, SpecularMIPLevelNode);
+
+      _this = _super.call(this, 'f');
+      _this.roughness = roughness;
+      _this.texture = texture;
+      _this.maxMIPLevel = undefined;
+      return _this;
+    }
+
+    _createClass(SpecularMIPLevelNode, [{
+      key: "setTexture",
+      value: function setTexture(texture) {
+        this.texture = texture;
+        return this;
+      }
+    }, {
+      key: "generate",
+      value: function generate(builder, output) {
+        if (builder.isShader('fragment')) {
+          this.maxMIPLevel = this.maxMIPLevel || new _MaxMIPLevelNode.MaxMIPLevelNode();
+          this.maxMIPLevel.texture = this.texture;
+          var getSpecularMIPLevel = builder.include(SpecularMIPLevelNode.Nodes.getSpecularMIPLevel);
+          return builder.format(getSpecularMIPLevel + '( ' + this.roughness.build(builder, 'f') + ', ' + this.maxMIPLevel.build(builder, 'f') + ' )', this.type, output);
+        } else {
+          console.warn('THREE.SpecularMIPLevelNode is not compatible with ' + builder.shader + ' shader.');
+          return builder.format('0.0', this.type, output);
+        }
+      }
+    }, {
+      key: "copy",
+      value: function copy(source) {
+        _get(_getPrototypeOf(SpecularMIPLevelNode.prototype), "copy", this).call(this, source);
+
+        this.texture = source.texture;
+        this.roughness = source.roughness;
+        return this;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(meta) {
+        var data = this.getJSONNode(meta);
+
+        if (!data) {
+          data = this.createJSONNode(meta);
+          data.texture = this.texture;
+          data.roughness = this.roughness;
+        }
+
+        return data;
+      }
+    }]);
+
+    return SpecularMIPLevelNode;
+  }(_TempNode2.TempNode);
+
+  _exports.SpecularMIPLevelNode = SpecularMIPLevelNode;
+
+  SpecularMIPLevelNode.Nodes = function () {
+    // taken from here: http://casual-effects.blogspot.ca/2011/08/plausible-environment-lighting-in-two.html
+    var getSpecularMIPLevel = new _FunctionNode.FunctionNode(
+    /* glsl */
+    "\n\n\t\tfloat getSpecularMIPLevel( const in float roughness, const in float maxMIPLevelScalar ) {\n\n\t\t\tfloat sigma = PI * roughness * roughness / ( 1.0 + roughness );\n\t\t\tfloat desiredMIPLevel = maxMIPLevelScalar + log2( sigma );\n\n\t\t\treturn clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );\n\n\t\t}");
+    return {
+      getSpecularMIPLevel: getSpecularMIPLevel
+    };
+  }();
+
+  SpecularMIPLevelNode.prototype.nodeType = 'SpecularMIPLevel';
+});

data/lib-opal/js_wrap/three/nodes/utils/SubSlotNode.js

@@ -0,0 +1,112 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/TempNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/TempNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.TempNode);
+    global.SubSlotNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _TempNode2) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.SubSlotNode = 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 SubSlotNode = /*#__PURE__*/function (_TempNode) {
+    _inherits(SubSlotNode, _TempNode);
+
+    var _super = _createSuper(SubSlotNode);
+
+    function SubSlotNode(slots) {
+      var _this;
+
+      _classCallCheck(this, SubSlotNode);
+
+      _this = _super.call(this);
+      _this.slots = slots || {};
+      return _this;
+    }
+
+    _createClass(SubSlotNode, [{
+      key: "getType",
+      value: function getType(builder, output) {
+        return output;
+      }
+    }, {
+      key: "generate",
+      value: function generate(builder, output) {
+        if (this.slots[builder.slot]) {
+          return this.slots[builder.slot].build(builder, output);
+        }
+
+        return builder.format('0.0', 'f', output);
+      }
+    }, {
+      key: "copy",
+      value: function copy(source) {
+        _get(_getPrototypeOf(SubSlotNode.prototype), "copy", this).call(this, source);
+
+        for (var prop in source.slots) {
+          this.slots[prop] = source.slots[prop];
+        }
+
+        return this;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(meta) {
+        var data = this.getJSONNode(meta);
+
+        if (!data) {
+          data = this.createJSONNode(meta);
+          data.slots = {};
+
+          for (var prop in this.slots) {
+            var slot = this.slots[prop];
+
+            if (slot) {
+              data.slots[prop] = slot.toJSON(meta).uuid;
+            }
+          }
+        }
+
+        return data;
+      }
+    }]);
+
+    return SubSlotNode;
+  }(_TempNode2.TempNode);
+
+  _exports.SubSlotNode = SubSlotNode;
+  SubSlotNode.prototype.nodeType = 'SubSlot';
+});

data/lib-opal/js_wrap/three/nodes/utils/SwitchNode.js

@@ -0,0 +1,129 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/Node.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/Node.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.Node);
+    global.SwitchNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _Node2) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.SwitchNode = 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 SwitchNode = /*#__PURE__*/function (_Node) {
+    _inherits(SwitchNode, _Node);
+
+    var _super = _createSuper(SwitchNode);
+
+    function SwitchNode(node, components) {
+      var _this;
+
+      _classCallCheck(this, SwitchNode);
+
+      _this = _super.call(this);
+      _this.node = node;
+      _this.components = components || 'x';
+      return _this;
+    }
+
+    _createClass(SwitchNode, [{
+      key: "getType",
+      value: function getType(builder) {
+        return builder.getTypeFromLength(this.components.length);
+      }
+    }, {
+      key: "generate",
+      value: function generate(builder, output) {
+        var type = this.node.getType(builder),
+            inputLength = builder.getTypeLength(type) - 1;
+        var node = this.node.build(builder, type);
+
+        if (inputLength > 0) {
+          // get max length
+          var outputLength = 0;
+          var components = builder.colorToVectorProperties(this.components);
+          var i;
+          var len = components.length;
+
+          for (i = 0; i < len; i++) {
+            outputLength = Math.max(outputLength, builder.getIndexByElement(components.charAt(i)));
+          }
+
+          if (outputLength > inputLength) outputLength = inputLength; // split
+
+          node += '.';
+
+          for (i = 0; i < len; i++) {
+            var idx = builder.getIndexByElement(components.charAt(i));
+            if (idx > outputLength) idx = outputLength;
+            node += builder.getElementByIndex(idx);
+          }
+
+          return builder.format(node, this.getType(builder), output);
+        } else {
+          // join
+          return builder.format(node, type, output);
+        }
+      }
+    }, {
+      key: "copy",
+      value: function copy(source) {
+        _get(_getPrototypeOf(SwitchNode.prototype), "copy", this).call(this, source);
+
+        this.node = source.node;
+        this.components = source.components;
+        return this;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(meta) {
+        var data = this.getJSONNode(meta);
+
+        if (!data) {
+          data = this.createJSONNode(meta);
+          data.node = this.node.toJSON(meta).uuid;
+          data.components = this.components;
+        }
+
+        return data;
+      }
+    }]);
+
+    return SwitchNode;
+  }(_Node2.Node);
+
+  _exports.SwitchNode = SwitchNode;
+  SwitchNode.prototype.nodeType = 'Switch';
+});

data/lib-opal/js_wrap/three/nodes/utils/TimerNode.js

@@ -0,0 +1,126 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../inputs/FloatNode.js", "../core/NodeLib.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../inputs/FloatNode.js"), require("../core/NodeLib.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.FloatNode, global.NodeLib);
+    global.TimerNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _FloatNode2, _NodeLib) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.TimerNode = 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 TimerNode = /*#__PURE__*/function (_FloatNode) {
+    _inherits(TimerNode, _FloatNode);
+
+    var _super = _createSuper(TimerNode);
+
+    function TimerNode(scale, scope, timeScale) {
+      var _this;
+
+      _classCallCheck(this, TimerNode);
+
+      _this = _super.call(this);
+      _this.scale = scale !== undefined ? scale : 1;
+      _this.scope = scope || TimerNode.GLOBAL;
+      _this.timeScale = timeScale !== undefined ? timeScale : scale !== undefined;
+      return _this;
+    }
+
+    _createClass(TimerNode, [{
+      key: "getReadonly",
+      value: function getReadonly() {
+        // never use TimerNode as readonly but aways as "uniform"
+        return false;
+      }
+    }, {
+      key: "getUnique",
+      value: function getUnique() {
+        // share TimerNode "uniform" input if is used on more time with others TimerNode
+        return this.timeScale && (this.scope === TimerNode.GLOBAL || this.scope === TimerNode.DELTA);
+      }
+    }, {
+      key: "updateFrame",
+      value: function updateFrame(frame) {
+        var scale = this.timeScale ? this.scale : 1;
+
+        switch (this.scope) {
+          case TimerNode.LOCAL:
+            this.value += frame.delta * scale;
+            break;
+
+          case TimerNode.DELTA:
+            this.value = frame.delta * scale;
+            break;
+
+          default:
+            this.value = frame.time * scale;
+        }
+      }
+    }, {
+      key: "copy",
+      value: function copy(source) {
+        _get(_getPrototypeOf(TimerNode.prototype), "copy", this).call(this, source);
+
+        this.scope = source.scope;
+        this.scale = source.scale;
+        this.timeScale = source.timeScale;
+        return this;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(meta) {
+        var data = _get(_getPrototypeOf(TimerNode.prototype), "toJSON", this).call(this, meta);
+
+        data.scope = this.scope;
+        data.scale = this.scale;
+        data.timeScale = this.timeScale;
+        return data;
+      }
+    }]);
+
+    return TimerNode;
+  }(_FloatNode2.FloatNode);
+
+  _exports.TimerNode = TimerNode;
+  TimerNode.GLOBAL = 'global';
+  TimerNode.LOCAL = 'local';
+  TimerNode.DELTA = 'delta';
+  TimerNode.prototype.nodeType = 'Timer';
+
+  _NodeLib.NodeLib.addKeyword('time', function () {
+    return new TimerNode();
+  });
+});

data/lib-opal/js_wrap/three/nodes/utils/UVTransformNode.js

@@ -0,0 +1,104 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/ExpressionNode.js", "../inputs/Matrix3Node.js", "../accessors/UVNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/ExpressionNode.js"), require("../inputs/Matrix3Node.js"), require("../accessors/UVNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.ExpressionNode, global.Matrix3Node, global.UVNode);
+    global.UVTransformNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _ExpressionNode2, _Matrix3Node, _UVNode) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.UVTransformNode = 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 UVTransformNode = /*#__PURE__*/function (_ExpressionNode) {
+    _inherits(UVTransformNode, _ExpressionNode);
+
+    var _super = _createSuper(UVTransformNode);
+
+    function UVTransformNode(uv, position) {
+      var _this;
+
+      _classCallCheck(this, UVTransformNode);
+
+      _this = _super.call(this, '( uvTransform * vec3( uvNode, 1 ) ).xy', 'vec2');
+      _this.uv = uv || new _UVNode.UVNode();
+      _this.position = position || new _Matrix3Node.Matrix3Node();
+      return _this;
+    }
+
+    _createClass(UVTransformNode, [{
+      key: "generate",
+      value: function generate(builder, output) {
+        this.keywords['uvNode'] = this.uv;
+        this.keywords['uvTransform'] = this.position;
+        return _get(_getPrototypeOf(UVTransformNode.prototype), "generate", this).call(this, builder, output);
+      }
+    }, {
+      key: "setUvTransform",
+      value: function setUvTransform(tx, ty, sx, sy, rotation, cx, cy) {
+        cx = cx !== undefined ? cx : .5;
+        cy = cy !== undefined ? cy : .5;
+        this.position.value.setUvTransform(tx, ty, sx, sy, rotation, cx, cy);
+      }
+    }, {
+      key: "copy",
+      value: function copy(source) {
+        _get(_getPrototypeOf(UVTransformNode.prototype), "copy", this).call(this, source);
+
+        this.uv = source.uv;
+        this.position = source.position;
+        return this;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(meta) {
+        var data = this.getJSONNode(meta);
+
+        if (!data) {
+          data = this.createJSONNode(meta);
+          data.uv = this.uv.toJSON(meta).uuid;
+          data.position = this.position.toJSON(meta).uuid;
+        }
+
+        return data;
+      }
+    }]);
+
+    return UVTransformNode;
+  }(_ExpressionNode2.ExpressionNode);
+
+  _exports.UVTransformNode = UVTransformNode;
+  UVTransformNode.prototype.nodeType = 'UVTransform';
+});