opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/nodes/math/MathNode.js

@@ -0,0 +1,266 @@
+(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.MathNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _TempNode2) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.MathNode = 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 MathNode = /*#__PURE__*/function (_TempNode) {
+    _inherits(MathNode, _TempNode);
+
+    var _super = _createSuper(MathNode);
+
+    function MathNode(a, bOrMethod, cOrMethod, method) {
+      var _this;
+
+      _classCallCheck(this, MathNode);
+
+      _this = _super.call(this);
+      _this.a = a;
+      typeof bOrMethod !== 'string' ? _this.b = bOrMethod : method = bOrMethod;
+      typeof cOrMethod !== 'string' ? _this.c = cOrMethod : method = cOrMethod;
+      _this.method = method;
+      return _this;
+    }
+
+    _createClass(MathNode, [{
+      key: "getNumInputs",
+      value: function
+        /*builder*/
+      getNumInputs() {
+        switch (this.method) {
+          case MathNode.MIX:
+          case MathNode.CLAMP:
+          case MathNode.REFRACT:
+          case MathNode.SMOOTHSTEP:
+          case MathNode.FACEFORWARD:
+            return 3;
+
+          case MathNode.MIN:
+          case MathNode.MAX:
+          case MathNode.MOD:
+          case MathNode.STEP:
+          case MathNode.REFLECT:
+          case MathNode.DISTANCE:
+          case MathNode.DOT:
+          case MathNode.CROSS:
+          case MathNode.POW:
+            return 2;
+
+          default:
+            return 1;
+        }
+      }
+    }, {
+      key: "getInputType",
+      value: function getInputType(builder) {
+        var a = builder.getTypeLength(this.a.getType(builder));
+        var b = this.b ? builder.getTypeLength(this.b.getType(builder)) : 0;
+        var c = this.c ? builder.getTypeLength(this.c.getType(builder)) : 0;
+
+        if (a > b && a > c) {
+          return this.a.getType(builder);
+        } else if (b > c) {
+          return this.b.getType(builder);
+        }
+
+        return this.c.getType(builder);
+      }
+    }, {
+      key: "getType",
+      value: function getType(builder) {
+        switch (this.method) {
+          case MathNode.LENGTH:
+          case MathNode.DISTANCE:
+          case MathNode.DOT:
+            return 'f';
+
+          case MathNode.CROSS:
+            return 'v3';
+        }
+
+        return this.getInputType(builder);
+      }
+    }, {
+      key: "generate",
+      value: function generate(builder, output) {
+        var a, b, c;
+        var al = this.a ? builder.getTypeLength(this.a.getType(builder)) : 0,
+            bl = this.b ? builder.getTypeLength(this.b.getType(builder)) : 0,
+            cl = this.c ? builder.getTypeLength(this.c.getType(builder)) : 0,
+            inputType = this.getInputType(builder),
+            nodeType = this.getType(builder);
+
+        switch (this.method) {
+          // 1 input
+          case MathNode.NEGATE:
+            return builder.format('( -' + this.a.build(builder, inputType) + ' )', inputType, output);
+
+          case MathNode.INVERT:
+            return builder.format('( 1.0 - ' + this.a.build(builder, inputType) + ' )', inputType, output);
+          // 2 inputs
+
+          case MathNode.CROSS:
+            a = this.a.build(builder, 'v3');
+            b = this.b.build(builder, 'v3');
+            break;
+
+          case MathNode.STEP:
+            a = this.a.build(builder, al === 1 ? 'f' : inputType);
+            b = this.b.build(builder, inputType);
+            break;
+
+          case MathNode.MIN:
+          case MathNode.MAX:
+          case MathNode.MOD:
+            a = this.a.build(builder, inputType);
+            b = this.b.build(builder, bl === 1 ? 'f' : inputType);
+            break;
+          // 3 inputs
+
+          case MathNode.REFRACT:
+            a = this.a.build(builder, inputType);
+            b = this.b.build(builder, inputType);
+            c = this.c.build(builder, 'f');
+            break;
+
+          case MathNode.MIX:
+            a = this.a.build(builder, inputType);
+            b = this.b.build(builder, inputType);
+            c = this.c.build(builder, cl === 1 ? 'f' : inputType);
+            break;
+          // default
+
+          default:
+            a = this.a.build(builder, inputType);
+            if (this.b) b = this.b.build(builder, inputType);
+            if (this.c) c = this.c.build(builder, inputType);
+            break;
+        } // build function call
+
+
+        var params = [];
+        params.push(a);
+        if (b) params.push(b);
+        if (c) params.push(c);
+        var numInputs = this.getNumInputs(builder);
+
+        if (params.length !== numInputs) {
+          throw Error("Arguments not match used in \"".concat(this.method, "\". Require ").concat(numInputs, ", currently ").concat(params.length, "."));
+        }
+
+        return builder.format(this.method + '( ' + params.join(', ') + ' )', nodeType, output);
+      }
+    }, {
+      key: "copy",
+      value: function copy(source) {
+        _get(_getPrototypeOf(MathNode.prototype), "copy", this).call(this, source);
+
+        this.a = source.a;
+        this.b = source.b;
+        this.c = source.c;
+        this.method = source.method;
+        return this;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(meta) {
+        var data = this.getJSONNode(meta);
+
+        if (!data) {
+          data = this.createJSONNode(meta);
+          data.a = this.a.toJSON(meta).uuid;
+          if (this.b) data.b = this.b.toJSON(meta).uuid;
+          if (this.c) data.c = this.c.toJSON(meta).uuid;
+          data.method = this.method;
+        }
+
+        return data;
+      }
+    }]);
+
+    return MathNode;
+  }(_TempNode2.TempNode); // 1 input
+
+
+  _exports.MathNode = MathNode;
+  MathNode.RAD = 'radians';
+  MathNode.DEG = 'degrees';
+  MathNode.EXP = 'exp';
+  MathNode.EXP2 = 'exp2';
+  MathNode.LOG = 'log';
+  MathNode.LOG2 = 'log2';
+  MathNode.SQRT = 'sqrt';
+  MathNode.INV_SQRT = 'inversesqrt';
+  MathNode.FLOOR = 'floor';
+  MathNode.CEIL = 'ceil';
+  MathNode.NORMALIZE = 'normalize';
+  MathNode.FRACT = 'fract';
+  MathNode.SATURATE = 'saturate';
+  MathNode.SIN = 'sin';
+  MathNode.COS = 'cos';
+  MathNode.TAN = 'tan';
+  MathNode.ASIN = 'asin';
+  MathNode.ACOS = 'acos';
+  MathNode.ARCTAN = 'atan';
+  MathNode.ABS = 'abs';
+  MathNode.SIGN = 'sign';
+  MathNode.LENGTH = 'length';
+  MathNode.NEGATE = 'negate';
+  MathNode.INVERT = 'invert'; // 2 inputs
+
+  MathNode.MIN = 'min';
+  MathNode.MAX = 'max';
+  MathNode.MOD = 'mod';
+  MathNode.STEP = 'step';
+  MathNode.REFLECT = 'reflect';
+  MathNode.DISTANCE = 'distance';
+  MathNode.DOT = 'dot';
+  MathNode.CROSS = 'cross';
+  MathNode.POW = 'pow'; // 3 inputs
+
+  MathNode.MIX = 'mix';
+  MathNode.CLAMP = 'clamp';
+  MathNode.REFRACT = 'refract';
+  MathNode.SMOOTHSTEP = 'smoothstep';
+  MathNode.FACEFORWARD = 'faceforward';
+  MathNode.prototype.nodeType = 'Math';
+  MathNode.prototype.hashProperties = ['method'];
+});

