opal-js_wrap-three 0.1.1 → 0.1.2

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

@@ -0,0 +1,272 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../shaders/CopyShader.js", "./ShaderPass.js", "./MaskPass.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../shaders/CopyShader.js"), require("./ShaderPass.js"), require("./MaskPass.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.CopyShader, global.ShaderPass, global.MaskPass);
+    global.EffectComposer = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _CopyShader, _ShaderPass, _MaskPass) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.Pass = _exports.FullScreenQuad = _exports.EffectComposer = 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; }
+
+  var EffectComposer = /*#__PURE__*/function () {
+    function EffectComposer(renderer, renderTarget) {
+      _classCallCheck(this, EffectComposer);
+
+      this.renderer = renderer;
+
+      if (renderTarget === undefined) {
+        var parameters = {
+          minFilter: _three.LinearFilter,
+          magFilter: _three.LinearFilter,
+          format: _three.RGBAFormat
+        };
+        var size = renderer.getSize(new _three.Vector2());
+        this._pixelRatio = renderer.getPixelRatio();
+        this._width = size.width;
+        this._height = size.height;
+        renderTarget = new _three.WebGLRenderTarget(this._width * this._pixelRatio, this._height * this._pixelRatio, parameters);
+        renderTarget.texture.name = 'EffectComposer.rt1';
+      } else {
+        this._pixelRatio = 1;
+        this._width = renderTarget.width;
+        this._height = renderTarget.height;
+      }
+
+      this.renderTarget1 = renderTarget;
+      this.renderTarget2 = renderTarget.clone();
+      this.renderTarget2.texture.name = 'EffectComposer.rt2';
+      this.writeBuffer = this.renderTarget1;
+      this.readBuffer = this.renderTarget2;
+      this.renderToScreen = true;
+      this.passes = []; // dependencies
+
+      if (_CopyShader.CopyShader === undefined) {
+        console.error('THREE.EffectComposer relies on CopyShader');
+      }
+
+      if (_ShaderPass.ShaderPass === undefined) {
+        console.error('THREE.EffectComposer relies on ShaderPass');
+      }
+
+      this.copyPass = new _ShaderPass.ShaderPass(_CopyShader.CopyShader);
+      this.clock = new _three.Clock();
+    }
+
+    _createClass(EffectComposer, [{
+      key: "swapBuffers",
+      value: function swapBuffers() {
+        var tmp = this.readBuffer;
+        this.readBuffer = this.writeBuffer;
+        this.writeBuffer = tmp;
+      }
+    }, {
+      key: "addPass",
+      value: function addPass(pass) {
+        this.passes.push(pass);
+        pass.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
+      }
+    }, {
+      key: "insertPass",
+      value: function insertPass(pass, index) {
+        this.passes.splice(index, 0, pass);
+        pass.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
+      }
+    }, {
+      key: "removePass",
+      value: function removePass(pass) {
+        var index = this.passes.indexOf(pass);
+
+        if (index !== -1) {
+          this.passes.splice(index, 1);
+        }
+      }
+    }, {
+      key: "isLastEnabledPass",
+      value: function isLastEnabledPass(passIndex) {
+        for (var i = passIndex + 1; i < this.passes.length; i++) {
+          if (this.passes[i].enabled) {
+            return false;
+          }
+        }
+
+        return true;
+      }
+    }, {
+      key: "render",
+      value: function render(deltaTime) {
+        // deltaTime value is in seconds
+        if (deltaTime === undefined) {
+          deltaTime = this.clock.getDelta();
+        }
+
+        var currentRenderTarget = this.renderer.getRenderTarget();
+        var maskActive = false;
+
+        for (var i = 0, il = this.passes.length; i < il; i++) {
+          var pass = this.passes[i];
+          if (pass.enabled === false) continue;
+          pass.renderToScreen = this.renderToScreen && this.isLastEnabledPass(i);
+          pass.render(this.renderer, this.writeBuffer, this.readBuffer, deltaTime, maskActive);
+
+          if (pass.needsSwap) {
+            if (maskActive) {
+              var context = this.renderer.getContext();
+              var stencil = this.renderer.state.buffers.stencil; //context.stencilFunc( context.NOTEQUAL, 1, 0xffffffff );
+
+              stencil.setFunc(context.NOTEQUAL, 1, 0xffffffff);
+              this.copyPass.render(this.renderer, this.writeBuffer, this.readBuffer, deltaTime); //context.stencilFunc( context.EQUAL, 1, 0xffffffff );
+
+              stencil.setFunc(context.EQUAL, 1, 0xffffffff);
+            }
+
+            this.swapBuffers();
+          }
+
+          if (_MaskPass.MaskPass !== undefined) {
+            if (pass instanceof _MaskPass.MaskPass) {
+              maskActive = true;
+            } else if (pass instanceof _MaskPass.ClearMaskPass) {
+              maskActive = false;
+            }
+          }
+        }
+
+        this.renderer.setRenderTarget(currentRenderTarget);
+      }
+    }, {
+      key: "reset",
+      value: function reset(renderTarget) {
+        if (renderTarget === undefined) {
+          var size = this.renderer.getSize(new _three.Vector2());
+          this._pixelRatio = this.renderer.getPixelRatio();
+          this._width = size.width;
+          this._height = size.height;
+          renderTarget = this.renderTarget1.clone();
+          renderTarget.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
+        }
+
+        this.renderTarget1.dispose();
+        this.renderTarget2.dispose();
+        this.renderTarget1 = renderTarget;
+        this.renderTarget2 = renderTarget.clone();
+        this.writeBuffer = this.renderTarget1;
+        this.readBuffer = this.renderTarget2;
+      }
+    }, {
+      key: "setSize",
+      value: function setSize(width, height) {
+        this._width = width;
+        this._height = height;
+        var effectiveWidth = this._width * this._pixelRatio;
+        var effectiveHeight = this._height * this._pixelRatio;
+        this.renderTarget1.setSize(effectiveWidth, effectiveHeight);
+        this.renderTarget2.setSize(effectiveWidth, effectiveHeight);
+
+        for (var i = 0; i < this.passes.length; i++) {
+          this.passes[i].setSize(effectiveWidth, effectiveHeight);
+        }
+      }
+    }, {
+      key: "setPixelRatio",
+      value: function setPixelRatio(pixelRatio) {
+        this._pixelRatio = pixelRatio;
+        this.setSize(this._width, this._height);
+      }
+    }]);
+
+    return EffectComposer;
+  }();
+
+  _exports.EffectComposer = EffectComposer;
+
+  var Pass = /*#__PURE__*/function () {
+    function Pass() {
+      _classCallCheck(this, Pass);
+
+      // if set to true, the pass is processed by the composer
+      this.enabled = true; // if set to true, the pass indicates to swap read and write buffer after rendering
+
+      this.needsSwap = true; // if set to true, the pass clears its buffer before rendering
+
+      this.clear = false; // if set to true, the result of the pass is rendered to screen. This is set automatically by EffectComposer.
+
+      this.renderToScreen = false;
+    }
+
+    _createClass(Pass, [{
+      key: "setSize",
+      value: function
+        /* width, height */
+      setSize() {}
+    }, {
+      key: "render",
+      value: function
+        /* renderer, writeBuffer, readBuffer, deltaTime, maskActive */
+      render() {
+        console.error('THREE.Pass: .render() must be implemented in derived pass.');
+      }
+    }]);
+
+    return Pass;
+  }(); // Helper for passes that need to fill the viewport with a single quad.
+
+
+  _exports.Pass = Pass;
+
+  var _camera = new _three.OrthographicCamera(-1, 1, 1, -1, 0, 1); // https://github.com/mrdoob/three.js/pull/21358
+
+
+  var _geometry = new _three.BufferGeometry();
+
+  _geometry.setAttribute('position', new _three.Float32BufferAttribute([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3));
+
+  _geometry.setAttribute('uv', new _three.Float32BufferAttribute([0, 2, 0, 0, 2, 0], 2));
+
+  var FullScreenQuad = /*#__PURE__*/function () {
+    function FullScreenQuad(material) {
+      _classCallCheck(this, FullScreenQuad);
+
+      this._mesh = new _three.Mesh(_geometry, material);
+    }
+
+    _createClass(FullScreenQuad, [{
+      key: "dispose",
+      value: function dispose() {
+        this._mesh.geometry.dispose();
+      }
+    }, {
+      key: "render",
+      value: function render(renderer) {
+        renderer.render(this._mesh, _camera);
+      }
+    }, {
+      key: "material",
+      get: function get() {
+        return this._mesh.material;
+      },
+      set: function set(value) {
+        this._mesh.material = value;
+      }
+    }]);
+
+    return FullScreenQuad;
+  }();
+
+  _exports.FullScreenQuad = FullScreenQuad;
+});

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

