angular-three-postprocessing 2.0.0-beta.3 → 2.0.0-beta.300

package/lib/effects/depth.d.ts

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

package/lib/effects/dot-screen.d.ts

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

package/lib/effects/fxaa.d.ts

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

package/lib/effects/glitch.d.ts

@@ -0,0 +1,29 @@
+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 {
+    private autoEffect;
+    private store;
+    private invalidate;
+    options: import("@angular/core").InputSignalWithTransform<GlitchOptions, "" | Partial<{
+        active: boolean;
+    }>>;
+    private active;
+    private mode;
+    private delay;
+    private duration;
+    private chromaticAberrationOffset;
+    private strength;
+    effect: import("@angular/core").Signal<GlitchEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpGlitch, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpGlitch, "ngtp-glitch", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,30 @@
+import { ElementRef } from '@angular/core';
+import { GodRaysEffect } from 'postprocessing';
+import { Mesh, Points } from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtpGodRays {
+    private autoEffect;
+    private effectComposer;
+    options: import("@angular/core").InputSignal<{
+        blendFunction?: import("postprocessing").BlendFunction;
+        samples?: number;
+        density?: number;
+        decay?: number;
+        weight?: number;
+        exposure?: number;
+        clampMax?: number;
+        resolutionScale?: number;
+        resolutionX?: number;
+        resolutionY?: number;
+        width?: number;
+        height?: number;
+        kernelSize?: import("postprocessing").KernelSize;
+        blur?: boolean;
+    } & {
+        sun: Mesh | Points | ElementRef<Mesh | Points>;
+    }>;
+    effect: import("@angular/core").Signal<GodRaysEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpGodRays, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpGodRays, "ngtp-god-rays", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/effects/grid.d.ts

@@ -0,0 +1,18 @@
+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 {
+    private autoEffect;
+    options: import("@angular/core").InputSignal<GridOptions>;
+    private size;
+    effect: import("@angular/core").Signal<GridEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpGrid, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpGrid, "ngtp-grid", never, { "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;
+        hue?: number;
+        saturation?: number;
+    }>, "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"; }; outputs: {}; }]>;
+}

package/lib/effects/index.d.ts

@@ -0,0 +1,27 @@
+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 './outline';
+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,96 @@
+import { BlendFunction, Effect } from 'postprocessing';
+import { Color, Texture, Vector3, WebGLRenderTarget, WebGLRenderer } from 'three';
+import { NgtpEffectComposer } from '../effect-composer';
+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: WebGLRenderer, _inputBuffer: WebGLRenderTarget, deltaTime: number): void;
+}
+export type LensFlareOptions = ConstructorParameters<typeof LensFlareEffect>[0] & {
+    position: Vector3;
+    followMouse: boolean;
+    smoothTime: number;
+};
+export declare class NgtpLensFlare {
+    private autoEffect;
+    private store;
+    private viewport;
+    private raycaster;
+    private pointer;
+    effectComposer: NgtpEffectComposer;
+    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;
+    }>>;
+    private projectedPosition;
+    private mouse2d;
+    effect: import("@angular/core").Signal<LensFlareEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpLensFlare, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpLensFlare, "ngtp-lens-flare", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/effects/lut.d.ts

@@ -0,0 +1,19 @@
+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 {
+    private autoEffect;
+    private store;
+    private invalidate;
+    options: import("@angular/core").InputSignal<LUTOptions>;
+    private lut;
+    effect: import("@angular/core").Signal<LUT3DEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpLUT, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpLUT, "ngtp-lut", never, { "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;
+        premultiply?: boolean;
+    }>, "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"; }; outputs: {}; }]>;
+}

package/lib/effects/outline.d.ts

