angular-three-postprocessing 3.7.0 → 4.0.0-next.2

package/lib/effect-composer.d.ts

@@ -1,4 +1,4 @@
-import { Camera, Scene, TextureDataType } from 'three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
 export interface NgtpEffectComposerOptions {
     enabled: boolean;
@@ -9,19 +9,15 @@ export interface NgtpEffectComposerOptions {
     autoClear: boolean;
     resolutionScale?: number;
     multisampling: number;
-    frameBufferType: TextureDataType;
+    frameBufferType: THREE.TextureDataType;
     renderPriority: number;
-    camera?: Camera;
-    scene?: Scene;
+    camera?: THREE.Camera;
+    scene?: THREE.Scene;
 }
 export declare class NgtpEffectComposer {
     options: import("@angular/core").InputSignalWithTransform<NgtpEffectComposerOptions, "" | Partial<NgtpEffectComposerOptions>>;
     private injector;
     private store;
-    private size;
-    private gl;
-    private defaultScene;
-    private defaultCamera;
     private depthBuffer;
     private stencilBuffer;
     private multisampling;
@@ -30,8 +26,8 @@ export declare class NgtpEffectComposer {
     private resolutionScale;
     private enabled;
     private renderPriority;
-    scene: import("@angular/core").Signal<Scene>;
-    camera: import("@angular/core").Signal<Camera>;
+    scene: import("@angular/core").Signal<THREE.Scene>;
+    camera: import("@angular/core").Signal<THREE.Camera>;
     private groupRef;
     private priority;
     private composerData;

package/lib/effect.d.ts

@@ -45,8 +45,8 @@ export declare class NgtpEffect {
     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>;
+    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,5 +1,5 @@
 import { Effect } from 'postprocessing';
-import { Texture } from 'three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
 interface ASCIIEffectOptions {
     font?: string;
@@ -12,11 +12,11 @@ interface ASCIIEffectOptions {
 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;
+    createCharactersTexture(characters: string, font: string, fontSize: number): THREE.Texture;
 }
 export declare class NgtpASCII {
     options: import("@angular/core").InputSignalWithTransform<ASCIIEffectOptions, "" | Partial<ASCIIEffectOptions>>;
-    effect: import("@angular/core").Signal<ASCIIEffect>;
+    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>;

package/lib/effects/bloom.d.ts

@@ -3,8 +3,9 @@ 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">>;
+    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

@@ -4,12 +4,13 @@ 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">>;
+    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

@@ -4,13 +4,14 @@ 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">>;
+    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

@@ -6,6 +6,7 @@ export declare class NgtpColorAverage {
     }, "" | 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

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

package/lib/effects/depth.d.ts

@@ -4,11 +4,12 @@ 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">>;
+    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

@@ -4,12 +4,13 @@ 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">>;
+    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

@@ -4,10 +4,11 @@ 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">>;
+    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

@@ -15,12 +15,16 @@ export declare class NgtpGlitch {
     }>>;
     private active;
     private mode;
+    private ratio;
+    private dtSize;
+    private columns;
+    private blendFunction;
+    private perturbationMap;
     private delay;
     private duration;
     private chromaticAberrationOffset;
     private strength;
     private store;
-    private invalidate;
     effect: import("@angular/core").Signal<GlitchEffect>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpGlitch, never>;

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

@@ -1,6 +1,6 @@
 import { ElementRef } from '@angular/core';
 import { GodRaysEffect } from 'postprocessing';
-import { Mesh, Points } from 'three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
 export declare class NgtpGodRays {
     options: import("@angular/core").InputSignal<{
@@ -19,10 +19,13 @@ export declare class NgtpGodRays {
         kernelSize?: import("postprocessing").KernelSize;
         blur?: boolean;
     } & {
-        sun: Mesh | Points | ElementRef<Mesh | Points>;
+        sun: THREE.Mesh | THREE.Points | ElementRef<THREE.Mesh | THREE.Points> | (() => THREE.Mesh | THREE.Points | ElementRef<THREE.Mesh | THREE.Points> | undefined);
     }>;
     private effectComposer;
-    effect: import("@angular/core").Signal<GodRaysEffect>;
+    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

@@ -8,8 +8,9 @@ type GridOptions = NonNullable<ConstructorParameters<typeof GridEffect>[0]> & Pa
 }>;
 export declare class NgtpGrid {
     options: import("@angular/core").InputSignal<GridOptions>;
+    private effectOptions;
     private size;
-    effect: import("@angular/core").Signal<GridEffect>;
+    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>;

package/lib/effects/hue-saturation.d.ts

@@ -4,12 +4,13 @@ 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">>;
+    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/lens-flare.d.ts

@@ -1,5 +1,6 @@
+import { NgtVector3 } from 'angular-three';
 import { BlendFunction, Effect } from 'postprocessing';
-import { Color, Texture, Vector3, WebGLRenderTarget, WebGLRenderer } from 'three';
+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, }?: {
@@ -14,8 +15,8 @@ export declare class LensFlareEffect extends Effect {
         flareShape?: number | undefined;
         animated?: boolean | undefined;
         anamorphic?: boolean | undefined;
-        colorGain?: Color | undefined;
-        lensDirtTexture?: Texture | null | undefined;
+        colorGain?: THREE.Color | undefined;
+        lensDirtTexture?: THREE.Texture | null | undefined;
         haloScale?: number | undefined;
         secondaryGhosts?: boolean | undefined;
         aditionalStreaks?: boolean | undefined;
@@ -23,10 +24,10 @@ export declare class LensFlareEffect extends Effect {
         opacity?: number | undefined;
         starBurst?: boolean | undefined;
     });
-    update(_renderer: WebGLRenderer, _inputBuffer: WebGLRenderTarget, deltaTime: number): void;
+    update(_renderer: THREE.WebGLRenderer, _inputBuffer: THREE.WebGLRenderTarget, deltaTime: number): void;
 }
 export type LensFlareOptions = ConstructorParameters<typeof LensFlareEffect>[0] & {
-    position: Vector3;
+    position: NgtVector3;
     followMouse: boolean;
     smoothTime: number;
 };
@@ -43,8 +44,8 @@ export declare class NgtpLensFlare {
         flareShape?: number | undefined;
         animated?: boolean | undefined;
         anamorphic?: boolean | undefined;
-        colorGain?: Color | undefined;
-        lensDirtTexture?: Texture | null | undefined;
+        colorGain?: THREE.Color | undefined;
+        lensDirtTexture?: THREE.Texture | null | undefined;
         haloScale?: number | undefined;
         secondaryGhosts?: boolean | undefined;
         aditionalStreaks?: boolean | undefined;
@@ -52,7 +53,7 @@ export declare class NgtpLensFlare {
         opacity?: number | undefined;
         starBurst?: boolean | undefined;
     } & {
-        position: Vector3;
+        position: NgtVector3;
         followMouse: boolean;
         smoothTime: number;
     }, "" | Partial<{
@@ -67,8 +68,8 @@ export declare class NgtpLensFlare {
         flareShape?: number | undefined;
         animated?: boolean | undefined;
         anamorphic?: boolean | undefined;
-        colorGain?: Color | undefined;
-        lensDirtTexture?: Texture | null | undefined;
+        colorGain?: THREE.Color | undefined;
+        lensDirtTexture?: THREE.Texture | null | undefined;
         haloScale?: number | undefined;
         secondaryGhosts?: boolean | undefined;
         aditionalStreaks?: boolean | undefined;
@@ -76,18 +77,17 @@ export declare class NgtpLensFlare {
         opacity?: number | undefined;
         starBurst?: boolean | undefined;
     } & {
-        position: Vector3;
+        position: NgtVector3;
         followMouse: boolean;
         smoothTime: number;
     }>>;
     private store;
-    private viewport;
-    private raycaster;
-    private pointer;
     private effectComposer;
+    private effectOptions;
+    private position;
     private projectedPosition;
     private mouse2d;
-    effect: import("@angular/core").Signal<LensFlareEffect>;
+    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,17 +1,17 @@
 import { BlendFunction, LUT3DEffect } from 'postprocessing';
-import { Texture } from 'three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
 export interface LUTOptions {
-    lut: Texture;
+    lut: THREE.Texture;
     blendFunction?: BlendFunction;
     tetrahedralInterpolation?: boolean;
 }
 export declare class NgtpLUT {
     options: import("@angular/core").InputSignal<LUTOptions>;
     private lut;
+    private tetrahedralInterpolation;
     private store;
-    private invalidate;
-    effect: import("@angular/core").Signal<LUT3DEffect>;
+    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

@@ -4,11 +4,12 @@ import * as i0 from "@angular/core";
 import * as i1 from "../effect";
 export type NoiseEffectOptions = Partial<NonNullable<ConstructorParameters<typeof NoiseEffect>[0]>>;
 export declare class NgtpNoise {
-    effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
         blendFunction?: BlendFunction;
         premultiply?: boolean;
     }>, "blendFunction">>;
+    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,15 +1,15 @@
 import { ElementRef } from '@angular/core';
 import { OutlineEffect } from 'postprocessing';
-import { Object3D } from 'three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
 export type NgtpOutlineOptions = ConstructorParameters<typeof OutlineEffect>[2] & {
-    selection?: Array<Object3D | ElementRef<Object3D>>;
+    selection?: Array<THREE.Object3D | ElementRef<THREE.Object3D>>;
     selectionLayer: number;
 };
 export declare class NgtpOutline {
     options: import("@angular/core").InputSignalWithTransform<{
         blendFunction?: import("postprocessing").BlendFunction;
-        patternTexture?: import("three").Texture;
+        patternTexture?: THREE.Texture;
         patternScale?: number;
         edgeStrength?: number;
         pulseSpeed?: number;
@@ -25,11 +25,11 @@ export declare class NgtpOutline {
         blur?: boolean;
         xRay?: boolean;
     } & {
-        selection?: Array<Object3D | ElementRef<Object3D>>;
+        selection?: Array<THREE.Object3D | ElementRef<THREE.Object3D>>;
         selectionLayer: number;
     }, "" | Partial<{
         blendFunction?: import("postprocessing").BlendFunction;
-        patternTexture?: import("three").Texture;
+        patternTexture?: THREE.Texture;
         patternScale?: number;
         edgeStrength?: number;
         pulseSpeed?: number;
@@ -45,13 +45,12 @@ export declare class NgtpOutline {
         blur?: boolean;
         xRay?: boolean;
     } & {
-        selection?: Array<Object3D | ElementRef<Object3D>>;
+        selection?: Array<THREE.Object3D | ElementRef<THREE.Object3D>>;
         selectionLayer: number;
     }>>;
     private ngtSelection;
     private effectComposer;
     private store;
-    private invalidate;
     private selection;
     private selectionLayer;
     private blendFunction;

package/lib/effects/pixelation.d.ts

@@ -10,7 +10,7 @@ export declare class NgtpPixelation {
         granularity: number;
     }>>;
     private granularity;
-    effect: import("@angular/core").Signal<PixelationEffect>;
+    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

@@ -4,7 +4,6 @@ import * as i0 from "@angular/core";
 import * as i1 from "../effect";
 export type ScanlineEffectOptions = Partial<NonNullable<ConstructorParameters<typeof ScanlineEffect>[0]>>;
 export declare class NgtpScanline {
-    effect: NgtpEffect;
     options: import("@angular/core").InputSignalWithTransform<Omit<Partial<{
         blendFunction?: BlendFunction;
         density?: number;
@@ -12,6 +11,8 @@ export declare class NgtpScanline {
         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: {}; }]>;
 }

package/lib/effects/sepia.d.ts

@@ -4,11 +4,12 @@ import * as i0 from "@angular/core";
 import * as i1 from "../effect";
 export type SepiaEffectOptions = Partial<NonNullable<ConstructorParameters<typeof SepiaEffect>[0]>>;
 export declare class NgtpSepia {
-    effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
         blendFunction?: import("postprocessing").BlendFunction;
         intensity?: number;
     }>, "blendFunction">>;
+    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 i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
 }

package/lib/effects/shock-wave.d.ts

@@ -4,8 +4,9 @@ import * as i0 from "@angular/core";
 import * as i1 from "../effect";
 export type ShockWaveEffectOptions = Partial<NonNullable<ConstructorParameters<typeof ShockWaveEffect>[0]>>;
 export declare class NgtpShockWave {
-    effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<import("three").Camera>, "blendFunction">>;
+    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 i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
 }

package/lib/effects/smaa.d.ts

@@ -4,12 +4,13 @@ import * as i0 from "@angular/core";
 import * as i1 from "../effect";
 export type SMAAEffectOptions = Partial<NonNullable<ConstructorParameters<typeof SMAAEffect>[0]>>;
 export declare class NgtpSMAA {
-    effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
         preset?: import("postprocessing").SMAAPreset;
         edgeDetectionMode?: import("postprocessing").EdgeDetectionMode;
         predicationMode?: import("postprocessing").PredicationMode;
     }>, "blendFunction">>;
+    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 i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
 }

package/lib/effects/tilt-shift-2.d.ts

@@ -20,7 +20,6 @@ export declare class TiltShift2Effect extends Effect {
 }
 export type TiltShift2EffectOptions = Partial<NonNullable<ConstructorParameters<typeof TiltShift2Effect>[0]>>;
 export declare class NgtpTiltShift2 {
-    effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
         blendFunction?: BlendFunction | undefined;
         blur?: number | undefined;
@@ -30,6 +29,7 @@ export declare class NgtpTiltShift2 {
         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 i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
 }

package/lib/effects/tilt-shift.d.ts

@@ -4,7 +4,6 @@ import * as i0 from "@angular/core";
 import * as i1 from "../effect";
 export type TiltShiftEffectOptions = Partial<NonNullable<ConstructorParameters<typeof TiltShiftEffect>[0]>>;
 export declare class NgtpTiltShift {
-    effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
         blendFunction?: BlendFunction;
         offset?: number;
@@ -17,6 +16,8 @@ export declare class NgtpTiltShift {
         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 i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
 }

package/lib/effects/tone-mapping.d.ts

@@ -4,7 +4,6 @@ import * as i0 from "@angular/core";
 import * as i1 from "../effect";
 export type ToneMappingEffectOptions = NonNullable<ConstructorParameters<typeof ToneMappingEffect>[0]>;
 export declare class NgtpToneMapping {
-    effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<{
         blendFunction?: import("postprocessing").BlendFunction;
         adaptive?: boolean;
@@ -17,6 +16,8 @@ export declare class NgtpToneMapping {
         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 i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
 }

package/lib/effects/vignette.d.ts

@@ -4,7 +4,6 @@ import * as i0 from "@angular/core";
 import * as i1 from "../effect";
 export type VignetteEffectOptions = Partial<NonNullable<ConstructorParameters<typeof VignetteEffect>[0]>>;
 export declare class NgtpVignette {
-    effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
         blendFunction?: import("postprocessing").BlendFunction;
         technique?: import("postprocessing").VignetteTechnique;
@@ -12,6 +11,8 @@ export declare class NgtpVignette {
         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 i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
 }

package/lib/effects/water.d.ts

@@ -10,11 +10,12 @@ export declare class WaterEffect extends Effect {
 }
 export type WaterEffectOptions = Partial<NonNullable<ConstructorParameters<typeof WaterEffect>[0]>>;
 export declare class NgtpWater {
-    effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
         blendFunction?: BlendFunction | undefined;
         factor?: number | undefined;
     }>, "blendFunction">>;
+    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 i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;
 }