@takram/three-geospatial-effects 0.0.1-alpha.0

package/build/shared.cjs

@@ -0,0 +1,315 @@
+"use strict";var R=Object.defineProperty;var T=(i,e,t)=>e in i?R(i,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):i[e]=t;var l=(i,e,t)=>T(i,typeof e!="symbol"?e+"":e,t);const s=require("postprocessing"),r=require("three"),f=require("@takram/three-geospatial");var S=`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);
+  depth = linearizeDepth(depth, near, far) / far;
+
+  #ifdef USE_TURBO
+  vec3 color = turbo(1.0 - depth);
+  #else
+  vec3 color = vec3(depth);
+  #endif 
+
+  outputColor = vec4(color, inputColor.a);
+}`;const d={blendFunction:s.BlendFunction.SRC,useTurbo:!1,near:1,far:1e3};class b extends s.Effect{constructor(e){const{blendFunction:t,useTurbo:o,near:n,far:a}={...d,...e};super("DepthEffect",`
+        ${f.depthShader}
+        ${S}
+      `,{blendFunction:t,attributes:s.EffectAttribute.DEPTH,uniforms:new Map([["near",new r.Uniform(n)],["far",new r.Uniform(a)]])}),this.useTurbo=o}get useTurbo(){return this.defines.has("USE_TURBO")}set useTurbo(e){this.useTurbo!==e&&(e?this.defines.set("USE_TURBO","1"):this.defines.delete("USE_TURBO"),this.setChanged())}get near(){return this.uniforms.get("near").value}set near(e){this.uniforms.get("near").value=e}get far(){return this.uniforms.get("far").value}set far(e){this.uniforms.get("far").value=e}}var B=`#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 m={blendFunction:s.BlendFunction.NORMAL};class D extends s.Effect{constructor(e){const{blendFunction:t}={...m,...e};super("DitheringEffect",B,{blendFunction:t})}}const h=Symbol("SETUP");function E(i){const e=i.vertexShader.replace("#include <fog_pars_vertex>",`
+        #include <fog_pars_vertex>
+        #include <normal_pars_vertex>
+      `).replace("#include <defaultnormal_vertex>",`
+        #include <defaultnormal_vertex>
+        #include <normal_vertex>
+      `).replace("#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )","#if 1").replace("#include <clipping_planes_vertex>",`
+        #include <clipping_planes_vertex>
+        vViewPosition = - mvPosition.xyz;
+      `);i.vertexShader=`
+    #undef FLAT_SHADED
+    varying vec3 vViewPosition;
+    ${e}
+  `;const t=i.fragmentShader.replace(/#ifndef FLAT_SHADED\s+varying vec3 vNormal;\s+#endif/m,"#include <normal_pars_fragment>").replace("#include <common>",`
+        #include <common>
+        #include <packing>
+      `).replace("#include <specularmap_fragment>",`
+        #include <specularmap_fragment>
+        #include <normal_fragment_begin>
+        #include <normal_fragment_maps>
+      `);return i.fragmentShader=`
+    #undef FLAT_SHADED
+    varying vec3 vViewPosition;
+    ${t}
+  `,i}function v(i,{type:e}={}){if(i[h]===!0)return i;e==="basic"&&E(i);const t=e==="physical"?`
+          vec4(
+            packNormalToVec2(normal),
+            metalnessFactor,
+            roughnessFactor
+          )
+        `:`
+          vec4(
+            packNormalToVec2(normal),
+            reflectivity,
+            0.0
+          );
+        `;return i.fragmentShader=`
+    layout(location = 1) out vec4 outputBuffer1;
+
+    #ifndef USE_ENVMAP
+      uniform float reflectivity;
+    #endif
+
+    ${f.packingShader}
+    ${i.fragmentShader.replace(/}\s*$/m,`
+          outputBuffer1 = ${t};
+        }
+      `)}
+  `,i[h]=!0,i}function p(){v(r.ShaderLib.lambert),v(r.ShaderLib.phong),v(r.ShaderLib.basic,{type:"basic"}),v(r.ShaderLib.standard,{type:"physical"}),v(r.ShaderLib.physical,{type:"physical"})}class C extends s.RenderPass{constructor(t,o,n,a){super(o,n,a);l(this,"geometryTexture");this.geometryTexture=t.texture.clone(),this.geometryTexture.isRenderTargetTexture=!0,this.geometryTexture.type=r.HalfFloatType,p()}render(t,o,n,a,u){o!=null&&(o.textures[1]=this.geometryTexture),super.render(t,o,null),o!=null&&(o.textures.length=1)}setSize(t,o){this.geometryTexture.image.width=t,this.geometryTexture.image.height=o}}var _=`#include <common>
+
+uniform sampler2D inputBuffer;
+
+uniform float thresholdLevel;
+uniform float thresholdRange;
+
+in vec2 vCenterUv1;
+in vec2 vCenterUv2;
+in vec2 vCenterUv3;
+in vec2 vCenterUv4;
+in vec2 vRowUv1;
+in vec2 vRowUv2;
+in vec2 vRowUv3;
+in vec2 vRowUv4;
+in vec2 vRowUv5;
+in vec2 vRowUv6;
+in vec2 vRowUv7;
+in vec2 vRowUv8;
+in vec2 vRowUv9;
+
+float clampToBorder(const vec2 uv) {
+  return float(uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0);
+}
+
+void main() {
+  vec3 color = 0.125 * texture2D(inputBuffer, vec2(vRowUv5)).rgb;
+  vec4 weight =
+    0.03125 *
+    vec4(
+      clampToBorder(vRowUv1),
+      clampToBorder(vRowUv3),
+      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;
+
+  weight =
+    0.0625 *
+    vec4(
+      clampToBorder(vRowUv2),
+      clampToBorder(vRowUv4),
+      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;
+
+  weight =
+    0.125 *
+    vec4(
+      clampToBorder(vRowUv2),
+      clampToBorder(vRowUv4),
+      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;
+
+  float l = luminance(color);
+  float scale = saturate(
+    smoothstep(thresholdLevel, thresholdLevel + thresholdRange, l)
+  );
+  gl_FragColor = vec4(color * scale, 1.0);
+}`,F=`uniform vec2 texelSize;
+
+out vec2 vCenterUv1;
+out vec2 vCenterUv2;
+out vec2 vCenterUv3;
+out vec2 vCenterUv4;
+out vec2 vRowUv1;
+out vec2 vRowUv2;
+out vec2 vRowUv3;
+out vec2 vRowUv4;
+out vec2 vRowUv5;
+out vec2 vRowUv6;
+out vec2 vRowUv7;
+out vec2 vRowUv8;
+out vec2 vRowUv9;
+
+void main() {
+  vec2 uv = position.xy * 0.5 + 0.5;
+  vCenterUv1 = uv + texelSize * vec2(-1.0, 1.0);
+  vCenterUv2 = uv + texelSize * vec2(1.0, 1.0);
+  vCenterUv3 = uv + texelSize * vec2(-1.0, -1.0);
+  vCenterUv4 = uv + texelSize * vec2(1.0, -1.0);
+  vRowUv1 = uv + texelSize * vec2(-2.0, 2.0);
+  vRowUv2 = uv + texelSize * vec2(0.0, 2.0);
+  vRowUv3 = uv + texelSize * vec2(2.0, 2.0);
+  vRowUv4 = uv + texelSize * vec2(-2.0, 0.0);
+  vRowUv5 = uv + texelSize;
+  vRowUv6 = uv + texelSize * vec2(2.0, 0.0);
+  vRowUv7 = uv + texelSize * vec2(-2.0, -2.0);
+  vRowUv8 = uv + texelSize * vec2(0.0, -2.0);
+  vRowUv9 = uv + texelSize * vec2(2.0, -2.0);
+
+  gl_Position = vec4(position.xy, 1.0, 1.0);
+}`;const y={thresholdLevel:10,thresholdRange:1};class M extends r.ShaderMaterial{constructor(e){const{inputBuffer:t=null,thresholdLevel:o,thresholdRange:n,...a}={...y,...e};super({name:"DownsampleThresholdMaterial",fragmentShader:_,vertexShader:F,uniforms:{inputBuffer:new r.Uniform(t),texelSize:new r.Uniform(new r.Vector2),thresholdLevel:new r.Uniform(o),thresholdRange:new r.Uniform(n)},blending:r.NoBlending,toneMapped:!1,depthWrite:!1,depthTest:!1,...a})}setSize(e,t){this.uniforms.texelSize.value.set(1/e,1/t)}get inputBuffer(){return this.uniforms.inputBuffer.value}set inputBuffer(e){this.uniforms.inputBuffer.value=e}get thresholdLevel(){return this.uniforms.thresholdLevel.value}set thresholdLevel(e){this.uniforms.thresholdLevel.value=e}get thresholdRange(){return this.uniforms.thresholdRange.value}set thresholdRange(e){this.uniforms.thresholdRange.value=e}}var P=`#include <common>
+
+#define SQRT_2 (0.7071067811865476)
+
+uniform sampler2D inputBuffer;
+
+uniform vec2 texelSize;
+uniform float ghostAmount;
+uniform float haloAmount;
+uniform float chromaticAberration;
+
+in vec2 vUv;
+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;
+
+  
+  float d = clamp(length(0.5 - suv) / (0.5 * SQRT_2), 0.0, 1.0);
+  result *= pow(1.0 - d, 3.0);
+  return result;
+}
+
+vec4 sampleGhosts(float amount) {
+  vec3 color = vec3(0.0);
+  vec2 direction = vUv - 0.5;
+  color += sampleGhost(direction, vec3(0.8, 0.8, 1.0), -5.0);
+  color += sampleGhost(direction, vec3(1.0, 0.8, 0.4), -1.5);
+  color += sampleGhost(direction, vec3(0.9, 1.0, 0.8), -0.4);
+  color += sampleGhost(direction, vec3(1.0, 0.8, 0.4), -0.2);
+  color += sampleGhost(direction, vec3(0.9, 0.7, 0.7), -0.1);
+  color += sampleGhost(direction, vec3(0.5, 1.0, 0.4), 0.7);
+  color += sampleGhost(direction, vec3(0.5, 0.5, 0.5), 1.0);
+  color += sampleGhost(direction, vec3(1.0, 1.0, 0.6), 2.5);
+  color += sampleGhost(direction, vec3(0.5, 0.8, 1.0), 10.0);
+  return vec4(color * amount, 1.0);
+}
+
+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);
+}
+
+vec3 sampleHalo(const float radius) {
+  vec2 direction = normalize((vUv - 0.5) / vAspectRatio) * vAspectRatio;
+  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
+  );
+
+  
+  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);
+  return result;
+}
+
+vec4 sampleHalos(const float amount) {
+  vec3 color = vec3(0.0);
+  color += sampleHalo(0.3);
+  return vec4(color, 1.0) * amount;
+}
+
+void main() {
+  gl_FragColor += sampleGhosts(ghostAmount);
+  gl_FragColor += sampleHalos(haloAmount);
+}`,z=`uniform vec2 texelSize;
+
+out vec2 vUv;
+out vec2 vAspectRatio;
+
+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 A={ghostAmount:.001,haloAmount:.001,chromaticAberration:10};class L extends r.ShaderMaterial{constructor(e){const{inputBuffer:t=null,ghostAmount:o,haloAmount:n,chromaticAberration:a}={...A,...e};super({name:"LensFlareFeaturesMaterial",fragmentShader:P,vertexShader:z,uniforms:{inputBuffer:new r.Uniform(t),texelSize:new r.Uniform(new r.Vector2),ghostAmount:new r.Uniform(o),haloAmount:new r.Uniform(n),chromaticAberration:new r.Uniform(a)},blending:r.NoBlending,toneMapped:!1,depthWrite:!1,depthTest:!1})}setSize(e,t){const o=this.uniforms.texelSize;o.value.x=1/e,o.value.y=1/t}get inputBuffer(){return this.uniforms.inputBuffer.value}set inputBuffer(e){this.uniforms.inputBuffer.value=e}get ghostAmount(){return this.uniforms.ghostAmount.value}set ghostAmount(e){this.uniforms.ghostAmount.value=e}get haloAmount(){return this.uniforms.haloAmount.value}set haloAmount(e){this.uniforms.haloAmount.value=e}get chromaticAberration(){return this.uniforms.chromaticAberration.value}set chromaticAberration(e){this.uniforms.chromaticAberration.value=e}}var N=`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 g={blendFunction:s.BlendFunction.NORMAL,resolutionScale:.5,width:s.Resolution.AUTO_SIZE,height:s.Resolution.AUTO_SIZE,intensity:.005};class O extends s.Effect{constructor(t){const{blendFunction:o,resolutionScale:n,width:a,height:u,resolutionX:c=a,resolutionY:w=u,intensity:U}={...g,...t};super("LensFlareEffect",N,{blendFunction:o,uniforms:new Map([["bloomBuffer",new r.Uniform(null)],["featuresBuffer",new r.Uniform(null)],["intensity",new r.Uniform(1)]])});l(this,"resolution");l(this,"renderTarget1");l(this,"renderTarget2");l(this,"thresholdMaterial");l(this,"thresholdPass");l(this,"blurPass");l(this,"preBlurPass");l(this,"featuresMaterial");l(this,"featuresPass");l(this,"onResolutionChange",()=>{this.setSize(this.resolution.baseWidth,this.resolution.baseHeight)});this.renderTarget1=new r.WebGLRenderTarget(1,1,{depthBuffer:!1,stencilBuffer:!1,type:r.HalfFloatType}),this.renderTarget1.texture.name="LensFlare.Target1",this.renderTarget2=new r.WebGLRenderTarget(1,1,{depthBuffer:!1,stencilBuffer:!1,type:r.HalfFloatType}),this.renderTarget2.texture.name="LensFlare.Target2",this.thresholdMaterial=new M,this.thresholdPass=new s.ShaderPass(this.thresholdMaterial),this.blurPass=new s.MipmapBlurPass,this.blurPass.levels=8,this.preBlurPass=new s.KawaseBlurPass({kernelSize:s.KernelSize.SMALL}),this.featuresMaterial=new L,this.featuresPass=new s.ShaderPass(this.featuresMaterial),this.uniforms.get("bloomBuffer").value=this.blurPass.texture,this.uniforms.get("featuresBuffer").value=this.renderTarget1.texture,this.resolution=new s.Resolution(this,c,w,n),this.resolution.addEventListener("change",this.onResolutionChange),this.intensity=U}initialize(t,o,n){this.thresholdPass.initialize(t,o,n),this.blurPass.initialize(t,o,n),this.preBlurPass.initialize(t,o,n),this.featuresPass.initialize(t,o,n)}update(t,o,n){this.thresholdPass.render(t,o,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,o){const n=this.resolution;n.setBaseSize(t,o),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)}get intensity(){return this.uniforms.get("intensity").value}set intensity(t){this.uniforms.get("intensity").value=t}get thresholdLevel(){return this.thresholdMaterial.thresholdLevel}set thresholdLevel(t){this.thresholdMaterial.thresholdLevel=t}get thresholdRange(){return this.thresholdMaterial.thresholdRange}set thresholdRange(t){this.thresholdMaterial.thresholdRange=t}}var G=`uniform highp sampler2D normalBuffer;
+
+uniform mat4 projectionMatrix;
+uniform mat4 inverseProjectionMatrix;
+
+vec3 reconstructNormal(const vec2 uv) {
+  float depth = readDepth(uv);
+  depth = reverseLogDepth(depth, cameraNear, cameraFar);
+  vec3 position = screenToView(
+    uv,
+    depth,
+    getViewZ(depth),
+    projectionMatrix,
+    inverseProjectionMatrix
+  );
+  vec3 dx = dFdx(position);
+  vec3 dy = dFdy(position);
+  return normalize(cross(dx, dy));
+}
+
+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 
+}
+
+void mainImage(const vec4 inputColor, const vec2 uv, out vec4 outputColor) {
+  #ifdef RECONSTRUCT_FROM_DEPTH
+  vec3 normal = reconstructNormal(uv);
+  #else
+  vec3 normal = readNormal(uv);
+  #endif 
+
+  outputColor = vec4(normal * 0.5 + 0.5, inputColor.a);
+}`;const x={blendFunction:s.BlendFunction.SRC,octEncoded:!1,reconstructFromDepth:!1};class H extends s.Effect{constructor(e,t){const{blendFunction:o,normalBuffer:n=null,octEncoded:a,reconstructFromDepth:u}={...x,...t};super("NormalEffect",`
+        ${f.depthShader}
+        ${f.packingShader}
+        ${f.transformShader}
+        ${G}
+      `,{blendFunction:o,attributes:s.EffectAttribute.DEPTH,uniforms:new Map([["normalBuffer",new r.Uniform(n)],["projectionMatrix",new r.Uniform(new r.Matrix4)],["inverseProjectionMatrix",new r.Uniform(new r.Matrix4)]])}),this.camera=e,e!=null&&(this.mainCamera=e),this.octEncoded=a,this.reconstructFromDepth=u}get mainCamera(){return this.camera}set mainCamera(e){this.camera=e}update(e,t,o){const n=this.uniforms,a=n.get("projectionMatrix"),u=n.get("inverseProjectionMatrix"),c=this.camera;c!=null&&(a.value.copy(c.projectionMatrix),u.value.copy(c.projectionMatrixInverse))}get normalBuffer(){return this.uniforms.get("normalBuffer").value}set normalBuffer(e){this.uniforms.get("normalBuffer").value=e}get octEncoded(){return this.defines.has("OCT_ENCODED")}set octEncoded(e){e!==this.octEncoded&&(e?this.defines.set("OCT_ENCODED","1"):this.defines.delete("OCT_ENCODED"),this.setChanged())}get reconstructFromDepth(){return this.defines.has("RECONSTRUCT_FROM_DEPTH")}set reconstructFromDepth(e){e!==this.reconstructFromDepth&&(e?this.defines.set("RECONSTRUCT_FROM_DEPTH","1"):this.defines.delete("RECONSTRUCT_FROM_DEPTH"),this.setChanged())}}exports.DepthEffect=b;exports.DitheringEffect=D;exports.GeometryPass=C;exports.LensFlareEffect=O;exports.NormalEffect=H;exports.depthEffectOptionsDefaults=d;exports.ditheringOptionsDefaults=m;exports.lensFlareEffectOptionsDefaults=g;exports.normalEffectOptionsDefaults=x;exports.setupMaterialsForGeometryPass=p;