angular-three-soba 1.14.0 → 2.0.0-beta.3

package/staging/cloud/cloud.d.ts

@@ -0,0 +1,48 @@
+import { NgtSignalStore, type NgtBeforeRenderEvent, type NgtGroup } from 'angular-three';
+import { Group } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsCloudState {
+    opacity: number;
+    speed: number;
+    width: number;
+    depth: number;
+    segments: number;
+    texture: string;
+    color: THREE.ColorRepresentation;
+    depthTest: boolean;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-cloud': NgtsCloudState & NgtGroup;
+    }
+}
+export declare class NgtsCloud extends NgtSignalStore<NgtsCloudState> {
+    #private;
+    groupRef: import("angular-three").NgtInjectedRef<Group>;
+    set opacity(opacity: number);
+    set speed(speed: number);
+    set width(width: number);
+    set depth(depth: number);
+    set segments(segments: number);
+    set texture(texture: string);
+    set color(color: THREE.ColorRepresentation);
+    set depthTest(depthTest: boolean);
+    readonly cloudSegments: import("@angular/core").Signal<number>;
+    readonly cloudDepth: import("@angular/core").Signal<number>;
+    readonly cloudDepthTest: import("@angular/core").Signal<boolean>;
+    readonly cloudOpacity: import("@angular/core").Signal<number>;
+    readonly cloudColor: import("@angular/core").Signal<import("three").ColorRepresentation>;
+    readonly encoding: import("@angular/core").Signal<import("three").TextureEncoding>;
+    readonly cloudTexture: import("@angular/core").Signal<import("three").Texture>;
+    readonly clouds: import("@angular/core").Signal<{
+        x: number;
+        y: number;
+        scale: number;
+        density: number;
+        rotation: number;
+    }[]>;
+    constructor();
+    onBeforeRender({ state, object }: NgtBeforeRenderEvent<Group>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCloud, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCloud, "ngts-cloud", never, { "groupRef": { "alias": "groupRef"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "speed": { "alias": "speed"; "required": false; }; "width": { "alias": "width"; "required": false; }; "depth": { "alias": "depth"; "required": false; }; "segments": { "alias": "segments"; "required": false; }; "texture": { "alias": "texture"; "required": false; }; "color": { "alias": "color"; "required": false; }; "depthTest": { "alias": "depthTest"; "required": false; }; }, {}, never, never, true, never>;
+}

package/staging/{lib/contact-shadows → contact-shadows}/contact-shadows.d.ts

@@ -1,12 +1,27 @@
-import { NgtRxStore } from 'angular-three';
+import { NgtSignalStore, type NgtGroup } from 'angular-three';
 import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export declare class NgtsContactShadows extends NgtRxStore {
-    private readonly store;
-    readonly shadowCameraRef: import("angular-three").NgtInjectedRef<THREE.OrthographicCamera>;
-    readonly encoding: THREE.TextureEncoding;
-    readonly contactShadows$: import("rxjs").Observable<any>;
-    readonly Math: Math;
+export interface NgtsContactShadowsState {
+    opacity: number;
+    width: number;
+    height: number;
+    blur: number;
+    far: number;
+    smooth: boolean;
+    resolution: number;
+    frames: number;
+    scale: number | [x: number, y: number];
+    color: THREE.ColorRepresentation;
+    depthWrite: boolean;
+    renderOrder: number;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-contact-shadows': NgtsContactShadowsState & NgtGroup;
+    }
+}
+export declare class NgtsContactShadows extends NgtSignalStore<NgtsContactShadowsState> {
+    #private;
     contactShadowsRef: import("angular-three").NgtInjectedRef<THREE.Group>;
     set opacity(opacity: number);
     set width(width: number);
@@ -20,10 +35,23 @@ export declare class NgtsContactShadows extends NgtRxStore {
     set color(color: THREE.ColorRepresentation);
     set depthWrite(depthWrite: boolean);
     set renderOrder(renderOrder: number);
+    readonly Math: Math;
+    readonly shadowCameraRef: import("angular-three").NgtInjectedRef<THREE.OrthographicCamera>;
+    readonly encoding: import("@angular/core").Signal<THREE.TextureEncoding>;
+    readonly shadowRenderOrder: import("@angular/core").Signal<number>;
+    readonly shadowOpacity: import("@angular/core").Signal<number>;
+    readonly shadowDepthWrite: import("@angular/core").Signal<boolean>;
+    readonly cameraArgs: import("@angular/core").Signal<number[]>;
+    readonly contactShadows: import("@angular/core").Signal<{
+        renderTarget: THREE.WebGLRenderTarget;
+        planeGeometry: THREE.PlaneGeometry;
+        depthMaterial: THREE.MeshDepthMaterial;
+        blurPlane: THREE.Mesh<THREE.PlaneGeometry, THREE.Material | THREE.Material[]>;
+        horizontalBlurMaterial: THREE.ShaderMaterial;
+        verticalBlurMaterial: THREE.ShaderMaterial;
+        renderTargetBlur: THREE.WebGLRenderTarget;
+    }>;
     constructor();
-    initialize(): void;
-    private onBeforeRender;
-    private blurShadows;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsContactShadows, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsContactShadows, "ngts-contact-shadows", never, { "contactShadowsRef": { "alias": "contactShadowsRef"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "blur": { "alias": "blur"; "required": false; }; "far": { "alias": "far"; "required": false; }; "smooth": { "alias": "smooth"; "required": false; }; "resolution": { "alias": "resolution"; "required": false; }; "frames": { "alias": "frames"; "required": false; }; "scale": { "alias": "scale"; "required": false; }; "color": { "alias": "color"; "required": false; }; "depthWrite": { "alias": "depthWrite"; "required": false; }; "renderOrder": { "alias": "renderOrder"; "required": false; }; }, {}, never, never, true, never>;
 }

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

@@ -0,0 +1,11 @@
+import { NgtsEnvironmentInput } from './environment-input';
+import * as i0 from "@angular/core";
+export declare class NgtsEnvironmentCube {
+    #private;
+    protected readonly environmentInput: NgtsEnvironmentInput;
+    readonly textureRef: import("angular-three").NgtInjectedRef<import("three").Texture | import("three").CubeTexture>;
+    set background(background: boolean);
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentCube, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsEnvironmentCube, "ngts-environment-cube", never, { "background": { "alias": "background"; "required": false; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,13 @@
+import { NgtsEnvironmentInput } from './environment-input';
+import * as i0 from "@angular/core";
+export declare class NgtsEnvironmentGround {
+    #private;
+    protected readonly environmentInput: NgtsEnvironmentInput;
+    readonly texture: import("@angular/core").Signal<import("three").Texture>;
+    readonly groundArgs: import("@angular/core").Signal<import("three").Texture[]>;
+    readonly height: import("@angular/core").Signal<any>;
+    readonly radius: import("@angular/core").Signal<any>;
+    readonly scale: import("@angular/core").Signal<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentGround, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEnvironmentGround, "ngts-environment-ground", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,68 @@
+import { ElementRef } from '@angular/core';
+import { NgtSignalStore } from 'angular-three';
+import { Loader, Scene, Texture, TextureEncoding } from 'three';
+import { NgtsEnvironmentPresetsType } from './assets';
+import * as i0 from "@angular/core";
+export interface NgtsEnvironmentInputState {
+    frames?: number;
+    near?: number;
+    far?: number;
+    resolution?: number;
+    background?: boolean | 'only';
+    blur?: number;
+    map?: Texture;
+    files?: string | string[];
+    path?: string;
+    preset?: NgtsEnvironmentPresetsType;
+    scene?: Scene | ElementRef<Scene>;
+    extensions?: (loader: Loader) => void;
+    ground?: boolean | {
+        radius?: number;
+        height?: number;
+        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 | {
+        radius?: number | undefined;
+        height?: number | undefined;
+        scale?: number | undefined;
+    } | undefined>;
+    readonly environmentEncoding: import("@angular/core").Signal<TextureEncoding | undefined>;
+    readonly environmentParams: 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;
+        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>;
+}

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

@@ -0,0 +1,11 @@
+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);
+    constructor();
+    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>;
+}

package/staging/{lib/environment → environment}/environment-portal.d.ts

@@ -1,15 +1,13 @@
-import { OnInit } from '@angular/core';
 import * as THREE from 'three';
-import { NgtsEnvironmentInputs } from './environment-inputs';
+import { NgtsEnvironmentInput } from './environment-input';
 import * as i0 from "@angular/core";
-export declare class NgtsEnvironmentPortal extends NgtsEnvironmentInputs implements OnInit {
+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>;
-    initialize(): void;
+    readonly cameraArgs: import("@angular/core").Signal<(number | THREE.WebGLCubeRenderTarget)[]>;
     constructor();
-    ngOnInit(): void;
-    private setEnvProps;
-    private onBeforeRender;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironmentPortal, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEnvironmentPortal, "ngts-environment-portal", never, {}, {}, never, ["*"], true, never>;
 }

package/staging/{lib/environment → environment}/environment.d.ts

@@ -1,11 +1,11 @@
 import { TemplateRef } from '@angular/core';
-import { NgtsEnvironmentInputs } from './environment-inputs';
+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 NgtsEnvironmentInputs {
+export declare class NgtsEnvironment extends NgtsEnvironmentInput {
     content?: TemplateRef<unknown>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEnvironment, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEnvironment, "ngts-environment", never, {}, {}, ["content"], never, true, never>;

package/staging/environment/utils.d.ts

@@ -0,0 +1,7 @@
+import { ElementRef, Injector } from '@angular/core';
+import { CubeTexture } from 'three';
+import { type NgtsEnvironmentInput } 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'>>;
+export declare function injectNgtsEnvironment(paramsFactory: () => Partial<NgtsInjectEnvironmentParams>, injector?: Injector): import("angular-three").NgtInjectedRef<import("three").Texture | CubeTexture>;
+export {};

package/staging/float/float.d.ts

@@ -0,0 +1,27 @@
+import { NgtSignalStore, 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;
+    floatingRange: [number?, number?];
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        '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?]);
+    constructor();
+    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>;
+}

package/staging/index.d.ts

@@ -1,17 +1,17 @@
-export { NgtsAccumulativeShadows } from './lib/accumulative-shadows/accumulative-shadows';
-export { NgtsRandomizedLights } from './lib/accumulative-shadows/randomized-lights';
-export * from './lib/bounds/bounds';
-export * from './lib/camera-shake/camera-shake';
-export * from './lib/caustics/caustics';
-export * from './lib/center/center';
-export * from './lib/cloud/cloud';
-export * from './lib/contact-shadows/contact-shadows';
-export * from './lib/environment/assets';
-export * from './lib/environment/environment';
-export * from './lib/float/float';
-export * from './lib/sky/sky';
-export * from './lib/sparkles/sparkles';
-export * from './lib/spot-light/spot-light';
-export * from './lib/spot-light/spot-light-shadow';
-export * from './lib/stage/stage';
-export * from './lib/stars/stars';
+export * from './accumulative-shadows/accumulative-shadows';
+export * from './accumulative-shadows/randomized-lights';
+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 './sky/sky';
+export * from './sparkles/sparkles';
+export * from './spot-light/spot-light';
+export { NgtsSpotLightShadow } from './spot-light/spot-light-shadow-mesh';
+export * from './stage/stage';
+export * from './stars/stars';

package/staging/{lib/sky → sky}/sky.d.ts

@@ -1,9 +1,24 @@
-import { NgtRxStore } from 'angular-three';
-import { Vector3 } from 'three';
+import { NgtSignalStore } from 'angular-three';
+import * as THREE from 'three';
 import { Sky } from 'three-stdlib';
 import * as i0 from "@angular/core";
-export declare function calcPosFromAngles(inclination: number, azimuth: number, vector?: Vector3): Vector3;
-export declare class NgtsSky extends NgtRxStore {
+export interface NgtsSkyState {
+    distance: number;
+    sunPosition: THREE.Vector3 | Parameters<THREE.Vector3['set']>;
+    inclination: number;
+    azimuth: number;
+    mieCoefficient: number;
+    mieDirectionalG: number;
+    rayleigh: number;
+    turbidity: number;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-sky': NgtsSkyState & Sky;
+    }
+}
+export declare class NgtsSky extends NgtSignalStore<NgtsSkyState> {
+    #private;
     skyRef: import("angular-three").NgtInjectedRef<Sky>;
     set distance(distance: number);
     set sunPosition(sunPosition: THREE.Vector3 | Parameters<THREE.Vector3['set']>);
@@ -14,7 +29,13 @@ export declare class NgtsSky extends NgtRxStore {
     set rayleigh(rayleigh: number);
     set turbidity(turbidity: number);
     readonly sky: Sky;
-    initialize(): void;
+    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();
     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>;
 }

package/staging/{lib/sparkles → sparkles}/sparkles.d.ts

@@ -1,11 +1,26 @@
-import { NgtRxStore } from 'angular-three';
-import { BufferGeometry, Points } from 'three';
+import { Signal } from '@angular/core';
+import { NgtSignalStore } from 'angular-three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export declare class NgtsSparkles extends NgtRxStore {
-    private readonly store;
-    readonly dpr: number;
-    readonly materialRef: import("angular-three").NgtInjectedRef<import("three").ShaderMaterial>;
-    pointsRef: import("angular-three").NgtInjectedRef<Points<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[]>>;
+export interface NgtsSparklesState {
+    /** Number of particles (default: 100) */
+    count: number;
+    /** Speed of particles (default: 1) */
+    speed: number | Float32Array;
+    /** Opacity of particles (default: 1) */
+    opacity: number | Float32Array;
+    /** Color of particles (default: 100) */
+    color?: THREE.ColorRepresentation | Float32Array;
+    /** Size of particles (default: randomized between 0 and 1) */
+    size?: number | Float32Array;
+    /** The space the particles occupy (default: 1) */
+    scale: number | [number, number, number] | THREE.Vector3;
+    /** Movement factor (default: 1) */
+    noise: number | [number, number, number] | THREE.Vector3 | Float32Array;
+}
+export declare class NgtsSparkles extends NgtSignalStore<NgtsSparklesState> {
+    #private;
+    pointsRef: import("angular-three").NgtInjectedRef<THREE.Points<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
     /** Number of particles (default: 100) */
     set count(count: number);
     /** Speed of particles (default: 1) */
@@ -20,10 +35,15 @@ export declare class NgtsSparkles extends NgtRxStore {
     set scale(scale: number | [number, number, number] | THREE.Vector3);
     /** Movement factor (default: 1) */
     set noise(noise: number | [number, number, number] | THREE.Vector3 | Float32Array);
-    initialize(): void;
+    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>;
     constructor();
-    private onBeforeRender;
-    private getAttribute$;
     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>;
 }

package/staging/{lib/spot-light → spot-light}/spot-light-input.d.ts

@@ -1,6 +1,18 @@
-import { NgtRxStore } from 'angular-three';
+import { NgtSignalStore } from 'angular-three';
 import * as i0 from "@angular/core";
-export declare abstract class NgtsSpotLightInput extends NgtRxStore {
+export interface NgtsSpotLightInputState {
+    depthBuffer?: THREE.DepthTexture;
+    angle: number;
+    distance: number;
+    attenuation: number;
+    anglePower: number;
+    radiusTop: number;
+    radiusBottom: number;
+    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);
@@ -11,6 +23,16 @@ export declare abstract class NgtsSpotLightInput extends NgtRxStore {
     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>;
     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>;
 }

package/staging/{lib/spot-light/shadow-mesh-input.d.ts → spot-light/spot-light-shadow-mesh-input.d.ts}

@@ -1,6 +1,15 @@
-import { NgtRxStore } from 'angular-three';
+import { NgtSignalStore } from 'angular-three';
 import * as i0 from "@angular/core";
-export declare abstract class NgtsSpotLightShadowMeshInput extends NgtRxStore {
+export interface NgtsSpotLightShadowMeshInputState {
+    distance: number;
+    alphaTest: number;
+    scale: number;
+    map: THREE.Texture;
+    shader: string;
+    width: number;
+    height: number;
+}
+export declare abstract class NgtsSpotLightShadowMeshInput extends NgtSignalStore<NgtsSpotLightShadowMeshInputState> {
     set distance(distance: number);
     set alphaTest(alphaTest: number);
     set scale(scale: number);
@@ -8,7 +17,13 @@ export declare abstract class NgtsSpotLightShadowMeshInput extends NgtRxStore {
     set shader(shader: string);
     set width(width: number);
     set height(height: number);
-    readonly map$: import("rxjs").Observable<any>;
+    readonly shadowMeshDistance: import("@angular/core").Signal<number>;
+    readonly shadowMeshAlphaTest: import("@angular/core").Signal<number>;
+    readonly shadowMeshScale: import("@angular/core").Signal<number>;
+    readonly shadowMeshMap: import("@angular/core").Signal<import("three").Texture>;
+    readonly shadowMeshShader: import("@angular/core").Signal<string>;
+    readonly shadowMeshWidth: import("@angular/core").Signal<number>;
+    readonly shadowMeshHeight: 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/spot-light-shadow-mesh.d.ts

@@ -0,0 +1,38 @@
+import { NgtInjectedRef } from 'angular-three';
+import * as THREE from 'three';
+import { NgtsSpotLightShadowMeshInput } from './spot-light-shadow-mesh-input';
+import * as i0 from "@angular/core";
+export declare class NgtsSpotLightShadowMeshNoShader {
+    #private;
+    protected readonly shadowMeshInput: NgtsSpotLightShadowMeshInput;
+    readonly meshRef: NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
+    readonly DoubleSide: 2;
+    readonly debug: () => 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 {
+    #private;
+    protected readonly shadowMeshInput: NgtsSpotLightShadowMeshInput;
+    readonly meshRef: NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
+    readonly DoubleSide: 2;
+    readonly RepeatWrapping: 1000;
+    readonly debug: () => boolean;
+    readonly renderTarget: import("@angular/core").Signal<THREE.WebGLRenderTarget>;
+    readonly uniforms: {
+        uShadowMap: {
+            value: THREE.Texture;
+        };
+        uTime: {
+            value: number;
+        };
+    };
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadowMeshShader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLightShadowMeshShader, "ngts-spot-light-shadow-mesh-shader", never, {}, {}, never, ["*"], true, never>;
+}
+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/{lib/spot-light → spot-light}/spot-light.d.ts

@@ -3,15 +3,21 @@ import { NgtInjectedRef } from 'angular-three';
 import { SpotLight } from 'three';
 import { NgtsSpotLightInput } from './spot-light-input';
 import * as i0 from "@angular/core";
-export interface NgtsSpotLightAPI {
-    spotLight: NgtInjectedRef<THREE.SpotLight>;
-    debug: boolean;
+declare module './spot-light-input' {
+    interface NgtsSpotLightInputState {
+        volumetric: boolean;
+    }
 }
-export declare const NGTS_SPOT_LIGHT_API: InjectionToken<NgtsSpotLightAPI>;
+export type NgtsSpotLightApi = {
+    spotLight: NgtInjectedRef<THREE.SpotLight>;
+    debug: () => boolean;
+};
+export declare const NGTS_SPOT_LIGHT_API: InjectionToken<NgtsSpotLightApi>;
 export declare class NgtsSpotLight extends NgtsSpotLightInput {
     spotLightRef: NgtInjectedRef<SpotLight>;
     set volumetric(volumetric: boolean);
-    initialize(): void;
+    readonly showVolumetric: import("@angular/core").Signal<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>;
 }

package/staging/{lib/spot-light → spot-light}/volumetric-mesh.d.ts

@@ -2,13 +2,16 @@ import { SpotLightMaterial } from 'angular-three-soba/shaders';
 import * as THREE from 'three';
 import { NgtsSpotLightInput } from './spot-light-input';
 import * as i0 from "@angular/core";
-export declare class NgtsVolumetricMesh extends NgtsSpotLightInput {
-    readonly mesh: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+export declare class NgtsVolumetricMesh {
+    #private;
+    protected readonly spotLightInput: NgtsSpotLightInput;
+    readonly mesh: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
     readonly material: SpotLightMaterial;
     readonly nullRaycast: () => null;
-    private readonly vec;
-    private readonly store;
-    initialize(): void;
+    readonly geometry: import("@angular/core").Signal<THREE.CylinderGeometry>;
+    readonly near: import("@angular/core").Signal<number>;
+    readonly far: import("@angular/core").Signal<number>;
+    readonly resolution: import("@angular/core").Signal<number[]>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsVolumetricMesh, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsVolumetricMesh, "ngts-volumetric-mesh", never, {}, {}, never, never, true, never>;