opal-js_wrap-three 0.1.1 → 0.1.2

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

@@ -0,0 +1,101 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./Node.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./Node.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.Node);
+    global.VarNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _Node2) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _Node2 = _interopRequireDefault(_Node2);
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+
+  function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var VarNode = /*#__PURE__*/function (_Node) {
+    _inherits(VarNode, _Node);
+
+    var _super = _createSuper(VarNode);
+
+    function VarNode(node) {
+      var _this;
+
+      var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      var nodeType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+
+      _classCallCheck(this, VarNode);
+
+      _this = _super.call(this, nodeType);
+      _this.node = node;
+      _this.name = name;
+      return _this;
+    }
+
+    _createClass(VarNode, [{
+      key: "getHash",
+      value: function getHash(builder) {
+        return this.name || _get(_getPrototypeOf(VarNode.prototype), "getHash", this).call(this, builder);
+      }
+    }, {
+      key: "getNodeType",
+      value: function getNodeType(builder) {
+        return _get(_getPrototypeOf(VarNode.prototype), "getNodeType", this).call(this, builder) || this.node.getNodeType(builder);
+      }
+    }, {
+      key: "generate",
+      value: function generate(builder) {
+        var type = builder.getVectorType(this.getNodeType(builder));
+        var node = this.node;
+        var name = this.name;
+        var snippet = node.build(builder, type);
+        var nodeVar = builder.getVarFromNode(this, type);
+
+        if (name !== null) {
+          nodeVar.name = name;
+        }
+
+        var propertyName = builder.getPropertyName(nodeVar);
+        builder.addFlowCode("".concat(propertyName, " = ").concat(snippet));
+        return propertyName;
+      }
+    }]);
+
+    return VarNode;
+  }(_Node2.default);
+
+  var _default = VarNode;
+  _exports.default = _default;
+});

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

@@ -0,0 +1,101 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./Node.js", "./constants.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./Node.js"), require("./constants.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.Node, global.constants);
+    global.VaryNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _Node2, _constants) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _Node2 = _interopRequireDefault(_Node2);
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+
+  function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var VaryNode = /*#__PURE__*/function (_Node) {
+    _inherits(VaryNode, _Node);
+
+    var _super = _createSuper(VaryNode);
+
+    function VaryNode(node) {
+      var _this;
+
+      var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+
+      _classCallCheck(this, VaryNode);
+
+      _this = _super.call(this);
+      _this.node = node;
+      _this.name = name;
+      return _this;
+    }
+
+    _createClass(VaryNode, [{
+      key: "getHash",
+      value: function getHash(builder) {
+        return this.name || _get(_getPrototypeOf(VaryNode.prototype), "getHash", this).call(this, builder);
+      }
+    }, {
+      key: "getNodeType",
+      value: function getNodeType(builder) {
+        // VaryNode is auto type
+        return this.node.getNodeType(builder);
+      }
+    }, {
+      key: "generate",
+      value: function generate(builder) {
+        var type = this.getNodeType(builder);
+        var node = this.node;
+        var name = this.name;
+        var nodeVary = builder.getVaryFromNode(this, type);
+
+        if (name !== null) {
+          nodeVary.name = name;
+        }
+
+        var propertyName = builder.getPropertyName(nodeVary, _constants.NodeShaderStage.Vertex); // force node run in vertex stage
+
+        builder.flowNodeFromShaderStage(_constants.NodeShaderStage.Vertex, node, type, propertyName);
+        return builder.getPropertyName(nodeVary);
+      }
+    }]);
+
+    return VaryNode;
+  }(_Node2.default);
+
+  var _default = VaryNode;
+  _exports.default = _default;
+});

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

