angular-three-postprocessing 2.0.0-beta.25 → 2.0.0-beta.250

package/lib/effect-composer.d.ts

@@ -1,100 +1,97 @@
+import { ElementRef, Injector } from '@angular/core';
 import { DepthDownsamplingPass, EffectComposer, NormalPass } from 'postprocessing';
-import * as THREE from 'three';
+import { Camera, Group, Scene, TextureDataType } from 'three';
 import * as i0 from "@angular/core";
-export type NgtpEffectComposerState = {
-    enabled: boolean;
-    depthBuffer?: boolean;
-    disableNormalPass?: boolean;
-    stencilBuffer?: boolean;
-    autoClear: boolean;
+export interface NgtpEffectComposerApi {
+    composer: EffectComposer;
+    camera: Camera;
+    scene: Scene;
+    normalPass: NormalPass | null;
+    downSamplingPass: DepthDownsamplingPass | null;
     resolutionScale?: number;
-    multisampling: number;
-    frameBufferType: THREE.TextureDataType;
-    renderPriority: number;
-    camera?: THREE.Camera;
-    scene?: THREE.Scene;
-};
-export declare const injectNgtpEffectComposerApi: {
+}
+export declare const injectEffectComposerApi: {
     (): import("@angular/core").Signal<{
         composer: EffectComposer;
+        camera: Camera;
+        scene: Scene;
         normalPass: NormalPass | null;
         downSamplingPass: DepthDownsamplingPass | null;
         resolutionScale: number | undefined;
-        camera: THREE.Camera;
-        scene: THREE.Scene;
     }>;
     (injectOptions: import("@angular/core").InjectOptions & {
         optional?: false | undefined;
+    } & {
+        injector?: Injector | undefined;
     }): import("@angular/core").Signal<{
         composer: EffectComposer;
+        camera: Camera;
+        scene: Scene;
         normalPass: NormalPass | null;
         downSamplingPass: DepthDownsamplingPass | null;
         resolutionScale: number | undefined;
-        camera: THREE.Camera;
-        scene: THREE.Scene;
     }>;
-    (injectOptions: import("@angular/core").InjectOptions): import("@angular/core").Signal<{
+    (injectOptions: import("@angular/core").InjectOptions & {
+        injector?: Injector | undefined;
+    }): import("@angular/core").Signal<{
         composer: EffectComposer;
+        camera: Camera;
+        scene: Scene;
         normalPass: NormalPass | null;
         downSamplingPass: DepthDownsamplingPass | null;
         resolutionScale: number | undefined;
-        camera: THREE.Camera;
-        scene: THREE.Scene;
     }> | null;
-}, provideNgtpEffectComposerApi: (value?: import("@angular/core").Signal<{
-    composer: EffectComposer;
-    normalPass: NormalPass | null;
-    downSamplingPass: DepthDownsamplingPass | null;
-    resolutionScale: number | undefined;
-    camera: THREE.Camera;
-    scene: THREE.Scene;
-}> | undefined) => import("@angular/core").Provider;
+}, provideEffectComposerApi: () => import("@angular/core").Provider;
+interface NgtpEffectComposerOptions {
+    enabled: boolean;
+    depthBuffer?: boolean;
+    /** Only used for SSGI currently, leave it disabled for everything else unless it's needed */
+    enableNormalPass?: boolean;
+    stencilBuffer?: boolean;
+    autoClear: boolean;
+    resolutionScale?: number;
+    multisampling: number;
+    frameBufferType: TextureDataType;
+    renderPriority: number;
+    camera?: Camera;
+    scene?: Scene;
+}
 export declare class NgtpEffectComposer {
-    private inputs;
-    composerRef: import("angular-three").NgtInjectedRef<THREE.Group>;
-    set _enabled(enabled: boolean);
-    set _depthBuffer(depthBuffer: boolean);
-    set _disableNormalPass(disableNormalPass: boolean);
-    set _stencilBuffer(stencilBuffer: boolean);
-    set _autoClear(autoClear: boolean);
-    set _resolutionScale(resolutionScale: number);
-    set _multisampling(multisampling: number);
-    set _frameBufferType(frameBufferType: THREE.TextureDataType);
-    set _renderPriority(renderPriority: number);
-    set _camera(camera: THREE.Camera);
-    set _scene(scene: THREE.Scene);
-    private injector;
-    private store;
-    private gl;
-    private defaultScene;
-    private defaultCamera;
-    private size;
-    private depthBuffer;
-    private stencilBuffer;
-    private multisampling;
-    private frameBufferType;
-    private scene;
-    private camera;
-    private disableNormalPass;
-    private resolutionScale;
-    private autoClear;
-    private activeScene;
-    private activeCamera;
-    private composerEntities;
-    private composer;
+    options: import("@angular/core").InputSignalWithTransform<NgtpEffectComposerOptions, "" | Partial<NgtpEffectComposerOptions>>;
+    injector: Injector;
+    autoEffect: (autoEffectCallback: (autoEffectInjector: Injector) => void | (() => void), options?: Omit<import("@angular/core").CreateEffectOptions, "injector"> | undefined) => import("@angular/core").EffectRef;
+    store: import("angular-three").NgtSignalStore<import("angular-three").NgtState>;
+    size: import("@angular/core").Signal<import("angular-three").NgtSize>;
+    gl: import("@angular/core").Signal<import("three").WebGLRenderer>;
+    defaultScene: import("@angular/core").Signal<Scene>;
+    defaultCamera: import("@angular/core").Signal<import("angular-three").NgtCameraManual>;
+    depthBuffer: import("@angular/core").Signal<boolean | undefined>;
+    stencilBuffer: import("@angular/core").Signal<boolean | undefined>;
+    multisampling: import("@angular/core").Signal<number>;
+    frameBufferType: import("@angular/core").Signal<TextureDataType>;
+    scene: import("@angular/core").Signal<Scene>;
+    camera: import("@angular/core").Signal<Camera>;
+    enableNormalPass: import("@angular/core").Signal<boolean | undefined>;
+    resolutionScale: import("@angular/core").Signal<number | undefined>;
+    group: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    composerData: import("@angular/core").Signal<{
+        composer: EffectComposer;
+        normalPass: NormalPass | null;
+        downSamplingPass: DepthDownsamplingPass | null;
+    }>;
     api: import("@angular/core").Signal<{
         composer: EffectComposer;
+        camera: Camera;
+        scene: Scene;
         normalPass: NormalPass | null;
         downSamplingPass: DepthDownsamplingPass | null;
         resolutionScale: number | undefined;
-        camera: THREE.Camera;
-        scene: THREE.Scene;
     }>;
     constructor();
-    ngOnInit(): void;
+    private disableToneMapping;
     private setComposerSize;
     private updatePasses;
-    private beforeRender;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpEffectComposer, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpEffectComposer, "ngtp-effect-composer", never, { "composerRef": { "alias": "composerRef"; "required": false; }; "_enabled": { "alias": "enabled"; "required": false; }; "_depthBuffer": { "alias": "depthBuffer"; "required": false; }; "_disableNormalPass": { "alias": "disableNormalPass"; "required": false; }; "_stencilBuffer": { "alias": "stencilBuffer"; "required": false; }; "_autoClear": { "alias": "autoClear"; "required": false; }; "_resolutionScale": { "alias": "resolutionScale"; "required": false; }; "_multisampling": { "alias": "multisampling"; "required": false; }; "_frameBufferType": { "alias": "frameBufferType"; "required": false; }; "_renderPriority": { "alias": "renderPriority"; "required": false; }; "_camera": { "alias": "camera"; "required": false; }; "_scene": { "alias": "scene"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpEffectComposer, "ngtp-effect-composer", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
+export {};

package/lib/effect.d.ts

@@ -1,27 +1,56 @@
-import { type NgtAnyRecord } from 'angular-three';
-import { BlendFunction, Effect } from 'postprocessing';
+import { BlendFunction } from 'postprocessing';
 import * as i0 from "@angular/core";
-export type NgtpEffectState = {
-    blendFunction?: BlendFunction;
-    opacity?: number;
-};
-export declare abstract class NgtpEffect<TEffect extends Effect> {
-    inputs: import("angular-three").NgtSignalStore<NgtpEffectState>;
-    effectRef: import("angular-three").NgtInjectedRef<TEffect>;
-    set _blendFunction(blendFunction: BlendFunction);
-    set _opacity(opacity: number);
-    protected defaultBlendFunction: BlendFunction;
-    protected nativeArgs: () => NgtAnyRecord[];
-    blendFunction: import("@angular/core").Signal<BlendFunction | undefined>;
-    opacity: import("@angular/core").Signal<number | undefined>;
-    protected store: import("angular-three").NgtSignalStore<import("angular-three").NgtState>;
-    protected camera: import("@angular/core").Signal<import("angular-three").NgtCameraManual>;
-    private invalidate;
-    private previousInputs?;
-    private nativeInputs;
-    args: import("@angular/core").Signal<NgtAnyRecord[]>;
-    constructor();
-    private setBlendMode;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpEffect<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtpEffect<any>, never, never, { "effectRef": { "alias": "effectRef"; "required": false; }; "_blendFunction": { "alias": "blendFunction"; "required": false; }; "_opacity": { "alias": "opacity"; "required": false; }; }, {}, never, never, false, never>;
+export declare const injectDefaultEffectOptions: {
+    (): {
+        blendFunction?: BlendFunction | undefined;
+        opacity?: number | undefined;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false | undefined;
+    } & {
+        injector?: import("@angular/core").Injector | undefined;
+    }): {
+        blendFunction?: BlendFunction | undefined;
+        opacity?: number | undefined;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        injector?: import("@angular/core").Injector | undefined;
+    }): {
+        blendFunction?: BlendFunction | undefined;
+        opacity?: number | undefined;
+    } | null;
+}, provideDefaultEffectOptions: ((value: {
+    blendFunction?: BlendFunction | undefined;
+    opacity?: number | undefined;
+} | (() => {
+    blendFunction?: BlendFunction | undefined;
+    opacity?: number | undefined;
+})) => import("@angular/core").Provider) & ((value: {
+    blendFunction?: BlendFunction | undefined;
+    opacity?: number | undefined;
+} | (() => {
+    blendFunction?: BlendFunction | undefined;
+    opacity?: number | undefined;
+})) => import("@angular/core").Provider);
+export declare class NgtpEffectBlendMode {
+    effect: NgtpEffect | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpEffectBlendMode, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpEffectBlendMode, "ngtp-effect-blend-mode", never, {}, {}, never, never, true, never>;
+}
+export declare class NgtpEffect {
+    defaultEffectOptions: {
+        blendFunction?: BlendFunction | undefined;
+        opacity?: number | undefined;
+    } | null;
+    blendFunction: import("@angular/core").InputSignal<BlendFunction | undefined>;
+    opacity: import("@angular/core").InputSignal<number | undefined>;
+    store: import("angular-three").NgtSignalStore<import("angular-three").NgtState>;
+    camera: import("@angular/core").Signal<import("angular-three").NgtCameraManual>;
+    invalidate: import("@angular/core").Signal<(frames?: number | undefined) => void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpEffect, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtpEffect, never, never, { "blendFunction": { "alias": "blendFunction"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
+export declare const NgtpEffectHostDirective: {
+    directive: typeof NgtpEffect;
+    inputs: string[];
+};

package/lib/effects/ascii.d.ts

@@ -0,0 +1,23 @@
+import { Effect } from 'postprocessing';
+import { Texture } from 'three';
+import * as i0 from "@angular/core";
+interface ASCIIEffectOptions {
+    font?: string;
+    characters?: string;
+    fontSize?: number;
+    cellSize?: number;
+    color?: string;
+    invert?: boolean;
+}
+export declare class ASCIIEffect extends Effect {
+    constructor({ font, characters, fontSize, cellSize, color, invert, }?: ASCIIEffectOptions);
+    /** Draws the characters on a Canvas and returns a texture */
+    createCharactersTexture(characters: string, font: string, fontSize: number): Texture;
+}
+export declare class NgtpASCII {
+    options: import("@angular/core").InputSignalWithTransform<ASCIIEffectOptions, "" | Partial<ASCIIEffectOptions>>;
+    effect: import("@angular/core").Signal<ASCIIEffect>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpASCII, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpASCII, "ngtp-ascii", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/effects/bloom.d.ts

@@ -0,0 +1,10 @@
+import { BloomEffectOptions } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export declare class NgtpBloom {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<BloomEffectOptions, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpBloom, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpBloom, "ngtp-bloom", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}

package/lib/effects/brightness-contrast.d.ts

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

package/lib/effects/chromatic-abberation.d.ts

@@ -0,0 +1,16 @@
+import { ChromaticAberrationEffect } from 'postprocessing';
+import { NgtpEffect } from '../effect';
+import * as i0 from "@angular/core";
+import * as i1 from "../effect";
+export type ChromaticAberrationEffectOptions = Partial<NonNullable<ConstructorParameters<typeof ChromaticAberrationEffect>[0]>>;
+export declare class NgtpChromaticAberration {
+    effect: NgtpEffect;
+    options: import("@angular/core").InputSignal<Omit<Partial<{
+        blendFunction?: import("postprocessing").BlendFunction | undefined;
+        offset?: import("three").Vector2 | undefined;
+        radialModulation: boolean;
+        modulationOffset: number;
+    }>, "blendFunction">>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpChromaticAberration, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpChromaticAberration, "ngtp-chromatic-aberration", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}

package/lib/effects/color-average.d.ts

@@ -0,0 +1,11 @@
+import { BlendFunction } from 'postprocessing';
+import * as i0 from "@angular/core";
+export declare class NgtpColorAverage {
+    options: import("@angular/core").InputSignalWithTransform<{
+        blendFunction: BlendFunction;
+    }, "" | Partial<{
+        blendFunction: BlendFunction;
+    }>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpColorAverage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpColorAverage, "ngtp-color-average", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/lib/effects/color-depth.d.ts

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

package/lib/effects/depth-of-field.d.ts

@@ -0,0 +1,29 @@
+import { NgtVector3 } from 'angular-three';
+import { DepthOfFieldEffect } from 'postprocessing';
+import { Texture } from 'three';
+import * as i0 from "@angular/core";
+type DOFOptions = NonNullable<ConstructorParameters<typeof DepthOfFieldEffect>[1]> & Partial<{
+    target: NgtVector3;
+    depthTexture: {
+        texture: Texture;
+        packing: number;
+    };
+}>;
+export declare class NgtpDepthOfField {
+    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;
+    }>;
+    options: import("@angular/core").InputSignal<DOFOptions>;
+    autoFocus: import("@angular/core").Signal<boolean>;
+    effect: import("@angular/core").Signal<DepthOfFieldEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpDepthOfField, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpDepthOfField, "ngtp-depth-of-field", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

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 | undefined;
+        inverted?: boolean | undefined;
+    }>, "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 | undefined;
+        angle?: number | undefined;
+        scale?: number | undefined;
+    }>, "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 | undefined;
+    }>, "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 {
+    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>;
+    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, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,37 @@
+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;
+    }>;
+    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, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/effects/grid.d.ts

@@ -0,0 +1,23 @@
+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>;
+    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, { "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"; }; outputs: {}; }]>;
+}

package/lib/effects/index.d.ts

@@ -1,17 +1,26 @@
-export * from './bloom/bloom';
-export * from './brightness-contrast/brightness-contrast';
-export * from './color-depth/color-depth';
-export * from './depth/depth';
-export * from './dot-screen/dot-screen';
-export * from './hue-saturation/hue-saturation';
-export * from './lut/lut';
-export * from './noise/noise';
-export * from './pixelation/pixelation';
-export * from './scanline/scanline';
-export * from './sepia/sepia';
-export * from './shock-wave/shock-wave';
-export * from './smaa/smaa';
-export * from './ssao/ssao';
-export * from './tilt-shift/tilt-shift';
-export * from './tone-mapping/tone-mapping';
-export * from './vignette/vignette';
+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';