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

package/fesm2022/angular-three-soba.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"angular-three-soba.mjs","sources":["../../../../libs/angular-three-soba/src/index.ts","../../../../libs/angular-three-soba/src/angular-three-soba.ts"],"sourcesContent":["export default void 0;\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"AAAA,YAAe,KAAK,CAAC;;ACArB;;AAEG"}
+{"version":3,"file":"angular-three-soba.mjs","sources":["../../../../libs/soba/src/index.ts","../../../../libs/soba/src/angular-three-soba.ts"],"sourcesContent":["export default void 0;\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"AAAA,YAAe,KAAK,CAAC;;ACArB;;AAEG"}

package/loaders/gltf-loader/gltf-loader.d.ts

@@ -0,0 +1,9 @@
+import { Injector, Signal } from '@angular/core';
+import { type NgtLoaderResults, type NgtObjectMap } from 'angular-three';
+import { GLTF, GLTFLoader } from 'three-stdlib/loaders/GLTFLoader';
+export declare function injectNgtsGLTFLoader<TUrl extends string | string[] | Record<string, string>>(path: () => TUrl, { useDraco, useMeshOpt, injector, extensions, }?: {
+    useDraco?: boolean | string;
+    useMeshOpt?: boolean;
+    injector?: Injector;
+    extensions?: (loader: GLTFLoader) => void;
+}): Signal<NgtLoaderResults<TUrl, GLTF & NgtObjectMap>>;

package/loaders/index.d.ts

@@ -1,5 +1,4 @@
-export * from './lib/cube-texture-loader/cube-texture-loader';
-export * from './lib/gltf-loader/gltf-loader';
-export * from './lib/loader/loader';
-export * from './lib/progress/progress';
-export * from './lib/texture-loader/texture-loader';
+export * from './gltf-loader/gltf-loader';
+export * from './loader/loader';
+export * from './progress/progress';
+export * from './texture-loader/texture-loader';

package/loaders/{lib/loader → loader}/loader.d.ts

@@ -1,17 +1,22 @@
-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 NgtsLoader extends NgtRxStore implements OnInit {
-    private readonly progress;
-    readonly vm$: import("rxjs").Observable<{
-        shown: any;
-        containerClass: any;
-        innerClass: any;
-        barClass: any;
-        dataClass: any;
-        progress: number;
-        active: boolean;
-    }>;
+export interface NgtsLoaderState {
+    containerClass?: string;
+    innerClass?: string;
+    barClass?: string;
+    dataClass?: string;
+    dataInterpolation: (value: number) => string;
+    initialState: (value: boolean) => boolean;
+}
+export declare class NgtsLoader extends NgtSignalStore<NgtsLoaderState> {
+    #private;
+    readonly active: import("@angular/core").Signal<boolean>;
+    readonly progress: import("@angular/core").Signal<number>;
+    readonly container: import("@angular/core").Signal<string | undefined>;
+    readonly inner: import("@angular/core").Signal<string | undefined>;
+    readonly bar: import("@angular/core").Signal<string | undefined>;
+    readonly data: import("@angular/core").Signal<string | undefined>;
     set containerClass(containerClass: string);
     set innerClass(innerClass: string);
     set barClass(barClass: string);
@@ -19,8 +24,8 @@ export declare class NgtsLoader extends NgtRxStore implements OnInit {
     set dataInterpolation(dataInterpolation: (value: number) => string);
     set initialState(initialState: (value: boolean) => boolean);
     progressSpanRef?: ElementRef<HTMLSpanElement>;
-    initialize(): void;
-    ngOnInit(): void;
+    readonly shown: import("@angular/core").WritableSignal<boolean>;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsLoader, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsLoader, "ngts-loader", never, { "containerClass": { "alias": "containerClass"; "required": false; }; "innerClass": { "alias": "innerClass"; "required": false; }; "barClass": { "alias": "barClass"; "required": false; }; "dataClass": { "alias": "dataClass"; "required": false; }; "dataInterpolation": { "alias": "dataInterpolation"; "required": false; }; "initialState": { "alias": "initialState"; "required": false; }; }, {}, never, never, true, never>;
 }

package/loaders/progress/progress.d.ts

@@ -0,0 +1,9 @@
+import { Injector } from '@angular/core';
+export declare function injectNgtsProgress(injector?: Injector): import("@angular/core").Signal<{
+    errors: string[];
+    active: boolean;
+    progress: number;
+    item: string;
+    loaded: number;
+    total: number;
+}>;

package/loaders/texture-loader/texture-loader.d.ts

@@ -0,0 +1,7 @@
+import { Injector, type Signal } from '@angular/core';
+import { type NgtLoaderResults } from 'angular-three';
+import * as THREE from 'three';
+export declare function injectNgtsTextureLoader<TInput extends string[] | string | Record<string, string>>(input: () => TInput, { onLoad, injector, }?: {
+    onLoad?: (texture: THREE.Texture | THREE.Texture[]) => void;
+    injector?: Injector;
+}): Signal<NgtLoaderResults<TInput, THREE.Texture>>;

package/materials/index.d.ts

@@ -1,5 +1,5 @@
-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 './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';

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

@@ -1,8 +1,12 @@
-import { NgtRxStore } from 'angular-three';
-import { MeshDistortMaterial } from 'angular-three-soba/shaders';
+import { NgtSignalStore } from 'angular-three';
 import * as i0 from "@angular/core";
-export declare class NgtsMeshDistortMaterial extends NgtRxStore {
-    readonly MeshDistortMaterial: MeshDistortMaterial;
+export interface NgtsMeshDistortMaterialState {
+    time: number;
+    distort: number;
+    radius: number;
+    speed: number;
+}
+export declare class NgtsMeshDistortMaterial extends NgtSignalStore<NgtsMeshDistortMaterialState> {
     readonly material: {
         time: number;
         distort: number;
@@ -17,7 +21,9 @@ export declare class NgtsMeshDistortMaterial extends NgtRxStore {
     set distort(distort: number);
     set radius(radius: number);
     set speed(speed: number);
-    initialize(): void;
+    readonly distortTime: import("@angular/core").Signal<number>;
+    readonly distortDistort: import("@angular/core").Signal<number>;
+    readonly distortRadius: import("@angular/core").Signal<number>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshDistortMaterial, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshDistortMaterial, "ngts-mesh-distort-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "time": { "alias": "time"; "required": false; }; "distort": { "alias": "distort"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "speed": { "alias": "speed"; "required": false; }; }, {}, never, never, true, never>;

package/materials/mesh-reflector-material/mesh-reflector-material.d.ts

@@ -0,0 +1,81 @@
+import { NgtSignalStore } from 'angular-three';
+import { MeshReflectorMaterial } from 'angular-three-soba/shaders';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsMeshReflectorMaterialState {
+    resolution: number;
+    mixBlur: number;
+    mixStrength: number;
+    blur: [number, number] | number;
+    mirror: number;
+    minDepthThreshold: number;
+    maxDepthThreshold: number;
+    depthScale: number;
+    depthToBlurRatioBias: number;
+    distortionMap?: THREE.Texture;
+    distortion: number;
+    mixContrast: number;
+    reflectorOffset: number;
+}
+export declare class NgtsMeshReflectorMaterial extends NgtSignalStore<NgtsMeshReflectorMaterialState> {
+    #private;
+    materialRef: import("angular-three").NgtInjectedRef<MeshReflectorMaterial>;
+    set resolution(resolution: number);
+    set mixBlur(mixBlur: number);
+    set mixStrength(mixStrength: number);
+    set blur(blur: [number, number] | number);
+    set mirror(mirror: number);
+    set minDepthThreshold(minDepthThreshold: number);
+    set maxDepthThreshold(maxDepthThreshold: number);
+    set depthScale(depthScale: number);
+    set depthToBlurRatioBias(depthToBlurRatioBias: number);
+    set distortionMap(distortionMap: THREE.Texture);
+    set distortion(distortion: number);
+    set mixContrast(mixContrast: number);
+    set reflectorOffset(reflectorOffset: number);
+    readonly reflectorProps: import("@angular/core").Signal<{
+        mirror: number;
+        textureMatrix: THREE.Matrix4;
+        mixBlur: number;
+        tDiffuse: THREE.Texture;
+        tDepth: THREE.DepthTexture;
+        tDiffuseBlur: THREE.Texture;
+        hasBlur: boolean;
+        mixStrength: number;
+        minDepthThreshold: number;
+        maxDepthThreshold: number;
+        depthScale: number;
+        depthToBlurRatioBias: number;
+        distortion: number;
+        distortionMap: THREE.Texture | undefined;
+        mixContrast: number;
+        defines: {
+            USE_BLUR: string | undefined;
+            USE_DEPTH: string | undefined;
+            USE_DISTORTION: string | undefined;
+        };
+    }>;
+    readonly defines: import("@angular/core").Signal<{
+        USE_BLUR: string | undefined;
+        USE_DEPTH: string | undefined;
+        USE_DISTORTION: string | undefined;
+    }>;
+    readonly reflectorMirror: import("@angular/core").Signal<number>;
+    readonly reflectorTextureMatrix: import("@angular/core").Signal<THREE.Matrix4>;
+    readonly reflectorMixBlur: import("@angular/core").Signal<number>;
+    readonly reflectorTDiffuse: import("@angular/core").Signal<THREE.Texture>;
+    readonly reflectorTDepth: import("@angular/core").Signal<THREE.DepthTexture>;
+    readonly reflectorTDiffuseBlur: import("@angular/core").Signal<THREE.Texture>;
+    readonly reflectorHasBlur: import("@angular/core").Signal<boolean>;
+    readonly reflectorMixStrength: import("@angular/core").Signal<number>;
+    readonly reflectorMinDepthThreshold: import("@angular/core").Signal<number>;
+    readonly reflectorMaxDepthThreshold: import("@angular/core").Signal<number>;
+    readonly reflectorDepthScale: import("@angular/core").Signal<number>;
+    readonly reflectorDepthToBlurRatioBias: import("@angular/core").Signal<number>;
+    readonly reflectorDistortion: import("@angular/core").Signal<number>;
+    readonly reflectorDistortionMap: import("@angular/core").Signal<THREE.Texture | undefined>;
+    readonly reflectorMixContrast: import("@angular/core").Signal<number>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshReflectorMaterial, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshReflectorMaterial, "ngts-mesh-reflector-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "resolution": { "alias": "resolution"; "required": false; }; "mixBlur": { "alias": "mixBlur"; "required": false; }; "mixStrength": { "alias": "mixStrength"; "required": false; }; "blur": { "alias": "blur"; "required": false; }; "mirror": { "alias": "mirror"; "required": false; }; "minDepthThreshold": { "alias": "minDepthThreshold"; "required": false; }; "maxDepthThreshold": { "alias": "maxDepthThreshold"; "required": false; }; "depthScale": { "alias": "depthScale"; "required": false; }; "depthToBlurRatioBias": { "alias": "depthToBlurRatioBias"; "required": false; }; "distortionMap": { "alias": "distortionMap"; "required": false; }; "distortion": { "alias": "distortion"; "required": false; }; "mixContrast": { "alias": "mixContrast"; "required": false; }; "reflectorOffset": { "alias": "reflectorOffset"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/materials/mesh-refraction-material/mesh-refraction-material.d.ts

@@ -0,0 +1,50 @@
+import { NgtSignalStore } from 'angular-three';
+import * as i0 from "@angular/core";
+export interface NgtsMeshRefractionMaterialState {
+    /** Environment map */
+    envMap: THREE.CubeTexture | THREE.Texture;
+    /** Number of ray-cast bounces, it can be expensive to have too many, 2 */
+    bounces: number;
+    /** Refraction index, 2.4 */
+    ior: number;
+    /** Fresnel (strip light), 0 */
+    fresnel: number;
+    /** RGB shift intensity, can be expensive, 0 */
+    aberrationStrength: number;
+    /** Color, white */
+    color: THREE.ColorRepresentation;
+    /** If this is on it uses fewer ray casts for the RGB shift sacrificing physical accuracy, true */
+    fastChroma: boolean;
+}
+export declare class NgtsMeshRefractionMaterial extends NgtSignalStore<NgtsMeshRefractionMaterialState> {
+    #private;
+    materialRef: import("angular-three").NgtInjectedRef<import("three").ShaderMaterial>;
+    /** Environment map */
+    set envMap(envMap: THREE.CubeTexture | THREE.Texture);
+    /** Number of ray-cast bounces, it can be expensive to have too many, 2 */
+    set bounces(bounces: number);
+    /** Refraction index, 2.4 */
+    set ior(ior: number);
+    /** Fresnel (strip light), 0 */
+    set fresnel(fresnel: number);
+    /** RGB shift intensity, can be expensive, 0 */
+    set aberrationStrength(aberrationStrength: number);
+    /** Color, white */
+    set color(color: THREE.ColorRepresentation);
+    /** If this is on it uses fewer ray casts for the RGB shift sacrificing physical accuracy, true */
+    set fastChroma(fastChroma: boolean);
+    readonly refractionEnvMap: import("@angular/core").Signal<import("three").Texture | import("three").CubeTexture>;
+    readonly refractionBounces: import("@angular/core").Signal<number>;
+    readonly refractionIor: import("@angular/core").Signal<number>;
+    readonly refractionFresnel: import("@angular/core").Signal<number>;
+    readonly refractionAberrationStrength: import("@angular/core").Signal<number>;
+    readonly refractionColor: import("@angular/core").Signal<import("three").ColorRepresentation>;
+    readonly refractionFastChroma: import("@angular/core").Signal<boolean>;
+    readonly defines: import("@angular/core").Signal<{
+        [key: string]: string;
+    } | null>;
+    readonly resolution: import("@angular/core").Signal<number[]>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshRefractionMaterial, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshRefractionMaterial, "ngts-mesh-refraction-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "envMap": { "alias": "envMap"; "required": true; }; "bounces": { "alias": "bounces"; "required": false; }; "ior": { "alias": "ior"; "required": false; }; "fresnel": { "alias": "fresnel"; "required": false; }; "aberrationStrength": { "alias": "aberrationStrength"; "required": false; }; "color": { "alias": "color"; "required": false; }; "fastChroma": { "alias": "fastChroma"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/materials/{lib/mesh-transmission-material → mesh-transmission-material}/mesh-transmission-material.d.ts

@@ -1,8 +1,40 @@
-import { NgtRxStore } from 'angular-three';
+import { NgtSignalStore } from 'angular-three';
 import { MeshTransmissionMaterial } from 'angular-three-soba/shaders';
 import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export declare class NgtsMeshTranmissionMaterial extends NgtRxStore {
+export interface NgtsMeshTranmissionMaterialState {
+    /** transmissionSampler, you can use the threejs transmission sampler texture that is
+     *  generated once for all transmissive materials. The upside is that it can be faster if you
+     *  use multiple MeshPhysical and Transmission materials, the downside is that transmissive materials
+     *  using this can't see other transparent or transmissive objects, default: false */
+    transmissionSampler: boolean;
+    /** Render the backside of the material (more cost, better results), default: false */
+    backside: boolean;
+    /** Backside thickness (when backside is true), default: 0 */
+    backsideThickness: number;
+    /** Resolution of the local buffer, default: undefined (fullscreen) */
+    resolution: number;
+    /** Resolution of the local buffer for backfaces, default: undefined (fullscreen) */
+    backsideResolution: number;
+    /** Refraction samples, default: 10 */
+    samples: number;
+    /** Buffer scene background (can be a texture, a cubetexture or a color), default: null */
+    background: THREE.Texture | THREE.Color;
+    transmission: number;
+    thickness: number;
+    roughness: number;
+    chromaticAberration: number;
+    anisotropy: number;
+    distortion: number;
+    distortionScale: number;
+    temporalDistortion: number;
+    /** The scene rendered into a texture (use it to share a texture between materials), default: null  */
+    buffer: THREE.Texture | null;
+    /** Internals */
+    time: number;
+}
+export declare class NgtsMeshTranmissionMaterial extends NgtSignalStore<NgtsMeshTranmissionMaterialState> {
+    #private;
     materialRef: import("angular-three").NgtInjectedRef<MeshTransmissionMaterial & {
         time: number;
         buffer?: THREE.Texture | undefined;
@@ -36,10 +68,23 @@ export declare class NgtsMeshTranmissionMaterial extends NgtRxStore {
     set buffer(buffer: THREE.Texture);
     /** Internals */
     set time(time: number);
-    readonly discardMaterial: THREE.ShaderMaterial;
-    readonly fboBackRef: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
-    readonly fboMainRef: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
-    initialize(): void;
+    readonly transmissionTransmissionSampler: import("@angular/core").Signal<boolean>;
+    readonly transmissionBackside: import("@angular/core").Signal<boolean>;
+    readonly transmissionTransmission: import("@angular/core").Signal<number>;
+    readonly transmissionThickness: import("@angular/core").Signal<number>;
+    readonly transmissionBacksideThickness: import("@angular/core").Signal<number>;
+    readonly transmissionSamples: import("@angular/core").Signal<number>;
+    readonly transmissionRoughness: import("@angular/core").Signal<number>;
+    readonly transmissionAnisotropy: import("@angular/core").Signal<number>;
+    readonly transmissionChromaticAberration: import("@angular/core").Signal<number>;
+    readonly transmissionDistortion: import("@angular/core").Signal<number>;
+    readonly transmissionDistortionScale: import("@angular/core").Signal<number>;
+    readonly transmissionTemporalDistortion: import("@angular/core").Signal<number>;
+    readonly transmissionBuffer: import("@angular/core").Signal<THREE.Texture | null>;
+    readonly transmissionTime: import("@angular/core").Signal<number>;
+    readonly fboBackRef: import("@angular/core").Signal<THREE.WebGLRenderTarget>;
+    readonly fboMainRef: import("@angular/core").Signal<THREE.WebGLRenderTarget>;
+    readonly side: 0;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshTranmissionMaterial, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshTranmissionMaterial, "ngts-mesh-transmission-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "transmissionSampler": { "alias": "transmissionSampler"; "required": false; }; "backside": { "alias": "backside"; "required": false; }; "backsideThickness": { "alias": "backsideThickness"; "required": false; }; "resolution": { "alias": "resolution"; "required": false; }; "backsideResolution": { "alias": "backsideResolution"; "required": false; }; "samples": { "alias": "samples"; "required": false; }; "background": { "alias": "background"; "required": false; }; "transmission": { "alias": "transmission"; "required": false; }; "thickness": { "alias": "thickness"; "required": false; }; "roughness": { "alias": "roughness"; "required": false; }; "chromaticAberration": { "alias": "chromaticAberration"; "required": false; }; "anisotropy": { "alias": "anisotropy"; "required": false; }; "distortion": { "alias": "distortion"; "required": false; }; "distortionScale": { "alias": "distortionScale"; "required": false; }; "temporalDistortion": { "alias": "temporalDistortion"; "required": false; }; "buffer": { "alias": "buffer"; "required": false; }; "time": { "alias": "time"; "required": false; }; }, {}, never, never, true, never>;

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

@@ -1,13 +1,19 @@
-import { NgtRxStore } from 'angular-three';
+import { NgtSignalStore } from 'angular-three';
 import { MeshWobbleMaterial } from 'angular-three-soba/shaders';
 import * as i0 from "@angular/core";
-export declare class NgtsMeshWobbleMaterial extends NgtRxStore {
+export interface NgtsMeshWobbleMaterialState {
+    time: number;
+    factor: number;
+    speed: number;
+}
+export declare class NgtsMeshWobbleMaterial extends NgtSignalStore<NgtsMeshWobbleMaterialState> {
     readonly material: MeshWobbleMaterial;
     materialRef: import("angular-three").NgtInjectedRef<MeshWobbleMaterial>;
     set time(time: number);
     set factor(factor: number);
     set speed(speed: number);
-    initialize(): void;
+    readonly wobbleTime: import("@angular/core").Signal<number>;
+    readonly wobbleFactor: import("@angular/core").Signal<number>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshWobbleMaterial, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshWobbleMaterial, "ngts-mesh-wobble-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "time": { "alias": "time"; "required": false; }; "factor": { "alias": "factor"; "required": false; }; "speed": { "alias": "speed"; "required": false; }; }, {}, never, never, true, never>;

package/misc/animations/animations.d.ts

@@ -0,0 +1,13 @@
+import { Injector } from '@angular/core';
+import { type NgtInjectedRef } from 'angular-three';
+import * as THREE from 'three';
+export declare function injectNgtsAnimations(animationsFactory: () => THREE.AnimationClip[], { ref, injector }: {
+    ref?: NgtInjectedRef<THREE.Object3D> | THREE.Object3D;
+    injector?: Injector;
+}): {
+    ref: NgtInjectedRef<THREE.Object3D<THREE.Event>>;
+    actions: Record<string, THREE.AnimationAction>;
+    mixer: THREE.AnimationMixer;
+    names: string[];
+    clips: THREE.AnimationClip[];
+};

package/misc/{lib/bake-shadows → bake-shadows}/bake-shadows.d.ts

@@ -1,9 +1,6 @@
-import { OnInit } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
 import * as i0 from "@angular/core";
-export declare class NgtsBakeShadows extends NgtRxStore implements OnInit {
-    private readonly store;
-    ngOnInit(): void;
+export declare class NgtsBakeShadows {
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsBakeShadows, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsBakeShadows, "ngts-bake-shadows", never, {}, {}, never, never, true, never>;
 }

package/misc/depth-buffer/depth-buffer.d.ts

@@ -0,0 +1,9 @@
+import { Injector } from '@angular/core';
+import * as THREE from 'three';
+export interface NgtsDepthBufferParams {
+    size: number;
+    frames: number;
+}
+export declare function injectNgtsDepthBuffer(paramsFactory?: () => Partial<NgtsDepthBufferParams>, { injector }?: {
+    injector?: Injector;
+}): import("@angular/core").Signal<THREE.DepthTexture>;

package/misc/{lib/fbo → fbo}/fbo.d.ts

@@ -1,4 +1,4 @@
-import { Observable } from 'rxjs';
+import { Injector } from '@angular/core';
 import * as THREE from 'three';
 interface FBOSettings extends THREE.WebGLRenderTargetOptions {
     /** Defines the count of MSAA samples. Can only be used with WebGL 2. Default: 0 */
@@ -11,5 +11,7 @@ export interface NgtsFBOParams {
     height?: number;
     settings?: FBOSettings;
 }
-export declare function injectNgtsFBO(paramsFactory: (defaultParams: Partial<NgtsFBOParams>) => NgtsFBOParams | Observable<NgtsFBOParams>): import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget>;
+export declare function injectNgtsFBO(fboParams: () => NgtsFBOParams, { injector }?: {
+    injector?: Injector;
+}): import("@angular/core").Signal<THREE.WebGLRenderTarget>;
 export {};

package/misc/index.d.ts

@@ -1,4 +1,4 @@
-export * from './lib/animations/animations';
-export * from './lib/bake-shadows/bake-shadows';
-export * from './lib/depth-buffer/depth-buffer';
-export * from './lib/fbo/fbo';
+export * from './animations/animations';
+export * from './bake-shadows/bake-shadows';
+export * from './depth-buffer/depth-buffer';
+export * from './fbo/fbo';

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "angular-three-soba",
-  "version": "1.14.0",
+  "version": "2.0.0-beta.3",
   "publishConfig": {
     "access": "public"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/angular-threejs/soba"
+    "url": "https://github.com/angular-threejs/angular-three/tree/main/libs/soba"
   },
   "author": {
     "name": "Chau Tran",
@@ -17,7 +17,9 @@
   "keywords": [
     "angular",
     "threejs",
-    "renderer"
+    "renderer",
+    "utilities",
+    "shaders"
   ],
   "license": "MIT",
   "exports": {
@@ -31,24 +33,18 @@
       "esm": "./esm2022/angular-three-soba.mjs",
       "default": "./fesm2022/angular-three-soba.mjs"
     },
-    "./abstractions": {
-      "types": "./abstractions/index.d.ts",
-      "esm2022": "./esm2022/abstractions/angular-three-soba-abstractions.mjs",
-      "esm": "./esm2022/abstractions/angular-three-soba-abstractions.mjs",
-      "default": "./fesm2022/angular-three-soba-abstractions.mjs"
-    },
-    "./controls": {
-      "types": "./controls/index.d.ts",
-      "esm2022": "./esm2022/controls/angular-three-soba-controls.mjs",
-      "esm": "./esm2022/controls/angular-three-soba-controls.mjs",
-      "default": "./fesm2022/angular-three-soba-controls.mjs"
-    },
     "./cameras": {
       "types": "./cameras/index.d.ts",
       "esm2022": "./esm2022/cameras/angular-three-soba-cameras.mjs",
       "esm": "./esm2022/cameras/angular-three-soba-cameras.mjs",
       "default": "./fesm2022/angular-three-soba-cameras.mjs"
     },
+    "./abstractions": {
+      "types": "./abstractions/index.d.ts",
+      "esm2022": "./esm2022/abstractions/angular-three-soba-abstractions.mjs",
+      "esm": "./esm2022/abstractions/angular-three-soba-abstractions.mjs",
+      "default": "./fesm2022/angular-three-soba-abstractions.mjs"
+    },
     "./loaders": {
       "types": "./loaders/index.d.ts",
       "esm2022": "./esm2022/loaders/angular-three-soba-loaders.mjs",
@@ -67,6 +63,12 @@
       "esm": "./esm2022/misc/angular-three-soba-misc.mjs",
       "default": "./fesm2022/angular-three-soba-misc.mjs"
     },
+    "./controls": {
+      "types": "./controls/index.d.ts",
+      "esm2022": "./esm2022/controls/angular-three-soba-controls.mjs",
+      "esm": "./esm2022/controls/angular-three-soba-controls.mjs",
+      "default": "./fesm2022/angular-three-soba-controls.mjs"
+    },
     "./performance": {
       "types": "./performance/index.d.ts",
       "esm2022": "./esm2022/performance/angular-three-soba-performance.mjs",
@@ -87,21 +89,21 @@
     }
   },
   "peerDependencies": {
-    "@angular/common": "^15.1.0 || ^16.0.0",
-    "@angular/core": "^15.1.0 || ^16.0.0",
-    "angular-three": "^1.0.0",
-    "stats.js": "^0.17.0",
+    "@angular/common": "^16.0.0",
+    "@angular/core": "^16.0.0",
+    "angular-three": "^2.0.0",
     "three": "^0.148.0 || ^0.149.0 || ^0.150.0 || ^0.151.0 || ^0.152.0",
+    "stats.js": "^0.17.0",
     "three-mesh-bvh": "^0.5.0",
     "three-stdlib": "^2.0.0",
     "troika-three-text": "^0.47.0",
-    "rxjs": "7.8.1",
-    "@rx-angular/state": "15.0.0"
+    "@storybook/addons": "7.0.8",
+    "@storybook/theming": "7.0.8"
   },
   "dependencies": {
     "tslib": "^2.3.0",
-    "@nx/devkit": "^15.0.0 || ^16.0.0",
-    "nx": "^15.0.0 || ^16.0.0"
+    "@nx/devkit": "^16.0.0",
+    "nx": "^16.0.0"
   },
   "sideEffects": false,
   "generators": "./plugin/generators.json",

package/performance/{lib/adaptive → adaptive}/adaptive-dpr.d.ts

@@ -1,11 +1,8 @@
-import { OnInit } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
 import * as i0 from "@angular/core";
-export declare class NgtsAdaptiveDpr extends NgtRxStore implements OnInit {
-    private readonly store;
-    private readonly actions;
-    pixelated: boolean;
-    ngOnInit(): void;
+export declare class NgtsAdaptiveDpr {
+    #private;
+    set pixelated(pixelated: boolean);
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsAdaptiveDpr, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsAdaptiveDpr, "ngts-adaptive-dpr", never, { "pixelated": { "alias": "pixelated"; "required": false; }; }, {}, never, never, true, never>;
 }

package/performance/{lib/adaptive → adaptive}/adaptive-events.d.ts

@@ -1,10 +1,6 @@
-import { OnInit } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
 import * as i0 from "@angular/core";
-export declare class NgtsAdaptiveEvents extends NgtRxStore implements OnInit {
-    private readonly store;
-    private readonly actions;
-    ngOnInit(): void;
+export declare class NgtsAdaptiveEvents {
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsAdaptiveEvents, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsAdaptiveEvents, "ngts-adaptive-events", never, {}, {}, never, never, true, never>;
 }

package/performance/detailed/detailed.d.ts

@@ -0,0 +1,20 @@
+import { NgtSignalStore, type NgtBeforeRenderEvent, type NgtLOD } from 'angular-three';
+import { LOD } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsDetailedState {
+    distances: number[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-detailed': NgtsDetailedState & NgtLOD;
+    }
+}
+export declare class NgtsDetailed extends NgtSignalStore<NgtsDetailedState> {
+    #private;
+    lodRef: import("angular-three").NgtInjectedRef<LOD>;
+    set distances(distances: number[]);
+    constructor();
+    onLODBeforeRender({ object, state }: NgtBeforeRenderEvent<THREE.LOD>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsDetailed, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsDetailed, "ngts-detailed", never, { "lodRef": { "alias": "lodRef"; "required": false; }; "distances": { "alias": "distances"; "required": true; }; }, {}, never, ["*"], true, never>;
+}

package/performance/index.d.ts

@@ -1,4 +1,6 @@
-export * from './lib/adaptive/adaptive-dpr';
-export * from './lib/adaptive/adaptive-events';
-export * from './lib/detailed/detailed';
-export * from './lib/stats/stats';
+export * from './adaptive/adaptive-dpr';
+export * from './adaptive/adaptive-events';
+export * from './detailed/detailed';
+export * from './instances/instance';
+export * from './instances/instances';
+export * from './stats/stats';

package/performance/instances/instance.d.ts

@@ -0,0 +1,9 @@
+import { PositionMesh } from './position-mesh';
+import * as i0 from "@angular/core";
+export declare class NgtsInstance {
+    protected readonly positionMeshRef: import("angular-three").NgtInjectedRef<PositionMesh>;
+    protected readonly instancesApi: import("@angular/core").Signal<import("./instances").NgtsInstancesApi>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsInstance, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsInstance, "ngts-instance", never, {}, {}, never, ["*"], true, never>;
+}