opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/nodes/inputs/RTTNode.js

@@ -0,0 +1,164 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../core/NodeBuilder.js", "../materials/NodeMaterial.js", "./TextureNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../core/NodeBuilder.js"), require("../materials/NodeMaterial.js"), require("./TextureNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.NodeBuilder, global.NodeMaterial, global.TextureNode);
+    global.RTTNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _NodeBuilder, _NodeMaterial, _TextureNode2) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.RTTNode = 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 RTTNode = /*#__PURE__*/function (_TextureNode) {
+    _inherits(RTTNode, _TextureNode);
+
+    var _super = _createSuper(RTTNode);
+
+    function RTTNode(width, height, input) {
+      var _this;
+
+      var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+
+      _classCallCheck(this, RTTNode);
+
+      var renderTarget = new _three.WebGLRenderTarget(width, height, options);
+      _this = _super.call(this, renderTarget.texture);
+      _this.input = input;
+      _this.clear = options.clear !== undefined ? options.clear : true;
+      _this.renderTarget = renderTarget;
+      _this.material = new _NodeMaterial.NodeMaterial();
+      _this.camera = new _three.OrthographicCamera(-1, 1, 1, -1, 0, 1);
+      _this.scene = new _three.Scene();
+      _this.quad = new _three.Mesh(new _three.PlaneGeometry(2, 2), _this.material);
+      _this.quad.frustumCulled = false; // Avoid getting clipped
+
+      _this.scene.add(_this.quad);
+
+      _this.render = true;
+      return _this;
+    }
+
+    _createClass(RTTNode, [{
+      key: "build",
+      value: function build(builder, output, uuid) {
+        var rttBuilder = new _NodeBuilder.NodeBuilder();
+        rttBuilder.nodes = builder.nodes;
+        rttBuilder.updaters = builder.updaters;
+        this.material.fragment.value = this.input;
+        this.material.build({
+          builder: rttBuilder
+        });
+        return _get(_getPrototypeOf(RTTNode.prototype), "build", this).call(this, builder, output, uuid);
+      }
+    }, {
+      key: "updateFramesaveTo",
+      value: function updateFramesaveTo(frame) {
+        this.saveTo.render = false;
+
+        if (this.saveTo !== this.saveToCurrent) {
+          if (this.saveToMaterial) this.saveToMaterial.dispose();
+          var material = new _NodeMaterial.NodeMaterial();
+          material.fragment.value = this;
+          material.build();
+          var scene = new _three.Scene();
+          var quad = new _three.Mesh(new _three.PlaneGeometry(2, 2), material);
+          quad.frustumCulled = false; // Avoid getting clipped
+
+          scene.add(quad);
+          this.saveToScene = scene;
+          this.saveToMaterial = material;
+        }
+
+        this.saveToCurrent = this.saveTo;
+        frame.renderer.setRenderTarget(this.saveTo.renderTarget);
+        if (this.saveTo.clear) frame.renderer.clear();
+        frame.renderer.render(this.saveToScene, this.camera);
+      }
+    }, {
+      key: "updateFrame",
+      value: function updateFrame(frame) {
+        if (frame.renderer) {
+          // from the second frame
+          if (this.saveTo && this.saveTo.render === false) {
+            this.updateFramesaveTo(frame);
+          }
+
+          if (this.render) {
+            if (this.material.uniforms.renderTexture) {
+              this.material.uniforms.renderTexture.value = frame.renderTexture;
+            }
+
+            frame.renderer.setRenderTarget(this.renderTarget);
+            if (this.clear) frame.renderer.clear();
+            frame.renderer.render(this.scene, this.camera);
+          } // first frame
+
+
+          if (this.saveTo && this.saveTo.render === true) {
+            this.updateFramesaveTo(frame);
+          }
+        } else {
+          console.warn('RTTNode need a renderer in NodeFrame');
+        }
+      }
+    }, {
+      key: "copy",
+      value: function copy(source) {
+        _get(_getPrototypeOf(RTTNode.prototype), "copy", this).call(this, source);
+
+        this.saveTo = source.saveTo;
+        return this;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(meta) {
+        var data = this.getJSONNode(meta);
+
+        if (!data) {
+          data = _get(_getPrototypeOf(RTTNode.prototype), "toJSON", this).call(this, meta);
+          if (this.saveTo) data.saveTo = this.saveTo.toJSON(meta).uuid;
+        }
+
+        return data;
+      }
+    }]);
+
+    return RTTNode;
+  }(_TextureNode2.TextureNode);
+
+  _exports.RTTNode = RTTNode;
+  RTTNode.prototype.nodeType = 'RTT';
+});

data/lib-opal/js_wrap/three/nodes/inputs/ReflectorNode.js

