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

package/src/shaders/downsampleThreshold.frag

@@ -25,7 +25,7 @@ float clampToBorder(const vec2 uv) {
 
 // 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(
@@ -34,10 +34,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 *
@@ -47,10 +47,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 *
@@ -60,10 +60,10 @@ 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
@@ -73,8 +73,6 @@ void main() {
   }
 
   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);
 }

package/src/shaders/geometryEffect.frag

@@ -1,10 +1,12 @@
+#include "core/packing"
+
 uniform sampler2D geometryBuffer;
 
 void mainImage(const vec4 inputColor, const vec2 uv, out vec4 outputColor) {
-  vec4 normalMetalnessRoughness = texture2D(geometryBuffer, uv);
+  vec4 normalMetalnessRoughness = texture(geometryBuffer, uv);
 
   #ifdef OUTPUT_NORMAL
-  vec3 normal = unpackVec2ToNormal(texture2D(geometryBuffer, uv).xy);
+  vec3 normal = unpackVec2ToNormal(texture(geometryBuffer, uv).xy);
   outputColor = vec4(normal * 0.5 + 0.5, inputColor.a);
   #endif // OUTPUT_NORMAL
 

package/src/shaders/lensFlareEffect.frag

@@ -3,10 +3,7 @@ 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
-  );
+  vec3 bloom = texture(bloomBuffer, uv).rgb;
+  vec3 features = texture(featuresBuffer, uv).rgb;
+  outputColor = vec4(inputColor.rgb + (bloom + features) * intensity, inputColor.a);
 }

package/src/shaders/lensFlareFeatures.frag

@@ -14,7 +14,7 @@ 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);
@@ -48,9 +48,9 @@ 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.

package/src/shaders/normalEffect.frag

@@ -1,3 +1,7 @@
+#include "core/depth"
+#include "core/packing"
+#include "core/transform"
+
 uniform highp sampler2D normalBuffer;
 
 uniform mat4 projectionMatrix;
@@ -20,16 +24,16 @@ 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;
+  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 // RECONSTRUCT_FROM_DEPTH
 

package/types/DepthEffect.d.ts

@@ -1,3 +1,5 @@
+import { UniformMap } from '@takram/three-geospatial';
+import { Uniform } from 'three';
 import { BlendFunction, Effect } from 'postprocessing';
 
 export interface DepthEffectOptions {
@@ -6,6 +8,10 @@ export interface DepthEffectOptions {
     near?: number;
     far?: number;
 }
+export interface DepthEffectUniforms {
+    near: Uniform<number>;
+    far: Uniform<number>;
+}
 export declare const depthEffectOptionsDefaults: {
     blendFunction: BlendFunction;
     useTurbo: false;
@@ -13,6 +19,7 @@ export declare const depthEffectOptionsDefaults: {
     far: number;
 };
 export declare class DepthEffect extends Effect {
+    uniforms: UniformMap<DepthEffectUniforms>;
     constructor(options?: DepthEffectOptions);
     get useTurbo(): boolean;
     set useTurbo(value: boolean);

package/types/GeometryEffect.d.ts

@@ -1,4 +1,5 @@
-import { Texture } from 'three';
+import { UniformMap } from '@takram/three-geospatial';
+import { Uniform, Texture } from 'three';
 import { BlendFunction, Effect } from 'postprocessing';
 
 export type GeometryEffectOutput = 'normal' | 'pbr';
@@ -7,11 +8,15 @@ export interface GeometryEffectOptions {
     geometryBuffer?: Texture | null;
     output?: GeometryEffectOutput;
 }
+export interface GeometryEffectUniforms {
+    geometryBuffer: Uniform<Texture | null>;
+}
 export declare const geometryEffectOptionsDefaults: {
     blendFunction: BlendFunction;
     output: "normal";
 };
 export declare class GeometryEffect extends Effect {
+    uniforms: UniformMap<GeometryEffectUniforms>;
     constructor(options?: GeometryEffectOptions);
     get geometryBuffer(): Texture | null;
     set geometryBuffer(value: Texture | null);

package/types/LensFlareEffect.d.ts

@@ -1,6 +1,7 @@
 import { LensFlareFeaturesMaterial } from './LensFlareFeaturesMaterial';
 import { DownsampleThresholdMaterial } from './DownsampleThresholdMaterial';
-import { WebGLRenderTarget, TextureDataType, WebGLRenderer } from 'three';
+import { UniformMap } from '@takram/three-geospatial';
+import { Uniform, WebGLRenderTarget, Texture, TextureDataType, WebGLRenderer } from 'three';
 import { BlendFunction, Effect, KawaseBlurPass, MipmapBlurPass, Resolution, ShaderPass } from 'postprocessing';
 
 export interface LensFlareEffectOptions {
@@ -12,6 +13,11 @@ export interface LensFlareEffectOptions {
     resolutionY?: number;
     intensity?: number;
 }
+export interface LensFlareEffectUniforms {
+    bloomBuffer: Uniform<Texture | null>;
+    featuresBuffer: Uniform<Texture | null>;
+    intensity: Uniform<number>;
+}
 export declare const lensFlareEffectOptionsDefaults: {
     blendFunction: BlendFunction;
     resolutionScale: number;
@@ -20,6 +26,7 @@ export declare const lensFlareEffectOptionsDefaults: {
     intensity: number;
 };
 export declare class LensFlareEffect extends Effect {
+    uniforms: UniformMap<LensFlareEffectUniforms>;
     readonly resolution: Resolution;
     readonly renderTarget1: WebGLRenderTarget;
     readonly renderTarget2: WebGLRenderTarget;
@@ -33,7 +40,7 @@ export declare class LensFlareEffect extends Effect {
     private readonly onResolutionChange;
     initialize(renderer: WebGLRenderer, alpha: boolean, frameBufferType: TextureDataType): void;
     update(renderer: WebGLRenderer, inputBuffer: WebGLRenderTarget, deltaTime?: number): void;
-    setSize(width: number, height: number): void;
+    setSize(baseWidth: number, baseHeight: number): void;
     get intensity(): number;
     set intensity(value: number);
     get thresholdLevel(): number;

package/types/NormalEffect.d.ts

@@ -1,4 +1,5 @@
-import { Camera, Texture, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { UniformMap } from '@takram/three-geospatial';
+import { Matrix4, Uniform, Camera, Texture, WebGLRenderer, WebGLRenderTarget } from 'three';
 import { BlendFunction, Effect } from 'postprocessing';
 
 export interface NormalEffectOptions {
@@ -7,6 +8,11 @@ export interface NormalEffectOptions {
     octEncoded?: boolean;
     reconstructFromDepth?: boolean;
 }
+export interface NormalEffectUniforms {
+    normalBuffer: Uniform<Texture | null>;
+    projectionMatrix: Uniform<Matrix4>;
+    inverseProjectionMatrix: Uniform<Matrix4>;
+}
 export declare const normalEffectOptionsDefaults: {
     blendFunction: BlendFunction;
     octEncoded: false;
@@ -14,6 +20,7 @@ export declare const normalEffectOptionsDefaults: {
 };
 export declare class NormalEffect extends Effect {
     private camera;
+    uniforms: UniformMap<NormalEffectUniforms>;
     constructor(camera: Camera, options?: NormalEffectOptions);
     get mainCamera(): Camera;
     set mainCamera(value: Camera);