angular-three-postprocessing 1.6.0 → 2.0.0-beta.3

package/README.md

@@ -1,15 +1,7 @@
-# Postprocessing for Angular Three using postprocessing
+# postprocessing
 
-## Installation
+This library was generated with [Nx](https://nx.dev).
 
-```shell
-ng add angular-three-postprocessing
-```
+## Running unit tests
 
-## Documentations
-
-Read more about Angular Three Postprocessing usages in [TBD: Documentations](#)
-
-## Contributions
-
-Contributions are welcomed
+Run `nx test postprocessing` to execute the unit tests.

package/effect-composer.d.ts

@@ -0,0 +1,53 @@
+import { InjectionToken, Signal } from '@angular/core';
+import { NgtSignalStore } from 'angular-three';
+import { DepthDownsamplingPass, EffectComposer, NormalPass } from 'postprocessing';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export interface NgtpEffectComposerState {
+    enabled: boolean;
+    depthBuffer?: boolean;
+    disableNormalPass?: boolean;
+    stencilBuffer?: boolean;
+    autoClear: boolean;
+    resolutionScale?: number;
+    multisampling: number;
+    frameBufferType: THREE.TextureDataType;
+    renderPriority: number;
+    camera?: THREE.Camera;
+    scene?: THREE.Scene;
+}
+export interface NgtpEffectComposerApi {
+    composer: EffectComposer;
+    normalPass: NormalPass | null;
+    downSamplingPass: DepthDownsamplingPass | null;
+    camera: THREE.Camera;
+    scene: THREE.Scene;
+    resolutionScale?: number;
+}
+export declare const NGTP_EFFECT_COMPOSER_API: InjectionToken<Signal<NgtpEffectComposerApi>>;
+export declare class NgtpEffectComposer extends NgtSignalStore<NgtpEffectComposerState> {
+    #private;
+    readonly composerRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+    set enabled(enabled: boolean);
+    set depthBuffer(depthBuffer: boolean);
+    set disableNormalPass(disableNormalPass: boolean);
+    set stencilBuffer(stencilBuffer: boolean);
+    set autoClear(autoClear: boolean);
+    set resolutionScale(resolutionScale: number);
+    set multisampling(multisampling: number);
+    set frameBufferType(frameBufferType: THREE.TextureDataType);
+    set renderPriority(renderPriority: number);
+    set camera(camera: THREE.Camera);
+    set scene(scene: THREE.Scene);
+    readonly api: Signal<{
+        composer: EffectComposer;
+        normalPass: NormalPass | null;
+        downSamplingPass: DepthDownsamplingPass | null;
+        resolutionScale: number | undefined;
+        camera: THREE.Camera;
+        scene: THREE.Scene;
+    }>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpEffectComposer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpEffectComposer, "ngtp-effect-composer", never, { "enabled": { "alias": "enabled"; "required": false; }; "depthBuffer": { "alias": "depthBuffer"; "required": false; }; "disableNormalPass": { "alias": "disableNormalPass"; "required": false; }; "stencilBuffer": { "alias": "stencilBuffer"; "required": false; }; "autoClear": { "alias": "autoClear"; "required": false; }; "resolutionScale": { "alias": "resolutionScale"; "required": false; }; "multisampling": { "alias": "multisampling"; "required": false; }; "frameBufferType": { "alias": "frameBufferType"; "required": false; }; "renderPriority": { "alias": "renderPriority"; "required": false; }; "camera": { "alias": "camera"; "required": false; }; "scene": { "alias": "scene"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/effect.d.ts

@@ -0,0 +1,24 @@
+import { NgtSignalStore, NgtStore } from 'angular-three';
+import { BlendFunction, Effect } from 'postprocessing';
+import * as i0 from "@angular/core";
+export declare abstract class NgtpEffect<T extends Effect> extends NgtSignalStore<{
+    blendFunction?: BlendFunction;
+    opacity?: number;
+}> {
+    #private;
+    effectRef: import("angular-three").NgtInjectedRef<T>;
+    set blendFunction(blendFunction: BlendFunction);
+    set opacity(opacity: number);
+    protected defaultBlendFunction: BlendFunction;
+    protected nativeArgs: () => never[];
+    readonly effectBlendFunction: import("@angular/core").Signal<BlendFunction | undefined>;
+    readonly effectOpacity: import("@angular/core").Signal<number | undefined>;
+    protected readonly store: NgtStore;
+    protected readonly camera: import("@angular/core").Signal<import("angular-three").NgtCameraManual>;
+    protected readonly args: import("@angular/core").Signal<{
+        [x: string]: any;
+    }[]>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpEffect<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtpEffect<any>, never, never, { "effectRef": { "alias": "effectRef"; "required": false; }; "blendFunction": { "alias": "blendFunction"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; }, {}, never, never, false, never>;
+}

package/effects/bloom/bloom.d.ts

@@ -0,0 +1,8 @@
+import { NgtpEffect } from 'angular-three-postprocessing';
+import { BlendFunction, BloomEffect } from 'postprocessing';
+import * as i0 from "@angular/core";
+export declare class NgtpBloom extends NgtpEffect<BloomEffect> {
+    defaultBlendFunction: BlendFunction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpBloom, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpBloom, "ngtp-bloom", never, {}, {}, never, ["*"], true, never>;
+}

package/effects/{lib/brightness-contrast → brightness-contrast}/brightness-contrast.d.ts

@@ -2,7 +2,6 @@ import { NgtpEffect } from 'angular-three-postprocessing';
 import { BrightnessContrastEffect } from 'postprocessing';
 import * as i0 from "@angular/core";
 export declare class NgtpBrightnessContrast extends NgtpEffect<BrightnessContrastEffect> {
-    get effectConstructor(): typeof BrightnessContrastEffect;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpBrightnessContrast, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpBrightnessContrast, "ngtp-brightness-contrast", never, { "brightness": { "alias": "brightness"; "required": false; }; "contrast": { "alias": "contrast"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpBrightnessContrast, "ngtp-brightness-contrast", never, {}, {}, never, ["*"], true, never>;
 }

package/effects/{lib/color-depth → color-depth}/color-depth.d.ts

@@ -2,7 +2,6 @@ import { NgtpEffect } from 'angular-three-postprocessing';
 import { ColorDepthEffect } from 'postprocessing';
 import * as i0 from "@angular/core";
 export declare class NgtpColorDepth extends NgtpEffect<ColorDepthEffect> {
-    get effectConstructor(): typeof ColorDepthEffect;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpColorDepth, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpColorDepth, "ngtp-color-depth", never, { "bits": { "alias": "bits"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpColorDepth, "ngtp-color-depth", never, {}, {}, never, ["*"], true, never>;
 }

package/effects/{lib/depth → depth}/depth.d.ts

@@ -2,7 +2,6 @@ import { NgtpEffect } from 'angular-three-postprocessing';
 import { DepthEffect } from 'postprocessing';
 import * as i0 from "@angular/core";
 export declare class NgtpDepth extends NgtpEffect<DepthEffect> {
-    get effectConstructor(): typeof DepthEffect;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpDepth, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpDepth, "ngtp-depth", never, { "inverted": { "alias": "inverted"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpDepth, "ngtp-depth", never, {}, {}, never, ["*"], true, never>;
 }

package/effects/{lib/dot-screen → dot-screen}/dot-screen.d.ts

@@ -2,7 +2,6 @@ import { NgtpEffect } from 'angular-three-postprocessing';
 import { DotScreenEffect } from 'postprocessing';
 import * as i0 from "@angular/core";
 export declare class NgtpDotScreen extends NgtpEffect<DotScreenEffect> {
-    get effectConstructor(): typeof DotScreenEffect;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpDotScreen, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpDotScreen, "ngtp-dot-screen", never, { "angle": { "alias": "angle"; "required": false; }; "scale": { "alias": "scale"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpDotScreen, "ngtp-dot-screen", never, {}, {}, never, ["*"], true, never>;
 }

package/effects/{lib/hue-saturation → hue-saturation}/hue-saturation.d.ts

@@ -2,7 +2,6 @@ import { NgtpEffect } from 'angular-three-postprocessing';
 import { HueSaturationEffect } from 'postprocessing';
 import * as i0 from "@angular/core";
 export declare class NgtpHueSaturation extends NgtpEffect<HueSaturationEffect> {
-    get effectConstructor(): typeof HueSaturationEffect;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpHueSaturation, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpHueSaturation, "ngtp-hue-saturation", never, { "hue": { "alias": "hue"; "required": false; }; "saturation": { "alias": "saturation"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpHueSaturation, "ngtp-hue-saturation", never, {}, {}, never, ["*"], true, never>;
 }

package/effects/index.d.ts

@@ -1,14 +1,16 @@
-export * from './lib/bloom/bloom';
-export * from './lib/brightness-contrast/brightness-contrast';
-export * from './lib/color-depth/color-depth';
-export * from './lib/depth/depth';
-export * from './lib/dot-screen/dot-screen';
-export * from './lib/hue-saturation/hue-saturation';
-export * from './lib/lut/lut';
-export * from './lib/noise/noise';
-export * from './lib/scanline/scanline';
-export * from './lib/sepia/sepia';
-export * from './lib/ssao/ssao';
-export * from './lib/tilt-shift/tilt-shift';
-export * from './lib/tone-mapping/tone-mapping';
-export * from './lib/vignette/vignette';
+export * from './bloom/bloom';
+export * from './brightness-contrast/brightness-contrast';
+export * from './color-depth/color-depth';
+export * from './depth/depth';
+export * from './dot-screen/dot-screen';
+export * from './hue-saturation/hue-saturation';
+export * from './lut/lut';
+export * from './noise/noise';
+export * from './scanline/scanline';
+export * from './sepia/sepia';
+export * from './shock-wave/shock-wave';
+export * from './smaa/smaa';
+export * from './ssao/ssao';
+export * from './tilt-shift/tilt-shift';
+export * from './tone-mapping/tone-mapping';
+export * from './vignette/vignette';

package/effects/lut/lut.d.ts

@@ -0,0 +1,19 @@
+import { NgtSignalStore } from 'angular-three';
+import { BlendFunction, LUT3DEffect } from 'postprocessing';
+import * as i0 from "@angular/core";
+export interface NgtpLUTState {
+    lut: THREE.Texture;
+    blendFunction?: BlendFunction;
+    tetrahedralInterpolation?: boolean;
+}
+export declare class NgtpLUT extends NgtSignalStore<NgtpLUTState> {
+    #private;
+    effectRef: import("angular-three").NgtInjectedRef<LUT3DEffect>;
+    set lut(lut: THREE.Texture);
+    set blendFunction(blendFunction: BlendFunction);
+    set tetrahedralInterpolation(tetrahedralInterpolation: boolean);
+    readonly effect: import("@angular/core").Signal<LUT3DEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpLUT, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpLUT, "ngtp-lut", never, { "effectRef": { "alias": "effectRef"; "required": false; }; "lut": { "alias": "lut"; "required": true; }; "blendFunction": { "alias": "blendFunction"; "required": false; }; "tetrahedralInterpolation": { "alias": "tetrahedralInterpolation"; "required": false; }; }, {}, never, never, true, never>;
+}

package/effects/{lib/noise → noise}/noise.d.ts

@@ -2,8 +2,7 @@ import { NgtpEffect } from 'angular-three-postprocessing';
 import { BlendFunction, NoiseEffect } from 'postprocessing';
 import * as i0 from "@angular/core";
 export declare class NgtpNoise extends NgtpEffect<NoiseEffect> {
-    get effectConstructor(): typeof NoiseEffect;
-    defaultBlendMode: BlendFunction;
+    defaultBlendFunction: BlendFunction;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpNoise, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpNoise, "ngtp-noise", never, { "premultiply": { "alias": "premultiply"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpNoise, "ngtp-noise", never, {}, {}, never, ["*"], true, never>;
 }

package/effects/{lib/scanline → scanline}/scanline.d.ts

@@ -2,8 +2,7 @@ import { NgtpEffect } from 'angular-three-postprocessing';
 import { BlendFunction, ScanlineEffect } from 'postprocessing';
 import * as i0 from "@angular/core";
 export declare class NgtpScanline extends NgtpEffect<ScanlineEffect> {
-    get effectConstructor(): typeof ScanlineEffect;
-    defaultBlendMode: BlendFunction;
+    defaultBlendFunction: BlendFunction;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpScanline, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpScanline, "ngtp-scanline", never, { "density": { "alias": "density"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpScanline, "ngtp-scanline", never, {}, {}, never, ["*"], true, never>;
 }

package/effects/{lib/sepia → sepia}/sepia.d.ts

@@ -2,7 +2,6 @@ import { NgtpEffect } from 'angular-three-postprocessing';
 import { SepiaEffect } from 'postprocessing';
 import * as i0 from "@angular/core";
 export declare class NgtpSepia extends NgtpEffect<SepiaEffect> {
-    get effectConstructor(): typeof SepiaEffect;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpSepia, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpSepia, "ngtp-sepia", never, { "intensity": { "alias": "intensity"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpSepia, "ngtp-sepia", never, {}, {}, never, ["*"], true, never>;
 }

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

@@ -0,0 +1,7 @@
+import { NgtpEffect } from 'angular-three-postprocessing';
+import { ShockWaveEffect } from 'postprocessing';
+import * as i0 from "@angular/core";
+export declare class NgtpShockWave extends NgtpEffect<ShockWaveEffect> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpShockWave, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpShockWave, "ngtp-noise", never, {}, {}, never, ["*"], true, never>;
+}

package/effects/smaa/smaa.d.ts

@@ -0,0 +1,7 @@
+import { NgtpEffect } from 'angular-three-postprocessing';
+import { SMAAEffect } from 'postprocessing';
+import * as i0 from "@angular/core";
+export declare class NgtpSMAA extends NgtpEffect<SMAAEffect> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpSMAA, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpSMAA, "ngtp-SMAA", never, {}, {}, never, ["*"], true, never>;
+}

package/effects/ssao/ssao.d.ts

@@ -0,0 +1,38 @@
+import { NgtSignalStore } from 'angular-three';
+import { BlendFunction, SSAOEffect } from 'postprocessing';
+import * as i0 from "@angular/core";
+export type NgtpSSAOState = NonNullable<ConstructorParameters<typeof SSAOEffect>[2]>;
+export declare class NgtpSSAO extends NgtSignalStore<NgtpSSAOState> {
+    #private;
+    effectRef: import("angular-three").NgtInjectedRef<SSAOEffect>;
+    set blendFunction(blendFunction: BlendFunction);
+    set distanceScaling(distanceScaling: boolean);
+    set depthAwareUpsampling(depthAwareUpsampling: boolean);
+    set normalDepthBuffer(normalDepthBuffer: THREE.Texture);
+    set samples(samples: number);
+    set rings(rings: number);
+    set worldDistanceThreshold(worldDistanceThreshold: number);
+    set worldDistanceFalloff(worldDistanceFalloff: number);
+    set worldProximityThreshold(worldProximityThreshold: number);
+    set worldProximityFalloff(worldProximityFalloff: number);
+    set distanceThreshold(distanceThreshold: number);
+    set distanceFalloff(distanceFalloff: number);
+    set rangeThreshold(rangeThreshold: number);
+    set rangeFalloff(rangeFalloff: number);
+    set minRadiusScale(minRadiusScale: number);
+    set luminanceInfluence(luminanceInfluence: number);
+    set radius(radius: number);
+    set intensity(intensity: number);
+    set bias(bias: number);
+    set fade(fade: number);
+    set color(color: THREE.Color);
+    set resolutionScale(resolutionScale: number);
+    set resolutionX(resolutionX: number);
+    set resolutionY(resolutionY: number);
+    set width(width: number);
+    set height(height: number);
+    readonly effect: import("@angular/core").Signal<{}>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpSSAO, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpSSAO, "ngtp-SSAO", never, { "effectRef": { "alias": "effectRef"; "required": false; }; "blendFunction": { "alias": "blendFunction"; "required": false; }; "distanceScaling": { "alias": "distanceScaling"; "required": false; }; "depthAwareUpsampling": { "alias": "depthAwareUpsampling"; "required": false; }; "normalDepthBuffer": { "alias": "normalDepthBuffer"; "required": false; }; "samples": { "alias": "samples"; "required": false; }; "rings": { "alias": "rings"; "required": false; }; "worldDistanceThreshold": { "alias": "worldDistanceThreshold"; "required": false; }; "worldDistanceFalloff": { "alias": "worldDistanceFalloff"; "required": false; }; "worldProximityThreshold": { "alias": "worldProximityThreshold"; "required": false; }; "worldProximityFalloff": { "alias": "worldProximityFalloff"; "required": false; }; "distanceThreshold": { "alias": "distanceThreshold"; "required": false; }; "distanceFalloff": { "alias": "distanceFalloff"; "required": false; }; "rangeThreshold": { "alias": "rangeThreshold"; "required": false; }; "rangeFalloff": { "alias": "rangeFalloff"; "required": false; }; "minRadiusScale": { "alias": "minRadiusScale"; "required": false; }; "luminanceInfluence": { "alias": "luminanceInfluence"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "intensity": { "alias": "intensity"; "required": false; }; "bias": { "alias": "bias"; "required": false; }; "fade": { "alias": "fade"; "required": false; }; "color": { "alias": "color"; "required": false; }; "resolutionScale": { "alias": "resolutionScale"; "required": false; }; "resolutionX": { "alias": "resolutionX"; "required": false; }; "resolutionY": { "alias": "resolutionY"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,8 @@
+import { NgtpEffect } from 'angular-three-postprocessing';
+import { BlendFunction, TiltShiftEffect } from 'postprocessing';
+import * as i0 from "@angular/core";
+export declare class NgtpTiltShift extends NgtpEffect<TiltShiftEffect> {
+    defaultBlendFunction: BlendFunction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpTiltShift, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpTiltShift, "ngtp-tilt-shift", never, {}, {}, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,7 @@
+import { NgtpEffect } from 'angular-three-postprocessing';
+import { ToneMappingEffect } from 'postprocessing';
+import * as i0 from "@angular/core";
+export declare class NgtpToneMapping extends NgtpEffect<ToneMappingEffect> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpToneMapping, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpToneMapping, "ngtp-tone-mapping", never, {}, {}, never, ["*"], true, never>;
+}

package/effects/{lib/vignette → vignette}/vignette.d.ts

@@ -2,7 +2,6 @@ import { NgtpEffect } from 'angular-three-postprocessing';
 import { VignetteEffect } from 'postprocessing';
 import * as i0 from "@angular/core";
 export declare class NgtpVignette extends NgtpEffect<VignetteEffect> {
-    get effectConstructor(): typeof VignetteEffect;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpVignette, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpVignette, "ngtp-vignette", never, { "technique": { "alias": "technique"; "required": false; }; "eskil": { "alias": "eskil"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "darkness": { "alias": "darkness"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpVignette, "ngtp-vignette", never, {}, {}, never, ["*"], true, never>;
 }

package/esm2022/angular-three-postprocessing.mjs

@@ -2,4 +2,4 @@
  * Generated bundle index. Do not edit.
  */
 export * from './index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1wb3N0cHJvY2Vzc2luZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci10aHJlZS1wb3N0cHJvY2Vzc2luZy9zcmMvYW5ndWxhci10aHJlZS1wb3N0cHJvY2Vzc2luZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1wb3N0cHJvY2Vzc2luZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnMvcG9zdHByb2Nlc3Npbmcvc3JjL2FuZ3VsYXItdGhyZWUtcG9zdHByb2Nlc3NpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/effect-composer.mjs

@@ -0,0 +1,242 @@
+import { CUSTOM_ELEMENTS_SCHEMA, Component, InjectionToken, Input, computed, effect, inject, } from '@angular/core';
+import { NgtSignalStore, NgtStore, extend, injectBeforeRender, injectNgtRef, requestAnimationInInjectionContext, } from 'angular-three';
+import { DepthDownsamplingPass, EffectComposer, EffectPass, NormalPass, RenderPass } from 'postprocessing';
+import * as THREE from 'three';
+import { Group } from 'three';
+import { isWebGL2Available } from 'three-stdlib';
+import * as i0 from "@angular/core";
+extend({ Group });
+export const NGTP_EFFECT_COMPOSER_API = new InjectionToken('NgtpEffectComposer API');
+class NgtpEffectComposer extends NgtSignalStore {
+    set enabled(enabled) {
+        this.set({ enabled });
+    }
+    set depthBuffer(depthBuffer) {
+        this.set({ depthBuffer });
+    }
+    set disableNormalPass(disableNormalPass) {
+        this.set({ disableNormalPass });
+    }
+    set stencilBuffer(stencilBuffer) {
+        this.set({ stencilBuffer });
+    }
+    set autoClear(autoClear) {
+        this.set({ autoClear });
+    }
+    set resolutionScale(resolutionScale) {
+        this.set({ resolutionScale });
+    }
+    set multisampling(multisampling) {
+        this.set({ multisampling });
+    }
+    set frameBufferType(frameBufferType) {
+        this.set({ frameBufferType });
+    }
+    set renderPriority(renderPriority) {
+        this.set({ renderPriority });
+    }
+    set camera(camera) {
+        this.set({ camera });
+    }
+    set scene(scene) {
+        this.set({ scene });
+    }
+    #store;
+    #gl;
+    #size;
+    #defaultScene;
+    #defaultCamera;
+    #scene;
+    #camera;
+    #depthBuffer;
+    #stencilBuffer;
+    #multisampling;
+    #frameBufferType;
+    #disableNormalPass;
+    #resolutionScale;
+    #activeScene;
+    #activeCamera;
+    #composerEntities;
+    constructor() {
+        super({
+            enabled: true,
+            renderPriority: 1,
+            autoClear: true,
+            multisampling: 8,
+            frameBufferType: THREE.HalfFloatType,
+        });
+        this.composerRef = injectNgtRef();
+        this.#store = inject(NgtStore);
+        this.#gl = this.#store.select('gl');
+        this.#size = this.#store.select('size');
+        this.#defaultScene = this.#store.select('scene');
+        this.#defaultCamera = this.#store.select('camera');
+        this.#scene = this.select('scene');
+        this.#camera = this.select('camera');
+        this.#depthBuffer = this.select('depthBuffer');
+        this.#stencilBuffer = this.select('stencilBuffer');
+        this.#multisampling = this.select('multisampling');
+        this.#frameBufferType = this.select('frameBufferType');
+        this.#disableNormalPass = this.select('disableNormalPass');
+        this.#resolutionScale = this.select('resolutionScale');
+        this.#activeScene = computed(() => this.#scene() || this.#defaultScene());
+        this.#activeCamera = computed(() => this.#camera() || this.#defaultCamera());
+        this.#composerEntities = computed(() => {
+            const gl = this.#gl();
+            const camera = this.#activeCamera();
+            const scene = this.#activeScene();
+            const depthBuffer = this.#depthBuffer();
+            const stencilBuffer = this.#stencilBuffer();
+            const multisampling = this.#multisampling();
+            const frameBufferType = this.#frameBufferType();
+            const disableNormalPass = this.#disableNormalPass();
+            const resolutionScale = this.#resolutionScale();
+            const webGL2Available = isWebGL2Available();
+            // Initialize composer
+            const effectComposer = new EffectComposer(gl, {
+                depthBuffer,
+                stencilBuffer,
+                multisampling: multisampling > 0 && webGL2Available ? multisampling : 0,
+                frameBufferType,
+            });
+            // Add render pass
+            effectComposer.addPass(new RenderPass(scene, camera));
+            // Create normal pass
+            let downSamplingPass = null;
+            let normalPass = null;
+            if (!disableNormalPass) {
+                normalPass = new NormalPass(scene, camera);
+                normalPass.enabled = false;
+                effectComposer.addPass(normalPass);
+                if (resolutionScale !== undefined && webGL2Available) {
+                    downSamplingPass = new DepthDownsamplingPass({ normalBuffer: normalPass.texture, resolutionScale });
+                    downSamplingPass.enabled = false;
+                    effectComposer.addPass(downSamplingPass);
+                }
+            }
+            return { effectComposer, normalPass, downSamplingPass };
+        });
+        this.api = computed(() => {
+            const { effectComposer, normalPass, downSamplingPass } = this.#composerEntities();
+            return {
+                composer: effectComposer,
+                normalPass,
+                downSamplingPass,
+                resolutionScale: this.#resolutionScale(),
+                camera: this.#activeCamera(),
+                scene: this.#activeScene(),
+            };
+        });
+        requestAnimationInInjectionContext(() => {
+            this.#setComposerSize();
+            this.#updateEffectPasses();
+            this.#setBeforeRender();
+        });
+    }
+    #setComposerSize() {
+        const trigger = computed(() => ({ composer: this.#composerEntities().effectComposer, size: this.#size() }));
+        effect(() => {
+            const { composer, size } = trigger();
+            if (!composer)
+                return;
+            composer.setSize(size.width, size.height);
+        });
+    }
+    #updateEffectPasses() {
+        const trigger = computed(() => ({
+            composerEntities: this.#composerEntities(),
+            instance: this.composerRef.nativeElement,
+            children: this.composerRef.children('nonObjects')(),
+            camera: this.#activeCamera(),
+        }));
+        effect((onCleanup) => {
+            const { composerEntities: { effectComposer, normalPass, downSamplingPass }, instance, children, camera, } = trigger();
+            let effectPass;
+            if (instance && children.length && effectComposer) {
+                effectPass = new EffectPass(camera, ...children);
+                effectPass.renderToScreen = true;
+                effectComposer.addPass(effectPass);
+                if (normalPass)
+                    normalPass.enabled = true;
+                if (downSamplingPass)
+                    downSamplingPass.enabled = true;
+            }
+            onCleanup(() => {
+                if (effectPass)
+                    effectComposer?.removePass(effectPass);
+                if (normalPass)
+                    normalPass.enabled = false;
+                if (downSamplingPass)
+                    downSamplingPass.enabled = false;
+            });
+        });
+    }
+    #setBeforeRender() {
+        injectBeforeRender(({ delta }) => {
+            const enabled = this.get('enabled');
+            const autoClear = this.get('autoClear');
+            const gl = this.#store.get('gl');
+            const { effectComposer } = this.#composerEntities();
+            if (enabled && effectComposer) {
+                gl.autoClear = autoClear;
+                effectComposer.render(delta);
+            }
+        }, { priority: this.get('enabled') ? this.get('renderPriority') : 0 });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtpEffectComposer, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtpEffectComposer, isStandalone: true, selector: "ngtp-effect-composer", inputs: { enabled: "enabled", depthBuffer: "depthBuffer", disableNormalPass: "disableNormalPass", stencilBuffer: "stencilBuffer", autoClear: "autoClear", resolutionScale: "resolutionScale", multisampling: "multisampling", frameBufferType: "frameBufferType", renderPriority: "renderPriority", camera: "camera", scene: "scene" }, providers: [
+            {
+                provide: NGTP_EFFECT_COMPOSER_API,
+                useFactory: (composer) => composer.api,
+                deps: [NgtpEffectComposer],
+            },
+        ], usesInheritance: true, ngImport: i0, template: `
+        <ngt-group [ref]="composerRef">
+            <ng-content />
+        </ngt-group>
+    `, isInline: true }); }
+}
+export { NgtpEffectComposer };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtpEffectComposer, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtp-effect-composer',
+                    standalone: true,
+                    template: `
+        <ngt-group [ref]="composerRef">
+            <ng-content />
+        </ngt-group>
+    `,
+                    providers: [
+                        {
+                            provide: NGTP_EFFECT_COMPOSER_API,
+                            useFactory: (composer) => composer.api,
+                            deps: [NgtpEffectComposer],
+                        },
+                    ],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { enabled: [{
+                type: Input
+            }], depthBuffer: [{
+                type: Input
+            }], disableNormalPass: [{
+                type: Input
+            }], stencilBuffer: [{
+                type: Input
+            }], autoClear: [{
+                type: Input
+            }], resolutionScale: [{
+                type: Input
+            }], multisampling: [{
+                type: Input
+            }], frameBufferType: [{
+                type: Input
+            }], renderPriority: [{
+                type: Input
+            }], camera: [{
+                type: Input
+            }], scene: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"effect-composer.js","sourceRoot":"","sources":["../../../../libs/postprocessing/src/effect-composer.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    CUSTOM_ELEMENTS_SCHEMA,\n    Component,\n    InjectionToken,\n    Input,\n    Signal,\n    computed,\n    effect,\n    inject,\n} from '@angular/core';\nimport {\n    NgtSignalStore,\n    NgtStore,\n    extend,\n    injectBeforeRender,\n    injectNgtRef,\n    requestAnimationInInjectionContext,\n} from 'angular-three';\nimport { DepthDownsamplingPass, EffectComposer, EffectPass, NormalPass, RenderPass } from 'postprocessing';\nimport * as THREE from 'three';\nimport { Group } from 'three';\nimport { isWebGL2Available } from 'three-stdlib';\n\nextend({ Group });\n\nexport interface NgtpEffectComposerState {\n    enabled: boolean;\n    depthBuffer?: boolean;\n    disableNormalPass?: boolean;\n    stencilBuffer?: boolean;\n    autoClear: boolean;\n    resolutionScale?: number;\n    multisampling: number;\n    frameBufferType: THREE.TextureDataType;\n    renderPriority: number;\n    camera?: THREE.Camera;\n    scene?: THREE.Scene;\n}\n\nexport interface NgtpEffectComposerApi {\n    composer: EffectComposer;\n    normalPass: NormalPass | null;\n    downSamplingPass: DepthDownsamplingPass | null;\n    camera: THREE.Camera;\n    scene: THREE.Scene;\n    resolutionScale?: number;\n}\n\nexport const NGTP_EFFECT_COMPOSER_API = new InjectionToken<Signal<NgtpEffectComposerApi>>('NgtpEffectComposer API');\n\n@Component({\n    selector: 'ngtp-effect-composer',\n    standalone: true,\n    template: `\n        <ngt-group [ref]=\"composerRef\">\n            <ng-content />\n        </ngt-group>\n    `,\n    providers: [\n        {\n            provide: NGTP_EFFECT_COMPOSER_API,\n            useFactory: (composer: NgtpEffectComposer) => composer.api,\n            deps: [NgtpEffectComposer],\n        },\n    ],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtpEffectComposer extends NgtSignalStore<NgtpEffectComposerState> {\n    readonly composerRef = injectNgtRef<THREE.Group>();\n\n    @Input() set enabled(enabled: boolean) {\n        this.set({ enabled });\n    }\n\n    @Input() set depthBuffer(depthBuffer: boolean) {\n        this.set({ depthBuffer });\n    }\n\n    @Input() set disableNormalPass(disableNormalPass: boolean) {\n        this.set({ disableNormalPass });\n    }\n\n    @Input() set stencilBuffer(stencilBuffer: boolean) {\n        this.set({ stencilBuffer });\n    }\n\n    @Input() set autoClear(autoClear: boolean) {\n        this.set({ autoClear });\n    }\n\n    @Input() set resolutionScale(resolutionScale: number) {\n        this.set({ resolutionScale });\n    }\n\n    @Input() set multisampling(multisampling: number) {\n        this.set({ multisampling });\n    }\n\n    @Input() set frameBufferType(frameBufferType: THREE.TextureDataType) {\n        this.set({ frameBufferType });\n    }\n\n    @Input() set renderPriority(renderPriority: number) {\n        this.set({ renderPriority });\n    }\n\n    @Input() set camera(camera: THREE.Camera) {\n        this.set({ camera });\n    }\n\n    @Input() set scene(scene: THREE.Scene) {\n        this.set({ scene });\n    }\n\n    readonly #store = inject(NgtStore);\n    readonly #gl = this.#store.select('gl');\n    readonly #size = this.#store.select('size');\n    readonly #defaultScene = this.#store.select('scene');\n    readonly #defaultCamera = this.#store.select('camera');\n\n    readonly #scene = this.select('scene');\n    readonly #camera = this.select('camera');\n\n    readonly #depthBuffer = this.select('depthBuffer');\n    readonly #stencilBuffer = this.select('stencilBuffer');\n    readonly #multisampling = this.select('multisampling');\n    readonly #frameBufferType = this.select('frameBufferType');\n    readonly #disableNormalPass = this.select('disableNormalPass');\n    readonly #resolutionScale = this.select('resolutionScale');\n\n    readonly #activeScene = computed(() => this.#scene() || this.#defaultScene());\n    readonly #activeCamera = computed(() => this.#camera() || this.#defaultCamera());\n\n    readonly #composerEntities = computed(() => {\n        const gl = this.#gl();\n        const camera = this.#activeCamera();\n        const scene = this.#activeScene();\n        const depthBuffer = this.#depthBuffer();\n        const stencilBuffer = this.#stencilBuffer();\n        const multisampling = this.#multisampling();\n        const frameBufferType = this.#frameBufferType();\n        const disableNormalPass = this.#disableNormalPass();\n        const resolutionScale = this.#resolutionScale();\n\n        const webGL2Available = isWebGL2Available();\n        // Initialize composer\n        const effectComposer = new EffectComposer(gl, {\n            depthBuffer,\n            stencilBuffer,\n            multisampling: multisampling > 0 && webGL2Available ? multisampling : 0,\n            frameBufferType,\n        });\n\n        // Add render pass\n        effectComposer.addPass(new RenderPass(scene, camera));\n\n        // Create normal pass\n        let downSamplingPass = null;\n        let normalPass = null;\n        if (!disableNormalPass) {\n            normalPass = new NormalPass(scene, camera);\n            normalPass.enabled = false;\n            effectComposer.addPass(normalPass);\n            if (resolutionScale !== undefined && webGL2Available) {\n                downSamplingPass = new DepthDownsamplingPass({ normalBuffer: normalPass.texture, resolutionScale });\n                downSamplingPass.enabled = false;\n                effectComposer.addPass(downSamplingPass);\n            }\n        }\n\n        return { effectComposer, normalPass, downSamplingPass };\n    });\n\n    readonly api = computed(() => {\n        const { effectComposer, normalPass, downSamplingPass } = this.#composerEntities();\n        return {\n            composer: effectComposer,\n            normalPass,\n            downSamplingPass,\n            resolutionScale: this.#resolutionScale(),\n            camera: this.#activeCamera(),\n            scene: this.#activeScene(),\n        };\n    });\n\n    constructor() {\n        super({\n            enabled: true,\n            renderPriority: 1,\n            autoClear: true,\n            multisampling: 8,\n            frameBufferType: THREE.HalfFloatType,\n        });\n        requestAnimationInInjectionContext(() => {\n            this.#setComposerSize();\n            this.#updateEffectPasses();\n            this.#setBeforeRender();\n        });\n    }\n\n    #setComposerSize() {\n        const trigger = computed(() => ({ composer: this.#composerEntities().effectComposer, size: this.#size() }));\n        effect(() => {\n            const { composer, size } = trigger();\n            if (!composer) return;\n            composer.setSize(size.width, size.height);\n        });\n    }\n\n    #updateEffectPasses() {\n        const trigger = computed(() => ({\n            composerEntities: this.#composerEntities(),\n            instance: this.composerRef.nativeElement,\n            children: this.composerRef.children('nonObjects')(),\n            camera: this.#activeCamera(),\n        }));\n        effect((onCleanup) => {\n            const {\n                composerEntities: { effectComposer, normalPass, downSamplingPass },\n                instance,\n                children,\n                camera,\n            } = trigger();\n\n            let effectPass: EffectPass;\n            if (instance && children.length && effectComposer) {\n                effectPass = new EffectPass(camera, ...children);\n                effectPass.renderToScreen = true;\n                effectComposer.addPass(effectPass);\n                if (normalPass) normalPass.enabled = true;\n                if (downSamplingPass) downSamplingPass.enabled = true;\n            }\n\n            onCleanup(() => {\n                if (effectPass) effectComposer?.removePass(effectPass);\n                if (normalPass) normalPass.enabled = false;\n                if (downSamplingPass) downSamplingPass.enabled = false;\n            });\n        });\n    }\n\n    #setBeforeRender() {\n        injectBeforeRender(\n            ({ delta }) => {\n                const enabled = this.get('enabled');\n                const autoClear = this.get('autoClear');\n                const gl = this.#store.get('gl');\n                const { effectComposer } = this.#composerEntities();\n                if (enabled && effectComposer) {\n                    gl.autoClear = autoClear;\n                    effectComposer.render(delta);\n                }\n            },\n            { priority: this.get('enabled') ? this.get('renderPriority') : 0 }\n        );\n    }\n}\n"]}