@takram/three-geospatial-effects 0.0.1-alpha.4 → 0.0.1-alpha.6

package/build/shared.js

@@ -1,19 +1,16 @@
-var _ = Object.defineProperty;
-var E = (o, e, t) => e in o ? _(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
-var a = (o, e, t) => E(o, typeof e != "symbol" ? e + "" : e, t);
-import { BlendFunction as f, Effect as h, EffectAttribute as p, RenderPass as y, Resolution as d, ShaderPass as g, MipmapBlurPass as z, KawaseBlurPass as F, KernelSize as M } from "postprocessing";
-import { Uniform as i, ShaderLib as c, HalfFloatType as m, ShaderMaterial as U, Vector2 as T, NoBlending as S, WebGLRenderTarget as x, Matrix4 as w } from "three";
-import { depthShader as b, packingShader as B, transformShader as P } from "@takram/three-geospatial";
-var A = `uniform float near;
+var D = Object.defineProperty;
+var y = (r, e, t) => e in r ? D(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var u = (r, e, t) => y(r, typeof e != "symbol" ? e + "" : e, t);
+import { BlendFunction as f, Effect as h, EffectAttribute as p, RenderPass as M, Resolution as d, ShaderPass as g, MipmapBlurPass as P, KawaseBlurPass as A, KernelSize as z } from "postprocessing";
+import { Uniform as s, ShaderLib as c, HalfFloatType as m, ShaderMaterial as U, NoBlending as T, Vector2 as S, WebGLRenderTarget as w, Matrix4 as x } from "three";
+import { resolveIncludes as b } from "@takram/three-geospatial";
+import { depth as B, turbo as F, packing as C, transform as O } from "@takram/three-geospatial/shaders";
+const N = `#include "core/depth"
+#include "core/turbo"
+
+uniform float near;
 uniform float far;
 
-vec3 turbo(const float x) {
-  float r = 0.1357 + x * (4.5974 - x * (42.3277 - x * (130.5887 - x * (150.5666 - x * 58.1375))));
-  float g = 0.0914 + x * (2.1856 + x * (4.8052 - x * (14.0195 - x * (4.2109 + x * 2.7747))));
-  float b = 0.1067 + x * (12.5925 - x * (60.1097 - x * (109.0745 - x * (88.5066 - x * 26.8183))));
-  return vec3(r, g, b);
-}
-
 void mainImage(const vec4 inputColor, const vec2 uv, out vec4 outputColor) {
   float depth = readDepth(uv);
   depth = reverseLogDepth(depth, cameraNear, cameraFar);
@@ -21,40 +18,40 @@ void mainImage(const vec4 inputColor, const vec2 uv, out vec4 outputColor) {
 
   #ifdef USE_TURBO
   vec3 color = turbo(1.0 - depth);
-  #else
+  #else // USE_TURBO
   vec3 color = vec3(depth);
-  #endif 
+  #endif // USE_TURBO
 
   outputColor = vec4(color, inputColor.a);
-}`;
-const L = {
+}
+`, L = {
   blendFunction: f.SRC,
   useTurbo: !1,
   near: 1,
   far: 1e3
 };
-class re extends h {
+class se extends h {
   constructor(e) {
-    const { blendFunction: t, useTurbo: r, near: n, far: s } = {
+    const { blendFunction: t, useTurbo: n, near: o, far: i } = {
       ...L,
       ...e
     };
     super(
       "DepthEffect",
-      /* glsl */
-      `
-        ${b}
-        ${A}
-      `,
+      b(N, {
+        core: { depth: B, turbo: F }
+      }),
       {
         blendFunction: t,
         attributes: p.DEPTH,
-        uniforms: /* @__PURE__ */ new Map([
-          ["near", new i(n)],
-          ["far", new i(s)]
-        ])
+        uniforms: new Map(
+          Object.entries({
+            near: new s(o),
+            far: new s(i)
+          })
+        )
       }
-    ), this.useTurbo = r;
+    ), this.useTurbo = n;
   }
   get useTurbo() {
     return this.defines.has("USE_TURBO");
@@ -75,30 +72,30 @@ class re extends h {
     this.uniforms.get("far").value = e;
   }
 }
-var N = `#define DITHERING
+const G = `#define DITHERING
 
 #include <dithering_pars_fragment>
 
 void mainImage(const vec4 inputColor, const vec2 uv, out vec4 outputColor) {
-  outputColor = vec4(dithering(inputColor.rgb), inputColor.a);
-}`;
-const O = {
+  outputColor = vec4(saturate(dithering(inputColor.rgb)), inputColor.a);
+}
+`, j = {
   blendFunction: f.NORMAL
 };
-class oe extends h {
+class ae extends h {
   constructor(e) {
     const { blendFunction: t } = {
-      ...O,
+      ...j,
       ...e
     };
-    super("DitheringEffect", N, {
+    super("DitheringEffect", G, {
       blendFunction: t
     });
   }
 }
 const R = Symbol("SETUP");
-function G(o) {
-  const e = o.vertexShader.replace(
+function H(r) {
+  const e = r.vertexShader.replace(
     /* glsl */
     "#include <fog_pars_vertex>",
     /* glsl */
@@ -128,13 +125,13 @@ function G(o) {
         vViewPosition = - mvPosition.xyz;
       `
   );
-  o.vertexShader = /* glsl */
+  r.vertexShader = /* glsl */
   `
     #undef FLAT_SHADED
     varying vec3 vViewPosition;
     ${e}
   `;
-  const t = o.fragmentShader.replace(
+  const t = r.fragmentShader.replace(
     /#ifndef FLAT_SHADED\s+varying vec3 vNormal;\s+#endif/m,
     /* glsl */
     "#include <normal_pars_fragment>"
@@ -156,17 +153,17 @@ function G(o) {
         #include <normal_fragment_maps>
       `
   );
-  return o.fragmentShader = /* glsl */
+  return r.fragmentShader = /* glsl */
   `
     #undef FLAT_SHADED
     varying vec3 vViewPosition;
     ${t}
-  `, o;
+  `, r;
 }
-function v(o, { type: e } = {}) {
-  if (o[R] === !0)
-    return o;
-  e === "basic" && G(o);
+function v(r, { type: e } = {}) {
+  if (r[R] === !0)
+    return r;
+  e === "basic" && H(r);
   const t = e === "physical" ? (
     /* glsl */
     `
@@ -186,16 +183,16 @@ function v(o, { type: e } = {}) {
           );
         `
   );
-  return o.fragmentShader = /* glsl */
+  return r.fragmentShader = /* glsl */
   `
     layout(location = 1) out vec4 outputBuffer1;
 
-    #ifndef USE_ENVMAP
+    #if !defined(USE_ENVMAP)
       uniform float reflectivity;
-    #endif
+    #endif // !defined(USE_ENVMAP)
 
-    ${B}
-    ${o.fragmentShader.replace(
+    ${C}
+    ${r.fragmentShader.replace(
     /}\s*$/m,
     // Assume the last curly brace is of main()
     /* glsl */
@@ -204,25 +201,25 @@ function v(o, { type: e } = {}) {
         }
       `
   )}
-  `, o[R] = !0, o;
+  `, r[R] = !0, r;
 }
-function H() {
+function I() {
   v(c.lambert), v(c.phong), v(c.basic, { type: "basic" }), v(c.standard, { type: "physical" }), v(c.physical, { type: "physical" });
 }
-class ie extends y {
-  constructor(t, r, n, s) {
-    super(r, n, s);
-    a(this, "geometryTexture");
-    this.geometryTexture = t.texture.clone(), this.geometryTexture.isRenderTargetTexture = !0, this.geometryTexture.type = m, H();
+class ue extends M {
+  constructor(t, n, o, i) {
+    super(n, o, i);
+    u(this, "geometryTexture");
+    this.geometryTexture = t.texture.clone(), this.geometryTexture.isRenderTargetTexture = !0, this.geometryTexture.type = m, I();
   }
-  render(t, r, n, s, u) {
-    r != null && (r.textures[1] = this.geometryTexture), super.render(t, r, null), r != null && (r.textures.length = 1);
+  render(t, n, o, i, a) {
+    n != null && (n.textures[1] = this.geometryTexture), super.render(t, n, null), n != null && (n.textures.length = 1);
   }
-  setSize(t, r) {
-    this.geometryTexture.image.width = t, this.geometryTexture.image.height = r;
+  setSize(t, n) {
+    this.geometryTexture.image.width = t, this.geometryTexture.image.height = n;
   }
 }
-var j = `#include <common>
+const V = `#include <common>
 
 uniform sampler2D inputBuffer;
 
@@ -247,8 +244,9 @@ float clampToBorder(const vec2 uv) {
   return float(uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0);
 }
 
+// Reference: https://learnopengl.com/Guest-Articles/2022/Phys.-Based-Bloom
 void main() {
-  vec3 color = 0.125 * texture2D(inputBuffer, vec2(vRowUv5)).rgb;
+  vec3 color = 0.125 * texture(inputBuffer, vec2(vRowUv5)).rgb;
   vec4 weight =
     0.03125 *
     vec4(
@@ -257,10 +255,10 @@ void main() {
       clampToBorder(vRowUv7),
       clampToBorder(vRowUv9)
     );
-  color += weight.x * texture2D(inputBuffer, vec2(vRowUv1)).rgb;
-  color += weight.y * texture2D(inputBuffer, vec2(vRowUv3)).rgb;
-  color += weight.z * texture2D(inputBuffer, vec2(vRowUv7)).rgb;
-  color += weight.w * texture2D(inputBuffer, vec2(vRowUv9)).rgb;
+  color += weight.x * texture(inputBuffer, vec2(vRowUv1)).rgb;
+  color += weight.y * texture(inputBuffer, vec2(vRowUv3)).rgb;
+  color += weight.z * texture(inputBuffer, vec2(vRowUv7)).rgb;
+  color += weight.w * texture(inputBuffer, vec2(vRowUv9)).rgb;
 
   weight =
     0.0625 *
@@ -270,10 +268,10 @@ void main() {
       clampToBorder(vRowUv6),
       clampToBorder(vRowUv8)
     );
-  color += weight.x * texture2D(inputBuffer, vec2(vRowUv2)).rgb;
-  color += weight.y * texture2D(inputBuffer, vec2(vRowUv4)).rgb;
-  color += weight.z * texture2D(inputBuffer, vec2(vRowUv6)).rgb;
-  color += weight.w * texture2D(inputBuffer, vec2(vRowUv8)).rgb;
+  color += weight.x * texture(inputBuffer, vec2(vRowUv2)).rgb;
+  color += weight.y * texture(inputBuffer, vec2(vRowUv4)).rgb;
+  color += weight.z * texture(inputBuffer, vec2(vRowUv6)).rgb;
+  color += weight.w * texture(inputBuffer, vec2(vRowUv8)).rgb;
 
   weight =
     0.125 *
@@ -283,24 +281,23 @@ void main() {
       clampToBorder(vRowUv6),
       clampToBorder(vRowUv8)
     );
-  color += weight.x * texture2D(inputBuffer, vec2(vCenterUv1)).rgb;
-  color += weight.y * texture2D(inputBuffer, vec2(vCenterUv2)).rgb;
-  color += weight.z * texture2D(inputBuffer, vec2(vCenterUv3)).rgb;
-  color += weight.w * texture2D(inputBuffer, vec2(vCenterUv4)).rgb;
+  color += weight.x * texture(inputBuffer, vec2(vCenterUv1)).rgb;
+  color += weight.y * texture(inputBuffer, vec2(vCenterUv2)).rgb;
+  color += weight.z * texture(inputBuffer, vec2(vCenterUv3)).rgb;
+  color += weight.w * texture(inputBuffer, vec2(vCenterUv4)).rgb;
 
-  
-  
+  // WORKAROUND: Avoid screen flashes if the input buffer contains NaN texels.
+  // See: https://github.com/takram-design-engineering/three-geospatial/issues/7
   if (any(isnan(color))) {
     gl_FragColor = vec4(vec3(0.0), 1.0);
     return;
   }
 
   float l = luminance(color);
-  float scale = saturate(
-    smoothstep(thresholdLevel, thresholdLevel + thresholdRange, l)
-  );
+  float scale = saturate(smoothstep(thresholdLevel, thresholdLevel + thresholdRange, l));
   gl_FragColor = vec4(color * scale, 1.0);
-}`, $ = `uniform vec2 texelSize;
+}
+`, k = `uniform vec2 texelSize;
 
 out vec2 vCenterUv1;
 out vec2 vCenterUv2;
@@ -333,37 +330,38 @@ void main() {
   vRowUv9 = uv + texelSize * vec2(2.0, -2.0);
 
   gl_Position = vec4(position.xy, 1.0, 1.0);
-}`;
-const I = {
+}
+`, $ = {
   thresholdLevel: 10,
   thresholdRange: 1
 };
-class V extends U {
+class W extends U {
   constructor(e) {
     const {
       inputBuffer: t = null,
-      thresholdLevel: r,
-      thresholdRange: n,
-      ...s
+      thresholdLevel: n,
+      thresholdRange: o,
+      ...i
     } = {
-      ...I,
+      ...$,
       ...e
     };
     super({
       name: "DownsampleThresholdMaterial",
-      fragmentShader: j,
-      vertexShader: $,
-      uniforms: {
-        inputBuffer: new i(t),
-        texelSize: new i(new T()),
-        thresholdLevel: new i(r),
-        thresholdRange: new i(n)
-      },
-      blending: S,
+      fragmentShader: V,
+      vertexShader: k,
+      blending: T,
       toneMapped: !1,
       depthWrite: !1,
       depthTest: !1,
-      ...s
+      ...i,
+      uniforms: {
+        inputBuffer: new s(t),
+        texelSize: new s(new S()),
+        thresholdLevel: new s(n),
+        thresholdRange: new s(o),
+        ...i.uniforms
+      }
     });
   }
   setSize(e, t) {
@@ -388,7 +386,7 @@ class V extends U {
     this.uniforms.thresholdRange.value = e;
   }
 }
-var k = `#include <common>
+const K = `#include <common>
 
 #define SQRT_2 (0.7071067811865476)
 
@@ -404,9 +402,9 @@ in vec2 vAspectRatio;
 
 vec3 sampleGhost(const vec2 direction, const vec3 color, const float offset) {
   vec2 suv = clamp(1.0 - vUv + direction * offset, 0.0, 1.0);
-  vec3 result = texture2D(inputBuffer, suv).rgb * color;
+  vec3 result = texture(inputBuffer, suv).rgb * color;
 
-  
+  // Falloff at the perimeter.
   float d = clamp(length(0.5 - suv) / (0.5 * SQRT_2), 0.0, 1.0);
   result *= pow(1.0 - d, 3.0);
   return result;
@@ -427,6 +425,7 @@ vec4 sampleGhosts(float amount) {
   return vec4(color * amount, 1.0);
 }
 
+// Reference: https://john-chapman.github.io/2017/11/05/pseudo-lens-flare.html
 float cubicRingMask(const float x, const float radius, const float thickness) {
   float v = min(abs(x - radius) / thickness, 1.0);
   return 1.0 - v * v * (3.0 - 2.0 * v);
@@ -437,12 +436,12 @@ vec3 sampleHalo(const float radius) {
   vec3 offset = vec3(texelSize.x * chromaticAberration) * vec3(-1.0, 0.0, 1.0);
   vec2 suv = fract(1.0 - vUv + direction * radius);
   vec3 result = vec3(
-    texture2D(inputBuffer, suv + direction * offset.r).r,
-    texture2D(inputBuffer, suv + direction * offset.g).g,
-    texture2D(inputBuffer, suv + direction * offset.b).b
+    texture(inputBuffer, suv + direction * offset.r).r,
+    texture(inputBuffer, suv + direction * offset.g).g,
+    texture(inputBuffer, suv + direction * offset.b).b
   );
 
-  
+  // Falloff at the center and perimeter.
   vec2 wuv = (vUv - vec2(0.5, 0.0)) / vAspectRatio + vec2(0.5, 0.0);
   float d = saturate(distance(wuv, vec2(0.5)));
   result *= cubicRingMask(d, 0.45, 0.25);
@@ -458,7 +457,9 @@ vec4 sampleHalos(const float amount) {
 void main() {
   gl_FragColor += sampleGhosts(ghostAmount);
   gl_FragColor += sampleHalos(haloAmount);
-}`, W = `uniform vec2 texelSize;
+}
+
+`, Z = `uniform vec2 texelSize;
 
 out vec2 vUv;
 out vec2 vAspectRatio;
@@ -467,43 +468,44 @@ void main() {
   vUv = position.xy * 0.5 + 0.5;
   vAspectRatio = vec2(texelSize.x / texelSize.y, 1.0);
   gl_Position = vec4(position.xy, 1.0, 1.0);
-}`;
-const K = {
+}
+`, Q = {
   ghostAmount: 1e-3,
   haloAmount: 1e-3,
   chromaticAberration: 10
 };
-class Z extends U {
+class X extends U {
   constructor(e) {
     const {
       inputBuffer: t = null,
-      ghostAmount: r,
-      haloAmount: n,
-      chromaticAberration: s
+      ghostAmount: n,
+      haloAmount: o,
+      chromaticAberration: i,
+      ...a
     } = {
-      ...K,
+      ...Q,
       ...e
     };
     super({
       name: "LensFlareFeaturesMaterial",
-      fragmentShader: k,
-      vertexShader: W,
-      uniforms: {
-        inputBuffer: new i(t),
-        texelSize: new i(new T()),
-        ghostAmount: new i(r),
-        haloAmount: new i(n),
-        chromaticAberration: new i(s)
-      },
-      blending: S,
+      fragmentShader: K,
+      vertexShader: Z,
+      blending: T,
       toneMapped: !1,
       depthWrite: !1,
-      depthTest: !1
+      depthTest: !1,
+      uniforms: {
+        inputBuffer: new s(t),
+        texelSize: new s(new S()),
+        ghostAmount: new s(n),
+        haloAmount: new s(o),
+        chromaticAberration: new s(i),
+        ...a.uniforms
+      }
     });
   }
   setSize(e, t) {
-    const r = this.uniforms.texelSize;
-    r.value.x = 1 / e, r.value.y = 1 / t;
+    this.uniforms.texelSize.value.set(1 / e, 1 / t);
   }
   get inputBuffer() {
     return this.uniforms.inputBuffer.value;
@@ -530,89 +532,90 @@ class Z extends U {
     this.uniforms.chromaticAberration.value = e;
   }
 }
-var Q = `uniform sampler2D bloomBuffer;
+const Y = `uniform sampler2D bloomBuffer;
 uniform sampler2D featuresBuffer;
 uniform float intensity;
 
 void mainImage(const vec4 inputColor, const vec2 uv, out vec4 outputColor) {
-  vec3 bloom = texture2D(bloomBuffer, uv).rgb;
-  vec3 features = texture2D(featuresBuffer, uv).rgb;
-  outputColor = vec4(
-    inputColor.rgb + (bloom + features) * intensity,
-    inputColor.a
-  );
-}`;
-const X = {
+  vec3 bloom = texture(bloomBuffer, uv).rgb;
+  vec3 features = texture(featuresBuffer, uv).rgb;
+  outputColor = vec4(inputColor.rgb + (bloom + features) * intensity, inputColor.a);
+}
+`, q = {
   blendFunction: f.NORMAL,
   resolutionScale: 0.5,
   width: d.AUTO_SIZE,
   height: d.AUTO_SIZE,
   intensity: 5e-3
 };
-class se extends h {
+class le extends h {
   constructor(t) {
     const {
-      blendFunction: r,
-      resolutionScale: n,
-      width: s,
-      height: u,
-      resolutionX: l = s,
-      resolutionY: D = u,
-      intensity: C
+      blendFunction: n,
+      resolutionScale: o,
+      width: i,
+      height: a,
+      resolutionX: l = i,
+      resolutionY: E = a,
+      intensity: _
     } = {
-      ...X,
+      ...q,
       ...t
     };
-    super("LensFlareEffect", Q, {
-      blendFunction: r,
+    super("LensFlareEffect", Y, {
+      blendFunction: n,
       attributes: p.CONVOLUTION,
-      uniforms: /* @__PURE__ */ new Map([
-        ["bloomBuffer", new i(null)],
-        ["featuresBuffer", new i(null)],
-        ["intensity", new i(1)]
-      ])
+      uniforms: new Map(
+        Object.entries({
+          bloomBuffer: new s(null),
+          featuresBuffer: new s(null),
+          intensity: new s(1)
+        })
+      )
     });
-    a(this, "resolution");
-    a(this, "renderTarget1");
-    a(this, "renderTarget2");
-    a(this, "thresholdMaterial");
-    a(this, "thresholdPass");
-    a(this, "blurPass");
-    a(this, "preBlurPass");
-    a(this, "featuresMaterial");
-    a(this, "featuresPass");
-    a(this, "onResolutionChange", () => {
+    u(this, "resolution");
+    u(this, "renderTarget1");
+    u(this, "renderTarget2");
+    u(this, "thresholdMaterial");
+    u(this, "thresholdPass");
+    u(this, "blurPass");
+    u(this, "preBlurPass");
+    u(this, "featuresMaterial");
+    u(this, "featuresPass");
+    u(this, "onResolutionChange", () => {
       this.setSize(this.resolution.baseWidth, this.resolution.baseHeight);
     });
-    this.renderTarget1 = new x(1, 1, {
+    this.renderTarget1 = new w(1, 1, {
       depthBuffer: !1,
       stencilBuffer: !1,
       type: m
-    }), this.renderTarget1.texture.name = "LensFlare.Target1", this.renderTarget2 = new x(1, 1, {
+    }), this.renderTarget1.texture.name = "LensFlare.Target1", this.renderTarget2 = new w(1, 1, {
       depthBuffer: !1,
       stencilBuffer: !1,
       type: m
-    }), this.renderTarget2.texture.name = "LensFlare.Target2", this.thresholdMaterial = new V(), this.thresholdPass = new g(this.thresholdMaterial), this.blurPass = new z(), this.blurPass.levels = 8, this.preBlurPass = new F({
-      kernelSize: M.SMALL
-    }), this.featuresMaterial = new Z(), this.featuresPass = new g(this.featuresMaterial), this.uniforms.get("bloomBuffer").value = this.blurPass.texture, this.uniforms.get("featuresBuffer").value = this.renderTarget1.texture, this.resolution = new d(
+    }), this.renderTarget2.texture.name = "LensFlare.Target2", this.thresholdMaterial = new W(), this.thresholdPass = new g(this.thresholdMaterial), this.blurPass = new P(), this.blurPass.levels = 8, this.preBlurPass = new A({
+      kernelSize: z.SMALL
+    }), this.featuresMaterial = new X(), this.featuresPass = new g(this.featuresMaterial), this.uniforms.get("bloomBuffer").value = this.blurPass.texture, this.uniforms.get("featuresBuffer").value = this.renderTarget1.texture, this.resolution = new d(
       this,
       l,
-      D,
-      n
+      E,
+      o
     ), this.resolution.addEventListener(
       "change",
       this.onResolutionChange
-    ), this.intensity = C;
+    ), this.intensity = _;
   }
-  initialize(t, r, n) {
-    this.thresholdPass.initialize(t, r, n), this.blurPass.initialize(t, r, n), this.preBlurPass.initialize(t, r, n), this.featuresPass.initialize(t, r, n);
+  initialize(t, n, o) {
+    this.thresholdPass.initialize(t, n, o), this.blurPass.initialize(t, n, o), this.preBlurPass.initialize(t, n, o), this.featuresPass.initialize(t, n, o);
   }
-  update(t, r, n) {
-    this.thresholdPass.render(t, r, this.renderTarget1), this.blurPass.render(t, this.renderTarget1, null), this.preBlurPass.render(t, this.renderTarget1, this.renderTarget2), this.featuresPass.render(t, this.renderTarget2, this.renderTarget1);
+  update(t, n, o) {
+    this.thresholdPass.render(t, n, this.renderTarget1), this.blurPass.render(t, this.renderTarget1, null), this.preBlurPass.render(t, this.renderTarget1, this.renderTarget2), this.featuresPass.render(t, this.renderTarget2, this.renderTarget1);
   }
-  setSize(t, r) {
-    const n = this.resolution;
-    n.setBaseSize(t, r), this.renderTarget1.setSize(n.width, n.height), this.renderTarget2.setSize(n.width, n.height), this.thresholdMaterial.setSize(n.width, n.height), this.blurPass.setSize(n.width, n.height), this.preBlurPass.setSize(n.width, n.height), this.featuresMaterial.setSize(n.width, n.height);
+  setSize(t, n) {
+    const o = this.resolution;
+    o.setBaseSize(t, n);
+    const { width: i, height: a } = o;
+    this.renderTarget1.setSize(i, a), this.renderTarget2.setSize(i, a), this.thresholdMaterial.setSize(i, a), this.blurPass.setSize(i, a), this.preBlurPass.setSize(i, a), this.featuresMaterial.setSize(i, a);
   }
   get intensity() {
     return this.uniforms.get("intensity").value;
@@ -633,7 +636,11 @@ class se extends h {
     this.thresholdMaterial.thresholdRange = t;
   }
 }
-var Y = `uniform highp sampler2D normalBuffer;
+const J = `#include "core/depth"
+#include "core/packing"
+#include "core/transform"
+
+uniform highp sampler2D normalBuffer;
 
 uniform mat4 projectionMatrix;
 uniform mat4 inverseProjectionMatrix;
@@ -655,56 +662,58 @@ vec3 reconstructNormal(const vec2 uv) {
 
 vec3 readNormal(const vec2 uv) {
   #ifdef OCT_ENCODED
-  return unpackVec2ToNormal(texture2D(normalBuffer, uv).xy);
-  #else
-  return 2.0 * texture2D(normalBuffer, uv).xyz - 1.0;
-  #endif 
+  return unpackVec2ToNormal(texture(normalBuffer, uv).xy);
+  #else // OCT_ENCODED
+  return 2.0 * texture(normalBuffer, uv).xyz - 1.0;
+  #endif // OCT_ENCODED
 }
 
 void mainImage(const vec4 inputColor, const vec2 uv, out vec4 outputColor) {
   #ifdef RECONSTRUCT_FROM_DEPTH
   vec3 normal = reconstructNormal(uv);
-  #else
+  #else // RECONSTRUCT_FROM_DEPTH
   vec3 normal = readNormal(uv);
-  #endif 
+  #endif // RECONSTRUCT_FROM_DEPTH
 
   outputColor = vec4(normal * 0.5 + 0.5, inputColor.a);
-}`;
-const q = {
+}
+`, ee = {
   blendFunction: f.SRC,
   octEncoded: !1,
   reconstructFromDepth: !1
 };
-class ae extends h {
+class ce extends h {
   constructor(e, t) {
     const {
-      blendFunction: r,
-      normalBuffer: n = null,
-      octEncoded: s,
-      reconstructFromDepth: u
+      blendFunction: n,
+      normalBuffer: o = null,
+      octEncoded: i,
+      reconstructFromDepth: a
     } = {
-      ...q,
+      ...ee,
       ...t
     };
     super(
       "NormalEffect",
-      /* glsl */
-      `
-        ${b}
-        ${B}
-        ${P}
-        ${Y}
-      `,
+      b(J, {
+        core: {
+          depth: B,
+          packing: C,
+          transform: O
+        }
+      }),
       {
-        blendFunction: r,
+        blendFunction: n,
         attributes: p.DEPTH,
-        uniforms: /* @__PURE__ */ new Map([
-          ["normalBuffer", new i(n)],
-          ["projectionMatrix", new i(new w())],
-          ["inverseProjectionMatrix", new i(new w())]
-        ])
+        uniforms: new Map(
+          Object.entries({
+            normalBuffer: new s(o),
+            projectionMatrix: new s(new x()),
+            inverseProjectionMatrix: new s(new x())
+          })
+        )
       }
-    ), this.camera = e, e != null && (this.mainCamera = e), this.octEncoded = s, this.reconstructFromDepth = u;
+    ), this.camera = e, e != null && (this.mainCamera = e), this.octEncoded = i, this.reconstructFromDepth = a;
   }
   get mainCamera() {
     return this.camera;
@@ -712,9 +721,9 @@ class ae extends h {
   set mainCamera(e) {
     this.camera = e;
   }
-  update(e, t, r) {
-    const n = this.uniforms, s = n.get("projectionMatrix"), u = n.get("inverseProjectionMatrix"), l = this.camera;
-    l != null && (s.value.copy(l.projectionMatrix), u.value.copy(l.projectionMatrixInverse));
+  update(e, t, n) {
+    const o = this.uniforms, i = o.get("projectionMatrix"), a = o.get("inverseProjectionMatrix"), l = this.camera;
+    l != null && (i.value.copy(l.projectionMatrix), a.value.copy(l.projectionMatrixInverse));
   }
   get normalBuffer() {
     return this.uniforms.get("normalBuffer").value;
@@ -736,15 +745,15 @@ class ae extends h {
   }
 }
 export {
-  re as D,
-  ie as G,
-  se as L,
-  ae as N,
-  O as a,
-  oe as b,
+  se as D,
+  ue as G,
+  le as L,
+  ce as N,
+  j as a,
+  ae as b,
   L as d,
-  X as l,
-  q as n,
-  H as s
+  q as l,
+  ee as n,
+  I as s
 };
 //# sourceMappingURL=shared.js.map