@@ -0,0 +1,91 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "./Pass.js", "../shaders/FilmShader.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("./Pass.js"), require("../shaders/FilmShader.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.Pass, global.FilmShader);
+    global.FilmPass = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _Pass2, _FilmShader) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.FilmPass = 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 FilmPass = /*#__PURE__*/function (_Pass) {
+    _inherits(FilmPass, _Pass);
+
+    var _super = _createSuper(FilmPass);
+
+    function FilmPass(noiseIntensity, scanlinesIntensity, scanlinesCount, grayscale) {
+      var _this;
+
+      _classCallCheck(this, FilmPass);
+
+      _this = _super.call(this);
+      if (_FilmShader.FilmShader === undefined) console.error('THREE.FilmPass relies on FilmShader');
+      var shader = _FilmShader.FilmShader;
+      _this.uniforms = _three.UniformsUtils.clone(shader.uniforms);
+      _this.material = new _three.ShaderMaterial({
+        uniforms: _this.uniforms,
+        vertexShader: shader.vertexShader,
+        fragmentShader: shader.fragmentShader
+      });
+      if (grayscale !== undefined) _this.uniforms.grayscale.value = grayscale;
+      if (noiseIntensity !== undefined) _this.uniforms.nIntensity.value = noiseIntensity;
+      if (scanlinesIntensity !== undefined) _this.uniforms.sIntensity.value = scanlinesIntensity;
+      if (scanlinesCount !== undefined) _this.uniforms.sCount.value = scanlinesCount;
+      _this.fsQuad = new _Pass2.FullScreenQuad(_this.material);
+      return _this;
+    }
+
+    _createClass(FilmPass, [{
+      key: "render",
+      value: function render(renderer, writeBuffer, readBuffer, deltaTime
+      /*, maskActive */
+      ) {
+        this.uniforms['tDiffuse'].value = readBuffer.texture;
+        this.uniforms['time'].value += deltaTime;
+
+        if (this.renderToScreen) {
+          renderer.setRenderTarget(null);
+          this.fsQuad.render(renderer);
+        } else {
+          renderer.setRenderTarget(writeBuffer);
+          if (this.clear) renderer.clear();
+          this.fsQuad.render(renderer);
+        }
+      }
+    }]);
+
+    return FilmPass;
+  }(_Pass2.Pass);
+
+  _exports.FilmPass = FilmPass;
+});

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

