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

package/shaders/mesh-distort-material/mesh-distort-material.d.ts

@@ -7,7 +7,14 @@ interface Uniform<T> {
  * 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)
+ * using provider:
+ * - provideNgtsMeshDistortMaterialShader(distort)
+ * - readonly MeshDistortMaterial = injectNgtsMeshDistortMaterial()
+ * - material = new this.MeshDistortMaterial(); // then use this with primitive
+ *
+ * using createMeshDistortMaterial: createMeshDistortMaterial(distort);
+ * - const MeshDistortMaterial = createMeshDistortMaterial(distort);
+ * - extend({ MeshDistortMaterial }); // then use as ngt-mesh-distort-material
  */
 export type MeshDistortMaterial = Type<{
     time: number;
@@ -15,6 +22,151 @@ export type MeshDistortMaterial = Type<{
     radius: number;
 } & THREE.MeshPhysicalMaterial>;
 export declare const NGTS_DISTORT_MATERIAL_SHADER: InjectionToken<MeshDistortMaterial>;
+export declare function injectNgtsMeshDistortMaterial(): MeshDistortMaterial;
+export declare function createMeshDistortMaterial(distortShader: string): {
+    new (parameters?: THREE.MeshPhysicalMaterialParameters): {
+        _time: Uniform<number>;
+        _distort: Uniform<number>;
+        _radius: Uniform<number>;
+        onBeforeCompile(shader: THREE.Shader): void;
+        time: number;
+        distort: number;
+        radius: number;
+        type: string;
+        defines: {
+            [key: string]: any;
+        };
+        clearcoat: number;
+        clearcoatMap: THREE.Texture | null;
+        clearcoatRoughness: number;
+        clearcoatRoughnessMap: THREE.Texture | null;
+        clearcoatNormalScale: THREE.Vector2;
+        clearcoatNormalMap: THREE.Texture | null;
+        reflectivity: number;
+        ior: number;
+        sheen: number;
+        sheenColor: THREE.Color;
+        sheenColorMap: THREE.Texture | null;
+        sheenRoughness: number;
+        sheenRoughnessMap: THREE.Texture | null;
+        transmission: number;
+        transmissionMap: THREE.Texture | null;
+        thickness: number;
+        thicknessMap: THREE.Texture | null;
+        attenuationDistance: number;
+        attenuationColor: THREE.Color;
+        specularIntensity: number;
+        specularColor: THREE.Color;
+        specularIntensityMap: THREE.Texture | null;
+        specularColorMap: THREE.Texture | null;
+        iridescenceMap: THREE.Texture | null;
+        iridescenceIOR: number;
+        iridescence: number;
+        iridescenceThicknessRange: [number, number];
+        iridescenceThicknessMap: THREE.Texture | null;
+        anisotropy?: number | undefined;
+        anisotropyRotation?: number | undefined;
+        anisotropyMap?: THREE.Texture | null | undefined;
+        color: THREE.Color;
+        roughness: number;
+        metalness: number;
+        map: THREE.Texture | null;
+        lightMap: THREE.Texture | null;
+        lightMapIntensity: number;
+        aoMap: THREE.Texture | null;
+        aoMapIntensity: number;
+        emissive: THREE.Color;
+        emissiveIntensity: number;
+        emissiveMap: THREE.Texture | null;
+        bumpMap: THREE.Texture | null;
+        bumpScale: number;
+        normalMap: THREE.Texture | null;
+        normalMapType: THREE.NormalMapTypes;
+        normalScale: THREE.Vector2;
+        displacementMap: THREE.Texture | null;
+        displacementScale: number;
+        displacementBias: number;
+        roughnessMap: THREE.Texture | null;
+        metalnessMap: THREE.Texture | null;
+        alphaMap: THREE.Texture | null;
+        envMap: THREE.Texture | null;
+        envMapIntensity: number;
+        wireframe: boolean;
+        wireframeLinewidth: number;
+        wireframeLinecap: string;
+        wireframeLinejoin: string;
+        flatShading: boolean;
+        fog: boolean;
+        isMeshStandardMaterial: boolean;
+        setValues(parameters: THREE.MeshStandardMaterialParameters): void;
+        alphaHash: boolean;
+        alphaTest: number;
+        alphaToCoverage: boolean;
+        blendDst: THREE.BlendingDstFactor;
+        blendDstAlpha: number | null;
+        blendEquation: THREE.BlendingEquation;
+        blendEquationAlpha: number | null;
+        blending: THREE.Blending;
+        blendSrc: 210 | THREE.BlendingDstFactor;
+        blendSrcAlpha: number | null;
+        clipIntersection: boolean;
+        clippingPlanes: THREE.Plane[];
+        clipShadows: boolean;
+        colorWrite: boolean;
+        depthFunc: THREE.DepthModes;
+        depthTest: boolean;
+        depthWrite: boolean;
+        id: number;
+        stencilWrite: boolean;
+        stencilFunc: THREE.StencilFunc;
+        stencilRef: number;
+        stencilWriteMask: number;
+        stencilFuncMask: number;
+        stencilFail: THREE.StencilOp;
+        stencilZFail: THREE.StencilOp;
+        stencilZPass: THREE.StencilOp;
+        readonly isMaterial: true;
+        name: string;
+        needsUpdate: boolean;
+        opacity: number;
+        polygonOffset: boolean;
+        polygonOffsetFactor: number;
+        polygonOffsetUnits: number;
+        precision: "highp" | "mediump" | "lowp" | null;
+        premultipliedAlpha: boolean;
+        forceSinglePass: boolean;
+        dithering: boolean;
+        side: THREE.Side;
+        shadowSide: THREE.Side | null;
+        toneMapped: boolean;
+        transparent: boolean;
+        uuid: string;
+        vertexColors: boolean;
+        visible: boolean;
+        userData: any;
+        version: number;
+        clone(): any;
+        copy(material: THREE.Material): any;
+        dispose(): void;
+        customProgramCacheKey(): string;
+        toJSON(meta?: any): any;
+        addEventListener<T extends "dispose">(type: T, listener: THREE.EventListener<{
+            dispose: {};
+        }[T], T, any>): void;
+        addEventListener<T_1 extends string>(type: T_1, listener: THREE.EventListener<{}, T_1, any>): void;
+        hasEventListener<T_2 extends "dispose">(type: T_2, listener: THREE.EventListener<{
+            dispose: {};
+        }[T_2], T_2, any>): boolean;
+        hasEventListener<T_3 extends string>(type: T_3, listener: THREE.EventListener<{}, T_3, any>): boolean;
+        removeEventListener<T_4 extends "dispose">(type: T_4, listener: THREE.EventListener<{
+            dispose: {};
+        }[T_4], T_4, any>): void;
+        removeEventListener<T_5 extends string>(type: T_5, listener: THREE.EventListener<{}, T_5, any>): void;
+        dispatchEvent<T_6 extends "dispose">(event: THREE.BaseEvent<T_6> & {
+            dispose: {};
+        }[T_6]): void;
+    };
+};
 export declare function provideNgtsMeshDistortMaterialShader(distortShader: string): {
     provide: InjectionToken<MeshDistortMaterial>;
     useFactory: () => {
@@ -58,6 +210,9 @@ export declare function provideNgtsMeshDistortMaterialShader(distortShader: stri
             iridescence: number;
             iridescenceThicknessRange: [number, number];
             iridescenceThicknessMap: THREE.Texture | null;
+            anisotropy?: number | undefined;
+            anisotropyRotation?: number | undefined;
+            anisotropyMap?: THREE.Texture | null | undefined;
             color: THREE.Color;
             roughness: number;
             metalness: number;
@@ -90,6 +245,7 @@ export declare function provideNgtsMeshDistortMaterialShader(distortShader: stri
             fog: boolean;
             isMeshStandardMaterial: boolean;
             setValues(parameters: THREE.MeshStandardMaterialParameters): void;
+            alphaHash: boolean;
             alphaTest: number;
             alphaToCoverage: boolean;
             blendDst: THREE.BlendingDstFactor;
@@ -100,7 +256,7 @@ export declare function provideNgtsMeshDistortMaterialShader(distortShader: stri
             blendSrc: 210 | THREE.BlendingDstFactor;
             blendSrcAlpha: number | null;
             clipIntersection: boolean;
-            clippingPlanes: any;
+            clippingPlanes: THREE.Plane[];
             clipShadows: boolean;
             colorWrite: boolean;
             depthFunc: THREE.DepthModes;
@@ -140,10 +296,21 @@ export declare function provideNgtsMeshDistortMaterialShader(distortShader: stri
             dispose(): void;
             customProgramCacheKey(): string;
             toJSON(meta?: any): any;
-            addEventListener<T extends string>(type: T, listener: THREE.EventListener<THREE.Event, T, any>): void;
-            hasEventListener<T_1 extends string>(type: T_1, listener: THREE.EventListener<THREE.Event, T_1, any>): boolean;
-            removeEventListener<T_2 extends string>(type: T_2, listener: THREE.EventListener<THREE.Event, T_2, any>): void;
-            dispatchEvent(event: THREE.Event): void;
+            addEventListener<T extends "dispose">(type: T, listener: THREE.EventListener<{
+                dispose: {};
+            }[T], T, any>): void;
+            addEventListener<T_1 extends string>(type: T_1, listener: THREE.EventListener<{}, T_1, any>): void;
+            hasEventListener<T_2 extends "dispose">(type: T_2, listener: THREE.EventListener<{
+                dispose: {};
+            }[T_2], T_2, any>): boolean;
+            hasEventListener<T_3 extends string>(type: T_3, listener: THREE.EventListener<{}, T_3, any>): boolean;
+            removeEventListener<T_4 extends "dispose">(type: T_4, listener: THREE.EventListener<{
+                dispose: {};
+            }[T_4], T_4, any>): void;
+            removeEventListener<T_5 extends string>(type: T_5, listener: THREE.EventListener<{}, T_5, any>): void;
+            dispatchEvent<T_6 extends "dispose">(event: THREE.BaseEvent<T_6> & {
+                dispose: {};
+            }[T_6]): void;
         };
     };
 };

package/shaders/mesh-transmission-material/mesh-transmission-material.d.ts

@@ -13,7 +13,7 @@ export declare class MeshTransmissionMaterial extends THREE.MeshPhysicalMaterial
         thicknessMap: Uniform<THREE.Texture | null>;
         attenuationDistance: Uniform<number>;
         attenuationColor: Uniform<THREE.Color>;
-        anisotropy: Uniform<number>;
+        anisotropicBlur: Uniform<number>;
         time: Uniform<number>;
         distortion: Uniform<number>;
         distortionScale: Uniform<number>;

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

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
-export declare function shaderMaterial(uniforms: {
+export declare function shaderMaterial<Uniforms extends {
     [name: string]: THREE.CubeTexture | THREE.Texture | Int32Array | Float32Array | THREE.Matrix4 | THREE.Matrix3 | THREE.Quaternion | THREE.Vector4 | THREE.Vector3 | THREE.Vector2 | THREE.Color | number | boolean | Array<any> | null;
-}, vertexShader: string, fragmentShader: string, onInit?: (material?: THREE.ShaderMaterial) => void): typeof THREE.ShaderMaterial & {
+}>(uniforms: Uniforms, vertexShader: string, fragmentShader: string, onInit?: (material?: THREE.ShaderMaterial) => void): typeof THREE.ShaderMaterial & {
     key: string;
 };

package/shaders/soft-shadow-material/soft-shadow-material.d.ts

@@ -1,10 +1,19 @@
+import type { NgtShaderMaterial } from 'angular-three';
 import * as THREE from 'three';
 export declare const SoftShadowMaterial: typeof THREE.ShaderMaterial & {
     key: string;
 };
-export interface SoftShadowMaterialInputs {
+export type NgtSoftShadowMaterialState = {
     map: THREE.Texture;
     color?: THREE.ColorRepresentation;
     alphaTest?: number;
     blend?: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         *  @extends ngt-shader-material
+         */
+        'ngt-soft-shadow-material': NgtSoftShadowMaterialState & NgtShaderMaterial;
+    }
 }

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

@@ -1,3 +1,16 @@
+import type { NgtShaderMaterial } from 'angular-three';
 export declare const SparklesMaterial: typeof import("three").ShaderMaterial & {
     key: string;
 };
+export type NgtSparklesMaterialState = {
+    time?: number;
+    pixelRatio?: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-shader-material
+         */
+        'ngt-sparkles-material': NgtSparklesMaterialState & NgtShaderMaterial;
+    }
+}

package/shaders/spot-light-material/spot-light-material.d.ts

@@ -1,4 +1,13 @@
-import { ShaderMaterial } from 'three';
-export declare class SpotLightMaterial extends ShaderMaterial {
+import type { NgtShaderMaterial } from 'angular-three';
+import * as THREE from 'three';
+export declare class SpotLightMaterial extends THREE.ShaderMaterial {
     constructor();
 }
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-shader-material
+         */
+        'ngt-spot-light-material': NgtShaderMaterial;
+    }
+}

package/shaders/star-field-material/star-field-material.d.ts

@@ -1,3 +1,12 @@
+import type { NgtShaderMaterial } from 'angular-three';
 export declare const StarFieldMaterial: typeof import("three").ShaderMaterial & {
     key: string;
 };
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-shader-material
+         */
+        'ngt-star-field-material': NgtShaderMaterial;
+    }
+}

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

@@ -0,0 +1,58 @@
+import { type Injector } from '@angular/core';
+import type { NgtShaderMaterial } from 'angular-three';
+import * as THREE from 'three';
+export type WireframeMaterialState = {
+    fillOpacity?: number;
+    fillMix?: number;
+    strokeOpacity?: number;
+    thickness?: number;
+    colorBackfaces?: boolean;
+    dashInvert?: boolean;
+    dash?: boolean;
+    dashRepeats?: number;
+    dashLength?: number;
+    squeeze?: boolean;
+    squeezeMin?: number;
+    squeezeMax?: number;
+    stroke?: THREE.ColorRepresentation;
+    backfaceStroke?: THREE.ColorRepresentation;
+    fill?: THREE.ColorRepresentation;
+};
+export declare const WireframeMaterialShaders: {
+    uniforms: {
+        strokeOpacity: number;
+        fillOpacity: number;
+        fillMix: number;
+        thickness: number;
+        colorBackfaces: boolean;
+        dashInvert: boolean;
+        dash: boolean;
+        dashRepeats: number;
+        dashLength: number;
+        squeeze: boolean;
+        squeezeMin: number;
+        squeezeMax: number;
+        stroke: THREE.Color;
+        backfaceStroke: THREE.Color;
+        fill: THREE.Color;
+    };
+    vertex: string;
+    fragment: string;
+};
+export declare const WireframeMaterial: typeof THREE.ShaderMaterial & {
+    key: string;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-shader-material
+         */
+        'ngt-wireframe-material': WireframeMaterialState & NgtShaderMaterial;
+    }
+}
+export declare function setWireframeOverride(material: THREE.Material, uniforms: {
+    [key: string]: THREE.IUniform<any>;
+}): void;
+export declare function injectNgtsWireframeUniforms(uniformsFactory: () => Record<string, THREE.IUniform<any>>, stateFactory: () => Partial<WireframeMaterialState>, { injector }?: {
+    injector?: Injector;
+}): void;

