angular-three-postprocessing 4.1.0 → 4.2.0

package/fesm2022/angular-three-postprocessing.mjs

@@ -1,9 +1,9 @@
 import * as i0 from '@angular/core';
-import { inject, ChangeDetectionStrategy, CUSTOM_ELEMENTS_SCHEMA, Component, input, Directive, computed, viewChild, effect, untracked } from '@angular/core';
-import { injectStore, pick, extend, getInstanceState, beforeRender, NgtArgs, vector2, omit, resolveRef, vector3, is, NgtSelectionApi } from 'angular-three';
+import { inject, ChangeDetectionStrategy, CUSTOM_ELEMENTS_SCHEMA, Component, input, Directive, computed, viewChild, effect, DestroyRef, untracked } from '@angular/core';
+import { injectStore, pick, extend, getInstanceState, beforeRender, NgtArgs, vector3, vector2, omit, resolveRef, is, NgtSelectionApi, loaderResource } from 'angular-three';
 import { createNoopInjectionToken } from 'ngxtension/create-injection-token';
 import { mergeInputs } from 'ngxtension/inject-inputs';
-import { EffectAttribute, EffectComposer, RenderPass, NormalPass, DepthDownsamplingPass, Effect, EffectPass, Pass, BloomEffect, BlendFunction, BrightnessContrastEffect, ChromaticAberrationEffect, ColorAverageEffect, ColorDepthEffect, DepthEffect, DepthOfFieldEffect, MaskFunction, DotScreenEffect, FXAAEffect, GlitchEffect, GlitchMode, GodRaysEffect, GridEffect, HueSaturationEffect, LUT3DEffect, NoiseEffect, OutlineEffect, PixelationEffect, ScanlineEffect, SelectiveBloomEffect, SepiaEffect, ShockWaveEffect, SMAAEffect, TiltShiftEffect, ToneMappingEffect, VignetteEffect } from 'postprocessing';
+import { EffectAttribute, EffectComposer, RenderPass, NormalPass, DepthDownsamplingPass, Effect, EffectPass, Pass, DepthPickingPass, CopyPass, DepthOfFieldEffect, BloomEffect, BlendFunction, BrightnessContrastEffect, ChromaticAberrationEffect, ColorAverageEffect, ColorDepthEffect, DepthEffect, MaskFunction, DotScreenEffect, FXAAEffect, GlitchEffect, GlitchMode, GodRaysEffect, GridEffect, HueSaturationEffect, LUT3DEffect, NoiseEffect, OutlineEffect, PixelationEffect, ScanlineEffect, SelectiveBloomEffect, SepiaEffect, SSAOEffect, ShockWaveEffect, SMAAEffect, TextureEffect, TiltShiftEffect, ToneMappingEffect, VignetteEffect } from 'postprocessing';
 import * as THREE from 'three';
 import { Group } from 'three';
 import { isWebGL2Available } from 'three-stdlib';
@@ -107,7 +107,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.6", ngImpor
             type: Directive
         }], propDecorators: { blendFunction: [{ type: i0.Input, args: [{ isSignal: true, alias: "blendFunction", required: false }] }], opacity: [{ type: i0.Input, args: [{ isSignal: true, alias: "opacity", required: false }] }] } });
 
