angular-three-soba 2.0.0-beta.4 → 2.0.0-beta.41

package/staging/environment/environment-input.d.ts

@@ -1,9 +1,8 @@
 import { ElementRef } from '@angular/core';
-import { NgtSignalStore } from 'angular-three';
-import { Loader, Scene, Texture, TextureEncoding } from 'three';
-import { NgtsEnvironmentPresetsType } from './assets';
+import type { Loader, Scene, Texture, TextureEncoding } from 'three';
+import type { NgtsEnvironmentPresetsType } from './assets';
 import * as i0 from "@angular/core";
-export interface NgtsEnvironmentInputState {
+export type NgtsEnvironmentInputState = {
     frames?: number;
     near?: number;
     far?: number;
@@ -22,47 +21,48 @@ export interface NgtsEnvironmentInputState {
         scale?: number;
     };
     encoding?: TextureEncoding;
-}
-export declare abstract class NgtsEnvironmentInput extends NgtSignalStore<NgtsEnvironmentInputState> {
-    set frames(frames: NgtsEnvironmentInputState['frames']);
-    set near(near: NgtsEnvironmentInputState['near']);
-    set far(far: NgtsEnvironmentInputState['far']);
-    set resolution(resolution: NgtsEnvironmentInputState['resolution']);
-    set background(background: NgtsEnvironmentInputState['background']);
-    set blur(blur: NgtsEnvironmentInputState['blur']);
-    set map(map: NgtsEnvironmentInputState['map']);
-    set files(files: NgtsEnvironmentInputState['files']);
-    set path(path: NgtsEnvironmentInputState['path']);
-    set preset(preset: NgtsEnvironmentInputState['preset']);
-    set scene(scene: NgtsEnvironmentInputState['scene']);
-    set extensions(extensions: NgtsEnvironmentInputState['extensions']);
-    set ground(ground: NgtsEnvironmentInputState['ground']);
-    set encoding(encoding: NgtsEnvironmentInputState['encoding']);
-    readonly environmentFrames: import("@angular/core").Signal<number | undefined>;
-    readonly environmentNear: import("@angular/core").Signal<number | undefined>;
-    readonly environmentFar: import("@angular/core").Signal<number | undefined>;
-    readonly environmentResolution: import("@angular/core").Signal<number | undefined>;
-    readonly environmentBackground: import("@angular/core").Signal<boolean | "only" | undefined>;
-    readonly environmentBlur: import("@angular/core").Signal<number | undefined>;
-    readonly environmentMap: import("@angular/core").Signal<Texture | undefined>;
-    readonly environmentFiles: import("@angular/core").Signal<string | string[] | undefined>;
-    readonly environmentPath: import("@angular/core").Signal<string | undefined>;
-    readonly environmentPreset: import("@angular/core").Signal<"sunset" | "dawn" | "night" | "warehouse" | "forest" | "apartment" | "studio" | "city" | "park" | "lobby" | undefined>;
-    readonly environmentScene: import("@angular/core").Signal<Scene | ElementRef<Scene> | undefined>;
-    readonly environmentExtensions: import("@angular/core").Signal<((loader: Loader) => void) | undefined>;
-    readonly environmentGround: import("@angular/core").Signal<boolean | {
+};
+export declare abstract class NgtsEnvironmentInput {
+    inputs: import("angular-three").NgtSignalStore<NgtsEnvironmentInputState>;
+    set _frames(frames: NgtsEnvironmentInputState['frames']);
+    set _near(near: NgtsEnvironmentInputState['near']);
+    set _far(far: NgtsEnvironmentInputState['far']);
+    set _resolution(resolution: NgtsEnvironmentInputState['resolution']);
+    set _background(background: NgtsEnvironmentInputState['background']);
+    set _blur(blur: NgtsEnvironmentInputState['blur']);
+    set _map(map: NgtsEnvironmentInputState['map']);
+    set _files(files: NgtsEnvironmentInputState['files']);
+    set _path(path: NgtsEnvironmentInputState['path']);
+    set _preset(preset: NgtsEnvironmentInputState['preset']);
+    set _scene(scene: NgtsEnvironmentInputState['scene']);
+    set _extensions(extensions: NgtsEnvironmentInputState['extensions']);
+    set _ground(ground: NgtsEnvironmentInputState['ground']);
+    set _encoding(encoding: NgtsEnvironmentInputState['encoding']);
+    frames: import("@angular/core").Signal<number | undefined>;
+    near: import("@angular/core").Signal<number | undefined>;
+    far: import("@angular/core").Signal<number | undefined>;
+    resolution: import("@angular/core").Signal<number | undefined>;
+    background: import("@angular/core").Signal<boolean | "only" | undefined>;
+    blur: import("@angular/core").Signal<number | undefined>;
+    map: import("@angular/core").Signal<Texture | undefined>;
+    files: import("@angular/core").Signal<string | string[] | undefined>;
+    path: import("@angular/core").Signal<string | undefined>;
+    preset: import("@angular/core").Signal<"apartment" | "city" | "dawn" | "forest" | "lobby" | "night" | "park" | "studio" | "sunset" | "warehouse" | undefined>;
+    scene: import("@angular/core").Signal<Scene | ElementRef<Scene> | undefined>;
+    extensions: import("@angular/core").Signal<((loader: Loader<unknown, string>) => void) | undefined>;
+    ground: import("@angular/core").Signal<boolean | {
         radius?: number | undefined;
         height?: number | undefined;
         scale?: number | undefined;
     } | undefined>;
-    readonly environmentEncoding: import("@angular/core").Signal<TextureEncoding | undefined>;
-    readonly environmentParams: import("@angular/core").Signal<{
+    encoding: import("@angular/core").Signal<TextureEncoding | undefined>;
+    params: import("@angular/core").Signal<{
         files: string | string[] | undefined;
         path: string | undefined;
-        preset: "sunset" | "dawn" | "night" | "warehouse" | "forest" | "apartment" | "studio" | "city" | "park" | "lobby" | undefined;
-        extensions: ((loader: Loader) => void) | undefined;
+        preset: "apartment" | "city" | "dawn" | "forest" | "lobby" | "night" | "park" | "studio" | "sunset" | "warehouse" | undefined;
+        extensions: ((loader: Loader<unknown, string>) => void) | undefined;
         encoding: TextureEncoding | undefined;
     }>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentInput, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsEnvironmentInput, never, never, { "frames": { "alias": "frames"; "required": false; }; "near": { "alias": "near"; "required": false; }; "far": { "alias": "far"; "required": false; }; "resolution": { "alias": "resolution"; "required": false; }; "background": { "alias": "background"; "required": false; }; "blur": { "alias": "blur"; "required": false; }; "map": { "alias": "map"; "required": false; }; "files": { "alias": "files"; "required": false; }; "path": { "alias": "path"; "required": false; }; "preset": { "alias": "preset"; "required": false; }; "scene": { "alias": "scene"; "required": false; }; "extensions": { "alias": "extensions"; "required": false; }; "ground": { "alias": "ground"; "required": false; }; "encoding": { "alias": "encoding"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsEnvironmentInput, never, never, { "_frames": { "alias": "frames"; "required": false; }; "_near": { "alias": "near"; "required": false; }; "_far": { "alias": "far"; "required": false; }; "_resolution": { "alias": "resolution"; "required": false; }; "_background": { "alias": "background"; "required": false; }; "_blur": { "alias": "blur"; "required": false; }; "_map": { "alias": "map"; "required": false; }; "_files": { "alias": "files"; "required": false; }; "_path": { "alias": "path"; "required": false; }; "_preset": { "alias": "preset"; "required": false; }; "_scene": { "alias": "scene"; "required": false; }; "_extensions": { "alias": "extensions"; "required": false; }; "_ground": { "alias": "ground"; "required": false; }; "_encoding": { "alias": "encoding"; "required": false; }; }, {}, never, never, false, never>;
 }

package/staging/environment/environment-map.d.ts

@@ -1,11 +1,16 @@
 import { NgtsEnvironmentInput } from './environment-input';
 import * as i0 from "@angular/core";
 export declare class NgtsEnvironmentMap {
-    #private;
-    protected readonly environmentInput: NgtsEnvironmentInput;
-    set map(map: THREE.Texture);
-    set background(background: boolean);
+    environmentInput: NgtsEnvironmentInput;
+    private store;
+    private inputs;
+    set _map(map: THREE.Texture);
+    set _background(background: boolean);
     constructor();
+    private scene;
+    private background;
+    private map;
+    private setEnvProps;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentMap, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsEnvironmentMap, "ngts-environment-map", never, { "map": { "alias": "map"; "required": false; }; "background": { "alias": "background"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsEnvironmentMap, "ngts-environment-map", never, { "_map": { "alias": "map"; "required": false; }; "_background": { "alias": "background"; "required": false; }; }, {}, never, never, true, never>;
 }

package/staging/environment/environment-portal.d.ts

@@ -2,12 +2,17 @@ import * as THREE from 'three';
 import { NgtsEnvironmentInput } from './environment-input';
 import * as i0 from "@angular/core";
 export declare class NgtsEnvironmentPortal {
-    #private;
-    protected readonly environmentInput: NgtsEnvironmentInput;
-    readonly virtualSceneRef: import("angular-three").NgtInjectedRef<THREE.Scene>;
-    readonly cubeCameraRef: import("angular-three").NgtInjectedRef<THREE.CubeCamera>;
-    readonly cameraArgs: import("@angular/core").Signal<(number | THREE.WebGLCubeRenderTarget)[]>;
+    environmentInput: NgtsEnvironmentInput;
+    private store;
+    private gl;
+    private scene;
+    virtualSceneRef: import("angular-three").NgtInjectedRef<THREE.Scene>;
+    cubeCameraRef: import("angular-three").NgtInjectedRef<THREE.CubeCamera>;
+    private fbo;
+    cameraArgs: import("@angular/core").Signal<(number | THREE.WebGLCubeRenderTarget)[]>;
     constructor();
+    private setEnvProps;
+    private beforeRender;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentPortal, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEnvironmentPortal, "ngts-environment-portal", never, {}, {}, never, ["*"], true, never>;
 }

package/staging/environment/environment.d.ts

@@ -1,10 +1,6 @@
 import { TemplateRef } from '@angular/core';
 import { NgtsEnvironmentInput } from './environment-input';
 import * as i0 from "@angular/core";
-export declare class NgtsEnvironmentContent {
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentContent, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsEnvironmentContent, "ng-template[ngtsEnvironmentContent]", never, {}, {}, never, never, true, never>;
-}
 export declare class NgtsEnvironment extends NgtsEnvironmentInput {
     content?: TemplateRef<unknown>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironment, never>;

package/staging/environment/utils.d.ts

@@ -1,7 +1,7 @@
 import { ElementRef, Injector } from '@angular/core';
 import { CubeTexture } from 'three';
-import { type NgtsEnvironmentInput } from './environment-input';
+import { type NgtsEnvironmentInputState } from './environment-input';
 export declare function setEnvProps(background: boolean | 'only', scene: THREE.Scene | ElementRef<THREE.Scene> | undefined, defaultScene: THREE.Scene, texture: THREE.Texture, blur?: number): () => void;
-type NgtsInjectEnvironmentParams = Partial<Pick<NgtsEnvironmentInput, 'files' | 'path' | 'preset' | 'extensions' | 'encoding'>>;
+type NgtsInjectEnvironmentParams = Partial<Pick<NgtsEnvironmentInputState, 'files' | 'path' | 'preset' | 'extensions' | 'encoding'>>;
 export declare function injectNgtsEnvironment(paramsFactory: () => Partial<NgtsInjectEnvironmentParams>, injector?: Injector): import("angular-three").NgtInjectedRef<import("three").Texture | CubeTexture>;
 export {};

package/staging/float/float.d.ts

@@ -1,27 +1,31 @@
-import { NgtSignalStore, type NgtGroup } from 'angular-three';
+import { type NgtGroup } from 'angular-three';
 import * as THREE from 'three';
 import * as i0 from "@angular/core";
 export type NgtsFloatState = {
     enabled: boolean;
     speed: number;
-    floatIntensity: number;
     rotationIntensity: number;
+    floatIntensity: number;
     floatingRange: [number?, number?];
 };
 declare global {
     interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-group
+         */
         'ngts-float': NgtsFloatState & NgtGroup;
     }
 }
-export declare class NgtsFloat extends NgtSignalStore<NgtsFloatState> {
-    #private;
-    floatRef: import("angular-three").NgtInjectedRef<THREE.Group>;
-    set enabled(enabled: boolean);
-    set speed(speed: number);
-    set rotationIntensity(rotationIntensity: number);
-    set floatIntensity(floatIntensity: number);
-    set floatingRange(floatingRange: [number?, number?]);
+export declare class NgtsFloat {
+    private inputs;
+    floatRef: import("angular-three").NgtInjectedRef<THREE.Group<THREE.Object3DEventMap>>;
+    set _enabled(enabled: boolean);
+    set _speed(speed: number);
+    set _rotationIntensity(rotationIntensity: number);
+    set _floatIntensity(floatIntensity: number);
+    set _floatingRange(floatingRange: [number?, number?]);
     constructor();
+    private beforeRender;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsFloat, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsFloat, "ngts-float", never, { "floatRef": { "alias": "floatRef"; "required": false; }; "enabled": { "alias": "enabled"; "required": false; }; "speed": { "alias": "speed"; "required": false; }; "rotationIntensity": { "alias": "rotationIntensity"; "required": false; }; "floatIntensity": { "alias": "floatIntensity"; "required": false; }; "floatingRange": { "alias": "floatingRange"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsFloat, "ngts-float", never, { "floatRef": { "alias": "floatRef"; "required": false; }; "_enabled": { "alias": "enabled"; "required": false; }; "_speed": { "alias": "speed"; "required": false; }; "_rotationIntensity": { "alias": "rotationIntensity"; "required": false; }; "_floatIntensity": { "alias": "floatIntensity"; "required": false; }; "_floatingRange": { "alias": "floatingRange"; "required": false; }; }, {}, never, ["*"], true, never>;
 }

package/staging/index.d.ts

@@ -1,17 +1,21 @@
 export * from './accumulative-shadows/accumulative-shadows';
 export * from './accumulative-shadows/randomized-lights';
+export * from './backdrop/backdrop';
+export * from './bb-anchor/bb-anchor';
 export * from './bounds/bounds';
 export * from './camera-shake/camera-shake';
-export * from './caustics/caustisc';
 export * from './center/center';
 export * from './cloud/cloud';
 export * from './contact-shadows/contact-shadows';
 export * from './environment/assets';
 export * from './environment/environment';
 export * from './float/float';
+export * from './matcap-texture/matcap-texture';
+export * from './normal-texture/normal-texture';
 export * from './sky/sky';
 export * from './sparkles/sparkles';
+export { NgtsSpotLightShadow } from './spot-light/shadow-mesh';
 export * from './spot-light/spot-light';
-export { NgtsSpotLightShadow } from './spot-light/spot-light-shadow-mesh';
 export * from './stage/stage';
 export * from './stars/stars';
+export * from './wireframe/wireframe';

package/staging/matcap-texture/matcap-texture.d.ts

@@ -0,0 +1,13 @@
+import { type Injector, type Signal } from '@angular/core';
+export type NgtsMatcapTextureState = {
+    id: string | number;
+    format: number;
+    onLoad?: (texture: THREE.Texture | THREE.Texture[]) => void;
+};
+export declare function injectNgtsMatcapTexture(matcapTextureState: () => Partial<NgtsMatcapTextureState>, { injector }?: {
+    injector?: Injector;
+}): {
+    texture: Signal<import("three").Texture | null>;
+    numTot: () => number;
+    url: () => string;
+};

package/staging/normal-texture/normal-texture.d.ts

@@ -0,0 +1,16 @@
+import { type Injector, type Signal } from '@angular/core';
+import * as THREE from 'three';
+export type NgtsNormalTextureState = {
+    id: string | number;
+    repeat: number[];
+    anisotropy: number;
+    offset: number[];
+    onLoad?: (texture: THREE.Texture | THREE.Texture[]) => void;
+};
+export declare function injectNgtsNormalTexture(normalTextureState: () => Partial<NgtsNormalTextureState>, { injector }?: {
+    injector?: Injector;
+}): {
+    texture: Signal<THREE.Texture | null>;
+    numTot: () => number;
+    url: () => string;
+};

package/staging/sky/sky.d.ts

@@ -1,4 +1,4 @@
-import { NgtSignalStore } from 'angular-three';
+import { type NgtMesh } from 'angular-three';
 import * as THREE from 'three';
 import { Sky } from 'three-stdlib';
 import * as i0 from "@angular/core";
@@ -14,28 +14,35 @@ export interface NgtsSkyState {
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'ngts-sky': NgtsSkyState & Sky;
+        /**
+         * @extends three-stdlib|Sky
+         * @extends ngt-mesh
+         */
+        'ngts-sky': NgtsSkyState & Sky & NgtMesh;
     }
 }
-export declare class NgtsSky extends NgtSignalStore<NgtsSkyState> {
-    #private;
+export declare class NgtsSky {
+    private inputs;
     skyRef: import("angular-three").NgtInjectedRef<Sky>;
-    set distance(distance: number);
-    set sunPosition(sunPosition: THREE.Vector3 | Parameters<THREE.Vector3['set']>);
-    set inclination(inclination: number);
-    set azimuth(azimuth: number);
-    set mieCoefficient(mieCoefficient: number);
-    set mieDirectionalG(mieDirectionalG: number);
-    set rayleigh(rayleigh: number);
-    set turbidity(turbidity: number);
-    readonly sky: Sky;
-    readonly skyMieCoefficient: import("@angular/core").Signal<number>;
-    readonly skyMieDirectionalG: import("@angular/core").Signal<number>;
-    readonly skyRayleigh: import("@angular/core").Signal<number>;
-    readonly skyTurbidity: import("@angular/core").Signal<number>;
-    readonly calculatedSunPosition: import("@angular/core").Signal<THREE.Vector3 | [x: number, y: number, z: number]>;
-    readonly scale: import("@angular/core").Signal<THREE.Vector3>;
-    constructor();
+    set _distance(distance: number);
+    set _sunPosition(sunPosition: THREE.Vector3 | Parameters<THREE.Vector3['set']>);
+    set _inclination(inclination: number);
+    set _azimuth(azimuth: number);
+    set _mieCoefficient(mieCoefficient: number);
+    set _mieDirectionalG(mieDirectionalG: number);
+    set _rayleigh(rayleigh: number);
+    set _turbidity(turbidity: number);
+    private inclination;
+    private azimuth;
+    private sunPos;
+    private distance;
+    sunPosition: import("@angular/core").Signal<THREE.Vector3 | [x: number, y: number, z: number]>;
+    scale: import("@angular/core").Signal<THREE.Vector3>;
+    mieCoefficient: import("@angular/core").Signal<number>;
+    mieDirectionalG: import("@angular/core").Signal<number>;
+    rayleigh: import("@angular/core").Signal<number>;
+    turbidity: import("@angular/core").Signal<number>;
+    sky: Sky;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSky, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSky, "ngts-sky", never, { "skyRef": { "alias": "skyRef"; "required": false; }; "distance": { "alias": "distance"; "required": false; }; "sunPosition": { "alias": "sunPosition"; "required": false; }; "inclination": { "alias": "inclination"; "required": false; }; "azimuth": { "alias": "azimuth"; "required": false; }; "mieCoefficient": { "alias": "mieCoefficient"; "required": false; }; "mieDirectionalG": { "alias": "mieDirectionalG"; "required": false; }; "rayleigh": { "alias": "rayleigh"; "required": false; }; "turbidity": { "alias": "turbidity"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSky, "ngts-sky", never, { "skyRef": { "alias": "skyRef"; "required": false; }; "_distance": { "alias": "distance"; "required": false; }; "_sunPosition": { "alias": "sunPosition"; "required": false; }; "_inclination": { "alias": "inclination"; "required": false; }; "_azimuth": { "alias": "azimuth"; "required": false; }; "_mieCoefficient": { "alias": "mieCoefficient"; "required": false; }; "_mieDirectionalG": { "alias": "mieDirectionalG"; "required": false; }; "_rayleigh": { "alias": "rayleigh"; "required": false; }; "_turbidity": { "alias": "turbidity"; "required": false; }; }, {}, never, ["*"], true, never>;
 }

package/staging/sparkles/sparkles.d.ts

@@ -1,8 +1,8 @@
-import { Signal } from '@angular/core';
-import { NgtSignalStore } from 'angular-three';
+import { type Signal } from '@angular/core';
+import { type NgtPoints } from 'angular-three';
 import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export interface NgtsSparklesState {
+export type NgtsSparklesState = {
     /** Number of particles (default: 100) */
     count: number;
     /** Speed of particles (default: 1) */
@@ -17,33 +17,47 @@ export interface NgtsSparklesState {
     scale: number | [number, number, number] | THREE.Vector3;
     /** Movement factor (default: 1) */
     noise: number | [number, number, number] | THREE.Vector3 | Float32Array;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-points
+         */
+        'ngts-sparkles': NgtsSparklesState & NgtPoints;
+    }
 }
-export declare class NgtsSparkles extends NgtSignalStore<NgtsSparklesState> {
-    #private;
-    pointsRef: import("angular-three").NgtInjectedRef<THREE.Points<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
+export declare class NgtsSparkles {
+    private inputs;
+    sparklesRef: import("angular-three").NgtInjectedRef<THREE.Points<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
     /** Number of particles (default: 100) */
-    set count(count: number);
+    set _count(count: number);
     /** Speed of particles (default: 1) */
-    set speed(speed: number | Float32Array);
+    set _speed(speed: number | Float32Array);
     /** Opacity of particles (default: 1) */
-    set opacity(opacity: number | Float32Array);
+    set _opacity(opacity: number | Float32Array);
     /** Color of particles (default: 100) */
-    set color(color: THREE.ColorRepresentation | Float32Array);
+    set _color(color: THREE.ColorRepresentation | Float32Array);
     /** Size of particles (default: randomized between 0 and 1) */
-    set size(size: number | Float32Array);
+    set _size(size: number | Float32Array);
     /** The space the particles occupy (default: 1) */
-    set scale(scale: number | [number, number, number] | THREE.Vector3);
+    set _scale(scale: number | [number, number, number] | THREE.Vector3);
     /** Movement factor (default: 1) */
-    set noise(noise: number | [number, number, number] | THREE.Vector3 | Float32Array);
-    readonly materialRef: import("angular-three").NgtInjectedRef<THREE.ShaderMaterial>;
-    readonly dpr: Signal<number>;
-    readonly positions: Signal<Float32Array>;
-    readonly sizes: Signal<Float32Array>;
-    readonly opacities: Signal<Float32Array>;
-    readonly speeds: Signal<Float32Array>;
-    readonly noises: Signal<Float32Array>;
-    readonly colors: Signal<Float32Array>;
+    set _noise(noise: number | [number, number, number] | THREE.Vector3 | Float32Array);
+    private store;
+    dpr: Signal<number>;
+    private scale;
+    private count;
+    private color;
+    positions: Signal<Float32Array>;
+    sizes: Signal<Float32Array>;
+    opacities: Signal<Float32Array>;
+    speeds: Signal<Float32Array>;
+    noises: Signal<Float32Array>;
+    colors: Signal<Float32Array>;
+    key: Signal<string>;
     constructor();
+    private beforeRender;
+    private getComputed;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSparkles, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSparkles, "ngts-sparkles", never, { "pointsRef": { "alias": "pointsRef"; "required": false; }; "count": { "alias": "count"; "required": false; }; "speed": { "alias": "speed"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "scale": { "alias": "scale"; "required": false; }; "noise": { "alias": "noise"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSparkles, "ngts-sparkles", never, { "sparklesRef": { "alias": "sparklesRef"; "required": false; }; "_count": { "alias": "count"; "required": false; }; "_speed": { "alias": "speed"; "required": false; }; "_opacity": { "alias": "opacity"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_size": { "alias": "size"; "required": false; }; "_scale": { "alias": "scale"; "required": false; }; "_noise": { "alias": "noise"; "required": false; }; }, {}, never, never, true, never>;
 }

package/staging/spot-light/shadow-mesh-input.d.ts

@@ -0,0 +1,29 @@
+import * as i0 from "@angular/core";
+export type NgtsSpotLightShadowMeshInputState = {
+    distance: number;
+    alphaTest: number;
+    scale: number;
+    map: THREE.Texture;
+    shader: string;
+    width: number;
+    height: number;
+};
+export declare abstract class NgtsSpotLightShadowMeshInput {
+    inputs: import("angular-three").NgtSignalStore<NgtsSpotLightShadowMeshInputState>;
+    set _distance(distance: number);
+    set _alphaTest(alphaTest: number);
+    set _scale(scale: number);
+    set _map(map: THREE.Texture);
+    set _shader(shader: string);
+    set _width(width: number);
+    set _height(height: number);
+    distance: import("@angular/core").Signal<number>;
+    alphaTest: import("@angular/core").Signal<number>;
+    scale: import("@angular/core").Signal<number>;
+    map: import("@angular/core").Signal<import("three").Texture>;
+    shader: import("@angular/core").Signal<string>;
+    width: import("@angular/core").Signal<number>;
+    height: import("@angular/core").Signal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadowMeshInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsSpotLightShadowMeshInput, never, never, { "_distance": { "alias": "distance"; "required": false; }; "_alphaTest": { "alias": "alphaTest"; "required": false; }; "_scale": { "alias": "scale"; "required": false; }; "_map": { "alias": "map"; "required": false; }; "_shader": { "alias": "shader"; "required": false; }; "_width": { "alias": "width"; "required": false; }; "_height": { "alias": "height"; "required": false; }; }, {}, never, never, false, never>;
+}

package/staging/spot-light/shadow-mesh.d.ts

@@ -0,0 +1,37 @@
+import { type NgtInjectedRef } from 'angular-three';
+import * as THREE from 'three';
+import { NgtsSpotLightShadowMeshInput, type NgtsSpotLightShadowMeshInputState } from './shadow-mesh-input';
+import * as i0 from "@angular/core";
+export declare class NgtsSpotLightShadowMeshNoShader {
+    shadowMeshInput: NgtsSpotLightShadowMeshInput;
+    meshRef: NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+    DoubleSide: 2;
+    private spotLightApi;
+    debug: import("@angular/core").Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadowMeshNoShader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLightShadowMeshNoShader, "ngts-spot-light-shadow-mesh-no-shader", never, {}, {}, never, ["*"], true, never>;
+}
+export declare class NgtsSpotLightShadowMeshShader {
+    shadowMeshInput: NgtsSpotLightShadowMeshInput;
+    meshRef: NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+    DoubleSide: 2;
+    RepeatWrapping: 1000;
+    private spotLightApi;
+    debug: import("@angular/core").Signal<boolean>;
+    renderTarget: import("@angular/core").Signal<THREE.WebGLRenderTarget<THREE.Texture>>;
+    private uniforms;
+    private fsQuad;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadowMeshShader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLightShadowMeshShader, "ngts-spot-light-shadow-mesh-shader", never, {}, {}, never, ["*"], true, never>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-spot-light-shadow': NgtsSpotLightShadowMeshInputState;
+    }
+}
+export declare class NgtsSpotLightShadow extends NgtsSpotLightShadowMeshInput {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLightShadow, "ngts-spot-light-shadow", never, {}, {}, never, never, true, never>;
+}

package/staging/spot-light/spot-light-input.d.ts

@@ -1,6 +1,5 @@
-import { NgtSignalStore } from 'angular-three';
 import * as i0 from "@angular/core";
-export interface NgtsSpotLightInputState {
+export type NgtsSpotLightInputState = {
     depthBuffer?: THREE.DepthTexture;
     angle: number;
     distance: number;
@@ -11,28 +10,29 @@ export interface NgtsSpotLightInputState {
     opacity: number;
     color: string | number;
     debug: boolean;
-}
-export declare abstract class NgtsSpotLightInput extends NgtSignalStore<NgtsSpotLightInputState> {
-    set depthBuffer(depthBuffer: THREE.DepthTexture);
-    set angle(angle: number);
-    set distance(distance: number);
-    set attenuation(attenuation: number);
-    set anglePower(anglePower: number);
-    set radiusTop(radiusTop: number);
-    set radiusBottom(radiusBottom: number);
-    set opacity(opacity: number);
-    set color(color: string | number);
-    set debug(debug: boolean);
-    readonly lightDebug: import("@angular/core").Signal<boolean>;
-    readonly lightColor: import("@angular/core").Signal<string | number>;
-    readonly lightOpacity: import("@angular/core").Signal<number>;
-    readonly lightRadiusBottom: import("@angular/core").Signal<number>;
-    readonly lightRadiusTop: import("@angular/core").Signal<number>;
-    readonly lightAnglePower: import("@angular/core").Signal<number>;
-    readonly lightAttenuation: import("@angular/core").Signal<number>;
-    readonly lightDistance: import("@angular/core").Signal<number>;
-    readonly lightAngle: import("@angular/core").Signal<number>;
-    readonly lightDepthBuffer: import("@angular/core").Signal<import("three").DepthTexture | undefined>;
+};
+export declare abstract class NgtsSpotLightInput {
+    inputs: import("angular-three").NgtSignalStore<NgtsSpotLightInputState>;
+    set _depthBuffer(depthBuffer: THREE.DepthTexture);
+    set _angle(angle: number);
+    set _distance(distance: number);
+    set _attenuation(attenuation: number);
+    set _anglePower(anglePower: number);
+    set _radiusTop(radiusTop: number);
+    set _radiusBottom(radiusBottom: number);
+    set _opacity(opacity: number);
+    set _color(color: string | number);
+    set _debug(debug: boolean);
+    debug: import("@angular/core").Signal<boolean>;
+    color: import("@angular/core").Signal<string | number>;
+    opacity: import("@angular/core").Signal<number>;
+    radiusBottom: import("@angular/core").Signal<number>;
+    radiusTop: import("@angular/core").Signal<number>;
+    anglePower: import("@angular/core").Signal<number>;
+    attenuation: import("@angular/core").Signal<number>;
+    distance: import("@angular/core").Signal<number>;
+    angle: import("@angular/core").Signal<number>;
+    depthBuffer: import("@angular/core").Signal<import("three").DepthTexture | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightInput, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsSpotLightInput, never, never, { "depthBuffer": { "alias": "depthBuffer"; "required": false; }; "angle": { "alias": "angle"; "required": false; }; "distance": { "alias": "distance"; "required": false; }; "attenuation": { "alias": "attenuation"; "required": false; }; "anglePower": { "alias": "anglePower"; "required": false; }; "radiusTop": { "alias": "radiusTop"; "required": false; }; "radiusBottom": { "alias": "radiusBottom"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "color": { "alias": "color"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsSpotLightInput, never, never, { "_depthBuffer": { "alias": "depthBuffer"; "required": false; }; "_angle": { "alias": "angle"; "required": false; }; "_distance": { "alias": "distance"; "required": false; }; "_attenuation": { "alias": "attenuation"; "required": false; }; "_anglePower": { "alias": "anglePower"; "required": false; }; "_radiusTop": { "alias": "radiusTop"; "required": false; }; "_radiusBottom": { "alias": "radiusBottom"; "required": false; }; "_opacity": { "alias": "opacity"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_debug": { "alias": "debug"; "required": false; }; }, {}, never, never, false, never>;
 }

package/staging/spot-light/spot-light.d.ts

@@ -1,23 +1,43 @@
-import { InjectionToken } from '@angular/core';
-import { NgtInjectedRef } from 'angular-three';
+import { type NgtSpotLight } from 'angular-three';
 import { SpotLight } from 'three';
-import { NgtsSpotLightInput } from './spot-light-input';
+import { NgtsSpotLightInput, type NgtsSpotLightInputState } from './spot-light-input';
 import * as i0 from "@angular/core";
-declare module './spot-light-input' {
-    interface NgtsSpotLightInputState {
-        volumetric: boolean;
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-spot-light
+         */
+        'ngts-spot-light': NgtsSpotLightInputState & NgtSpotLight;
     }
 }
-export type NgtsSpotLightApi = {
-    spotLight: NgtInjectedRef<THREE.SpotLight>;
-    debug: () => boolean;
-};
-export declare const NGTS_SPOT_LIGHT_API: InjectionToken<NgtsSpotLightApi>;
+export declare const injectNgtsSpotLightApi: {
+    (): {
+        spotLight: import("angular-three").NgtInjectedRef<SpotLight>;
+        debug: import("@angular/core").Signal<boolean>;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false | undefined;
+    } & {
+        injector?: import("@angular/core").Injector | undefined;
+    }): {
+        spotLight: import("angular-three").NgtInjectedRef<SpotLight>;
+        debug: import("@angular/core").Signal<boolean>;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        injector?: import("@angular/core").Injector | undefined;
+    }): {
+        spotLight: import("angular-three").NgtInjectedRef<SpotLight>;
+        debug: import("@angular/core").Signal<boolean>;
+    } | null;
+}, provideNgtsSpotLightApi: (value?: {
+    spotLight: import("angular-three").NgtInjectedRef<SpotLight>;
+    debug: import("@angular/core").Signal<boolean>;
+} | undefined) => import("@angular/core").Provider;
 export declare class NgtsSpotLight extends NgtsSpotLightInput {
-    spotLightRef: NgtInjectedRef<SpotLight>;
-    set volumetric(volumetric: boolean);
-    readonly showVolumetric: import("@angular/core").Signal<boolean>;
+    spotLightRef: import("angular-three").NgtInjectedRef<SpotLight>;
+    volumetric: import("@angular/core").WritableSignal<boolean>;
+    set _volumetric(volumetric: boolean);
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLight, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLight, "ngts-spot-light", never, { "spotLightRef": { "alias": "spotLightRef"; "required": false; }; "volumetric": { "alias": "volumetric"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLight, "ngts-spot-light", never, { "spotLightRef": { "alias": "spotLightRef"; "required": false; }; "_volumetric": { "alias": "volumetric"; "required": false; }; }, {}, never, ["*"], true, never>;
 }