angular-three-postprocessing 2.0.0-beta.235 → 2.0.0-beta.236

package/lib/effects/glitch.d.ts

@@ -0,0 +1,30 @@
+import { NgtVector2 } from 'angular-three';
+import { GlitchEffect, GlitchMode } from 'postprocessing';
+import * as i0 from "@angular/core";
+export type GlitchOptions = NonNullable<ConstructorParameters<typeof GlitchEffect>[0]> & Partial<{
+    mode: GlitchMode;
+    active: boolean;
+    delay: NgtVector2;
+    duration: NgtVector2;
+    chromaticAberrationOffset: NgtVector2;
+    strength: NgtVector2;
+}>;
+export declare class NgtpGlitch {
+    autoEffect: (autoEffectCallback: (autoEffectInjector: import("@angular/core").Injector) => void | (() => void), options?: Omit<import("@angular/core").CreateEffectOptions, "injector"> | undefined) => import("@angular/core").EffectRef;
+    store: import("angular-three").NgtSignalStore<import("angular-three").NgtState>;
+    invalidate: import("@angular/core").Signal<(frames?: number | undefined) => void>;
+    effectRef: import("@angular/core").InputSignal<import("angular-three").NgtInjectedRef<GlitchEffect>>;
+    options: import("@angular/core").InputSignalWithTransform<GlitchOptions, "" | Partial<{
+        active: boolean;
+    }>>;
+    active: import("@angular/core").Signal<boolean | undefined>;
+    mode: import("@angular/core").Signal<GlitchMode | undefined>;
+    delay: import("@angular/core").Signal<import("three").Vector2>;
+    duration: import("@angular/core").Signal<import("three").Vector2>;
+    chromaticAberrationOffset: import("@angular/core").Signal<import("three").Vector2>;
+    strength: import("@angular/core").Signal<import("three").Vector2>;
+    effect: import("@angular/core").Signal<GlitchEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpGlitch, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpGlitch, "ngtp-glitch", never, { "effectRef": { "alias": "effectRef"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/effects/god-rays.d.ts

@@ -0,0 +1,38 @@
+import { ElementRef } from '@angular/core';
+import { GodRaysEffect } from 'postprocessing';
+import { Mesh, Points } from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtpGodRays {
+    autoEffect: (autoEffectCallback: (autoEffectInjector: import("@angular/core").Injector) => void | (() => void), options?: Omit<import("@angular/core").CreateEffectOptions, "injector"> | undefined) => import("@angular/core").EffectRef;
+    composerApi: import("@angular/core").Signal<{
+        composer: import("postprocessing").EffectComposer;
+        camera: import("three").Camera;
+        scene: import("three").Scene;
+        normalPass: import("postprocessing").NormalPass | null;
+        downSamplingPass: import("postprocessing").DepthDownsamplingPass | null;
+        resolutionScale: number | undefined;
+    }>;
+    effectRef: import("@angular/core").InputSignal<import("angular-three").NgtInjectedRef<GodRaysEffect>>;
+    options: import("@angular/core").InputSignal<{
+        blendFunction?: import("postprocessing").BlendFunction | undefined;
+        samples?: number | undefined;
+        density?: number | undefined;
+        decay?: number | undefined;
+        weight?: number | undefined;
+        exposure?: number | undefined;
+        clampMax?: number | undefined;
+        resolutionScale?: number | undefined;
+        resolutionX?: number | undefined;
+        resolutionY?: number | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        kernelSize?: import("postprocessing").KernelSize | undefined;
+        blur?: boolean | undefined;
+    } & {
+        sun: Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> | Points<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> | ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> | Points<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>;
+    }>;
+    effect: import("@angular/core").Signal<GodRaysEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpGodRays, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpGodRays, "ngtp-god-rays", never, { "effectRef": { "alias": "effectRef"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/effects/grid.d.ts

@@ -0,0 +1,24 @@
+import { GridEffect } from 'postprocessing';
+import * as i0 from "@angular/core";
+type GridOptions = NonNullable<ConstructorParameters<typeof GridEffect>[0]> & Partial<{
+    size: {
+        width: number;
+        height: number;
+    };
+}>;
+export declare class NgtpGrid {
+    autoEffect: (autoEffectCallback: (autoEffectInjector: import("@angular/core").Injector) => void | (() => void), options?: Omit<import("@angular/core").CreateEffectOptions, "injector"> | undefined) => import("@angular/core").EffectRef;
+    store: import("angular-three").NgtSignalStore<import("angular-three").NgtState>;
+    invalidate: import("@angular/core").Signal<(frames?: number | undefined) => void>;
+    effectRef: import("@angular/core").InputSignal<import("angular-three").NgtInjectedRef<GridEffect>>;
+    options: import("@angular/core").InputSignal<GridOptions>;
+    size: import("@angular/core").Signal<{
+        width: number;
+        height: number;
+    } | undefined>;
+    effect: import("@angular/core").Signal<GridEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpGrid, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpGrid, "ngtp-grid", never, { "effectRef": { "alias": "effectRef"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/effects/hue-saturation.d.ts

@@ -0,0 +1,15 @@
+import { HueSaturationEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type HueSaturationEffectOptions = Partial<NonNullable<ConstructorParameters<typeof HueSaturationEffect>[0]>>;
+export declare class NgtpHueSaturation {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        blendFunction?: import("postprocessing").BlendFunction | undefined;
+        hue?: number | undefined;
+        saturation?: number | undefined;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpHueSaturation, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpHueSaturation, "ngtp-hue-saturation", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; "effectRef": "effectRef"; }; outputs: {}; }]>;
+}

package/lib/effects/index.d.ts

@@ -1 +1,26 @@
+export * from './ascii';
 export * from './bloom';
+export * from './brightness-contrast';
+export * from './chromatic-abberation';
+export * from './color-average';
+export * from './color-depth';
+export * from './depth';
+export * from './depth-of-field';
+export * from './dot-screen';
+export * from './fxaa';
+export * from './glitch';
+export * from './god-rays';
+export * from './grid';
+export * from './hue-saturation';
+export * from './lens-flare';
+export * from './lut';
+export * from './noise';
+export * from './pixelation';
+export * from './scanline';
+export * from './sepia';
+export * from './shock-wave';
+export * from './smaa';
+export * from './tilt-shift';
+export * from './tilt-shift-2';
+export * from './vignette';
+export * from './water';

package/lib/effects/lens-flare.d.ts

@@ -0,0 +1,111 @@
+import { BlendFunction, Effect } from 'postprocessing';
+import { Color, Texture, Vector2, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+export declare class LensFlareEffect extends Effect {
+    constructor({ blendFunction, enabled, glareSize, lensPosition, iResolution, starPoints, flareSize, flareSpeed, flareShape, animated, anamorphic, colorGain, lensDirtTexture, haloScale, secondaryGhosts, aditionalStreaks, ghostScale, opacity, starBurst, }?: {
+        blendFunction?: BlendFunction | undefined;
+        enabled?: boolean | undefined;
+        glareSize?: number | undefined;
+        lensPosition?: number[] | undefined;
+        iResolution?: number[] | undefined;
+        starPoints?: number | undefined;
+        flareSize?: number | undefined;
+        flareSpeed?: number | undefined;
+        flareShape?: number | undefined;
+        animated?: boolean | undefined;
+        anamorphic?: boolean | undefined;
+        colorGain?: Color | undefined;
+        lensDirtTexture?: Texture | null | undefined;
+        haloScale?: number | undefined;
+        secondaryGhosts?: boolean | undefined;
+        aditionalStreaks?: boolean | undefined;
+        ghostScale?: number | undefined;
+        opacity?: number | undefined;
+        starBurst?: boolean | undefined;
+    });
+    update(_renderer: any, _inputBuffer: any, deltaTime: number): void;
+}
+export type LensFlareOptions = ConstructorParameters<typeof LensFlareEffect>[0] & {
+    position: Vector3;
+    followMouse: boolean;
+    smoothTime: number;
+};
+export declare class NgtpLensFlare {
+    autoEffect: (autoEffectCallback: (autoEffectInjector: import("@angular/core").Injector) => void | (() => void), options?: Omit<import("@angular/core").CreateEffectOptions, "injector"> | undefined) => import("@angular/core").EffectRef;
+    store: import("angular-three").NgtSignalStore<import("angular-three").NgtState>;
+    viewport: import("@angular/core").Signal<import("angular-three").NgtSize & {
+        initialDpr: number;
+        dpr: number;
+        factor: number;
+        distance: number;
+        aspect: number;
+    } & {
+        getCurrentViewport: (camera?: import("angular-three").NgtCamera | undefined, target?: Vector3 | [x: number, y: number, z: number] | undefined, size?: import("angular-three").NgtSize | undefined) => Omit<import("angular-three").NgtViewport, "dpr" | "initialDpr">;
+    }>;
+    raycaster: import("@angular/core").Signal<import("three").Raycaster>;
+    pointer: import("@angular/core").Signal<Vector2>;
+    composerApi: import("@angular/core").Signal<{
+        composer: import("postprocessing").EffectComposer;
+        camera: import("three").Camera;
+        scene: import("three").Scene;
+        normalPass: import("postprocessing").NormalPass | null;
+        downSamplingPass: import("postprocessing").DepthDownsamplingPass | null;
+        resolutionScale: number | undefined;
+    }>;
+    effectRef: import("@angular/core").InputSignal<import("angular-three").NgtInjectedRef<LensFlareEffect>>;
+    options: import("@angular/core").InputSignalWithTransform<{
+        blendFunction?: BlendFunction | undefined;
+        enabled?: boolean | undefined;
+        glareSize?: number | undefined;
+        lensPosition?: number[] | undefined;
+        iResolution?: number[] | undefined;
+        starPoints?: number | undefined;
+        flareSize?: number | undefined;
+        flareSpeed?: number | undefined;
+        flareShape?: number | undefined;
+        animated?: boolean | undefined;
+        anamorphic?: boolean | undefined;
+        colorGain?: Color | undefined;
+        lensDirtTexture?: Texture | null | undefined;
+        haloScale?: number | undefined;
+        secondaryGhosts?: boolean | undefined;
+        aditionalStreaks?: boolean | undefined;
+        ghostScale?: number | undefined;
+        opacity?: number | undefined;
+        starBurst?: boolean | undefined;
+    } & {
+        position: Vector3;
+        followMouse: boolean;
+        smoothTime: number;
+    }, "" | Partial<{
+        blendFunction?: BlendFunction | undefined;
+        enabled?: boolean | undefined;
+        glareSize?: number | undefined;
+        lensPosition?: number[] | undefined;
+        iResolution?: number[] | undefined;
+        starPoints?: number | undefined;
+        flareSize?: number | undefined;
+        flareSpeed?: number | undefined;
+        flareShape?: number | undefined;
+        animated?: boolean | undefined;
+        anamorphic?: boolean | undefined;
+        colorGain?: Color | undefined;
+        lensDirtTexture?: Texture | null | undefined;
+        haloScale?: number | undefined;
+        secondaryGhosts?: boolean | undefined;
+        aditionalStreaks?: boolean | undefined;
+        ghostScale?: number | undefined;
+        opacity?: number | undefined;
+        starBurst?: boolean | undefined;
+    } & {
+        position: Vector3;
+        followMouse: boolean;
+        smoothTime: number;
+    }>>;
+    projectedPosition: Vector3;
+    mouse2d: Vector2;
+    effect: import("@angular/core").Signal<LensFlareEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpLensFlare, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpLensFlare, "ngtp-lens-flare", never, { "effectRef": { "alias": "effectRef"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/effects/lut.d.ts

@@ -0,0 +1,20 @@
+import { BlendFunction, LUT3DEffect } from 'postprocessing';
+import { Texture } from 'three';
+import * as i0 from "@angular/core";
+export interface LUTOptions {
+    lut: Texture;
+    blendFunction?: BlendFunction;
+    tetrahedralInterpolation?: boolean;
+}
+export declare class NgtpLUT {
+    autoEffect: (autoEffectCallback: (autoEffectInjector: import("@angular/core").Injector) => void | (() => void), options?: Omit<import("@angular/core").CreateEffectOptions, "injector"> | undefined) => import("@angular/core").EffectRef;
+    store: import("angular-three").NgtSignalStore<import("angular-three").NgtState>;
+    invalidate: import("@angular/core").Signal<(frames?: number | undefined) => void>;
+    effectRef: import("@angular/core").InputSignal<import("angular-three").NgtInjectedRef<LUT3DEffect>>;
+    options: import("@angular/core").InputSignal<LUTOptions>;
+    lut: import("@angular/core").Signal<Texture>;
+    effect: import("@angular/core").Signal<LUT3DEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpLUT, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpLUT, "ngtp-lut", never, { "effectRef": { "alias": "effectRef"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/effects/noise.d.ts

@@ -0,0 +1,14 @@
+import { BlendFunction, NoiseEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type NoiseEffectOptions = Partial<NonNullable<ConstructorParameters<typeof NoiseEffect>[0]>>;
+export declare class NgtpNoise {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        blendFunction?: BlendFunction | undefined;
+        premultiply?: boolean | undefined;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpNoise, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpNoise, "ngtp-noise", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; "effectRef": "effectRef"; }; outputs: {}; }]>;
+}

package/lib/effects/pixelation.d.ts

@@ -0,0 +1,17 @@
+import { PixelationEffect } from 'postprocessing';
+import * as i0 from "@angular/core";
+export interface PixelationOptions {
+    granularity: number;
+}
+export declare class NgtpPixelation {
+    effectRef: import("@angular/core").InputSignal<import("angular-three").NgtInjectedRef<PixelationEffect>>;
+    options: import("@angular/core").InputSignalWithTransform<{
+        granularity: number;
+    }, "" | Partial<{
+        granularity: number;
+    }>>;
+    granularity: import("@angular/core").Signal<number>;
+    effect: import("@angular/core").Signal<PixelationEffect>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpPixelation, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpPixelation, "ngtp-pixelation", never, { "effectRef": { "alias": "effectRef"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/effects/scanline.d.ts

@@ -0,0 +1,17 @@
+import { BlendFunction, ScanlineEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type ScanlineEffectOptions = Partial<NonNullable<ConstructorParameters<typeof ScanlineEffect>[0]>>;
+export declare class NgtpScanline {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignalWithTransform<Omit<Partial<{
+        blendFunction?: BlendFunction | undefined;
+        density?: number | undefined;
+    }>, "blendFunction">, "" | Partial<Omit<Partial<{
+        blendFunction?: BlendFunction | undefined;
+        density?: number | undefined;
+    }>, "blendFunction">>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpScanline, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpScanline, "ngtp-scanline", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; "effectRef": "effectRef"; }; outputs: {}; }]>;
+}

package/lib/effects/sepia.d.ts

@@ -0,0 +1,14 @@
+import { SepiaEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type SepiaEffectOptions = Partial<NonNullable<ConstructorParameters<typeof SepiaEffect>[0]>>;
+export declare class NgtpSepia {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        blendFunction?: import("postprocessing").BlendFunction | undefined;
+        intensity?: number | undefined;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpSepia, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpSepia, "ngtp-sepia", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; "effectRef": "effectRef"; }; outputs: {}; }]>;
+}

package/lib/effects/shock-wave.d.ts

@@ -0,0 +1,11 @@
+import { ShockWaveEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type ShockWaveEffectOptions = Partial<NonNullable<ConstructorParameters<typeof ShockWaveEffect>[0]>>;
+export declare class NgtpShockWave {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<import("three").Camera>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpShockWave, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpShockWave, "ngtp-shock-wave", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; "effectRef": "effectRef"; }; outputs: {}; }]>;
+}

package/lib/effects/smaa.d.ts

@@ -0,0 +1,15 @@
+import { SMAAEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type SMAAEffectOptions = Partial<NonNullable<ConstructorParameters<typeof SMAAEffect>[0]>>;
+export declare class NgtpSMAA {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        preset?: import("postprocessing").SMAAPreset | undefined;
+        edgeDetectionMode?: import("postprocessing").EdgeDetectionMode | undefined;
+        predicationMode?: import("postprocessing").PredicationMode | undefined;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpSMAA, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpSMAA, "ngtp-smaa", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; "effectRef": "effectRef"; }; outputs: {}; }]>;
+}

package/lib/effects/tilt-shift-2.d.ts

@@ -0,0 +1,35 @@
+import { BlendFunction, Effect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export declare class TiltShift2Effect extends Effect {
+    constructor({ blendFunction, blur, // [0, 1], can go beyond 1 for extra
+    taper, // [0, 1], can go beyond 1 for extra
+    start, // [0,1] percentage x,y of screenspace
+    end, // [0,1] percentage x,y of screenspace
+    samples, // number of blur samples
+    direction, }?: {
+        blendFunction?: BlendFunction | undefined;
+        blur?: number | undefined;
+        taper?: number | undefined;
+        start?: number[] | undefined;
+        end?: number[] | undefined;
+        samples?: number | undefined;
+        direction?: number[] | undefined;
+    });
+}
+export type TiltShift2EffectOptions = Partial<NonNullable<ConstructorParameters<typeof TiltShift2Effect>[0]>>;
+export declare class NgtpTiltShift2 {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        blendFunction?: BlendFunction | undefined;
+        blur?: number | undefined;
+        taper?: number | undefined;
+        start?: number[] | undefined;
+        end?: number[] | undefined;
+        samples?: number | undefined;
+        direction?: number[] | undefined;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpTiltShift2, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpTiltShift2, "ngtp-tilt-shift2", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; "effectRef": "effectRef"; }; outputs: {}; }]>;
+}

package/lib/effects/tilt-shift.d.ts

@@ -0,0 +1,22 @@
+import { BlendFunction, TiltShiftEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type TiltShiftEffectOptions = Partial<NonNullable<ConstructorParameters<typeof TiltShiftEffect>[0]>>;
+export declare class NgtpTiltShift {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        blendFunction?: BlendFunction | undefined;
+        offset?: number | undefined;
+        rotation?: number | undefined;
+        focusArea?: number | undefined;
+        feather?: number | undefined;
+        bias?: number | undefined;
+        kernelSize?: import("postprocessing").KernelSize | undefined;
+        resolutionScale?: number | undefined;
+        resolutionX?: number | undefined;
+        resolutionY?: number | undefined;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpTiltShift, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpTiltShift, "ngtp-tilt-shift", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; "effectRef": "effectRef"; }; outputs: {}; }]>;
+}

package/lib/effects/vignette.d.ts

@@ -0,0 +1,17 @@
+import { VignetteEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type VignetteEffectOptions = Partial<NonNullable<ConstructorParameters<typeof VignetteEffect>[0]>>;
+export declare class NgtpVignette {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        blendFunction?: import("postprocessing").BlendFunction | undefined;
+        technique?: import("postprocessing").VignetteTechnique | undefined;
+        eskil?: boolean | undefined;
+        offset?: number | undefined;
+        darkness?: number | undefined;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpVignette, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpVignette, "ngtp-vignette", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; "effectRef": "effectRef"; }; outputs: {}; }]>;
+}

package/lib/effects/water.d.ts

@@ -0,0 +1,20 @@
+import { BlendFunction, Effect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export declare class WaterEffect extends Effect {
+    constructor({ blendFunction, factor }?: {
+        blendFunction?: BlendFunction | undefined;
+        factor?: number | undefined;
+    });
+}
+export type WaterEffectOptions = Partial<NonNullable<ConstructorParameters<typeof WaterEffect>[0]>>;
+export declare class NgtpWater {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        blendFunction?: BlendFunction | undefined;
+        factor?: number | undefined;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpWater, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpWater, "ngtp-water", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; "effectRef": "effectRef"; }; outputs: {}; }]>;
+}

package/lib/utils.d.ts

@@ -0,0 +1,3 @@
+import { Signal } from '@angular/core';
+import { Vector2 } from 'three';
+export declare function vector2<TObject extends object>(options: Signal<TObject>, key: keyof TObject): Signal<Vector2>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "angular-three-postprocessing",
-	"version": "2.0.0-beta.235",
+	"version": "2.0.0-beta.236",
 	"publishConfig": {
 		"access": "public"
 	},
@@ -24,11 +24,17 @@
 	"peerDependencies": {
 		"@angular/common": "^18.0.0",
 		"@angular/core": "^18.0.0",
+		"maath": "^0.10.0",
 		"ngxtension": "^3.0.0",
 		"postprocessing": "^6.0.0",
 		"three": ">=0.148.0",
 		"three-stdlib": "^2.0.0"
 	},
+	"peerDependenciesMeta": {
+		"maath": {
+			"optional": true
+		}
+	},
 	"dependencies": {
 		"tslib": "^2.3.0"
 	},