angular-three-postprocessing 4.0.0-next.11 → 4.0.0-next.111

package/index.d.ts

@@ -1,3 +1,715 @@
-export * from './lib/effect';
-export * from './lib/effect-composer';
-export * from './lib/effects';
+import * as angular_three from 'angular-three';
+import { NgtVector3, NgtVector2 } from 'angular-three';
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+import * as postprocessing from 'postprocessing';
+import { BlendFunction, EffectComposer, Effect, BloomEffectOptions, BrightnessContrastEffect, ChromaticAberrationEffect, ColorDepthEffect, DepthEffect, DepthOfFieldEffect, DotScreenEffect, FXAAEffect, GlitchEffect, GlitchMode, GodRaysEffect, GridEffect, HueSaturationEffect, LUT3DEffect, NoiseEffect, OutlineEffect, PixelationEffect, ScanlineEffect, SelectiveBloomEffect, SepiaEffect, ShockWaveEffect, SMAAEffect, TiltShiftEffect, ToneMappingEffect, VignetteEffect } from 'postprocessing';
+import * as THREE from 'three';
+
+declare const injectDefaultEffectOptions: {
+    (): {
+        blendFunction?: BlendFunction;
+        opacity?: number;
+    };
+    (injectOptions: i0.InjectOptions & {
+        optional?: false;
+    } & {
+        injector?: i0.Injector;
+    }): {
+        blendFunction?: BlendFunction;
+        opacity?: number;
+    };
+    (injectOptions: i0.InjectOptions & {
+        injector?: i0.Injector;
+    }): {
+        blendFunction?: BlendFunction;
+        opacity?: number;
+    } | null;
+};
+declare const provideDefaultEffectOptions: ((value: {
+    blendFunction?: BlendFunction;
+    opacity?: number;
+} | (() => {
+    blendFunction?: BlendFunction;
+    opacity?: number;
+})) => i0.Provider) & ((value: {
+    blendFunction?: BlendFunction;
+    opacity?: number;
+} | (() => {
+    blendFunction?: BlendFunction;
+    opacity?: number;
+})) => i0.Provider);
+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>;
+}
+declare class NgtpEffect {
+    defaultEffectOptions: {
+        blendFunction?: BlendFunction;
+        opacity?: number;
+    } | null;
+    blendFunction: i0.InputSignal<BlendFunction | undefined>;
+    opacity: i0.InputSignal<number | undefined>;
+    private store;
+    camera: angular_three.DeepSignal<angular_three.NgtCamera>;
+    invalidate: 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>;
+}
+
+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;
+}
+declare class NgtpEffectComposer {
+    options: i0.InputSignalWithTransform<NgtpEffectComposerOptions, "" | Partial<NgtpEffectComposerOptions>>;
+    private store;
+    private depthBuffer;
+    private stencilBuffer;
+    private multisampling;
+    private frameBufferType;
+    private enableNormalPass;
+    private resolutionScale;
+    private enabled;
+    private renderPriority;
+    scene: i0.Signal<THREE.Scene>;
+    camera: i0.Signal<THREE.Camera>;
+    private groupRef;
+    private priority;
+    private composerData;
+    effectComposer: i0.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>;
+}
+
+interface ASCIIEffectOptions {
+    font?: string;
+    characters?: string;
+    fontSize?: number;
+    cellSize?: number;
+    color?: string;
+    invert?: boolean;
+}
+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;
+}
+declare class NgtpASCII {
+    options: i0.InputSignalWithTransform<ASCIIEffectOptions, "" | Partial<ASCIIEffectOptions>>;
+    protected effect: i0.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>;
+}
+
+declare class NgtpBloom {
+    options: i0.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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+type BrightnessEffectOptions = NonNullable<ConstructorParameters<typeof BrightnessContrastEffect>[0]>;
+declare class NgtpBrightnessContrast {
+    options: i0.InputSignal<Omit<{
+        blendFunction?: 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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+type ChromaticAberrationEffectOptions = Partial<NonNullable<ConstructorParameters<typeof ChromaticAberrationEffect>[0]>>;
+declare class NgtpChromaticAberration {
+    options: i0.InputSignal<Omit<Partial<{
+        blendFunction?: postprocessing.BlendFunction;
+        offset?: 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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+declare class NgtpColorAverage {
+    options: i0.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>;
+}
+
+type ColorDepthEffectOptions = Partial<NonNullable<ConstructorParameters<typeof ColorDepthEffect>[0]>>;
+declare class NgtpColorDepth {
+    options: i0.InputSignal<Omit<Partial<{
+        blendFunction?: 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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+type DepthEffectOptions = Partial<NonNullable<ConstructorParameters<typeof DepthEffect>[0]>>;
+declare class NgtpDepth {
+    options: i0.InputSignal<Omit<Partial<{
+        blendFunction?: 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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+type DOFOptions = NonNullable<ConstructorParameters<typeof DepthOfFieldEffect>[1]> & Partial<{
+    target: NgtVector3;
+    depthTexture: {
+        texture: THREE.Texture;
+        packing: THREE.DepthPackingStrategies;
+    };
+}>;
+declare class NgtpDepthOfField {
+    options: i0.InputSignal<DOFOptions>;
+    private effectComposer;
+    protected effect: i0.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>;
+}
+
+type DotScreenEffectOptions = Partial<NonNullable<ConstructorParameters<typeof DotScreenEffect>[0]>>;
+declare class NgtpDotScreen {
+    options: i0.InputSignal<Omit<Partial<{
+        blendFunction?: 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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+type FXAAEffectOptions = Partial<NonNullable<ConstructorParameters<typeof FXAAEffect>[0]>>;
+declare class NgtpFXAA {
+    options: i0.InputSignal<Omit<Partial<{
+        blendFunction?: 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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+type GlitchOptions = NonNullable<ConstructorParameters<typeof GlitchEffect>[0]> & Partial<{
+    mode: GlitchMode;
+    active: boolean;
+    delay: NgtVector2;
+    duration: NgtVector2;
+    chromaticAberrationOffset: NgtVector2;
+    strength: NgtVector2;
+}>;
+declare class NgtpGlitch {
+    options: i0.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: i0.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>;
+}
+
+declare class NgtpGodRays {
+    options: i0.InputSignal<{
+        blendFunction?: 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?: 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: i0.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>;
+}
+
+type GridOptions = NonNullable<ConstructorParameters<typeof GridEffect>[0]> & Partial<{
+    size: {
+        width: number;
+        height: number;
+    };
+}>;
+declare class NgtpGrid {
+    options: i0.InputSignal<GridOptions>;
+    private effectOptions;
+    private size;
+    protected effect: i0.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>;
+}
+
+type HueSaturationEffectOptions = Partial<NonNullable<ConstructorParameters<typeof HueSaturationEffect>[0]>>;
+declare class NgtpHueSaturation {
+    options: i0.InputSignal<Omit<Partial<{
+        blendFunction?: 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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+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;
+}
+type LensFlareOptions = ConstructorParameters<typeof LensFlareEffect>[0] & {
+    position: NgtVector3;
+    followMouse: boolean;
+    smoothTime: number;
+};
+declare class NgtpLensFlare {
+    options: i0.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: i0.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>;
+}
+
+interface LUTOptions {
+    lut: THREE.Texture;
+    blendFunction?: BlendFunction;
+    tetrahedralInterpolation?: boolean;
+}
+declare class NgtpLUT {
+    options: i0.InputSignal<LUTOptions>;
+    private lut;
+    private tetrahedralInterpolation;
+    private store;
+    protected effect: i0.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>;
+}
+
+type NoiseEffectOptions = Partial<NonNullable<ConstructorParameters<typeof NoiseEffect>[0]>>;
+declare class NgtpNoise {
+    options: i0.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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+type NgtpOutlineOptions = ConstructorParameters<typeof OutlineEffect>[2] & {
+    selection?: Array<THREE.Object3D | ElementRef<THREE.Object3D>>;
+    selectionLayer: number;
+};
+declare class NgtpOutline {
+    options: i0.InputSignalWithTransform<{
+        blendFunction?: 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?: postprocessing.KernelSize;
+        blur?: boolean;
+        xRay?: boolean;
+    } & {
+        selection?: Array<THREE.Object3D | ElementRef<THREE.Object3D>>;
+        selectionLayer: number;
+    }, "" | Partial<{
+        blendFunction?: 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?: 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: i0.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>;
+}
+
+interface PixelationOptions {
+    granularity: number;
+}
+declare class NgtpPixelation {
+    options: i0.InputSignalWithTransform<{
+        granularity: number;
+    }, "" | Partial<{
+        granularity: number;
+    }>>;
+    private granularity;
+    protected effect: i0.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>;
+}
+
+type ScanlineEffectOptions = Partial<NonNullable<ConstructorParameters<typeof ScanlineEffect>[0]>>;
+declare class NgtpScanline {
+    options: i0.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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+type SelectiveBloomOptions = BloomEffectOptions & {
+    selectionLayer: number;
+    inverted: boolean;
+    ignoreBackground: boolean;
+};
+declare class NgtpSelectiveBloom {
+    lights: i0.InputSignal<THREE.Object3D<THREE.Object3DEventMap>[] | ElementRef<THREE.Object3D<THREE.Object3DEventMap> | undefined>[]>;
+    selection: i0.InputSignal<THREE.Object3D<THREE.Object3DEventMap> | THREE.Object3D<THREE.Object3DEventMap>[] | ElementRef<THREE.Object3D<THREE.Object3DEventMap> | undefined> | ElementRef<THREE.Object3D<THREE.Object3DEventMap> | undefined>[]>;
+    options: i0.InputSignalWithTransform<SelectiveBloomOptions, "" | Partial<SelectiveBloomOptions>>;
+    private blendFunction;
+    private luminanceThreshold;
+    private luminanceSmoothing;
+    private mipmapBlur;
+    private intensity;
+    private radius;
+    private levels;
+    private kernelSize;
+    private resolutionScale;
+    private width;
+    private height;
+    private resolutionX;
+    private resolutionY;
+    private inverted;
+    private ignoreBackground;
+    private selectionLayer;
+    private store;
+    private effectComposer;
+    private selectionApi;
+    private resolvedLights;
+    private resolvedSelected;
+    private resolvedNgtSelected;
+    protected effect: i0.Signal<SelectiveBloomEffect>;
+    constructor();
+    private addLight;
+    private removeLight;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpSelectiveBloom, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpSelectiveBloom, "ngtp-selective-bloom", never, { "lights": { "alias": "lights"; "required": true; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type SepiaEffectOptions = Partial<NonNullable<ConstructorParameters<typeof SepiaEffect>[0]>>;
+declare class NgtpSepia {
+    options: i0.InputSignal<Omit<Partial<{
+        blendFunction?: postprocessing.BlendFunction;
+        intensity?: number;
+    }>, "blendFunction">>;
+    protected effect: NgtpEffect;
+    constructor();
+    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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+type ShockWaveEffectOptions = Partial<NonNullable<ConstructorParameters<typeof ShockWaveEffect>[0]>>;
+declare class NgtpShockWave {
+    options: i0.InputSignal<Omit<Partial<THREE.Camera>, "blendFunction">>;
+    protected effect: NgtpEffect;
+    constructor();
+    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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+type SMAAEffectOptions = Partial<NonNullable<ConstructorParameters<typeof SMAAEffect>[0]>>;
+declare class NgtpSMAA {
+    options: i0.InputSignal<Omit<Partial<{
+        preset?: postprocessing.SMAAPreset;
+        edgeDetectionMode?: postprocessing.EdgeDetectionMode;
+        predicationMode?: postprocessing.PredicationMode;
+    }>, "blendFunction">>;
+    protected effect: NgtpEffect;
+    constructor();
+    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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+type TiltShiftEffectOptions = Partial<NonNullable<ConstructorParameters<typeof TiltShiftEffect>[0]>>;
+declare class NgtpTiltShift {
+    options: i0.InputSignal<Omit<Partial<{
+        blendFunction?: BlendFunction;
+        offset?: number;
+        rotation?: number;
+        focusArea?: number;
+        feather?: number;
+        bias?: number;
+        kernelSize?: postprocessing.KernelSize;
+        resolutionScale?: number;
+        resolutionX?: number;
+        resolutionY?: number;
+    }>, "blendFunction">>;
+    protected effect: NgtpEffect;
+    constructor();
+    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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+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;
+    });
+}
+type TiltShift2EffectOptions = Partial<NonNullable<ConstructorParameters<typeof TiltShift2Effect>[0]>>;
+declare class NgtpTiltShift2 {
+    options: i0.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">>;
+    protected effect: NgtpEffect;
+    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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+type ToneMappingEffectOptions = NonNullable<ConstructorParameters<typeof ToneMappingEffect>[0]>;
+declare class NgtpToneMapping {
+    options: i0.InputSignal<Omit<{
+        blendFunction?: postprocessing.BlendFunction;
+        adaptive?: boolean;
+        mode?: postprocessing.ToneMappingMode;
+        resolution?: number;
+        maxLuminance?: number;
+        whitePoint?: number;
+        middleGrey?: number;
+        minLuminance?: number;
+        averageLuminance?: number;
+        adaptationRate?: number;
+    }, "blendFunction">>;
+    protected effect: NgtpEffect;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpToneMapping, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpToneMapping, "ngtp-tone-mapping", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+type VignetteEffectOptions = Partial<NonNullable<ConstructorParameters<typeof VignetteEffect>[0]>>;
+declare class NgtpVignette {
+    options: i0.InputSignal<Omit<Partial<{
+        blendFunction?: postprocessing.BlendFunction;
+        technique?: postprocessing.VignetteTechnique;
+        eskil?: boolean;
+        offset?: number;
+        darkness?: number;
+    }>, "blendFunction">>;
+    protected effect: NgtpEffect;
+    constructor();
+    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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+declare class WaterEffect extends Effect {
+    constructor({ blendFunction, factor }?: {
+        blendFunction?: BlendFunction | undefined;
+        factor?: number | undefined;
+    });
+}
+type WaterEffectOptions = Partial<NonNullable<ConstructorParameters<typeof WaterEffect>[0]>>;
+declare class NgtpWater {
+    options: i0.InputSignal<Omit<Partial<{
+        blendFunction?: BlendFunction | undefined;
+        factor?: number | undefined;
+    }>, "blendFunction">>;
+    protected effect: NgtpEffect;
+    constructor();
+    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 NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
+}
+
+export { ASCIIEffect, LensFlareEffect, NgtpASCII, NgtpBloom, NgtpBrightnessContrast, NgtpChromaticAberration, NgtpColorAverage, NgtpColorDepth, NgtpDepth, NgtpDepthOfField, NgtpDotScreen, NgtpEffect, NgtpEffectBlendMode, NgtpEffectComposer, NgtpFXAA, NgtpGlitch, NgtpGodRays, NgtpGrid, NgtpHueSaturation, NgtpLUT, NgtpLensFlare, NgtpNoise, NgtpOutline, NgtpPixelation, NgtpSMAA, NgtpScanline, NgtpSelectiveBloom, NgtpSepia, NgtpShockWave, NgtpTiltShift, NgtpTiltShift2, NgtpToneMapping, NgtpVignette, NgtpWater, TiltShift2Effect, WaterEffect, injectDefaultEffectOptions, provideDefaultEffectOptions };
+export type { BrightnessEffectOptions, ChromaticAberrationEffectOptions, ColorDepthEffectOptions, DepthEffectOptions, DotScreenEffectOptions, FXAAEffectOptions, GlitchOptions, HueSaturationEffectOptions, LUTOptions, LensFlareOptions, NgtpEffectComposerOptions, NgtpOutlineOptions, NoiseEffectOptions, PixelationOptions, SMAAEffectOptions, ScanlineEffectOptions, SelectiveBloomOptions, SepiaEffectOptions, ShockWaveEffectOptions, TiltShift2EffectOptions, TiltShiftEffectOptions, ToneMappingEffectOptions, VignetteEffectOptions, WaterEffectOptions };