@@ -0,0 +1,42 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports);
+    global.constants = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.NodeUpdateType = _exports.NodeType = _exports.NodeShaderStage = void 0;
+  var NodeShaderStage = {
+    Vertex: 'vertex',
+    Fragment: 'fragment'
+  };
+  _exports.NodeShaderStage = NodeShaderStage;
+  var NodeUpdateType = {
+    None: 'none',
+    Frame: 'frame',
+    Object: 'object'
+  };
+  _exports.NodeUpdateType = NodeUpdateType;
+  var NodeType = {
+    Boolean: 'bool',
+    Integer: 'int',
+    Float: 'float',
+    Vector2: 'vec2',
+    Vector3: 'vec3',
+    Vector4: 'vec4',
+    Matrix3: 'mat3',
+    Matrix4: 'mat4'
+  };
+  _exports.NodeType = NodeType;
+});

data/lib-opal/js_wrap/three/renderers/nodes/display/ColorSpaceNode.js

@@ -0,0 +1,165 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../core/Node.js", "../ShaderNode.js", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../core/Node.js"), require("../ShaderNode.js"), require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.Node, global.ShaderNode, global.three);
+    global.ColorSpaceNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _Node, _ShaderNode, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.sRGBToLinear = _exports.default = _exports.LinearToLinear = void 0;
+  _Node = _interopRequireDefault(_Node);
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+  var LinearToLinear = new _ShaderNode.ShaderNode(function (inputs) {
+    return inputs.value;
+  });
+  _exports.LinearToLinear = LinearToLinear;
+  var sRGBToLinear = new _ShaderNode.ShaderNode(function (inputs) {
+    var value = inputs.value;
+    var rgb = value.rgb;
+    var a = (0, _ShaderNode.pow)((0, _ShaderNode.add)((0, _ShaderNode.mul)(rgb, 0.9478672986), (0, _ShaderNode.vec3)(0.0521327014)), (0, _ShaderNode.vec3)(2.4));
+    var b = (0, _ShaderNode.mul)(rgb, 0.0773993808);
+    var factor = (0, _ShaderNode.vec3)((0, _ShaderNode.lessThanEqual)(rgb, (0, _ShaderNode.vec3)(0.04045)));
+    var rgbResult = (0, _ShaderNode.mix)(a, b, factor);
+    return (0, _ShaderNode.join)(rgbResult.r, rgbResult.g, rgbResult.b, value.a);
+  });
+  _exports.sRGBToLinear = sRGBToLinear;
+  var EncodingLib = {
+    LinearToLinear: LinearToLinear,
+    sRGBToLinear: sRGBToLinear
+  };
+
+  function getEncodingComponents(encoding) {
+    switch (encoding) {
+      case _three.LinearEncoding:
+        return ['Linear'];
+
+      case _three.sRGBEncoding:
+        return ['sRGB'];
+
+      /*
+      		case RGBEEncoding:
+      			return [ 'RGBE' ];
+      		case RGBM7Encoding:
+      			return [ 'RGBM', new FloatNode( 7.0 ).setConst( true ) ];
+      		case RGBM16Encoding:
+      			return [ 'RGBM', new FloatNode( 16.0 ).setConst( true ) ];
+      		case RGBDEncoding:
+      			return [ 'RGBD', new FloatNode( 256.0 ).setConst( true ) ];
+      		case GammaEncoding:
+      			return [ 'Gamma', new CodeNode( 'float( GAMMA_FACTOR )' ) ];
+      */
+    }
+  }
+
+  var ColorSpaceNode = /*#__PURE__*/function (_TempNode) {
+    _inherits(ColorSpaceNode, _TempNode);
+
+    var _super = _createSuper(ColorSpaceNode);
+
+    /*
+    	static GAMMA_TO_LINEAR = 'GammaToLinear';
+    	static LINEAR_TO_GAMMA = 'LinearToGamma';
+    
+    	static RGBE_TO_LINEAR = 'RGBEToLinear';
+    	static LINEAR_TO_RGBE = 'LinearToRGBE';
+    
+    	static RGBM_TO_LINEAR = 'RGBMToLinear';
+    	static LINEAR_TO_RGBM = 'LinearToRGBM';
+    
+    	static RGBD_TO_LINEAR = 'RGBDToLinear';
+    	static LINEAR_TO_RGBD = 'LinearToRGBD';
+    */
+    function ColorSpaceNode(method, node) {
+      var _this;
+
+      _classCallCheck(this, ColorSpaceNode);
+
+      _this = _super.call(this, 'vec4');
+      _this.method = method;
+      _this.node = node;
+      _this.factor = null;
+      return _this;
+    }
+
+    _createClass(ColorSpaceNode, [{
+      key: "fromEncoding",
+      value: function fromEncoding(encoding) {
+        var components = getEncodingComponents(encoding);
+        this.method = 'LinearTo' + components[0];
+        this.factor = components[1];
+        return this;
+      }
+    }, {
+      key: "fromDecoding",
+      value: function fromDecoding(encoding) {
+        var components = getEncodingComponents(encoding);
+        this.method = components[0] + 'ToLinear';
+        this.factor = components[1];
+        return this;
+      }
+    }, {
+      key: "generate",
+      value: function generate(builder) {
+        var type = this.getNodeType(builder);
+        var method = this.method;
+        var node = this.node;
+
+        if (method !== ColorSpaceNode.LINEAR_TO_LINEAR) {
+          var encodingFunctionNode = EncodingLib[method];
+          var factor = this.factor;
+          return encodingFunctionNode({
+            value: node,
+            factor: factor
+          }).build(builder, type);
+        } else {
+          return node.build(builder, type);
+        }
+      }
+    }]);
+
+    return ColorSpaceNode;
+  }(_Node.default);
+
+  _defineProperty(ColorSpaceNode, "LINEAR_TO_LINEAR", 'LinearToLinear');
+
+  _defineProperty(ColorSpaceNode, "SRGB_TO_LINEAR", 'sRGBToLinear');
+
+  _defineProperty(ColorSpaceNode, "LINEAR_TO_SRGB", 'LinearTosRGB');
+
+  var _default = ColorSpaceNode;
+  _exports.default = _default;
+});

