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

package/performance/instances/instances.d.ts

@@ -0,0 +1,35 @@
+import { ElementRef, InjectionToken, Signal } from '@angular/core';
+import { NgtSignalStore } from 'angular-three';
+import * as THREE from 'three';
+import { InstancedMesh } from 'three';
+import { PositionMesh } from './position-mesh';
+import * as i0 from "@angular/core";
+export interface NgtsInstancesState {
+    range: number;
+    limit: number;
+    frames: number;
+}
+export interface NgtsInstancesApi {
+    getParent: () => ElementRef<InstancedMesh>;
+    subscribe: (ref: ElementRef<PositionMesh>) => () => void;
+}
+export declare const NGTS_INSTANCES_API: InjectionToken<Signal<NgtsInstancesApi>>;
+export declare class NgtsInstances extends NgtSignalStore<NgtsInstancesState> {
+    #private;
+    readonly nullRaycast: () => null;
+    readonly DynamicDrawUsage: 35048;
+    instancesRef: import("angular-three").NgtInjectedRef<THREE.InstancedMesh<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
+    set range(range: number);
+    set limit(limit: number);
+    set frames(frames: number);
+    readonly matrices: Signal<Float32Array>;
+    readonly colors: Signal<Float32Array>;
+    readonly instances: import("@angular/core").WritableSignal<ElementRef<PositionMesh>[]>;
+    readonly api: Signal<{
+        getParent: () => import("angular-three").NgtInjectedRef<THREE.InstancedMesh<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
+        subscribe: (ref: ElementRef<PositionMesh>) => () => void;
+    }>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsInstances, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsInstances, "ngts-instances", never, { "instancesRef": { "alias": "instancesRef"; "required": false; }; "range": { "alias": "range"; "required": true; }; "limit": { "alias": "limit"; "required": false; }; "frames": { "alias": "frames"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/performance/instances/position-mesh.d.ts

@@ -0,0 +1,10 @@
+import { ElementRef } from '@angular/core';
+import * as THREE from 'three';
+export declare class PositionMesh extends THREE.Group {
+    color: THREE.Color;
+    instance: ElementRef<THREE.InstancedMesh | undefined>;
+    instanceKey: ElementRef<PositionMesh | undefined>;
+    constructor();
+    get geometry(): THREE.BufferGeometry | undefined;
+    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
+}

package/performance/{lib/stats → stats}/stats.d.ts

@@ -1,15 +1,18 @@
-import { ElementRef, OnInit } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
+import { ElementRef } from '@angular/core';
+import { NgtSignalStore } from 'angular-three';
 import * as i0 from "@angular/core";
-export declare class NgtsStats extends NgtRxStore implements OnInit {
-    private readonly document;
-    private readonly stats;
+export interface NgtsStatsState {
+    showPanel: number;
+    right: boolean;
+    parent?: HTMLElement;
+    classes?: string;
+}
+export declare class NgtsStats extends NgtSignalStore<NgtsStatsState> {
     set showPanel(showPanel: number);
     set parent(parent: HTMLElement | ElementRef<HTMLElement>);
     set classes(classes: string);
     set right(right: boolean);
-    initialize(): void;
-    ngOnInit(): void;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsStats, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsStats, "ngts-stats", never, { "showPanel": { "alias": "showPanel"; "required": false; }; "parent": { "alias": "parent"; "required": false; }; "classes": { "alias": "classes"; "required": false; }; "right": { "alias": "right"; "required": false; }; }, {}, never, never, true, never>;
 }

package/plugin/package.json

@@ -5,5 +5,5 @@
   },
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
-  "version": "1.14.0"
+  "version": "2.0.0-beta.3"
 }

package/plugin/src/generators/init/compat.js.map

@@ -1 +1 @@
-{"version":3,"file":"compat.js","sourceRoot":"","sources":["../../../../../../../libs/plugin/src/generators/init/compat.ts"],"names":[],"mappings":";;AAAA,uCAAgD;AAChD,iCAA0B;AAE1B,kBAAe,IAAA,2BAAkB,EAAC,cAAI,CAAC,CAAC"}
+{"version":3,"file":"compat.js","sourceRoot":"","sources":["../../../../../../../libs/soba-plugin/src/generators/init/compat.ts"],"names":[],"mappings":";;AAAA,uCAAgD;AAChD,iCAA0B;AAE1B,kBAAe,IAAA,2BAAkB,EAAC,cAAI,CAAC,CAAC"}

package/plugin/src/generators/init/init.d.ts

@@ -1,4 +1,4 @@
 import { Tree } from '@nx/devkit';
-export declare const ANGULAR_THREE_SOBA_VERSION = "^1.0.0";
+export declare const ANGULAR_THREE_SOBA_VERSION = "^2.0.0";
 export declare const THREE_STDLIB_VERSION = "^2.0.0";
 export default function (tree: Tree): Promise<() => void>;

package/plugin/src/generators/init/init.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.THREE_STDLIB_VERSION = exports.ANGULAR_THREE_SOBA_VERSION = void 0;
 const devkit_1 = require("@nx/devkit");
-exports.ANGULAR_THREE_SOBA_VERSION = '^1.0.0';
+exports.ANGULAR_THREE_SOBA_VERSION = '^2.0.0';
 exports.THREE_STDLIB_VERSION = '^2.0.0';
 async function default_1(tree) {
     devkit_1.logger.log('Initializing Angular Three...');

package/plugin/src/generators/init/init.js.map

@@ -1 +1 @@
-{"version":3,"file":"init.js","sourceRoot":"","sources":["../../../../../../../libs/plugin/src/generators/init/init.ts"],"names":[],"mappings":";;;AAAA,uCAAuG;AAE1F,QAAA,0BAA0B,GAAG,QAAQ,CAAC;AACtC,QAAA,oBAAoB,GAAG,QAAQ,CAAC;AAE9B,KAAK,oBAAW,IAAU;IACrC,eAAM,CAAC,GAAG,CAAC,+BAA+B,CAAC,CAAC;IAE5C,MAAM,WAAW,GAAG,IAAA,iBAAQ,EAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IAEnD,MAAM,OAAO,GACT,WAAW,CAAC,cAAc,CAAC,EAAE,CAAC,oBAAoB,CAAC;QACnD,WAAW,CAAC,iBAAiB,CAAC,EAAE,CAAC,oBAAoB,CAAC;QACtD,kCAA0B,CAAC;IAE/B,IAAA,qCAA4B,EACxB,IAAI,EACJ;QACI,oBAAoB,EAAE,OAAO;QAC7B,cAAc,EAAE,4BAAoB;KACvC,EACD,EAAE,CACL,CAAC;IAEF,OAAO,GAAG,EAAE;QACR,IAAA,4BAAmB,EAAC,IAAI,CAAC,CAAC;IAC9B,CAAC,CAAC;AACN,CAAC;AAtBD,4BAsBC"}
+{"version":3,"file":"init.js","sourceRoot":"","sources":["../../../../../../../libs/soba-plugin/src/generators/init/init.ts"],"names":[],"mappings":";;;AAAA,uCAAuG;AAE1F,QAAA,0BAA0B,GAAG,QAAQ,CAAC;AACtC,QAAA,oBAAoB,GAAG,QAAQ,CAAC;AAE9B,KAAK,oBAAW,IAAU;IACrC,eAAM,CAAC,GAAG,CAAC,+BAA+B,CAAC,CAAC;IAE5C,MAAM,WAAW,GAAG,IAAA,iBAAQ,EAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IAEnD,MAAM,OAAO,GACT,WAAW,CAAC,cAAc,CAAC,EAAE,CAAC,oBAAoB,CAAC;QACnD,WAAW,CAAC,iBAAiB,CAAC,EAAE,CAAC,oBAAoB,CAAC;QACtD,kCAA0B,CAAC;IAE/B,IAAA,qCAA4B,EACxB,IAAI,EACJ;QACI,oBAAoB,EAAE,OAAO;QAC7B,cAAc,EAAE,4BAAoB;KACvC,EACD,EAAE,CACL,CAAC;IAEF,OAAO,GAAG,EAAE;QACR,IAAA,4BAAmB,EAAC,IAAI,CAAC,CAAC;IAC9B,CAAC,CAAC;AACN,CAAC;AAtBD,4BAsBC"}

package/plugin/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../libs/plugin/src/index.ts"],"names":[],"mappings":";;;AAAA,+CAAkE;AAAzD,qGAAA,OAAO,OAAiB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../libs/soba-plugin/src/index.ts"],"names":[],"mappings":";;;AAAA,+CAAkE;AAAzD,qGAAA,OAAO,OAAiB"}

package/shaders/{lib/blur-pass → blur-pass}/blur-pass.d.ts

@@ -1,4 +1,4 @@
-import { Camera, Mesh, Scene, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { Camera, Mesh, Scene, WebGLRenderTarget, WebGLRenderer } from 'three';
 import { ConvolutionMaterial } from '../convolution-material/convolution-material';
 export interface BlurPassProps {
     gl: WebGLRenderer;
@@ -19,5 +19,5 @@ export declare class BlurPass {
     readonly screen: Mesh;
     renderToScreen: boolean;
     constructor({ gl, resolution, width, height, minDepthThreshold, maxDepthThreshold, depthScale, depthToBlurRatioBias, }: BlurPassProps);
-    render(renderer: WebGLRenderer, inputBuffer: any, outputBuffer: any): void;
+    render(renderer: WebGLRenderer, inputBuffer: WebGLRenderTarget, outputBuffer: WebGLRenderTarget): void;
 }

package/shaders/index.d.ts

@@ -1,14 +1,14 @@
-export * from './lib/blur-pass/blur-pass';
-export * from './lib/caustics-material/caustics-material';
-export * from './lib/caustics-projection-material/caustics-projection-material';
-export * from './lib/convolution-material/convolution-material';
-export * from './lib/discard-material/discard-material';
-export * from './lib/mesh-distort-material/mesh-distort-material';
-export * from './lib/mesh-reflector-material/mesh-reflector-material';
-export * from './lib/mesh-refraction-material/mesh-refraction-material';
-export * from './lib/mesh-transmission-material/mesh-transmission-material';
-export * from './lib/mesh-wobble-material/mesh-wobble-material';
-export * from './lib/shader-material/shader-material';
-export * from './lib/soft-shadow-material/soft-shadow-material';
-export * from './lib/spot-light-material/spot-light-material';
-export * from './lib/star-field-material/star-field-material';
+export * from './blur-pass/blur-pass';
+export * from './caustics-material/caustics-material';
+export * from './caustics-material/caustics-projection-material';
+export * from './convolution-material/convolution-material';
+export * from './discard-material/discard-material';
+export * from './mesh-distort-material/mesh-distort-material';
+export * from './mesh-reflector-material/mesh-reflector-material';
+export * from './mesh-refraction-material/mesh-refraction-material';
+export * from './mesh-transmission-material/mesh-transmission-material';
+export * from './mesh-wobble-material/mesh-wobble-material';
+export * from './soft-shadow-material/soft-shadow-material';
+export * from './sparkles-material/sparkles-material';
+export * from './spot-light-material/spot-light-material';
+export * from './star-field-material/star-field-material';

package/shaders/{lib/mesh-distort-material → mesh-distort-material}/mesh-distort-material.d.ts

@@ -4,7 +4,7 @@ interface Uniform<T> {
     value: T;
 }
 /**
- * npm i -D raw-loader glslify-loader
+ * npm i -D raw-loader glslify-loader glsl-noise
  * Usage: import distort from 'raw-loader!glslify-loader!angular-three-soba/assets/distort.vert.glsl'
  *
  * provideNgtsMeshDistortMaterialShader(distort)

package/shaders/{lib/mesh-wobble-material → mesh-wobble-material}/mesh-wobble-material.d.ts

@@ -11,5 +11,6 @@ export declare class MeshWobbleMaterial extends THREE.MeshStandardMaterial {
     set time(v: number);
     get factor(): number;
     set factor(v: number);
+    speed: number;
 }
 export {};

package/shaders/{lib/soft-shadow-material → soft-shadow-material}/soft-shadow-material.d.ts

@@ -2,9 +2,9 @@ import * as THREE from 'three';
 export declare const SoftShadowMaterial: typeof THREE.ShaderMaterial & {
     key: string;
 };
-export type SoftShadowMaterialInputs = {
+export interface SoftShadowMaterialInputs {
     map: THREE.Texture;
     color?: THREE.ColorRepresentation;
     alphaTest?: number;
     blend?: number;
-};
+}

package/shaders/sparkles-material/sparkles-material.d.ts

@@ -0,0 +1,3 @@
+export declare const SparklesMaterial: typeof import("three").ShaderMaterial & {
+    key: string;
+};

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

@@ -1,14 +1,38 @@
-import { InjectionToken } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
+import { InjectionToken, Signal } from '@angular/core';
+import { NgtSignalStore, type NgtGroup } from 'angular-three';
 import { SoftShadowMaterialInputs } from 'angular-three-soba/shaders';
-import * as THREE from 'three';
+import { Group, Mesh, PlaneGeometry } from 'three';
 import { ProgressiveLightMap } from './progressive-light-map';
 import * as i0 from "@angular/core";
+export interface NgtsAccumulativeShadowsState {
+    /** How many frames it can render, more yields cleaner results but takes more time, 40 */
+    frames: number;
+    /** If frames === Infinity blend controls the refresh ratio, 100 */
+    blend: number;
+    /** Can limit the amount of frames rendered if frames === Infinity, usually to get some performance back once a movable scene has settled, Infinity */
+    limit: number;
+    /** Scale of the plane,  */
+    scale: number;
+    /** Temporal accumulates shadows over time which is more performant but has a visual regression over instant results, false  */
+    temporal: boolean;
+    /** Opacity of the plane, 1 */
+    opacity: number;
+    /** Discards alpha pixels, 0.65 */
+    alphaTest: number;
+    /** Shadow color, black */
+    color: string;
+    /** Colorblend, how much colors turn to black, 0 is black, 2 */
+    colorBlend: number;
+    /** Buffer resolution, 1024 */
+    resolution: number;
+    /** Texture tonemapping */
+    toneMapped: boolean;
+}
 export type NgtsAccumulativeShadowsLightApi = {
     update: () => void;
 };
-export type NgtsAccumulativeShadowsApi = {
-    lights: Map<string, NgtsAccumulativeShadowsLightApi>;
+export interface NgtsAccumulativeShadowsApi {
+    lights: Map<string, Signal<NgtsAccumulativeShadowsLightApi>>;
     temporal: boolean;
     frames: number;
     blend: number;
@@ -16,20 +40,17 @@ export type NgtsAccumulativeShadowsApi = {
     getMesh: () => THREE.Mesh<THREE.PlaneGeometry, SoftShadowMaterialInputs & THREE.ShaderMaterial>;
     reset: () => void;
     update: (frames?: number) => void;
-};
-export declare const NGTS_ACCUMULATIVE_SHADOWS_API: InjectionToken<NgtsAccumulativeShadowsApi>;
-export declare class AccumulativeShadowsConsumer {
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<AccumulativeShadowsConsumer, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AccumulativeShadowsConsumer, "[ngtsAccumulativeShadowsConsumer]", never, {}, {}, never, never, true, never>;
 }
-export declare class NgtsAccumulativeShadows extends NgtRxStore {
+export declare const NGTS_ACCUMULATIVE_SHADOWS_API: InjectionToken<Signal<NgtsAccumulativeShadowsApi>>;
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-accumulative-shadows': NgtGroup & NgtsAccumulativeShadowsState;
+    }
+}
+export declare class NgtsAccumulativeShadows extends NgtSignalStore<NgtsAccumulativeShadowsState> {
+    #private;
     readonly nullTraverse: () => null;
     readonly Math: Math;
-    private readonly store;
-    readonly pLM: ProgressiveLightMap;
-    readonly accumulativeShadowsRef: import("angular-three").NgtInjectedRef<THREE.Group>;
-    readonly meshRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
     /** How many frames it can render, more yields cleaner results but takes more time, 40 */
     set frames(frames: number);
     /** If frames === Infinity blend controls the refresh ratio, 100 */
@@ -52,7 +73,24 @@ export declare class NgtsAccumulativeShadows extends NgtRxStore {
     set resolution(resolution: number);
     /** Texture tonemapping */
     set toneMapped(toneMapped: boolean);
-    initialize(): void;
+    readonly accumulativeShadowsScale: Signal<number>;
+    readonly accumulativeShadowsToneMapped: Signal<boolean>;
+    readonly accumulativeShadowsColor: Signal<string>;
+    readonly accumulativeShadowsColorBlend: Signal<number>;
+    readonly meshRef: import("angular-three").NgtInjectedRef<Mesh<PlaneGeometry, SoftShadowMaterialInputs & import("three").ShaderMaterial>>;
+    readonly accumulativeShadowsRef: import("angular-three").NgtInjectedRef<Group>;
+    readonly pLM: Signal<ProgressiveLightMap>;
+    readonly api: Signal<{
+        lights: Map<any, any>;
+        temporal: boolean;
+        frames: number;
+        blend: number;
+        count: number;
+        getMesh: () => Mesh<PlaneGeometry, SoftShadowMaterialInputs & import("three").ShaderMaterial>;
+        reset: () => void;
+        update: (frames?: number) => void;
+    }>;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsAccumulativeShadows, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsAccumulativeShadows, "ngts-accumulative-shadows", never, { "frames": { "alias": "frames"; "required": false; }; "blend": { "alias": "blend"; "required": false; }; "limit": { "alias": "limit"; "required": false; }; "scale": { "alias": "scale"; "required": false; }; "temporal": { "alias": "temporal"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "alphaTest": { "alias": "alphaTest"; "required": false; }; "color": { "alias": "color"; "required": false; }; "colorBlend": { "alias": "colorBlend"; "required": false; }; "resolution": { "alias": "resolution"; "required": false; }; "toneMapped": { "alias": "toneMapped"; "required": false; }; }, {}, never, ["*"], true, never>;
 }

package/staging/{lib/accumulative-shadows → accumulative-shadows}/progressive-light-map.d.ts

@@ -29,6 +29,6 @@ export declare class ProgressiveLightMap {
     clear(): void;
     prepare(): void;
     finish(): void;
-    configure(object: any): void;
-    update(camera: any, blendWindow?: number): void;
+    configure(object: THREE.Mesh): void;
+    update(camera: THREE.Camera, blendWindow?: number): void;
 }

package/staging/{lib/accumulative-shadows → accumulative-shadows}/randomized-lights.d.ts

@@ -1,15 +1,40 @@
-import { InjectionToken } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
+import { NgtSignalStore, type NgtGroup } from 'angular-three';
 import * as THREE from 'three';
-import { NgtsAccumulativeShadowsLightApi } from './accumulative-shadows';
 import * as i0 from "@angular/core";
-export declare const NGTS_RANDOMIZED_LIGHTS_API: InjectionToken<NgtsAccumulativeShadowsLightApi>;
-export declare class RandomizedLightsConsumer {
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<RandomizedLightsConsumer, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RandomizedLightsConsumer, "[ngtsRandomizedLightsConsumer]", never, {}, {}, never, never, true, never>;
+export interface NgtsRandomizedLightsState {
+    /** How many frames it will jiggle the lights, 1.
+     *  Frames is context aware, if a provider like AccumulativeShadows exists, frames will be taken from there!  */
+    frames: number;
+    /** Light position, [0, 0, 0] */
+    position: [x: number, y: number, z: number];
+    /** Radius of the jiggle, higher values make softer light, 5 */
+    radius: number;
+    /** Amount of lights, 8 */
+    amount: number;
+    /** Light intensity, 1 */
+    intensity: number;
+    /** Ambient occlusion, lower values mean less AO, hight more, you can mix AO and directional light, 0.5 */
+    ambient: number;
+    /** If the lights cast shadows, this is true by default */
+    castShadow: boolean;
+    /** Default shadow bias, 0 */
+    bias: number;
+    /** Default map size, 512 */
+    mapSize: number;
+    /** Default size of the shadow camera, 10 */
+    size: number;
+    /** Default shadow camera near, 0.5 */
+    near: number;
+    /** Default shadow camera far, 500 */
+    far: number;
 }
-export declare class NgtsRandomizedLights extends NgtRxStore {
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-randomized-lights': NgtGroup & NgtsRandomizedLightsState;
+    }
+}
+export declare class NgtsRandomizedLights extends NgtSignalStore<NgtsRandomizedLightsState> {
+    #private;
     lightsRef: import("angular-three").NgtInjectedRef<THREE.Group>;
     /** How many frames it will jiggle the lights, 1.
      *  Frames is context aware, if a provider like AccumulativeShadows exists, frames will be taken from there!  */
@@ -36,7 +61,17 @@ export declare class NgtsRandomizedLights extends NgtRxStore {
     set near(near: number);
     /** Default shadow camera far, 500 */
     set far(far: number);
-    initialize(): void;
+    readonly lightsAmount: import("@angular/core").Signal<number>;
+    readonly lightsCastShadow: import("@angular/core").Signal<boolean>;
+    readonly lightsIntensity: import("@angular/core").Signal<number>;
+    readonly lightsBias: import("@angular/core").Signal<number>;
+    readonly shadowMapSize: import("@angular/core").Signal<number[]>;
+    readonly cameraArgs: import("@angular/core").Signal<number[]>;
+    readonly length: import("@angular/core").Signal<number>;
+    readonly api: import("@angular/core").Signal<{
+        update: () => void;
+    }>;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsRandomizedLights, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsRandomizedLights, "ngts-randomized-lights", never, { "lightsRef": { "alias": "lightsRef"; "required": false; }; "frames": { "alias": "frames"; "required": false; }; "position": { "alias": "position"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "amount": { "alias": "amount"; "required": false; }; "intensity": { "alias": "intensity"; "required": false; }; "ambient": { "alias": "ambient"; "required": false; }; "castShadow": { "alias": "castShadow"; "required": false; }; "bias": { "alias": "bias"; "required": false; }; "mapSize": { "alias": "mapSize"; "required": false; }; "size": { "alias": "size"; "required": false; }; "near": { "alias": "near"; "required": false; }; "far": { "alias": "far"; "required": false; }; }, {}, never, never, true, never>;
 }

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

@@ -1,14 +1,14 @@
-import { EventEmitter, InjectionToken, OnInit } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
+import { EventEmitter, InjectionToken, Signal } from '@angular/core';
+import { NgtSignalStore } from 'angular-three';
 import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export interface NgtsBoundsSize {
+export type NgtsBoundsSize = {
     box: THREE.Box3;
     size: THREE.Vector3;
     center: THREE.Vector3;
     distance: number;
-}
-export interface NgtsBoundsApi {
+};
+export type NgtsBoundsApi = {
     getSize: () => NgtsBoundsSize;
     refresh: (object?: THREE.Object3D | THREE.Box3) => NgtsBoundsApi;
     clip: () => NgtsBoundsApi;
@@ -17,9 +17,18 @@ export interface NgtsBoundsApi {
         position: [number, number, number];
         target?: [number, number, number];
     }) => NgtsBoundsApi;
+};
+export declare const NGTS_BOUNDS_API: InjectionToken<Signal<NgtsBoundsApi>>;
+export interface NgtsBoundsState {
+    damping: number;
+    fit: boolean;
+    clip: boolean;
+    observe: boolean;
+    margin: number;
+    eps: number;
 }
-export declare const NGTS_BOUNDS_API: InjectionToken<NgtsBoundsApi>;
-export declare class NgtsBounds extends NgtRxStore implements OnInit {
+export declare class NgtsBounds extends NgtSignalStore<NgtsBoundsState> {
+    #private;
     boundsRef: import("angular-three").NgtInjectedRef<THREE.Group>;
     set damping(damping: number);
     set fit(fit: boolean);
@@ -28,21 +37,22 @@ export declare class NgtsBounds extends NgtRxStore implements OnInit {
     set margin(margin: number);
     set eps(eps: number);
     fitted: EventEmitter<NgtsBoundsSize>;
-    private readonly store;
-    readonly current: {
-        animating: boolean;
-        focus: THREE.Vector3;
-        camera: THREE.Vector3;
-        zoom: number;
-    };
-    readonly goal: {
-        focus: THREE.Vector3;
-        camera: THREE.Vector3;
-        zoom: number;
-    };
-    initialize(): void;
-    ngOnInit(): void;
-    private preventDragHijacking;
+    readonly api: Signal<{
+        getSize: () => {
+            box: THREE.Box3;
+            size: THREE.Vector3;
+            center: THREE.Vector3;
+            distance: number;
+        };
+        refresh(object?: THREE.Object3D | THREE.Box3): any;
+        clip(): any;
+        to({ position, target }: {
+            position: [number, number, number];
+            target?: [number, number, number] | undefined;
+        }): any;
+        fit(): any;
+    }>;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsBounds, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsBounds, "ngts-bounds", never, { "boundsRef": { "alias": "boundsRef"; "required": false; }; "damping": { "alias": "damping"; "required": false; }; "fit": { "alias": "fit"; "required": false; }; "clip": { "alias": "clip"; "required": false; }; "observe": { "alias": "observe"; "required": false; }; "margin": { "alias": "margin"; "required": false; }; "eps": { "alias": "eps"; "required": false; }; }, { "fitted": "fitted"; }, never, ["*"], true, never>;
 }

package/staging/{lib/camera-shake → camera-shake}/camera-shake.d.ts

@@ -1,12 +1,19 @@
 import { OnInit } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
+import { NgtSignalStore } from 'angular-three';
 import * as i0 from "@angular/core";
-export declare class NgtsCameraShake extends NgtRxStore implements OnInit {
-    private readonly store;
-    private initialRotation;
-    private readonly yawNoise;
-    private readonly pitchNoise;
-    private readonly rollNoise;
+export interface NgtsCameraShakeState {
+    intensity: number;
+    decay: boolean;
+    decayRate: number;
+    maxYaw: number;
+    maxPitch: number;
+    maxRoll: number;
+    yawFrequency: number;
+    pitchFrequency: number;
+    rollFrequency: number;
+}
+export declare class NgtsCameraShake extends NgtSignalStore<NgtsCameraShakeState> implements OnInit {
+    #private;
     set intensity(intensity: number);
     set decay(decay: boolean);
     set decayRate(decayRate: number);
@@ -16,13 +23,10 @@ export declare class NgtsCameraShake extends NgtRxStore implements OnInit {
     set yawFrequency(yawFrequency: number);
     set pitchFrequency(pitchFrequency: number);
     set rollFrequency(rollFrequency: number);
-    initialize(): void;
     constructor();
     ngOnInit(): void;
-    private setChangeEvent;
-    getIntensity(): any;
+    getIntensity(): number;
     setIntensity(intensity: number): void;
-    private constraintIntensity;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCameraShake, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsCameraShake, "ngts-camera-shake", never, { "intensity": { "alias": "intensity"; "required": false; }; "decay": { "alias": "decay"; "required": false; }; "decayRate": { "alias": "decayRate"; "required": false; }; "maxYaw": { "alias": "maxYaw"; "required": false; }; "maxPitch": { "alias": "maxPitch"; "required": false; }; "maxRoll": { "alias": "maxRoll"; "required": false; }; "yawFrequency": { "alias": "yawFrequency"; "required": false; }; "pitchFrequency": { "alias": "pitchFrequency"; "required": false; }; "rollFrequency": { "alias": "rollFrequency"; "required": false; }; }, {}, never, never, true, never>;
 }

package/staging/{lib/caustics/caustics.d.ts → caustics/caustisc.d.ts}

@@ -1,13 +1,38 @@
-import { ElementRef, OnInit } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
+import { ElementRef } from '@angular/core';
+import { NgtSignalStore } from 'angular-three';
 import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export declare class NgtsCaustics extends NgtRxStore implements OnInit {
+export interface NgtsCausticsState {
+    /** How many frames it will render, set it to Infinity for runtime, default: 1 */
+    frames: number;
+    /** Enables visual cues to help you stage your scene, default: false */
+    debug: boolean;
+    /** Will display caustics only and skip the models, default: false */
+    causticsOnly: boolean;
+    /** Will include back faces and enable the backsideIOR prop, default: false */
+    backside: boolean;
+    /** The IOR refraction index, default: 1.1 */
+    ior: number;
+    /** The IOR refraction index for back faces (only available when backside is enabled), default: 1.1 */
+    backsideIOR: number;
+    /** The texel size, default: 0.3125 */
+    worldRadius: number;
+    /** Intensity of the prjected caustics, default: 0.05 */
+    intensity: number;
+    /** Caustics color, default: white */
+    color: THREE.ColorRepresentation;
+    /** Buffer resolution, default: 2048 */
+    resolution: number;
+    /** Camera position, it will point towards the contents bounds center, default: [5, 5, 5] */
+    lightSource: [x: number, y: number, z: number] | ElementRef<THREE.Object3D>;
+}
+export declare class NgtsCaustics extends NgtSignalStore<NgtsCausticsState> {
+    #private;
     readonly CustomBlending: 5;
     readonly OneFactor: 201;
     readonly SrcAlphaFactor: 204;
     readonly Math: Math;
-    readonly planeRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    readonly planeRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
     readonly sceneRef: import("angular-three").NgtInjectedRef<THREE.Scene>;
     readonly cameraRef: import("angular-three").NgtInjectedRef<THREE.OrthographicCamera>;
     causticsRef: import("angular-three").NgtInjectedRef<THREE.Group>;
@@ -33,15 +58,13 @@ export declare class NgtsCaustics extends NgtRxStore implements OnInit {
     set resolution(resolution: number);
     /** Camera position, it will point towards the contents bounds center, default: [5, 5, 5] */
     set lightSource(lightSource: [x: number, y: number, z: number] | ElementRef<THREE.Object3D>);
-    readonly normalTargetFbo: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
-    readonly normalTargetBFbo: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
-    readonly causticsTargetFbo: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
-    readonly causticsTargetBFbo: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
-    private readonly store;
-    initialize(): void;
-    ngOnInit(): void;
-    private updateWorldMatrix;
-    private setBeforeRender;
+    readonly causticsColor: import("@angular/core").Signal<THREE.ColorRepresentation>;
+    readonly causticsDebug: import("@angular/core").Signal<boolean>;
+    readonly normalTargetFbo: import("@angular/core").Signal<THREE.WebGLRenderTarget>;
+    readonly normalTargetBFbo: import("@angular/core").Signal<THREE.WebGLRenderTarget>;
+    readonly causticsTargetFbo: import("@angular/core").Signal<THREE.WebGLRenderTarget>;
+    readonly causticsTargetBFbo: import("@angular/core").Signal<THREE.WebGLRenderTarget>;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCaustics, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCaustics, "ngts-caustics", never, { "causticsRef": { "alias": "causticsRef"; "required": false; }; "frames": { "alias": "frames"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; "causticsOnly": { "alias": "causticsOnly"; "required": false; }; "backside": { "alias": "backside"; "required": false; }; "ior": { "alias": "ior"; "required": false; }; "backsideIOR": { "alias": "backsideIOR"; "required": false; }; "worldRadius": { "alias": "worldRadius"; "required": false; }; "intensity": { "alias": "intensity"; "required": false; }; "color": { "alias": "color"; "required": false; }; "resolution": { "alias": "resolution"; "required": false; }; "lightSource": { "alias": "lightSource"; "required": false; }; }, {}, never, ["*"], true, never>;
 }

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

@@ -1,8 +1,32 @@
-import { EventEmitter, OnInit } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
+import { EventEmitter } from '@angular/core';
+import { NgtSignalStore, type NgtGroup } from 'angular-three';
 import { Box3, Group, Sphere, Vector3 } from 'three';
 import * as i0 from "@angular/core";
-export declare class NgtsCenter extends NgtRxStore implements OnInit {
+export type NgtsCenterState = {
+    top?: boolean;
+    right?: boolean;
+    bottom?: boolean;
+    left?: boolean;
+    front?: boolean;
+    back?: boolean;
+    /** Disable all axes */
+    disable?: boolean;
+    /** Disable x-axis centering */
+    disableX?: boolean;
+    /** Disable y-axis centering */
+    disableY?: boolean;
+    /** Disable z-axis centering */
+    disableZ?: boolean;
+    /** See https://threejs.org/docs/index.html?q=box3#api/en/math/Box3.setFromObject */
+    precise: boolean;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-center': NgtsCenterState & NgtGroup;
+    }
+}
+export declare class NgtsCenter extends NgtSignalStore<NgtsCenterState> {
+    #private;
     centerRef: import("angular-three").NgtInjectedRef<Group>;
     readonly outerRef: import("angular-three").NgtInjectedRef<Group>;
     readonly innerRef: import("angular-three").NgtInjectedRef<Group>;
@@ -15,7 +39,7 @@ export declare class NgtsCenter extends NgtRxStore implements OnInit {
     set disableX(disableX: boolean);
     set disableY(disableY: boolean);
     set disableZ(disableZ: boolean);
-    set disabled(disabled: boolean);
+    set disable(disable: boolean);
     set precise(precise: boolean);
     centered: EventEmitter<{
         /** The next parent above <Center> */
@@ -32,9 +56,7 @@ export declare class NgtsCenter extends NgtRxStore implements OnInit {
         horizontalAlignment: number;
         depthAlignment: number;
     }>;
-    initialize(): void;
-    ngOnInit(): void;
-    private setPosition;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCenter, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCenter, "ngts-center", never, { "centerRef": { "alias": "centerRef"; "required": false; }; "top": { "alias": "top"; "required": false; }; "right": { "alias": "right"; "required": false; }; "bottom": { "alias": "bottom"; "required": false; }; "left": { "alias": "left"; "required": false; }; "front": { "alias": "front"; "required": false; }; "back": { "alias": "back"; "required": false; }; "disableX": { "alias": "disableX"; "required": false; }; "disableY": { "alias": "disableY"; "required": false; }; "disableZ": { "alias": "disableZ"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "precise": { "alias": "precise"; "required": false; }; }, { "centered": "centered"; }, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCenter, "ngts-center", never, { "centerRef": { "alias": "centerRef"; "required": false; }; "top": { "alias": "top"; "required": false; }; "right": { "alias": "right"; "required": false; }; "bottom": { "alias": "bottom"; "required": false; }; "left": { "alias": "left"; "required": false; }; "front": { "alias": "front"; "required": false; }; "back": { "alias": "back"; "required": false; }; "disableX": { "alias": "disableX"; "required": false; }; "disableY": { "alias": "disableY"; "required": false; }; "disableZ": { "alias": "disableZ"; "required": false; }; "disable": { "alias": "disable"; "required": false; }; "precise": { "alias": "precise"; "required": false; }; }, { "centered": "centered"; }, never, ["*"], true, never>;
 }