data/lib-opal/js_wrap/three/nodes/math/OperatorNode.js

@@ -0,0 +1,120 @@
+(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.OperatorNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _TempNode2) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.OperatorNode = 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 OperatorNode = /*#__PURE__*/function (_TempNode) {
+    _inherits(OperatorNode, _TempNode);
+
+    var _super = _createSuper(OperatorNode);
+
+    function OperatorNode(a, b, op) {
+      var _this;
+
+      _classCallCheck(this, OperatorNode);
+
+      _this = _super.call(this);
+      _this.a = a;
+      _this.b = b;
+      _this.op = op;
+      return _this;
+    }
+
+    _createClass(OperatorNode, [{
+      key: "getType",
+      value: function getType(builder) {
+        var a = this.a.getType(builder),
+            b = this.b.getType(builder);
+
+        if (builder.isTypeMatrix(a)) {
+          return 'v4';
+        } else if (builder.getTypeLength(b) > builder.getTypeLength(a)) {
+          // use the greater length vector
+          return b;
+        }
+
+        return a;
+      }
+    }, {
+      key: "generate",
+      value: function generate(builder, output) {
+        var type = this.getType(builder);
+        var a = this.a.build(builder, type),
+            b = this.b.build(builder, type);
+        return builder.format('( ' + a + ' ' + this.op + ' ' + b + ' )', type, output);
+      }
+    }, {
+      key: "copy",
+      value: function copy(source) {
+        _get(_getPrototypeOf(OperatorNode.prototype), "copy", this).call(this, source);
+
+        this.a = source.a;
+        this.b = source.b;
+        this.op = source.op;
+        return this;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(meta) {
+        var data = this.getJSONNode(meta);
+
+        if (!data) {
+          data = this.createJSONNode(meta);
+          data.a = this.a.toJSON(meta).uuid;
+          data.b = this.b.toJSON(meta).uuid;
+          data.op = this.op;
+        }
+
+        return data;
+      }
+    }]);
+
+    return OperatorNode;
+  }(_TempNode2.TempNode);
+
+  _exports.OperatorNode = OperatorNode;
+  OperatorNode.ADD = '+';
+  OperatorNode.SUB = '-';
+  OperatorNode.MUL = '*';
+  OperatorNode.DIV = '/';
+  OperatorNode.prototype.nodeType = 'Operator';
+});