data/lib-opal/js_wrap/three/renderers/nodes/display/NormalMapNode.js

@@ -0,0 +1,120 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../accessors/PositionNode.js", "../accessors/NormalNode.js", "../accessors/UVNode.js", "../math/MathNode.js", "../math/OperatorNode.js", "../inputs/FloatNode.js", "../core/TempNode.js", "../accessors/ModelNode.js", "../ShaderNode.js", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../accessors/PositionNode.js"), require("../accessors/NormalNode.js"), require("../accessors/UVNode.js"), require("../math/MathNode.js"), require("../math/OperatorNode.js"), require("../inputs/FloatNode.js"), require("../core/TempNode.js"), require("../accessors/ModelNode.js"), require("../ShaderNode.js"), require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.PositionNode, global.NormalNode, global.UVNode, global.MathNode, global.OperatorNode, global.FloatNode, global.TempNode, global.ModelNode, global.ShaderNode, global.three);
+    global.NormalMapNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _PositionNode, _NormalNode, _UVNode, _MathNode, _OperatorNode, _FloatNode, _TempNode2, _ModelNode, _ShaderNode, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _PositionNode = _interopRequireDefault(_PositionNode);
+  _NormalNode = _interopRequireDefault(_NormalNode);
+  _UVNode = _interopRequireDefault(_UVNode);
+  _MathNode = _interopRequireDefault(_MathNode);
+  _OperatorNode = _interopRequireDefault(_OperatorNode);
+  _FloatNode = _interopRequireDefault(_FloatNode);
+  _TempNode2 = _interopRequireDefault(_TempNode2);
+  _ModelNode = _interopRequireDefault(_ModelNode);
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  // Normal Mapping Without Precomputed Tangents
+  // http://www.thetenthplanet.de/archives/1180
+  var perturbNormal2ArbNode = new _ShaderNode.ShaderNode(function (inputs) {
+    var eye_pos = inputs.eye_pos,
+        surf_norm = inputs.surf_norm,
+        mapN = inputs.mapN,
+        faceDirection = inputs.faceDirection,
+        uv = inputs.uv;
+    var q0 = (0, _ShaderNode.dFdx)(eye_pos.xyz);
+    var q1 = (0, _ShaderNode.dFdy)(eye_pos.xyz);
+    var st0 = (0, _ShaderNode.dFdx)(uv.st);
+    var st1 = (0, _ShaderNode.dFdy)(uv.st);
+    var N = surf_norm; // normalized
+
+    var q1perp = (0, _ShaderNode.cross)(q1, N);
+    var q0perp = (0, _ShaderNode.cross)(N, q0);
+    var T = (0, _ShaderNode.add)((0, _ShaderNode.mul)(q1perp, st0.x), (0, _ShaderNode.mul)(q0perp, st1.x));
+    var B = (0, _ShaderNode.add)((0, _ShaderNode.mul)(q1perp, st0.y), (0, _ShaderNode.mul)(q0perp, st1.y));
+    var det = (0, _ShaderNode.max)((0, _ShaderNode.dot)(T, T), (0, _ShaderNode.dot)(B, B));
+    var scale = (0, _ShaderNode.cond)((0, _ShaderNode.equal)(det, 0), 0, (0, _ShaderNode.mul)(faceDirection, (0, _ShaderNode.inversesqrt)(det)));
+    return (0, _ShaderNode.normalize)((0, _ShaderNode.add)((0, _ShaderNode.mul)(T, (0, _ShaderNode.mul)(mapN.x, scale)), (0, _ShaderNode.mul)(B, (0, _ShaderNode.mul)(mapN.y, scale)), (0, _ShaderNode.mul)(N, mapN.z)));
+  });
+
+  var NormalMapNode = /*#__PURE__*/function (_TempNode) {
+    _inherits(NormalMapNode, _TempNode);
+
+    var _super = _createSuper(NormalMapNode);
+
+    function NormalMapNode(node) {
+      var _this;
+
+      _classCallCheck(this, NormalMapNode);
+
+      _this = _super.call(this, 'vec3');
+      _this.node = node;
+      _this.normalMapType = _three.TangentSpaceNormalMap;
+      return _this;
+    }
+
+    _createClass(NormalMapNode, [{
+      key: "generate",
+      value: function generate(builder) {
+        var type = this.getNodeType(builder);
+        var normalMapType = this.normalMapType;
+        var normalOP = new _OperatorNode.default('*', this.node, new _FloatNode.default(2.0).setConst(true));
+        var normalMap = new _OperatorNode.default('-', normalOP, new _FloatNode.default(1.0).setConst(true));
+
+        if (normalMapType === _three.ObjectSpaceNormalMap) {
+          var vertexNormalNode = new _OperatorNode.default('*', new _ModelNode.default(_ModelNode.default.NORMAL_MATRIX), normalMap);
+          var normal = new _MathNode.default(_MathNode.default.NORMALIZE, vertexNormalNode);
+          return normal.build(builder, type);
+        } else if (normalMapType === _three.TangentSpaceNormalMap) {
+          var perturbNormal2ArbCall = perturbNormal2ArbNode({
+            eye_pos: new _PositionNode.default(_PositionNode.default.VIEW),
+            surf_norm: new _NormalNode.default(_NormalNode.default.VIEW),
+            mapN: normalMap,
+            faceDirection: new _FloatNode.default(1.0).setConst(true),
+            uv: new _UVNode.default()
+          });
+          return perturbNormal2ArbCall.build(builder, type);
+        }
+      }
+    }]);
+
+    return NormalMapNode;
+  }(_TempNode2.default);
+
+  var _default = NormalMapNode;
+  _exports.default = _default;
+});

