@xviewer.js/postprocessing 1.0.0-alpha.4 → 1.0.0-alpha.6

package/dist/module.js

@@ -1,20 +1,284 @@
 import { Plugin, property } from '@xviewer.js/core';
-import { Pass, Effect, RenderPass, Selection, NormalPass, EffectPass, EffectComposer, ToneMappingMode, ToneMappingEffect, BloomEffect, BlendFunction, FXAAEffect, SMAAPreset, EdgeDetectionMode, PredicationMode, SMAAEffect } from 'postprocessing';
-import { ShaderChunk, ShaderLib, UniformsUtils, ShaderMaterial, Uniform, Vector2, Matrix4, Vector3, NoBlending, GLSL3, FramebufferTexture, LinearFilter, Clock, Quaternion, WebGLRenderTarget, NearestFilter, DataTexture, RGBAFormat, FloatType, ClampToEdgeWrapping, LinearMipMapLinearFilter, EquirectangularReflectionMapping, TextureLoader, RepeatWrapping, NoColorSpace, MeshPhysicalMaterial, Color, DepthTexture, RedFormat, Matrix3, HalfFloatType, WebGLMultipleRenderTargets, SRGBColorSpace } from 'three';
-
-function _extends() {
-    _extends = Object.assign || function assign(target) {
-        for (var i = 1; i < arguments.length; i++) {
-            var source = arguments[i];
-            for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+import { RenderPass, EffectPass, EffectComposer, ToneMappingMode, ToneMappingEffect, BloomEffect, BlendFunction, FXAAEffect, SMAAPreset, EdgeDetectionMode, PredicationMode, SMAAEffect, Pass, Effect, Selection, NormalPass } from 'postprocessing';
+import { HalfFloatType, ShaderChunk, ShaderLib, UniformsUtils, ShaderMaterial, Uniform, Vector2, Matrix4, Vector3, NoBlending, GLSL3, FramebufferTexture, LinearFilter, Clock, Quaternion, WebGLRenderTarget, NearestFilter, DataTexture, RGBAFormat, FloatType, ClampToEdgeWrapping, LinearMipMapLinearFilter, EquirectangularReflectionMapping, TextureLoader, RepeatWrapping, NoColorSpace, MeshPhysicalMaterial, Color, DepthTexture, RedFormat, Matrix3, WebGLMultipleRenderTargets, SRGBColorSpace } from 'three';
+
+class EffectComposerPlugin extends Plugin {
+    static Instance(viewer) {
+        return viewer.getPlugin(EffectComposerPlugin, true);
+    }
+    get multisampling() {
+        return this._composer.multisampling;
+    }
+    set multisampling(v) {
+        this._composer.multisampling = v;
+    }
+    getPass(constructor) {
+        return this._composer.passes.find((v)=>v.constructor === constructor);
+    }
+    addPass(pass) {
+        this._composer.addPass(pass, this._composer.passes.length - 1);
+        this._checkOutputPass();
+        return pass;
+    }
+    removePass(pass) {
+        this._composer.removePass(pass);
+        this._checkOutputPass();
+    }
+    activePass(pass, v) {
+        pass.enabled = v;
+        this._checkOutputPass();
+        return pass;
+    }
+    _checkOutputPass() {
+        const count = this._composer.passes.filter((v)=>v.enabled && v.name !== "VelocityDepthNormalPass" && v !== this._outputPass).length;
+        this._outputPass.enabled = this._composer.multisampling > 0 && count === 1;
+        this._setRenderToScreen();
+    }
+    _setRenderToScreen() {
+        const passes = this._composer.passes;
+        for(let k = 0, i = passes.length; i--;){
+            let pass = passes[i];
+            if (pass.enabled && pass.name !== "VelocityDepthNormalPass" && k === 0) {
+                k = i;
+            }
+            pass.renderToScreen = k === i;
         }
+    }
+    constructor(props){
+        super();
+        this.install = ()=>{
+            const { renderer, scene, camera } = this.viewer;
+            this._renderPass = new RenderPass(scene, camera);
+            this._outputPass = new EffectPass(camera);
+            this._composer = new EffectComposer(renderer, Object.assign({
+                frameBufferType: HalfFloatType
+            }, props));
+            this._composer.addPass(this._renderPass);
+            this._composer.addPass(this._outputPass);
+            this.viewer._onResize = (width, height)=>this._composer.setSize(width, height);
+            this.viewer._onRender = (dt)=>this._composer.render(dt);
+        };
+        this.uninstall = ()=>{
+            this._composer.dispose();
+        };
+    }
+}
 
-        return target;
-    };
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
 
-    return _extends.apply(this, arguments);
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+class PassPlugin extends Plugin {
+    get enable() {
+        return this.pass.enabled;
+    }
+    set enable(v) {
+        this.setEnable(v);
+    }
+    get composer() {
+        return EffectComposerPlugin.Instance(this.viewer);
+    }
+    setEnable(v) {
+        this.composer.activePass(this.pass, v);
+    }
+}
+__decorate([
+    property
+], PassPlugin.prototype, "enable", null);
+
+class ToneMappingPlugin extends PassPlugin {
+    get mode() {
+        return this.effect.mode;
+    }
+    set mode(v) {
+        this.effect.mode = v;
+    }
+    constructor(props){
+        super();
+        this.install = ()=>{
+            this.effect = new ToneMappingEffect(props);
+            this.pass = this.composer.addPass(new EffectPass(this.viewer.camera, this.effect));
+        };
+        this.uninstall = ()=>{
+            this.composer.removePass(this.pass);
+        };
+    }
+}
+__decorate([
+    property({
+        value: ToneMappingMode
+    })
+], ToneMappingPlugin.prototype, "mode", null);
+
+class BloomPlugin extends PassPlugin {
+    get intensity() {
+        return this.effect.intensity;
+    }
+    set intensity(v) {
+        this.effect.intensity = v;
+    }
+    get luminanceThreshold() {
+        return this.effect.luminanceMaterial.threshold;
+    }
+    set luminanceThreshold(v) {
+        this.effect.luminanceMaterial.threshold = v;
+    }
+    get luminanceSmoothing() {
+        return this.effect.luminanceMaterial.smoothing;
+    }
+    set luminanceSmoothing(v) {
+        this.effect.luminanceMaterial.smoothing = v;
+    }
+    constructor(props){
+        super();
+        this.install = ()=>{
+            this.effect = new BloomEffect({
+                blendFunction: BlendFunction.ADD,
+                ...props
+            });
+            this.pass = this.composer.addPass(new EffectPass(this.viewer.camera, this.effect));
+        };
+        this.uninstall = ()=>{
+            this.composer.removePass(this.pass);
+        };
+    }
+}
+__decorate([
+    property({
+        min: 0,
+        max: 2,
+        step: 0.01
+    })
+], BloomPlugin.prototype, "intensity", null);
+__decorate([
+    property({
+        min: 0,
+        max: 10,
+        step: 0.01
+    })
+], BloomPlugin.prototype, "luminanceThreshold", null);
+__decorate([
+    property({
+        min: 0,
+        max: 10,
+        step: 0.01
+    })
+], BloomPlugin.prototype, "luminanceSmoothing", null);
+
+class FXAAPlugin extends PassPlugin {
+    constructor(){
+        super();
+        this.install = ()=>{
+            this.pass = this.composer.addPass(new EffectPass(this.viewer.camera, new FXAAEffect()));
+        };
+        this.uninstall = ()=>{
+            this.composer.removePass(this.pass);
+        };
+    }
+}
+
+class SMAAPlugin extends PassPlugin {
+    get preset() {
+        return this._preset;
+    }
+    set preset(v) {
+        if (this._preset !== v) {
+            this._preset = v;
+            this.effect.applyPreset(v);
+        }
+    }
+    get edgeDetectionMode() {
+        return this.effect.edgeDetectionMaterial.edgeDetectionMode;
+    }
+    set edgeDetectionMode(v) {
+        this.effect.edgeDetectionMaterial.edgeDetectionMode = v;
+    }
+    get predicationMode() {
+        return this.effect.edgeDetectionMaterial.predicationMode;
+    }
+    set predicationMode(v) {
+        this.effect.edgeDetectionMaterial.predicationMode = v;
+    }
+    constructor(props = {}){
+        super();
+        this._preset = SMAAPreset.MEDIUM;
+        this.install = ()=>{
+            this.effect = new SMAAEffect(props);
+            this.pass = this.composer.addPass(new EffectPass(this.viewer.camera, this.effect));
+        };
+        this.uninstall = ()=>{
+            this.composer.removePass(this.pass);
+        };
+    }
+}
+__decorate([
+    property({
+        value: SMAAPreset
+    })
+], SMAAPlugin.prototype, "preset", null);
+__decorate([
+    property({
+        value: EdgeDetectionMode
+    })
+], SMAAPlugin.prototype, "edgeDetectionMode", null);
+__decorate([
+    property({
+        value: PredicationMode
+    })
+], SMAAPlugin.prototype, "predicationMode", null);
+
+class MSAAPlugin extends Plugin {
+    get enable() {
+        return this.composer.multisampling > 0;
+    }
+    set enable(v) {
+        this.composer.multisampling = v ? this._maxSamples : 0;
+    }
+    get composer() {
+        return EffectComposerPlugin.Instance(this.viewer);
+    }
+    constructor(){
+        super();
+        this._maxSamples = 4;
+        this.install = ()=>{
+            const { renderer } = this.viewer;
+            this._maxSamples = Math.min(4, renderer.capabilities.maxSamples);
+            this.composer.multisampling = this._maxSamples;
+        };
+        this.uninstall = ()=>{
+            this.composer.multisampling = 0;
+        };
+    }
+}
+__decorate([
+    property
+], MSAAPlugin.prototype, "enable", null);
+
 // from: https://news.ycombinator.com/item?id=17876741
 // reference: http://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/
 // eslint-disable-next-line no-unused-vars
@@ -296,7 +560,10 @@ class TemporalReprojectPass extends Pass {
         this._scene = scene;
         this._camera = camera;
         this.textureCount = textureCount;
-        options = _extends({}, defaultTemporalReprojectPassOptions, options);
+        options = {
+            ...defaultTemporalReprojectPassOptions,
+            ...options
+        };
         this.renderTarget = new WebGLRenderTarget(1, 1, {
             count: textureCount,
             minFilter: NearestFilter,
@@ -389,15 +656,21 @@ class TRAAEffect extends Effect {
         this._scene = scene;
         this._camera = camera;
         this.velocityDepthNormalPass = velocityDepthNormalPass;
-        options = _extends({}, options, {
-            maxBlend: 0.9,
-            neighborhoodClamp: true,
-            neighborhoodClampIntensity: 1,
-            neighborhoodClampRadius: 1,
-            logTransform: true,
-            confidencePower: 4
-        });
-        this.options = _extends({}, defaultTemporalReprojectPassOptions, options);
+        options = {
+            ...options,
+            ...{
+                maxBlend: 0.9,
+                neighborhoodClamp: true,
+                neighborhoodClampIntensity: 1,
+                neighborhoodClampRadius: 1,
+                logTransform: true,
+                confidencePower: 4
+            }
+        };
+        this.options = {
+            ...defaultTemporalReprojectPassOptions,
+            ...options
+        };
         this.setSize(options.width, options.height);
     }
 }
@@ -410,8 +683,8 @@ class CubeToEquirectEnvPass extends Pass {
     generateEquirectEnvMap(renderer, cubeMap, width = null, height = null, maxWidth = 4096) {
         if (width === null && height === null) {
             const w = cubeMap.source.data[0].width;
-            const widthEquirect = Math.pow(2, Math.ceil(Math.log2(2 * w * Math.pow(3, 0.5))));
-            const heightEquirect = Math.pow(2, Math.ceil(Math.log2(w * Math.pow(3, 0.5))));
+            const widthEquirect = 2 ** Math.ceil(Math.log2(2 * w * 3 ** 0.5));
+            const heightEquirect = 2 ** Math.ceil(Math.log2(w * 3 ** 0.5));
             width = widthEquirect;
             height = heightEquirect;
         }
@@ -523,7 +796,10 @@ const setupBlueNoise = (fragmentShader)=>{
 const useBlueNoise = (material)=>{
     const { fragmentShader, uniforms } = setupBlueNoise(material.fragmentShader);
     material.fragmentShader = fragmentShader;
-    material.uniforms = _extends({}, material.uniforms, uniforms);
+    material.uniforms = {
+        ...material.uniforms,
+        ...uniforms
+    };
     material.needsUpdate = true;
 };
 
@@ -600,7 +876,10 @@ class GBufferMaterial extends MeshPhysicalMaterial {
 
             gl_FragColor = gBuffer;`);
         const { uniforms, fragmentShader } = setupBlueNoise(shader.fragmentShader);
-        shader.uniforms = _extends({}, shader.uniforms, uniforms);
+        shader.uniforms = {
+            ...shader.uniforms,
+            ...uniforms
+        };
         shader.fragmentShader = fragmentShader;
     }
 }
@@ -1266,11 +1545,14 @@ const velocity_uniforms = {
 class VelocityDepthNormalMaterial extends ShaderMaterial {
     constructor(camera){
         super({
-            uniforms: _extends({}, UniformsUtils.clone(velocity_uniforms), {
-                cameraMatrixWorld: {
-                    value: camera.matrixWorld
+            uniforms: {
+                ...UniformsUtils.clone(velocity_uniforms),
+                ...{
+                    cameraMatrixWorld: {
+                        value: camera.matrixWorld
+                    }
                 }
-            }),
+            },
             vertexShader: /* glsl */ `
 					#include <common>
 					#include <uv_pars_vertex>
@@ -1734,7 +2016,10 @@ class PoissonDenoisePass extends Pass {
         super("PoissonBlurPass");
         this.iterations = defaultPoissonBlurOptions.iterations;
         this.index = 0;
-        options = _extends({}, defaultPoissonBlurOptions, options);
+        options = {
+            ...defaultPoissonBlurOptions,
+            ...options
+        };
         this.textures = textures;
         let isTextureSpecular = [
             false,
@@ -1878,13 +2163,16 @@ class Denoiser {
     }
     constructor(scene, camera, texture, options = defaultDenosierOptions){
         var _this_denoisePass;
-        options = _extends({}, defaultDenosierOptions, options);
+        options = {
+            ...defaultDenosierOptions,
+            ...options
+        };
         this.options = options;
         var _options_velocityDepthNormalPass;
         this.velocityDepthNormalPass = (_options_velocityDepthNormalPass = options.velocityDepthNormalPass) != null ? _options_velocityDepthNormalPass : new VelocityDepthNormalPass(scene, camera);
         this.isOwnVelocityDepthNormalPass = !options.velocityDepthNormalPass;
         const textureCount = options.inputType === "diffuseSpecular" ? 2 : 1;
-        this.temporalReprojectPass = new TemporalReprojectPass(scene, camera, this.velocityDepthNormalPass, texture, textureCount, _extends({
+        this.temporalReprojectPass = new TemporalReprojectPass(scene, camera, this.velocityDepthNormalPass, texture, textureCount, {
             fullAccumulate: true,
             logTransform: true,
             copyTextures: !options.denoise,
@@ -1897,8 +2185,9 @@ class Denoiser {
                 true
             ],
             neighborhoodClampRadius: 2,
-            neighborhoodClampIntensity: 0.5
-        }, options));
+            neighborhoodClampIntensity: 0.5,
+            ...options
+        });
         const textures = this.temporalReprojectPass.renderTarget.texture.slice(0, textureCount);
         if (this.options.denoiseMode === "full" || this.options.denoiseMode === "denoised") {
             this.denoisePass = new PoissonDenoisePass(camera, textures, options);
@@ -2276,7 +2565,10 @@ class SSGIEffect extends Effect {
     }
     constructor(composer, scene, camera, options){
         var _scene_fog;
-        options = _extends({}, defaultSSGIOptions, options);
+        options = {
+            ...defaultSSGIOptions,
+            ...options
+        };
         let fragmentShader = ssgi_compose.replace("#include <fog_pars_fragment>", ShaderChunk.fog_pars_fragment.replace("varying", ""));
         // delete the line starting with gl_FragColor using a regex
         fragmentShader = fragmentShader.replace("#include <fog_fragment>", ShaderChunk.fog_fragment.replace(/.*gl_FragColor.*/g, ""));
@@ -2374,10 +2666,11 @@ class SSGIEffect extends Effect {
             }
         }
         this.ssgiPass = new SSGIPass(this, options);
-        this.denoiser = new Denoiser(scene, camera, this.ssgiPass.texture, _extends({
+        this.denoiser = new Denoiser(scene, camera, this.ssgiPass.texture, {
             gBufferPass: this.ssgiPass.gBufferPass,
-            velocityDepthNormalPass: options.velocityDepthNormalPass
-        }, options));
+            velocityDepthNormalPass: options.velocityDepthNormalPass,
+            ...options
+        });
         this.lastSize = {
             width: options.width,
             height: options.height,
@@ -2461,7 +2754,10 @@ class MotionBlurEffect extends Effect {
         }
     }
     constructor(velocityPass, options = defaultOptions){
-        options = _extends({}, defaultOptions, options);
+        options = {
+            ...defaultOptions,
+            ...options
+        };
         const { fragmentShader, uniforms } = setupBlueNoise(motion_blur);
         // convert the uniforms from type { uniform: value,... } to type ["uniform", value,...]
         const formattedUniforms = [];
@@ -2522,7 +2818,7 @@ class MotionBlurEffect extends Effect {
 
 var ao_compose = "#define GLSLIFY 1\nuniform sampler2D inputTexture;uniform highp sampler2D depthTexture;uniform float power;uniform vec3 color;void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){float unpackedDepth=textureLod(depthTexture,uv,0.).r;float ao=unpackedDepth>0.9999 ? 1.0 : textureLod(inputTexture,uv,0.0).a;ao=pow(ao,power);vec3 aoColor=mix(color,vec3(1.),ao);aoColor*=inputColor.rgb;outputColor=vec4(aoColor,inputColor.a);}"; // eslint-disable-line
 
-const defaultAOOptions = _extends({
+const defaultAOOptions = {
     resolutionScale: 1,
     spp: 8,
     distance: 2,
@@ -2533,8 +2829,9 @@ const defaultAOOptions = _extends({
     color: new Color("black"),
     useNormalPass: false,
     velocityDepthNormalPass: null,
-    normalTexture: null
-}, PoissonDenoisePass.DefaultOptions);
+    normalTexture: null,
+    ...PoissonDenoisePass.DefaultOptions
+};
 class AOEffect extends Effect {
     makeOptionsReactive(options) {
         for (const key of Object.keys(options)){
@@ -2557,431 +2854,158 @@ class AOEffect extends Effect {
                             this.setSize(this.lastSize.width, this.lastSize.height);
                             break;
                         case "power":
-                            this.uniforms.get("power").value = value;
-                            break;
-                        case "color":
-                            this.uniforms.get("color").value.copy(new Color(value));
-                            break;
-                        // denoiser
-                        case "iterations":
-                        case "radius":
-                        case "rings":
-                        case "samples":
-                            this.PoissonDenoisePass[key] = value;
-                            break;
-                        case "lumaPhi":
-                        case "depthPhi":
-                        case "normalPhi":
-                            this.PoissonDenoisePass.fullscreenMaterial.uniforms[key].value = Math.max(value, 0.0001);
-                            break;
-                        default:
-                            if (key in this.aoPass.fullscreenMaterial.uniforms) {
-                                this.aoPass.fullscreenMaterial.uniforms[key].value = value;
-                            }
-                    }
-                },
-                configurable: true
-            });
-            // apply all uniforms and defines
-            this[key] = options[key];
-        }
-    }
-    setSize(width, height) {
-        var _this_normalPass;
-        if (width === undefined || height === undefined) return;
-        if (width === this.lastSize.width && height === this.lastSize.height && this.resolutionScale === this.lastSize.resolutionScale) {
-            return;
-        }
-        (_this_normalPass = this.normalPass) == null ? void 0 : _this_normalPass.setSize(width, height);
-        this.aoPass.setSize(width * this.resolutionScale, height * this.resolutionScale);
-        this.PoissonDenoisePass.setSize(width, height);
-        this.lastSize = {
-            width,
-            height,
-            resolutionScale: this.resolutionScale
-        };
-    }
-    get texture() {
-        if (this.iterations > 0) {
-            return this.PoissonDenoisePass.texture;
-        }
-        return this.aoPass.texture;
-    }
-    update(renderer) {
-        var _this_normalPass;
-        // check if TRAA is being used so we can animate the noise
-        const hasTRAA = this.composer.passes.some((pass)=>{
-            var _pass_effects;
-            return pass.enabled && !pass.skipRendering && ((_pass_effects = pass.effects) == null ? void 0 : _pass_effects.some((effect)=>effect instanceof TRAAEffect));
-        });
-        // set animated noise depending on TRAA
-        if (hasTRAA && !("animatedNoise" in this.aoPass.fullscreenMaterial.defines)) {
-            this.aoPass.fullscreenMaterial.defines.animatedNoise = "";
-            this.aoPass.fullscreenMaterial.needsUpdate = true;
-        } else if (!hasTRAA && "animatedNoise" in this.aoPass.fullscreenMaterial.defines) {
-            delete this.aoPass.fullscreenMaterial.defines.animatedNoise;
-            this.aoPass.fullscreenMaterial.needsUpdate = true;
-        }
-        this.uniforms.get("inputTexture").value = this.texture;
-        (_this_normalPass = this.normalPass) == null ? void 0 : _this_normalPass.render(renderer);
-        this.aoPass.render(renderer);
-        this.PoissonDenoisePass.render(renderer);
-    }
-    constructor(composer, camera, scene, aoPass, options = defaultAOOptions){
-        super("AOEffect", ao_compose, {
-            type: "FinalAOMaterial",
-            uniforms: new Map([
-                [
-                    "inputTexture",
-                    new Uniform(null)
-                ],
-                [
-                    "depthTexture",
-                    new Uniform(null)
-                ],
-                [
-                    "power",
-                    new Uniform(0)
-                ],
-                [
-                    "color",
-                    new Uniform(new Color("black"))
-                ]
-            ])
-        });
-        this.lastSize = {
-            width: 0,
-            height: 0,
-            resolutionScale: 0
-        };
-        this.composer = composer;
-        this.aoPass = aoPass;
-        options = _extends({}, defaultAOOptions, options);
-        // set up depth texture
-        if (!composer.depthTexture) composer.createDepthTexture();
-        this.aoPass.fullscreenMaterial.uniforms.depthTexture.value = composer.depthTexture;
-        this.uniforms.get("depthTexture").value = composer.depthTexture;
-        // set up optional normal texture
-        if (options.useNormalPass || options.normalTexture) {
-            if (options.useNormalPass) this.normalPass = new NormalPass(scene, camera);
-            var _options_normalTexture;
-            const normalTexture = (_options_normalTexture = options.normalTexture) != null ? _options_normalTexture : this.normalPass.texture;
-            this.aoPass.fullscreenMaterial.uniforms.normalTexture.value = normalTexture;
-            this.aoPass.fullscreenMaterial.defines.useNormalTexture = "";
-        }
-        this.PoissonDenoisePass = new PoissonDenoisePass(camera, this.aoPass.texture, composer.depthTexture, {
-            normalInRgb: true
-        });
-        this.makeOptionsReactive(options);
-    }
-}
-AOEffect.DefaultOptions = defaultAOOptions;
-
-class EffectComposerPlugin extends Plugin {
-    static Instance(viewer) {
-        return viewer.getPlugin(EffectComposerPlugin, true);
-    }
-    get multisampling() {
-        return this._composer.multisampling;
-    }
-    set multisampling(v) {
-        this._composer.multisampling = v;
-    }
-    getPass(constructor) {
-        return this._composer.passes.find((v)=>v.constructor === constructor);
-    }
-    addPass(pass) {
-        this._composer.addPass(pass, this._composer.passes.length - 1);
-        this._checkOutputPass();
-        return pass;
-    }
-    removePass(pass) {
-        this._composer.removePass(pass);
-        this._checkOutputPass();
-    }
-    activePass(pass, v) {
-        pass.enabled = v;
-        this._checkOutputPass();
-        return pass;
-    }
-    getVelocityDepthNormalPass(autoAdd = false) {
-        let vdnPass = this.getPass(VelocityDepthNormalPass);
-        if (vdnPass === undefined && autoAdd) {
-            vdnPass = this.addPass(new VelocityDepthNormalPass(this.viewer.scene, this.viewer.camera));
-        }
-        return vdnPass;
-    }
-    _checkOutputPass() {
-        const vdnPass = this.getVelocityDepthNormalPass();
-        const count = this._composer.passes.filter((v)=>v.enabled && v !== vdnPass && v !== this._outputPass).length;
-        this._outputPass.enabled = this._composer.multisampling > 0 && count === 1;
-        this._setRenderToScreen();
-    }
-    _setRenderToScreen() {
-        const vdnPass = this.getVelocityDepthNormalPass();
-        const passes = this._composer.passes;
-        for(let k = 0, i = passes.length; i--;){
-            let pass = passes[i];
-            if (pass.enabled && pass !== vdnPass && k === 0) {
-                k = i;
-            }
-            pass.renderToScreen = k === i;
-        }
-    }
-    constructor(props){
-        super();
-        this.install = ()=>{
-            const { renderer, scene, camera } = this.viewer;
-            this._renderPass = new RenderPass(scene, camera);
-            this._outputPass = new EffectPass(camera);
-            this._composer = new EffectComposer(renderer, Object.assign({
-                frameBufferType: HalfFloatType
-            }, props));
-            this._composer.addPass(this._renderPass);
-            this._composer.addPass(this._outputPass);
-            this.viewer._onResize = (width, height)=>this._composer.setSize(width, height);
-            this.viewer._onRender = (dt)=>this._composer.render(dt);
-        };
-        this.uninstall = ()=>{
-            this._composer.dispose();
-        };
-    }
-}
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
-
-
-function __decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-  var e = new Error(message);
-  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-class PassPlugin extends Plugin {
-    get enable() {
-        return this.pass.enabled;
-    }
-    set enable(v) {
-        this.setEnable(v);
-    }
-    get composer() {
-        return EffectComposerPlugin.Instance(this.viewer);
-    }
-    setEnable(v) {
-        this.composer.activePass(this.pass, v);
-    }
-}
-__decorate([
-    property
-], PassPlugin.prototype, "enable", null);
-
-class ToneMappingPlugin extends PassPlugin {
-    get mode() {
-        return this.effect.mode;
-    }
-    set mode(v) {
-        this.effect.mode = v;
-    }
-    constructor(props){
-        super();
-        this.install = ()=>{
-            this.effect = new ToneMappingEffect(props);
-            this.pass = this.composer.addPass(new EffectPass(this.viewer.camera, this.effect));
-        };
-        this.uninstall = ()=>{
-            this.composer.removePass(this.pass);
-        };
+                            this.uniforms.get("power").value = value;
+                            break;
+                        case "color":
+                            this.uniforms.get("color").value.copy(new Color(value));
+                            break;
+                        // denoiser
+                        case "iterations":
+                        case "radius":
+                        case "rings":
+                        case "samples":
+                            this.PoissonDenoisePass[key] = value;
+                            break;
+                        case "lumaPhi":
+                        case "depthPhi":
+                        case "normalPhi":
+                            this.PoissonDenoisePass.fullscreenMaterial.uniforms[key].value = Math.max(value, 0.0001);
+                            break;
+                        default:
+                            if (key in this.aoPass.fullscreenMaterial.uniforms) {
+                                this.aoPass.fullscreenMaterial.uniforms[key].value = value;
+                            }
+                    }
+                },
+                configurable: true
+            });
+            // apply all uniforms and defines
+            this[key] = options[key];
+        }
     }
-}
-__decorate([
-    property({
-        value: ToneMappingMode
-    })
-], ToneMappingPlugin.prototype, "mode", null);
-
-class MotionBlurPlugin extends PassPlugin {
-    constructor(){
-        super();
-        this.install = ()=>{
-            const effect = new MotionBlurEffect(this.composer.getVelocityDepthNormalPass(true));
-            this.pass = this.composer.addPass(new EffectPass(this.viewer.camera, effect));
-        };
-        this.uninstall = ()=>{
-            this.composer.removePass(this.pass);
+    setSize(width, height) {
+        var _this_normalPass;
+        if (width === undefined || height === undefined) return;
+        if (width === this.lastSize.width && height === this.lastSize.height && this.resolutionScale === this.lastSize.resolutionScale) {
+            return;
+        }
+        (_this_normalPass = this.normalPass) == null ? void 0 : _this_normalPass.setSize(width, height);
+        this.aoPass.setSize(width * this.resolutionScale, height * this.resolutionScale);
+        this.PoissonDenoisePass.setSize(width, height);
+        this.lastSize = {
+            width,
+            height,
+            resolutionScale: this.resolutionScale
         };
     }
-}
-
-class BloomPlugin extends PassPlugin {
-    get intensity() {
-        return this.effect.intensity;
-    }
-    set intensity(v) {
-        this.effect.intensity = v;
-    }
-    get luminanceThreshold() {
-        return this.effect.luminanceMaterial.threshold;
-    }
-    set luminanceThreshold(v) {
-        this.effect.luminanceMaterial.threshold = v;
-    }
-    get luminanceSmoothing() {
-        return this.effect.luminanceMaterial.smoothing;
+    get texture() {
+        if (this.iterations > 0) {
+            return this.PoissonDenoisePass.texture;
+        }
+        return this.aoPass.texture;
     }
-    set luminanceSmoothing(v) {
-        this.effect.luminanceMaterial.smoothing = v;
+    update(renderer) {
+        var _this_normalPass;
+        // check if TRAA is being used so we can animate the noise
+        const hasTRAA = this.composer.passes.some((pass)=>{
+            var _pass_effects;
+            return pass.enabled && !pass.skipRendering && ((_pass_effects = pass.effects) == null ? void 0 : _pass_effects.some((effect)=>effect instanceof TRAAEffect));
+        });
+        // set animated noise depending on TRAA
+        if (hasTRAA && !("animatedNoise" in this.aoPass.fullscreenMaterial.defines)) {
+            this.aoPass.fullscreenMaterial.defines.animatedNoise = "";
+            this.aoPass.fullscreenMaterial.needsUpdate = true;
+        } else if (!hasTRAA && "animatedNoise" in this.aoPass.fullscreenMaterial.defines) {
+            delete this.aoPass.fullscreenMaterial.defines.animatedNoise;
+            this.aoPass.fullscreenMaterial.needsUpdate = true;
+        }
+        this.uniforms.get("inputTexture").value = this.texture;
+        (_this_normalPass = this.normalPass) == null ? void 0 : _this_normalPass.render(renderer);
+        this.aoPass.render(renderer);
+        this.PoissonDenoisePass.render(renderer);
     }
-    constructor(props){
-        super();
-        this.install = ()=>{
-            this.effect = new BloomEffect(_extends({
-                blendFunction: BlendFunction.ADD
-            }, props));
-            this.pass = this.composer.addPass(new EffectPass(this.viewer.camera, this.effect));
+    constructor(composer, camera, scene, aoPass, options = defaultAOOptions){
+        super("AOEffect", ao_compose, {
+            type: "FinalAOMaterial",
+            uniforms: new Map([
+                [
+                    "inputTexture",
+                    new Uniform(null)
+                ],
+                [
+                    "depthTexture",
+                    new Uniform(null)
+                ],
+                [
+                    "power",
+                    new Uniform(0)
+                ],
+                [
+                    "color",
+                    new Uniform(new Color("black"))
+                ]
+            ])
+        });
+        this.lastSize = {
+            width: 0,
+            height: 0,
+            resolutionScale: 0
         };
-        this.uninstall = ()=>{
-            this.composer.removePass(this.pass);
+        this.composer = composer;
+        this.aoPass = aoPass;
+        options = {
+            ...defaultAOOptions,
+            ...options
         };
+        // set up depth texture
+        if (!composer.depthTexture) composer.createDepthTexture();
+        this.aoPass.fullscreenMaterial.uniforms.depthTexture.value = composer.depthTexture;
+        this.uniforms.get("depthTexture").value = composer.depthTexture;
+        // set up optional normal texture
+        if (options.useNormalPass || options.normalTexture) {
+            if (options.useNormalPass) this.normalPass = new NormalPass(scene, camera);
+            var _options_normalTexture;
+            const normalTexture = (_options_normalTexture = options.normalTexture) != null ? _options_normalTexture : this.normalPass.texture;
+            this.aoPass.fullscreenMaterial.uniforms.normalTexture.value = normalTexture;
+            this.aoPass.fullscreenMaterial.defines.useNormalTexture = "";
+        }
+        this.PoissonDenoisePass = new PoissonDenoisePass(camera, this.aoPass.texture, composer.depthTexture, {
+            normalInRgb: true
+        });
+        this.makeOptionsReactive(options);
     }
 }
-__decorate([
-    property({
-        min: 0,
-        max: 2,
-        step: 0.01
-    })
-], BloomPlugin.prototype, "intensity", null);
-__decorate([
-    property({
-        min: 0,
-        max: 10,
-        step: 0.01
-    })
-], BloomPlugin.prototype, "luminanceThreshold", null);
-__decorate([
-    property({
-        min: 0,
-        max: 10,
-        step: 0.01
-    })
-], BloomPlugin.prototype, "luminanceSmoothing", null);
+AOEffect.DefaultOptions = defaultAOOptions;
 
-class FXAAPlugin extends PassPlugin {
-    constructor(){
-        super();
-        this.install = ()=>{
-            this.pass = this.composer.addPass(new EffectPass(this.viewer.camera, new FXAAEffect()));
-        };
-        this.uninstall = ()=>{
-            this.composer.removePass(this.pass);
-        };
+function getVelocityDepthNormalPass(viewer, autoAdd = true) {
+    const composer = EffectComposerPlugin.Instance(viewer);
+    let vdnPass = composer.getPass(VelocityDepthNormalPass);
+    if (vdnPass === undefined && autoAdd) {
+        vdnPass = composer.addPass(new VelocityDepthNormalPass(viewer.scene, viewer.camera));
     }
+    return vdnPass;
 }
 
-class SMAAPlugin extends PassPlugin {
-    get preset() {
-        return this._preset;
-    }
-    set preset(v) {
-        if (this._preset !== v) {
-            this._preset = v;
-            this.effect.applyPreset(v);
-        }
-    }
-    get edgeDetectionMode() {
-        return this.effect.edgeDetectionMaterial.edgeDetectionMode;
-    }
-    set edgeDetectionMode(v) {
-        this.effect.edgeDetectionMaterial.edgeDetectionMode = v;
-    }
-    get predicationMode() {
-        return this.effect.edgeDetectionMaterial.predicationMode;
-    }
-    set predicationMode(v) {
-        this.effect.edgeDetectionMaterial.predicationMode = v;
-    }
+class TRAAPlugin extends PassPlugin {
     constructor(props = {}){
         super();
-        this._preset = SMAAPreset.MEDIUM;
         this.install = ()=>{
-            this.effect = new SMAAEffect(props);
-            this.pass = this.composer.addPass(new EffectPass(this.viewer.camera, this.effect));
+            const { scene, camera } = this.viewer;
+            this._effect = new TRAAEffect(scene, camera, getVelocityDepthNormalPass(this.viewer), props);
+            this.pass = this.composer.addPass(new EffectPass(camera, this._effect));
         };
         this.uninstall = ()=>{
             this.composer.removePass(this.pass);
         };
     }
 }
-__decorate([
-    property({
-        value: SMAAPreset
-    })
-], SMAAPlugin.prototype, "preset", null);
-__decorate([
-    property({
-        value: EdgeDetectionMode
-    })
-], SMAAPlugin.prototype, "edgeDetectionMode", null);
-__decorate([
-    property({
-        value: PredicationMode
-    })
-], SMAAPlugin.prototype, "predicationMode", null);
 
-class MSAAPlugin extends Plugin {
-    get enable() {
-        return this.composer.multisampling > 0;
-    }
-    set enable(v) {
-        this.composer.multisampling = v ? this._maxSamples : 0;
-    }
-    get composer() {
-        return EffectComposerPlugin.Instance(this.viewer);
-    }
+class MotionBlurPlugin extends PassPlugin {
     constructor(){
-        super();
-        this._maxSamples = 4;
-        this.install = ()=>{
-            const { renderer } = this.viewer;
-            this._maxSamples = Math.min(4, renderer.capabilities.maxSamples);
-            this.composer.multisampling = this._maxSamples;
-        };
-        this.uninstall = ()=>{
-            this.composer.multisampling = 0;
-        };
-    }
-}
-__decorate([
-    property
-], MSAAPlugin.prototype, "enable", null);
-
-class TRAAPlugin extends PassPlugin {
-    constructor(props = {}){
         super();
         this.install = ()=>{
-            const { scene, camera } = this.viewer;
-            this._effect = new TRAAEffect(scene, camera, this.composer.getVelocityDepthNormalPass(true), props);
-            this.pass = this.composer.addPass(new EffectPass(camera, this._effect));
+            const effect = new MotionBlurEffect(getVelocityDepthNormalPass(this.viewer));
+            this.pass = this.composer.addPass(new EffectPass(this.viewer.camera, effect));
         };
         this.uninstall = ()=>{
             this.composer.removePass(this.pass);