angular-three-postprocessing 2.0.0-beta.9 → 2.0.0

package/esm2022/lib/effects/scanline.mjs

@@ -0,0 +1,43 @@
+import { CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, Component, inject, input } from '@angular/core';
+import { NgtArgs, extend } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { BlendFunction, ScanlineEffect } from 'postprocessing';
+import { NgtpEffect, NgtpEffectBlendMode, NgtpEffectHostDirective, provideDefaultEffectOptions } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+extend({ ScanlineEffect });
+const defaultOptions = {
+    density: 1.25,
+};
+export class NgtpScanline {
+    constructor() {
+        this.effect = inject(NgtpEffect, { host: true });
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtpScanline, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.0", type: NgtpScanline, isStandalone: true, selector: "ngtp-scanline", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, providers: [provideDefaultEffectOptions({ blendFunction: BlendFunction.OVERLAY })], hostDirectives: [{ directive: i1.NgtpEffect, inputs: ["blendFunction", "blendFunction", "opacity", "opacity"] }], ngImport: i0, template: `
+		<ngt-scanline-effect *args="[options()]" [camera]="effect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-scanline-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: "18.2.0", ngImport: i0, type: NgtpScanline, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtp-scanline',
+                    template: `
+		<ngt-scanline-effect *args="[options()]" [camera]="effect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-scanline-effect>
+	`,
+                    standalone: true,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs, NgtpEffectBlendMode],
+                    hostDirectives: [NgtpEffectHostDirective],
+                    providers: [provideDefaultEffectOptions({ blendFunction: BlendFunction.OVERLAY })],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/effects/sepia.mjs

@@ -0,0 +1,38 @@
+import { CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, Component, inject, input } from '@angular/core';
+import { NgtArgs, extend } from 'angular-three';
+import { SepiaEffect } from 'postprocessing';
+import { NgtpEffect, NgtpEffectBlendMode, NgtpEffectHostDirective } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+extend({ SepiaEffect });
+export class NgtpSepia {
+    constructor() {
+        this.effect = inject(NgtpEffect, { host: true });
+        this.options = input({});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtpSepia, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.0", type: NgtpSepia, isStandalone: true, selector: "ngtp-sepia", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, hostDirectives: [{ directive: i1.NgtpEffect, inputs: ["blendFunction", "blendFunction", "opacity", "opacity"] }], ngImport: i0, template: `
+		<ngt-sepia-effect *args="[options()]" [camera]="effect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-sepia-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: "18.2.0", ngImport: i0, type: NgtpSepia, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtp-sepia',
+                    template: `
+		<ngt-sepia-effect *args="[options()]" [camera]="effect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-sepia-effect>
+	`,
+                    standalone: true,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs, NgtpEffectBlendMode],
+                    hostDirectives: [NgtpEffectHostDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/effects/shock-wave.mjs

@@ -0,0 +1,38 @@
+import { CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, Component, inject, input } from '@angular/core';
+import { NgtArgs, extend } from 'angular-three';
+import { ShockWaveEffect } from 'postprocessing';
+import { NgtpEffect, NgtpEffectBlendMode, NgtpEffectHostDirective } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+extend({ ShockWaveEffect });
+export class NgtpShockWave {
+    constructor() {
+        this.effect = inject(NgtpEffect, { host: true });
+        this.options = input({});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtpShockWave, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.0", type: NgtpShockWave, isStandalone: true, selector: "ngtp-shock-wave", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, hostDirectives: [{ directive: i1.NgtpEffect, inputs: ["blendFunction", "blendFunction", "opacity", "opacity"] }], ngImport: i0, template: `
+		<ngt-shock-wave-effect *args="[options()]" [camera]="effect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-shock-wave-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: "18.2.0", ngImport: i0, type: NgtpShockWave, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtp-shock-wave',
+                    template: `
+		<ngt-shock-wave-effect *args="[options()]" [camera]="effect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-shock-wave-effect>
+	`,
+                    standalone: true,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs, NgtpEffectBlendMode],
+                    hostDirectives: [NgtpEffectHostDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/effects/smaa.mjs

@@ -0,0 +1,38 @@
+import { CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, Component, inject, input } from '@angular/core';
+import { NgtArgs, extend } from 'angular-three';
+import { SMAAEffect } from 'postprocessing';
+import { NgtpEffect, NgtpEffectBlendMode, NgtpEffectHostDirective } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+extend({ SMAAEffect });
+export class NgtpSMAA {
+    constructor() {
+        this.effect = inject(NgtpEffect, { host: true });
+        this.options = input({});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtpSMAA, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.0", type: NgtpSMAA, isStandalone: true, selector: "ngtp-smaa", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, hostDirectives: [{ directive: i1.NgtpEffect, inputs: ["blendFunction", "blendFunction", "opacity", "opacity"] }], ngImport: i0, template: `
+		<ngt-sMAA-effect *args="[options()]" [camera]="effect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-sMAA-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: "18.2.0", ngImport: i0, type: NgtpSMAA, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtp-smaa',
+                    template: `
+		<ngt-sMAA-effect *args="[options()]" [camera]="effect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-sMAA-effect>
+	`,
+                    standalone: true,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs, NgtpEffectBlendMode],
+                    hostDirectives: [NgtpEffectHostDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/effects/tilt-shift-2.mjs

@@ -0,0 +1,121 @@
+import { CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, Component, inject, input } from '@angular/core';
+import { NgtArgs, extend } from 'angular-three';
+import { BlendFunction, Effect, EffectAttribute } from 'postprocessing';
+import { Uniform } from 'three';
+import { NgtpEffect, NgtpEffectBlendMode, NgtpEffectHostDirective, provideDefaultEffectOptions } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+const TiltShiftShader = {
+    fragmentShader: /* language=glsl glsl */ `
+
+    // original shader by Evan Wallace
+
+    #define MAX_ITERATIONS 100
+
+    uniform float blur;
+    uniform float taper;
+    uniform vec2 start;
+    uniform vec2 end;
+    uniform vec2 direction;
+    uniform int samples;
+
+    float random(vec3 scale, float seed) {
+        /* use the fragment position for a different seed per-pixel */
+        return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
+    }
+
+    void mainImage(const in vec4 inputColor, const in vec2 uv, out vec4 outputColor) {
+        vec4 color = vec4(0.0);
+        float total = 0.0;
+        vec2 startPixel = vec2(start.x * resolution.x, start.y * resolution.y);
+        vec2 endPixel = vec2(end.x * resolution.x, end.y * resolution.y);
+        float f_samples = float(samples);
+        float half_samples = f_samples / 2.0;
+
+        // use screen diagonal to normalize blur radii
+        float maxScreenDistance = distance(vec2(0.0), resolution); // diagonal distance
+        float gradientRadius = taper * (maxScreenDistance);
+        float blurRadius = blur * (maxScreenDistance / 16.0);
+
+        /* randomize the lookup values to hide the fixed number of samples */
+        float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
+        vec2 normal = normalize(vec2(startPixel.y - endPixel.y, endPixel.x - startPixel.x));
+        float radius = smoothstep(0.0, 1.0, abs(dot(uv * resolution - startPixel, normal)) / gradientRadius) * blurRadius;
+
+        #pragma unroll_loop_start
+        for (int i = 0; i <= MAX_ITERATIONS; i++) {
+            if (i >= samples) { break; } // return early if over sample count
+            float f_i = float(i);
+            float s_i = -half_samples + f_i;
+            float percent = (s_i + offset - 0.5) / half_samples;
+            float weight = 1.0 - abs(percent);
+            vec4 sample_i = texture2D(inputBuffer, uv + normalize(direction) / resolution * percent * radius);
+            /* switch to pre-multiplied alpha to correctly blur transparent images */
+            sample_i.rgb *= sample_i.a;
+            color += sample_i * weight;
+            total += weight;
+        }
+        #pragma unroll_loop_end
+
+        outputColor = color / total;
+
+        /* switch back from pre-multiplied alpha */
+        outputColor.rgb /= outputColor.a + 0.00001;
+    }
+    `,
+};
+export class TiltShift2Effect extends Effect {
+    constructor({ blendFunction = BlendFunction.NORMAL, blur = 0.15, // [0, 1], can go beyond 1 for extra
+    taper = 0.5, // [0, 1], can go beyond 1 for extra
+    start = [0.5, 0.0], // [0,1] percentage x,y of screenspace
+    end = [0.5, 1.0], // [0,1] percentage x,y of screenspace
+    samples = 10.0, // number of blur samples
+    direction = [1, 1], // direction of blur
+     } = {}) {
+        super('TiltShiftEffect', TiltShiftShader.fragmentShader, {
+            blendFunction,
+            attributes: EffectAttribute.CONVOLUTION,
+            uniforms: new Map([
+                ['blur', new Uniform(blur)],
+                ['taper', new Uniform(taper)],
+                ['start', new Uniform(start)],
+                ['end', new Uniform(end)],
+                ['samples', new Uniform(samples)],
+                ['direction', new Uniform(direction)],
+            ]),
+        });
+    }
+}
+extend({ TiltShift2Effect });
+export class NgtpTiltShift2 {
+    constructor() {
+        this.effect = inject(NgtpEffect, { host: true });
+        this.options = input({});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtpTiltShift2, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.0", type: NgtpTiltShift2, isStandalone: true, selector: "ngtp-tilt-shift2", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, providers: [provideDefaultEffectOptions({ blendFunction: BlendFunction.NORMAL })], hostDirectives: [{ directive: i1.NgtpEffect, inputs: ["blendFunction", "blendFunction", "opacity", "opacity"] }], ngImport: i0, template: `
+		<ngt-tilt-shift2-effect *args="[options()]" [camera]="effect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-tilt-shift2-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: "18.2.0", ngImport: i0, type: NgtpTiltShift2, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtp-tilt-shift2',
+                    standalone: true,
+                    template: `
+		<ngt-tilt-shift2-effect *args="[options()]" [camera]="effect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-tilt-shift2-effect>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs, NgtpEffectBlendMode],
+                    hostDirectives: [NgtpEffectHostDirective],
+                    providers: [provideDefaultEffectOptions({ blendFunction: BlendFunction.NORMAL })],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tilt-shift-2.js","sourceRoot":"","sources":["../../../../../../libs/postprocessing/src/lib/effects/tilt-shift-2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC1G,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,2BAA2B,EAAE,MAAM,WAAW,CAAC;;;AAElH,MAAM,eAAe,GAAG;IACvB,cAAc,EAAE,wBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAwDrC;CACJ,CAAC;AAEF,MAAM,OAAO,gBAAiB,SAAQ,MAAM;IAC3C,YAAY,EACX,aAAa,GAAG,aAAa,CAAC,MAAM,EACpC,IAAI,GAAG,IAAI,EAAE,oCAAoC;IACjD,KAAK,GAAG,GAAG,EAAE,oCAAoC;IACjD,KAAK,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,sCAAsC;IAC1D,GAAG,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,sCAAsC;IACxD,OAAO,GAAG,IAAI,EAAE,yBAAyB;IACzC,SAAS,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,oBAAoB;MACxC,GAAG,EAAE;QACL,KAAK,CAAC,iBAAiB,EAAE,eAAe,CAAC,cAAc,EAAE;YACxD,aAAa;YACb,UAAU,EAAE,eAAe,CAAC,WAAW;YACvC,QAAQ,EAAE,IAAI,GAAG,CAAqC;gBACrD,CAAC,MAAM,EAAE,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;gBAC3B,CAAC,OAAO,EAAE,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC;gBAC7B,CAAC,OAAO,EAAE,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC;gBAC7B,CAAC,KAAK,EAAE,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;gBACzB,CAAC,SAAS,EAAE,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;gBACjC,CAAC,WAAW,EAAE,IAAI,OAAO,CAAC,SAAS,CAAC,CAAC;aACrC,CAAC;SACF,CAAC,CAAC;IACJ,CAAC;CACD;AAID,MAAM,CAAC,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAiB7B,MAAM,OAAO,cAAc;IAf3B;QAgBC,WAAM,GAAG,MAAM,CAAC,UAAU,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QAC5C,YAAO,GAAG,KAAK,CAAC,EAAoD,CAAC,CAAC;KACtE;8GAHY,cAAc;kGAAd,cAAc,yMAFf,CAAC,2BAA2B,CAAC,EAAE,aAAa,EAAE,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,4IAVvE;;;;;EAKT,4DAGS,OAAO,gFAAE,mBAAmB;;2FAI1B,cAAc;kBAf1B,SAAS;mBAAC;oBACV,QAAQ,EAAE,kBAAkB;oBAC5B,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE;;;;;EAKT;oBACD,OAAO,EAAE,CAAC,sBAAsB,CAAC;oBACjC,eAAe,EAAE,uBAAuB,CAAC,MAAM;oBAC/C,OAAO,EAAE,CAAC,OAAO,EAAE,mBAAmB,CAAC;oBACvC,cAAc,EAAE,CAAC,uBAAuB,CAAC;oBACzC,SAAS,EAAE,CAAC,2BAA2B,CAAC,EAAE,aAAa,EAAE,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC;iBACjF","sourcesContent":["import { CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, Component, inject, input } from '@angular/core';\nimport { NgtArgs, extend } from 'angular-three';\nimport { BlendFunction, Effect, EffectAttribute } from 'postprocessing';\nimport { Uniform } from 'three';\nimport { NgtpEffect, NgtpEffectBlendMode, NgtpEffectHostDirective, provideDefaultEffectOptions } from '../effect';\n\nconst TiltShiftShader = {\n\tfragmentShader: /* language=glsl glsl */ `\n\n    // original shader by Evan Wallace\n\n    #define MAX_ITERATIONS 100\n\n    uniform float blur;\n    uniform float taper;\n    uniform vec2 start;\n    uniform vec2 end;\n    uniform vec2 direction;\n    uniform int samples;\n\n    float random(vec3 scale, float seed) {\n        /* use the fragment position for a different seed per-pixel */\n        return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n    }\n\n    void mainImage(const in vec4 inputColor, const in vec2 uv, out vec4 outputColor) {\n        vec4 color = vec4(0.0);\n        float total = 0.0;\n        vec2 startPixel = vec2(start.x * resolution.x, start.y * resolution.y);\n        vec2 endPixel = vec2(end.x * resolution.x, end.y * resolution.y);\n        float f_samples = float(samples);\n        float half_samples = f_samples / 2.0;\n\n        // use screen diagonal to normalize blur radii\n        float maxScreenDistance = distance(vec2(0.0), resolution); // diagonal distance\n        float gradientRadius = taper * (maxScreenDistance);\n        float blurRadius = blur * (maxScreenDistance / 16.0);\n\n        /* randomize the lookup values to hide the fixed number of samples */\n        float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n        vec2 normal = normalize(vec2(startPixel.y - endPixel.y, endPixel.x - startPixel.x));\n        float radius = smoothstep(0.0, 1.0, abs(dot(uv * resolution - startPixel, normal)) / gradientRadius) * blurRadius;\n\n        #pragma unroll_loop_start\n        for (int i = 0; i <= MAX_ITERATIONS; i++) {\n            if (i >= samples) { break; } // return early if over sample count\n            float f_i = float(i);\n            float s_i = -half_samples + f_i;\n            float percent = (s_i + offset - 0.5) / half_samples;\n            float weight = 1.0 - abs(percent);\n            vec4 sample_i = texture2D(inputBuffer, uv + normalize(direction) / resolution * percent * radius);\n            /* switch to pre-multiplied alpha to correctly blur transparent images */\n            sample_i.rgb *= sample_i.a;\n            color += sample_i * weight;\n            total += weight;\n        }\n        #pragma unroll_loop_end\n\n        outputColor = color / total;\n\n        /* switch back from pre-multiplied alpha */\n        outputColor.rgb /= outputColor.a + 0.00001;\n    }\n    `,\n};\n\nexport class TiltShift2Effect extends Effect {\n\tconstructor({\n\t\tblendFunction = BlendFunction.NORMAL,\n\t\tblur = 0.15, // [0, 1], can go beyond 1 for extra\n\t\ttaper = 0.5, // [0, 1], can go beyond 1 for extra\n\t\tstart = [0.5, 0.0], // [0,1] percentage x,y of screenspace\n\t\tend = [0.5, 1.0], // [0,1] percentage x,y of screenspace\n\t\tsamples = 10.0, // number of blur samples\n\t\tdirection = [1, 1], // direction of blur\n\t} = {}) {\n\t\tsuper('TiltShiftEffect', TiltShiftShader.fragmentShader, {\n\t\t\tblendFunction,\n\t\t\tattributes: EffectAttribute.CONVOLUTION,\n\t\t\tuniforms: new Map<string, Uniform<number | number[]>>([\n\t\t\t\t['blur', new Uniform(blur)],\n\t\t\t\t['taper', new Uniform(taper)],\n\t\t\t\t['start', new Uniform(start)],\n\t\t\t\t['end', new Uniform(end)],\n\t\t\t\t['samples', new Uniform(samples)],\n\t\t\t\t['direction', new Uniform(direction)],\n\t\t\t]),\n\t\t});\n\t}\n}\n\nexport type TiltShift2EffectOptions = Partial<NonNullable<ConstructorParameters<typeof TiltShift2Effect>[0]>>;\n\nextend({ TiltShift2Effect });\n\n@Component({\n\tselector: 'ngtp-tilt-shift2',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-tilt-shift2-effect *args=\"[options()]\" [camera]=\"effect.camera()\">\n\t\t\t<ngtp-effect-blend-mode />\n\t\t\t<ng-content />\n\t\t</ngt-tilt-shift2-effect>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [NgtArgs, NgtpEffectBlendMode],\n\thostDirectives: [NgtpEffectHostDirective],\n\tproviders: [provideDefaultEffectOptions({ blendFunction: BlendFunction.NORMAL })],\n})\nexport class NgtpTiltShift2 {\n\teffect = inject(NgtpEffect, { host: true });\n\toptions = input({} as Omit<TiltShift2EffectOptions, 'blendFunction'>);\n}\n"]}

package/esm2022/lib/effects/tilt-shift.mjs

@@ -0,0 +1,39 @@
+import { CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, Component, inject, input } from '@angular/core';
+import { NgtArgs, extend } from 'angular-three';
+import { BlendFunction, TiltShiftEffect } from 'postprocessing';
+import { NgtpEffect, NgtpEffectBlendMode, NgtpEffectHostDirective, provideDefaultEffectOptions } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+extend({ TiltShiftEffect });
+export class NgtpTiltShift {
+    constructor() {
+        this.effect = inject(NgtpEffect, { host: true });
+        this.options = input({});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtpTiltShift, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.0", type: NgtpTiltShift, isStandalone: true, selector: "ngtp-tilt-shift", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, providers: [provideDefaultEffectOptions({ blendFunction: BlendFunction.ADD })], hostDirectives: [{ directive: i1.NgtpEffect, inputs: ["blendFunction", "blendFunction", "opacity", "opacity"] }], ngImport: i0, template: `
+		<ngt-tilt-shift-effect *args="[options()]" [camera]="effect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-tilt-shift-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: "18.2.0", ngImport: i0, type: NgtpTiltShift, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtp-tilt-shift',
+                    template: `
+		<ngt-tilt-shift-effect *args="[options()]" [camera]="effect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-tilt-shift-effect>
+	`,
+                    standalone: true,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs, NgtpEffectBlendMode],
+                    hostDirectives: [NgtpEffectHostDirective],
+                    providers: [provideDefaultEffectOptions({ blendFunction: BlendFunction.ADD })],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/effects/vignette.mjs

@@ -0,0 +1,38 @@
+import { CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, Component, inject, input } from '@angular/core';
+import { NgtArgs, extend } from 'angular-three';
+import { VignetteEffect } from 'postprocessing';
+import { NgtpEffect, NgtpEffectBlendMode, NgtpEffectHostDirective } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+extend({ VignetteEffect });
+export class NgtpVignette {
+    constructor() {
+        this.effect = inject(NgtpEffect, { host: true });
+        this.options = input({});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtpVignette, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.0", type: NgtpVignette, isStandalone: true, selector: "ngtp-vignette", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, hostDirectives: [{ directive: i1.NgtpEffect, inputs: ["blendFunction", "blendFunction", "opacity", "opacity"] }], ngImport: i0, template: `
+		<ngt-vignette-effect *args="[options()]" [camera]="effect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-vignette-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: "18.2.0", ngImport: i0, type: NgtpVignette, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtp-vignette',
+                    template: `
+		<ngt-vignette-effect *args="[options()]" [camera]="effect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-vignette-effect>
+	`,
+                    standalone: true,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs, NgtpEffectBlendMode],
+                    hostDirectives: [NgtpEffectHostDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/effects/water.mjs

@@ -0,0 +1,64 @@
+import { CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, Component, inject, input } from '@angular/core';
+import { NgtArgs, extend } from 'angular-three';
+import { BlendFunction, Effect, EffectAttribute } from 'postprocessing';
+import { Uniform } from 'three';
+import { NgtpEffect, NgtpEffectBlendMode, NgtpEffectHostDirective, provideDefaultEffectOptions } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+const WaterShader = {
+    fragmentShader: /* language=glsl glsl */ `
+  uniform float factor;
+  void mainImage(const in vec4 inputColor, const in vec2 uv, out vec4 outputColor) {
+    vec2 vUv = uv;
+    float frequency = 6.0 * factor;
+    float amplitude = 0.015 * factor;
+    float x = vUv.y * frequency + time * .7;
+    float y = vUv.x * frequency + time * .3;
+    vUv.x += cos(x+y) * amplitude * cos(y);
+    vUv.y += sin(x-y) * amplitude * cos(y);
+    vec4 rgba = texture2D(inputBuffer, vUv);
+    outputColor = rgba;
+  }`,
+};
+export class WaterEffect extends Effect {
+    constructor({ blendFunction = BlendFunction.NORMAL, factor = 0 } = {}) {
+        super('WaterEffect', WaterShader.fragmentShader, {
+            blendFunction,
+            attributes: EffectAttribute.CONVOLUTION,
+            uniforms: new Map([['factor', new Uniform(factor)]]),
+        });
+    }
+}
+extend({ WaterEffect });
+export class NgtpWater {
+    constructor() {
+        this.effect = inject(NgtpEffect, { host: true });
+        this.options = input({});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtpWater, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.0", type: NgtpWater, isStandalone: true, selector: "ngtp-water", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, providers: [provideDefaultEffectOptions({ blendFunction: BlendFunction.NORMAL })], hostDirectives: [{ directive: i1.NgtpEffect, inputs: ["blendFunction", "blendFunction", "opacity", "opacity"] }], ngImport: i0, template: `
+		<ngt-water-effect *args="[options()]" [camera]="effect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-water-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: "18.2.0", ngImport: i0, type: NgtpWater, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtp-water',
+                    standalone: true,
+                    template: `
+		<ngt-water-effect *args="[options()]" [camera]="effect.camera()">
+			<ngtp-effect-blend-mode />
+			<ng-content />
+		</ngt-water-effect>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs, NgtpEffectBlendMode],
+                    hostDirectives: [NgtpEffectHostDirective],
+                    providers: [provideDefaultEffectOptions({ blendFunction: BlendFunction.NORMAL })],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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