angular-three-postprocessing 4.0.0-next.99 → 4.0.0

package/index.d.ts

@@ -1,3 +0,0 @@
-export * from './lib/effect';
-export * from './lib/effect-composer';
-export * from './lib/effects';

package/lib/effect-composer.d.ts

@@ -1,38 +0,0 @@
-import { EffectComposer } from 'postprocessing';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export 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: THREE.TextureDataType;
-    renderPriority: number;
-    camera?: THREE.Camera;
-    scene?: THREE.Scene;
-}
-export declare class NgtpEffectComposer {
-    options: import("@angular/core").InputSignalWithTransform<NgtpEffectComposerOptions, "" | Partial<NgtpEffectComposerOptions>>;
-    private store;
-    private depthBuffer;
-    private stencilBuffer;
-    private multisampling;
-    private frameBufferType;
-    private enableNormalPass;
-    private resolutionScale;
-    private enabled;
-    private renderPriority;
-    scene: import("@angular/core").Signal<THREE.Scene>;
-    camera: import("@angular/core").Signal<THREE.Camera>;
-    private groupRef;
-    private priority;
-    private composerData;
-    effectComposer: import("@angular/core").Signal<EffectComposer>;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpEffectComposer, 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,52 +0,0 @@
-import { BlendFunction } from 'postprocessing';
-import * as i0 from "@angular/core";
-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;
-} | (() => {
-    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-three").DeepSignal<import("angular-three").NgtCamera>;
-    invalidate: import("angular-three").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>;
-}

package/lib/effects/ascii.d.ts

@@ -1,24 +0,0 @@
-import { Effect } from 'postprocessing';
-import * as THREE 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): THREE.Texture;
-}
-export declare class NgtpASCII {
-    options: import("@angular/core").InputSignalWithTransform<ASCIIEffectOptions, "" | Partial<ASCIIEffectOptions>>;
-    protected effect: import("@angular/core").Signal<ASCIIEffect>;
-    constructor();
-    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

@@ -1,11 +0,0 @@
-import { BloomEffectOptions } from 'postprocessing';
-import { NgtpEffect } from '../effect';
-import * as i0 from "@angular/core";
-import * as i1 from "../effect";
-export declare class NgtpBloom {
-    options: import("@angular/core").InputSignal<Omit<BloomEffectOptions, "blendFunction">>;
-    protected effect: NgtpEffect;
-    constructor();
-    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

@@ -1,16 +0,0 @@
-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 {
-    options: import("@angular/core").InputSignal<Omit<{
-        blendFunction?: import("postprocessing").BlendFunction;
-        brightness?: number;
-        contrast?: number;
-    }, "blendFunction">>;
-    protected effect: NgtpEffect;
-    constructor();
-    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

@@ -1,17 +0,0 @@
-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 {
-    options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: import("postprocessing").BlendFunction;
-        offset?: import("three").Vector2;
-        radialModulation: boolean;
-        modulationOffset: number;
-    }>, "blendFunction">>;
-    protected effect: NgtpEffect;
-    constructor();
-    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

@@ -1,12 +0,0 @@
-import { BlendFunction } from 'postprocessing';
-import * as i0 from "@angular/core";
-export declare class NgtpColorAverage {
-    options: import("@angular/core").InputSignalWithTransform<{
-        blendFunction: BlendFunction;
-    }, "" | Partial<{
-        blendFunction: BlendFunction;
-    }>>;
-    constructor();
-    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

@@ -1,15 +0,0 @@
-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 {
-    options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: import("postprocessing").BlendFunction;
-        bits?: number;
-    }>, "blendFunction">>;
-    protected effect: NgtpEffect;
-    constructor();
-    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

@@ -1,20 +0,0 @@
-import { NgtVector3 } from 'angular-three';
-import { DepthOfFieldEffect } from 'postprocessing';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-type DOFOptions = NonNullable<ConstructorParameters<typeof DepthOfFieldEffect>[1]> & Partial<{
-    target: NgtVector3;
-    depthTexture: {
-        texture: THREE.Texture;
-        packing: THREE.DepthPackingStrategies;
-    };
-}>;
-export declare class NgtpDepthOfField {
-    options: import("@angular/core").InputSignal<DOFOptions>;
-    private effectComposer;
-    protected 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

@@ -1,15 +0,0 @@
-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 {
-    options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: import("postprocessing").BlendFunction;
-        inverted?: boolean;
-    }>, "blendFunction">>;
-    protected effect: NgtpEffect;
-    constructor();
-    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

@@ -1,16 +0,0 @@
-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 {
-    options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: import("postprocessing").BlendFunction;
-        angle?: number;
-        scale?: number;
-    }>, "blendFunction">>;
-    protected effect: NgtpEffect;
-    constructor();
-    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

@@ -1,14 +0,0 @@
-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 {
-    options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: import("postprocessing").BlendFunction;
-    }>, "blendFunction">>;
-    protected effect: NgtpEffect;
-    constructor();
-    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

@@ -1,32 +0,0 @@
-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 {
-    options: import("@angular/core").InputSignalWithTransform<GlitchOptions, "" | Partial<{
-        active: boolean;
-    }>>;
-    private active;
-    private mode;
-    private ratio;
-    private dtSize;
-    private columns;
-    private blendFunction;
-    private perturbationMap;
-    private delay;
-    private duration;
-    private chromaticAberrationOffset;
-    private strength;
-    private store;
-    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

@@ -1,32 +0,0 @@
-import { ElementRef } from '@angular/core';
-import { GodRaysEffect } from 'postprocessing';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export declare class NgtpGodRays {
-    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: THREE.Mesh | THREE.Points | ElementRef<THREE.Mesh | THREE.Points> | (() => THREE.Mesh | THREE.Points | ElementRef<THREE.Mesh | THREE.Points> | undefined);
-    }>;
-    private effectComposer;
-    private effectOptions;
-    private sun;
-    private sunElement;
-    protected 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

@@ -1,18 +0,0 @@
-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 {
-    options: import("@angular/core").InputSignal<GridOptions>;
-    private effectOptions;
-    private size;
-    protected 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

@@ -1,16 +0,0 @@
-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 {
-    options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: import("postprocessing").BlendFunction;
-        hue?: number;
-        saturation?: number;
-    }>, "blendFunction">>;
-    protected effect: NgtpEffect;
-    constructor();
-    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,29 +0,0 @@
-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 './selective-bloom';
-export * from './sepia';
-export * from './shock-wave';
-export * from './smaa';
-export * from './tilt-shift';
-export * from './tilt-shift-2';
-export * from './tone-mapping';
-export * from './vignette';
-export * from './water';

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

@@ -1,94 +0,0 @@
-import { NgtVector3 } from 'angular-three';
-import { BlendFunction, Effect } from 'postprocessing';
-import * as THREE 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?: THREE.Color | undefined;
-        lensDirtTexture?: THREE.Texture | null | undefined;
-        haloScale?: number | undefined;
-        secondaryGhosts?: boolean | undefined;
-        aditionalStreaks?: boolean | undefined;
-        ghostScale?: number | undefined;
-        opacity?: number | undefined;
-        starBurst?: boolean | undefined;
-    });
-    update(_renderer: THREE.WebGLRenderer, _inputBuffer: THREE.WebGLRenderTarget, deltaTime: number): void;
-}
-export type LensFlareOptions = ConstructorParameters<typeof LensFlareEffect>[0] & {
-    position: NgtVector3;
-    followMouse: boolean;
-    smoothTime: number;
-};
-export declare class NgtpLensFlare {
-    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?: THREE.Color | undefined;
-        lensDirtTexture?: THREE.Texture | null | undefined;
-        haloScale?: number | undefined;
-        secondaryGhosts?: boolean | undefined;
-        aditionalStreaks?: boolean | undefined;
-        ghostScale?: number | undefined;
-        opacity?: number | undefined;
-        starBurst?: boolean | undefined;
-    } & {
-        position: NgtVector3;
-        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?: THREE.Color | undefined;
-        lensDirtTexture?: THREE.Texture | null | undefined;
-        haloScale?: number | undefined;
-        secondaryGhosts?: boolean | undefined;
-        aditionalStreaks?: boolean | undefined;
-        ghostScale?: number | undefined;
-        opacity?: number | undefined;
-        starBurst?: boolean | undefined;
-    } & {
-        position: NgtVector3;
-        followMouse: boolean;
-        smoothTime: number;
-    }>>;
-    private store;
-    private effectComposer;
-    private effectOptions;
-    private position;
-    private projectedPosition;
-    private mouse2d;
-    protected 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

@@ -1,18 +0,0 @@
-import { BlendFunction, LUT3DEffect } from 'postprocessing';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export interface LUTOptions {
-    lut: THREE.Texture;
-    blendFunction?: BlendFunction;
-    tetrahedralInterpolation?: boolean;
-}
-export declare class NgtpLUT {
-    options: import("@angular/core").InputSignal<LUTOptions>;
-    private lut;
-    private tetrahedralInterpolation;
-    private store;
-    protected 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

@@ -1,15 +0,0 @@
-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 {
-    options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: BlendFunction;
-        premultiply?: boolean;
-    }>, "blendFunction">>;
-    protected effect: NgtpEffect;
-    constructor();
-    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

@@ -1,73 +0,0 @@
-import { ElementRef } from '@angular/core';
-import { OutlineEffect } from 'postprocessing';
-import * as THREE from 'three';
-import * as i0 from "@angular/core";
-export type NgtpOutlineOptions = ConstructorParameters<typeof OutlineEffect>[2] & {
-    selection?: Array<THREE.Object3D | ElementRef<THREE.Object3D>>;
-    selectionLayer: number;
-};
-export declare class NgtpOutline {
-    options: import("@angular/core").InputSignalWithTransform<{
-        blendFunction?: import("postprocessing").BlendFunction;
-        patternTexture?: 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<THREE.Object3D | ElementRef<THREE.Object3D>>;
-        selectionLayer: number;
-    }, "" | Partial<{
-        blendFunction?: import("postprocessing").BlendFunction;
-        patternTexture?: 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<THREE.Object3D | ElementRef<THREE.Object3D>>;
-        selectionLayer: number;
-    }>>;
-    private selectionApi;
-    private effectComposer;
-    private store;
-    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

@@ -1,17 +0,0 @@
-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;
-    protected effect: import("@angular/core").Signal<PixelationEffect>;
-    constructor();
-    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

@@ -1,18 +0,0 @@
-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 {
-    options: import("@angular/core").InputSignalWithTransform<Omit<Partial<{
-        blendFunction?: BlendFunction;
-        density?: number;
-    }>, "blendFunction">, "" | Partial<Omit<Partial<{
-        blendFunction?: BlendFunction;
-        density?: number;
-    }>, "blendFunction">>>;
-    protected effect: NgtpEffect;
-    constructor();
-    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: {}; }]>;
-}