@@ -0,0 +1,140 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "./Pass.js", "../shaders/DigitalGlitch.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("./Pass.js"), require("../shaders/DigitalGlitch.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.Pass, global.DigitalGlitch);
+    global.GlitchPass = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _Pass2, _DigitalGlitch) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.GlitchPass = 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 GlitchPass = /*#__PURE__*/function (_Pass) {
+    _inherits(GlitchPass, _Pass);
+
+    var _super = _createSuper(GlitchPass);
+
+    function GlitchPass() {
+      var _this;
+
+      var dt_size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 64;
+
+      _classCallCheck(this, GlitchPass);
+
+      _this = _super.call(this);
+      if (_DigitalGlitch.DigitalGlitch === undefined) console.error('THREE.GlitchPass relies on DigitalGlitch');
+      var shader = _DigitalGlitch.DigitalGlitch;
+      _this.uniforms = _three.UniformsUtils.clone(shader.uniforms);
+      _this.uniforms['tDisp'].value = _this.generateHeightmap(dt_size);
+      _this.material = new _three.ShaderMaterial({
+        uniforms: _this.uniforms,
+        vertexShader: shader.vertexShader,
+        fragmentShader: shader.fragmentShader
+      });
+      _this.fsQuad = new _Pass2.FullScreenQuad(_this.material);
+      _this.goWild = false;
+      _this.curF = 0;
+
+      _this.generateTrigger();
+
+      return _this;
+    }
+
+    _createClass(GlitchPass, [{
+      key: "render",
+      value: function render(renderer, writeBuffer, readBuffer
+      /*, deltaTime, maskActive */
+      ) {
+        this.uniforms['tDiffuse'].value = readBuffer.texture;
+        this.uniforms['seed'].value = Math.random(); //default seeding
+
+        this.uniforms['byp'].value = 0;
+
+        if (this.curF % this.randX == 0 || this.goWild == true) {
+          this.uniforms['amount'].value = Math.random() / 30;
+          this.uniforms['angle'].value = _three.MathUtils.randFloat(-Math.PI, Math.PI);
+          this.uniforms['seed_x'].value = _three.MathUtils.randFloat(-1, 1);
+          this.uniforms['seed_y'].value = _three.MathUtils.randFloat(-1, 1);
+          this.uniforms['distortion_x'].value = _three.MathUtils.randFloat(0, 1);
+          this.uniforms['distortion_y'].value = _three.MathUtils.randFloat(0, 1);
+          this.curF = 0;
+          this.generateTrigger();
+        } else if (this.curF % this.randX < this.randX / 5) {
+          this.uniforms['amount'].value = Math.random() / 90;
+          this.uniforms['angle'].value = _three.MathUtils.randFloat(-Math.PI, Math.PI);
+          this.uniforms['distortion_x'].value = _three.MathUtils.randFloat(0, 1);
+          this.uniforms['distortion_y'].value = _three.MathUtils.randFloat(0, 1);
+          this.uniforms['seed_x'].value = _three.MathUtils.randFloat(-0.3, 0.3);
+          this.uniforms['seed_y'].value = _three.MathUtils.randFloat(-0.3, 0.3);
+        } else if (this.goWild == false) {
+          this.uniforms['byp'].value = 1;
+        }
+
+        this.curF++;
+
+        if (this.renderToScreen) {
+          renderer.setRenderTarget(null);
+          this.fsQuad.render(renderer);
+        } else {
+          renderer.setRenderTarget(writeBuffer);
+          if (this.clear) renderer.clear();
+          this.fsQuad.render(renderer);
+        }
+      }
+    }, {
+      key: "generateTrigger",
+      value: function generateTrigger() {
+        this.randX = _three.MathUtils.randInt(120, 240);
+      }
+    }, {
+      key: "generateHeightmap",
+      value: function generateHeightmap(dt_size) {
+        var data_arr = new Float32Array(dt_size * dt_size * 3);
+        var length = dt_size * dt_size;
+
+        for (var i = 0; i < length; i++) {
+          var val = _three.MathUtils.randFloat(0, 1);
+
+          data_arr[i * 3 + 0] = val;
+          data_arr[i * 3 + 1] = val;
+          data_arr[i * 3 + 2] = val;
+        }
+
+        return new _three.DataTexture(data_arr, dt_size, dt_size, _three.RGBFormat, _three.FloatType);
+      }
+    }]);
+
+    return GlitchPass;
+  }(_Pass2.Pass);
+
+  _exports.GlitchPass = GlitchPass;
+});

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

