@react-three/postprocessing 2.14.12 → 2.15.0

package/dist/index.js

@@ -1,12 +1,11 @@
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import React, { createContext, useState, useMemo, useRef, useContext, useEffect, forwardRef, useLayoutEffect, useImperativeHandle, useCallback } from "react";
 import * as THREE from "three";
-import { HalfFloatType, Vector3, TextureLoader, sRGBEncoding, RepeatWrapping, Uniform, Texture as Texture$1, Color, CanvasTexture, NearestFilter, BufferGeometry, BufferAttribute, Sphere, OrthographicCamera, Matrix4, Vector2, ShaderMaterial, WebGLRenderTarget, LinearFilter, DataTexture, NoColorSpace, WebGLMultipleRenderTargets, RedFormat, FloatType, RGBAFormat, Mesh } from "three";
+import { HalfFloatType, Vector3, TextureLoader, sRGBEncoding, RepeatWrapping, Uniform, Texture as Texture$1, Color, CanvasTexture, NearestFilter, ShaderChunk, Vector2, WebGLCubeRenderTarget, CubeCamera, PMREMGenerator, LinearFilter, WebGLRenderTarget, WebGLMultipleRenderTargets, Quaternion, FramebufferTexture, RGBAFormat, ShaderMaterial, Matrix3, REVISION, TangentSpaceNormalMap, GLSL3, Matrix4, VideoTexture, DataTexture, FloatType, BufferGeometry, BufferAttribute, Sphere, OrthographicCamera, NoColorSpace, RedFormat, Mesh } from "three";
 import { useThree, useFrame, useInstanceHandle, extend, createPortal, useLoader, applyProps } from "@react-three/fiber";
-import { EffectComposer as EffectComposer$1, RenderPass, NormalPass, DepthDownsamplingPass, Effect, EffectPass, Pass, DepthOfFieldEffect, MaskFunction, DepthPickingPass, CopyPass, BlendFunction, BloomEffect, BrightnessContrastEffect, ChromaticAberrationEffect, ColorAverageEffect, ColorDepthEffect, DepthEffect, DotScreenEffect, GlitchEffect, GlitchMode, GodRaysEffect, GridEffect, HueSaturationEffect, NoiseEffect, OutlineEffect, PixelationEffect, ScanlineEffect, SelectiveBloomEffect, SepiaEffect, SSAOEffect, SMAAEffect, FXAAEffect, TextureEffect, ToneMappingEffect, VignetteEffect, ShockWaveEffect, LUT3DEffect, TiltShiftEffect as TiltShiftEffect$1, EffectAttribute } from "postprocessing";
-import { isWebGL2Available } from "three-stdlib";
+import { EffectComposer as EffectComposer$1, RenderPass, NormalPass, DepthDownsamplingPass, Effect, EffectPass, Pass, DepthOfFieldEffect, MaskFunction, DepthPickingPass, CopyPass, BlendFunction, BloomEffect, BrightnessContrastEffect, ChromaticAberrationEffect, ColorAverageEffect, ColorDepthEffect, DepthEffect, DotScreenEffect, GlitchEffect, GlitchMode, GodRaysEffect, GridEffect, HueSaturationEffect, NoiseEffect, OutlineEffect, PixelationEffect, ScanlineEffect, SelectiveBloomEffect, SepiaEffect, SSAOEffect, SMAAEffect, FXAAEffect, TextureEffect, ToneMappingEffect, VignetteEffect, ShockWaveEffect, LUT3DEffect, TiltShiftEffect as TiltShiftEffect$1, EffectAttribute, Selection as Selection$1, DepthPass } from "postprocessing";
+import { isWebGL2Available as isWebGL2Available$1 } from "three-stdlib";
 import { easing } from "maath";