data/lib-opal/js_wrap/three/renderers/nodes/functions/BSDFs.js

@@ -0,0 +1,133 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../ShaderNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../ShaderNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.ShaderNode);
+    global.BSDFs = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _ShaderNode) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.getDistanceAttenuation = _exports.V_GGX_SmithCorrelated = _exports.RE_Direct_Physical = _exports.PhysicalLightingModel = _exports.F_Schlick = _exports.D_GGX = _exports.BRDF_Specular_GGX = _exports.BRDF_Lambert = void 0;
+  var F_Schlick = new _ShaderNode.ShaderNode(function (inputs) {
+    var f0 = inputs.f0,
+        f90 = inputs.f90,
+        dotVH = inputs.dotVH; // Original approximation by Christophe Schlick '94
+    // float fresnel = pow( 1.0 - dotVH, 5.0 );
+    // Optimized variant (presented by Epic at SIGGRAPH '13)
+    // https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf
+
+    var fresnel = (0, _ShaderNode.exp2)((0, _ShaderNode.mul)((0, _ShaderNode.sub)((0, _ShaderNode.mul)(-5.55473, dotVH), 6.98316), dotVH));
+    return (0, _ShaderNode.add)((0, _ShaderNode.mul)(f0, (0, _ShaderNode.sub)(1.0, fresnel)), (0, _ShaderNode.mul)(f90, fresnel));
+  }); // validated
+
+  _exports.F_Schlick = F_Schlick;
+  var BRDF_Lambert = new _ShaderNode.ShaderNode(function (inputs) {
+    return (0, _ShaderNode.mul)(_ShaderNode.RECIPROCAL_PI, inputs.diffuseColor); // punctual light
+  }); // validated
+
+  _exports.BRDF_Lambert = BRDF_Lambert;
+  var getDistanceAttenuation = new _ShaderNode.ShaderNode(function (inputs) {
+    var lightDistance = inputs.lightDistance,
+        cutoffDistance = inputs.cutoffDistance,
+        decayExponent = inputs.decayExponent;
+    return (0, _ShaderNode.cond)((0, _ShaderNode.and)((0, _ShaderNode.greaterThan)(cutoffDistance, 0), (0, _ShaderNode.greaterThan)(decayExponent, 0)), (0, _ShaderNode.pow)((0, _ShaderNode.saturate)((0, _ShaderNode.add)((0, _ShaderNode.div)((0, _ShaderNode.negate)(lightDistance), cutoffDistance), 1.0)), decayExponent), 1.0);
+  }); // validated
+  //
+  // STANDARD
+  //
+  // Moving Frostbite to Physically Based Rendering 3.0 - page 12, listing 2
+  // https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
+
+  _exports.getDistanceAttenuation = getDistanceAttenuation;
+  var V_GGX_SmithCorrelated = new _ShaderNode.ShaderNode(function (inputs) {
+    var alpha = inputs.alpha,
+        dotNL = inputs.dotNL,
+        dotNV = inputs.dotNV;
+    var a2 = (0, _ShaderNode.pow2)(alpha);
+    var gv = (0, _ShaderNode.mul)(dotNL, (0, _ShaderNode.sqrt)((0, _ShaderNode.add)(a2, (0, _ShaderNode.mul)((0, _ShaderNode.sub)(1.0, a2), (0, _ShaderNode.pow2)(dotNV)))));
+    var gl = (0, _ShaderNode.mul)(dotNV, (0, _ShaderNode.sqrt)((0, _ShaderNode.add)(a2, (0, _ShaderNode.mul)((0, _ShaderNode.sub)(1.0, a2), (0, _ShaderNode.pow2)(dotNL)))));
+    return (0, _ShaderNode.div)(0.5, (0, _ShaderNode.max)((0, _ShaderNode.add)(gv, gl), _ShaderNode.EPSILON));
+  }); // validated
+  // Microfacet Models for Refraction through Rough Surfaces - equation (33)
+  // http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
+  // alpha is "roughness squared" in Disney’s reparameterization
+
+  _exports.V_GGX_SmithCorrelated = V_GGX_SmithCorrelated;
+  var D_GGX = new _ShaderNode.ShaderNode(function (inputs) {
+    var alpha = inputs.alpha,
+        dotNH = inputs.dotNH;
+    var a2 = (0, _ShaderNode.pow2)(alpha);
+    var denom = (0, _ShaderNode.add)((0, _ShaderNode.mul)((0, _ShaderNode.pow2)(dotNH), (0, _ShaderNode.sub)(a2, 1.0)), 1.0); // avoid alpha = 0 with dotNH = 1
+
+    return (0, _ShaderNode.mul)(_ShaderNode.RECIPROCAL_PI, (0, _ShaderNode.div)(a2, (0, _ShaderNode.pow2)(denom)));
+  }); // validated
+  // GGX Distribution, Schlick Fresnel, GGX_SmithCorrelated Visibility
+
+  _exports.D_GGX = D_GGX;
+  var BRDF_Specular_GGX = new _ShaderNode.ShaderNode(function (inputs) {
+    var lightDirection = inputs.lightDirection,
+        f0 = inputs.f0,
+        f90 = inputs.f90,
+        roughness = inputs.roughness;
+    var alpha = (0, _ShaderNode.pow2)(roughness); // UE4's roughness
+
+    var halfDir = (0, _ShaderNode.normalize)((0, _ShaderNode.add)(lightDirection, _ShaderNode.positionViewDirection));
+    var dotNL = (0, _ShaderNode.saturate)((0, _ShaderNode.dot)(_ShaderNode.transformedNormalView, lightDirection));
+    var dotNV = (0, _ShaderNode.saturate)((0, _ShaderNode.dot)(_ShaderNode.transformedNormalView, _ShaderNode.positionViewDirection));
+    var dotNH = (0, _ShaderNode.saturate)((0, _ShaderNode.dot)(_ShaderNode.transformedNormalView, halfDir));
+    var dotVH = (0, _ShaderNode.saturate)((0, _ShaderNode.dot)(_ShaderNode.positionViewDirection, halfDir));
+    var F = F_Schlick({
+      f0: f0,
+      f90: f90,
+      dotVH: dotVH
+    });
+    var V = V_GGX_SmithCorrelated({
+      alpha: alpha,
+      dotNL: dotNL,
+      dotNV: dotNV
+    });
+    var D = D_GGX({
+      alpha: alpha,
+      dotNH: dotNH
+    });
+    return (0, _ShaderNode.mul)(F, (0, _ShaderNode.mul)(V, D));
+  }); // validated
+
+  _exports.BRDF_Specular_GGX = BRDF_Specular_GGX;
+  var RE_Direct_Physical = new _ShaderNode.ShaderNode(function (inputs) {
+    var lightDirection = inputs.lightDirection,
+        lightColor = inputs.lightColor,
+        directDiffuse = inputs.directDiffuse,
+        directSpecular = inputs.directSpecular;
+    var dotNL = (0, _ShaderNode.saturate)((0, _ShaderNode.dot)(_ShaderNode.transformedNormalView, lightDirection));
+    var irradiance = (0, _ShaderNode.mul)(dotNL, lightColor);
+    irradiance = (0, _ShaderNode.mul)(irradiance, _ShaderNode.PI); // punctual light
+
+    (0, _ShaderNode.addTo)(directDiffuse, (0, _ShaderNode.mul)(irradiance, BRDF_Lambert({
+      diffuseColor: _ShaderNode.diffuseColor
+    })));
+    (0, _ShaderNode.addTo)(directSpecular, (0, _ShaderNode.mul)(irradiance, BRDF_Specular_GGX({
+      lightDirection: lightDirection,
+      f0: _ShaderNode.specularColor,
+      f90: 1,
+      roughness: _ShaderNode.roughness
+    })));
+  });
+  _exports.RE_Direct_Physical = RE_Direct_Physical;
+  var PhysicalLightingModel = new _ShaderNode.ShaderNode(function (inputs
+  /*, builder*/
+  ) {
+    // PHYSICALLY_CORRECT_LIGHTS <-> builder.renderer.physicallyCorrectLights === true
+    RE_Direct_Physical(inputs);
+  });
+  _exports.PhysicalLightingModel = PhysicalLightingModel;
+});