@@ -0,0 +1,111 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/TempNode.js", "../core/InputNode.js", "../accessors/PositionNode.js", "../math/OperatorNode.js", "./TextureNode.js", "./Matrix4Node.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/TempNode.js"), require("../core/InputNode.js"), require("../accessors/PositionNode.js"), require("../math/OperatorNode.js"), require("./TextureNode.js"), require("./Matrix4Node.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.TempNode, global.InputNode, global.PositionNode, global.OperatorNode, global.TextureNode, global.Matrix4Node);
+    global.ReflectorNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _TempNode2, _InputNode, _PositionNode, _OperatorNode, _TextureNode, _Matrix4Node) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.ReflectorNode = 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 _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 ReflectorNode = /*#__PURE__*/function (_TempNode) {
+    _inherits(ReflectorNode, _TempNode);
+
+    var _super = _createSuper(ReflectorNode);
+
+    function ReflectorNode(mirror) {
+      var _this;
+
+      _classCallCheck(this, ReflectorNode);
+
+      _this = _super.call(this, 'v4');
+      if (mirror) _this.setMirror(mirror);
+      return _this;
+    }
+
+    _createClass(ReflectorNode, [{
+      key: "setMirror",
+      value: function setMirror(mirror) {
+        this.mirror = mirror;
+        this.textureMatrix = new _Matrix4Node.Matrix4Node(this.mirror.material.uniforms.textureMatrix.value);
+        this.localPosition = new _PositionNode.PositionNode(_PositionNode.PositionNode.LOCAL);
+        this.uv = new _OperatorNode.OperatorNode(this.textureMatrix, this.localPosition, _OperatorNode.OperatorNode.MUL);
+        this.uvResult = new _OperatorNode.OperatorNode(null, this.uv, _OperatorNode.OperatorNode.ADD);
+        this.texture = new _TextureNode.TextureNode(this.mirror.material.uniforms.tDiffuse.value, this.uv, null, true);
+      }
+    }, {
+      key: "generate",
+      value: function generate(builder, output) {
+        if (builder.isShader('fragment')) {
+          this.uvResult.a = this.offset;
+          this.texture.uv = this.offset ? this.uvResult : this.uv;
+
+          if (output === 'sampler2D') {
+            return this.texture.build(builder, output);
+          }
+
+          return builder.format(this.texture.build(builder, this.type), this.type, output);
+        } else {
+          console.warn('THREE.ReflectorNode is not compatible with ' + builder.shader + ' shader.');
+          return builder.format('vec4( 0.0 )', this.type, output);
+        }
+      }
+    }, {
+      key: "copy",
+      value: function copy(source) {
+        _InputNode.InputNode.prototype.copy.call(this, source);
+
+        this.scope.mirror = source.mirror;
+        return this;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(meta) {
+        var data = this.getJSONNode(meta);
+
+        if (!data) {
+          data = this.createJSONNode(meta);
+          data.mirror = this.mirror.uuid;
+          if (this.offset) data.offset = this.offset.toJSON(meta).uuid;
+        }
+
+        return data;
+      }
+    }]);
+
+    return ReflectorNode;
+  }(_TempNode2.TempNode);
+
+  _exports.ReflectorNode = ReflectorNode;
+  ReflectorNode.prototype.nodeType = 'Reflector';
+});

data/lib-opal/js_wrap/three/nodes/inputs/ScreenNode.js

@@ -0,0 +1,69 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/InputNode.js", "./TextureNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/InputNode.js"), require("./TextureNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.InputNode, global.TextureNode);
+    global.ScreenNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _InputNode, _TextureNode2) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.ScreenNode = 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 _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 ScreenNode = /*#__PURE__*/function (_TextureNode) {
+    _inherits(ScreenNode, _TextureNode);
+
+    var _super = _createSuper(ScreenNode);
+
+    function ScreenNode(uv) {
+      _classCallCheck(this, ScreenNode);
+
+      return _super.call(this, undefined, uv);
+    }
+
+    _createClass(ScreenNode, [{
+      key: "getUnique",
+      value: function getUnique() {
+        return true;
+      }
+    }, {
+      key: "getTexture",
+      value: function getTexture(builder, output) {
+        return _InputNode.InputNode.prototype.generate.call(this, builder, output, this.getUuid(), 't', 'renderTexture');
+      }
+    }]);
+
+    return ScreenNode;
+  }(_TextureNode2.TextureNode);
+
+  _exports.ScreenNode = ScreenNode;
+  ScreenNode.prototype.nodeType = 'Screen';
+});

data/lib-opal/js_wrap/three/nodes/inputs/TextureNode.js