-import { SSREffect } from "screen-space-reflections";
 import "three-stdlib";
 const selectionContext = createContext(null);
 function Selection({ children, enabled = true }) {
@@ -57,7 +56,7 @@ const EffectComposer = React.memo(
       const scene = _scene || defaultScene;
       const camera = _camera || defaultCamera;
       const [composer, normalPass, downSamplingPass] = useMemo(() => {
-        const webGL2Available = isWebGL2Available();
+        const webGL2Available = isWebGL2Available$1();
         const effectComposer = new EffectComposer$1(gl, {
           depthBuffer,
           stencilBuffer,
@@ -306,6 +305,166 @@ const Autofocus = forwardRef(
     ] });
   }
 );
+const LensFlareShader = {
+  fragmentShader: (
+    /* glsl */
+    `
+
+  uniform float iTime;
+  uniform vec2 lensPosition;
+  uniform vec2 iResolution;
+  uniform vec3 colorGain;
+  uniform float starPoints;
+  uniform float glareSize;
+  uniform float flareSize;
+  uniform float flareSpeed;
+  uniform float flareShape;
+  uniform float haloScale;
+  uniform float opacity;
+  uniform bool animated;
+  uniform bool anamorphic;
+  uniform bool enabled;
+  uniform bool secondaryGhosts;
+  uniform bool starBurst;
+  uniform float ghostScale;
+  uniform bool aditionalStreaks;
+  uniform sampler2D lensDirtTexture;
+  vec2 vxtC;
+
+  float rndf(float n){return fract(sin(n) * 43758.5453123);}float niz(float p){float fl = floor(p);float fc = fract(p);return mix(rndf(fl),rndf(fl + 1.0), fc);}
+  vec3 hsv2rgb(vec3 c){vec4 k = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);vec3 p = abs(fract(c.xxx + k.xyz) * 6.0 - k.www);return c.z * mix(k.xxx, clamp(p - k.xxx, 0.0, 1.0), c.y);}
+  float satU(float x){return clamp(x, 0.,1.);}vec2 rtU(vec2 naz, float rtn){return vec2(cos(rtn) * naz.x + sin(rtn) * naz.y,cos(rtn) * naz.y - sin(rtn) * naz.x);}
+  vec3 drwF(vec2 p, float intensity, float rnd, float speed, int id){float flhos = (1. / 32.) * float(id) * 0.1;float lingrad = distance(vec2(0.), p);float expg = 1. / exp(lingrad * (fract(rnd) * 0.66 + 0.33));vec3 qzTg = hsv2rgb(vec3( fract( (expg * 8.) + speed * flareSpeed + flhos), pow(1.-abs(expg*2.-1.), 0.45), 20.0 * expg * intensity));float internalStarPoints;if(anamorphic){internalStarPoints = 1.0;} else{internalStarPoints = starPoints;}float ams = length(p * flareShape * sin(internalStarPoints * atan(p.x, p.y)));float kJhg = pow(1.-satU(ams), ( anamorphic ? 100. : 12.));kJhg += satU(expg-0.9) * 3.;kJhg = pow(kJhg * expg, 8. + (1.-intensity) * 5.);if(flareSpeed > 0.0){return vec3(kJhg) * qzTg;} else{return vec3(kJhg) * flareSize * 15.;}}
+  float ams2(vec3 a, vec3 b) { return abs(a.x - b.x) + abs(a.y - b.y) + abs(a.z - b.z);}vec3 satU(vec3 x){return clamp(x, vec3(0.0), vec3(1.0));}
+  float glR(vec2 naz, vec2 pos, float zsi){vec2 mni;if(animated){mni = rtU(naz-pos, iTime * 0.1);} else{mni = naz-pos;}float ang = atan(mni.y, mni.x) * (anamorphic ? 1.0 : starPoints);float ams2 = length(mni);ams2 = pow(ams2, .9);float f0 = 1.0/(length(naz-pos)*(1.0/zsi*16.0)+.2);return f0+f0*(sin((ang))*.2 +.3);}
+  float sdHex(vec2 p){p = abs(p);vec2 q = vec2(p.x*2.0*0.5773503, p.y + p.x*0.5773503);return dot(step(q.xy,q.yx), 1.0-q.yx);}float fpow(float x, float k){return x > k ? pow((x-k)/(1.0-k),2.0) : 0.0;}
+  vec3 rHx(vec2 naz, vec2 p, float s, vec3 col){naz -= p;if (abs(naz.x) < 0.2*s && abs(naz.y) < 0.2*s){return mix(vec3(0),mix(vec3(0),col,0.1 + fpow(length(naz/s),0.1)*10.0),smoothstep(0.0,0.1,sdHex(naz*20.0/s)));}return vec3(0);}
+  vec3 mLs(vec2 naz, vec2 pos){vec2 mni = naz-pos;vec2 zxMp = naz*(length(naz));float ang = atan(mni.x,mni.y);float f0 = .3/(length(naz-pos)*16.0+1.0);f0 = f0*(sin(niz(sin(ang*3.9-(animated ? iTime : 0.0) * 0.3) * starPoints))*.2 );float f1 = max(0.01-pow(length(naz+1.2*pos),1.9),.0)*7.0;float f2 = max(.9/(10.0+32.0*pow(length(zxMp+0.99*pos),2.0)),.0)*0.35;float f22 = max(.9/(11.0+32.0*pow(length(zxMp+0.85*pos),2.0)),.0)*0.23;float f23 = max(.9/(12.0+32.0*pow(length(zxMp+0.95*pos),2.0)),.0)*0.6;vec2 ztX = mix(naz,zxMp, 0.1);float f4 = max(0.01-pow(length(ztX+0.4*pos),2.9),.0)*4.02;float f42 = max(0.0-pow(length(ztX+0.45*pos),2.9),.0)*4.1;float f43 = max(0.01-pow(length(ztX+0.5*pos),2.9),.0)*4.6;ztX = mix(naz,zxMp,-.4);float f5 = max(0.01-pow(length(ztX+0.1*pos),5.5),.0)*2.0;float f52 = max(0.01-pow(length(ztX+0.2*pos),5.5),.0)*2.0;float f53 = max(0.01-pow(length(ztX+0.1*pos),5.5),.0)*2.0;ztX = mix(naz,zxMp, 2.1);float f6 = max(0.01-pow(length(ztX-0.3*pos),1.61),.0)*3.159;float f62 = max(0.01-pow(length(ztX-0.325*pos),1.614),.0)*3.14;float f63 = max(0.01-pow(length(ztX-0.389*pos),1.623),.0)*3.12;vec3 c = vec3(glR(naz,pos, glareSize));vec2 prot;if(animated){prot = rtU(naz - pos, (iTime * 0.1));} else if(anamorphic){prot = rtU(naz - pos, 1.570796);} else {prot = naz - pos;}c += drwF(prot, (anamorphic ? flareSize * 10. : flareSize), 0.1, iTime, 1);c.r+=f1+f2+f4+f5+f6; c.g+=f1+f22+f42+f52+f62; c.b+=f1+f23+f43+f53+f63;c = c*1.3 * vec3(length(zxMp)+.09);c+=vec3(f0);return c;}
+  vec3 cc(vec3 clr, float fct,float fct2){float w = clr.x+clr.y+clr.z;return mix(clr,vec3(w)*fct,w*fct2);}float rnd(vec2 p){float f = fract(sin(dot(p, vec2(12.1234, 72.8392) )*45123.2));return f;}float rnd(float w){float f = fract(sin(w)*1000.);return f;}
+  float rShp(vec2 p, int N){float f;float a=atan(p.x,p.y)+.2;float b=6.28319/float(N);f=smoothstep(.5,.51, cos(floor(.5+a/b)*b-a)*length(p.xy)* 2.0  -ghostScale);return f;}
+  vec3 drC(vec2 p, float zsi, float dCy, vec3 clr, vec3 clr2, float ams2, vec2 esom){float l = length(p + esom*(ams2*2.))+zsi/2.;float l2 = length(p + esom*(ams2*4.))+zsi/3.;float c = max(0.01-pow(length(p + esom*ams2), zsi*ghostScale), 0.0)*10.;float c1 = max(0.001-pow(l-0.3, 1./40.)+sin(l*20.), 0.0)*3.;float c2 =  max(0.09/pow(length(p-esom*ams2/.5)*1., .95), 0.0)/20.;float s = max(0.02-pow(rShp(p*5. + esom*ams2*5. + dCy, 6) , 1.), 0.0)*1.5;clr = cos(vec3(0.44, .24, .2)*8. + ams2*4.)*0.5+.5;vec3 f = c*clr;f += c1*clr;f += c2*clr;f +=  s*clr;return f-0.01;}
+  vec4 geLC(float x){return vec4(vec3(mix(mix(mix(mix(mix(mix(mix(mix(mix(mix(mix(mix(mix(mix(mix(vec3(0., 0., 0.),vec3(0., 0., 0.), smoothstep(0.0, 0.063, x)),vec3(0., 0., 0.), smoothstep(0.063, 0.125, x)),vec3(0.0, 0., 0.), smoothstep(0.125, 0.188, x)),vec3(0.188, 0.131, 0.116), smoothstep(0.188, 0.227, x)),vec3(0.31, 0.204, 0.537), smoothstep(0.227, 0.251, x)),vec3(0.192, 0.106, 0.286), smoothstep(0.251, 0.314, x)),vec3(0.102, 0.008, 0.341), smoothstep(0.314, 0.392, x)),vec3(0.086, 0.0, 0.141), smoothstep(0.392, 0.502, x)),vec3(1.0, 0.31, 0.0), smoothstep(0.502, 0.604, x)),vec3(.1, 0.1, 0.1), smoothstep(0.604, 0.643, x)),vec3(1.0, 0.929, 0.0), smoothstep(0.643, 0.761, x)),vec3(1.0, 0.086, 0.424), smoothstep(0.761, 0.847, x)),vec3(1.0, 0.49, 0.0), smoothstep(0.847, 0.89, x)),vec3(0.945, 0.275, 0.475), smoothstep(0.89, 0.941, x)),vec3(0.251, 0.275, 0.796), smoothstep(0.941, 1.0, x))),1.0);}
+  float diTN(vec2 p){vec2 f = fract(p);f = (f * f) * (3.0 - (2.0 * f));float n = dot(floor(p), vec2(1.0, 157.0));vec4 a = fract(sin(vec4(n + 0.0, n + 1.0, n + 157.0, n + 158.0)) * 43758.5453123);return mix(mix(a.x, a.y, f.x), mix(a.z, a.w, f.x), f.y);} 
+  float fbm(vec2 p){const mat2 m = mat2(0.80, -0.60, 0.60, 0.80);float f = 0.0;f += 0.5000*diTN(p); p = m*p*2.02;f += 0.2500*diTN(p); p = m*p*2.03;f += 0.1250*diTN(p); p = m*p*2.01;f += 0.0625*diTN(p);return f/0.9375;} 
+  vec4 geLS(vec2 p){vec2 pp = (p - vec2(0.5)) * 2.0;float a = atan(pp.y, pp.x);vec4 cp = vec4(sin(a * 1.0), length(pp), sin(a * 13.0), sin(a * 53.0));float d = sin(clamp(pow(length(vec2(0.5) - p) * 0.5 + haloScale /2., 5.0), 0.0, 1.0) * 3.14159);vec3 c = vec3(d) * vec3(fbm(cp.xy * 16.0) * fbm(cp.zw * 9.0) * max(max(max(max(0.5, sin(a * 1.0)), sin(a * 3.0) * 0.8), sin(a * 7.0) * 0.8), sin(a * 9.0) * 10.6));c *= vec3(mix(2.0, (sin(length(pp.xy) * 256.0) * 0.5) + 0.5, sin((clamp((length(pp.xy) - 0.875) / 0.1, 0.0, 1.0) + 0.0) * 2.0 * 3.14159) * 1.5) + 0.5) * 0.3275;return vec4(vec3(c * 1.0), d);}
+  vec4 geLD(vec2 p){p.xy += vec2(fbm(p.yx * 3.0), fbm(p.yx * 2.0)) * 0.0825;vec3 o = vec3(mix(0.125, 0.25, max(max(smoothstep(0.1, 0.0, length(p - vec2(0.25))),smoothstep(0.4, 0.0, length(p - vec2(0.75)))),smoothstep(0.8, 0.0, length(p - vec2(0.875, 0.125))))));o += vec3(max(fbm(p * 1.0) - 0.5, 0.0)) * 0.5;o += vec3(max(fbm(p * 2.0) - 0.5, 0.0)) * 0.5;o += vec3(max(fbm(p * 4.0) - 0.5, 0.0)) * 0.25;o += vec3(max(fbm(p * 8.0) - 0.75, 0.0)) * 1.0;o += vec3(max(fbm(p * 16.0) - 0.75, 0.0)) * 0.75;o += vec3(max(fbm(p * 64.0) - 0.75, 0.0)) * 0.5;return vec4(clamp(o, vec3(0.15), vec3(1.0)), 1.0);}
+  vec4 txL(sampler2D tex, vec2 xtC){if(((xtC.x < 0.) || (xtC.y < 0.)) || ((xtC.x > 1.) || (xtC.y > 1.))){return vec4(0.0);}else{return texture(tex, xtC); }}
+  vec4 txD(sampler2D tex, vec2 xtC, vec2 dir, vec3 ditn) {return vec4(txL(tex, (xtC + (dir * ditn.r))).r,txL(tex, (xtC + (dir * ditn.g))).g,txL(tex, (xtC + (dir * ditn.b))).b,1.0);}
+  vec4 strB(){vec2 aspXtc = vec2(1.0) - (((vxtC - vec2(0.5)) * vec2(1.0)) + vec2(0.5)); vec2 xtC = vec2(1.0) - vxtC; vec2 ghvc = (vec2(0.5) - xtC) * 0.3 - lensPosition; vec2 ghNm = normalize(ghvc * vec2(1.0)) * vec2(1.0);vec2 haloVec = normalize(ghvc) * 0.6;vec2 hlNm = ghNm * 0.6;vec2 texelSize = vec2(1.0) / vec2(iResolution.xy);vec3 ditn = vec3(-(texelSize.x * 1.5), 0.2, texelSize.x * 1.5);vec4 c = vec4(0.0);for (int i = 0; i < 8; i++) {vec2 offset = xtC + (ghvc * float(i));c += txD(lensDirtTexture, offset, ghNm, ditn) * pow(max(0.0, 1.0 - (length(vec2(0.5) - offset) / length(vec2(0.5)))), 10.0);}vec2 uyTrz = xtC + hlNm; return (c * geLC((length(vec2(0.5) - aspXtc) / length(vec2(haloScale))))) +(txD(lensDirtTexture, uyTrz, ghNm, ditn) * pow(max(0.0, 1.0 - (length(vec2(0.5) - uyTrz) / length(vec2(0.5)))), 10.0));} 
+  void mainImage(vec4 v,vec2 r,out vec4 i){vec2 g=r-.5;g.y*=iResolution.y/iResolution.x;vec2 l=lensPosition*.5;l.y*=iResolution.y/iResolution.x;vec3 f=mLs(g,l)*20.*colorGain/256.;if(aditionalStreaks){vec3 o=vec3(.9,.2,.1),p=vec3(.3,.1,.9);for(float n=0.;n<10.;n++)f+=drC(g,pow(rnd(n*2e3)*2.8,.1)+1.41,0.,o+n,p+n,rnd(n*20.)*3.+.2-.5,lensPosition);}if(secondaryGhosts){vec3 n=vec3(0);n+=rHx(g,-lensPosition*.25,ghostScale*1.4,vec3(.25,.35,0));n+=rHx(g,lensPosition*.25,ghostScale*.5,vec3(1,.5,.5));n+=rHx(g,lensPosition*.1,ghostScale*1.6,vec3(1));n+=rHx(g,lensPosition*1.8,ghostScale*2.,vec3(0,.5,.75));n+=rHx(g,lensPosition*1.25,ghostScale*.8,vec3(1,1,.5));n+=rHx(g,-lensPosition*1.25,ghostScale*5.,vec3(.5,.5,.25));n+=fpow(1.-abs(distance(lensPosition*.8,g)-.7),.985)*colorGain/2100.;f+=n;}if(starBurst){vxtC=g+.5;vec4 n=geLD(g);float o=1.-clamp(0.5,0.,.5)*2.;n+=mix(n,pow(n*2.,vec4(2))*.5,o);float s=(g.x+g.y)*(1./6.);vec2 d=mat2(cos(s),-sin(s),sin(s),cos(s))*vxtC;n+=geLS(d)*2.;f+=clamp(n.xyz*strB().xyz,.01,1.);}i=enabled?vec4(mix(f,vec3(0),opacity)+v.xyz,v.w):vec4(v);}
+`
+  )
+};
+class LensFlareEffect extends Effect {
+  constructor({
+    blendFunction = BlendFunction.NORMAL,
+    enabled = true,
+    glareSize = 0.2,
+    lensPosition = [0.01, 0.01],
+    iResolution = [0, 0],
+    starPoints = 6,
+    flareSize = 0.01,
+    flareSpeed = 0.01,
+    flareShape = 0.01,
+    animated = true,
+    anamorphic = false,
+    colorGain = new THREE.Color(20, 20, 20),
+    lensDirtTexture = null,
+    haloScale = 0.5,
+    secondaryGhosts = true,
+    aditionalStreaks = true,
+    ghostScale = 0,
+    opacity = 1,
+    starBurst = false
+  } = {}) {
+    super("LensFlareEffect", LensFlareShader.fragmentShader, {
+      blendFunction,
+      uniforms: /* @__PURE__ */ new Map([
+        ["enabled", new THREE.Uniform(enabled)],
+        ["glareSize", new THREE.Uniform(glareSize)],
+        ["lensPosition", new THREE.Uniform(lensPosition)],
+        ["iTime", new THREE.Uniform(0)],
+        ["iResolution", new THREE.Uniform(iResolution)],
+        ["starPoints", new THREE.Uniform(starPoints)],
+        ["flareSize", new THREE.Uniform(flareSize)],
+        ["flareSpeed", new THREE.Uniform(flareSpeed)],
+        ["flareShape", new THREE.Uniform(flareShape)],
+        ["animated", new THREE.Uniform(animated)],
+        ["anamorphic", new THREE.Uniform(anamorphic)],
+        ["colorGain", new THREE.Uniform(colorGain)],
+        ["lensDirtTexture", new THREE.Uniform(lensDirtTexture)],
+        ["haloScale", new THREE.Uniform(haloScale)],
+        ["secondaryGhosts", new THREE.Uniform(secondaryGhosts)],
+        ["aditionalStreaks", new THREE.Uniform(aditionalStreaks)],
+        ["ghostScale", new THREE.Uniform(ghostScale)],
+        ["starBurst", new THREE.Uniform(starBurst)],
+        ["opacity", new THREE.Uniform(opacity)]
+      ])
+    });
+  }
+  update(_renderer, _inputBuffer, deltaTime) {
+    const iTime = this.uniforms.get("iTime");
+    if (iTime) {
+      iTime.value += deltaTime;
+    }
+  }
+}
+const LensFlare = forwardRef(
+  ({ position = new THREE.Vector3(-25, 6, -60), followMouse = false, smoothTime = 0.07, ...props }, ref) => {
+    const viewport = useThree(({ viewport: viewport2 }) => viewport2);
+    const raycaster = useThree(({ raycaster: raycaster2 }) => raycaster2);
+    const pointer = useThree(({ pointer: pointer2 }) => pointer2);
+    const { scene, camera } = useContext(EffectComposerContext);
+    const [projectedPosition] = useState(() => new THREE.Vector3());
+    const [mouse2d] = useState(() => new THREE.Vector2());
+    const effect = useMemo(() => new LensFlareEffect(props), [props]);
+    useFrame((_, delta) => {
+      var _a, _b, _c;
+      const uLensPosition = effect.uniforms.get("lensPosition");
+      const uOpacity = effect.uniforms.get("opacity");
+      if (!uLensPosition || !uOpacity)
+        return;
+      let target = 1;
+      if (followMouse) {
+        uLensPosition.value.x = pointer.x;
+        uLensPosition.value.y = pointer.y;
+        target = 0;
+      } else {
+        projectedPosition.copy(position).project(camera);
+        if (projectedPosition.z > 1)
+          return;
+        uLensPosition.value.x = projectedPosition.x;
+        uLensPosition.value.y = projectedPosition.y;
+        mouse2d.set(projectedPosition.x, projectedPosition.y);
+        raycaster.setFromCamera(mouse2d, camera);
+        const intersects = raycaster.intersectObjects(scene.children, true);
+        const { object } = intersects[0];
+        if (object) {
+          if (((_a = object.userData) == null ? void 0 : _a.lensflare) === "no-occlusion") {
+            target = 0;
+          } else if (object instanceof THREE.Mesh) {
+            if (((_c = (_b = object.material.uniforms) == null ? void 0 : _b._transmission) == null ? void 0 : _c.value) > 0.2) {
+              target = 0.2;
+            } else if (object.material._transmission && object.material._transmission > 0.2) {
+              target = 0.2;
+            } else if (object.material.transparent) {
+              target = object.material.opacity;
+            }
+          }
+        }
+      }
+      easing.damp(uOpacity, "value", target, smoothTime, delta);
+    });
+    useEffect(() => {
+      const iResolution = effect.uniforms.get("iResolution");
+      if (iResolution) {
+        iResolution.value.x = viewport.width;
+        iResolution.value.y = viewport.height;
+      }
+    }, [effect, viewport]);
+    return /* @__PURE__ */ jsx("primitive", { ref, object: effect, dispose: null });
+  }
+);
 const Bloom = wrapEffect(BloomEffect, {
   blendFunction: BlendFunction.ADD
 });
@@ -764,6 +923,1132 @@ const ASCII = forwardRef(
     return /* @__PURE__ */ jsx("primitive", { ref: fref, object: effect });
   }
 );
+var boxBlur = "#define GLSLIFY 1\nuniform float blur;uniform float blurSharpness;uniform int blurKernel;vec3 denoise(vec3 center,sampler2D tex,vec2 uv,vec2 invTexSize,float blur,float blurSharpness,int blurKernel){vec3 color;float total;vec3 col;float weight;for(int x=-blurKernel;x<=blurKernel;x++){for(int y=-blurKernel;y<=blurKernel;y++){col=textureLod(tex,uv+vec2(x,y)*invTexSize,0.).rgb;weight=1.0-abs(dot(col-center,vec3(0.25)));weight=pow(weight,blurSharpness);color+=col*weight;total+=weight;}}return color/total;}";
+var finalSSRShader = "#define GLSLIFY 1\n#define MODE_DEFAULT 0\n#define MODE_REFLECTIONS 1\n#define MODE_RAW_REFLECTION 2\n#define MODE_BLURRED_REFLECTIONS 3\n#define MODE_INPUT 4\n#define MODE_BLUR_MIX 5\n#define FLOAT_EPSILON 0.00001\nuniform sampler2D inputTexture;uniform sampler2D reflectionsTexture;uniform float samples;\n#include <boxBlur>\nvoid mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){vec4 reflectionsTexel=texture2D(reflectionsTexture,vUv);ivec2 size=textureSize(reflectionsTexture,0);vec2 invTexSize=1./vec2(size.x,size.y);vec3 reflectionClr=reflectionsTexel.xyz;if(blur>FLOAT_EPSILON){vec3 blurredReflectionsColor=denoise(reflectionsTexel.rgb,reflectionsTexture,vUv,invTexSize,blur,blurSharpness,blurKernel);reflectionClr=mix(reflectionClr,blurredReflectionsColor.rgb,blur);}\n#if RENDER_MODE == MODE_DEFAULT\noutputColor=vec4(inputColor.rgb+reflectionClr,1.0);\n#endif\n#if RENDER_MODE == MODE_REFLECTIONS\noutputColor=vec4(reflectionClr,1.0);\n#endif\n#if RENDER_MODE == MODE_RAW_REFLECTION\noutputColor=vec4(reflectionsTexel.xyz,1.0);\n#endif\n#if RENDER_MODE == MODE_BLURRED_REFLECTIONS\noutputColor=vec4(blurredReflectionsTexel.xyz,1.0);\n#endif\n#if RENDER_MODE == MODE_INPUT\noutputColor=vec4(inputColor.xyz,1.0);\n#endif\n#if RENDER_MODE == MODE_BLUR_MIX\noutputColor=vec4(vec3(blur),1.0);\n#endif\n}";
+var helperFunctions = "#define GLSLIFY 1\nvec3 getViewPosition(const float depth){float clipW=_projectionMatrix[2][3]*depth+_projectionMatrix[3][3];vec4 clipPosition=vec4((vec3(vUv,depth)-0.5)*2.0,1.0);clipPosition*=clipW;return(_inverseProjectionMatrix*clipPosition).xyz;}float 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){vec4 ndc=vec4((uv.x-0.5)*2.0,(uv.y-0.5)*2.0,(depth-0.5)*2.0,1.0);vec4 clip=_inverseProjectionMatrix*ndc;vec4 view=cameraMatrixWorld*(clip/clip.w);return view.xyz;}\n#define Scale (vec3(0.8, 0.8, 0.8))\n#define K (19.19)\nvec3 hash(vec3 a){a=fract(a*Scale);a+=dot(a,a.yxz+K);return fract((a.xxy+a.yxx)*a.zyx);}float fresnel_dielectric_cos(float cosi,float eta){float c=abs(cosi);float g=eta*eta-1.0+c*c;float result;if(g>0.0){g=sqrt(g);float A=(g-c)/(g+c);float B=(c*(g+c)-1.0)/(c*(g-c)+1.0);result=0.5*A*A*(1.0+B*B);}else{result=1.0;}return result;}float fresnel_dielectric(vec3 Incoming,vec3 Normal,float eta){float cosine=dot(Incoming,Normal);return min(1.0,5.0*fresnel_dielectric_cos(cosine,eta));}";
+var trCompose = "#define GLSLIFY 1\n#define INV_EULER 0.36787944117144233\nalpha=velocityDisocclusion<FLOAT_EPSILON ?(alpha+0.0075): 0.0;alpha=clamp(alpha,0.0,1.0);bool needsBlur=!didReproject||velocityDisocclusion>0.5;\n#ifdef boxBlur\nif(needsBlur)inputColor=boxBlurredColor;\n#endif\nif(alpha==1.0){outputColor=accumulatedColor;}else{float m=mix(alpha,1.0,blend);if(needsBlur)m=0.0;outputColor=accumulatedColor*m+inputColor*(1.0-m);}";
+class MRTMaterial extends ShaderMaterial {
+  constructor() {
+    super({
+      type: "MRTMaterial",
+      defines: {
+        USE_UV: "",
+        TEMPORAL_RESOLVE: ""
+      },
+      uniforms: {
+        opacity: new Uniform(1),
+        normalMap: new Uniform(null),
+        normalScale: new Uniform(new Vector2(1, 1)),
+        uvTransform: new Uniform(new Matrix3()),
+        roughness: new Uniform(1),
+        roughnessMap: new Uniform(null)
+      },
+      vertexShader: (
+        /* glsl */
+        `
+                #ifdef USE_MRT
+                 varying vec2 vHighPrecisionZW;
+                #endif
+                #define NORMAL
+                #if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
+                    varying vec3 vViewPosition;
+                #endif
+                #include <common>
+                #include <uv_pars_vertex>
+                #include <displacementmap_pars_vertex>
+                #include <normal_pars_vertex>
+                #include <morphtarget_pars_vertex>
+                #include <skinning_pars_vertex>
+                #include <logdepthbuf_pars_vertex>
+                #include <clipping_planes_pars_vertex>
+                #ifdef USE_UV
+                  ${REVISION.replace(/\D+/g, "") >= 151 ? "uniform mat3 uvTransform;" : ""}
+                #endif
+                void main() {
+                    #include <uv_vertex>
+                    #include <beginnormal_vertex>
+                    #include <morphnormal_vertex>
+                    #include <skinbase_vertex>
+                    #include <skinnormal_vertex>
+                    #include <defaultnormal_vertex>
+                    #include <normal_vertex>
+                    #include <begin_vertex>
+                    #include <morphtarget_vertex>
+                    #include <skinning_vertex>
+                    #include <displacementmap_vertex>
+                    #include <project_vertex>
+                    #include <logdepthbuf_vertex>
+                    #include <clipping_planes_vertex>
+                    #if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
+                        vViewPosition = - mvPosition.xyz;
+                    #endif
+                    #ifdef USE_MRT
+                        vHighPrecisionZW = gl_Position.zw;
+                    #endif
+                    #ifdef USE_UV
+                        vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
+                    #endif
+                }
+            `
+      ),
+      fragmentShader: (
+        /* glsl */
+        `
+                 #define NORMAL
+                #if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
+                    varying vec3 vViewPosition;
+                #endif
+                #include <packing>
+                #include <uv_pars_fragment>
+                #include <normal_pars_fragment>
+                #include <bumpmap_pars_fragment>
+                #include <normalmap_pars_fragment>
+                #include <logdepthbuf_pars_fragment>
+                #include <clipping_planes_pars_fragment>
+                #include <roughnessmap_pars_fragment>
+
+                #ifdef USE_MRT
+                layout(location = 0) out vec4 gNormal;
+                layout(location = 1) out vec4 gDepth;
+
+                varying vec2 vHighPrecisionZW;
+                #endif
+                uniform float roughness;
+                void main() {
+                    #include <clipping_planes_fragment>
+                    #include <logdepthbuf_fragment>
+                    #include <normal_fragment_begin>
+                    #include <normal_fragment_maps>
+
+                    float roughnessFactor = roughness;
+
+                    if(roughness > 10.0e9){
+                        roughnessFactor = 1.;
+                    }else{
+                        #ifdef useRoughnessMap
+                            vec4 texelRoughness = texture2D( roughnessMap, vUv );
+                            // reads channel G, compatible with a combined OcclusionRoughnessMetallic (RGB) texture
+                            roughnessFactor *= texelRoughness.g;
+                        #endif
+                    }
+
+                    vec3 normalColor = packNormalToRGB( normal );
+                    #ifdef USE_MRT
+                        float fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;
+                        vec4 depthColor = packDepthToRGBA( fragCoordZ );
+                        gNormal = vec4( normalColor, roughnessFactor );
+                        gDepth = depthColor;
+                    #else
+                        gl_FragColor = vec4(normalColor, roughnessFactor);
+                    #endif
+                }
+            `
+      ),
+      toneMapped: false
+    });
+    this.normalMapType = TangentSpaceNormalMap;
+    this.normalScale = new Vector2(1, 1);
+    Object.defineProperty(this, "glslVersion", {
+      get() {
+        return "USE_MRT" in this.defines ? GLSL3 : null;
+      },
+      set(_) {
+      }
+    });
+  }
+}
+var vertexShader$1 = "#define GLSLIFY 1\nvarying vec2 vUv;void main(){vUv=position.xy*0.5+0.5;gl_Position=vec4(position.xy,1.0,1.0);}";
+var fragmentShader = "#define GLSLIFY 1\nvarying vec2 vUv;uniform sampler2D inputTexture;uniform sampler2D accumulatedTexture;uniform sampler2D normalTexture;uniform sampler2D depthTexture;uniform sampler2D envMap;uniform mat4 _projectionMatrix;uniform mat4 _inverseProjectionMatrix;uniform mat4 cameraMatrixWorld;uniform float cameraNear;uniform float cameraFar;uniform float rayDistance;uniform float intensity;uniform float maxDepthDifference;uniform float roughnessFade;uniform float maxRoughness;uniform float fade;uniform float thickness;uniform float ior;uniform float samples;uniform float jitter;uniform float jitterRoughness;\n#define INVALID_RAY_COORDS vec2(-1.0);\n#define EARLY_OUT_COLOR vec4(0.0, 0.0, 0.0, 1.0)\n#define FLOAT_EPSILON 0.00001\nfloat nearMinusFar;float nearMulFar;float farMinusNear;\n#include <packing>\n#include <helperFunctions>\nvec2 RayMarch(vec3 dir,inout vec3 hitPos,inout float rayHitDepthDifference);vec2 BinarySearch(in vec3 dir,inout vec3 hitPos,inout float rayHitDepthDifference);float fastGetViewZ(const in float depth);vec3 getIBLRadiance(const in vec3 viewDir,const in vec3 normal,const in float roughness);void main(){vec4 depthTexel=textureLod(depthTexture,vUv,0.0);if(dot(depthTexel.rgb,depthTexel.rgb)<FLOAT_EPSILON){gl_FragColor=EARLY_OUT_COLOR;return;}float unpackedDepth=unpackRGBAToDepth(depthTexel);vec4 normalTexel=textureLod(normalTexture,vUv,0.0);float roughness=normalTexel.a;float specular=1.0-roughness;nearMinusFar=cameraNear-cameraFar;nearMulFar=cameraNear*cameraFar;farMinusNear=cameraFar-cameraNear;normalTexel.rgb=unpackRGBToNormal(normalTexel.rgb);float depth=fastGetViewZ(unpackedDepth);vec3 viewPos=getViewPosition(depth);vec3 viewDir=normalize(viewPos);vec3 viewNormal=normalTexel.xyz;vec3 worldPos=screenSpaceToWorldSpace(vUv,unpackedDepth);vec3 jitt=vec3(0.0);if(jitterRoughness!=0.0||jitter!=0.0){vec3 randomJitter=hash(50.0*samples*worldPos)-0.5;float spread=((2.0-specular)+roughness*jitterRoughness);float jitterMix=jitter*0.25+jitterRoughness*roughness;if(jitterMix>1.0)jitterMix=1.0;jitt=mix(vec3(0.0),randomJitter*spread,jitterMix);}viewNormal+=jitt;float fresnelFactor=fresnel_dielectric(viewDir,viewNormal,ior);vec3 iblRadiance=getIBLRadiance(-viewDir,viewNormal,0.)*fresnelFactor;float lastFrameAlpha=textureLod(accumulatedTexture,vUv,0.0).a;if(roughness>maxRoughness||(roughness>1.0-FLOAT_EPSILON&&roughnessFade>1.0-FLOAT_EPSILON)){gl_FragColor=vec4(iblRadiance,lastFrameAlpha);return;}vec3 reflected=reflect(viewDir,viewNormal);vec3 rayDir=reflected*-viewPos.z;vec3 hitPos=viewPos;float rayHitDepthDifference;vec2 coords=RayMarch(rayDir,hitPos,rayHitDepthDifference);if(coords.x==-1.0){gl_FragColor=vec4(iblRadiance,lastFrameAlpha);return;}vec4 SSRTexel=textureLod(inputTexture,coords.xy,0.0);vec4 SSRTexelReflected=textureLod(accumulatedTexture,coords.xy,0.0);vec3 SSR=SSRTexel.rgb+SSRTexelReflected.rgb;float roughnessFactor=mix(specular,1.0,max(0.0,1.0-roughnessFade));vec2 coordsNDC=(coords.xy*2.0-1.0);float screenFade=0.1;float maxDimension=min(1.0,max(abs(coordsNDC.x),abs(coordsNDC.y)));float reflectionIntensity=1.0-(max(0.0,maxDimension-screenFade)/(1.0-screenFade));reflectionIntensity=max(0.,reflectionIntensity);vec3 finalSSR=mix(iblRadiance,SSR,reflectionIntensity)*roughnessFactor;if(fade!=0.0){vec3 hitWorldPos=screenSpaceToWorldSpace(coords,rayHitDepthDifference);float reflectionDistance=distance(hitWorldPos,worldPos)+1.0;float opacity=1.0/(reflectionDistance*fade*0.1);if(opacity>1.0)opacity=1.0;finalSSR*=opacity;}finalSSR*=fresnelFactor*intensity;finalSSR=min(vec3(1.0),finalSSR);float alpha=hitPos.z==1.0 ? 1.0 : SSRTexelReflected.a;alpha=min(lastFrameAlpha,alpha);gl_FragColor=vec4(finalSSR,alpha);}vec2 RayMarch(vec3 dir,inout vec3 hitPos,inout float rayHitDepthDifference){dir=normalize(dir);dir*=rayDistance/float(steps);float depth;vec4 projectedCoord;vec4 lastProjectedCoord;float unpackedDepth;vec4 depthTexel;for(int i=0;i<steps;i++){hitPos+=dir;projectedCoord=_projectionMatrix*vec4(hitPos,1.0);projectedCoord.xy/=projectedCoord.w;projectedCoord.xy=projectedCoord.xy*0.5+0.5;\n#ifndef missedRays\nif(projectedCoord.x<0.0||projectedCoord.x>1.0||projectedCoord.y<0.0||projectedCoord.y>1.0){return INVALID_RAY_COORDS;}\n#endif\ndepthTexel=textureLod(depthTexture,projectedCoord.xy,0.0);unpackedDepth=unpackRGBAToDepth(depthTexel);depth=fastGetViewZ(unpackedDepth);rayHitDepthDifference=depth-hitPos.z;if(rayHitDepthDifference>=0.0&&rayHitDepthDifference<thickness){\n#if refineSteps == 0\nif(dot(depthTexel.rgb,depthTexel.rgb)<FLOAT_EPSILON)return INVALID_RAY_COORDS;\n#else\nreturn BinarySearch(dir,hitPos,rayHitDepthDifference);\n#endif\n}\n#ifndef missedRays\nif(hitPos.z>0.0){return INVALID_RAY_COORDS;}\n#endif\nlastProjectedCoord=projectedCoord;}hitPos.z=1.0;\n#ifndef missedRays\nreturn INVALID_RAY_COORDS;\n#endif\nrayHitDepthDifference=unpackedDepth;return projectedCoord.xy;}vec2 BinarySearch(in vec3 dir,inout vec3 hitPos,inout float rayHitDepthDifference){float depth;vec4 projectedCoord;vec2 lastMinProjectedCoordXY;float unpackedDepth;vec4 depthTexel;for(int i=0;i<refineSteps;i++){projectedCoord=_projectionMatrix*vec4(hitPos,1.0);projectedCoord.xy/=projectedCoord.w;projectedCoord.xy=projectedCoord.xy*0.5+0.5;depthTexel=textureLod(depthTexture,projectedCoord.xy,0.0);unpackedDepth=unpackRGBAToDepth(depthTexel);depth=fastGetViewZ(unpackedDepth);rayHitDepthDifference=depth-hitPos.z;dir*=0.5;if(rayHitDepthDifference>0.0){hitPos-=dir;}else{hitPos+=dir;}}if(dot(depthTexel.rgb,depthTexel.rgb)<FLOAT_EPSILON)return INVALID_RAY_COORDS;if(abs(rayHitDepthDifference)>maxDepthDifference)return INVALID_RAY_COORDS;projectedCoord=_projectionMatrix*vec4(hitPos,1.0);projectedCoord.xy/=projectedCoord.w;projectedCoord.xy=projectedCoord.xy*0.5+0.5;rayHitDepthDifference=unpackedDepth;return projectedCoord.xy;}float fastGetViewZ(const in float depth){\n#ifdef PERSPECTIVE_CAMERA\nreturn nearMulFar/(farMinusNear*depth-cameraFar);\n#else\nreturn depth*nearMinusFar-cameraNear;\n#endif\n}\n#include <common>\n#include <cube_uv_reflection_fragment>\nvec3 getIBLRadiance(const in vec3 viewDir,const in vec3 normal,const in float roughness){\n#if defined(ENVMAP_TYPE_CUBE_UV)\nvec3 reflectVec=reflect(-viewDir,normal);reflectVec=normalize(mix(reflectVec,normal,roughness*roughness));reflectVec=inverseTransformDirection(reflectVec,viewMatrix);vec4 envMapColor=textureCubeUV(envMap,reflectVec,roughness);return envMapColor.rgb*intensity;\n#else\nreturn vec3(0.0);\n#endif\n}";
+class ReflectionsMaterial extends ShaderMaterial {
+  constructor() {
+    super({
+      type: "ReflectionsMaterial",
+      uniforms: {
+        inputTexture: new Uniform(null),
+        accumulatedTexture: new Uniform(null),
+        normalTexture: new Uniform(null),
+        depthTexture: new Uniform(null),
+        _projectionMatrix: new Uniform(new Matrix4()),
+        _inverseProjectionMatrix: new Uniform(new Matrix4()),
+        cameraMatrixWorld: new Uniform(new Matrix4()),
+        cameraNear: new Uniform(0),
+        cameraFar: new Uniform(0),
+        rayDistance: new Uniform(0),
+        intensity: new Uniform(0),
+        roughnessFade: new Uniform(0),
+        fade: new Uniform(0),
+        thickness: new Uniform(0),
+        ior: new Uniform(0),
+        maxDepthDifference: new Uniform(0),
+        jitter: new Uniform(0),
+        jitterRoughness: new Uniform(0),
+        maxRoughness: new Uniform(0),
+        samples: new Uniform(0),
+        envMap: new Uniform(null),
+        envMapPosition: new Uniform(new Vector3()),
+        envMapSize: new Uniform(new Vector3()),
+        viewMatrix: new Uniform(new Matrix4())
+      },
+      defines: {
+        steps: 20,
+        refineSteps: 5,
+        CUBEUV_TEXEL_WIDTH: 0,
+        CUBEUV_TEXEL_HEIGHT: 0,
+        CUBEUV_MAX_MIP: 0,
+        vWorldPosition: "worldPos"
+      },
+      fragmentShader: fragmentShader.replace("#include <helperFunctions>", helperFunctions),
+      vertexShader: vertexShader$1,
+      toneMapped: false,
+      depthWrite: false,
+      depthTest: 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 generateCubeUVSize = (parameters) => {
+  const imageHeight = parameters.envMapCubeUVHeight;
+  if (imageHeight === null)
+    return null;
+  const maxMip = Math.log2(imageHeight) - 2;
+  const texelHeight = 1 / imageHeight;
+  const texelWidth = 1 / (3 * Math.max(Math.pow(2, maxMip), 7 * 16));
+  return {
+    texelWidth,
+    texelHeight,
+    maxMip
+  };
+};
+const setupEnvMap = (reflectionsMaterial, envMap, envMapCubeUVHeight) => {
+  reflectionsMaterial.uniforms.envMap.value = envMap;
+  const envMapCubeUVSize = generateCubeUVSize({
+    envMapCubeUVHeight
+  });
+  reflectionsMaterial.defines.ENVMAP_TYPE_CUBE_UV = "";
+  reflectionsMaterial.defines.CUBEUV_TEXEL_WIDTH = envMapCubeUVSize.texelWidth;
+  reflectionsMaterial.defines.CUBEUV_TEXEL_HEIGHT = envMapCubeUVSize.texelHeight;
+  reflectionsMaterial.defines.CUBEUV_MAX_MIP = envMapCubeUVSize.maxMip + ".0";
+  reflectionsMaterial.needsUpdate = true;
+};
+const isWebGL2Available = () => {
+  try {
+    const canvas = document.createElement("canvas");
+    return !!(window.WebGL2RenderingContext && canvas.getContext("webgl2"));
+  } catch (e) {
+    return false;
+  }
+};
+class ReflectionsPass extends Pass {
+  constructor(ssrEffect, options = {}) {
+    super("ReflectionsPass");
+    this.ssrEffect = void 0;
+    this.cachedMaterials = /* @__PURE__ */ new WeakMap();
+    this.USE_MRT = false;
+    this.webgl1DepthPass = null;
+    this.visibleMeshes = [];
+    this.ssrEffect = ssrEffect;
+    this._scene = ssrEffect._scene;
+    this._camera = ssrEffect._camera;
+    this.fullscreenMaterial = new ReflectionsMaterial();
+    if (ssrEffect._camera.isPerspectiveCamera)
+      this.fullscreenMaterial.defines.PERSPECTIVE_CAMERA = "";
+    const width = options.width || typeof window !== "undefined" ? window.innerWidth : 2e3;
+    const height = options.height || typeof window !== "undefined" ? window.innerHeight : 1e3;
+    this.renderTarget = new WebGLRenderTarget(width, height, {
+      minFilter: LinearFilter,
+      magFilter: LinearFilter,
+      type: HalfFloatType,
+      depthBuffer: false
+    });
+    this.renderPass = new RenderPass(this._scene, this._camera);
+    this.USE_MRT = isWebGL2Available();
+    if (this.USE_MRT) {
+      this.gBuffersRenderTarget = new WebGLMultipleRenderTargets(width, height, 2, {
+        minFilter: LinearFilter,
+        magFilter: LinearFilter
+      });
+      this.normalTexture = this.gBuffersRenderTarget.texture[0];
+      this.depthTexture = this.gBuffersRenderTarget.texture[1];
+    } else {
+      this.webgl1DepthPass = new DepthPass(this._scene, this._camera);
+      this.webgl1DepthPass.renderTarget.minFilter = LinearFilter;
+      this.webgl1DepthPass.renderTarget.magFilter = LinearFilter;
+      this.webgl1DepthPass.renderTarget.texture.minFilter = LinearFilter;
+      this.webgl1DepthPass.renderTarget.texture.magFilter = LinearFilter;
+      this.webgl1DepthPass.setSize(
+        typeof window !== "undefined" ? window.innerWidth : 2e3,
+        typeof window !== "undefined" ? window.innerHeight : 1e3
+      );
+      this.gBuffersRenderTarget = new WebGLRenderTarget(width, height, {
+        minFilter: LinearFilter,
+        magFilter: LinearFilter
+      });
+      this.normalTexture = this.gBuffersRenderTarget.texture;
+      this.depthTexture = this.webgl1DepthPass.texture;
+    }
+    this.fullscreenMaterial.uniforms.normalTexture.value = this.normalTexture;
+    this.fullscreenMaterial.uniforms.depthTexture.value = this.depthTexture;
+    this.fullscreenMaterial.uniforms.accumulatedTexture.value = this.ssrEffect.temporalResolvePass.accumulatedTexture;
+    this.fullscreenMaterial.uniforms.cameraMatrixWorld.value = this._camera.matrixWorld;
+    this.fullscreenMaterial.uniforms._projectionMatrix.value = this._camera.projectionMatrix;
+    this.fullscreenMaterial.uniforms._inverseProjectionMatrix.value = this._camera.projectionMatrixInverse;
+  }
+  setSize(width, height) {
+    this.renderTarget.setSize(width * this.ssrEffect.resolutionScale, height * this.ssrEffect.resolutionScale);
+    this.gBuffersRenderTarget.setSize(width * this.ssrEffect.resolutionScale, height * this.ssrEffect.resolutionScale);
+    this.fullscreenMaterial.uniforms.accumulatedTexture.value = this.ssrEffect.temporalResolvePass.accumulatedTexture;
+    this.fullscreenMaterial.needsUpdate = true;
+  }
+  dispose() {
+    this.renderTarget.dispose();
+    this.gBuffersRenderTarget.dispose();
+    this.renderPass.dispose();
+    if (!this.USE_MRT)
+      this.webgl1DepthPass.dispose();
+    this.fullscreenMaterial.dispose();
+    this.normalTexture = null;
+    this.depthTexture = null;
+    this.velocityTexture = null;
+  }
+  keepMaterialMapUpdated(mrtMaterial, originalMaterial, prop, define) {
+    if (this.ssrEffect[define]) {
+      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;
+      }
+    } else if (mrtMaterial[prop] !== void 0) {
+      mrtMaterial[prop] = void 0;
+      mrtMaterial.uniforms[prop].value = void 0;
+      delete mrtMaterial.defines[define];
+      mrtMaterial.needsUpdate = true;
+    }
+  }
+  setMRTMaterialInScene() {
+    this.visibleMeshes = getVisibleChildren(this._scene);
+    for (const c of this.visibleMeshes) {
+      if (c.material) {
+        const originalMaterial = c.material;
+        let [cachedOriginalMaterial, mrtMaterial] = this.cachedMaterials.get(c) || [];
+        if (originalMaterial !== cachedOriginalMaterial) {
+          if (mrtMaterial)
+            mrtMaterial.dispose();
+          mrtMaterial = new MRTMaterial();
+          if (this.USE_MRT)
+            mrtMaterial.defines.USE_MRT = "";
+          mrtMaterial.normalScale = originalMaterial.normalScale;
+          mrtMaterial.uniforms.normalScale.value = originalMaterial.normalScale;
+          const map = originalMaterial.map || originalMaterial.normalMap || originalMaterial.roughnessMap || originalMaterial.metalnessMap;
+          if (map)
+            mrtMaterial.uniforms.uvTransform.value = map.matrix;
+          this.cachedMaterials.set(c, [originalMaterial, mrtMaterial]);
+        }
+        this.keepMaterialMapUpdated(mrtMaterial, originalMaterial, "normalMap", "useNormalMap");
+        this.keepMaterialMapUpdated(mrtMaterial, originalMaterial, "roughnessMap", "useRoughnessMap");
+        mrtMaterial.uniforms.roughness.value = this.ssrEffect.selection.size === 0 || this.ssrEffect.selection.has(c) ? originalMaterial.roughness || 0 : 1e11;
+        c.material = mrtMaterial;
+      }
+    }
+  }
+  unsetMRTMaterialInScene() {
+    for (const c of this.visibleMeshes) {
+      var _c$material;
+      if (((_c$material = c.material) == null ? void 0 : _c$material.type) === "MRTMaterial") {
+        c.visible = true;
+        const [originalMaterial] = this.cachedMaterials.get(c);
+        c.material = originalMaterial;
+      }
+    }
+  }
+  render(renderer, inputBuffer) {
+    this.setMRTMaterialInScene();
+    renderer.setRenderTarget(this.gBuffersRenderTarget);
+    this.renderPass.render(renderer, this.gBuffersRenderTarget);
+    this.unsetMRTMaterialInScene();
+    if (!this.USE_MRT)
+      this.webgl1DepthPass.renderPass.render(renderer, this.webgl1DepthPass.renderTarget);
+    this.fullscreenMaterial.uniforms.inputTexture.value = inputBuffer.texture;
+    this.fullscreenMaterial.uniforms.samples.value = this.ssrEffect.temporalResolvePass.samples;
+    this.fullscreenMaterial.uniforms.cameraNear.value = this._camera.near;
+    this.fullscreenMaterial.uniforms.cameraFar.value = this._camera.far;
+    this.fullscreenMaterial.uniforms.viewMatrix.value.copy(this._camera.matrixWorldInverse);
+    renderer.setRenderTarget(this.renderTarget);
+    renderer.render(this.scene, this.camera);
+  }
+}
+const defaultSSROptions = {
+  intensity: 1,
+  exponent: 1,
+  distance: 10,
+  fade: 0,
+  roughnessFade: 1,
+  thickness: 10,
+  ior: 1.45,
+  maxRoughness: 1,
+  maxDepthDifference: 10,
+  blend: 0.9,
+  correction: 1,
+  correctionRadius: 1,
+  blur: 0.5,
+  blurKernel: 1,
+  blurSharpness: 10,
+  jitter: 0,
+  jitterRoughness: 0,
+  steps: 20,
+  refineSteps: 5,
+  missedRays: true,
+  useNormalMap: true,
+  useRoughnessMap: true,
+  resolutionScale: 1,
+  velocityResolutionScale: 1
+};
+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);}";
+var temporalResolve = "#define GLSLIFY 1\nuniform sampler2D inputTexture;uniform sampler2D accumulatedTexture;uniform sampler2D velocityTexture;uniform sampler2D lastVelocityTexture;uniform float blend;uniform float correction;uniform float exponent;uniform float samples;uniform vec2 invTexSize;uniform mat4 curInverseProjectionMatrix;uniform mat4 curCameraMatrixWorld;uniform mat4 prevInverseProjectionMatrix;uniform mat4 prevCameraMatrixWorld;varying vec2 vUv;\n#define MAX_NEIGHBOR_DEPTH_DIFFERENCE 0.001\n#define FLOAT_EPSILON 0.00001\n#define FLOAT_ONE_MINUS_EPSILON 0.99999\nvec3 transformexponent;vec3 undoColorTransformExponent;vec3 transformColor(vec3 color){if(exponent==1.0)return color;return pow(abs(color),transformexponent);}vec3 undoColorTransform(vec3 color){if(exponent==1.0)return color;return max(pow(abs(color),undoColorTransformExponent),vec3(0.0));}void main(){if(exponent!=1.0){transformexponent=vec3(1.0/exponent);undoColorTransformExponent=vec3(exponent);}vec4 inputTexel=textureLod(inputTexture,vUv,0.0);vec4 accumulatedTexel;vec3 inputColor=transformColor(inputTexel.rgb);vec3 accumulatedColor;float alpha=inputTexel.a;float velocityDisocclusion;bool didReproject=false;\n#ifdef boxBlur\nvec3 boxBlurredColor=inputTexel.rgb;\n#endif\nvec4 velocity=textureLod(velocityTexture,vUv,0.0);bool isMoving=alpha<1.0||dot(velocity.xy,velocity.xy)>0.0;if(isMoving){vec3 minNeighborColor=inputColor;vec3 maxNeighborColor=inputColor;vec3 col;vec2 neighborUv;vec2 reprojectedUv=vUv-velocity.xy;vec4 lastVelocity=textureLod(lastVelocityTexture,reprojectedUv,0.0);float depth=velocity.b;float closestDepth=depth;float lastClosestDepth=lastVelocity.b;float neighborDepth;float lastNeighborDepth;for(int x=-correctionRadius;x<=correctionRadius;x++){for(int y=-correctionRadius;y<=correctionRadius;y++){if(x!=0||y!=0){neighborUv=vUv+vec2(x,y)*invTexSize;vec4 neigborVelocity=textureLod(velocityTexture,neighborUv,0.0);neighborDepth=neigborVelocity.b;col=textureLod(inputTexture,neighborUv,0.0).xyz;int absX=abs(x);int absY=abs(y);\n#ifdef dilation\nif(absX==1&&absY==1){if(neighborDepth>closestDepth){velocity=neigborVelocity;closestDepth=neighborDepth;}vec4 lastNeighborVelocity=textureLod(velocityTexture,vUv+vec2(x,y)*invTexSize,0.0);lastNeighborDepth=lastNeighborVelocity.b;if(neighborDepth>closestDepth){lastVelocity=lastNeighborVelocity;lastClosestDepth=lastNeighborDepth;}}\n#endif\nif(abs(depth-neighborDepth)<MAX_NEIGHBOR_DEPTH_DIFFERENCE){\n#ifdef boxBlur\nif(absX<=2&&absY<=2)boxBlurredColor+=col;\n#endif\ncol=transformColor(col);minNeighborColor=min(col,minNeighborColor);maxNeighborColor=max(col,maxNeighborColor);}}}}float velocityLength=length(lastVelocity.xy-velocity.xy);velocityDisocclusion=(velocityLength-0.000005)*10.0;velocityDisocclusion*=velocityDisocclusion;reprojectedUv=vUv-velocity.xy;\n#ifdef boxBlur\nfloat pxRadius=correctionRadius>5 ? 121.0 : pow(float(correctionRadius*2+1),2.0);boxBlurredColor/=pxRadius;boxBlurredColor=transformColor(boxBlurredColor);\n#endif\nif(reprojectedUv.x>=0.0&&reprojectedUv.x<=1.0&&reprojectedUv.y>=0.0&&reprojectedUv.y<=1.0){accumulatedTexel=textureLod(accumulatedTexture,reprojectedUv,0.0);accumulatedColor=transformColor(accumulatedTexel.rgb);vec3 clampedColor=clamp(accumulatedColor,minNeighborColor,maxNeighborColor);accumulatedColor=mix(accumulatedColor,clampedColor,correction);didReproject=true;}else{\n#ifdef boxBlur\naccumulatedColor=boxBlurredColor;\n#else\naccumulatedColor=inputColor;\n#endif\n}if(velocity.r>FLOAT_ONE_MINUS_EPSILON&&velocity.g>FLOAT_ONE_MINUS_EPSILON){alpha=0.0;velocityDisocclusion=1.0;}}else{accumulatedColor=transformColor(textureLod(accumulatedTexture,vUv,0.0).rgb);}vec3 outputColor=inputColor;\n#include <custom_compose_shader>\ngl_FragColor=vec4(undoColorTransform(outputColor),alpha);}";
+class TemporalResolveMaterial extends ShaderMaterial {
+  constructor(customComposeShader) {
+    const fragmentShader2 = temporalResolve.replace("#include <custom_compose_shader>", customComposeShader);
+    super({
+      type: "TemporalResolveMaterial",
+      uniforms: {
+        inputTexture: new Uniform(null),
+        accumulatedTexture: new Uniform(null),
+        velocityTexture: new Uniform(null),
+        lastVelocityTexture: new Uniform(null),
+        samples: new Uniform(1),
+        blend: new Uniform(0.5),
+        correction: new Uniform(1),
+        exponent: new Uniform(1),
+        invTexSize: new Uniform(new Vector2())
+      },
+      defines: {
+        correctionRadius: 1
+      },
+      vertexShader,
+      fragmentShader: fragmentShader2
+    });
+  }
+}
+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 = texture2D( prevBoneTexture, vec2( dx * ( x + 0.5 ), y ) );
+          vec4 v2 = texture2D( prevBoneTexture, vec2( dx * ( x + 1.5 ), y ) );
+          vec4 v3 = texture2D( prevBoneTexture, vec2( dx * ( x + 2.5 ), y ) );
+          vec4 v4 = texture2D( prevBoneTexture, vec2( dx * ( x + 3.5 ), y ) );
+          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 = (
+  /* glsl */
+  `
+    vec3 transformed;
+
+    // Get the normal
+    ${ShaderChunk.skinbase_vertex}
+    ${ShaderChunk.beginnormal_vertex}
+    ${ShaderChunk.skinnormal_vertex}
+    ${ShaderChunk.defaultnormal_vertex}
+
+    // Get the current vertex position
+    transformed = vec3( position );
+    ${ShaderChunk.skinning_vertex}
+    newPosition = velocityMatrix * vec4( transformed, 1.0 );
+
+    // Get the previous vertex position
+    transformed = vec3( position );
+    ${ShaderChunk.skinbase_vertex.replace(/mat4 /g, "").replace(/getBoneMatrix/g, "getPrevBoneMatrix")}
+    ${ShaderChunk.skinning_vertex.replace(/vec4 /g, "")}
+    prevPosition = prevVelocityMatrix * vec4( transformed, 1.0 );
+
+    gl_Position = newPosition;
+`
+);
+class VelocityMaterial extends ShaderMaterial {
+  constructor() {
+    super({
+      uniforms: {
+        prevVelocityMatrix: {
+          value: new Matrix4()
+        },
+        velocityMatrix: {
+          value: new Matrix4()
+        },
+        prevBoneTexture: {
+          value: null
+        },
+        interpolateGeometry: {
+          value: 0
+        },
+        intensity: {
+          value: 1
+        },
+        boneTexture: {
+          value: null
+        },
+        alphaTest: {
+          value: 0
+        },
+        map: {
+          value: null
+        },
+        alphaMap: {
+          value: null
+        },
+        opacity: {
+          value: 1
+        }
+      },
+      vertexShader: (
+        /* glsl */
+        `
+                    #define MAX_BONES 1024
+
+                    ${ShaderChunk.skinning_pars_vertex}
+                    ${prev_skinning_pars_vertex}
+
+                    uniform mat4 velocityMatrix;
+                    uniform mat4 prevVelocityMatrix;
+                    uniform float interpolateGeometry;
+                    varying vec4 prevPosition;
+                    varying vec4 newPosition;
+          varying vec2 vHighPrecisionZW;
+
+                    void main() {
+
+                        ${velocity_vertex}
+
+            vHighPrecisionZW = gl_Position.zw;
+
+                    }`
+      ),
+      fragmentShader: (
+        /* glsl */
+        `
+                    uniform float intensity;
+                    varying vec4 prevPosition;
+                    varying vec4 newPosition;
+          varying vec2 vHighPrecisionZW;
+
+                    void main() {
+            #ifdef FULL_MOVEMENT
+            gl_FragColor = vec4( 1., 1., 1. - gl_FragCoord.z, 0. );
+            return;
+            #endif
+
+                        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, 1. - fragCoordZ, 0. );
+
+                    }`
+      )
+    });
+    this.isVelocityMaterial = true;
+  }
+}
+const backgroundColor = new Color(0);
+const updateProperties = ["visible", "wireframe", "side"];
+class VelocityPass extends Pass {
+  constructor(scene, camera) {
+    var _window, _window2;
+    super("VelocityPass");
+    this.cachedMaterials = /* @__PURE__ */ new WeakMap();
+    this.lastCameraTransform = {
+      position: new Vector3(),
+      quaternion: new Quaternion()
+    };
+    this.visibleMeshes = [];
+    this.renderedMeshesThisFrame = 0;
+    this.renderedMeshesLastFrame = 0;
+    this._scene = scene;
+    this._camera = camera;
+    this.renderTarget = new WebGLRenderTarget(
+      ((_window = window) == null ? void 0 : _window.innerWidth) || 1e3,
+      ((_window2 = window) == null ? void 0 : _window2.innerHeight) || 1e3,
+      {
+        type: HalfFloatType
+      }
+    );
+  }
+  setVelocityMaterialInScene() {
+    this.renderedMeshesThisFrame = 0;
+    this.visibleMeshes = getVisibleChildren(this._scene);
+    for (const c of this.visibleMeshes) {
+      var _c$skeleton2;
+      const originalMaterial = c.material;
+      let [cachedOriginalMaterial, velocityMaterial] = this.cachedMaterials.get(c) || [];
+      if (originalMaterial !== cachedOriginalMaterial) {
+        var _c$skeleton;
+        velocityMaterial = new VelocityMaterial();
+        velocityMaterial.lastMatrixWorld = new Matrix4();
+        c.material = velocityMaterial;
+        if ((_c$skeleton = c.skeleton) != null && _c$skeleton.boneTexture)
+          this.saveBoneTexture(c);
+        this.cachedMaterials.set(c, [originalMaterial, velocityMaterial]);
+      }
+      velocityMaterial.uniforms.velocityMatrix.value.multiplyMatrices(this._camera.projectionMatrix, c.modelViewMatrix);
+      if (c.userData.needsUpdatedReflections || originalMaterial.map instanceof VideoTexture) {
+        if (!("FULL_MOVEMENT" in velocityMaterial.defines))
+          velocityMaterial.needsUpdate = true;
+        velocityMaterial.defines.FULL_MOVEMENT = "";
+      } else {
+        if ("FULL_MOVEMENT" in velocityMaterial.defines) {
+          delete velocityMaterial.defines.FULL_MOVEMENT;
+          velocityMaterial.needsUpdate = true;
+        }
+      }
+      c.visible = this.cameraMovedThisFrame || !c.matrixWorld.equals(velocityMaterial.lastMatrixWorld) || c.skeleton || "FULL_MOVEMENT" in velocityMaterial.defines;
+      c.material = velocityMaterial;
+      if (!c.visible)
+        continue;
+      this.renderedMeshesThisFrame++;
+      for (const prop of updateProperties)
+        velocityMaterial[prop] = originalMaterial[prop];
+      if ((_c$skeleton2 = c.skeleton) != null && _c$skeleton2.boneTexture) {
+        velocityMaterial.defines.USE_SKINNING = "";
+        velocityMaterial.defines.BONE_TEXTURE = "";
+        velocityMaterial.uniforms.boneTexture.value = c.skeleton.boneTexture;
+      }
+    }
+  }
+  saveBoneTexture(object) {
+    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 {
+      var _boneTexture;
+      (_boneTexture = boneTexture) == null ? void 0 : _boneTexture.dispose();
+      const boneMatrices = object.skeleton.boneTexture.image.data.slice();
+      const size = object.skeleton.boneTexture.image.width;
+      boneTexture = new DataTexture(boneMatrices, size, size, RGBAFormat, FloatType);
+      object.material.uniforms.prevBoneTexture.value = boneTexture;
+      boneTexture.needsUpdate = true;
+    }
+  }
+  unsetVelocityMaterialInScene() {
+    for (const c of this.visibleMeshes) {
+      if (c.material.isVelocityMaterial) {
+        var _c$skeleton3;
+        c.visible = true;
+        c.material.lastMatrixWorld.copy(c.matrixWorld);
+        c.material.uniforms.prevVelocityMatrix.value.multiplyMatrices(this._camera.projectionMatrix, c.modelViewMatrix);
+        if ((_c$skeleton3 = c.skeleton) != null && _c$skeleton3.boneTexture)
+          this.saveBoneTexture(c);
+        c.material = this.cachedMaterials.get(c)[0];
+      }
+    }
+  }
+  setSize(width, height) {
+    this.renderTarget.setSize(width, height);
+  }
+  renderVelocity(renderer) {
+    renderer.setRenderTarget(this.renderTarget);
+    if (this.renderedMeshesThisFrame > 0) {
+      const { background } = this._scene;
+      this._scene.background = backgroundColor;
+      renderer.render(this._scene, this._camera);
+      this._scene.background = background;
+    } else {
+      renderer.clearColor();
+    }
+  }
+  checkCameraMoved() {
+    const moveDist = this.lastCameraTransform.position.distanceToSquared(this._camera.position);
+    const rotateDist = 8 * (1 - this.lastCameraTransform.quaternion.dot(this._camera.quaternion));
+    if (moveDist > 1e-6 || rotateDist > 1e-6) {
+      this.lastCameraTransform.position.copy(this._camera.position);
+      this.lastCameraTransform.quaternion.copy(this._camera.quaternion);
+      return true;
+    }
+    return false;
+  }
+  render(renderer) {
+    this.cameraMovedThisFrame = this.checkCameraMoved();
+    this.setVelocityMaterialInScene();
+    if (this.renderedMeshesThisFrame > 0 || this.renderedMeshesLastFrame > 0)
+      this.renderVelocity(renderer);
+    this.unsetVelocityMaterialInScene();
+    this.renderedMeshesLastFrame = this.renderedMeshesThisFrame;
+  }
+}
+const zeroVec2 = new Vector2();
+class TemporalResolvePass extends Pass {
+  constructor(scene, camera, customComposeShader, options = {}) {
+    super("TemporalResolvePass");
+    this.velocityPass = null;
+    this.velocityResolutionScale = 1;
+    this.samples = 1;
+    this.lastCameraTransform = {
+      position: new Vector3(),
+      quaternion: new Quaternion()
+    };
+    this._scene = scene;
+    this._camera = camera;
+    this.renderTarget = new WebGLRenderTarget(1, 1, {
+      minFilter: LinearFilter,
+      magFilter: LinearFilter,
+      type: HalfFloatType,
+      depthBuffer: false
+    });
+    this.velocityPass = new VelocityPass(scene, camera);
+    this.fullscreenMaterial = new TemporalResolveMaterial(customComposeShader);
+    this.fullscreenMaterial.defines.correctionRadius = options.correctionRadius || 1;
+    if (options.dilation)
+      this.fullscreenMaterial.defines.dilation = "";
+    if (options.boxBlur)
+      this.fullscreenMaterial.defines.boxBlur = "";
+    this.setupFramebuffers(1, 1);
+    this.checkCanUseSharedVelocityTexture();
+  }
+  dispose() {
+    if (this._scene.userData.velocityTexture === this.velocityPass.renderTarget.texture) {
+      delete this._scene.userData.velocityTexture;
+      delete this._scene.userData.lastVelocityTexture;
+    }
+    this.renderTarget.dispose();
+    this.accumulatedTexture.dispose();
+    this.fullscreenMaterial.dispose();
+    this.velocityPass.dispose();
+  }
+  setSize(width, height) {
+    this.renderTarget.setSize(width, height);
+    this.velocityPass.setSize(width * this.velocityResolutionScale, height * this.velocityResolutionScale);
+    this.velocityPass.renderTarget.texture.minFilter = this.velocityResolutionScale === 1 ? NearestFilter : LinearFilter;
+    this.velocityPass.renderTarget.texture.magFilter = this.velocityResolutionScale === 1 ? NearestFilter : LinearFilter;
+    this.velocityPass.renderTarget.texture.needsUpdate = true;
+    this.fullscreenMaterial.uniforms.invTexSize.value.set(1 / width, 1 / height);
+    this.setupFramebuffers(width, height);
+  }
+  setupFramebuffers(width, height) {
+    if (this.accumulatedTexture)
+      this.accumulatedTexture.dispose();
+    if (this.lastVelocityTexture)
+      this.lastVelocityTexture.dispose();
+    this.accumulatedTexture = new FramebufferTexture(width, height, RGBAFormat);
+    this.accumulatedTexture.minFilter = LinearFilter;
+    this.accumulatedTexture.magFilter = LinearFilter;
+    this.accumulatedTexture.type = HalfFloatType;
+    this.lastVelocityTexture = new FramebufferTexture(
+      width * this.velocityResolutionScale,
+      height * this.velocityResolutionScale,
+      RGBAFormat
+    );
+    this.lastVelocityTexture.minFilter = this.velocityResolutionScale === 1 ? NearestFilter : LinearFilter;
+    this.lastVelocityTexture.magFilter = this.velocityResolutionScale === 1 ? NearestFilter : LinearFilter;
+    this.lastVelocityTexture.type = HalfFloatType;
+    this.fullscreenMaterial.uniforms.accumulatedTexture.value = this.accumulatedTexture;
+    this.fullscreenMaterial.uniforms.lastVelocityTexture.value = this.lastVelocityTexture;
+    this.fullscreenMaterial.needsUpdate = true;
+  }
+  checkCanUseSharedVelocityTexture() {
+    const canUseSharedVelocityTexture = this._scene.userData.velocityTexture && this.velocityPass.renderTarget.texture !== this._scene.userData.velocityTexture;
+    if (canUseSharedVelocityTexture) {
+      if (this.velocityPass.renderTarget.texture === this.fullscreenMaterial.uniforms.velocityTexture.value) {
+        this.fullscreenMaterial.uniforms.lastVelocityTexture.value = this._scene.userData.lastVelocityTexture;
+        this.fullscreenMaterial.uniforms.velocityTexture.value = this._scene.userData.velocityTexture;
+        this.fullscreenMaterial.needsUpdate = true;
+      }
+    } else {
+      if (this.velocityPass.renderTarget.texture !== this.fullscreenMaterial.uniforms.velocityTexture.value) {
+        this.fullscreenMaterial.uniforms.velocityTexture.value = this.velocityPass.renderTarget.texture;
+        this.fullscreenMaterial.uniforms.lastVelocityTexture.value = this.lastVelocityTexture;
+        this.fullscreenMaterial.needsUpdate = true;
+        if (!this._scene.userData.velocityTexture) {
+          this._scene.userData.velocityTexture = this.velocityPass.renderTarget.texture;
+          this._scene.userData.lastVelocityTexture = this.lastVelocityTexture;
+        }
+      }
+    }
+    return this.velocityPass.renderTarget.texture !== this.fullscreenMaterial.uniforms.velocityTexture.value;
+  }
+  checkNeedsResample() {
+    const moveDist = this.lastCameraTransform.position.distanceToSquared(this._camera.position);
+    const rotateDist = 8 * (1 - this.lastCameraTransform.quaternion.dot(this._camera.quaternion));
+    if (moveDist > 1e-6 || rotateDist > 1e-6) {
+      this.samples = 1;
+      this.lastCameraTransform.position.copy(this._camera.position);
+      this.lastCameraTransform.quaternion.copy(this._camera.quaternion);
+    }
+  }
+  render(renderer) {
+    this.samples++;
+    this.checkNeedsResample();
+    this.fullscreenMaterial.uniforms.samples.value = this.samples;
+    renderer.setRenderTarget(this.renderTarget);
+    renderer.render(this.scene, this.camera);
+    renderer.copyFramebufferToTexture(zeroVec2, this.accumulatedTexture);
+    renderer.setRenderTarget(this.velocityPass.renderTarget);
+    renderer.copyFramebufferToTexture(zeroVec2, this.lastVelocityTexture);
+  }
+}
+const halton = function halton2(index, base) {
+  let fraction = 1;
+  let result = 0;
+  while (index > 0) {
+    fraction /= base;
+    result += fraction * (index % base);
+    index = ~~(index / base);
+  }
+  return result;
+};
+const generateHalton23Points = (count) => {
+  const data = [];
+  let i2 = 1;
+  const end = i2 + count;
+  for (; i2 < end; i2++) {
+    data.push([halton(i2, 2) - 0.5, halton(i2, 3) - 0.5]);
+  }
+  return data;
+};
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const worldposReplace = (
+  /* glsl */
+  `
+#if defined( USE_ENVMAP ) || defined(  ) || defined ( USE_SHADOWMAP )
+    vec4 worldPosition = modelMatrix * vec4( transformed, 1.0 );
+
+    #ifdef BOX_PROJECTED_ENV_MAP
+        vWorldPosition = worldPosition.xyz;
+    #endif
+#endif
+`
+);
+const boxProjectDefinitions = (
+  /* glsl */
+  `
+#ifdef BOX_PROJECTED_ENV_MAP
+    uniform vec3 envMapSize;
+    uniform vec3 envMapPosition;
+    varying vec3 vWorldPosition;
+
+    vec3 parallaxCorrectNormal( vec3 v, vec3 cubeSize, vec3 cubePos ) {
+        vec3 nDir = normalize( v );
+
+        vec3 rbmax = ( .5 * cubeSize + cubePos - vWorldPosition ) / nDir;
+        vec3 rbmin = ( -.5 * cubeSize + cubePos - vWorldPosition ) / nDir;
+
+        vec3 rbminmax;
+
+        rbminmax.x = ( nDir.x > 0. ) ? rbmax.x : rbmin.x;
+        rbminmax.y = ( nDir.y > 0. ) ? rbmax.y : rbmin.y;
+        rbminmax.z = ( nDir.z > 0. ) ? rbmax.z : rbmin.z;
+
+        float correction = min( min( rbminmax.x, rbminmax.y ), rbminmax.z );
+        vec3 boxIntersection = vWorldPosition + nDir * correction;
+
+        return boxIntersection - cubePos;
+    }
+#endif
+`
+);
+const getIBLIrradiance_patch = (
+  /* glsl */
+  `
+#ifdef BOX_PROJECTED_ENV_MAP
+    worldNormal = parallaxCorrectNormal( worldNormal, envMapSize, envMapPosition );
+#endif
+`
+);
+const getIBLRadiance_patch = (
+  /* glsl */
+  `
+#ifdef BOX_PROJECTED_ENV_MAP
+    reflectVec = parallaxCorrectNormal( reflectVec, envMapSize, envMapPosition );
+#endif
+`
+);
+function useBoxProjectedEnvMap(shader, envMapPosition, envMapSize) {
+  shader.defines.BOX_PROJECTED_ENV_MAP = "";
+  shader.uniforms.envMapPosition = {
+    value: envMapPosition
+  };
+  shader.uniforms.envMapSize = {
+    value: envMapSize
+  };
+  const line1 = new RegExp(
+    escapeRegExp("vec3 worldNormal = inverseTransformDirection ( normal , viewMatrix ) ;").replaceAll(" ", "\\s*"),
+    "g"
+  );
+  const line2 = new RegExp(
+    escapeRegExp("reflectVec = inverseTransformDirection ( reflectVec , viewMatrix ) ;").replaceAll(" ", "\\s*"),
+    "g"
+  );
+  shader.vertexShader = "varying vec3 vWorldPosition;\n" + shader.vertexShader.replace("#include <worldpos_vertex>", worldposReplace);
+  shader.fragmentShader = boxProjectDefinitions + "\n" + shader.fragmentShader.replace("#include <envmap_physical_pars_fragment>", ShaderChunk.envmap_physical_pars_fragment).replace(
+    line1,
+    `vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
+                ${getIBLIrradiance_patch}`
+  ).replace(
+    line2,
+    `reflectVec = inverseTransformDirection( reflectVec, viewMatrix );
+                ${getIBLRadiance_patch}`
+  );
+}
+const finalFragmentShader = finalSSRShader.replace("#include <helperFunctions>", helperFunctions).replace("#include <boxBlur>", boxBlur);
+const noResetSamplesProperties = ["blur", "blurSharpness", "blurKernel"];
+const defaultCubeRenderTarget = new WebGLCubeRenderTarget(1);
+let pmremGenerator;
+class SSREffect extends Effect {
+  /**
+   * @param {THREE.Scene} scene The scene of the SSR effect
+   * @param {THREE.Camera} camera The camera with which SSR is being rendered
+   * @param {SSROptions} [options] The optional options for the SSR effect
+   */
+  constructor(scene, camera, options = defaultSSROptions) {
+    super("SSREffect", finalFragmentShader, {
+      type: "FinalSSRMaterial",
+      uniforms: /* @__PURE__ */ new Map([
+        ["reflectionsTexture", new Uniform(null)],
+        ["blur", new Uniform(0)],
+        ["blurSharpness", new Uniform(0)],
+        ["blurKernel", new Uniform(0)]
+      ]),
+      defines: /* @__PURE__ */ new Map([["RENDER_MODE", "0"]])
+    });
+    this.haltonSequence = generateHalton23Points(1024);
+    this.haltonIndex = 0;
+    this.selection = new Selection$1();
+    this.lastSize = void 0;
+    this.cubeCamera = new CubeCamera(1e-3, 1e3, defaultCubeRenderTarget);
+    this.usingBoxProjectedEnvMap = false;
+    this._scene = scene;
+    this._camera = camera;
+    const trOptions = {
+      boxBlur: true,
+      dilation: true
+    };
+    options = { ...defaultSSROptions, ...options, ...trOptions };
+    this.temporalResolvePass = new TemporalResolvePass(scene, camera, trCompose, options);
+    this.uniforms.get("reflectionsTexture").value = this.temporalResolvePass.renderTarget.texture;
+    this.reflectionsPass = new ReflectionsPass(this, options);
+    this.temporalResolvePass.fullscreenMaterial.uniforms.inputTexture.value = this.reflectionsPass.renderTarget.texture;
+    this.lastSize = {
+      width: options.width,
+      height: options.height,
+      resolutionScale: options.resolutionScale,
+      velocityResolutionScale: options.velocityResolutionScale
+    };
+    this.setSize(options.width, options.height);
+    this.makeOptionsReactive(options);
+  }
+  makeOptionsReactive(options) {
+    let needsUpdate = false;
+    const reflectionPassFullscreenMaterialUniforms = this.reflectionsPass.fullscreenMaterial.uniforms;
+    const reflectionPassFullscreenMaterialUniformsKeys = Object.keys(reflectionPassFullscreenMaterialUniforms);
+    for (const key of Object.keys(options)) {
+      Object.defineProperty(this, key, {
+        get() {
+          return options[key];
+        },
+        set(value) {
+          if (options[key] === value && needsUpdate)
+            return;
+          options[key] = value;
+          if (!noResetSamplesProperties.includes(key)) {
+            this.setSize(this.lastSize.width, this.lastSize.height, true);
+          }
+          switch (key) {
+            case "resolutionScale":
+              this.setSize(this.lastSize.width, this.lastSize.height);
+              break;
+            case "velocityResolutionScale":
+              this.temporalResolvePass.velocityResolutionScale = value;
+              this.setSize(this.lastSize.width, this.lastSize.height, true);
+              break;
+            case "blur":
+              this.uniforms.get("blur").value = value;
+              break;
+            case "blurSharpness":
+              this.uniforms.get("blurSharpness").value = value;
+              break;
+            case "blurKernel":
+              this.uniforms.get("blurKernel").value = value;
+              break;
+            case "steps":
+              this.reflectionsPass.fullscreenMaterial.defines.steps = parseInt(value);
+              this.reflectionsPass.fullscreenMaterial.needsUpdate = needsUpdate;
+              break;
+            case "refineSteps":
+              this.reflectionsPass.fullscreenMaterial.defines.refineSteps = parseInt(value);
+              this.reflectionsPass.fullscreenMaterial.needsUpdate = needsUpdate;
+              break;
+            case "missedRays":
+              if (value) {
+                this.reflectionsPass.fullscreenMaterial.defines.missedRays = "";
+              } else {
+                delete this.reflectionsPass.fullscreenMaterial.defines.missedRays;
+              }
+              this.reflectionsPass.fullscreenMaterial.needsUpdate = needsUpdate;
+              break;
+            case "correctionRadius":
+              this.temporalResolvePass.fullscreenMaterial.defines.correctionRadius = Math.round(value);
+              this.temporalResolvePass.fullscreenMaterial.needsUpdate = needsUpdate;
+              break;
+            case "blend":
+              this.temporalResolvePass.fullscreenMaterial.uniforms.blend.value = value;
+              break;
+            case "correction":
+              this.temporalResolvePass.fullscreenMaterial.uniforms.correction.value = value;
+              break;
+            case "exponent":
+              this.temporalResolvePass.fullscreenMaterial.uniforms.exponent.value = value;
+              break;
+            case "distance":
+              reflectionPassFullscreenMaterialUniforms.rayDistance.value = value;
+            default:
+              if (reflectionPassFullscreenMaterialUniformsKeys.includes(key)) {
+                reflectionPassFullscreenMaterialUniforms[key].value = value;
+              }
+          }
+        }
+      });
+      this[key] = options[key];
+    }
+    needsUpdate = true;
+  }
+  setSize(width, height, force = false) {
+    if (!force && width === this.lastSize.width && height === this.lastSize.height && this.resolutionScale === this.lastSize.resolutionScale && this.velocityResolutionScale === this.lastSize.velocityResolutionScale)
+      return;
+    this.temporalResolvePass.setSize(width, height);
+    this.reflectionsPass.setSize(width, height);
+    this.lastSize = {
+      width,
+      height,
+      resolutionScale: this.resolutionScale,
+      velocityResolutionScale: this.velocityResolutionScale
+    };
+  }
+  generateBoxProjectedEnvMapFallback(renderer, position = new Vector3(), size = new Vector3(), envMapSize = 512) {
+    this.cubeCamera.renderTarget.dispose();
+    this.cubeCamera.renderTarget = new WebGLCubeRenderTarget(envMapSize);
+    this.cubeCamera.position.copy(position);
+    this.cubeCamera.updateMatrixWorld();
+    this.cubeCamera.update(renderer, this._scene);
+    if (!pmremGenerator) {
+      pmremGenerator = new PMREMGenerator(renderer);
+      pmremGenerator.compileCubemapShader();
+    }
+    const envMap = pmremGenerator.fromCubemap(this.cubeCamera.renderTarget.texture).texture;
+    envMap.minFilter = LinearFilter;
+    envMap.magFilter = LinearFilter;
+    const reflectionsMaterial = this.reflectionsPass.fullscreenMaterial;
+    useBoxProjectedEnvMap(reflectionsMaterial, position, size);
+    reflectionsMaterial.fragmentShader = reflectionsMaterial.fragmentShader.replace("vec3 worldPos", "worldPos").replace("varying vec3 vWorldPosition;", "vec3 worldPos;");
+    reflectionsMaterial.uniforms.envMapPosition.value.copy(position);
+    reflectionsMaterial.uniforms.envMapSize.value.copy(size);
+    setupEnvMap(reflectionsMaterial, envMap, envMapSize);
+    this.usingBoxProjectedEnvMap = true;
+    return envMap;
+  }
+  setIBLRadiance(iblRadiance, renderer) {
+    this._scene.traverse((c) => {
+      if (c.material) {
+        var _renderer$properties$;
+        const uniforms = (_renderer$properties$ = renderer.properties.get(c.material)) == null ? void 0 : _renderer$properties$.uniforms;
+        if (uniforms && "disableIBLRadiance" in uniforms) {
+          uniforms.disableIBLRadiance.value = iblRadiance;
+        }
+      }
+    });
+  }
+  deleteBoxProjectedEnvMapFallback() {
+    const reflectionsMaterial = this.reflectionsPass.fullscreenMaterial;
+    reflectionsMaterial.uniforms.envMap.value = null;
+    reflectionsMaterial.fragmentShader = reflectionsMaterial.fragmentShader.replace("worldPos = ", "vec3 worldPos = ");
+    delete reflectionsMaterial.defines.BOX_PROJECTED_ENV_MAP;
+    reflectionsMaterial.needsUpdate = true;
+    this.usingBoxProjectedEnvMap = false;
+  }
+  dispose() {
+    super.dispose();
+    this.reflectionsPass.dispose();
+    this.temporalResolvePass.dispose();
+  }
+  update(renderer, inputBuffer) {
+    if (!this.usingBoxProjectedEnvMap && this._scene.environment) {
+      const reflectionsMaterial = this.reflectionsPass.fullscreenMaterial;
+      let envMap = null;
+      this._scene.traverse((c) => {
+        if (!envMap && c.material && !c.material.envMap) {
+          const properties = renderer.properties.get(c.material);
+          if ("envMap" in properties && properties.envMap instanceof Texture$1)
+            envMap = properties.envMap;
+        }
+      });
+      if (envMap) {
+        const envMapCubeUVHeight = this._scene.environment.image.height;
+        setupEnvMap(reflectionsMaterial, envMap, envMapCubeUVHeight);
+      }
+    }
+    this.haltonIndex = (this.haltonIndex + 1) % this.haltonSequence.length;
+    const [x, y] = this.haltonSequence[this.haltonIndex];
+    const { width, height } = this.lastSize;
+    this.temporalResolvePass.velocityPass.render(renderer);
+    if (this._camera.setViewOffset)
+      this._camera.setViewOffset(width, height, x, y, width, height);
+    this.reflectionsPass.render(renderer, inputBuffer);
+    this.temporalResolvePass.render(renderer);
+    this._camera.clearViewOffset();
+  }
+  static patchDirectEnvIntensity(envMapIntensity = 0) {
+    if (envMapIntensity === 0) {
+      ShaderChunk.envmap_physical_pars_fragment = ShaderChunk.envmap_physical_pars_fragment.replace(
+        "vec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {",
+        "vec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) { return vec3(0.0);"
+      );
+    } else {
+      ShaderChunk.envmap_physical_pars_fragment = ShaderChunk.envmap_physical_pars_fragment.replace(
+        "vec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );",
+        "vec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness ) * " + envMapIntensity.toFixed(5) + ";"
+      );
+    }
+  }
+}
 const SSR = forwardRef(function SSR2({ ENABLE_BLUR = true, USE_MRT = true, ...props }, ref) {
   const { invalidate } = useThree();
   const { scene, camera } = useContext(EffectComposerContext);
@@ -2289,6 +3574,8 @@ export {
   Grid,
   HueSaturation,
   LUT,
+  LensFlare,
+  LensFlareEffect,
   N8AO,
   Noise,
   Outline,