@@ -0,0 +1,108 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "./Pass.js", "../shaders/HalftoneShader.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("./Pass.js"), require("../shaders/HalftoneShader.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.Pass, global.HalftoneShader);
+    global.HalftonePass = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _Pass2, _HalftoneShader) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.HalftonePass = 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); }
+
+  /**
+   * RGB Halftone pass for three.js effects composer. Requires HalftoneShader.
+   */
+  var HalftonePass = /*#__PURE__*/function (_Pass) {
+    _inherits(HalftonePass, _Pass);
+
+    var _super = _createSuper(HalftonePass);
+
+    function HalftonePass(width, height, params) {
+      var _this;
+
+      _classCallCheck(this, HalftonePass);
+
+      _this = _super.call(this);
+
+      if (_HalftoneShader.HalftoneShader === undefined) {
+        console.error('THREE.HalftonePass requires HalftoneShader');
+      }
+
+      _this.uniforms = _three.UniformsUtils.clone(_HalftoneShader.HalftoneShader.uniforms);
+      _this.material = new _three.ShaderMaterial({
+        uniforms: _this.uniforms,
+        fragmentShader: _HalftoneShader.HalftoneShader.fragmentShader,
+        vertexShader: _HalftoneShader.HalftoneShader.vertexShader
+      }); // set params
+
+      _this.uniforms.width.value = width;
+      _this.uniforms.height.value = height;
+
+      for (var key in params) {
+        if (params.hasOwnProperty(key) && _this.uniforms.hasOwnProperty(key)) {
+          _this.uniforms[key].value = params[key];
+        }
+      }
+
+      _this.fsQuad = new _Pass2.FullScreenQuad(_this.material);
+      return _this;
+    }
+
+    _createClass(HalftonePass, [{
+      key: "render",
+      value: function render(renderer, writeBuffer, readBuffer
+      /*, deltaTime, maskActive*/
+      ) {
+        this.material.uniforms['tDiffuse'].value = readBuffer.texture;
+
+        if (this.renderToScreen) {
+          renderer.setRenderTarget(null);
+          this.fsQuad.render(renderer);
+        } else {
+          renderer.setRenderTarget(writeBuffer);
+          if (this.clear) renderer.clear();
+          this.fsQuad.render(renderer);
+        }
+      }
+    }, {
+      key: "setSize",
+      value: function setSize(width, height) {
+        this.uniforms.width.value = width;
+        this.uniforms.height.value = height;
+      }
+    }]);
+
+    return HalftonePass;
+  }(_Pass2.Pass);
+
+  _exports.HalftonePass = HalftonePass;
+});