opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/objects/Reflector.js

@@ -0,0 +1,205 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.Reflector = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.Reflector = void 0;
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  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 Reflector = /*#__PURE__*/function (_Mesh) {
+    _inherits(Reflector, _Mesh);
+
+    var _super = _createSuper(Reflector);
+
+    function Reflector(geometry) {
+      var _this;
+
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      _classCallCheck(this, Reflector);
+
+      _this = _super.call(this, geometry);
+      _this.type = 'Reflector';
+
+      var scope = _assertThisInitialized(_this);
+
+      var color = options.color !== undefined ? new _three.Color(options.color) : new _three.Color(0x7F7F7F);
+      var textureWidth = options.textureWidth || 512;
+      var textureHeight = options.textureHeight || 512;
+      var clipBias = options.clipBias || 0;
+      var shader = options.shader || Reflector.ReflectorShader; //
+
+      var reflectorPlane = new _three.Plane();
+      var normal = new _three.Vector3();
+      var reflectorWorldPosition = new _three.Vector3();
+      var cameraWorldPosition = new _three.Vector3();
+      var rotationMatrix = new _three.Matrix4();
+      var lookAtPosition = new _three.Vector3(0, 0, -1);
+      var clipPlane = new _three.Vector4();
+      var view = new _three.Vector3();
+      var target = new _three.Vector3();
+      var q = new _three.Vector4();
+      var textureMatrix = new _three.Matrix4();
+      var virtualCamera = new _three.PerspectiveCamera();
+      var parameters = {
+        minFilter: _three.LinearFilter,
+        magFilter: _three.LinearFilter,
+        format: _three.RGBFormat
+      };
+      var renderTarget = new _three.WebGLRenderTarget(textureWidth, textureHeight, parameters);
+
+      if (!_three.MathUtils.isPowerOfTwo(textureWidth) || !_three.MathUtils.isPowerOfTwo(textureHeight)) {
+        renderTarget.texture.generateMipmaps = false;
+      }
+
+      var material = new _three.ShaderMaterial({
+        uniforms: _three.UniformsUtils.clone(shader.uniforms),
+        fragmentShader: shader.fragmentShader,
+        vertexShader: shader.vertexShader
+      });
+      material.uniforms['tDiffuse'].value = renderTarget.texture;
+      material.uniforms['color'].value = color;
+      material.uniforms['textureMatrix'].value = textureMatrix;
+      _this.material = material;
+
+      _this.onBeforeRender = function (renderer, scene, camera) {
+        reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld);
+        cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld);
+        rotationMatrix.extractRotation(scope.matrixWorld);
+        normal.set(0, 0, 1);
+        normal.applyMatrix4(rotationMatrix);
+        view.subVectors(reflectorWorldPosition, cameraWorldPosition); // Avoid rendering when reflector is facing away
+
+        if (view.dot(normal) > 0) return;
+        view.reflect(normal).negate();
+        view.add(reflectorWorldPosition);
+        rotationMatrix.extractRotation(camera.matrixWorld);
+        lookAtPosition.set(0, 0, -1);
+        lookAtPosition.applyMatrix4(rotationMatrix);
+        lookAtPosition.add(cameraWorldPosition);
+        target.subVectors(reflectorWorldPosition, lookAtPosition);
+        target.reflect(normal).negate();
+        target.add(reflectorWorldPosition);
+        virtualCamera.position.copy(view);
+        virtualCamera.up.set(0, 1, 0);
+        virtualCamera.up.applyMatrix4(rotationMatrix);
+        virtualCamera.up.reflect(normal);
+        virtualCamera.lookAt(target);
+        virtualCamera.far = camera.far; // Used in WebGLBackground
+
+        virtualCamera.updateMatrixWorld();
+        virtualCamera.projectionMatrix.copy(camera.projectionMatrix); // Update the texture matrix
+
+        textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0);
+        textureMatrix.multiply(virtualCamera.projectionMatrix);
+        textureMatrix.multiply(virtualCamera.matrixWorldInverse);
+        textureMatrix.multiply(scope.matrixWorld); // Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html
+        // Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf
+
+        reflectorPlane.setFromNormalAndCoplanarPoint(normal, reflectorWorldPosition);
+        reflectorPlane.applyMatrix4(virtualCamera.matrixWorldInverse);
+        clipPlane.set(reflectorPlane.normal.x, reflectorPlane.normal.y, reflectorPlane.normal.z, reflectorPlane.constant);
+        var projectionMatrix = virtualCamera.projectionMatrix;
+        q.x = (Math.sign(clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0];
+        q.y = (Math.sign(clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5];
+        q.z = -1.0;
+        q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14]; // Calculate the scaled plane vector
+
+        clipPlane.multiplyScalar(2.0 / clipPlane.dot(q)); // Replacing the third row of the projection matrix
+
+        projectionMatrix.elements[2] = clipPlane.x;
+        projectionMatrix.elements[6] = clipPlane.y;
+        projectionMatrix.elements[10] = clipPlane.z + 1.0 - clipBias;
+        projectionMatrix.elements[14] = clipPlane.w; // Render
+
+        renderTarget.texture.encoding = renderer.outputEncoding;
+        scope.visible = false;
+        var currentRenderTarget = renderer.getRenderTarget();
+        var currentXrEnabled = renderer.xr.enabled;
+        var currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
+        renderer.xr.enabled = false; // Avoid camera modification
+
+        renderer.shadowMap.autoUpdate = false; // Avoid re-computing shadows
+
+        renderer.setRenderTarget(renderTarget);
+        renderer.state.buffers.depth.setMask(true); // make sure the depth buffer is writable so it can be properly cleared, see #18897
+
+        if (renderer.autoClear === false) renderer.clear();
+        renderer.render(scene, virtualCamera);
+        renderer.xr.enabled = currentXrEnabled;
+        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
+        renderer.setRenderTarget(currentRenderTarget); // Restore viewport
+
+        var viewport = camera.viewport;
+
+        if (viewport !== undefined) {
+          renderer.state.viewport(viewport);
+        }
+
+        scope.visible = true;
+      };
+
+      _this.getRenderTarget = function () {
+        return renderTarget;
+      };
+
+      return _this;
+    }
+
+    return _createClass(Reflector);
+  }(_three.Mesh);
+
+  _exports.Reflector = Reflector;
+  Reflector.prototype.isReflector = true;
+  Reflector.ReflectorShader = {
+    uniforms: {
+      'color': {
+        value: null
+      },
+      'tDiffuse': {
+        value: null
+      },
+      'textureMatrix': {
+        value: null
+      }
+    },
+    vertexShader:
+    /* glsl */
+    "\n\t\tuniform mat4 textureMatrix;\n\t\tvarying vec4 vUv;\n\n\t\t#include <common>\n\t\t#include <logdepthbuf_pars_vertex>\n\n\t\tvoid main() {\n\n\t\t\tvUv = textureMatrix * vec4( position, 1.0 );\n\n\t\t\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n\n\t\t\t#include <logdepthbuf_vertex>\n\n\t\t}",
+    fragmentShader:
+    /* glsl */
+    "\n\t\tuniform vec3 color;\n\t\tuniform sampler2D tDiffuse;\n\t\tvarying vec4 vUv;\n\n\t\t#include <logdepthbuf_pars_fragment>\n\n\t\tfloat blendOverlay( float base, float blend ) {\n\n\t\t\treturn( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );\n\n\t\t}\n\n\t\tvec3 blendOverlay( vec3 base, vec3 blend ) {\n\n\t\t\treturn vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ), blendOverlay( base.b, blend.b ) );\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\t#include <logdepthbuf_fragment>\n\n\t\t\tvec4 base = texture2DProj( tDiffuse, vUv );\n\t\t\tgl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );\n\n\t\t}"
+  };
+});

