opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/postprocessing/SSAOPass.js

@@ -0,0 +1,388 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "./Pass.js", "../math/SimplexNoise.js", "../shaders/SSAOShader.js", "../shaders/CopyShader.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("./Pass.js"), require("../math/SimplexNoise.js"), require("../shaders/SSAOShader.js"), require("../shaders/CopyShader.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.Pass, global.SimplexNoise, global.SSAOShader, global.CopyShader);
+    global.SSAOPass = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _Pass2, _SimplexNoise, _SSAOShader, _CopyShader) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.SSAOPass = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var SSAOPass = /*#__PURE__*/function (_Pass) {
+    _inherits(SSAOPass, _Pass);
+
+    var _super = _createSuper(SSAOPass);
+
+    function SSAOPass(scene, camera, width, height) {
+      var _this;
+
+      _classCallCheck(this, SSAOPass);
+
+      _this = _super.call(this);
+      _this.width = width !== undefined ? width : 512;
+      _this.height = height !== undefined ? height : 512;
+      _this.clear = true;
+      _this.camera = camera;
+      _this.scene = scene;
+      _this.kernelRadius = 8;
+      _this.kernelSize = 32;
+      _this.kernel = [];
+      _this.noiseTexture = null;
+      _this.output = 0;
+      _this.minDistance = 0.005;
+      _this.maxDistance = 0.1;
+      _this._visibilityCache = new Map(); //
+
+      _this.generateSampleKernel();
+
+      _this.generateRandomKernelRotations(); // beauty render target
+
+
+      var depthTexture = new _three.DepthTexture();
+      depthTexture.type = _three.UnsignedShortType;
+      _this.beautyRenderTarget = new _three.WebGLRenderTarget(_this.width, _this.height, {
+        minFilter: _three.LinearFilter,
+        magFilter: _three.LinearFilter,
+        format: _three.RGBAFormat
+      }); // normal render target with depth buffer
+
+      _this.normalRenderTarget = new _three.WebGLRenderTarget(_this.width, _this.height, {
+        minFilter: _three.NearestFilter,
+        magFilter: _three.NearestFilter,
+        format: _three.RGBAFormat,
+        depthTexture: depthTexture
+      }); // ssao render target
+
+      _this.ssaoRenderTarget = new _three.WebGLRenderTarget(_this.width, _this.height, {
+        minFilter: _three.LinearFilter,
+        magFilter: _three.LinearFilter,
+        format: _three.RGBAFormat
+      });
+      _this.blurRenderTarget = _this.ssaoRenderTarget.clone(); // ssao material
+
+      if (_SSAOShader.SSAOShader === undefined) {
+        console.error('THREE.SSAOPass: The pass relies on SSAOShader.');
+      }
+
+      _this.ssaoMaterial = new _three.ShaderMaterial({
+        defines: Object.assign({}, _SSAOShader.SSAOShader.defines),
+        uniforms: _three.UniformsUtils.clone(_SSAOShader.SSAOShader.uniforms),
+        vertexShader: _SSAOShader.SSAOShader.vertexShader,
+        fragmentShader: _SSAOShader.SSAOShader.fragmentShader,
+        blending: _three.NoBlending
+      });
+      _this.ssaoMaterial.uniforms['tDiffuse'].value = _this.beautyRenderTarget.texture;
+      _this.ssaoMaterial.uniforms['tNormal'].value = _this.normalRenderTarget.texture;
+      _this.ssaoMaterial.uniforms['tDepth'].value = _this.normalRenderTarget.depthTexture;
+      _this.ssaoMaterial.uniforms['tNoise'].value = _this.noiseTexture;
+      _this.ssaoMaterial.uniforms['kernel'].value = _this.kernel;
+      _this.ssaoMaterial.uniforms['cameraNear'].value = _this.camera.near;
+      _this.ssaoMaterial.uniforms['cameraFar'].value = _this.camera.far;
+
+      _this.ssaoMaterial.uniforms['resolution'].value.set(_this.width, _this.height);
+
+      _this.ssaoMaterial.uniforms['cameraProjectionMatrix'].value.copy(_this.camera.projectionMatrix);
+
+      _this.ssaoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(_this.camera.projectionMatrixInverse); // normal material
+
+
+      _this.normalMaterial = new _three.MeshNormalMaterial();
+      _this.normalMaterial.blending = _three.NoBlending; // blur material
+
+      _this.blurMaterial = new _three.ShaderMaterial({
+        defines: Object.assign({}, _SSAOShader.SSAOBlurShader.defines),
+        uniforms: _three.UniformsUtils.clone(_SSAOShader.SSAOBlurShader.uniforms),
+        vertexShader: _SSAOShader.SSAOBlurShader.vertexShader,
+        fragmentShader: _SSAOShader.SSAOBlurShader.fragmentShader
+      });
+      _this.blurMaterial.uniforms['tDiffuse'].value = _this.ssaoRenderTarget.texture;
+
+      _this.blurMaterial.uniforms['resolution'].value.set(_this.width, _this.height); // material for rendering the depth
+
+
+      _this.depthRenderMaterial = new _three.ShaderMaterial({
+        defines: Object.assign({}, _SSAOShader.SSAODepthShader.defines),
+        uniforms: _three.UniformsUtils.clone(_SSAOShader.SSAODepthShader.uniforms),
+        vertexShader: _SSAOShader.SSAODepthShader.vertexShader,
+        fragmentShader: _SSAOShader.SSAODepthShader.fragmentShader,
+        blending: _three.NoBlending
+      });
+      _this.depthRenderMaterial.uniforms['tDepth'].value = _this.normalRenderTarget.depthTexture;
+      _this.depthRenderMaterial.uniforms['cameraNear'].value = _this.camera.near;
+      _this.depthRenderMaterial.uniforms['cameraFar'].value = _this.camera.far; // material for rendering the content of a render target
+
+      _this.copyMaterial = new _three.ShaderMaterial({
+        uniforms: _three.UniformsUtils.clone(_CopyShader.CopyShader.uniforms),
+        vertexShader: _CopyShader.CopyShader.vertexShader,
+        fragmentShader: _CopyShader.CopyShader.fragmentShader,
+        transparent: true,
+        depthTest: false,
+        depthWrite: false,
+        blendSrc: _three.DstColorFactor,
+        blendDst: _three.ZeroFactor,
+        blendEquation: _three.AddEquation,
+        blendSrcAlpha: _three.DstAlphaFactor,
+        blendDstAlpha: _three.ZeroFactor,
+        blendEquationAlpha: _three.AddEquation
+      });
+      _this.fsQuad = new _Pass2.FullScreenQuad(null);
+      _this.originalClearColor = new _three.Color();
+      return _this;
+    }
+
+    _createClass(SSAOPass, [{
+      key: "dispose",
+      value: function dispose() {
+        // dispose render targets
+        this.beautyRenderTarget.dispose();
+        this.normalRenderTarget.dispose();
+        this.ssaoRenderTarget.dispose();
+        this.blurRenderTarget.dispose(); // dispose materials
+
+        this.normalMaterial.dispose();
+        this.blurMaterial.dispose();
+        this.copyMaterial.dispose();
+        this.depthRenderMaterial.dispose(); // dipsose full screen quad
+
+        this.fsQuad.dispose();
+      }
+    }, {
+      key: "render",
+      value: function render(renderer, writeBuffer
+      /*, readBuffer, deltaTime, maskActive */
+      ) {
+        // render beauty
+        renderer.setRenderTarget(this.beautyRenderTarget);
+        renderer.clear();
+        renderer.render(this.scene, this.camera); // render normals and depth (honor only meshes, points and lines do not contribute to SSAO)
+
+        this.overrideVisibility();
+        this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0x7777ff, 1.0);
+        this.restoreVisibility(); // render SSAO
+
+        this.ssaoMaterial.uniforms['kernelRadius'].value = this.kernelRadius;
+        this.ssaoMaterial.uniforms['minDistance'].value = this.minDistance;
+        this.ssaoMaterial.uniforms['maxDistance'].value = this.maxDistance;
+        this.renderPass(renderer, this.ssaoMaterial, this.ssaoRenderTarget); // render blur
+
+        this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget); // output result to screen
+
+        switch (this.output) {
+          case SSAOPass.OUTPUT.SSAO:
+            this.copyMaterial.uniforms['tDiffuse'].value = this.ssaoRenderTarget.texture;
+            this.copyMaterial.blending = _three.NoBlending;
+            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+            break;
+
+          case SSAOPass.OUTPUT.Blur:
+            this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget.texture;
+            this.copyMaterial.blending = _three.NoBlending;
+            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+            break;
+
+          case SSAOPass.OUTPUT.Beauty:
+            this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture;
+            this.copyMaterial.blending = _three.NoBlending;
+            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+            break;
+
+          case SSAOPass.OUTPUT.Depth:
+            this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer);
+            break;
+
+          case SSAOPass.OUTPUT.Normal:
+            this.copyMaterial.uniforms['tDiffuse'].value = this.normalRenderTarget.texture;
+            this.copyMaterial.blending = _three.NoBlending;
+            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+            break;
+
+          case SSAOPass.OUTPUT.Default:
+            this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture;
+            this.copyMaterial.blending = _three.NoBlending;
+            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+            this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget.texture;
+            this.copyMaterial.blending = _three.CustomBlending;
+            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+            break;
+
+          default:
+            console.warn('THREE.SSAOPass: Unknown output type.');
+        }
+      }
+    }, {
+      key: "renderPass",
+      value: function renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
+        // save original state
+        renderer.getClearColor(this.originalClearColor);
+        var originalClearAlpha = renderer.getClearAlpha();
+        var originalAutoClear = renderer.autoClear;
+        renderer.setRenderTarget(renderTarget); // setup pass state
+
+        renderer.autoClear = false;
+
+        if (clearColor !== undefined && clearColor !== null) {
+          renderer.setClearColor(clearColor);
+          renderer.setClearAlpha(clearAlpha || 0.0);
+          renderer.clear();
+        }
+
+        this.fsQuad.material = passMaterial;
+        this.fsQuad.render(renderer); // restore original state
+
+        renderer.autoClear = originalAutoClear;
+        renderer.setClearColor(this.originalClearColor);
+        renderer.setClearAlpha(originalClearAlpha);
+      }
+    }, {
+      key: "renderOverride",
+      value: function renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+        renderer.getClearColor(this.originalClearColor);
+        var originalClearAlpha = renderer.getClearAlpha();
+        var originalAutoClear = renderer.autoClear;
+        renderer.setRenderTarget(renderTarget);
+        renderer.autoClear = false;
+        clearColor = overrideMaterial.clearColor || clearColor;
+        clearAlpha = overrideMaterial.clearAlpha || clearAlpha;
+
+        if (clearColor !== undefined && clearColor !== null) {
+          renderer.setClearColor(clearColor);
+          renderer.setClearAlpha(clearAlpha || 0.0);
+          renderer.clear();
+        }
+
+        this.scene.overrideMaterial = overrideMaterial;
+        renderer.render(this.scene, this.camera);
+        this.scene.overrideMaterial = null; // restore original state
+
+        renderer.autoClear = originalAutoClear;
+        renderer.setClearColor(this.originalClearColor);
+        renderer.setClearAlpha(originalClearAlpha);
+      }
+    }, {
+      key: "setSize",
+      value: function setSize(width, height) {
+        this.width = width;
+        this.height = height;
+        this.beautyRenderTarget.setSize(width, height);
+        this.ssaoRenderTarget.setSize(width, height);
+        this.normalRenderTarget.setSize(width, height);
+        this.blurRenderTarget.setSize(width, height);
+        this.ssaoMaterial.uniforms['resolution'].value.set(width, height);
+        this.ssaoMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix);
+        this.ssaoMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse);
+        this.blurMaterial.uniforms['resolution'].value.set(width, height);
+      }
+    }, {
+      key: "generateSampleKernel",
+      value: function generateSampleKernel() {
+        var kernelSize = this.kernelSize;
+        var kernel = this.kernel;
+
+        for (var i = 0; i < kernelSize; i++) {
+          var sample = new _three.Vector3();
+          sample.x = Math.random() * 2 - 1;
+          sample.y = Math.random() * 2 - 1;
+          sample.z = Math.random();
+          sample.normalize();
+          var scale = i / kernelSize;
+          scale = _three.MathUtils.lerp(0.1, 1, scale * scale);
+          sample.multiplyScalar(scale);
+          kernel.push(sample);
+        }
+      }
+    }, {
+      key: "generateRandomKernelRotations",
+      value: function generateRandomKernelRotations() {
+        var width = 4,
+            height = 4;
+
+        if (_SimplexNoise.SimplexNoise === undefined) {
+          console.error('THREE.SSAOPass: The pass relies on SimplexNoise.');
+        }
+
+        var simplex = new _SimplexNoise.SimplexNoise();
+        var size = width * height;
+        var data = new Float32Array(size * 4);
+
+        for (var i = 0; i < size; i++) {
+          var stride = i * 4;
+          var x = Math.random() * 2 - 1;
+          var y = Math.random() * 2 - 1;
+          var z = 0;
+          var noise = simplex.noise3d(x, y, z);
+          data[stride] = noise;
+          data[stride + 1] = noise;
+          data[stride + 2] = noise;
+          data[stride + 3] = 1;
+        }
+
+        this.noiseTexture = new _three.DataTexture(data, width, height, _three.RGBAFormat, _three.FloatType);
+        this.noiseTexture.wrapS = _three.RepeatWrapping;
+        this.noiseTexture.wrapT = _three.RepeatWrapping;
+      }
+    }, {
+      key: "overrideVisibility",
+      value: function overrideVisibility() {
+        var scene = this.scene;
+        var cache = this._visibilityCache;
+        scene.traverse(function (object) {
+          cache.set(object, object.visible);
+          if (object.isPoints || object.isLine) object.visible = false;
+        });
+      }
+    }, {
+      key: "restoreVisibility",
+      value: function restoreVisibility() {
+        var scene = this.scene;
+        var cache = this._visibilityCache;
+        scene.traverse(function (object) {
+          var visible = cache.get(object);
+          object.visible = visible;
+        });
+        cache.clear();
+      }
+    }]);
+
+    return SSAOPass;
+  }(_Pass2.Pass);
+
+  _exports.SSAOPass = SSAOPass;
+  SSAOPass.OUTPUT = {
+    'Default': 0,
+    'SSAO': 1,
+    'Blur': 2,
+    'Beauty': 3,
+    'Depth': 4,
+    'Normal': 5
+  };
+});