@@ -0,0 +1,74 @@
+import { ElementRef } from '@angular/core';
+import { OutlineEffect } from 'postprocessing';
+import { Object3D } from 'three';
+import * as i0 from "@angular/core";
+export type NgtpOutlineOptions = ConstructorParameters<typeof OutlineEffect>[2] & {
+    selection?: Array<Object3D | ElementRef<Object3D>>;
+    selectionLayer: number;
+};
+export declare class NgtpOutline {
+    options: import("@angular/core").InputSignalWithTransform<{
+        blendFunction?: import("postprocessing").BlendFunction;
+        patternTexture?: import("three").Texture;
+        patternScale?: number;
+        edgeStrength?: number;
+        pulseSpeed?: number;
+        visibleEdgeColor?: number;
+        hiddenEdgeColor?: number;
+        multisampling?: number;
+        resolutionScale?: number;
+        resolutionX?: number;
+        resolutionY?: number;
+        width?: number;
+        height?: number;
+        kernelSize?: import("postprocessing").KernelSize;
+        blur?: boolean;
+        xRay?: boolean;
+    } & {
+        selection?: Array<Object3D | ElementRef<Object3D>>;
+        selectionLayer: number;
+    }, "" | Partial<{
+        blendFunction?: import("postprocessing").BlendFunction;
+        patternTexture?: import("three").Texture;
+        patternScale?: number;
+        edgeStrength?: number;
+        pulseSpeed?: number;
+        visibleEdgeColor?: number;
+        hiddenEdgeColor?: number;
+        multisampling?: number;
+        resolutionScale?: number;
+        resolutionX?: number;
+        resolutionY?: number;
+        width?: number;
+        height?: number;
+        kernelSize?: import("postprocessing").KernelSize;
+        blur?: boolean;
+        xRay?: boolean;
+    } & {
+        selection?: Array<Object3D | ElementRef<Object3D>>;
+        selectionLayer: number;
+    }>>;
+    private ngtSelection;
+    private effectComposer;
+    private store;
+    private invalidate;
+    private selection;
+    private selectionLayer;
+    private blendFunction;
+    private patternTexture;
+    private edgeStrength;
+    private pulseSpeed;
+    private visibleEdgeColor;
+    private hiddenEdgeColor;
+    private width;
+    private height;
+    private kernelSize;
+    private blur;
+    private xRay;
+    private restOptions;
+    effect: import("@angular/core").Signal<OutlineEffect>;
+    constructor();
+    private handleSelectionChangeEffect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpOutline, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpOutline, "ngtp-outline", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/effects/pixelation.d.ts

@@ -0,0 +1,16 @@
+import { PixelationEffect } from 'postprocessing';
+import * as i0 from "@angular/core";
+export interface PixelationOptions {
+    granularity: number;
+}
+export declare class NgtpPixelation {
+    options: import("@angular/core").InputSignalWithTransform<{
+        granularity: number;
+    }, "" | Partial<{
+        granularity: number;
+    }>>;
+    private granularity;
+    effect: import("@angular/core").Signal<PixelationEffect>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpPixelation, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpPixelation, "ngtp-pixelation", never, { "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;
+        density?: number;
+    }>, "blendFunction">, "" | Partial<Omit<Partial<{
+        blendFunction?: BlendFunction;
+        density?: number;
+    }>, "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"; }; 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;
+        intensity?: number;
+    }>, "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"; }; 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"; }; 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;
+        edgeDetectionMode?: import("postprocessing").EdgeDetectionMode;
+        predicationMode?: import("postprocessing").PredicationMode;
+    }>, "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"; }; 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"; }; 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;
+        offset?: number;
+        rotation?: number;
+        focusArea?: number;
+        feather?: number;
+        bias?: number;
+        kernelSize?: import("postprocessing").KernelSize;
+        resolutionScale?: number;
+        resolutionX?: number;
+        resolutionY?: number;
+    }>, "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"; }; 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;
+        technique?: import("postprocessing").VignetteTechnique;
+        eskil?: boolean;
+        offset?: number;
+        darkness?: number;
+    }>, "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"; }; 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"; }; outputs: {}; }]>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-three-postprocessing",
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.300",
   "publishConfig": {
     "access": "public"
   },
@@ -13,7 +13,7 @@
     "email": "nartc7789@gmail.com",
     "url": "https://nartc.me"
   },
-  "description": "Postprocessing integration with Angular Three",
+  "description": "Postprocessing for Angular Three",
   "keywords": [
     "angular",
     "threejs",
@@ -22,21 +22,21 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@angular/common": "^16.0.0",
-    "@angular/core": " ^16.0.0",
-    "angular-three": "^2.0.0",
+    "@angular/common": ">=18.0.0 <19.0.0",
+    "@angular/core": ">=18.0.0 <19.0.0",
+    "maath": ">=0.10.0 <0.11.0",
     "postprocessing": "^6.0.0",
-    "three": "^0.148.0 || ^0.149.0 || ^0.150.0 || ^0.151.0 || ^0.152.0",
-    "three-stdlib": "2.21.8"
+    "three": ">=0.148.0 <0.168.0",
+    "three-stdlib": "^2.0.0"
   },
   "dependencies": {
-    "tslib": "^2.3.0",
-    "@nx/devkit": "^16.0.0",
-    "nx": "^16.0.0"
+    "tslib": "^2.3.0"
   },
   "sideEffects": false,
-  "generators": "./plugin/generators.json",
-  "schematics": "./plugin/generators.json",
+  "web-types": [
+    "../../node_modules/angular-three/web-types.json",
+    "node_modules/angular-three/web-types.json"
+  ],
   "module": "fesm2022/angular-three-postprocessing.mjs",
   "typings": "index.d.ts",
   "exports": {
@@ -48,12 +48,6 @@
       "esm2022": "./esm2022/angular-three-postprocessing.mjs",
       "esm": "./esm2022/angular-three-postprocessing.mjs",
       "default": "./fesm2022/angular-three-postprocessing.mjs"
-    },
-    "./effects": {
-      "types": "./effects/index.d.ts",
-      "esm2022": "./esm2022/effects/angular-three-postprocessing-effects.mjs",
-      "esm": "./esm2022/effects/angular-three-postprocessing-effects.mjs",
-      "default": "./fesm2022/angular-three-postprocessing-effects.mjs"
     }
   }
-}
+}