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

package/staging/camera-shake/camera-shake.d.ts

@@ -1,9 +1,7 @@
-import { OnInit } from '@angular/core';
-import { NgtSignalStore } from 'angular-three';
 import * as i0 from "@angular/core";
-export interface NgtsCameraShakeState {
+export type NgtsCameraShakeState = {
+    decay?: boolean;
     intensity: number;
-    decay: boolean;
     decayRate: number;
     maxYaw: number;
     maxPitch: number;
@@ -11,22 +9,35 @@ export interface NgtsCameraShakeState {
     yawFrequency: number;
     pitchFrequency: number;
     rollFrequency: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-camera-shake': NgtsCameraShakeState;
+    }
 }
-export declare class NgtsCameraShake extends NgtSignalStore<NgtsCameraShakeState> implements OnInit {
-    #private;
-    set intensity(intensity: number);
-    set decay(decay: boolean);
-    set decayRate(decayRate: number);
-    set maxYaw(maxYaw: number);
-    set maxPitch(maxPitch: number);
-    set maxRoll(maxRoll: number);
-    set yawFrequency(yawFrequency: number);
-    set pitchFrequency(pitchFrequency: number);
-    set rollFrequency(rollFrequency: number);
+export declare class NgtsCameraShake {
+    private inputs;
+    set _intensity(intensity: number);
+    set _decay(decay: boolean);
+    set _decayRate(decayRate: number);
+    set _maxYaw(maxYaw: number);
+    set _maxPitch(maxPitch: number);
+    set _maxRoll(maxRoll: number);
+    set _yawFrequency(yawFrequency: number);
+    set _pitchFrequency(pitchFrequency: number);
+    set _rollFrequency(rollFrequency: number);
+    private store;
+    private camera;
+    private controls;
+    private initialRotation;
+    private yawNoise;
+    private rollNoise;
+    private pitchNoise;
+    private intensity;
+    private constrainedIntensity;
     constructor();
-    ngOnInit(): void;
-    getIntensity(): number;
-    setIntensity(intensity: number): void;
+    private beforeRender;
+    private setEvents;
     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>;
+    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/center/center.d.ts

@@ -1,7 +1,22 @@
 import { EventEmitter } from '@angular/core';
-import { NgtSignalStore, type NgtGroup } from 'angular-three';
-import { Box3, Group, Sphere, Vector3 } from 'three';
+import { type NgtGroup } from 'angular-three';
+import * as THREE from 'three';
 import * as i0 from "@angular/core";
+export type NgtsCenteredEvent = {
+    /** The next parent above <Center> */
+    parent: THREE.Object3D;
+    /** The outmost container group of the <Center> component */
+    container: THREE.Object3D;
+    width: number;
+    height: number;
+    depth: number;
+    boundingBox: THREE.Box3;
+    boundingSphere: THREE.Sphere;
+    center: THREE.Vector3;
+    verticalAlignment: number;
+    horizontalAlignment: number;
+    depthAlignment: number;
+};
 export type NgtsCenterState = {
     top?: boolean;
     right?: boolean;
@@ -18,45 +33,38 @@ export type NgtsCenterState = {
     /** Disable z-axis centering */
     disableZ?: boolean;
     /** See https://threejs.org/docs/index.html?q=box3#api/en/math/Box3.setFromObject */
-    precise: boolean;
+    precise?: boolean;
+    /** Optional cacheKey to keep the component from recalculating on every render */
+    cacheKey?: any;
 };
 declare global {
     interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-group
+         */
         '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>;
-    set top(top: boolean);
-    set right(right: boolean);
-    set bottom(bottom: boolean);
-    set left(left: boolean);
-    set front(front: boolean);
-    set back(back: boolean);
-    set disableX(disableX: boolean);
-    set disableY(disableY: boolean);
-    set disableZ(disableZ: boolean);
-    set disable(disable: boolean);
-    set precise(precise: boolean);
-    centered: EventEmitter<{
-        /** The next parent above <Center> */
-        parent: THREE.Object3D;
-        /** The outmost container group of the <Center> component */
-        container: THREE.Object3D;
-        width: number;
-        height: number;
-        depth: number;
-        boundingBox: THREE.Box3;
-        boundingSphere: THREE.Sphere;
-        center: THREE.Vector3;
-        verticalAlignment: number;
-        horizontalAlignment: number;
-        depthAlignment: number;
-    }>;
+export declare class NgtsCenter {
+    private inputs;
+    centerRef: import("angular-three").NgtInjectedRef<THREE.Group<THREE.Object3DEventMap>>;
+    outerRef: import("angular-three").NgtInjectedRef<THREE.Group<THREE.Object3DEventMap>>;
+    innerRef: import("angular-three").NgtInjectedRef<THREE.Group<THREE.Object3DEventMap>>;
+    set _top(top: boolean);
+    set _right(right: boolean);
+    set _bottom(bottom: boolean);
+    set _left(left: boolean);
+    set _front(front: boolean);
+    set _back(back: boolean);
+    set _disableX(disableX: boolean);
+    set _disableY(disableY: boolean);
+    set _disableZ(disableZ: boolean);
+    set _disable(disable: boolean);
+    set _precise(precise: boolean);
+    set _cacheKey(cacheKey: any);
+    centered: EventEmitter<NgtsCenteredEvent>;
     constructor();
+    private setPosition;
     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; }; "disable": { "alias": "disable"; "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; }; "_cacheKey": { "alias": "cacheKey"; "required": false; }; }, { "centered": "centered"; }, never, ["*"], true, never>;
 }

package/staging/cloud/cloud.d.ts

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

package/staging/contact-shadows/contact-shadows.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 NgtsContactShadowsState {
+export type NgtsContactShadowsState = {
     opacity: number;
     width: number;
     height: number;
@@ -14,44 +14,57 @@ export interface NgtsContactShadowsState {
     color: THREE.ColorRepresentation;
     depthWrite: boolean;
     renderOrder: number;
-}
+};
 declare global {
     interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-group
+         */
         'ngts-contact-shadows': NgtsContactShadowsState & NgtGroup;
     }
 }
-export declare class NgtsContactShadows extends NgtSignalStore<NgtsContactShadowsState> {
-    #private;
-    contactShadowsRef: import("angular-three").NgtInjectedRef<THREE.Group>;
-    set opacity(opacity: number);
-    set width(width: number);
-    set height(height: number);
-    set blur(blur: number);
-    set far(far: number);
-    set smooth(smooth: boolean);
-    set resolution(resolution: number);
-    set frames(frames: number);
-    set scale(scale: number | [x: number, y: number]);
-    set color(color: THREE.ColorRepresentation);
-    set depthWrite(depthWrite: boolean);
-    set renderOrder(renderOrder: number);
-    readonly Math: Math;
-    readonly shadowCameraRef: import("angular-three").NgtInjectedRef<THREE.OrthographicCamera>;
-    readonly encoding: import("@angular/core").Signal<THREE.TextureEncoding>;
-    readonly shadowRenderOrder: import("@angular/core").Signal<number>;
-    readonly shadowOpacity: import("@angular/core").Signal<number>;
-    readonly shadowDepthWrite: import("@angular/core").Signal<boolean>;
-    readonly cameraArgs: import("@angular/core").Signal<number[]>;
-    readonly contactShadows: import("@angular/core").Signal<{
-        renderTarget: THREE.WebGLRenderTarget;
+export declare class NgtsContactShadows {
+    private inputs;
+    contactShadowsRef: import("angular-three").NgtInjectedRef<THREE.Group<THREE.Object3DEventMap>>;
+    set _opacity(opacity: number);
+    set _width(width: number);
+    set _height(height: number);
+    set _blur(blur: number);
+    set _far(far: number);
+    set _smooth(smooth: boolean);
+    set _resolution(resolution: number);
+    set _frames(frames: number);
+    set _scale(scale: number | [x: number, y: number]);
+    set _color(color: THREE.ColorRepresentation);
+    set _depthWrite(depthWrite: boolean);
+    set _renderOrder(renderOrder: number);
+    Math: Math;
+    private store;
+    shadowCameraRef: import("angular-three").NgtInjectedRef<THREE.OrthographicCamera>;
+    private scale;
+    private width;
+    private height;
+    private far;
+    private resolution;
+    private color;
+    private scaledWidth;
+    private scaledHeight;
+    renderOrder: import("@angular/core").Signal<number>;
+    opacity: import("@angular/core").Signal<number>;
+    depthWrite: import("@angular/core").Signal<boolean>;
+    cameraArgs: import("@angular/core").Signal<number[]>;
+    contactShadows: import("@angular/core").Signal<{
+        renderTarget: THREE.WebGLRenderTarget<THREE.Texture>;
         planeGeometry: THREE.PlaneGeometry;
         depthMaterial: THREE.MeshDepthMaterial;
-        blurPlane: THREE.Mesh<THREE.PlaneGeometry, THREE.Material | THREE.Material[]>;
+        blurPlane: THREE.Mesh<THREE.PlaneGeometry, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
         horizontalBlurMaterial: THREE.ShaderMaterial;
         verticalBlurMaterial: THREE.ShaderMaterial;
-        renderTargetBlur: THREE.WebGLRenderTarget;
+        renderTargetBlur: THREE.WebGLRenderTarget<THREE.Texture>;
     }>;
     constructor();
+    private beforeRender;
+    private blurShadows;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsContactShadows, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsContactShadows, "ngts-contact-shadows", never, { "contactShadowsRef": { "alias": "contactShadowsRef"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "blur": { "alias": "blur"; "required": false; }; "far": { "alias": "far"; "required": false; }; "smooth": { "alias": "smooth"; "required": false; }; "resolution": { "alias": "resolution"; "required": false; }; "frames": { "alias": "frames"; "required": false; }; "scale": { "alias": "scale"; "required": false; }; "color": { "alias": "color"; "required": false; }; "depthWrite": { "alias": "depthWrite"; "required": false; }; "renderOrder": { "alias": "renderOrder"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsContactShadows, "ngts-contact-shadows", never, { "contactShadowsRef": { "alias": "contactShadowsRef"; "required": false; }; "_opacity": { "alias": "opacity"; "required": false; }; "_width": { "alias": "width"; "required": false; }; "_height": { "alias": "height"; "required": false; }; "_blur": { "alias": "blur"; "required": false; }; "_far": { "alias": "far"; "required": false; }; "_smooth": { "alias": "smooth"; "required": false; }; "_resolution": { "alias": "resolution"; "required": false; }; "_frames": { "alias": "frames"; "required": false; }; "_scale": { "alias": "scale"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_depthWrite": { "alias": "depthWrite"; "required": false; }; "_renderOrder": { "alias": "renderOrder"; "required": false; }; }, {}, never, never, true, never>;
 }

package/staging/environment/assets.d.ts

@@ -1,13 +1,13 @@
-export declare const ngtsEnvironmentPresetsObj: {
-    sunset: string;
-    dawn: string;
-    night: string;
-    warehouse: string;
-    forest: string;
+export declare const ENVIRONMENT_PRESETS: {
     apartment: string;
-    studio: string;
     city: string;
-    park: string;
+    dawn: string;
+    forest: string;
     lobby: string;
+    night: string;
+    park: string;
+    studio: string;
+    sunset: string;
+    warehouse: string;
 };
-export type NgtsEnvironmentPresetsType = keyof typeof ngtsEnvironmentPresetsObj;
+export type NgtsEnvironmentPresetsType = keyof typeof ENVIRONMENT_PRESETS;

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

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

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

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

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

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

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

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

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

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

package/staging/environment/environment.d.ts

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

package/staging/environment/utils.d.ts

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