angular-three-soba 2.0.0-beta.2 → 2.0.0-beta.20

package/abstractions/billboard/billboard.d.ts

@@ -1,4 +1,4 @@
-import { NgtSignalStore, type NgtGroup } from 'angular-three';
+import { type NgtGroup } from 'angular-three';
 import { Group } from 'three';
 import * as i0 from "@angular/core";
 export type NgtsBillboardState = {
@@ -9,16 +9,20 @@ export type NgtsBillboardState = {
 };
 declare global {
     interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-group
+         */
         'ngts-billboard': NgtsBillboardState & NgtGroup;
     }
 }
-export declare class NgtsBillboard extends NgtSignalStore<NgtsBillboardState> {
+export declare class NgtsBillboard {
+    private inputs;
     billboardRef: import("angular-three").NgtInjectedRef<Group>;
-    set follow(follow: boolean);
-    set lockX(lockX: boolean);
-    set lockY(lockY: boolean);
-    set lockZ(lockZ: boolean);
+    set _follow(follow: boolean);
+    set _lockX(lockX: boolean);
+    set _lockY(lockY: boolean);
+    set _lockZ(lockZ: boolean);
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsBillboard, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsBillboard, "ngts-billboard", never, { "billboardRef": { "alias": "billboardRef"; "required": false; }; "follow": { "alias": "follow"; "required": false; }; "lockX": { "alias": "lockX"; "required": false; }; "lockY": { "alias": "lockY"; "required": false; }; "lockZ": { "alias": "lockZ"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsBillboard, "ngts-billboard", never, { "billboardRef": { "alias": "billboardRef"; "required": false; }; "_follow": { "alias": "follow"; "required": false; }; "_lockX": { "alias": "lockX"; "required": false; }; "_lockY": { "alias": "lockY"; "required": false; }; "_lockZ": { "alias": "lockZ"; "required": false; }; }, {}, never, ["*"], true, never>;
 }

package/abstractions/detailed/detailed.d.ts

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

package/abstractions/edges/edges.d.ts

@@ -1,22 +1,34 @@
-import { NgtAnyRecord, NgtSignalStore } from 'angular-three';
+import { TemplateRef } from '@angular/core';
+import { type NgtAnyRecord, type NgtLineSegments } from 'angular-three';
 import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export interface NgtsEdgesState {
+export type NgtsEdgesState = {
     threshold: number;
     color: THREE.ColorRepresentation;
     geometry: THREE.BufferGeometry;
     userData: NgtAnyRecord;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-line-segments
+         */
+        'ngts-edges': NgtsEdgesState & NgtLineSegments;
+    }
 }
-export declare class NgtsEdges extends NgtSignalStore<NgtsEdgesState> {
-    #private;
-    edgesRef: import("angular-three").NgtInjectedRef<THREE.LineSegments<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
-    set threshold(threshold: number);
-    set color(color: THREE.ColorRepresentation);
-    set geometry(geometry: THREE.BufferGeometry);
-    set userData(userData: NgtAnyRecord);
-    withChildren: boolean;
-    readonly noop: () => null;
+export declare class NgtsEdges {
+    nullRaycast: () => null;
+    content?: TemplateRef<unknown>;
+    private inputs;
+    edgesRef: import("angular-three").NgtInjectedRef<THREE.LineSegments<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    set _threshold(threshold: number);
+    set _color(color: THREE.ColorRepresentation);
+    set _geometry(geometry: THREE.BufferGeometry);
+    set _userData(userData: NgtAnyRecord);
+    private geometry;
+    private threshold;
+    color: import("@angular/core").Signal<THREE.ColorRepresentation>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEdges, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEdges, "ngts-edges", never, { "edgesRef": { "alias": "edgesRef"; "required": false; }; "threshold": { "alias": "threshold"; "required": false; }; "color": { "alias": "color"; "required": false; }; "geometry": { "alias": "geometry"; "required": false; }; "userData": { "alias": "userData"; "required": false; }; "withChildren": { "alias": "withChildren"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEdges, "ngts-edges", never, { "edgesRef": { "alias": "edgesRef"; "required": false; }; "_threshold": { "alias": "threshold"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_geometry": { "alias": "geometry"; "required": false; }; "_userData": { "alias": "userData"; "required": false; }; }, {}, ["content"], never, true, never>;
 }

package/abstractions/grid/grid.d.ts

@@ -0,0 +1,50 @@
+import { type NgtMesh } from 'angular-three';
+import { type NgtGridMaterialState } from 'angular-three-soba/shaders';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export type NgtsGridState = {
+    /** Default plane-geometry arguments */
+    args: ConstructorParameters<typeof THREE.PlaneGeometry>;
+} & NgtGridMaterialState;
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-mesh
+         */
+        'ngts-grid': NgtsGridState & NgtMesh;
+    }
+}
+export declare class NgtsGrid {
+    private inputs;
+    gridRef: import("angular-three").NgtInjectedRef<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    set _cellSize(cellSize: NgtsGridState['cellSize']);
+    set _cellThickness(cellThickness: NgtsGridState['cellThickness']);
+    set _cellColor(cellColor: NgtsGridState['cellColor']);
+    set _sectionSize(sectionSize: NgtsGridState['sectionSize']);
+    set _sectionThickness(sectionThickness: NgtsGridState['sectionThickness']);
+    set _sectionColor(sectionColor: NgtsGridState['sectionColor']);
+    set _followCamera(followCamera: NgtsGridState['followCamera']);
+    set _infiniteGrid(infiniteGrid: NgtsGridState['infiniteGrid']);
+    set _fadeDistance(fadeDistance: NgtsGridState['fadeDistance']);
+    set _fadeStrength(fadeStrength: NgtsGridState['fadeStrength']);
+    set _side(side: NgtsGridState['side']);
+    set _args(args: NgtsGridState['args']);
+    cellSize: import("@angular/core").Signal<number | undefined>;
+    sectionSize: import("@angular/core").Signal<number | undefined>;
+    fadeDistance: import("@angular/core").Signal<number | undefined>;
+    fadeStrength: import("@angular/core").Signal<number | undefined>;
+    cellThickness: import("@angular/core").Signal<number | undefined>;
+    sectionThickness: import("@angular/core").Signal<number | undefined>;
+    infiniteGrid: import("@angular/core").Signal<boolean | undefined>;
+    followCamera: import("@angular/core").Signal<boolean | undefined>;
+    cellColor: import("@angular/core").Signal<THREE.ColorRepresentation | undefined>;
+    sectionColor: import("@angular/core").Signal<THREE.ColorRepresentation | undefined>;
+    side: import("@angular/core").Signal<THREE.Side | undefined>;
+    args: import("@angular/core").Signal<[width?: number | undefined, height?: number | undefined, widthSegments?: number | undefined, heightSegments?: number | undefined]>;
+    private plane;
+    private upVector;
+    private zeroVector;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGrid, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGrid, "ngts-grid", never, { "gridRef": { "alias": "gridRef"; "required": false; }; "_cellSize": { "alias": "cellSize"; "required": false; }; "_cellThickness": { "alias": "cellThickness"; "required": false; }; "_cellColor": { "alias": "cellColor"; "required": false; }; "_sectionSize": { "alias": "sectionSize"; "required": false; }; "_sectionThickness": { "alias": "sectionThickness"; "required": false; }; "_sectionColor": { "alias": "sectionColor"; "required": false; }; "_followCamera": { "alias": "followCamera"; "required": false; }; "_infiniteGrid": { "alias": "infiniteGrid"; "required": false; }; "_fadeDistance": { "alias": "fadeDistance"; "required": false; }; "_fadeStrength": { "alias": "fadeStrength"; "required": false; }; "_side": { "alias": "side"; "required": false; }; "_args": { "alias": "args"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/abstractions/index.d.ts

@@ -1,11 +1,6 @@
 export * from './billboard/billboard';
-export * from './catmull-rom-line/catmull-rom-line';
-export * from './cubic-bezier-line/cubic-bezier-line';
+export * from './detailed/detailed';
 export * from './edges/edges';
-export * from './gizmo-helper/gizmo-helper';
-export * from './gizmo-helper/gizmo-viewcube/gizmo-viewcube';
-export * from './gizmo-helper/gizmo-viewport/gizmo-viewport';
-export * from './line/line';
-export * from './quadratic-bezier-line/quadratic-bezier-line';
+export * from './grid/grid';
 export * from './text-3d/text-3d';
 export * from './text/text';

package/abstractions/text/text.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from '@angular/core';
-import { NgtSignalStore, type NgtMesh } from 'angular-three';
+import { type NgtMesh } from 'angular-three';
 import * as i0 from "@angular/core";
 export type NgtsTextState = {
     text: string;
@@ -34,11 +34,14 @@ export type NgtsTextState = {
 };
 declare global {
     interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-mesh
+         */
         'ngts-text': NgtsTextState & NgtMesh;
     }
 }
-export declare class NgtsText extends NgtSignalStore<NgtsTextState> {
-    #private;
+export declare class NgtsText {
+    protected inputs: import("angular-three").NgtSignalStore<NgtsTextState>;
     textRef: import("angular-three").NgtInjectedRef<Text>;
     set text(text: string);
     set font(font: string);
@@ -69,9 +72,11 @@ export declare class NgtsText extends NgtSignalStore<NgtsTextState> {
     set fillOpacity(fillOpacity: number);
     set debugSDF(debugSDF: boolean);
     sync: EventEmitter<Text>;
-    readonly troikaText: any;
-    readonly state: import("@angular/core").Signal<NgtsTextState>;
+    troikaText: any;
+    private store;
     constructor();
+    private preloadFont;
+    private syncText;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsText, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtsText, "ngts-text", never, { "textRef": { "alias": "textRef"; "required": false; }; "text": { "alias": "text"; "required": true; }; "font": { "alias": "font"; "required": false; }; "fontSize": { "alias": "fontSize"; "required": false; }; "anchorX": { "alias": "anchorX"; "required": false; }; "anchorY": { "alias": "anchorY"; "required": false; }; "sdfGlyphSize": { "alias": "sdfGlyphSize"; "required": false; }; "characters": { "alias": "characters"; "required": false; }; "color": { "alias": "color"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "lineHeight": { "alias": "lineHeight"; "required": false; }; "letterSpacing": { "alias": "letterSpacing"; "required": false; }; "textAlign": { "alias": "textAlign"; "required": false; }; "clipRect": { "alias": "clipRect"; "required": false; }; "depthOffset": { "alias": "depthOffset"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "overflowWrap": { "alias": "overflowWrap"; "required": false; }; "whiteSpace": { "alias": "whiteSpace"; "required": false; }; "outlineWidth": { "alias": "outlineWidth"; "required": false; }; "outlineOffsetX": { "alias": "outlineOffsetX"; "required": false; }; "outlineOffsetY": { "alias": "outlineOffsetY"; "required": false; }; "outlineBlur": { "alias": "outlineBlur"; "required": false; }; "outlineColor": { "alias": "outlineColor"; "required": false; }; "outlineOpacity": { "alias": "outlineOpacity"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "strokeColor": { "alias": "strokeColor"; "required": false; }; "strokeOpacity": { "alias": "strokeOpacity"; "required": false; }; "fillOpacity": { "alias": "fillOpacity"; "required": false; }; "debugSDF": { "alias": "debugSDF"; "required": false; }; }, { "sync": "sync"; }, never, ["*"], true, never>;
 }

package/abstractions/text-3d/text-3d.d.ts

@@ -1,5 +1,6 @@
-import { NgtSignalStore, type NgtMesh } from 'angular-three';
+import { type NgtMesh } from 'angular-three';
 import { Mesh } from 'three';
+import { Font, type TextGeometryParameters } from 'three-stdlib';
 import * as i0 from "@angular/core";
 declare type Glyph = {
     _cachedOutline: string[];
@@ -21,54 +22,63 @@ declare type FontData = {
 export type NgtsText3DState = {
     font: FontData | string;
     text: string;
-    letterSpacing: number;
-    lineHeight: number;
-    size: number;
-    height: number;
-    bevelThickness: number;
-    bevelSize: number;
-    bevelEnabled: boolean;
-    bevelOffset: number;
-    bevelSegments: number;
-    curveSegments: number;
+    bevelSegments?: number;
     smooth?: number;
-};
+} & Omit<TextGeometryParameters, 'font'>;
 declare global {
     interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-mesh
+         * @extends three-stdlib|TextGeometryParameters
+         */
         'ngts-text-3d': NgtsText3DState & NgtMesh;
     }
 }
-export declare class NgtsText3D extends NgtSignalStore<NgtsText3DState> {
-    #private;
-    textRef: import("angular-three").NgtInjectedRef<Mesh<import("three").BufferGeometry, import("three").Material | import("three").Material[]>>;
-    set font(font: FontData | string);
-    set text(text: string);
-    set bevelEnabled(bevelEnabled: boolean);
-    set bevelOffset(bevelOffset: number);
-    set bevelSize(bevelSize: number);
-    set bevelThickness(bevelThickness: number);
-    set curveSegments(curveSegments: number);
-    set bevelSegments(bevelSegments: number);
-    set height(height: number);
-    set size(size: number);
-    set lineHeight(lineHeight: number);
-    set letterSpacing(letterSpacing: number);
-    set smooth(smooth: number);
+export declare class NgtsText3D {
+    private inputs;
+    textRef: import("angular-three").NgtInjectedRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[]>>;
+    set _font(font: FontData | string);
+    set _text(text: string);
+    set _bevelEnabled(bevelEnabled: boolean);
+    set _bevelOffset(bevelOffset: number);
+    set _bevelSize(bevelSize: number);
+    set _bevelThickness(bevelThickness: number);
+    set _curveSegments(curveSegments: number);
+    set _bevelSegments(bevelSegments: number);
+    set _height(height: number);
+    set _size(size: number);
+    set _lineHeight(lineHeight: number);
+    set _letterSpacing(letterSpacing: number);
+    set _smooth(smooth: number);
+    private cdr;
+    private fontData;
+    private font;
+    private text;
+    private size;
+    private height;
+    private bevelThickness;
+    private bevelSize;
+    private bevelEnabled;
+    private bevelSegments;
+    private bevelOffset;
+    private curveSegments;
+    private letterSpacing;
+    private lineHeight;
     constructor();
-    readonly geometryArgs: import("@angular/core").Signal<(string | {
-        font: import("three-stdlib").Font;
-        size: number;
-        height: number;
-        bevelThickness: number;
-        bevelSize: number;
-        bevelSegments: number;
-        bevelEnabled: boolean;
-        bevelOffset: number;
-        curveSegments: number;
-        letterSpacing: number;
-        lineHeight: number;
+    geometryArgs: import("@angular/core").Signal<(string | {
+        font: Font;
+        size: number | undefined;
+        height: number | undefined;
+        bevelThickness: number | undefined;
+        bevelSize: number | undefined;
+        bevelSegments: number | undefined;
+        bevelEnabled: boolean | undefined;
+        bevelOffset: number | undefined;
+        curveSegments: number | undefined;
+        letterSpacing: number | undefined;
+        lineHeight: number | undefined;
     })[] | null>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsText3D, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsText3D, "ngts-text-3d", never, { "textRef": { "alias": "textRef"; "required": false; }; "font": { "alias": "font"; "required": true; }; "text": { "alias": "text"; "required": true; }; "bevelEnabled": { "alias": "bevelEnabled"; "required": false; }; "bevelOffset": { "alias": "bevelOffset"; "required": false; }; "bevelSize": { "alias": "bevelSize"; "required": false; }; "bevelThickness": { "alias": "bevelThickness"; "required": false; }; "curveSegments": { "alias": "curveSegments"; "required": false; }; "bevelSegments": { "alias": "bevelSegments"; "required": false; }; "height": { "alias": "height"; "required": false; }; "size": { "alias": "size"; "required": false; }; "lineHeight": { "alias": "lineHeight"; "required": false; }; "letterSpacing": { "alias": "letterSpacing"; "required": false; }; "smooth": { "alias": "smooth"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsText3D, "ngts-text-3d", never, { "textRef": { "alias": "textRef"; "required": false; }; "_font": { "alias": "font"; "required": true; }; "_text": { "alias": "text"; "required": true; }; "_bevelEnabled": { "alias": "bevelEnabled"; "required": false; }; "_bevelOffset": { "alias": "bevelOffset"; "required": false; }; "_bevelSize": { "alias": "bevelSize"; "required": false; }; "_bevelThickness": { "alias": "bevelThickness"; "required": false; }; "_curveSegments": { "alias": "curveSegments"; "required": false; }; "_bevelSegments": { "alias": "bevelSegments"; "required": false; }; "_height": { "alias": "height"; "required": false; }; "_size": { "alias": "size"; "required": false; }; "_lineHeight": { "alias": "lineHeight"; "required": false; }; "_letterSpacing": { "alias": "letterSpacing"; "required": false; }; "_smooth": { "alias": "smooth"; "required": false; }; }, {}, never, ["*"], true, never>;
 }
 export {};

package/cameras/camera/camera-content.d.ts

@@ -2,7 +2,7 @@ import { TemplateRef } from '@angular/core';
 import * as THREE from 'three';
 import * as i0 from "@angular/core";
 export declare class NgtsCameraContent {
-    readonly template: TemplateRef<any>;
+    template: TemplateRef<any>;
     ngtsCameraContent: true | '';
     static ngTemplateContextGuard(_: NgtsCameraContent, ctx: unknown): ctx is {
         fbo: THREE.WebGLRenderTarget;

package/cameras/camera/camera.d.ts

@@ -1,23 +1,26 @@
-import { NgtSignalStore, NgtStore, type NgtCamera } from 'angular-three';
+import { type NgtCamera } from 'angular-three';
 import * as i0 from "@angular/core";
-export interface NgtsCameraState {
+export type NgtsCameraState = {
     makeDefault: boolean;
     manual: boolean;
     frames: number;
     resolution: number;
     envMap?: THREE.Texture;
-}
-export declare abstract class NgtsCamera<TCamera extends NgtCamera> extends NgtSignalStore<NgtsCameraState> {
-    #private;
-    set makeDefault(makeDefault: boolean);
-    set manual(manual: boolean);
-    set frames(frames: number);
-    set resolution(resolution: number);
-    set envMap(envMap: THREE.Texture);
+};
+export declare abstract class NgtsCamera<TCamera extends NgtCamera> {
+    protected inputs: import("angular-three").NgtSignalStore<NgtsCameraState>;
+    set _makeDefault(makeDefault: boolean);
+    set _manual(manual: boolean);
+    set _frames(frames: number);
+    set _resolution(resolution: number);
+    set _envMap(envMap: THREE.Texture);
     cameraRef: import("angular-three").NgtInjectedRef<TCamera>;
-    protected readonly store: NgtStore;
-    readonly fboRef: import("@angular/core").Signal<import("three").WebGLRenderTarget>;
+    private cameraResolution;
+    protected store: import("angular-three").NgtSignalStore<import("angular-three").NgtState>;
+    protected fboRef: import("angular-three").NgtInjectedRef<import("three").WebGLRenderTarget<import("three").Texture> | null>;
     constructor();
+    private setDefaultCamera;
+    private updateProjectionMatrix;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCamera<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsCamera<any>, never, never, { "makeDefault": { "alias": "makeDefault"; "required": false; }; "manual": { "alias": "manual"; "required": false; }; "frames": { "alias": "frames"; "required": false; }; "resolution": { "alias": "resolution"; "required": false; }; "envMap": { "alias": "envMap"; "required": false; }; "cameraRef": { "alias": "cameraRef"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsCamera<any>, never, never, { "_makeDefault": { "alias": "makeDefault"; "required": false; }; "_manual": { "alias": "manual"; "required": false; }; "_frames": { "alias": "frames"; "required": false; }; "_resolution": { "alias": "resolution"; "required": false; }; "_envMap": { "alias": "envMap"; "required": false; }; "cameraRef": { "alias": "cameraRef"; "required": false; }; }, {}, never, never, false, never>;
 }

package/cameras/cube-camera/cube-camera.d.ts

@@ -1,11 +1,8 @@
-import { ElementRef } from '@angular/core';
-import { NgtSignalStore } from 'angular-three';
+import { type Injector, type OnInit, type Signal } from '@angular/core';
+import { type NgtGroup } from 'angular-three';
 import * as THREE from 'three';
-import { NgtsCameraContent } from '../camera/camera-content';
 import * as i0 from "@angular/core";
-export interface NgtsCubeCameraState {
-    /** Number of frames to render, Infinity */
-    frames: number;
+export type NgtsCubeCameraState = {
     /** Resolution of the FBO, 256 */
     resolution: number;
     /** Camera near, 0.1 */
@@ -13,30 +10,60 @@ export interface NgtsCubeCameraState {
     /** Camera far, 1000 */
     far: number;
     /** Custom environment map that is temporarily set as the scenes background */
-    envMap: THREE.Texture;
+    envMap?: THREE.Texture;
     /** Custom fog that is temporarily set as the scenes fog */
-    fog: THREE.Fog | THREE.FogExp2;
+    fog?: THREE.Fog | THREE.FogExp2;
+};
+export declare function injectNgtsCubeCamera(cubeCameraState: () => Partial<NgtsCubeCameraState>, { injector }?: {
+    injector?: Injector;
+}): {
+    fbo: Signal<THREE.WebGLCubeRenderTarget>;
+    camera: Signal<THREE.CubeCamera>;
+    update: Signal<() => void>;
+};
+export type NgtsCubeCameraComponentState = NgtsCubeCameraState & {
+    frames: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-group
+         */
+        'ngts-cube-camera': NgtsCubeCameraComponentState & NgtGroup;
+    }
+}
+export declare class NgtsCubeCameraContent {
+    static ngTemplateContextGuard(_: NgtsCubeCameraContent, ctx: unknown): ctx is {
+        texture: Signal<THREE.WebGLRenderTarget['texture']>;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCubeCameraContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsCubeCameraContent, "ng-template[ngtsCubeCameraContent]", never, {}, {}, never, never, true, never>;
 }
-export declare class NgtsCubeCamera extends NgtSignalStore<NgtsCubeCameraState> {
-    #private;
-    groupRef: ElementRef<THREE.Group>;
-    cameraContent?: NgtsCameraContent;
-    cameraRef: import("angular-three").NgtInjectedRef<THREE.CubeCamera>;
-    /** Number of frames to render, Infinity */
-    set frames(frames: number);
+export declare class NgtsCubeCamera implements OnInit {
+    private inputs;
+    cameraRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+    private cameraContent;
+    private anchor;
     /** Resolution of the FBO, 256 */
-    set resolution(resolution: number);
+    set _resolution(resolution: number);
     /** Camera near, 0.1 */
-    set near(near: number);
+    set _near(near: number);
     /** Camera far, 1000 */
-    set far(far: number);
+    set _far(far: number);
     /** Custom environment map that is temporarily set as the scenes background */
-    set envMap(envMap: THREE.Texture);
+    set _envMap(envMap: THREE.Texture);
     /** Custom fog that is temporarily set as the scenes fog */
-    set fog(fog: THREE.Fog | THREE.FogExp2);
-    readonly fbo: import("@angular/core").Signal<THREE.WebGLCubeRenderTarget>;
-    readonly cameraArgs: import("@angular/core").Signal<(number | THREE.WebGLCubeRenderTarget)[]>;
+    set _fog(fog: THREE.Fog | THREE.FogExp2);
+    cubeCamera: {
+        fbo: Signal<THREE.WebGLCubeRenderTarget>;
+        camera: Signal<THREE.CubeCamera>;
+        update: Signal<() => void>;
+    };
+    private texture;
+    private contentRef?;
     constructor();
+    ngOnInit(): void;
+    private beforeRender;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCubeCamera, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCubeCamera, "ngts-cube-camera", never, { "cameraRef": { "alias": "cameraRef"; "required": false; }; "frames": { "alias": "frames"; "required": false; }; "resolution": { "alias": "resolution"; "required": false; }; "near": { "alias": "near"; "required": false; }; "far": { "alias": "far"; "required": false; }; "envMap": { "alias": "envMap"; "required": false; }; "fog": { "alias": "fog"; "required": false; }; }, {}, ["cameraContent"], never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCubeCamera, "ngts-cube-camera", never, { "cameraRef": { "alias": "cameraRef"; "required": false; }; "_resolution": { "alias": "resolution"; "required": false; }; "_near": { "alias": "near"; "required": false; }; "_far": { "alias": "far"; "required": false; }; "_envMap": { "alias": "envMap"; "required": false; }; "_fog": { "alias": "fog"; "required": false; }; }, {}, ["cameraContent"], never, true, never>;
 }

package/cameras/index.d.ts

@@ -1,4 +1,3 @@
-export * from './camera/camera';
 export * from './camera/camera-content';
 export * from './cube-camera/cube-camera';
 export * from './orthographic-camera/orthographic-camera';

package/cameras/orthographic-camera/orthographic-camera.d.ts

@@ -1,26 +1,37 @@
-import { NgtsCamera } from '../camera/camera';
+import { type NgtOrthographicCamera } from 'angular-three';
+import { NgtsCamera, type NgtsCameraState } from '../camera/camera';
 import { NgtsCameraContent } from '../camera/camera-content';
 import * as i0 from "@angular/core";
-declare module '../camera/camera' {
-    interface NgtsCameraState {
-        left: number;
-        top: number;
-        right: number;
-        bottom: number;
+export type NgtsOrthographicCameraState = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-orthographic-camera
+         */
+        'ngts-orthographic-camera': NgtsCameraState & NgtsOrthographicCameraState & NgtOrthographicCamera;
     }
 }
 export declare class NgtsOrthographicCamera extends NgtsCamera<THREE.OrthographicCamera> {
-    #private;
+    private orthographicInputs;
     cameraContent?: NgtsCameraContent;
-    set left(left: number);
-    set right(right: number);
-    set top(top: number);
-    set bottom(bottom: number);
-    readonly cameraLeft: import("@angular/core").Signal<number>;
-    readonly cameraRight: import("@angular/core").Signal<number>;
-    readonly cameraTop: import("@angular/core").Signal<number>;
-    readonly cameraBottom: import("@angular/core").Signal<number>;
-    constructor();
+    set _left(left: number);
+    set _right(right: number);
+    set _top(top: number);
+    set _bottom(bottom: number);
+    private left;
+    private right;
+    private top;
+    private bottom;
+    private size;
+    cameraLeft: import("@angular/core").Signal<number>;
+    cameraRight: import("@angular/core").Signal<number>;
+    cameraTop: import("@angular/core").Signal<number>;
+    cameraBottom: import("@angular/core").Signal<number>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsOrthographicCamera, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsOrthographicCamera, "ngts-orthographic-camera", never, { "left": { "alias": "left"; "required": false; }; "right": { "alias": "right"; "required": false; }; "top": { "alias": "top"; "required": false; }; "bottom": { "alias": "bottom"; "required": false; }; }, {}, ["cameraContent"], never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsOrthographicCamera, "ngts-orthographic-camera", never, { "_left": { "alias": "left"; "required": false; }; "_right": { "alias": "right"; "required": false; }; "_top": { "alias": "top"; "required": false; }; "_bottom": { "alias": "bottom"; "required": false; }; }, {}, ["cameraContent"], never, true, never>;
 }

package/cameras/perspective-camera/perspective-camera.d.ts

@@ -1,7 +1,16 @@
+import { type NgtPerspectiveCamera } from 'angular-three';
 import { PerspectiveCamera } from 'three';
-import { NgtsCamera } from '../camera/camera';
+import { NgtsCamera, type NgtsCameraState } from '../camera/camera';
 import { NgtsCameraContent } from '../camera/camera-content';
 import * as i0 from "@angular/core";
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-perspective-camera
+         */
+        'ngts-perspective-camera': NgtsCameraState & NgtPerspectiveCamera;
+    }
+}
 export declare class NgtsPerspectiveCamera extends NgtsCamera<PerspectiveCamera> {
     cameraContent?: NgtsCameraContent;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPerspectiveCamera, never>;

package/controls/orbit-controls/orbit-controls.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from '@angular/core';
-import { NgtSignalStore, NgtVector3 } from 'angular-three';
+import { type NgtVector3 } from 'angular-three';
 import { OrbitControls } from 'three-stdlib';
 import * as i0 from "@angular/core";
 export type NgtsOrbitControlsState = {
@@ -9,27 +9,46 @@ export type NgtsOrbitControlsState = {
     makeDefault: boolean;
     regress: boolean;
     enableDamping: boolean;
+    keyEvents: boolean | HTMLElement;
 };
 declare global {
     interface HTMLElementTagNameMap {
+        /**
+         * @extends three-stdlib|OrbitControls
+         */
         'ngts-orbit-controls': OrbitControls & NgtsOrbitControlsState;
     }
 }
-export declare class NgtsOrbitControls extends NgtSignalStore<NgtsOrbitControlsState> {
-    #private;
+export declare class NgtsOrbitControls {
+    private inputs;
     controlsRef: import("angular-three").NgtInjectedRef<OrbitControls>;
-    set camera(camera: THREE.Camera);
-    set domElement(domElement: HTMLElement);
-    set makeDefault(makeDefault: boolean);
-    set regress(regress: boolean);
-    set target(target: THREE.Vector3 | Parameters<THREE.Vector3['set']>);
-    set enableDamping(enableDamping: boolean);
+    set _camera(camera: THREE.Camera);
+    set _domElement(domElement: HTMLElement);
+    set _makeDefault(makeDefault: boolean);
+    set _regress(regress: boolean);
+    set _target(target: THREE.Vector3 | Parameters<THREE.Vector3['set']>);
+    set _enableDamping(enableDamping: boolean);
+    set _keyEvents(keyEvents: boolean);
     change: EventEmitter<import("three").Event>;
     start: EventEmitter<import("three").Event>;
     end: EventEmitter<import("three").Event>;
-    readonly args: import("@angular/core").Signal<OrbitControls[]>;
-    readonly damping: import("@angular/core").Signal<boolean>;
+    private store;
+    private invalidate;
+    private performanceRegress;
+    private defaultCamera;
+    private glDomElement;
+    private regress;
+    private camera;
+    private domElement;
+    private keyEvents;
+    private makeDefault;
+    args: import("@angular/core").Signal<OrbitControls[]>;
+    enableDamping: import("@angular/core").Signal<boolean>;
     constructor();
+    private setControls;
+    private connectElement;
+    private makeControlsDefault;
+    private setEvents;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsOrbitControls, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsOrbitControls, "ngts-orbit-controls", never, { "controlsRef": { "alias": "controlsRef"; "required": false; }; "camera": { "alias": "camera"; "required": false; }; "domElement": { "alias": "domElement"; "required": false; }; "makeDefault": { "alias": "makeDefault"; "required": false; }; "regress": { "alias": "regress"; "required": false; }; "target": { "alias": "target"; "required": false; }; "enableDamping": { "alias": "enableDamping"; "required": false; }; }, { "change": "change"; "start": "start"; "end": "end"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsOrbitControls, "ngts-orbit-controls", never, { "controlsRef": { "alias": "controlsRef"; "required": false; }; "_camera": { "alias": "camera"; "required": false; }; "_domElement": { "alias": "domElement"; "required": false; }; "_makeDefault": { "alias": "makeDefault"; "required": false; }; "_regress": { "alias": "regress"; "required": false; }; "_target": { "alias": "target"; "required": false; }; "_enableDamping": { "alias": "enableDamping"; "required": false; }; "_keyEvents": { "alias": "keyEvents"; "required": false; }; }, { "change": "change"; "start": "start"; "end": "end"; }, never, never, true, never>;
 }