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

package/lib/effect-composer.d.ts

@@ -1,100 +1,48 @@
+import { ElementRef } 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 = {
+export interface NgtpEffectComposerOptions {
     enabled: boolean;
     depthBuffer?: boolean;
-    disableNormalPass?: 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: THREE.TextureDataType;
+    frameBufferType: TextureDataType;
     renderPriority: number;
-    camera?: THREE.Camera;
-    scene?: THREE.Scene;
-};
-export declare const injectNgtpEffectComposerApi: {
-    (): import("@angular/core").Signal<{
-        composer: EffectComposer;
-        normalPass: NormalPass | null;
-        downSamplingPass: DepthDownsamplingPass | null;
-        resolutionScale: number | undefined;
-        camera: THREE.Camera;
-        scene: THREE.Scene;
-    }>;
-    (injectOptions: import("@angular/core").InjectOptions & {
-        optional?: false | undefined;
-    }): import("@angular/core").Signal<{
-        composer: EffectComposer;
-        normalPass: NormalPass | null;
-        downSamplingPass: DepthDownsamplingPass | null;
-        resolutionScale: number | undefined;
-        camera: THREE.Camera;
-        scene: THREE.Scene;
-    }>;
-    (injectOptions: import("@angular/core").InjectOptions): import("@angular/core").Signal<{
-        composer: EffectComposer;
-        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;
+    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);
+    options: import("@angular/core").InputSignalWithTransform<NgtpEffectComposerOptions, "" | Partial<NgtpEffectComposerOptions>>;
     private injector;
+    private autoEffect;
     private store;
+    private size;
     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;
-    api: import("@angular/core").Signal<{
+    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>;
+    groupRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    composerData: import("@angular/core").Signal<{
         composer: EffectComposer;
         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>;
 }

package/lib/effect.d.ts

@@ -1,27 +1,56 @@
-import { NgtAnyRecord } from 'angular-three';
-import { BlendFunction, Effect } from 'postprocessing';
+import { BlendFunction } from 'postprocessing';
 import * as i0 from "@angular/core";
-export type NgtpEffectState = {
+export declare const injectDefaultEffectOptions: {
+    (): {
+        blendFunction?: BlendFunction;
+        opacity?: number;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false;
+    } & {
+        injector?: import("@angular/core").Injector;
+    }): {
+        blendFunction?: BlendFunction;
+        opacity?: number;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        injector?: import("@angular/core").Injector;
+    }): {
+        blendFunction?: BlendFunction;
+        opacity?: number;
+    } | null;
+}, provideDefaultEffectOptions: ((value: {
     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>;
+} | (() => {
+    blendFunction?: BlendFunction;
+    opacity?: number;
+})) => import("@angular/core").Provider) & ((value: {
+    blendFunction?: BlendFunction;
+    opacity?: number;
+} | (() => {
+    blendFunction?: BlendFunction;
+    opacity?: number;
+})) => 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;
+        opacity?: number;
+    } | null;
+    blendFunction: import("@angular/core").InputSignal<BlendFunction | undefined>;
+    opacity: import("@angular/core").InputSignal<number | undefined>;
+    private store;
+    camera: import("@angular/core").Signal<import("angular-three").NgtCameraManual>;
+    invalidate: import("@angular/core").Signal<(frames?: number) => 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;
+        brightness?: number;
+        contrast?: number;
+    }, "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;
+        offset?: import("three").Vector2;
+        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;
+        bits?: number;
+    }>, "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,22 @@
+import { NgtVector3 } from 'angular-three';
+import { DepthOfFieldEffect } from 'postprocessing';
+import { DepthPackingStrategies, Texture } from 'three';
+import * as i0 from "@angular/core";
+type DOFOptions = NonNullable<ConstructorParameters<typeof DepthOfFieldEffect>[1]> & Partial<{
+    target: NgtVector3;
+    depthTexture: {
+        texture: Texture;
+        packing: DepthPackingStrategies;
+    };
+}>;
+export declare class NgtpDepthOfField {
+    private autoEffect;
+    private effectComposer;
+    options: import("@angular/core").InputSignal<DOFOptions>;
+    private autoFocus;
+    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;
+        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

@@ -1,17 +1,27 @@
-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 './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>;
+}