@@ -0,0 +1,140 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/InputNode.js", "../accessors/UVNode.js", "../utils/ColorSpaceNode.js", "../core/ExpressionNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/InputNode.js"), require("../accessors/UVNode.js"), require("../utils/ColorSpaceNode.js"), require("../core/ExpressionNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.InputNode, global.UVNode, global.ColorSpaceNode, global.ExpressionNode);
+    global.TextureNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _InputNode2, _UVNode, _ColorSpaceNode, _ExpressionNode) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.TextureNode = 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 TextureNode = /*#__PURE__*/function (_InputNode) {
+    _inherits(TextureNode, _InputNode);
+
+    var _super = _createSuper(TextureNode);
+
+    function TextureNode(value, uv, bias, project) {
+      var _this;
+
+      _classCallCheck(this, TextureNode);
+
+      _this = _super.call(this, 'v4', {
+        shared: true
+      });
+      _this.value = value;
+      _this.uv = uv || new _UVNode.UVNode();
+      _this.bias = bias;
+      _this.project = project !== undefined ? project : false;
+      return _this;
+    }
+
+    _createClass(TextureNode, [{
+      key: "getTexture",
+      value: function getTexture(builder, output) {
+        return _get(_getPrototypeOf(TextureNode.prototype), "generate", this).call(this, builder, output, this.value.uuid, 't');
+      }
+    }, {
+      key: "generate",
+      value: function generate(builder, output) {
+        if (output === 'sampler2D') {
+          return this.getTexture(builder, output);
+        }
+
+        var tex = this.getTexture(builder, output),
+            uv = this.uv.build(builder, this.project ? 'v4' : 'v2');
+        var bias = this.bias ? this.bias.build(builder, 'f') : undefined;
+
+        if (bias === undefined && builder.context.bias) {
+          bias = builder.context.bias.setTexture(this).build(builder, 'f');
+        }
+
+        var method, code;
+        if (this.project) method = 'texture2DProj';else method = bias ? 'tex2DBias' : 'tex2D';
+        if (bias) code = method + '( ' + tex + ', ' + uv + ', ' + bias + ' )';else code = method + '( ' + tex + ', ' + uv + ' )'; // add a custom context for fix incompatibility with the core
+        // include ColorSpace function only for vertex shader (in fragment shader color space functions is added automatically by core)
+        // this should be removed in the future
+        // context.include is used to include or not functions if used FunctionNode
+        // context.ignoreCache =: not create temp variables nodeT0..9 to optimize the code
+
+        var context = {
+          include: builder.isShader('vertex'),
+          ignoreCache: true
+        };
+        var outputType = this.getType(builder);
+        builder.addContext(context);
+        this.colorSpace = this.colorSpace || new _ColorSpaceNode.ColorSpaceNode(new _ExpressionNode.ExpressionNode('', outputType));
+        this.colorSpace.fromDecoding(builder.getTextureEncodingFromMap(this.value));
+        this.colorSpace.input.parse(code);
+        code = this.colorSpace.build(builder, outputType); // end custom context
+
+        builder.removeContext();
+        return builder.format(code, outputType, output);
+      }
+    }, {
+      key: "copy",
+      value: function copy(source) {
+        _get(_getPrototypeOf(TextureNode.prototype), "copy", this).call(this, source);
+
+        if (source.value) this.value = source.value;
+        this.uv = source.uv;
+        if (source.bias) this.bias = source.bias;
+        if (source.project !== undefined) this.project = source.project;
+        return this;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(meta) {
+        var data = this.getJSONNode(meta);
+
+        if (!data) {
+          data = this.createJSONNode(meta);
+          if (this.value) data.value = this.value.uuid;
+          data.uv = this.uv.toJSON(meta).uuid;
+          data.project = this.project;
+          if (this.bias) data.bias = this.bias.toJSON(meta).uuid;
+        }
+
+        return data;
+      }
+    }]);
+
+    return TextureNode;
+  }(_InputNode2.InputNode);
+
+  _exports.TextureNode = TextureNode;
+  TextureNode.prototype.nodeType = 'Texture';
+});

data/lib-opal/js_wrap/three/nodes/inputs/Vector2Node.js

@@ -0,0 +1,98 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../core/InputNode.js", "../core/NodeUtils.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../core/InputNode.js"), require("../core/NodeUtils.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.InputNode, global.NodeUtils);
+    global.Vector2Node = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _InputNode2, _NodeUtils) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.Vector2Node = 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 Vector2Node = /*#__PURE__*/function (_InputNode) {
+    _inherits(Vector2Node, _InputNode);
+
+    var _super = _createSuper(Vector2Node);
+
+    function Vector2Node(x, y) {
+      var _this;
+
+      _classCallCheck(this, Vector2Node);
+
+      _this = _super.call(this, 'v2');
+      _this.value = x instanceof _three.Vector2 ? x : new _three.Vector2(x, y);
+      return _this;
+    }
+
+    _createClass(Vector2Node, [{
+      key: "generateReadonly",
+      value: function generateReadonly(builder, output, uuid, type
+      /*, ns, needsUpdate*/
+      ) {
+        return builder.format('vec2( ' + this.x + ', ' + this.y + ' )', type, output);
+      }
+    }, {
+      key: "copy",
+      value: function copy(source) {
+        _get(_getPrototypeOf(Vector2Node.prototype), "copy", this).call(this, source);
+
+        this.value.copy(source);
+        return this;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(meta) {
+        var data = this.getJSONNode(meta);
+
+        if (!data) {
+          data = this.createJSONNode(meta);
+          data.x = this.x;
+          data.y = this.y;
+          if (this.readonly === true) data.readonly = true;
+        }
+
+        return data;
+      }
+    }]);
+
+    return Vector2Node;
+  }(_InputNode2.InputNode);
+
+  _exports.Vector2Node = Vector2Node;
+  Vector2Node.prototype.nodeType = 'Vector2';
+
+  _NodeUtils.NodeUtils.addShortcuts(Vector2Node.prototype, 'value', ['x', 'y']);
+});