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

package/README.md

@@ -1,7 +1,7 @@
-# angular-three-soba
+# soba
 
 This library was generated with [Nx](https://nx.dev).
 
 ## Running unit tests
 
-Run `nx test angular-three-soba` to execute the unit tests.
+Run `nx test soba` to execute the unit tests.

package/abstractions/billboard/billboard.d.ts

@@ -0,0 +1,28 @@
+import { type NgtGroup } from 'angular-three';
+import { Group } from 'three';
+import * as i0 from "@angular/core";
+export type NgtsBillboardState = {
+    follow?: boolean;
+    lockX?: boolean;
+    lockY?: boolean;
+    lockZ?: boolean;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-group
+         */
+        'ngts-billboard': NgtsBillboardState & NgtGroup;
+    }
+}
+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);
+    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>;
+}

package/abstractions/detailed/detailed.d.ts

@@ -0,0 +1,26 @@
+import { 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

@@ -0,0 +1,34 @@
+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 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 {
+    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; }; }, {}, ["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 './lib/billboard/billboard';
-export * from './lib/catmull-rom-line/catmull-rom-line';
-export * from './lib/cubic-bezier-line/cubic-bezier-line';
-export * from './lib/edges/edges';
-export * from './lib/gizmo-helper/gizmo-helper';
-export * from './lib/gizmo-helper/gizmo-viewcube/gizmo-viewcube';
-export * from './lib/gizmo-helper/gizmo-viewport/gizmo-viewport';
-export * from './lib/line/line';
-export * from './lib/quadratic-bezier-line/quadratic-bezier-line';
-export * from './lib/text-3d/text-3d';
-export * from './lib/text/text';
+export * from './billboard/billboard';
+export * from './detailed/detailed';
+export * from './edges/edges';
+export * from './grid/grid';
+export * from './text-3d/text-3d';
+export * from './text/text';

package/abstractions/text/text.d.ts

@@ -0,0 +1,82 @@
+import { EventEmitter } from '@angular/core';
+import { type NgtMesh } from 'angular-three';
+import * as i0 from "@angular/core";
+export type NgtsTextState = {
+    text: string;
+    /** Font size, default: 1 */
+    fontSize: number;
+    anchorX: number | 'left' | 'center' | 'right';
+    anchorY: number | 'top' | 'top-baseline' | 'middle' | 'bottom-baseline' | 'bottom';
+    sdfGlyphSize: number;
+    font?: string;
+    characters?: string;
+    color?: THREE.ColorRepresentation;
+    maxWidth?: number;
+    lineHeight?: number;
+    letterSpacing?: number;
+    textAlign?: 'left' | 'right' | 'center' | 'justify';
+    clipRect?: [number, number, number, number];
+    depthOffset?: number;
+    direction?: 'auto' | 'ltr' | 'rtl';
+    overflowWrap?: 'normal' | 'break-word';
+    whiteSpace?: 'normal' | 'overflowWrap' | 'nowrap';
+    outlineWidth?: number | string;
+    outlineOffsetX?: number | string;
+    outlineOffsetY?: number | string;
+    outlineBlur?: number | string;
+    outlineColor?: THREE.ColorRepresentation;
+    outlineOpacity?: number;
+    strokeWidth?: number | string;
+    strokeColor?: THREE.ColorRepresentation;
+    strokeOpacity?: number;
+    fillOpacity?: number;
+    debugSDF?: boolean;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-mesh
+         */
+        'ngts-text': NgtsTextState & NgtMesh;
+    }
+}
+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);
+    set fontSize(fontSize: number);
+    set anchorX(anchorX: number | 'left' | 'center' | 'right');
+    set anchorY(anchorY: number | 'top' | 'top-baseline' | 'middle' | 'bottom-baseline' | 'bottom');
+    set sdfGlyphSize(sdfGlyphSize: number);
+    set characters(characters: string);
+    set color(color: THREE.ColorRepresentation);
+    set maxWidth(maxWidth: number);
+    set lineHeight(lineHeight: number);
+    set letterSpacing(letterSpacing: number);
+    set textAlign(textAlign: 'left' | 'right' | 'center' | 'justify');
+    set clipRect(clipRect: [number, number, number, number]);
+    set depthOffset(depthOffset: number);
+    set direction(direction: 'auto' | 'ltr' | 'rtl');
+    set overflowWrap(overflowWrap: 'normal' | 'break-word');
+    set whiteSpace(whiteSpace: 'normal' | 'overflowWrap' | 'nowrap');
+    set outlineWidth(outlineWidth: number | string);
+    set outlineOffsetX(outlineOffsetX: number | string);
+    set outlineOffsetY(outlineOffsetY: number | string);
+    set outlineBlur(outlineBlur: number | string);
+    set outlineColor(outlineColor: THREE.ColorRepresentation);
+    set outlineOpacity(outlineOpacity: number);
+    set strokeWidth(strokeWidth: number | string);
+    set strokeColor(strokeColor: THREE.ColorRepresentation);
+    set strokeOpacity(strokeOpacity: number);
+    set fillOpacity(fillOpacity: number);
+    set debugSDF(debugSDF: boolean);
+    sync: EventEmitter<Text>;
+    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

