angular-three-postprocessing 2.2.0 → 2.3.0

package/lib/effect-composer.d.ts

@@ -19,7 +19,6 @@ export interface NgtpEffectComposerOptions {
 export declare class NgtpEffectComposer {
     options: import("@angular/core").InputSignalWithTransform<NgtpEffectComposerOptions, "" | Partial<NgtpEffectComposerOptions>>;
     private injector;
-    private autoEffect;
     private store;
     private size;
     private gl;
@@ -40,9 +39,6 @@ export declare class NgtpEffectComposer {
         downSamplingPass: DepthDownsamplingPass | null;
     }>;
     constructor();
-    private disableToneMapping;
-    private setComposerSize;
-    private updatePasses;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpEffectComposer, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtpEffectComposer, "ngtp-effect-composer", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

package/lib/effects/depth-of-field.d.ts

@@ -10,10 +10,9 @@ type DOFOptions = NonNullable<ConstructorParameters<typeof DepthOfFieldEffect>[1
     };
 }>;
 export declare class NgtpDepthOfField {
-    private autoEffect;
-    private effectComposer;
     options: import("@angular/core").InputSignal<DOFOptions>;
     private autoFocus;
+    private effectComposer;
     effect: import("@angular/core").Signal<DepthOfFieldEffect>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpDepthOfField, never>;

package/lib/effects/glitch.d.ts

@@ -10,9 +10,6 @@ export type GlitchOptions = NonNullable<ConstructorParameters<typeof GlitchEffec
     strength: NgtVector2;
 }>;
 export declare class NgtpGlitch {
-    private autoEffect;
-    private store;
-    private invalidate;
     options: import("@angular/core").InputSignalWithTransform<GlitchOptions, "" | Partial<{
         active: boolean;
     }>>;
@@ -22,6 +19,8 @@ export declare class NgtpGlitch {
     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

@@ -3,8 +3,6 @@ import { GodRaysEffect } from 'postprocessing';
 import { Mesh, Points } from 'three';
 import * as i0 from "@angular/core";
 export declare class NgtpGodRays {
-    private autoEffect;
-    private effectComposer;
     options: import("@angular/core").InputSignal<{
         blendFunction?: import("postprocessing").BlendFunction;
         samples?: number;
@@ -23,6 +21,7 @@ export declare class NgtpGodRays {
     } & {
         sun: Mesh | Points | ElementRef<Mesh | Points>;
     }>;
+    private effectComposer;
     effect: import("@angular/core").Signal<GodRaysEffect>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpGodRays, never>;

package/lib/effects/grid.d.ts

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

package/lib/effects/index.d.ts

@@ -23,5 +23,6 @@ export * from './shock-wave';
 export * from './smaa';
 export * from './tilt-shift';
 export * from './tilt-shift-2';
+export * from './tone-mapping';
 export * from './vignette';
 export * from './water';

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

@@ -1,6 +1,5 @@
 import { BlendFunction, Effect } from 'postprocessing';
 import { Color, Texture, Vector3, WebGLRenderTarget, WebGLRenderer } from 'three';
-import { NgtpEffectComposer } from '../effect-composer';
 import * as i0 from "@angular/core";
 export declare class LensFlareEffect extends Effect {
     constructor({ blendFunction, enabled, glareSize, lensPosition, iResolution, starPoints, flareSize, flareSpeed, flareShape, animated, anamorphic, colorGain, lensDirtTexture, haloScale, secondaryGhosts, aditionalStreaks, ghostScale, opacity, starBurst, }?: {
@@ -32,12 +31,6 @@ export type LensFlareOptions = ConstructorParameters<typeof LensFlareEffect>[0]
     smoothTime: number;
 };
 export declare class NgtpLensFlare {
-    private autoEffect;
-    private store;
-    private viewport;
-    private raycaster;
-    private pointer;
-    effectComposer: NgtpEffectComposer;
     options: import("@angular/core").InputSignalWithTransform<{
         blendFunction?: BlendFunction | undefined;
         enabled?: boolean | undefined;
@@ -87,6 +80,11 @@ export declare class NgtpLensFlare {
         followMouse: boolean;
         smoothTime: number;
     }>>;
+    private store;
+    private viewport;
+    private raycaster;
+    private pointer;
+    private effectComposer;
     private projectedPosition;
     private mouse2d;
     effect: import("@angular/core").Signal<LensFlareEffect>;

package/lib/effects/lut.d.ts

@@ -7,11 +7,10 @@ export interface LUTOptions {
     tetrahedralInterpolation?: boolean;
 }
 export declare class NgtpLUT {
-    private autoEffect;
-    private store;
-    private invalidate;
     options: import("@angular/core").InputSignal<LUTOptions>;
     private lut;
+    private store;
+    private invalidate;
     effect: import("@angular/core").Signal<LUT3DEffect>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpLUT, never>;

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

@@ -0,0 +1,43 @@
+import { ToneMappingEffect } from 'postprocessing';
+import * as i0 from "@angular/core";
+export type NgtpToneMappingOptions = Partial<NonNullable<ConstructorParameters<typeof ToneMappingEffect>[0]>>;
+export declare class NgtpToneMapping {
+    options: import("@angular/core").InputSignal<Partial<{
+        blendFunction?: import("postprocessing").BlendFunction;
+        adaptive?: boolean;
+        mode?: import("postprocessing").ToneMappingMode;
+        resolution?: number;
+        maxLuminance?: number;
+        whitePoint?: number;
+        middleGrey?: number;
+        minLuminance?: number;
+        averageLuminance?: number;
+        adaptationRate?: number;
+    }>>;
+    protected parameters: import("@angular/core").Signal<Omit<Partial<{
+        blendFunction?: import("postprocessing").BlendFunction;
+        adaptive?: boolean;
+        mode?: import("postprocessing").ToneMappingMode;
+        resolution?: number;
+        maxLuminance?: number;
+        whitePoint?: number;
+        middleGrey?: number;
+        minLuminance?: number;
+        averageLuminance?: number;
+        adaptationRate?: number;
+    }>, "blendFunction" | "mode" | "adaptive" | "resolution" | "maxLuminance" | "whitePoint" | "middleGrey" | "minLuminance" | "averageLuminance" | "adaptationRate">>;
+    private blendFunction;
+    private adaptive;
+    private mode;
+    private resolution;
+    private maxLuminance;
+    private whitePoint;
+    private middleGrey;
+    private minLuminance;
+    private averageLuminance;
+    private adaptationRate;
+    effect: import("@angular/core").Signal<ToneMappingEffect>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpToneMapping, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpToneMapping, "ngtp-tone-mapping", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/n8ao/README.md

@@ -0,0 +1,3 @@
+# angular-three-postprocessing/n8ao
+
+Secondary entry point of `angular-three-postprocessing`. It can be used by importing from `angular-three-postprocessing/n8ao`.

package/n8ao/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/n8ao';

package/n8ao/lib/n8ao.d.ts

@@ -0,0 +1,35 @@
+import { ColorRepresentation } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtpN8AOOptions {
+    aoRadius: number;
+    aoTones: number;
+    distanceFalloff: number;
+    intensity: number;
+    biasOffset: number;
+    biasMultiplier: number;
+    aoSamples: number;
+    denoiseSamples: number;
+    denoiseRadius: number;
+    color: ColorRepresentation;
+    halfRes: boolean;
+    depthAwareUpsampling: boolean;
+    screenSpaceRadius: boolean;
+    renderMode: 0 | 1 | 2 | 3 | 4;
+    denoiseIterations: number;
+    transparencyAware: boolean;
+    gammaCorrection: boolean;
+    logarithmicDepthBuffer: boolean;
+    colorMultiply: boolean;
+    accumulate: boolean;
+    quality?: 'performance' | 'low' | 'medium' | 'high' | 'ultra';
+}
+export declare class NgtpN8AO {
+    options: import("@angular/core").InputSignalWithTransform<NgtpN8AOOptions, "" | Partial<NgtpN8AOOptions>>;
+    private quality;
+    private effectComposer;
+    effect: import("@angular/core").Signal<any>;
+    constructor();
+    private setQualityEffect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtpN8AO, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtpN8AO, "ngtp-n8ao", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-three-postprocessing",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "publishConfig": {
     "access": "public"
   },
@@ -25,10 +25,16 @@
     "@angular/common": ">=18.0.0 <19.0.0",
     "@angular/core": ">=18.0.0 <19.0.0",
     "maath": ">=0.10.0 <0.11.0",
+    "n8ao": "^1.9.0",
     "postprocessing": "^6.0.0",
     "three": ">=0.148.0 <0.169.0",
     "three-stdlib": "^2.0.0"
   },
+  "peerDependenciesMeta": {
+    "n8ao": {
+      "optional": true
+    }
+  },
   "dependencies": {
     "tslib": "^2.7.0"
   },
@@ -48,6 +54,12 @@
       "esm2022": "./esm2022/angular-three-postprocessing.mjs",
       "esm": "./esm2022/angular-three-postprocessing.mjs",
       "default": "./fesm2022/angular-three-postprocessing.mjs"
+    },
+    "./n8ao": {
+      "types": "./n8ao/index.d.ts",
+      "esm2022": "./esm2022/n8ao/angular-three-postprocessing-n8ao.mjs",
+      "esm": "./esm2022/n8ao/angular-three-postprocessing-n8ao.mjs",
+      "default": "./fesm2022/angular-three-postprocessing-n8ao.mjs"
     }
   }
 }