-const defaultOptions$5 = {
+const defaultOptions$6 = {
     enabled: true,
     renderPriority: 1,
     autoClear: true,
@@ -153,7 +153,7 @@ class NgtpEffectComposer {
          * Configuration options for the effect composer.
          * @see NgtpEffectComposerOptions
          */
-        this.options = input(defaultOptions$5, { ...(ngDevMode ? { debugName: "options" } : {}), transform: mergeInputs(defaultOptions$5) });
+        this.options = input(defaultOptions$6, { ...(ngDevMode ? { debugName: "options" } : {}), transform: mergeInputs(defaultOptions$6) });
         this.store = injectStore();
         this.depthBuffer = pick(this.options, 'depthBuffer');
         this.stencilBuffer = pick(this.options, 'stencilBuffer');
@@ -230,6 +230,8 @@ class NgtpEffectComposer {
          * Can be used to access the composer directly for advanced use cases.
          */
         this.effectComposer = pick(this.composerData, 'composer');
+        this.normalPass = pick(this.composerData, 'normalPass');
+        this.downSamplingPass = pick(this.composerData, 'downSamplingPass');
         extend({ Group });
         // NOTE: Disable tone mapping because threejs disallows tonemapping on render targets
         effect((onCleanup) => {
@@ -447,7 +449,7 @@ class ASCIIEffect extends Effect {
         return texture;
     }
 }
-const defaultOptions$4 = {
+const defaultOptions$5 = {
     font: 'arial',
     characters: ` .:,'-^=*+?!|0#X%WM@`,
     fontSize: 54,
@@ -474,7 +476,7 @@ class NgtpASCII {
          * Configuration options for the ASCII effect.
          * @see ASCIIEffectOptions
          */
-        this.options = input(defaultOptions$4, { ...(ngDevMode ? { debugName: "options" } : {}), transform: mergeInputs(defaultOptions$4) });
+        this.options = input(defaultOptions$5, { ...(ngDevMode ? { debugName: "options" } : {}), transform: mergeInputs(defaultOptions$5) });
         /** The underlying ASCIIEffect instance */
         this.effect = computed(() => new ASCIIEffect(this.options()), ...(ngDevMode ? [{ debugName: "effect" }] : []));
         effect((onCleanup) => {
@@ -500,6 +502,139 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.6", ngImpor
                 }]
         }], ctorParameters: () => [], propDecorators: { options: [{ type: i0.Input, args: [{ isSignal: true, alias: "options", required: false }] }] } });
 
+const defaultOptions$4 = {
+    mouse: false,
+    manual: false,
+    smoothTime: 0.25,
+};
+class NgtpAutofocus {
+    constructor() {
+        this.options = input(defaultOptions$4, { ...(ngDevMode ? { debugName: "options" } : {}), transform: mergeInputs(defaultOptions$4) });
+        this.effectComposer = inject(NgtpEffectComposer);
+        this.store = injectStore();
+        this.hitpoint = new THREE.Vector3(0, 0, 0);
+        this.ndc = new THREE.Vector3(0, 0, 0);
+        this.depthPickingPass = new DepthPickingPass();
+        this.copyPass = new CopyPass();
+        this.debugSize = pick(this.options, 'debug');
+        this.hitpointMeshRef = viewChild('hitpointMesh', ...(ngDevMode ? [{ debugName: "hitpointMeshRef" }] : []));
+        this.targetMeshRef = viewChild('targetMesh', ...(ngDevMode ? [{ debugName: "targetMeshRef" }] : []));
+        this.target = vector3(this.options, 'target', true);
+        this.dofEffect = computed(() => {
+            const [camera, options] = [this.effectComposer.camera(), this.options()];
+            const { target: _, mouse: __, debug: ___, manual: ____, smoothTime: _____, ...dofOptions } = options;
+            const dof = new DepthOfFieldEffect(camera, dofOptions);
+            dof.target = new THREE.Vector3().copy(this.hitpoint);
+            return dof;
+        }, ...(ngDevMode ? [{ debugName: "dofEffect" }] : []));
+        // add passes to composer
+        effect((onCleanup) => {
+            const composer = this.effectComposer.effectComposer();
+            if (!composer)
+                return;
+            composer.addPass(this.depthPickingPass);
+            composer.addPass(this.copyPass);
+            onCleanup(() => {
+                composer.removePass(this.depthPickingPass);
+                composer.removePass(this.copyPass);
+            });
+        });
+        inject(DestroyRef).onDestroy(() => {
+            this.depthPickingPass.dispose();
+            this.copyPass.dispose();
+        });
+        // cleanup dof effect
+        effect((onCleanup) => {
+            const dof = this.dofEffect();
+            onCleanup(() => dof.dispose());
+        });
+        beforeRender(({ delta }) => {
+            const dof = this.dofEffect();
+            if (!dof?.target)
+                return;
+            const { mouse: followMouse, smoothTime, manual } = this.options();
+            if (manual)
+                return;
+            const target = this.target();
+            const camera = this.effectComposer.camera();
+            if (target) {
+                this.hitpoint.copy(target);
+            }
+            else {
+                const { x, y } = followMouse ? this.store.snapshot.pointer : { x: 0, y: 0 };
+                this.ndc.x = x;
+                this.ndc.y = y;
+                this.depthPickingPass.readDepth(this.ndc).then((depth) => {
+                    this.ndc.z = depth * 2.0 - 1.0;
+                    const hit = 1 - this.ndc.z > 0.0000001;
+                    if (hit) {
+                        const unprojected = this.ndc.clone().unproject(camera);
+                        this.hitpoint.copy(unprojected);
+                    }
+                });
+            }
+            if (smoothTime && smoothTime > 0 && delta > 0) {
+                easing.damp3(dof.target, this.hitpoint, smoothTime, delta);
+            }
+            else {
+                dof.target.copy(this.hitpoint);
+            }
+            const hitpointMesh = this.hitpointMeshRef()?.nativeElement;
+            if (hitpointMesh)
+                hitpointMesh.position.copy(this.hitpoint);
+            const targetMesh = this.targetMeshRef()?.nativeElement;
+            if (targetMesh)
+                targetMesh.position.copy(dof.target);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.6", ngImport: i0, type: NgtpAutofocus, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.1.6", type: NgtpAutofocus, isStandalone: true, selector: "ngtp-autofocus", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "hitpointMeshRef", first: true, predicate: ["hitpointMesh"], descendants: true, isSignal: true }, { propertyName: "targetMeshRef", first: true, predicate: ["targetMesh"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-primitive *args="[dofEffect()]" [dispose]="null" />
+		@if (debugSize(); as debugSize) {
+			<ngt-mesh #hitpointMesh>
+				<ngt-sphere-geometry *args="[debugSize, 16, 16]" />
+				<ngt-mesh-basic-material [color]="'#00ff00'" [opacity]="1" [transparent]="true" [depthWrite]="false" />
+			</ngt-mesh>
+			<ngt-mesh #targetMesh>
+				<ngt-sphere-geometry *args="[debugSize / 2, 16, 16]" />
+				<ngt-mesh-basic-material
+					[color]="'#00ff00'"
+					[opacity]="0.5"
+					[transparent]="true"
+					[depthWrite]="false"
+				/>
+			</ngt-mesh>
+		}
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.6", ngImport: i0, type: NgtpAutofocus, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtp-autofocus',
+                    template: `
+		<ngt-primitive *args="[dofEffect()]" [dispose]="null" />
+		@if (debugSize(); as debugSize) {
+			<ngt-mesh #hitpointMesh>
+				<ngt-sphere-geometry *args="[debugSize, 16, 16]" />
+				<ngt-mesh-basic-material [color]="'#00ff00'" [opacity]="1" [transparent]="true" [depthWrite]="false" />
+			</ngt-mesh>
+			<ngt-mesh #targetMesh>
+				<ngt-sphere-geometry *args="[debugSize / 2, 16, 16]" />
+				<ngt-mesh-basic-material
+					[color]="'#00ff00'"
+					[opacity]="0.5"
+					[transparent]="true"
+					[depthWrite]="false"
+				/>
+			</ngt-mesh>
+		}
+	`,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [], propDecorators: { options: [{ type: i0.Input, args: [{ isSignal: true, alias: "options", required: false }] }], hitpointMeshRef: [{ type: i0.ViewChild, args: ['hitpointMesh', { isSignal: true }] }], targetMeshRef: [{ type: i0.ViewChild, args: ['targetMesh', { isSignal: true }] }] } });
+
 /**
  * Angular component that applies a bloom postprocessing effect to the scene.
  *
@@ -1272,49 +1407,376 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.6", ngImpor
  */
 const LensFlareShader = {
     fragmentShader: /* language=glsl glsl */ `
+    uniform float time;
+    uniform vec2 lensPosition;
+    uniform vec2 screenRes;
+    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 vTexCoord;
+
+    float rand(float n){return fract(sin(n) * 43758.5453123);}
+
+    float noise(float p){
+      float fl = floor(p);
+      float fc = fract(p);
+      return mix(rand(fl),rand(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 saturate(float x)
+    {
+      return clamp(x, 0.,1.);
+    }
+
+    vec2 rotateUV(vec2 uv, float rotation)
+    {
+      return vec2(
+          cos(rotation) * uv.x + sin(rotation) * uv.y,
+          cos(rotation) * uv.y - sin(rotation) * uv.x
+      );
+    }
+
+    vec3 drawflare(vec2 p, float intensity, float rnd, float speed, int id)
+    {
+      float flarehueoffset = (1. / 32.) * float(id) * 0.1;
+      float lingrad = distance(vec2(0.), p);
+      float expgrad = 1. / exp(lingrad * (fract(rnd) * 0.66 + 0.33));
+      vec3 colgrad = hsv2rgb(vec3( fract( (expgrad * 8.) + speed * flareSpeed + flarehueoffset), pow(1.-abs(expgrad*2.-1.), 0.45), 20.0 * expgrad * intensity));
+
+      float internalStarPoints;
+
+      if(anamorphic){
+        internalStarPoints = 1.0;
+      } else{
+        internalStarPoints = starPoints;
+      }
+
+      float blades = length(p * flareShape * sin(internalStarPoints * atan(p.x, p.y)));
+
+      float comp = pow(1.-saturate(blades), ( anamorphic ? 100. : 12.));
+      comp += saturate(expgrad-0.9) * 3.;
+      comp = pow(comp * expgrad, 8. + (1.-intensity) * 5.);
+
+      if(flareSpeed > 0.0){
+        return vec3(comp) * colgrad;
+      } else{
+        return vec3(comp) * flareSize * 15.;
+      }
+    }
+
+    float dist(vec3 a, vec3 b) { return abs(a.x - b.x) + abs(a.y - b.y) + abs(a.z - b.z); }
+
+    vec3 saturate(vec3 x)
+    {
+      return clamp(x, vec3(0.0), vec3(1.0));
+    }
+
+    float glare(vec2 uv, vec2 pos, float size)
+    {
+      vec2 main;
+
+      if(animated){
+        main = rotateUV(uv-pos, time * 0.1);
+      } else{
+        main = uv-pos;
+      }
+
+      float ang = atan(main.y, main.x) * (anamorphic ? 1.0 : starPoints);
+      float dist = length(main);
+      dist = pow(dist, .9);
+
+      float f0 = 1.0/(length(uv-pos)*(1.0/size*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 renderhex(vec2 uv, vec2 p, float s, vec3 col){
+      uv -= p;
+      if (abs(uv.x) < 0.2*s && abs(uv.y) < 0.2*s){
+          return mix(vec3(0),mix(vec3(0),col,0.1 + fpow(length(uv/s),0.1)*10.0),smoothstep(0.0,0.1,sdHex(uv*20.0/s)));
+      }
+      return vec3(0);
+    }
+
+    vec3 LensFlare(vec2 uv, vec2 pos)
+    {
+      vec2 main = uv-pos;
+      vec2 uvd = uv*(length(uv));
+
+      float ang = atan(main.x,main.y);
+
+      float f0 = .3/(length(uv-pos)*16.0+1.0);
+
+      f0 = f0*(sin(noise(sin(ang*3.9-(animated ? time : 0.0) * 0.3) * starPoints))*.2 );
+
+      float f1 = max(0.01-pow(length(uv+1.2*pos),1.9),.0)*7.0;
+
+      float f2 = max(.9/(10.0+32.0*pow(length(uvd+0.99*pos),2.0)),.0)*0.35;
+      float f22 = max(.9/(11.0+32.0*pow(length(uvd+0.85*pos),2.0)),.0)*0.23;
+      float f23 = max(.9/(12.0+32.0*pow(length(uvd+0.95*pos),2.0)),.0)*0.6;
+
+      vec2 uvx = mix(uv,uvd, 0.1);
+
+      float f4 = max(0.01-pow(length(uvx+0.4*pos),2.9),.0)*4.02;
+      float f42 = max(0.0-pow(length(uvx+0.45*pos),2.9),.0)*4.1;
+      float f43 = max(0.01-pow(length(uvx+0.5*pos),2.9),.0)*4.6;
+
+      uvx = mix(uv,uvd,-.4);
+
+      float f5 = max(0.01-pow(length(uvx+0.1*pos),5.5),.0)*2.0;
+      float f52 = max(0.01-pow(length(uvx+0.2*pos),5.5),.0)*2.0;
+      float f53 = max(0.01-pow(length(uvx+0.1*pos),5.5),.0)*2.0;
+
+      uvx = mix(uv,uvd, 2.1);
+
+      float f6 = max(0.01-pow(length(uvx-0.3*pos),1.61),.0)*3.159;
+      float f62 = max(0.01-pow(length(uvx-0.325*pos),1.614),.0)*3.14;
+      float f63 = max(0.01-pow(length(uvx-0.389*pos),1.623),.0)*3.12;
+
+      vec3 c = vec3(glare(uv,pos, glareSize));
+
+      vec2 prot;
+
+      if(animated){
+        prot = rotateUV(uv - pos, (time * 0.1));
+      } else if(anamorphic){
+        prot = rotateUV(uv - pos, 1.570796);
+      } else {
+        prot = uv - pos;
+      }
+
+      c += drawflare(prot, (anamorphic ? flareSize * 10. : flareSize), 0.1, time, 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(uvd)+.09);
+      c+=vec3(f0);
+
+      return c;
+    }
+
+    vec3 cc(vec3 color, float factor,float factor2)
+    {
+      float w = color.x+color.y+color.z;
+      return mix(color,vec3(w)*factor,w*factor2);
+    }
+
+    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 regShape(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 circle(vec2 p, float size, float decay, vec3 color, vec3 color2, float dist, vec2 position)
+    {
+      float l = length(p + position*(dist*2.))+size/2.;
+      float l2 = length(p + position*(dist*4.))+size/3.;
+
+      float c = max(0.01-pow(length(p + position*dist), size*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-position*dist/.5)*1., .95), 0.0)/20.;
+      float s = max(0.02-pow(regShape(p*5. + position*dist*5. + decay, 6) , 1.), 0.0)*1.5;
+
+      color = cos(vec3(0.44, .24, .2)*16. + dist/8.)*0.5+.5;
+      vec3 f = c*color;
+      f += c1*color;
+      f += c2*color;
+      f +=  s*color;
+      return f;
+    }
+
+    vec4 getLensColor(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 dirtNoise(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*dirtNoise(p); p = m*p*2.02;
+      f += 0.2500*dirtNoise(p); p = m*p*2.03;
+      f += 0.1250*dirtNoise(p); p = m*p*2.01;
+      f += 0.0625*dirtNoise(p);
+      return f/0.9375;
+    }
+
+    vec4 getLensStar(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 getLensDirt(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 textureLimited(sampler2D tex, vec2 texCoord){
+      if(((texCoord.x < 0.) || (texCoord.y < 0.)) || ((texCoord.x > 1.) || (texCoord.y > 1.))){
+        return vec4(0.0);
+      }else{
+        return texture(tex, texCoord);
+      }
+    }
+
+    vec4 textureDistorted(sampler2D tex, vec2 texCoord, vec2 direction, vec3 distortion) {
+      return vec4(textureLimited(tex, (texCoord + (direction * distortion.r))).r,
+                  textureLimited(tex, (texCoord + (direction * distortion.g))).g,
+                  textureLimited(tex, (texCoord + (direction * distortion.b))).b,
+                  1.0);
+    }
+
+    vec4 getStartBurst(){
+      vec2 aspectTexCoord = vec2(1.0) - (((vTexCoord - vec2(0.5)) * vec2(1.0)) + vec2(0.5));
+      vec2 texCoord = vec2(1.0) - vTexCoord;
+      vec2 ghostVec = (vec2(0.5) - texCoord) * 0.3 - lensPosition;
+      vec2 ghostVecAspectNormalized = normalize(ghostVec * vec2(1.0)) * vec2(1.0);
+      vec2 haloVec = normalize(ghostVec) * 0.6;
+      vec2 haloVecAspectNormalized = ghostVecAspectNormalized * 0.6;
+      vec2 texelSize = vec2(1.0) / vec2(screenRes.xy);
+      vec3 distortion = 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 = texCoord + (ghostVec * float(i));
+        c += textureDistorted(lensDirtTexture, offset, ghostVecAspectNormalized, distortion) * pow(max(0.0, 1.0 - (length(vec2(0.5) - offset) / length(vec2(0.5)))), 10.0);
+      }
+      vec2 haloOffset = texCoord + haloVecAspectNormalized;
+      return (c * getLensColor((length(vec2(0.5) - aspectTexCoord) / length(vec2(haloScale))))) +
+            (textureDistorted(lensDirtTexture, haloOffset, ghostVecAspectNormalized, distortion) * pow(max(0.0, 1.0 - (length(vec2(0.5) - haloOffset) / length(vec2(0.5)))), 10.0));
+    }
+
+    void mainImage(vec4 inputColor, vec2 uv, out vec4 outputColor)
+    {
+      vec2 myUV = uv -0.5;
+      myUV.y *= screenRes.y/screenRes.x;
+      vec2 finalLensPosition = lensPosition * 0.5;
+      finalLensPosition.y *= screenRes.y/screenRes.x;
+
+      vec3 finalColor = LensFlare(myUV, finalLensPosition) * 20.0 * colorGain / 256.;
+
+      if(aditionalStreaks){
+        vec3 circColor = vec3(0.9, 0.2, 0.1);
+        vec3 circColor2 = vec3(0.3, 0.1, 0.9);
+
+        for(float i=0.;i<10.;i++){
+          finalColor += circle(myUV, pow(rnd(i*2000.)*2.8, .1)+1.41, 0.0, circColor+i , circColor2+i, rnd(i*20.)*3.+0.2-.5, lensPosition);
+        }
+      }
+
+      if(secondaryGhosts){
+        vec3 altGhosts = vec3(0);
+        altGhosts += renderhex(myUV, -lensPosition*0.25, ghostScale * 1.4, vec3(0.25,0.35,0));
+        altGhosts += renderhex(myUV, lensPosition*0.25, ghostScale * 0.5, vec3(1,0.5,0.5));
+        altGhosts += renderhex(myUV, lensPosition*0.1, ghostScale * 1.6, vec3(1,1,1));
+        altGhosts += renderhex(myUV, lensPosition*1.8, ghostScale * 2.0, vec3(0,0.5,0.75));
+        altGhosts += renderhex(myUV, lensPosition*1.25, ghostScale * 0.8, vec3(1,1,0.5));
+        altGhosts += renderhex(myUV, -lensPosition*1.25, ghostScale * 5.0, vec3(0.5,0.5,0.25));
+
+        altGhosts += fpow(1.0 - abs(distance(lensPosition*0.8,myUV) - 0.7),0.985)*colorGain / 2100.;
+        finalColor += altGhosts;
+      }
 
-  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);}
+      if(starBurst){
+        vTexCoord = myUV + 0.5;
+        vec4 lensMod = getLensDirt(myUV);
+        float tooBright = 1.0 - (clamp(0.5, 0.0, 0.5) * 2.0);
+        float tooDark = clamp(0.5 - 0.5, 0.0, 0.5) * 2.0;
+        lensMod += mix(lensMod, pow(lensMod * 2.0, vec4(2.0)) * 0.5, tooBright);
+        float lensStarRotationAngle = ((myUV.x + myUV.y)) * (1.0 / 6.0);
+        vec2 lensStarTexCoord = (mat2(cos(lensStarRotationAngle), -sin(lensStarRotationAngle), sin(lensStarRotationAngle), cos(lensStarRotationAngle)) * vTexCoord);
+        lensMod += getLensStar(lensStarTexCoord) * 2.;
+
+        finalColor += clamp((lensMod.rgb * getStartBurst().rgb ), 0.01, 1.0);
+      }
+
+      if(enabled){
+        outputColor = vec4(mix(finalColor, vec3(.0), opacity) + inputColor.rgb, inputColor.a);
+      } else {
+        outputColor = vec4(inputColor);
+      }
+    }
 `,
 };
 /**
@@ -1341,7 +1803,7 @@ class LensFlareEffect extends Effect {
      * @param options.enabled - Whether the effect is enabled
      * @param options.glareSize - Size of the glare
      * @param options.lensPosition - Position of the lens on screen
-     * @param options.iResolution - Resolution of the effect
+     * @param options.screenRes - Resolution of the effect
      * @param options.starPoints - Number of points in the star pattern
      * @param options.flareSize - Size of individual flares
      * @param options.flareSpeed - Animation speed of flares
@@ -1357,15 +1819,15 @@ class LensFlareEffect extends Effect {
      * @param options.opacity - Opacity of the effect
      * @param options.starBurst - Enable star burst 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.0, opacity = 1.0, starBurst = false, } = {}) {
+    constructor({ blendFunction = BlendFunction.NORMAL, enabled = true, glareSize = 0.2, lensPosition = [0.01, 0.01], screenRes = [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.0, opacity = 1.0, starBurst = false, } = {}) {
         super('LensFlareEffect', LensFlareShader.fragmentShader, {
             blendFunction,
             uniforms: 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)],
+                ['time', new THREE.Uniform(0)],
+                ['screenRes', new THREE.Uniform(screenRes)],
                 ['starPoints', new THREE.Uniform(starPoints)],
                 ['flareSize', new THREE.Uniform(flareSize)],
                 ['flareSpeed', new THREE.Uniform(flareSpeed)],
@@ -1391,9 +1853,9 @@ class LensFlareEffect extends Effect {
      * @param deltaTime - Time elapsed since last frame
      */
     update(_renderer, _inputBuffer, deltaTime) {
-        const iTime = this.uniforms.get('iTime');
-        if (iTime) {
-            iTime.value += deltaTime;
+        const time = this.uniforms.get('time');
+        if (time) {
+            time.value += deltaTime;
         }
     }
 }
@@ -1447,10 +1909,10 @@ class NgtpLensFlare {
                 this.store.viewport.width(),
                 this.store.viewport.height(),
             ];
-            const iResolution = lensFlareEffect.uniforms.get('iResolution');
-            if (iResolution) {
-                iResolution.value.x = width;
-                iResolution.value.y = height;
+            const screenRes = lensFlareEffect.uniforms.get('screenRes');
+            if (screenRes) {
+                screenRes.value.x = width;
+                screenRes.value.y = height;
             }
         });
         effect((onCleanup) => {
@@ -1885,6 +2347,125 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.6", ngImpor
                 }]
         }], ctorParameters: () => [], propDecorators: { options: [{ type: i0.Input, args: [{ isSignal: true, alias: "options", required: false }] }] } });
 
+const RampShader = {
+    fragmentShader: /* language=glsl glsl */ `
+    uniform int rampType;
+
+    uniform vec2 rampStart;
+    uniform vec2 rampEnd;
+
+    uniform vec4 startColor;
+    uniform vec4 endColor;
+
+    uniform float rampBias;
+    uniform float rampGain;
+
+    uniform bool rampMask;
+    uniform bool rampInvert;
+
+    float getBias(float time, float bias) {
+      return time / (((1.0 / bias) - 2.0) * (1.0 - time) + 1.0);
+    }
+
+    float getGain(float time, float gain) {
+      if (time < 0.5)
+        return getBias(time * 2.0, gain) / 2.0;
+      else
+        return getBias(time * 2.0 - 1.0, 1.0 - gain) / 2.0 + 0.5;
+    }
+
+    void mainImage(const in vec4 inputColor, const in vec2 uv, out vec4 outputColor) {
+      vec2 centerPixel = uv * resolution;
+      vec2 startPixel = rampStart * resolution;
+      vec2 endPixel = rampEnd * resolution;
+
+      float rampAlpha;
+
+      if (rampType == 1) {
+        vec2 fuv = centerPixel / resolution.y;
+        vec2 suv = startPixel / resolution.y;
+        vec2 euv = endPixel / resolution.y;
+
+        float radius = length(suv - euv);
+        float falloff = length(fuv - suv);
+        rampAlpha = smoothstep(0.0, radius, falloff);
+      } else {
+        float radius = length(startPixel - endPixel);
+        vec2 direction = normalize(vec2(endPixel.x - startPixel.x, -(startPixel.y - endPixel.y)));
+
+        float fade = dot(centerPixel - startPixel, direction);
+        if (rampType == 2) fade = abs(fade);
+
+        rampAlpha = smoothstep(0.0, 1.0, fade / radius);
+      }
+
+      rampAlpha = abs((rampInvert ? 1.0 : 0.0) - getBias(rampAlpha, rampBias) * getGain(rampAlpha, rampGain));
+
+      if (rampMask) {
+        vec4 inputBuff = texture2D(inputBuffer, uv);
+        outputColor = mix(inputBuff, inputColor, rampAlpha);
+      } else {
+        outputColor = mix(startColor, endColor, rampAlpha);
+      }
+    }
+  `,
+};
+var RampType;
+(function (RampType) {
+    RampType[RampType["Linear"] = 0] = "Linear";
+    RampType[RampType["Radial"] = 1] = "Radial";
+    RampType[RampType["MirroredLinear"] = 2] = "MirroredLinear";
+})(RampType || (RampType = {}));
+class RampEffect extends Effect {
+    constructor({ rampType = RampType.Linear, rampStart = [0.5, 0.5], rampEnd = [1, 1], startColor = [0, 0, 0, 1], endColor = [1, 1, 1, 1], rampBias = 0.5, rampGain = 0.5, rampMask = false, rampInvert = false, ...params } = {}) {
+        super('RampEffect', RampShader.fragmentShader, {
+            ...params,
+            uniforms: new Map([
+                ['rampType', new THREE.Uniform(rampType)],
+                ['rampStart', new THREE.Uniform(rampStart)],
+                ['rampEnd', new THREE.Uniform(rampEnd)],
+                ['startColor', new THREE.Uniform(startColor)],
+                ['endColor', new THREE.Uniform(endColor)],
+                ['rampBias', new THREE.Uniform(rampBias)],
+                ['rampGain', new THREE.Uniform(rampGain)],
+                ['rampMask', new THREE.Uniform(rampMask)],
+                ['rampInvert', new THREE.Uniform(rampInvert)],
+            ]),
+        });
+    }
+}
+extend({ RampEffect });
+class NgtpRamp {
+    constructor() {
+        this.options = input({}, ...(ngDevMode ? [{ debugName: "options" }] : []));
+        this.hostEffect = inject(NgtpEffect, { host: true });
+        this.effectRef = viewChild('effect', ...(ngDevMode ? [{ debugName: "effectRef" }] : []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.6", ngImport: i0, type: NgtpRamp, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "21.1.6", type: NgtpRamp, isStandalone: true, selector: "ngtp-ramp", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "effectRef", first: true, predicate: ["effect"], descendants: true, isSignal: true }], hostDirectives: [{ directive: NgtpEffect, inputs: ["blendFunction", "blendFunction", "opacity", "opacity"] }], ngImport: i0, template: `
+		<ngt-ramp-effect #effect *args="[options()]" [camera]="hostEffect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-ramp-effect>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }, { kind: "component", type: NgtpEffectBlendMode, selector: "ngtp-effect-blend-mode" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.6", ngImport: i0, type: NgtpRamp, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtp-ramp',
+                    template: `
+		<ngt-ramp-effect #effect *args="[options()]" [camera]="hostEffect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-ramp-effect>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs, NgtpEffectBlendMode],
+                    hostDirectives: [{ directive: NgtpEffect, inputs: ['blendFunction', 'opacity'] }],
+                }]
+        }], propDecorators: { options: [{ type: i0.Input, args: [{ isSignal: true, alias: "options", required: false }] }], effectRef: [{ type: i0.ViewChild, args: ['effect', { isSignal: true }] }] } });
+
 const defaultOptions$1 = {
     density: 1.25,
 };
@@ -2176,6 +2757,65 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.6", ngImpor
                 }]
         }], ctorParameters: () => [], propDecorators: { options: [{ type: i0.Input, args: [{ isSignal: true, alias: "options", required: false }] }], effectRef: [{ type: i0.ViewChild, args: ['effect', { isSignal: true }] }] } });
 
+class NgtpSSAO {
+    constructor() {
+        this.options = input({}, ...(ngDevMode ? [{ debugName: "options" }] : []));
+        this.effectComposer = inject(NgtpEffectComposer);
+        this.effect = computed(() => {
+            const [normalPass, downSamplingPass] = [
+                this.effectComposer.normalPass(),
+                this.effectComposer.downSamplingPass(),
+            ];
+            if (normalPass === null && downSamplingPass === null) {
+                console.error('[NGT Postprocessing] Please enable the NormalPass in the EffectComposer in order to use SSAO.');
+                return null;
+            }
+            const [camera, options] = [this.effectComposer.camera(), this.options()];
+            return new SSAOEffect(camera, normalPass && !downSamplingPass ? normalPass.texture : null, {
+                blendFunction: BlendFunction.MULTIPLY,
+                samples: 30,
+                rings: 4,
+                distanceThreshold: 1.0,
+                distanceFalloff: 0.0,
+                rangeThreshold: 0.5,
+                rangeFalloff: 0.1,
+                luminanceInfluence: 0.9,
+                radius: 20,
+                bias: 0.5,
+                intensity: 1.0,
+                color: undefined,
+                // @ts-expect-error - normalDepthBuffer is not in the types but is supported
+                normalDepthBuffer: downSamplingPass ? downSamplingPass.texture : null,
+                resolutionScale: 1,
+                depthAwareUpsampling: true,
+                ...options,
+            });
+        }, ...(ngDevMode ? [{ debugName: "effect" }] : []));
+        effect((onCleanup) => {
+            const ssaoEffect = this.effect();
+            if (!ssaoEffect)
+                return;
+            onCleanup(() => ssaoEffect.dispose());
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.6", ngImport: i0, type: NgtpSSAO, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.1.6", type: NgtpSSAO, isStandalone: true, selector: "ngtp-ssao", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+		<ngt-primitive *args="[effect()]" [dispose]="null" />
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.6", ngImport: i0, type: NgtpSSAO, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtp-ssao',
+                    template: `
+		<ngt-primitive *args="[effect()]" [dispose]="null" />
+	`,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [], propDecorators: { options: [{ type: i0.Input, args: [{ isSignal: true, alias: "options", required: false }] }] } });
+
 /**
  * Angular component that applies a shock wave distortion effect.
  *
@@ -2287,6 +2927,74 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.6", ngImpor
                 }]
         }], ctorParameters: () => [], propDecorators: { options: [{ type: i0.Input, args: [{ isSignal: true, alias: "options", required: false }] }], effectRef: [{ type: i0.ViewChild, args: ['effect', { isSignal: true }] }] } });
 
+class NgtpTexture {
+    constructor() {
+        this.options = input({}, ...(ngDevMode ? [{ debugName: "options" }] : []));
+        this.textureSrc = pick(this.options, 'textureSrc');
+        this.texture = pick(this.options, 'texture');
+        this.opacity = pick(this.options, 'opacity');
+        this.store = injectStore();
+        this.loadedTexture = loaderResource(() => THREE.TextureLoader, () => this.textureSrc() || '', {
+            onLoad: (texture) => {
+                texture.colorSpace = THREE.SRGBColorSpace;
+                texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
+            },
+        });
+        this.effect = computed(() => {
+            const { textureSrc: _, texture, opacity: __, ...options } = this.options();
+            const loaded = this.loadedTexture.value();
+            const t = loaded || texture;
+            if (!t)
+                return null;
+            return new TextureEffect({ ...options, texture: t });
+        }, ...(ngDevMode ? [{ debugName: "effect" }] : []));
+        effect(() => {
+            const effect = this.effect();
+            if (!effect)
+                return;
+            const opacity = this.opacity();
+            if (opacity === undefined)
+                return;
+            const invalidate = this.store.invalidate();
+            effect.blendMode.opacity.value = opacity;
+            invalidate();
+        });
+        effect(() => {
+            const effect = this.effect();
+            if (!effect)
+                return;
+            const texture = this.texture();
+            if (!texture)
+                return;
+            const invalidate = this.store.invalidate();
+            effect.texture = texture;
+            invalidate();
+        });
+        effect((onCleanup) => {
+            const effect = this.effect();
+            if (!effect)
+                return;
+            onCleanup(() => effect.dispose());
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.6", ngImport: i0, type: NgtpTexture, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.1.6", type: NgtpTexture, isStandalone: true, selector: "ngtp-texture", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+		<ngt-primitive *args="[effect()]" [dispose]="null" />
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.6", ngImport: i0, type: NgtpTexture, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtp-texture',
+                    template: `
+		<ngt-primitive *args="[effect()]" [dispose]="null" />
+	`,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [], propDecorators: { options: [{ type: i0.Input, args: [{ isSignal: true, alias: "options", required: false }] }] } });
+
 /**
  * Angular component that applies a tilt-shift blur effect.
  *
@@ -2716,5 +3424,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.6", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { ASCIIEffect, LensFlareEffect, NgtpASCII, NgtpBloom, NgtpBrightnessContrast, NgtpChromaticAberration, NgtpColorAverage, NgtpColorDepth, NgtpDepth, NgtpDepthOfField, NgtpDotScreen, NgtpEffect, NgtpEffectBlendMode, NgtpEffectComposer, NgtpFXAA, NgtpGlitch, NgtpGodRays, NgtpGrid, NgtpHueSaturation, NgtpLUT, NgtpLensFlare, NgtpNoise, NgtpOutline, NgtpPixelation, NgtpSMAA, NgtpScanline, NgtpSelectiveBloom, NgtpSepia, NgtpShockWave, NgtpTiltShift, NgtpTiltShift2, NgtpToneMapping, NgtpVignette, NgtpWater, TiltShift2Effect, WaterEffect, injectDefaultEffectOptions, provideDefaultEffectOptions };
+export { ASCIIEffect, LensFlareEffect, NgtpASCII, NgtpAutofocus, NgtpBloom, NgtpBrightnessContrast, NgtpChromaticAberration, NgtpColorAverage, NgtpColorDepth, NgtpDepth, NgtpDepthOfField, NgtpDotScreen, NgtpEffect, NgtpEffectBlendMode, NgtpEffectComposer, NgtpFXAA, NgtpGlitch, NgtpGodRays, NgtpGrid, NgtpHueSaturation, NgtpLUT, NgtpLensFlare, NgtpNoise, NgtpOutline, NgtpPixelation, NgtpRamp, NgtpSMAA, NgtpSSAO, NgtpScanline, NgtpSelectiveBloom, NgtpSepia, NgtpShockWave, NgtpTexture, NgtpTiltShift, NgtpTiltShift2, NgtpToneMapping, NgtpVignette, NgtpWater, RampEffect, RampType, TiltShift2Effect, WaterEffect, injectDefaultEffectOptions, provideDefaultEffectOptions };
 //# sourceMappingURL=angular-three-postprocessing.mjs.map