package/staging/accumulative-shadows/accumulative-shadows.d.ts

@@ -1,10 +1,10 @@
-import { InjectionToken, Signal } from '@angular/core';
-import { NgtSignalStore, type NgtGroup } from 'angular-three';
-import { SoftShadowMaterialInputs } from 'angular-three-soba/shaders';
+import { type Signal } from '@angular/core';
+import { type NgtGroup } from 'angular-three';
+import { type NgtSoftShadowMaterialState } from 'angular-three-soba/shaders';
 import { Group, Mesh, PlaneGeometry } from 'three';
 import { ProgressiveLightMap } from './progressive-light-map';
 import * as i0 from "@angular/core";
-export interface NgtsAccumulativeShadowsState {
+export type 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 */
@@ -27,70 +27,124 @@ export interface NgtsAccumulativeShadowsState {
     resolution: number;
     /** Texture tonemapping */
     toneMapped: boolean;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-group
+         */
+        'ngts-accumulative-shadows': NgtsAccumulativeShadowsState & NgtGroup;
+    }
 }
 export type NgtsAccumulativeShadowsLightApi = {
     update: () => void;
 };
-export interface NgtsAccumulativeShadowsApi {
+export declare const injectNgtsAccumulativeShadowsApi: {
+    (): Signal<{
+        lights: Map<string, Signal<NgtsAccumulativeShadowsLightApi>>;
+        temporal: boolean;
+        frames: number;
+        blend: number;
+        count: number;
+        getMesh: () => Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial, import("three").Object3DEventMap>;
+        reset: () => void;
+        update: (frames?: number) => void;
+    }>;
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false | undefined;
+    } & {
+        injector?: import("@angular/core").Injector | undefined;
+    }): Signal<{
+        lights: Map<string, Signal<NgtsAccumulativeShadowsLightApi>>;
+        temporal: boolean;
+        frames: number;
+        blend: number;
+        count: number;
+        getMesh: () => Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial, import("three").Object3DEventMap>;
+        reset: () => void;
+        update: (frames?: number) => void;
+    }>;
+    (injectOptions: import("@angular/core").InjectOptions & {
+        injector?: import("@angular/core").Injector | undefined;
+    }): Signal<{
+        lights: Map<string, Signal<NgtsAccumulativeShadowsLightApi>>;
+        temporal: boolean;
+        frames: number;
+        blend: number;
+        count: number;
+        getMesh: () => Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial, import("three").Object3DEventMap>;
+        reset: () => void;
+        update: (frames?: number) => void;
+    }> | null;
+}, provideNgtsAccumulativeShadowsApi: (value?: Signal<{
     lights: Map<string, Signal<NgtsAccumulativeShadowsLightApi>>;
     temporal: boolean;
     frames: number;
     blend: number;
     count: number;
-    getMesh: () => THREE.Mesh<THREE.PlaneGeometry, SoftShadowMaterialInputs & THREE.ShaderMaterial>;
+    getMesh: () => Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial, import("three").Object3DEventMap>;
     reset: () => void;
     update: (frames?: number) => void;
-}
-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;
+}> | undefined) => import("@angular/core").Provider;
+export declare class NgtsAccumulativeShadows {
+    private inputs;
+    nullTraverse: () => null;
+    Math: Math;
+    accumulativeShadowsRef: import("angular-three").NgtInjectedRef<Group<import("three").Object3DEventMap>>;
     /** How many frames it can render, more yields cleaner results but takes more time, 40 */
-    set frames(frames: number);
+    set _frames(frames: number);
     /** If frames === Infinity blend controls the refresh ratio, 100 */
-    set blend(blend: number);
+    set _blend(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 */
-    set limit(limit: number);
+    set _limit(limit: number);
     /** Scale of the plane,  */
-    set scale(scale: number);
+    set _scale(scale: number);
     /** Temporal accumulates shadows over time which is more performant but has a visual regression over instant results, false  */
-    set temporal(temporal: boolean);
+    set _temporal(temporal: boolean);
     /** Opacity of the plane, 1 */
-    set opacity(opacity: number);
+    set _opacity(opacity: number);
     /** Discards alpha pixels, 0.65 */
-    set alphaTest(alphaTest: number);
+    set _alphaTest(alphaTest: number);
     /** Shadow color, black */
-    set color(color: string);
+    set _color(color: string);
     /** Colorblend, how much colors turn to black, 0 is black, 2 */
-    set colorBlend(colorBlend: number);
+    set _colorBlend(colorBlend: number);
     /** Buffer resolution, 1024 */
-    set resolution(resolution: number);
+    set _resolution(resolution: number);
     /** Texture tonemapping */
-    set toneMapped(toneMapped: boolean);
-    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>;
+    set _toneMapped(toneMapped: boolean);
+    meshRef: import("angular-three").NgtInjectedRef<Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial, import("three").Object3DEventMap>>;
+    private store;
+    private gl;
+    private scene;
+    private camera;
+    private invalidate;
+    private resolution;
+    private alphaTest;
+    private opacity;
+    private temporal;
+    private blend;
+    private frames;
+    pLM: Signal<ProgressiveLightMap>;
+    scale: Signal<number>;
+    toneMapped: Signal<boolean>;
+    color: Signal<string>;
+    colorBlend: Signal<number>;
+    map: Signal<import("three").Texture>;
+    api: Signal<{
+        lights: Map<string, Signal<NgtsAccumulativeShadowsLightApi>>;
         temporal: boolean;
         frames: number;
         blend: number;
         count: number;
-        getMesh: () => Mesh<PlaneGeometry, SoftShadowMaterialInputs & import("three").ShaderMaterial>;
+        getMesh: () => Mesh<PlaneGeometry, NgtSoftShadowMaterialState & import("three").ShaderMaterial, import("three").Object3DEventMap>;
         reset: () => void;
         update: (frames?: number) => void;
     }>;
     constructor();
+    private configure;
+    private resetAndUpdate;
+    private beforeRender;
     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>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsAccumulativeShadows, "ngts-accumulative-shadows", never, { "accumulativeShadowsRef": { "alias": "accumulativeShadowsRef"; "required": false; }; "_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/accumulative-shadows/randomized-lights.d.ts

@@ -1,7 +1,7 @@
-import { NgtSignalStore, type NgtGroup } from 'angular-three';
+import { type NgtGroup } from 'angular-three';
 import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export interface NgtsRandomizedLightsState {
+export type 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;
@@ -27,51 +27,64 @@ export interface NgtsRandomizedLightsState {
     near: number;
     /** Default shadow camera far, 500 */
     far: number;
-}
+};
 declare global {
     interface HTMLElementTagNameMap {
-        'ngts-randomized-lights': NgtGroup & NgtsRandomizedLightsState;
+        /**
+         * @extends ngt-group
+         */
+        'ngts-randomized-lights': NgtsRandomizedLightsState & NgtGroup;
     }
 }
-export declare class NgtsRandomizedLights extends NgtSignalStore<NgtsRandomizedLightsState> {
-    #private;
-    lightsRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+export declare class NgtsRandomizedLights {
+    private inputs;
+    Math: Math;
+    lightsRef: import("angular-three").NgtInjectedRef<THREE.Group<THREE.Object3DEventMap>>;
     /** 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!  */
-    set frames(frames: number);
+    set _frames(frames: number);
     /** Light position, [0, 0, 0] */
-    set position(position: [x: number, y: number, z: number]);
+    set _position(position: [x: number, y: number, z: number]);
     /** Radius of the jiggle, higher values make softer light, 5 */
-    set radius(radius: number);
+    set _radius(radius: number);
     /** Amount of lights, 8 */
-    set amount(amount: number);
+    set _amount(amount: number);
     /** Light intensity, 1 */
-    set intensity(intensity: number);
+    set _intensity(intensity: number);
     /** Ambient occlusion, lower values mean less AO, hight more, you can mix AO and directional light, 0.5 */
-    set ambient(ambient: number);
+    set _ambient(ambient: number);
     /** If the lights cast shadows, this is true by default */
-    set castShadow(castShadow: boolean);
+    set _castShadow(castShadow: boolean);
     /** Default shadow bias, 0 */
-    set bias(bias: number);
+    set _bias(bias: number);
     /** Default map size, 512 */
-    set mapSize(mapSize: number);
+    set _mapSize(mapSize: number);
     /** Default size of the shadow camera, 10 */
-    set size(size: number);
+    set _size(size: number);
     /** Default shadow camera near, 0.5 */
-    set near(near: number);
+    set _near(near: number);
     /** Default shadow camera far, 500 */
-    set far(far: number);
-    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<{
+    set _far(far: number);
+    private position;
+    private ambient;
+    private radius;
+    private mapSize;
+    private size;
+    private near;
+    private far;
+    private length;
+    private shadowsApi;
+    amount: import("@angular/core").Signal<number>;
+    castShadow: import("@angular/core").Signal<boolean>;
+    intensity: import("@angular/core").Signal<number>;
+    bias: import("@angular/core").Signal<number>;
+    shadowsMapSize: import("@angular/core").Signal<number[]>;
+    cameraArgs: import("@angular/core").Signal<number[]>;
+    api: import("@angular/core").Signal<{
         update: () => void;
     }>;
     constructor();
+    private updateLightMap;
     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>;
+    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, ["*"], true, never>;
 }