@@ -0,0 +1,81 @@
+import { type NgtMesh } from 'angular-three';
+import { Mesh } from 'three';
+import { TextGeometryParameters } from 'three-stdlib';
+import * as i0 from "@angular/core";
+declare type Glyph = {
+    _cachedOutline: string[];
+    ha: number;
+    o: string;
+};
+declare type FontData = {
+    boundingBox: {
+        yMax: number;
+        yMin: number;
+    };
+    familyName: string;
+    glyphs: {
+        [k: string]: Glyph;
+    };
+    resolution: number;
+    underlineThickness: number;
+};
+export type NgtsText3DState = {
+    font: FontData | string;
+    text: string;
+    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 {
+    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 fontData;
+    private text;
+    private size;
+    private height;
+    private bevelThickness;
+    private bevelSize;
+    private bevelEnabled;
+    private bevelSegments;
+    private bevelOffset;
+    private curveSegments;
+    private letterSpacing;
+    private lineHeight;
+    geometryArgs: import("@angular/core").Signal<(string | {
+        font: import("three-stdlib").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>;
+}
+export {};

package/cameras/{lib/camera → camera}/camera-content.d.ts

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

package/cameras/camera/camera.d.ts

@@ -0,0 +1,26 @@
+import { type NgtCamera } from 'angular-three';
+import * as i0 from "@angular/core";
+export type NgtsCameraState = {
+    makeDefault: boolean;
+    manual: boolean;
+    frames: number;
+    resolution: number;
+    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>;
+    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>;
+}

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

@@ -0,0 +1,69 @@
+import { OnInit, Signal, type Injector } from '@angular/core';
+import { type NgtGroup } from 'angular-three';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export type NgtsCubeCameraState = {
+    /** Resolution of the FBO, 256 */
+    resolution: number;
+    /** Camera near, 0.1 */
+    near: number;
+    /** Camera far, 1000 */
+    far: number;
+    /** Custom environment map that is temporarily set as the scenes background */
+    envMap?: THREE.Texture;
+    /** Custom fog that is temporarily set as the scenes fog */
+    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 implements OnInit {
+    private inputs;
+    cameraRef: import("angular-three").NgtInjectedRef<THREE.Group>;
+    private cameraContent;
+    private anchor;
+    /** Resolution of the FBO, 256 */
+    set _resolution(resolution: number);
+    /** Camera near, 0.1 */
+    set _near(near: number);
+    /** Camera far, 1000 */
+    set _far(far: number);
+    /** Custom environment map that is temporarily set as the scenes background */
+    set _envMap(envMap: THREE.Texture);
+    /** Custom fog that is temporarily set as the scenes fog */
+    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; }; "_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,4 @@
-export * from './lib/camera/camera-content';
-export * from './lib/cube-camera/cube-camera';
-export * from './lib/orthographic-camera/orthographic-camera';
-export * from './lib/perspective-camera/perspective-camera';
+export * from './camera/camera-content';
+export * from './cube-camera/cube-camera';
+export * from './orthographic-camera/orthographic-camera';
+export * from './perspective-camera/perspective-camera';

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

@@ -0,0 +1,37 @@
+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";
+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 orthographicInputs;
+    cameraContent?: NgtsCameraContent;
+    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>;
+}

package/cameras/{lib/perspective-camera → 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/index.d.ts

@@ -1 +1 @@
-export * from './lib/orbit-controls/orbit-controls';
+export * from './orbit-controls/orbit-controls';

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

@@ -0,0 +1,54 @@
+import { EventEmitter } from '@angular/core';
+import { type NgtVector3 } from 'angular-three';
+import { OrbitControls } from 'three-stdlib';
+import * as i0 from "@angular/core";
+export type NgtsOrbitControlsState = {
+    camera?: THREE.Camera;
+    domElement?: HTMLElement;
+    target?: NgtVector3;
+    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 {
+    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 _keyEvents(keyEvents: boolean);
+    change: EventEmitter<import("three").Event>;
+    start: EventEmitter<import("three").Event>;
+    end: EventEmitter<import("three").Event>;
+    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; }; "_keyEvents": { "alias": "keyEvents"; "required": false; }; }, { "change": "change"; "start": "start"; "end": "end"; }, never, never, true, never>;
+}

package/esm2022/abstractions/angular-three-soba-abstractions.mjs

@@ -2,4 +2,4 @@
  * Generated bundle index. Do not edit.
  */
 export * from './index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1zb2JhLWFic3RyYWN0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci10aHJlZS1zb2JhL2Fic3RyYWN0aW9ucy9zcmMvYW5ndWxhci10aHJlZS1zb2JhLWFic3RyYWN0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1zb2JhLWFic3RyYWN0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvc29iYS9hYnN0cmFjdGlvbnMvc3JjL2FuZ3VsYXItdGhyZWUtc29iYS1hYnN0cmFjdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=