data/lib-opal/js_wrap/three/nodes/misc/BumpMapNode.js

@@ -0,0 +1,139 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/TempNode.js", "../inputs/FloatNode.js", "../core/FunctionNode.js", "../accessors/NormalNode.js", "../accessors/PositionNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/TempNode.js"), require("../inputs/FloatNode.js"), require("../core/FunctionNode.js"), require("../accessors/NormalNode.js"), require("../accessors/PositionNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.TempNode, global.FloatNode, global.FunctionNode, global.NormalNode, global.PositionNode);
+    global.BumpMapNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _TempNode2, _FloatNode, _FunctionNode, _NormalNode, _PositionNode) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.BumpMapNode = 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 BumpMapNode = /*#__PURE__*/function (_TempNode) {
+    _inherits(BumpMapNode, _TempNode);
+
+    var _super = _createSuper(BumpMapNode);
+
+    function BumpMapNode(value, scale) {
+      var _this;
+
+      _classCallCheck(this, BumpMapNode);
+
+      _this = _super.call(this, 'v3');
+      _this.value = value;
+      _this.scale = scale || new _FloatNode.FloatNode(1);
+      _this.toNormalMap = false;
+      return _this;
+    }
+
+    _createClass(BumpMapNode, [{
+      key: "generate",
+      value: function generate(builder, output) {
+        if (builder.isShader('fragment')) {
+          if (this.toNormalMap) {
+            var bumpToNormal = builder.include(BumpMapNode.Nodes.bumpToNormal);
+            return builder.format(bumpToNormal + '( ' + this.value.build(builder, 'sampler2D') + ', ' + this.value.uv.build(builder, 'v2') + ', ' + this.scale.build(builder, 'f') + ' )', this.getType(builder), output);
+          } else {
+            var derivativeHeight = builder.include(BumpMapNode.Nodes.dHdxy_fwd),
+                perturbNormalArb = builder.include(BumpMapNode.Nodes.perturbNormalArb);
+            this.normal = this.normal || new _NormalNode.NormalNode();
+            this.position = this.position || new _PositionNode.PositionNode(_PositionNode.PositionNode.VIEW);
+            var derivativeHeightCode = derivativeHeight + '( ' + this.value.build(builder, 'sampler2D') + ', ' + this.value.uv.build(builder, 'v2') + ', ' + this.scale.build(builder, 'f') + ' )';
+            return builder.format(perturbNormalArb + '( -' + this.position.build(builder, 'v3') + ', ' + this.normal.build(builder, 'v3') + ', ' + derivativeHeightCode + ' )', this.getType(builder), output);
+          }
+        } else {
+          console.warn('THREE.BumpMapNode is not compatible with ' + builder.shader + ' shader.');
+          return builder.format('vec3( 0.0 )', this.getType(builder), output);
+        }
+      }
+    }, {
+      key: "copy",
+      value: function copy(source) {
+        _get(_getPrototypeOf(BumpMapNode.prototype), "copy", this).call(this, source);
+
+        this.value = source.value;
+        this.scale = source.scale;
+        return this;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(meta) {
+        var data = this.getJSONNode(meta);
+
+        if (!data) {
+          data = this.createJSONNode(meta);
+          data.value = this.value.toJSON(meta).uuid;
+          data.scale = this.scale.toJSON(meta).uuid;
+        }
+
+        return data;
+      }
+    }]);
+
+    return BumpMapNode;
+  }(_TempNode2.TempNode);
+
+  _exports.BumpMapNode = BumpMapNode;
+
+  BumpMapNode.Nodes = function () {
+    // Bump Mapping Unparametrized Surfaces on the GPU by Morten S. Mikkelsen
+    // http://api.unrealengine.com/attachments/Engine/Rendering/LightingAndShadows/BumpMappingWithoutTangentSpace/mm_sfgrad_bump.pdf
+    // Evaluate the derivative of the height w.r.t. screen-space using forward differencing (listing 2)
+    var dHdxy_fwd = new _FunctionNode.FunctionNode(
+    /* glsl */
+    "\n\n\t\tvec2 dHdxy_fwd( sampler2D bumpMap, vec2 vUv, float bumpScale ) {\n\n\t\t\tvec2 dSTdx = dFdx( vUv );\n\t\t\tvec2 dSTdy = dFdy( vUv );\n\n\t\t\tfloat Hll = bumpScale * texture2D( bumpMap, vUv ).x;\n\t\t\tfloat dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n\t\t\tfloat dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\n\n\t\t\treturn vec2( dBx, dBy );\n\n\t\t}", null, {
+      derivatives: true
+    });
+    var perturbNormalArb = new _FunctionNode.FunctionNode(
+    /* glsl */
+    "\n\n\t\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {\n\n\t\t\tvec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );\n\t\t\tvec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );\n\t\t\tvec3 vN = surf_norm; // normalized\n\n\t\t\tvec3 R1 = cross( vSigmaY, vN );\n\t\t\tvec3 R2 = cross( vN, vSigmaX );\n\n\t\t\tfloat fDet = dot( vSigmaX, R1 );\n\n\t\t\tfDet *= ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\n\t\t\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n\n\t\t\treturn normalize( abs( fDet ) * surf_norm - vGrad );\n\n\t\t}", [dHdxy_fwd], {
+      derivatives: true
+    });
+    var bumpToNormal = new _FunctionNode.FunctionNode(
+    /* glsl */
+    "\n\t\tvec3 bumpToNormal( sampler2D bumpMap, vec2 uv, float scale ) {\n\n\t\t\tvec2 dSTdx = dFdx( uv );\n\t\t\tvec2 dSTdy = dFdy( uv );\n\n\t\t\tfloat Hll = texture2D( bumpMap, uv ).x;\n\t\t\tfloat dBx = texture2D( bumpMap, uv + dSTdx ).x - Hll;\n\t\t\tfloat dBy = texture2D( bumpMap, uv + dSTdy ).x - Hll;\n\n\t\t\treturn vec3( .5 - ( dBx * scale ), .5 - ( dBy * scale ), 1.0 );\n\n\t\t}", null, {
+      derivatives: true
+    });
+    return {
+      dHdxy_fwd: dHdxy_fwd,
+      perturbNormalArb: perturbNormalArb,
+      bumpToNormal: bumpToNormal
+    };
+  }();
+
+  BumpMapNode.prototype.nodeType = 'BumpMap';
+  BumpMapNode.prototype.hashProperties = ['toNormalMap'];
+});