data/lib-opal/js_wrap/three/objects/ReflectorForSSRPass.js

@@ -0,0 +1,288 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.ReflectorForSSRPass = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.ReflectorForSSRPass = void 0;
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  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 ReflectorForSSRPass = /*#__PURE__*/function (_Mesh) {
+    _inherits(ReflectorForSSRPass, _Mesh);
+
+    var _super = _createSuper(ReflectorForSSRPass);
+
+    function ReflectorForSSRPass(geometry) {
+      var _this;
+
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+      _classCallCheck(this, ReflectorForSSRPass);
+
+      _this = _super.call(this, geometry);
+      _this.type = 'ReflectorForSSRPass';
+
+      var scope = _assertThisInitialized(_this);
+
+      var color = options.color !== undefined ? new _three.Color(options.color) : new _three.Color(0x7F7F7F);
+      var textureWidth = options.textureWidth || 512;
+      var textureHeight = options.textureHeight || 512;
+      var clipBias = options.clipBias || 0;
+      var shader = options.shader || ReflectorForSSRPass.ReflectorShader;
+      var useDepthTexture = options.useDepthTexture === true;
+      var yAxis = new _three.Vector3(0, 1, 0);
+      var vecTemp0 = new _three.Vector3();
+      var vecTemp1 = new _three.Vector3(); //
+
+      scope.needsUpdate = false;
+      scope.maxDistance = ReflectorForSSRPass.ReflectorShader.uniforms.maxDistance.value;
+      scope.opacity = ReflectorForSSRPass.ReflectorShader.uniforms.opacity.value;
+      scope.color = color;
+      scope.resolution = options.resolution || new _three.Vector2(window.innerWidth, window.innerHeight);
+      scope._distanceAttenuation = ReflectorForSSRPass.ReflectorShader.defines.DISTANCE_ATTENUATION;
+      Object.defineProperty(scope, 'distanceAttenuation', {
+        get: function get() {
+          return scope._distanceAttenuation;
+        },
+        set: function set(val) {
+          if (scope._distanceAttenuation === val) return;
+          scope._distanceAttenuation = val;
+          scope.material.defines.DISTANCE_ATTENUATION = val;
+          scope.material.needsUpdate = true;
+        }
+      });
+      scope._fresnel = ReflectorForSSRPass.ReflectorShader.defines.FRESNEL;
+      Object.defineProperty(scope, 'fresnel', {
+        get: function get() {
+          return scope._fresnel;
+        },
+        set: function set(val) {
+          if (scope._fresnel === val) return;
+          scope._fresnel = val;
+          scope.material.defines.FRESNEL = val;
+          scope.material.needsUpdate = true;
+        }
+      });
+      var normal = new _three.Vector3();
+      var reflectorWorldPosition = new _three.Vector3();
+      var cameraWorldPosition = new _three.Vector3();
+      var rotationMatrix = new _three.Matrix4();
+      var lookAtPosition = new _three.Vector3(0, 0, -1);
+      var view = new _three.Vector3();
+      var target = new _three.Vector3();
+      var textureMatrix = new _three.Matrix4();
+      var virtualCamera = new _three.PerspectiveCamera();
+      var depthTexture;
+
+      if (useDepthTexture) {
+        depthTexture = new _three.DepthTexture();
+        depthTexture.type = _three.UnsignedShortType;
+        depthTexture.minFilter = _three.NearestFilter;
+        depthTexture.magFilter = _three.NearestFilter;
+      }
+
+      var parameters = {
+        minFilter: _three.LinearFilter,
+        magFilter: _three.LinearFilter,
+        format: _three.RGBFormat,
+        depthTexture: useDepthTexture ? depthTexture : null
+      };
+      var renderTarget = new _three.WebGLRenderTarget(textureWidth, textureHeight, parameters);
+
+      if (!_three.MathUtils.isPowerOfTwo(textureWidth) || !_three.MathUtils.isPowerOfTwo(textureHeight)) {
+        renderTarget.texture.generateMipmaps = false;
+      }
+
+      var material = new _three.ShaderMaterial({
+        transparent: useDepthTexture,
+        defines: Object.assign({}, ReflectorForSSRPass.ReflectorShader.defines, {
+          useDepthTexture: useDepthTexture
+        }),
+        uniforms: _three.UniformsUtils.clone(shader.uniforms),
+        fragmentShader: shader.fragmentShader,
+        vertexShader: shader.vertexShader
+      });
+      material.uniforms['tDiffuse'].value = renderTarget.texture;
+      material.uniforms['color'].value = scope.color;
+      material.uniforms['textureMatrix'].value = textureMatrix;
+
+      if (useDepthTexture) {
+        material.uniforms['tDepth'].value = renderTarget.depthTexture;
+      }
+
+      _this.material = material;
+      var globalPlane = new _three.Plane(new _three.Vector3(0, 1, 0), clipBias);
+      var globalPlanes = [globalPlane];
+
+      _this.doRender = function (renderer, scene, camera) {
+        material.uniforms['maxDistance'].value = scope.maxDistance;
+        material.uniforms['color'].value = scope.color;
+        material.uniforms['opacity'].value = scope.opacity;
+        vecTemp0.copy(camera.position).normalize();
+        vecTemp1.copy(vecTemp0).reflect(yAxis);
+        material.uniforms['fresnelCoe'].value = (vecTemp0.dot(vecTemp1) + 1.) / 2.; // TODO: Also need to use glsl viewPosition and viewNormal per pixel.
+
+        reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld);
+        cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld);
+        rotationMatrix.extractRotation(scope.matrixWorld);
+        normal.set(0, 0, 1);
+        normal.applyMatrix4(rotationMatrix);
+        view.subVectors(reflectorWorldPosition, cameraWorldPosition); // Avoid rendering when reflector is facing away
+
+        if (view.dot(normal) > 0) return;
+        view.reflect(normal).negate();
+        view.add(reflectorWorldPosition);
+        rotationMatrix.extractRotation(camera.matrixWorld);
+        lookAtPosition.set(0, 0, -1);
+        lookAtPosition.applyMatrix4(rotationMatrix);
+        lookAtPosition.add(cameraWorldPosition);
+        target.subVectors(reflectorWorldPosition, lookAtPosition);
+        target.reflect(normal).negate();
+        target.add(reflectorWorldPosition);
+        virtualCamera.position.copy(view);
+        virtualCamera.up.set(0, 1, 0);
+        virtualCamera.up.applyMatrix4(rotationMatrix);
+        virtualCamera.up.reflect(normal);
+        virtualCamera.lookAt(target);
+        virtualCamera.far = camera.far; // Used in WebGLBackground
+
+        virtualCamera.updateMatrixWorld();
+        virtualCamera.projectionMatrix.copy(camera.projectionMatrix);
+        material.uniforms['virtualCameraNear'].value = camera.near;
+        material.uniforms['virtualCameraFar'].value = camera.far;
+        material.uniforms['virtualCameraMatrixWorld'].value = virtualCamera.matrixWorld;
+        material.uniforms['virtualCameraProjectionMatrix'].value = camera.projectionMatrix;
+        material.uniforms['virtualCameraProjectionMatrixInverse'].value = camera.projectionMatrixInverse;
+        material.uniforms['resolution'].value = scope.resolution; // Update the texture matrix
+
+        textureMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0);
+        textureMatrix.multiply(virtualCamera.projectionMatrix);
+        textureMatrix.multiply(virtualCamera.matrixWorldInverse);
+        textureMatrix.multiply(scope.matrixWorld); // Render
+
+        renderTarget.texture.encoding = renderer.outputEncoding; // scope.visible = false;
+
+        var currentRenderTarget = renderer.getRenderTarget();
+        var currentXrEnabled = renderer.xr.enabled;
+        var currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
+        var currentClippingPlanes = renderer.clippingPlanes;
+        renderer.xr.enabled = false; // Avoid camera modification
+
+        renderer.shadowMap.autoUpdate = false; // Avoid re-computing shadows
+
+        renderer.clippingPlanes = globalPlanes;
+        renderer.setRenderTarget(renderTarget);
+        renderer.state.buffers.depth.setMask(true); // make sure the depth buffer is writable so it can be properly cleared, see #18897
+
+        if (renderer.autoClear === false) renderer.clear();
+        renderer.render(scene, virtualCamera);
+        renderer.xr.enabled = currentXrEnabled;
+        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
+        renderer.clippingPlanes = currentClippingPlanes;
+        renderer.setRenderTarget(currentRenderTarget); // Restore viewport
+
+        var viewport = camera.viewport;
+
+        if (viewport !== undefined) {
+          renderer.state.viewport(viewport);
+        } // scope.visible = true;
+
+      };
+
+      _this.getRenderTarget = function () {
+        return renderTarget;
+      };
+
+      return _this;
+    }
+
+    return _createClass(ReflectorForSSRPass);
+  }(_three.Mesh);
+
+  _exports.ReflectorForSSRPass = ReflectorForSSRPass;
+  ReflectorForSSRPass.prototype.isReflectorForSSRPass = true;
+  ReflectorForSSRPass.ReflectorShader = {
+    defines: {
+      DISTANCE_ATTENUATION: true,
+      FRESNEL: true
+    },
+    uniforms: {
+      color: {
+        value: null
+      },
+      tDiffuse: {
+        value: null
+      },
+      tDepth: {
+        value: null
+      },
+      textureMatrix: {
+        value: new _three.Matrix4()
+      },
+      maxDistance: {
+        value: 180
+      },
+      opacity: {
+        value: 0.5
+      },
+      fresnelCoe: {
+        value: null
+      },
+      virtualCameraNear: {
+        value: null
+      },
+      virtualCameraFar: {
+        value: null
+      },
+      virtualCameraProjectionMatrix: {
+        value: new _three.Matrix4()
+      },
+      virtualCameraMatrixWorld: {
+        value: new _three.Matrix4()
+      },
+      virtualCameraProjectionMatrixInverse: {
+        value: new _three.Matrix4()
+      },
+      resolution: {
+        value: new _three.Vector2()
+      }
+    },
+    vertexShader:
+    /* glsl */
+    "\n\t\tuniform mat4 textureMatrix;\n\t\tvarying vec4 vUv;\n\n\t\tvoid main() {\n\n\t\t\tvUv = textureMatrix * vec4( position, 1.0 );\n\n\t\t\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n\n\t\t}",
+    fragmentShader:
+    /* glsl */
+    "\n\t\tuniform vec3 color;\n\t\tuniform sampler2D tDiffuse;\n\t\tuniform sampler2D tDepth;\n\t\tuniform float maxDistance;\n\t\tuniform float opacity;\n\t\tuniform float fresnelCoe;\n\t\tuniform float virtualCameraNear;\n\t\tuniform float virtualCameraFar;\n\t\tuniform mat4 virtualCameraProjectionMatrix;\n\t\tuniform mat4 virtualCameraProjectionMatrixInverse;\n\t\tuniform mat4 virtualCameraMatrixWorld;\n\t\tuniform vec2 resolution;\n\t\tvarying vec4 vUv;\n\t\t#include <packing>\n\t\tfloat blendOverlay( float base, float blend ) {\n\t\t\treturn( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );\n\t\t}\n\t\tvec3 blendOverlay( vec3 base, vec3 blend ) {\n\t\t\treturn vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ), blendOverlay( base.b, blend.b ) );\n\t\t}\n\t\tfloat getDepth( const in vec2 uv ) {\n\t\t\treturn texture2D( tDepth, uv ).x;\n\t\t}\n\t\tfloat getViewZ( const in float depth ) {\n\t\t\treturn perspectiveDepthToViewZ( depth, virtualCameraNear, virtualCameraFar );\n\t\t}\n\t\tvec3 getViewPosition( const in vec2 uv, const in float depth/*clip space*/, const in float clipW ) {\n\t\t\tvec4 clipPosition = vec4( ( vec3( uv, depth ) - 0.5 ) * 2.0, 1.0 );//ndc\n\t\t\tclipPosition *= clipW; //clip\n\t\t\treturn ( virtualCameraProjectionMatrixInverse * clipPosition ).xyz;//view\n\t\t}\n\t\tvoid main() {\n\t\t\tvec4 base = texture2DProj( tDiffuse, vUv );\n\t\t\t#ifdef useDepthTexture\n\t\t\t\tvec2 uv=(gl_FragCoord.xy-.5)/resolution.xy;\n\t\t\t\tuv.x=1.-uv.x;\n\t\t\t\tfloat depth = texture2DProj( tDepth, vUv ).r;\n\t\t\t\tfloat viewZ = getViewZ( depth );\n\t\t\t\tfloat clipW = virtualCameraProjectionMatrix[2][3] * viewZ+virtualCameraProjectionMatrix[3][3];\n\t\t\t\tvec3 viewPosition=getViewPosition( uv, depth, clipW );\n\t\t\t\tvec3 worldPosition=(virtualCameraMatrixWorld*vec4(viewPosition,1)).xyz;\n\t\t\t\tif(worldPosition.y>maxDistance) discard;\n\t\t\t\tfloat op=opacity;\n\t\t\t\t#ifdef DISTANCE_ATTENUATION\n\t\t\t\t\tfloat ratio=1.-(worldPosition.y/maxDistance);\n\t\t\t\t\tfloat attenuation=ratio*ratio;\n\t\t\t\t\top=opacity*attenuation;\n\t\t\t\t#endif\n\t\t\t\t#ifdef FRESNEL\n\t\t\t\t\top*=fresnelCoe;\n\t\t\t\t#endif\n\t\t\t\tgl_FragColor = vec4( blendOverlay( base.rgb, color ), op );\n\t\t\t#else\n\t\t\t\tgl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );\n\t\t\t#endif\n\t\t}\n\t"
+  };
+});

data/lib-opal/js_wrap/three/objects/ReflectorRTT.js

@@ -0,0 +1,63 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../objects/Reflector.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../objects/Reflector.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.Reflector);
+    global.ReflectorRTT = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _Reflector2) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.ReflectorRTT = void 0;
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  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 ReflectorRTT = /*#__PURE__*/function (_Reflector) {
+    _inherits(ReflectorRTT, _Reflector);
+
+    var _super = _createSuper(ReflectorRTT);
+
+    function ReflectorRTT(geometry, options) {
+      var _this;
+
+      _classCallCheck(this, ReflectorRTT);
+
+      _this = _super.call(this, geometry, options);
+
+      _this.geometry.setDrawRange(0, 0); // avoid rendering geometry
+
+
+      return _this;
+    }
+
+    return _createClass(ReflectorRTT);
+  }(_Reflector2.Reflector);
+
+  _exports.ReflectorRTT = ReflectorRTT;
+});