@xviewer.js/postprocessing 1.0.0-alpha.12 → 1.0.0-alpha.14

package/dist/main.js

@@ -48,6 +48,7 @@ class EffectComposerPlugin extends core.Plugin {
     }
     constructor(props){
         super();
+        this.type = "EffectComposerPlugin";
         this.install = ()=>{
             const { renderer, scene, camera } = this.viewer;
             this._renderPass = new postprocessing.RenderPass(scene, camera);
@@ -66,35 +67,6 @@ class EffectComposerPlugin extends core.Plugin {
     }
 }
 
-/******************************************************************************
-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 core.Plugin {
     get enable() {
         return this.pass.enabled;
@@ -109,9 +81,6 @@ class PassPlugin extends core.Plugin {
         this.composer.activePass(this.pass, v);
     }
 }
-__decorate([
-    core.property
-], PassPlugin.prototype, "enable", null);
 
 class ToneMappingPlugin extends PassPlugin {
     get mode() {
@@ -122,6 +91,7 @@ class ToneMappingPlugin extends PassPlugin {
     }
     constructor(props){
         super();
+        this.type = "ToneMappingPlugin";
         this.install = ()=>{
             this.effect = new postprocessing.ToneMappingEffect(props);
             this.pass = this.composer.addPass(new postprocessing.EffectPass(this.viewer.camera, this.effect));
@@ -131,25 +101,39 @@ class ToneMappingPlugin extends PassPlugin {
         };
     }
 }
-__decorate([
-    core.property({
-        value: postprocessing.ToneMappingMode
-    })
-], ToneMappingPlugin.prototype, "mode", null);
+core.PropertyManager._getClassProperties("ToneMappingPlugin").property("enable").property("mode", {
+    value: postprocessing.ToneMappingMode
+});
+
+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];
+        }
+
+        return target;
+    };
+
+    return _extends.apply(this, arguments);
+}
 
 class BloomPlugin extends PassPlugin {
+    // @property({ min: 0, max: 2, step: 0.01 })
     get intensity() {
         return this.effect.intensity;
     }
     set intensity(v) {
         this.effect.intensity = v;
     }
+    // @property({ min: 0, max: 10, step: 0.01 })
     get luminanceThreshold() {
         return this.effect.luminanceMaterial.threshold;
     }
     set luminanceThreshold(v) {
         this.effect.luminanceMaterial.threshold = v;
     }
+    // @property({ min: 0, max: 10, step: 0.01 })
     get luminanceSmoothing() {
         return this.effect.luminanceMaterial.smoothing;
     }
@@ -158,11 +142,11 @@ class BloomPlugin extends PassPlugin {
     }
     constructor(props){
         super();
+        this.type = "BloomPlugin";
         this.install = ()=>{
-            this.effect = new postprocessing.BloomEffect({
-                blendFunction: postprocessing.BlendFunction.ADD,
-                ...props
-            });
+            this.effect = new postprocessing.BloomEffect(_extends({
+                blendFunction: postprocessing.BlendFunction.ADD
+            }, props));
             this.pass = this.composer.addPass(new postprocessing.EffectPass(this.viewer.camera, this.effect));
         };
         this.uninstall = ()=>{
@@ -170,31 +154,24 @@ class BloomPlugin extends PassPlugin {
         };
     }
 }
-__decorate([
-    core.property({
-        min: 0,
-        max: 2,
-        step: 0.01
-    })
-], BloomPlugin.prototype, "intensity", null);
-__decorate([
-    core.property({
-        min: 0,
-        max: 10,
-        step: 0.01
-    })
-], BloomPlugin.prototype, "luminanceThreshold", null);
-__decorate([
-    core.property({
-        min: 0,
-        max: 10,
-        step: 0.01
-    })
-], BloomPlugin.prototype, "luminanceSmoothing", null);
+core.PropertyManager._getClassProperties("BloomPlugin").property("enable").property("intensity", {
+    min: 0,
+    max: 2,
+    step: 0.01
+}).property("luminanceThreshold", {
+    min: 0,
+    max: 10,
+    step: 0.01
+}).property("luminanceSmoothing", {
+    min: 0,
+    max: 10,
+    step: 0.01
+});
 
 class FXAAPlugin extends PassPlugin {
     constructor(){
         super();
+        this.type = "FXAAPlugin";
         this.install = ()=>{
             this.pass = this.composer.addPass(new postprocessing.EffectPass(this.viewer.camera, new postprocessing.FXAAEffect()));
         };
@@ -203,8 +180,10 @@ class FXAAPlugin extends PassPlugin {
         };
     }
 }
+core.PropertyManager._getClassProperties("FXAAPlugin").property("enable");
 
 class SMAAPlugin extends PassPlugin {
+    // @property({ value: SMAAPreset })
     get preset() {
         return this._preset;
     }
@@ -214,12 +193,14 @@ class SMAAPlugin extends PassPlugin {
             this.effect.applyPreset(v);
         }
     }
+    // @property({ value: EdgeDetectionMode })
     get edgeDetectionMode() {
         return this.effect.edgeDetectionMaterial.edgeDetectionMode;
     }
     set edgeDetectionMode(v) {
         this.effect.edgeDetectionMaterial.edgeDetectionMode = v;
     }
+    // @property({ value: PredicationMode })
     get predicationMode() {
         return this.effect.edgeDetectionMaterial.predicationMode;
     }
@@ -228,6 +209,7 @@ class SMAAPlugin extends PassPlugin {
     }
     constructor(props = {}){
         super();
+        this.type = "SMAAPlugin";
         this._preset = postprocessing.SMAAPreset.MEDIUM;
         this.install = ()=>{
             this.effect = new postprocessing.SMAAEffect(props);
@@ -238,21 +220,13 @@ class SMAAPlugin extends PassPlugin {
         };
     }
 }
-__decorate([
-    core.property({
-        value: postprocessing.SMAAPreset
-    })
-], SMAAPlugin.prototype, "preset", null);
-__decorate([
-    core.property({
-        value: postprocessing.EdgeDetectionMode
-    })
-], SMAAPlugin.prototype, "edgeDetectionMode", null);
-__decorate([
-    core.property({
-        value: postprocessing.PredicationMode
-    })
-], SMAAPlugin.prototype, "predicationMode", null);
+core.PropertyManager._getClassProperties("SMAAPlugin").property("enable").property("preset", {
+    value: postprocessing.SMAAPreset
+}).property("edgeDetectionMode", {
+    value: postprocessing.EdgeDetectionMode
+}).property("predicationMode", {
+    value: postprocessing.PredicationMode
+});
 
 class MSAAPlugin extends core.Plugin {
     get enable() {
@@ -266,6 +240,7 @@ class MSAAPlugin extends core.Plugin {
     }
     constructor(){
         super();
+        this.type = "MSAAPlugin";
         this._maxSamples = 4;
         this.install = ()=>{
             const { renderer } = this.viewer;
@@ -277,14 +252,749 @@ class MSAAPlugin extends core.Plugin {
         };
     }
 }
-__decorate([
-    core.property
-], MSAAPlugin.prototype, "enable", null);
+core.PropertyManager._getClassProperties("MSAAPlugin").property("enable");
+
+// 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
+const g = 1.32471795724474602596090885447809 // Plastic number
+;
+const a1 = 1.0 / g;
+const a2 = 1.0 / (g * g);
+const base = 1.1127756842787055 // harmoniousNumber(7), yields better coverage compared to using 0.5
+;
+const generateR2 = (count)=>{
+    const points = [];
+    for(let n = 0; n < count; n++){
+        points.push([
+            (base + a1 * n) % 1,
+            (base + a2 * n) % 1
+        ]);
+    }
+    return points;
+};
+
+const r2Sequence = generateR2(256).map(([a, b])=>[
+        a - 0.5,
+        b - 0.5
+    ]);
+function jitter(width, height, camera, frame, jitterScale = 1) {
+    const [x, y] = r2Sequence[frame % r2Sequence.length];
+    if (camera.setViewOffset) {
+        camera.setViewOffset(width, height, x * jitterScale, y * jitterScale, width, height);
+    }
+}
+
+var vertexShader = "#define GLSLIFY 1\nvarying vec2 vUv;void main(){vUv=position.xy*0.5+0.5;gl_Position=vec4(position.xy,1.0,1.0);}"; // eslint-disable-line
+
+var fragmentShader = "#define GLSLIFY 1\nvarying vec2 vUv;uniform highp sampler2D inputTexture;uniform highp sampler2D velocityTexture;uniform highp sampler2D depthTexture;uniform highp sampler2D lastVelocityTexture;uniform float maxBlend;uniform float neighborhoodClampIntensity;uniform bool fullAccumulate;uniform vec2 invTexSize;uniform float cameraNear;uniform float cameraFar;uniform mat4 projectionMatrix;uniform mat4 projectionMatrixInverse;uniform mat4 cameraMatrixWorld;uniform vec3 cameraPos;uniform vec3 prevCameraPos;uniform mat4 prevViewMatrix;uniform mat4 prevCameraMatrixWorld;uniform mat4 prevProjectionMatrix;uniform mat4 prevProjectionMatrixInverse;uniform float keepData;\n#define EPSILON 0.00001\n#define DIFFUSE_SPECULAR 0\n#define DIFFUSE 1\n#define SPECULAR 2\n#include <gbuffer_packing>\n#include <packing>\n#include <reproject>\nvec3 reprojectedUvDiffuse=vec3(-1.0),reprojectedUvSpecular=vec3(-1.0);void accumulate(inout vec4 outputColor,inout vec4 inp,inout vec4 acc,inout float roughness,inout float moveFactor,bool doReprojectSpecular){vec3 reprojectedUvConfidence=doReprojectSpecular ? reprojectedUvSpecular : reprojectedUvDiffuse;vec2 reprojectedUv=reprojectedUvConfidence.xy;float confidence=reprojectedUvConfidence.z;confidence=pow(confidence,confidencePower);float accumBlend=1.-1./(acc.a+1.0);accumBlend=mix(0.,accumBlend,confidence);float maxValue=(fullAccumulate ? 1. : maxBlend)*keepData;\n#if inputType != DIFFUSE\nconst float roughnessMaximum=0.1;if(doReprojectSpecular&&roughness>=0.0&&roughness<roughnessMaximum){float maxRoughnessValue=mix(0.,maxValue,roughness/roughnessMaximum);maxValue=mix(maxValue,maxRoughnessValue,min(100.*moveFactor,1.));}\n#endif\nfloat temporalReprojectMix=min(accumBlend,maxValue);acc.a=1./(1.-temporalReprojectMix)-1.;acc.a=min(65536.,acc.a);outputColor.rgb=mix(inp.rgb,acc.rgb,temporalReprojectMix);outputColor.a=acc.a;undoColorTransform(outputColor.rgb);}void reproject(inout vec4 inp,inout vec4 acc,sampler2D accumulatedTexture,inout bool wasSampled,bool doNeighborhoodClamp,bool doReprojectSpecular){vec3 uvc=doReprojectSpecular ? reprojectedUvSpecular : reprojectedUvDiffuse;vec2 uv=uvc.xy;acc=sampleReprojectedTexture(accumulatedTexture,uv);transformColor(acc.rgb);if(!wasSampled){inp.rgb=acc.rgb;return;}acc.a++;vec3 clampedColor=acc.rgb;int clampRadius=doReprojectSpecular&&roughness<0.25 ? 1 : 2;clampNeighborhood(inputTexture,clampedColor,inp.rgb,clampRadius,doReprojectSpecular);float r=doReprojectSpecular ? roughness : 1.0;float clampAggressiveness=min(1.,uvc.z*r);float clampIntensity=mix(0.,min(1.,moveFactor*50.+neighborhoodClampIntensity),clampAggressiveness);vec3 newColor=mix(acc.rgb,clampedColor,clampIntensity);float colorDiff=min(length(newColor-acc.rgb),1.);acc.a*=1.-colorDiff;acc.rgb=newColor;}void preprocessInput(inout highp vec4 texel,inout bool sampledThisFrame){sampledThisFrame=texel.r>=0.;texel.rgb=max(texel.rgb,vec3(0.));transformColor(texel.rgb);}void getTexels(inout highp vec4 inputTexel[textureCount],inout bool sampledThisFrame[textureCount]){\n#if inputType == DIFFUSE_SPECULAR\nhighp vec4 tex=textureLod(inputTexture,vUv,0.);unpackTwoVec4(tex,inputTexel[0],inputTexel[1]);preprocessInput(inputTexel[0],sampledThisFrame[0]);preprocessInput(inputTexel[1],sampledThisFrame[1]);\n#else\ninputTexel[0]=textureLod(inputTexture,vUv,0.0);preprocessInput(inputTexel[0],sampledThisFrame[0]);\n#endif\n}void computeGVariables(vec2 dilatedUv,float depth){worldPos=screenSpaceToWorldSpace(dilatedUv,depth,cameraMatrixWorld,projectionMatrixInverse);vec3 viewPos=(viewMatrix*vec4(worldPos,1.0)).xyz;viewDir=normalize(viewPos);vec3 viewNormal=(vec4(worldNormal,0.0)*viewMatrix).xyz;viewAngle=dot(-viewDir,viewNormal);}void computeReprojectedUv(float depth,vec3 worldPos,vec3 worldNormal){reprojectedUvDiffuse=getReprojectedUV(false,depth,worldPos,worldNormal);\n#if inputType == DIFFUSE_SPECULAR || inputType == SPECULAR\nreprojectedUvSpecular=getReprojectedUV(true,depth,worldPos,worldNormal);if(reprojectedUvSpecular.x==-1.0){reprojectedUvSpecular=reprojectedUvDiffuse;}\n#endif\n}void getRoughnessRayLength(inout highp vec4 inputTexel[textureCount]){\n#if inputType == DIFFUSE_SPECULAR\nrayLength=inputTexel[1].a;roughness=clamp(inputTexel[0].a,0.,1.);\n#elif inputType == SPECULAR\nvec2 data=unpackHalf2x16(floatBitsToUint(inputTexel[0].a));rayLength=data.r;roughness=clamp(data.g,0.,1.);\n#endif\n}void main(){vec2 dilatedUv=vUv;getVelocityNormalDepth(dilatedUv,velocity,worldNormal,depth);highp vec4 inputTexel[textureCount],accumulatedTexel[textureCount];bool textureSampledThisFrame[textureCount];getTexels(inputTexel,textureSampledThisFrame);\n#if inputType != DIFFUSE\nif(depth==1.0&&fwidth(depth)==0.0){discard;return;}\n#endif\ncurvature=getCurvature(worldNormal);computeGVariables(dilatedUv,depth);getRoughnessRayLength(inputTexel);computeReprojectedUv(depth,worldPos,worldNormal);moveFactor=min(dot(velocity,velocity)*10000.,1.);\n#pragma unroll_loop_start\nfor(int i=0;i<textureCount;i++){reproject(inputTexel[i],accumulatedTexel[i],accumulatedTexture[i],textureSampledThisFrame[i],neighborhoodClamp[i],reprojectSpecular[i]);accumulate(gOutput[i],inputTexel[i],accumulatedTexel[i],roughness,moveFactor,reprojectSpecular[i]);}\n#pragma unroll_loop_end\n}"; // eslint-disable-line
+
+var reproject = "#define GLSLIFY 1\nvec2 dilatedUv,velocity;vec3 worldNormal,worldPos,viewDir;float depth,curvature,viewAngle,rayLength,angleMix;float roughness=1.;float moveFactor=0.;\n#define luminance(a) dot(vec3(0.2125, 0.7154, 0.0721), a)\nfloat getViewZ(const in float depth){\n#ifdef PERSPECTIVE_CAMERA\nreturn perspectiveDepthToViewZ(depth,cameraNear,cameraFar);\n#else\nreturn orthographicDepthToViewZ(depth,cameraNear,cameraFar);\n#endif\n}vec3 screenSpaceToWorldSpace(const vec2 uv,const float depth,mat4 curMatrixWorld,const mat4 projMatrixInverse){vec4 ndc=vec4((uv.x-0.5)*2.0,(uv.y-0.5)*2.0,(depth-0.5)*2.0,1.0);vec4 clip=projMatrixInverse*ndc;vec4 view=curMatrixWorld*(clip/clip.w);return view.xyz;}vec2 viewSpaceToScreenSpace(const vec3 position,const mat4 projMatrix){vec4 projectedCoord=projMatrix*vec4(position,1.0);projectedCoord.xy/=projectedCoord.w;projectedCoord.xy=projectedCoord.xy*0.5+0.5;return projectedCoord.xy;}\n#ifdef logTransform\nvoid transformColor(inout vec3 color){color=log(color+1.);}void undoColorTransform(inout vec3 color){color=exp(color)-1.;}\n#else\n#define transformColor\n#define undoColorTransform\n#endif\nvoid getNeighborhoodAABB(const sampler2D tex,const int clampRadius,inout vec3 minNeighborColor,inout vec3 maxNeighborColor,const bool isSpecular){for(int x=-clampRadius;x<=clampRadius;x++){for(int y=-clampRadius;y<=clampRadius;y++){vec2 offset=vec2(x,y)*invTexSize;vec2 neighborUv=vUv+offset;\n#if inputType == DIFFUSE_SPECULAR\nvec4 t1,t2;vec4 packedNeighborTexel=textureLod(inputTexture,neighborUv,0.0);unpackTwoVec4(packedNeighborTexel,t1,t2);vec4 neighborTexel=isSpecular ? t2 : t1;\n#else\nvec4 neighborTexel=textureLod(inputTexture,neighborUv,0.0);\n#endif\nif(neighborTexel.r>=0.){minNeighborColor=min(neighborTexel.rgb,minNeighborColor);maxNeighborColor=max(neighborTexel.rgb,maxNeighborColor);}}}}void clampNeighborhood(const sampler2D tex,inout vec3 color,vec3 inputColor,const int clampRadius,const bool isSpecular){undoColorTransform(inputColor);vec3 minNeighborColor=inputColor;vec3 maxNeighborColor=inputColor;getNeighborhoodAABB(tex,clampRadius,minNeighborColor,maxNeighborColor,isSpecular);transformColor(minNeighborColor);transformColor(maxNeighborColor);color=clamp(color,minNeighborColor,maxNeighborColor);}void getVelocityNormalDepth(inout vec2 dilatedUv,out vec2 vel,out vec3 normal,out float depth){vec2 centerUv=dilatedUv;vec4 velocityTexel=textureLod(velocityTexture,centerUv,0.0);vel=velocityTexel.rg;normal=unpackNormal(velocityTexel.b);depth=velocityTexel.a;}\n#define PLANE_DISTANCE 20.\n#define WORLD_DISTANCE 10.\n#define NORMAL_DISTANCE 1.\nfloat planeDistanceDisocclusionCheck(const vec3 worldPos,const vec3 lastWorldPos,const vec3 worldNormal,const float distFactor){vec3 toCurrent=worldPos-lastWorldPos;float distToPlane=abs(dot(toCurrent,worldNormal));return distToPlane/PLANE_DISTANCE*distFactor;}float worldDistanceDisocclusionCheck(const vec3 worldPos,const vec3 lastWorldPos,const float distFactor){return length(worldPos-lastWorldPos)/WORLD_DISTANCE*distFactor;}float normalDisocclusionCheck(const vec3 worldNormal,const vec3 lastWorldNormal,const float distFactor){return min(1.-dot(worldNormal,lastWorldNormal),1.)/NORMAL_DISTANCE*distFactor;}float validateReprojectedUV(const vec2 reprojectedUv,const vec3 worldPos,const vec3 worldNormal,const bool isHitPoint){if(reprojectedUv.x>1.0||reprojectedUv.x<0.0||reprojectedUv.y>1.0||reprojectedUv.y<0.0)return 0.;vec2 dilatedReprojectedUv=reprojectedUv;vec2 lastVelocity=vec2(0.0);vec3 lastWorldNormal=vec3(0.0);float lastDepth=0.0;getVelocityNormalDepth(dilatedReprojectedUv,lastVelocity,lastWorldNormal,lastDepth);vec3 lastWorldPos=screenSpaceToWorldSpace(dilatedReprojectedUv,lastDepth,prevCameraMatrixWorld,prevProjectionMatrixInverse);vec3 lastViewPos=(prevViewMatrix*vec4(lastWorldPos,1.0)).xyz;vec3 lastViewDir=normalize(lastViewPos);vec3 lastViewNormal=(vec4(lastWorldNormal,0.0)*prevViewMatrix).xyz;float lastViewAngle=dot(-lastViewDir,lastViewNormal);angleMix=abs(lastViewAngle-viewAngle);float viewZ=abs(getViewZ(depth));float distFactor=1.+1./(viewZ+1.0);float disoccl=0.;disoccl+=worldDistanceDisocclusionCheck(worldPos,lastWorldPos,distFactor);disoccl+=planeDistanceDisocclusionCheck(worldPos,lastWorldPos,worldNormal,distFactor);disoccl+=normalDisocclusionCheck(worldNormal,lastWorldNormal,distFactor);float confidence=1.-min(disoccl,1.);confidence=max(confidence,0.);confidence=pow(confidence,confidencePower);return confidence;}vec2 reprojectHitPoint(const vec3 rayOrig,const float rayLength){if(curvature>0.05||rayLength<0.01){return vec2(-1.);}vec3 cameraRay=normalize(rayOrig-cameraPos);vec3 parallaxHitPoint=cameraPos+cameraRay*rayLength;vec4 reprojectedHitPoint=prevProjectionMatrix*prevViewMatrix*vec4(parallaxHitPoint,1.0);reprojectedHitPoint.xyz/=reprojectedHitPoint.w;reprojectedHitPoint.xy=reprojectedHitPoint.xy*0.5+0.5;vec2 diffuseUv=vUv-velocity.xy;float m=min(max(0.,roughness-0.25)/0.25,1.);return reprojectedHitPoint.xy;}vec3 getReprojectedUV(const bool doReprojectSpecular,const float depth,const vec3 worldPos,const vec3 worldNormal){if(doReprojectSpecular){vec2 reprojectedUv=reprojectHitPoint(worldPos,rayLength);float confidence=validateReprojectedUV(reprojectedUv,worldPos,worldNormal,true);return vec3(reprojectedUv,confidence);}else{vec2 reprojectedUv=vUv-velocity;float confidence=validateReprojectedUV(reprojectedUv,worldPos,worldNormal,false);return vec3(reprojectedUv,confidence);}}vec4 BiCubicCatmullRom5Tap(sampler2D tex,vec2 P){vec2 Weight[3];vec2 Sample[3];vec2 UV=P/invTexSize;vec2 tc=floor(UV-0.5)+0.5;vec2 f=UV-tc;vec2 f2=f*f;vec2 f3=f2*f;vec2 w0=f2-0.5*(f3+f);vec2 w1=1.5*f3-2.5*f2+vec2(1.);vec2 w3=0.5*(f3-f2);vec2 w2=vec2(1.)-w0-w1-w3;Weight[0]=w0;Weight[1]=w1+w2;Weight[2]=w3;Sample[0]=tc-vec2(1.);Sample[1]=tc+w2/Weight[1];Sample[2]=tc+vec2(2.);Sample[0]*=invTexSize;Sample[1]*=invTexSize;Sample[2]*=invTexSize;float sampleWeight[5];sampleWeight[0]=Weight[1].x*Weight[0].y;sampleWeight[1]=Weight[0].x*Weight[1].y;sampleWeight[2]=Weight[1].x*Weight[1].y;sampleWeight[3]=Weight[2].x*Weight[1].y;sampleWeight[4]=Weight[1].x*Weight[2].y;vec4 Ct=textureLod(tex,vec2(Sample[1].x,Sample[0].y),0.)*sampleWeight[0];vec4 Cl=textureLod(tex,vec2(Sample[0].x,Sample[1].y),0.)*sampleWeight[1];vec4 Cc=textureLod(tex,vec2(Sample[1].x,Sample[1].y),0.)*sampleWeight[2];vec4 Cr=textureLod(tex,vec2(Sample[2].x,Sample[1].y),0.)*sampleWeight[3];vec4 Cb=textureLod(tex,vec2(Sample[1].x,Sample[2].y),0.)*sampleWeight[4];float WeightMultiplier=1./(sampleWeight[0]+sampleWeight[1]+sampleWeight[2]+sampleWeight[3]+sampleWeight[4]);return max((Ct+Cl+Cc+Cr+Cb)*WeightMultiplier,vec4(0.));}vec4 sampleReprojectedTexture(const sampler2D tex,const vec2 reprojectedUv){vec4 catmull=BiCubicCatmullRom5Tap(tex,reprojectedUv);return catmull;}float getCurvature(vec3 n){float curvature=length(fwidth(n));return curvature;}"; // eslint-disable-line
+
+var gbuffer_packing = "#define GLSLIFY 1\nuniform highp sampler2D gBufferTexture;struct Material{highp vec4 diffuse;highp vec3 normal;highp float roughness;highp float metalness;highp vec3 emissive;};\n#define ONE_SAFE 0.999999\n#define NON_ZERO_OFFSET 0.0001\nconst highp float c_precision=256.0;const highp float c_precisionp1=c_precision+1.0;highp float color2float(in highp vec3 color){color=min(color+NON_ZERO_OFFSET,vec3(ONE_SAFE));return floor(color.r*c_precision+0.5)+floor(color.b*c_precision+0.5)*c_precisionp1+floor(color.g*c_precision+0.5)*c_precisionp1*c_precisionp1;}highp vec3 float2color(in highp float value){highp vec3 color;color.r=mod(value,c_precisionp1)/c_precision;color.b=mod(floor(value/c_precisionp1),c_precisionp1)/c_precision;color.g=floor(value/(c_precisionp1*c_precisionp1))/c_precision;color-=NON_ZERO_OFFSET;color=max(color,vec3(0.0));return color;}highp vec2 OctWrap(highp vec2 v){highp vec2 w=1.0-abs(v.yx);if(v.x<0.0)w.x=-w.x;if(v.y<0.0)w.y=-w.y;return w;}highp vec2 encodeOctWrap(highp vec3 n){n/=(abs(n.x)+abs(n.y)+abs(n.z));n.xy=n.z>0.0 ? n.xy : OctWrap(n.xy);n.xy=n.xy*0.5+0.5;return n.xy;}highp vec3 decodeOctWrap(highp vec2 f){f=f*2.0-1.0;highp vec3 n=vec3(f.x,f.y,1.0-abs(f.x)-abs(f.y));highp float t=max(-n.z,0.0);n.x+=n.x>=0.0 ?-t : t;n.y+=n.y>=0.0 ?-t : t;return normalize(n);}highp float packNormal(highp vec3 normal){return uintBitsToFloat(packHalf2x16(encodeOctWrap(normal)));}highp vec3 unpackNormal(highp float packedNormal){return decodeOctWrap(unpackHalf2x16(floatBitsToUint(packedNormal)));}highp vec4 packTwoVec4(highp vec4 v1,highp vec4 v2){highp vec4 encoded=vec4(0.0);v1+=NON_ZERO_OFFSET;v2+=NON_ZERO_OFFSET;highp uint v1r=packHalf2x16(v1.rg);highp uint v1g=packHalf2x16(v1.ba);highp uint v2r=packHalf2x16(v2.rg);highp uint v2g=packHalf2x16(v2.ba);encoded.r=uintBitsToFloat(v1r);encoded.g=uintBitsToFloat(v1g);encoded.b=uintBitsToFloat(v2r);encoded.a=uintBitsToFloat(v2g);return encoded;}void unpackTwoVec4(highp vec4 encoded,out highp vec4 v1,out highp vec4 v2){highp uint r=floatBitsToUint(encoded.r);highp uint g=floatBitsToUint(encoded.g);highp uint b=floatBitsToUint(encoded.b);highp uint a=floatBitsToUint(encoded.a);v1.rg=unpackHalf2x16(r);v1.ba=unpackHalf2x16(g);v2.rg=unpackHalf2x16(b);v2.ba=unpackHalf2x16(a);v1-=NON_ZERO_OFFSET;v2-=NON_ZERO_OFFSET;}vec4 unpackTwoVec4(highp vec4 encoded,const int index){highp uint r=floatBitsToUint(index==0 ? encoded.r : encoded.b);highp uint g=floatBitsToUint(index==0 ? encoded.g : encoded.a);vec4 v;v.rg=unpackHalf2x16(r);v.ba=unpackHalf2x16(g);v-=NON_ZERO_OFFSET;return v;}highp vec4 encodeRGBE8(highp vec3 rgb){highp vec4 vEncoded;highp float maxComponent=max(max(rgb.r,rgb.g),rgb.b);highp float fExp=ceil(log2(maxComponent));vEncoded.rgb=rgb/exp2(fExp);vEncoded.a=(fExp+128.0)/255.0;return vEncoded;}highp vec3 decodeRGBE8(highp vec4 rgbe){highp vec3 vDecoded;highp float fExp=rgbe.a*255.0-128.0;vDecoded=rgbe.rgb*exp2(fExp);return vDecoded;}highp float vec4ToFloat(highp vec4 vec){vec=min(vec+NON_ZERO_OFFSET,vec4(ONE_SAFE));highp uvec4 v=uvec4(vec*255.0);highp uint value=(v.a<<24u)|(v.b<<16u)|(v.g<<8u)|(v.r);return uintBitsToFloat(value);}highp vec4 floatToVec4(highp float f){highp uint value=floatBitsToUint(f);highp vec4 v;v.r=float(value&0xFFu)/255.0;v.g=float((value>>8u)&0xFFu)/255.0;v.b=float((value>>16u)&0xFFu)/255.0;v.a=float((value>>24u)&0xFFu)/255.0;v-=NON_ZERO_OFFSET;v=max(v,vec4(0.0));return v;}highp vec4 packGBuffer(highp vec4 diffuse,highp vec3 normal,highp float roughness,highp float metalness,highp vec3 emissive){highp vec4 gBuffer;gBuffer.r=vec4ToFloat(diffuse);gBuffer.g=packNormal(normal);gBuffer.b=color2float(vec3(roughness,metalness,0.));gBuffer.a=vec4ToFloat(encodeRGBE8(emissive));return gBuffer;}Material getMaterial(highp sampler2D gBufferTexture,highp vec2 uv){highp vec4 gBuffer=textureLod(gBufferTexture,uv,0.0);highp vec4 diffuse=floatToVec4(gBuffer.r);highp vec3 normal=unpackNormal(gBuffer.g);highp vec3 roughnessMetalness=float2color(gBuffer.b);highp float roughness=roughnessMetalness.r;highp float metalness=roughnessMetalness.g;highp vec3 emissive=decodeRGBE8(floatToVec4(gBuffer.a));return Material(diffuse,normal,roughness,metalness,emissive);}Material getMaterial(highp vec2 uv){return getMaterial(gBufferTexture,uv);}highp vec3 getNormal(highp sampler2D gBufferTexture,highp vec2 uv){return unpackNormal(textureLod(gBufferTexture,uv,0.0).g);}"; // eslint-disable-line
+
+// source: https://github.com/mrdoob/three.js/blob/b9bc47ab1978022ab0947a9bce1b1209769b8d91/src/renderers/webgl/WebGLProgram.js#L228
+// Unroll Loops
+const unrollLoopPattern = /#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;
+function unrollLoops(string) {
+    return string.replace(unrollLoopPattern, loopReplacer);
+}
+function loopReplacer(match, start, end, snippet) {
+    let string = "";
+    for(let i = parseInt(start); i < parseInt(end); i++){
+        string += snippet.replace(/\[\s*i\s*\]/g, "[ " + i + " ]").replace(/UNROLLED_LOOP_INDEX/g, i);
+    }
+    return string;
+}
+
+class TemporalReprojectMaterial extends three.ShaderMaterial {
+    constructor(textureCount = 1){
+        let finalFragmentShader = fragmentShader.replace("#include <reproject>", reproject).replace("#include <gbuffer_packing>", gbuffer_packing);
+        let definitions = "";
+        for(let i = 0; i < textureCount; i++){
+            definitions += /* glsl */ `
+				uniform sampler2D accumulatedTexture${i};
+
+				layout(location = ${i}) out vec4 gOutput${i};
+			`;
+        }
+        finalFragmentShader = definitions + finalFragmentShader.replaceAll("textureCount", textureCount);
+        finalFragmentShader = unrollLoops(finalFragmentShader);
+        const matches2 = finalFragmentShader.matchAll(/accumulatedTexture\[\s*[0-9]+\s*]/g);
+        for (const [key] of matches2){
+            const number = key.replace(/[^0-9]/g, "");
+            finalFragmentShader = finalFragmentShader.replace(key, "accumulatedTexture" + number);
+        }
+        const matches3 = finalFragmentShader.matchAll(/gOutput\[\s*[0-9]+\s*]/g);
+        for (const [key] of matches3){
+            const number = key.replace(/[^0-9]/g, "");
+            finalFragmentShader = finalFragmentShader.replace(key, "gOutput" + number);
+        }
+        super({
+            type: "TemporalReprojectMaterial",
+            uniforms: {
+                inputTexture: new three.Uniform(null),
+                velocityTexture: new three.Uniform(null),
+                depthTexture: new three.Uniform(null),
+                lastVelocityTexture: new three.Uniform(null),
+                neighborhoodClampIntensity: new three.Uniform(0),
+                fullAccumulate: new three.Uniform(false),
+                keepData: new three.Uniform(1),
+                delta: new three.Uniform(0),
+                invTexSize: new three.Uniform(new three.Vector2()),
+                projectionMatrix: new three.Uniform(new three.Matrix4()),
+                projectionMatrixInverse: new three.Uniform(new three.Matrix4()),
+                cameraMatrixWorld: new three.Uniform(new three.Matrix4()),
+                viewMatrix: new three.Uniform(new three.Matrix4()),
+                prevViewMatrix: new three.Uniform(new three.Matrix4()),
+                prevCameraMatrixWorld: new three.Uniform(new three.Matrix4()),
+                prevProjectionMatrix: new three.Uniform(new three.Matrix4()),
+                prevProjectionMatrixInverse: new three.Uniform(new three.Matrix4()),
+                cameraPos: new three.Uniform(new three.Vector3()),
+                prevCameraPos: new three.Uniform(new three.Vector3()),
+                cameraNear: new three.Uniform(0),
+                cameraFar: new three.Uniform(0),
+                maxBlend: new three.Uniform(0)
+            },
+            vertexShader,
+            fragmentShader: finalFragmentShader,
+            blending: three.NoBlending,
+            depthWrite: false,
+            depthTest: false,
+            toneMapped: false,
+            glslVersion: three.GLSL3
+        });
+        for(let i = 0; i < textureCount; i++){
+            this.uniforms["inputTexture" + i] = new three.Uniform(null);
+            this.uniforms["accumulatedTexture" + i] = new three.Uniform(null);
+        }
+    }
+}
+
+const isGroundProjectedEnv = (c)=>{
+    var _c_material_fragmentShader;
+    return (_c_material_fragmentShader = c.material.fragmentShader) == null ? void 0 : _c_material_fragmentShader.includes("float intersection2 = diskIntersectWithBackFaceCulling( camPos, p, h, vec3( 0.0, 1.0, 0.0 ), radius );");
+};
+const isChildMaterialRenderable = (c, material = c.material)=>{
+    return material.visible && material.depthWrite && material.depthTest && (!material.transparent || material.opacity > 0) && !isGroundProjectedEnv(c);
+};
+const didCameraMove = (camera, lastCameraPosition, lastCameraQuaternion)=>{
+    if (camera.position.distanceToSquared(lastCameraPosition) > 0.000001) {
+        return true;
+    }
+    if (camera.quaternion.angleTo(lastCameraQuaternion) > 0.001) {
+        return true;
+    }
+    return false;
+};
+const getVisibleChildren = (object)=>{
+    const queue = [
+        object
+    ];
+    const objects = [];
+    while(queue.length !== 0){
+        const mesh = queue.shift();
+        if (mesh.material) objects.push(mesh);
+        for (const c of mesh.children){
+            if (c.visible) queue.push(c);
+        }
+    }
+    return objects;
+};
+
+const defaultTemporalReprojectPassOptions = {
+    dilation: false,
+    fullAccumulate: false,
+    neighborhoodClamp: false,
+    neighborhoodClampRadius: 1,
+    neighborhoodClampIntensity: 1,
+    maxBlend: 1,
+    logTransform: false,
+    depthDistance: 2,
+    worldDistance: 4,
+    reprojectSpecular: false,
+    renderTarget: null,
+    copyTextures: true,
+    confidencePower: 0.75,
+    inputType: "diffuse"
+};
+const tmpProjectionMatrix$1 = new three.Matrix4();
+const tmpProjectionMatrixInverse$1 = new three.Matrix4();
+const tmpVec2 = new three.Vector2();
+class TemporalReprojectPass extends postprocessing.Pass {
+    setInputTexture(texture) {
+        this.fullscreenMaterial.uniforms.inputTexture.value = texture;
+    }
+    dispose() {
+        super.dispose();
+        this.renderTarget.dispose();
+        this.fullscreenMaterial.dispose();
+    }
+    setSize(width, height) {
+        var _this_framebufferTexture;
+        this.renderTarget.setSize(width, height);
+        this.fullscreenMaterial.uniforms.invTexSize.value.set(1 / width, 1 / height);
+        (_this_framebufferTexture = this.framebufferTexture) == null ? void 0 : _this_framebufferTexture.dispose();
+        const inputTexture = this.fullscreenMaterial.uniforms.inputTexture.value;
+        this.framebufferTexture = new three.FramebufferTexture(width, height, inputTexture.format);
+        this.framebufferTexture.type = inputTexture.type;
+        this.framebufferTexture.minFilter = three.LinearFilter;
+        this.framebufferTexture.magFilter = three.LinearFilter;
+        this.framebufferTexture.needsUpdate = true;
+        for(let i = 0; i < this.textureCount; i++){
+            var _this_overrideAccumulatedTextures_i;
+            const accumulatedTexture = (_this_overrideAccumulatedTextures_i = this.overrideAccumulatedTextures[i]) != null ? _this_overrideAccumulatedTextures_i : this.framebufferTexture;
+            this.fullscreenMaterial.uniforms["accumulatedTexture" + i].value = accumulatedTexture;
+        }
+    }
+    get texture() {
+        return this.renderTarget.texture;
+    }
+    reset() {
+        this.fullscreenMaterial.uniforms.keepData.value = 0;
+    }
+    render(renderer) {
+        this.frame = (this.frame + 1) % 4096;
+        const delta = Math.min(1 / 10, this.clock.getDelta());
+        this.fullscreenMaterial.uniforms.delta.value = delta;
+        tmpProjectionMatrix$1.copy(this._camera.projectionMatrix);
+        tmpProjectionMatrixInverse$1.copy(this._camera.projectionMatrixInverse);
+        if (this._camera.view) this._camera.view.enabled = false;
+        this._camera.updateProjectionMatrix();
+        this.fullscreenMaterial.uniforms.projectionMatrix.value.copy(this._camera.projectionMatrix);
+        this.fullscreenMaterial.uniforms.projectionMatrixInverse.value.copy(this._camera.projectionMatrixInverse);
+        this.fullscreenMaterial.uniforms.lastVelocityTexture.value = this.velocityDepthNormalPass.lastVelocityTexture;
+        this.fullscreenMaterial.uniforms.fullAccumulate.value = this.options.fullAccumulate && !didCameraMove(this._camera, this.lastCameraTransform.position, this.lastCameraTransform.quaternion);
+        this.lastCameraTransform.position.copy(this._camera.position);
+        this.lastCameraTransform.quaternion.copy(this._camera.quaternion);
+        if (this._camera.view) this._camera.view.enabled = true;
+        this._camera.projectionMatrix.copy(tmpProjectionMatrix$1);
+        this._camera.projectionMatrixInverse.copy(tmpProjectionMatrixInverse$1);
+        this.fullscreenMaterial.uniforms.cameraNear.value = this._camera.near;
+        this.fullscreenMaterial.uniforms.cameraFar.value = this._camera.far;
+        renderer.setRenderTarget(this.renderTarget);
+        renderer.render(this.scene, this.camera);
+        this.fullscreenMaterial.uniforms.keepData.value = 1;
+        if (this.overrideAccumulatedTextures.length === 0) {
+            this.framebufferTexture.needsUpdate = true;
+            renderer.copyFramebufferToTexture(tmpVec2, this.framebufferTexture);
+        }
+        // save last transformations
+        this.fullscreenMaterial.uniforms.prevCameraMatrixWorld.value.copy(this._camera.matrixWorld);
+        this.fullscreenMaterial.uniforms.prevViewMatrix.value.copy(this._camera.matrixWorldInverse);
+        this.fullscreenMaterial.uniforms.prevProjectionMatrix.value.copy(this.fullscreenMaterial.uniforms.projectionMatrix.value);
+        this.fullscreenMaterial.uniforms.prevProjectionMatrixInverse.value.copy(this.fullscreenMaterial.uniforms.projectionMatrixInverse.value);
+        this.fullscreenMaterial.uniforms.prevCameraPos.value.copy(this._camera.position);
+    }
+    jitter(jitterScale = 1) {
+        this.unjitter();
+        jitter(this.renderTarget.width, this.renderTarget.height, this._camera, this.frame, jitterScale);
+    }
+    unjitter() {
+        if (this._camera.clearViewOffset) this._camera.clearViewOffset();
+    }
+    constructor(scene, camera, velocityDepthNormalPass, texture, textureCount, options = defaultTemporalReprojectPassOptions){
+        super("TemporalReprojectPass");
+        this.needsSwap = false;
+        this.overrideAccumulatedTextures = [];
+        this.clock = new three.Clock();
+        this.r2Sequence = [];
+        this.frame = 0;
+        this.lastCameraTransform = {
+            position: new three.Vector3(),
+            quaternion: new three.Quaternion()
+        };
+        this._scene = scene;
+        this._camera = camera;
+        this.textureCount = textureCount;
+        options = _extends({}, defaultTemporalReprojectPassOptions, options);
+        this.renderTarget = new three.WebGLRenderTarget(1, 1, {
+            count: textureCount,
+            minFilter: three.NearestFilter,
+            magFilter: three.NearestFilter,
+            type: texture.type,
+            depthBuffer: false
+        });
+        this.renderTarget.textures.forEach((texture, index)=>texture.name = "TemporalReprojectPass.accumulatedTexture" + index);
+        this.fullscreenMaterial = new TemporalReprojectMaterial(textureCount);
+        this.fullscreenMaterial.defines.textureCount = textureCount;
+        if (options.dilation) this.fullscreenMaterial.defines.dilation = "";
+        if (options.neighborhoodClamp) this.fullscreenMaterial.defines.neighborhoodClamp = "";
+        if (options.logTransform) this.fullscreenMaterial.defines.logTransform = "";
+        if (camera.isPerspectiveCamera) this.fullscreenMaterial.defines.PERSPECTIVE_CAMERA = "";
+        this.fullscreenMaterial.defines.neighborhoodClampRadius = parseInt(options.neighborhoodClampRadius);
+        this.fullscreenMaterial.defines.depthDistance = options.depthDistance.toPrecision(5);
+        this.fullscreenMaterial.defines.worldDistance = options.worldDistance.toPrecision(5);
+        this.fullscreenMaterial.uniforms.fullAccumulate.value = options.fullAccumulate;
+        this.fullscreenMaterial.uniforms.neighborhoodClampIntensity.value = options.neighborhoodClampIntensity;
+        this.fullscreenMaterial.uniforms.maxBlend.value = options.maxBlend;
+        this.fullscreenMaterial.uniforms.projectionMatrix.value = camera.projectionMatrix.clone();
+        this.fullscreenMaterial.uniforms.projectionMatrixInverse.value = camera.projectionMatrixInverse.clone();
+        this.fullscreenMaterial.uniforms.cameraMatrixWorld.value = camera.matrixWorld;
+        this.fullscreenMaterial.uniforms.viewMatrix.value = camera.matrixWorldInverse;
+        this.fullscreenMaterial.uniforms.cameraPos.value = camera.position;
+        this.fullscreenMaterial.uniforms.prevViewMatrix.value = camera.matrixWorldInverse.clone();
+        this.fullscreenMaterial.uniforms.prevCameraMatrixWorld.value = camera.matrixWorld.clone();
+        this.fullscreenMaterial.uniforms.prevProjectionMatrix.value = camera.projectionMatrix.clone();
+        this.fullscreenMaterial.uniforms.prevProjectionMatrixInverse.value = camera.projectionMatrixInverse.clone();
+        this.fullscreenMaterial.uniforms.velocityTexture.value = velocityDepthNormalPass.renderTarget.texture;
+        this.fullscreenMaterial.uniforms.depthTexture.value = velocityDepthNormalPass.depthTexture;
+        var _indexOf;
+        this.fullscreenMaterial.defines.inputType = (_indexOf = [
+            "diffuseSpecular",
+            "diffuse",
+            "specular"
+        ].indexOf(options.inputType)) != null ? _indexOf : 1;
+        for (const opt of [
+            "reprojectSpecular",
+            "neighborhoodClamp"
+        ]){
+            let value = options[opt];
+            if (typeof value !== "array") value = Array(textureCount).fill(value);
+            this.fullscreenMaterial.defines[opt] = /* glsl */ `bool[](${value.join(", ")})`;
+        }
+        this.fullscreenMaterial.defines.confidencePower = options.confidencePower.toPrecision(5);
+        this.options = options;
+        this.velocityDepthNormalPass = velocityDepthNormalPass;
+        this.fullscreenMaterial.uniforms.inputTexture.value = texture;
+    }
+}
+
+var traa_compose = "#define GLSLIFY 1\nuniform sampler2D accumulatedTexture;void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){vec4 accumulatedTexel=textureLod(accumulatedTexture,uv,0.);outputColor=vec4(accumulatedTexel.rgb,1.);}"; // eslint-disable-line
+
+class TRAAEffect extends postprocessing.Effect {
+    setSize(width, height) {
+        var _this_temporalReprojectPass;
+        (_this_temporalReprojectPass = this.temporalReprojectPass) == null ? void 0 : _this_temporalReprojectPass.setSize(width, height);
+    }
+    dispose() {
+        super.dispose();
+        this.temporalReprojectPass.dispose();
+    }
+    reset() {
+        this.temporalReprojectPass.reset();
+    }
+    update(renderer, inputBuffer) {
+        if (!this.temporalReprojectPass) {
+            this.temporalReprojectPass = new TemporalReprojectPass(this._scene, this._camera, this.velocityDepthNormalPass, inputBuffer.texture, 1, this.options);
+            this.temporalReprojectPass.setSize(inputBuffer.width, inputBuffer.height);
+            this.uniforms.get("accumulatedTexture").value = this.temporalReprojectPass.texture;
+        }
+        this.temporalReprojectPass.setInputTexture(inputBuffer.texture);
+        this.temporalReprojectPass.unjitter();
+        this.unjitteredProjectionMatrix = this._camera.projectionMatrix.clone();
+        this._camera.projectionMatrix.copy(this.unjitteredProjectionMatrix);
+        this.temporalReprojectPass.jitter();
+        this.temporalReprojectPass.render(renderer);
+    }
+    constructor(scene, camera, velocityDepthNormalPass, options = defaultTemporalReprojectPassOptions){
+        super("TRAAEffect", traa_compose, {
+            type: "FinalTRAAEffectMaterial",
+            uniforms: new Map([
+                [
+                    "accumulatedTexture",
+                    new three.Uniform(null)
+                ]
+            ])
+        });
+        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);
+        this.setSize(options.width, options.height);
+    }
+}
+
+// this shader is from: https://github.com/gkjohnson/threejs-sandbox
+// Modified ShaderChunk.skinning_pars_vertex to handle
+// a second set of bone information from the previous frame
+const prev_skinning_pars_vertex = /* glsl */ `
+		#ifdef USE_SKINNING
+		#ifdef BONE_TEXTURE
+			uniform sampler2D prevBoneTexture;
+			mat4 getPrevBoneMatrix( const in float i ) {
+				float j = i * 4.0;
+				float x = mod( j, float( boneTextureSize ) );
+				float y = floor( j / float( boneTextureSize ) );
+				float dx = 1.0 / float( boneTextureSize );
+				float dy = 1.0 / float( boneTextureSize );
+				y = dy * ( y + 0.5 );
+				vec4 v1 = textureLod( prevBoneTexture, vec2( dx * ( x + 0.5 ), y ), 0. );
+				vec4 v2 = textureLod( prevBoneTexture, vec2( dx * ( x + 1.5 ), y ), 0. );
+				vec4 v3 = textureLod( prevBoneTexture, vec2( dx * ( x + 2.5 ), y ), 0. );
+				vec4 v4 = textureLod( prevBoneTexture, vec2( dx * ( x + 3.5 ), y ), 0. );
+				mat4 bone = mat4( v1, v2, v3, v4 );
+				return bone;
+			}
+		#else
+			uniform mat4 prevBoneMatrices[ MAX_BONES ];
+			mat4 getPrevBoneMatrix( const in float i ) {
+				mat4 bone = prevBoneMatrices[ int(i) ];
+				return bone;
+			}
+		#endif
+		#endif
+`;
+const velocity_vertex_pars = /* glsl */ `
+#define MAX_BONES 64
+                    
+${three.ShaderChunk.skinning_pars_vertex}
+${prev_skinning_pars_vertex}
+
+uniform mat4 velocityMatrix;
+uniform mat4 prevVelocityMatrix;
+varying vec4 prevPosition;
+varying vec4 newPosition;
+
+varying vec2 vHighPrecisionZW;
+`;
+// Returns the body of the vertex shader for the velocity buffer
+const velocity_vertex_main = /* glsl */ `
+// Get the current vertex position
+transformed = vec3( position );
+${three.ShaderChunk.skinning_vertex}
+newPosition = velocityMatrix * vec4( transformed, 1.0 );
+
+// Get the previous vertex position
+transformed = vec3( position );
+${three.ShaderChunk.skinbase_vertex.replace(/mat4 /g, "").replace(/getBoneMatrix/g, "getPrevBoneMatrix")}
+${three.ShaderChunk.skinning_vertex.replace(/vec4 /g, "")}
+prevPosition = prevVelocityMatrix * vec4( transformed, 1.0 );
+
+gl_Position = newPosition;
+
+vHighPrecisionZW = gl_Position.zw;
+`;
+const velocity_fragment_pars = /* glsl */ `
+varying vec4 prevPosition;
+varying vec4 newPosition;
+
+varying vec2 vHighPrecisionZW;
+`;
+const velocity_fragment_main = /* glsl */ `
+vec2 pos0 = (prevPosition.xy / prevPosition.w) * 0.5 + 0.5;
+vec2 pos1 = (newPosition.xy / newPosition.w) * 0.5 + 0.5;
+
+vec2 vel = pos1 - pos0;
+
+float fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;
+
+gl_FragColor = vec4(vel.x, vel.y, 0., 0.);
+`;
+const velocity_uniforms = {
+    prevVelocityMatrix: {
+        value: new three.Matrix4()
+    },
+    velocityMatrix: {
+        value: new three.Matrix4()
+    },
+    prevBoneTexture: {
+        value: null
+    },
+    boneTexture: {
+        value: null
+    },
+    normalMap: {
+        value: null
+    },
+    normalScale: {
+        value: new three.Vector2(1, 1)
+    },
+    uvTransform: {
+        value: new three.Matrix3()
+    }
+};
+class VelocityDepthNormalMaterial extends three.ShaderMaterial {
+    constructor(camera){
+        super({
+            uniforms: _extends({}, three.UniformsUtils.clone(velocity_uniforms), {
+                cameraMatrixWorld: {
+                    value: camera.matrixWorld
+                }
+            }),
+            vertexShader: /* glsl */ `
+					#include <common>
+					#include <uv_pars_vertex>
+					#include <displacementmap_pars_vertex>
+					#include <normal_pars_vertex>
+					#include <morphtarget_pars_vertex>
+					#include <logdepthbuf_pars_vertex>
+					#include <clipping_planes_pars_vertex>
+
+					varying vec2 vUv;
+
+					varying vec3 vViewPosition;
+					
+                    ${velocity_vertex_pars}
+        
+                    void main() {
+						vec3 transformed;
+
+						#include <uv_vertex>
+
+						#include <skinbase_vertex>
+						#include <beginnormal_vertex>
+						#include <skinnormal_vertex>
+						#include <defaultnormal_vertex>
+
+						#include <morphnormal_vertex>
+						#include <normal_vertex>
+						#include <morphtarget_vertex>
+						#include <displacementmap_vertex>
+						#include <project_vertex>
+						#include <logdepthbuf_vertex>
+						#include <clipping_planes_vertex>
+
+						${velocity_vertex_main}
+
+						vViewPosition = - mvPosition.xyz;
+
+						vUv = uv;
+
+                    }`,
+            fragmentShader: /* glsl */ `
+					precision highp float;
+					uniform mat4 cameraMatrixWorld;
+
+					varying vec3 vViewPosition;
+
+					${velocity_fragment_pars}
+					#include <packing>
+
+					#include <uv_pars_fragment>
+					#include <normal_pars_fragment>
+					#include <normalmap_pars_fragment>
+
+					varying vec2 vUv;
+
+					// source: https://knarkowicz.wordpress.com/2014/04/16/octahedron-normal-vector-encoding/
+					vec2 OctWrap( vec2 v ) {
+						vec2 w = 1.0 - abs( v.yx );
+						if (v.x < 0.0) w.x = -w.x;
+						if (v.y < 0.0) w.y = -w.y;
+						return w;
+					}
+
+					vec2 encodeOctWrap(vec3 n) {
+						n /= (abs(n.x) + abs(n.y) + abs(n.z));
+						n.xy = n.z > 0.0 ? n.xy : OctWrap(n.xy);
+						n.xy = n.xy * 0.5 + 0.5;
+						return n.xy;
+					}
+
+					float packNormal(vec3 normal) {
+						return uintBitsToFloat(packHalf2x16(encodeOctWrap(normal)));
+					}
+
+                    void main() {
+						#define vNormalMapUv vUv
+
+						#include <normal_fragment_begin>
+                    	#include <normal_fragment_maps>
+
+						${velocity_fragment_main}
+						vec3 worldNormal = normalize((cameraMatrixWorld * vec4(normal, 0.)).xyz);
+						gl_FragColor.b = packNormal(worldNormal);
+						gl_FragColor.a = fragCoordZ;
+                    }`
+        });
+    }
+}
+
+const materialProps = [
+    "vertexTangent",
+    "vertexColors",
+    "vertexAlphas",
+    "vertexUvs",
+    "uvsVertexOnly",
+    "supportsVertexTextures",
+    "instancing",
+    "instancingColor",
+    "side",
+    "flatShading",
+    "skinning",
+    "doubleSided",
+    "flipSided"
+];
+const copyNecessaryProps = (originalMaterial, newMaterial)=>{
+    for (const props of materialProps)newMaterial[props] = originalMaterial[props];
+};
+const keepMaterialMapUpdated = (mrtMaterial, originalMaterial, prop, define, useKey)=>{
+    {
+        if (originalMaterial[prop] !== mrtMaterial[prop]) {
+            mrtMaterial[prop] = originalMaterial[prop];
+            mrtMaterial.uniforms[prop].value = originalMaterial[prop];
+            if (originalMaterial[prop]) {
+                mrtMaterial.defines[define] = "";
+            } else {
+                delete mrtMaterial.defines[define];
+            }
+            mrtMaterial.needsUpdate = true;
+        }
+    }
+};
+
+const backgroundColor = new three.Color(0);
+const zeroVec2 = new three.Vector2();
+const tmpProjectionMatrix = new three.Matrix4();
+const tmpProjectionMatrixInverse = new three.Matrix4();
+const saveBoneTexture = (object, floatType)=>{
+    let boneTexture = object.material.uniforms.prevBoneTexture.value;
+    if (boneTexture && boneTexture.image.width === object.skeleton.boneTexture.width) {
+        boneTexture = object.material.uniforms.prevBoneTexture.value;
+        boneTexture.image.data.set(object.skeleton.boneTexture.image.data);
+    } else {
+        boneTexture == null ? void 0 : boneTexture.dispose();
+        const boneMatrices = object.skeleton.boneTexture.image.data.slice();
+        const size = object.skeleton.boneTexture.image.width;
+        boneTexture = new three.DataTexture(boneMatrices, size, size, three.RGBAFormat, floatType);
+        object.material.uniforms.prevBoneTexture.value = boneTexture;
+        boneTexture.needsUpdate = true;
+    }
+};
+const updateVelocityDepthNormalMaterialBeforeRender = (c, camera)=>{
+    var _c_skeleton;
+    if ((_c_skeleton = c.skeleton) == null ? void 0 : _c_skeleton.boneTexture) {
+        c.material.uniforms.boneTexture.value = c.skeleton.boneTexture;
+        if (!("USE_SKINNING" in c.material.defines)) {
+            c.material.defines.USE_SKINNING = "";
+            c.material.defines.BONE_TEXTURE = "";
+            c.material.needsUpdate = true;
+        }
+    }
+    c.modelViewMatrix.multiplyMatrices(camera.matrixWorldInverse, c.matrixWorld);
+    c.material.uniforms.velocityMatrix.value.multiplyMatrices(camera.projectionMatrix, c.modelViewMatrix);
+};
+const updateVelocityDepthNormalMaterialAfterRender = (c, camera, floatType)=>{
+    var _c_skeleton;
+    c.material.uniforms.prevVelocityMatrix.value.multiplyMatrices(camera.projectionMatrix, c.modelViewMatrix);
+    if ((_c_skeleton = c.skeleton) == null ? void 0 : _c_skeleton.boneTexture) saveBoneTexture(c, floatType);
+};
+class VelocityDepthNormalPass extends postprocessing.Pass {
+    get texture() {
+        return this.renderTarget.texture;
+    }
+    setVelocityDepthNormalMaterialInScene() {
+        this.visibleMeshes = getVisibleChildren(this._scene);
+        for (const c of this.visibleMeshes){
+            const originalMaterial = c.material;
+            let [cachedOriginalMaterial, velocityDepthNormalMaterial] = this.cachedMaterials.get(c) || [];
+            if (originalMaterial !== cachedOriginalMaterial) {
+                var _c_skeleton;
+                velocityDepthNormalMaterial = new VelocityDepthNormalMaterial(this._camera);
+                copyNecessaryProps(originalMaterial, velocityDepthNormalMaterial);
+                c.material = velocityDepthNormalMaterial;
+                if ((_c_skeleton = c.skeleton) == null ? void 0 : _c_skeleton.boneTexture) saveBoneTexture(c, this._floatType);
+                this.cachedMaterials.set(c, [
+                    originalMaterial,
+                    velocityDepthNormalMaterial
+                ]);
+            }
+            c.material = velocityDepthNormalMaterial;
+            c.visible = isChildMaterialRenderable(c, originalMaterial);
+            keepMaterialMapUpdated(velocityDepthNormalMaterial, originalMaterial, "normalMap", "USE_NORMALMAP_TANGENTSPACE");
+            velocityDepthNormalMaterial.uniforms.normalMap.value = originalMaterial.normalMap;
+            const map = originalMaterial.map || originalMaterial.normalMap || originalMaterial.roughnessMap || originalMaterial.metalnessMap;
+            if (map) velocityDepthNormalMaterial.uniforms.uvTransform.value = map.matrix;
+            updateVelocityDepthNormalMaterialBeforeRender(c, this._camera);
+        }
+    }
+    unsetVelocityDepthNormalMaterialInScene() {
+        for (const c of this.visibleMeshes){
+            c.visible = true;
+            updateVelocityDepthNormalMaterialAfterRender(c, this._camera, this._floatType);
+            c.material = this.cachedMaterials.get(c)[0];
+        }
+    }
+    setSize(width, height) {
+        var _this_lastVelocityTexture;
+        this.renderTarget.setSize(width, height);
+        (_this_lastVelocityTexture = this.lastVelocityTexture) == null ? void 0 : _this_lastVelocityTexture.dispose();
+        this.lastVelocityTexture = new three.FramebufferTexture(width, height, three.RGBAFormat);
+        this.lastVelocityTexture.type = this._floatType;
+        this.lastVelocityTexture.minFilter = three.NearestFilter;
+        this.lastVelocityTexture.magFilter = three.NearestFilter;
+    }
+    dispose() {
+        super.dispose();
+        this.renderTarget.dispose();
+    }
+    render(renderer) {
+        tmpProjectionMatrix.copy(this._camera.projectionMatrix);
+        tmpProjectionMatrixInverse.copy(this._camera.projectionMatrixInverse);
+        if (this._camera.view) this._camera.view.enabled = false;
+        this._camera.updateProjectionMatrix();
+        // in case a RenderPass is not being used, so we need to update the camera's world matrix manually
+        this._camera.updateMatrixWorld();
+        this.setVelocityDepthNormalMaterialInScene();
+        const { background } = this._scene;
+        this._scene.background = backgroundColor;
+        renderer.setRenderTarget(this.renderTarget);
+        renderer.copyFramebufferToTexture(zeroVec2, this.lastVelocityTexture);
+        renderer.render(this._scene, this._camera);
+        this._scene.background = background;
+        this.unsetVelocityDepthNormalMaterialInScene();
+        if (this._camera.view) this._camera.view.enabled = true;
+        this._camera.projectionMatrix.copy(tmpProjectionMatrix);
+        this._camera.projectionMatrixInverse.copy(tmpProjectionMatrixInverse);
+    }
+    constructor(scene, camera, floatType = three.HalfFloatType){
+        super("VelocityDepthNormalPass");
+        this.cachedMaterials = new WeakMap();
+        this.visibleMeshes = [];
+        this.needsSwap = false;
+        this._scene = scene;
+        this._camera = camera;
+        this._floatType = floatType;
+        this.renderTarget = new three.WebGLRenderTarget(1, 1, {
+            type: floatType,
+            minFilter: three.NearestFilter,
+            magFilter: three.NearestFilter
+        });
+        this.renderTarget.texture.name = "VelocityDepthNormalPass.Texture";
+        this.renderTarget.depthTexture = new three.DepthTexture(1, 1);
+        this.renderTarget.depthTexture.type = floatType;
+    }
+}
+
+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 TRAAPlugin extends PassPlugin {
+    constructor(props = {}){
+        super();
+        this.type = "TRAAPlugin";
+        this.install = ()=>{
+            const { scene, camera } = this.viewer;
+            this._effect = new TRAAEffect(scene, camera, getVelocityDepthNormalPass(this.viewer), props);
+            this.pass = this.composer.addPass(new postprocessing.EffectPass(camera, this._effect));
+        };
+        this.uninstall = ()=>{
+            this.composer.removePass(this.pass);
+        };
+    }
+}
+core.PropertyManager._getClassProperties("TRAAPlugin").property("enable");
 
 exports.BloomPlugin = BloomPlugin;
 exports.EffectComposerPlugin = EffectComposerPlugin;
 exports.FXAAPlugin = FXAAPlugin;
 exports.MSAAPlugin = MSAAPlugin;
 exports.SMAAPlugin = SMAAPlugin;
+exports.TRAAPlugin = TRAAPlugin;
 exports.ToneMappingPlugin = ToneMappingPlugin;
 //# sourceMappingURL=main.js.map