data/lib-opal/js_wrap/three/nodes/misc/NormalMapNode.js

@@ -0,0 +1,122 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../core/TempNode.js", "../inputs/Vector2Node.js", "../core/FunctionNode.js", "../accessors/UVNode.js", "../accessors/NormalNode.js", "../accessors/PositionNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../core/TempNode.js"), require("../inputs/Vector2Node.js"), require("../core/FunctionNode.js"), require("../accessors/UVNode.js"), require("../accessors/NormalNode.js"), require("../accessors/PositionNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.TempNode, global.Vector2Node, global.FunctionNode, global.UVNode, global.NormalNode, global.PositionNode);
+    global.NormalMapNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _TempNode2, _Vector2Node, _FunctionNode, _UVNode, _NormalNode, _PositionNode) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.NormalMapNode = 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 NormalMapNode = /*#__PURE__*/function (_TempNode) {
+    _inherits(NormalMapNode, _TempNode);
+
+    var _super = _createSuper(NormalMapNode);
+
+    function NormalMapNode(value, scale) {
+      var _this;
+
+      _classCallCheck(this, NormalMapNode);
+
+      _this = _super.call(this, 'v3');
+      _this.value = value;
+      _this.scale = scale || new _Vector2Node.Vector2Node(1, 1);
+      return _this;
+    }
+
+    _createClass(NormalMapNode, [{
+      key: "generate",
+      value: function generate(builder, output) {
+        if (builder.isShader('fragment')) {
+          var perturbNormal2Arb = builder.include(NormalMapNode.Nodes.perturbNormal2Arb);
+          this.normal = this.normal || new _NormalNode.NormalNode();
+          this.position = this.position || new _PositionNode.PositionNode(_PositionNode.PositionNode.VIEW);
+          this.uv = this.uv || new _UVNode.UVNode();
+          var scale = this.scale.build(builder, 'v2');
+
+          if (builder.material.side === _three.BackSide) {
+            scale = '-' + scale;
+          }
+
+          return builder.format(perturbNormal2Arb + '( -' + this.position.build(builder, 'v3') + ', ' + this.normal.build(builder, 'v3') + ', ' + this.value.build(builder, 'v3') + ', ' + this.uv.build(builder, 'v2') + ', ' + scale + ' )', this.getType(builder), output);
+        } else {
+          console.warn('THREE.NormalMapNode is not compatible with ' + builder.shader + ' shader.');
+          return builder.format('vec3( 0.0 )', this.getType(builder), output);
+        }
+      }
+    }, {
+      key: "copy",
+      value: function copy(source) {
+        _get(_getPrototypeOf(NormalMapNode.prototype), "copy", this).call(this, source);
+
+        this.value = source.value;
+        this.scale = source.scale;
+        return this;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(meta) {
+        var data = this.getJSONNode(meta);
+
+        if (!data) {
+          data = this.createJSONNode(meta);
+          data.value = this.value.toJSON(meta).uuid;
+          data.scale = this.scale.toJSON(meta).uuid;
+        }
+
+        return data;
+      }
+    }]);
+
+    return NormalMapNode;
+  }(_TempNode2.TempNode);
+
+  _exports.NormalMapNode = NormalMapNode;
+
+  NormalMapNode.Nodes = function () {
+    var perturbNormal2Arb = new _FunctionNode.FunctionNode( // Per-Pixel Tangent Space Normal Mapping
+    // http://hacksoflife.blogspot.ch/2009/11/per-pixel-tangent-space-normal-mapping.html
+    "vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 map, vec2 vUv, vec2 normalScale ) {\n\n\t\t// Workaround for Adreno 3XX dFd*( vec3 ) bug. See #9988\n\n\t\tvec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\n\t\tvec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\n\t\tvec2 st0 = dFdx( vUv.st );\n\t\tvec2 st1 = dFdy( vUv.st );\n\n\t\tfloat scale = sign( st1.t * st0.s - st0.t * st1.s ); // we do not care about the magnitude\n\n\t\tvec3 S = normalize( ( q0 * st1.t - q1 * st0.t ) * scale );\n\t\tvec3 T = normalize( ( - q0 * st1.s + q1 * st0.s ) * scale );\n\t\tvec3 N = normalize( surf_norm );\n\n\t\tvec3 mapN = map * 2.0 - 1.0;\n\n\t\tmapN.xy *= normalScale;\n\n\t\t#ifdef DOUBLE_SIDED\n\n\t\t\t// Workaround for Adreno GPUs gl_FrontFacing bug. See #15850 and #10331\n\n\t\t\tif ( dot( cross( S, T ), N ) < 0.0 ) mapN.xy *= - 1.0;\n\n\t\t#else\n\n\t\t\tmapN.xy *= ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\n\t\t#endif\n\n\t\tmat3 tsn = mat3( S, T, N );\n\t\treturn normalize( tsn * mapN );\n\n\t}", null, {
+      derivatives: true
+    });
+    return {
+      perturbNormal2Arb: perturbNormal2Arb
+    };
+  }();
+
+  NormalMapNode.prototype.nodeType = 'NormalMap';
+});