angular-three-soba 2.0.0-beta.9 → 2.0.0

package/staging/lib/render-texture.d.ts

@@ -0,0 +1,64 @@
+import { Injector, TemplateRef } from '@angular/core';
+import { NgtAttachable, NgtComputeFunction, NgtTexture } from 'angular-three';
+import { Object3D, Scene, WebGLRenderTarget } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsRenderTextureOptions extends Partial<Omit<NgtTexture, 'attach'>> {
+    /** Optional width of the texture, defaults to viewport bounds */
+    width?: number;
+    /** Optional height of the texture, defaults to viewport bounds */
+    height?: number;
+    /** Optional fbo samples */
+    samples: number;
+    /** Optional stencil buffer, defaults to false */
+    stencilBuffer: boolean;
+    /** Optional depth buffer, defaults to true */
+    depthBuffer: boolean;
+    /** Optional generate mipmaps, defaults to false */
+    generateMipmaps: boolean;
+    /** Optional render priority, defaults to 0 */
+    renderPriority: number;
+    /** Optional event priority, defaults to 0 */
+    eventPriority: number;
+    /** Optional frame count, defaults to Infinity. If you set it to 1, it would only render a single frame, etc */
+    frames: number;
+    /** Optional event compute, defaults to undefined */
+    compute?: (event: any, state: any, previous: any) => false | undefined;
+}
+export declare class NgtsRenderTextureContainer {
+    fbo: import("@angular/core").InputSignal<WebGLRenderTarget<import("three").Texture>>;
+    renderPriority: import("@angular/core").InputSignal<number>;
+    frames: import("@angular/core").InputSignal<number>;
+    injector: import("@angular/core").InputSignal<Injector>;
+    private store;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsRenderTextureContainer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsRenderTextureContainer, "[ngtsRenderTextureContainer]", never, { "fbo": { "alias": "fbo"; "required": true; "isSignal": true; }; "renderPriority": { "alias": "renderPriority"; "required": true; "isSignal": true; }; "frames": { "alias": "frames"; "required": true; "isSignal": true; }; "injector": { "alias": "injector"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class NgtsRenderTextureContent {
+    static ngTemplateContextGuard(_: NgtsRenderTextureContent, ctx: unknown): ctx is {
+        container: Object3D;
+        injector: Injector;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsRenderTextureContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsRenderTextureContent, "ng-template[renderTextureContent]", never, {}, {}, never, never, true, never>;
+}
+export declare class NgtsRenderTexture {
+    attach: import("@angular/core").InputSignal<NgtAttachable>;
+    options: import("@angular/core").InputSignalWithTransform<NgtsRenderTextureOptions, "" | Partial<NgtsRenderTextureOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsRenderTextureOptions, "frames" | "width" | "height" | "depthBuffer" | "stencilBuffer" | "samples" | "generateMipmaps" | "renderPriority" | "eventPriority" | "compute">>;
+    content: import("@angular/core").Signal<TemplateRef<any>>;
+    private store;
+    private size;
+    private viewport;
+    private fboParams;
+    renderPriority: import("@angular/core").Signal<number>;
+    frames: import("@angular/core").Signal<number>;
+    fbo: import("@angular/core").Signal<WebGLRenderTarget<import("three").Texture>>;
+    virtualScene: import("@angular/core").Signal<import("angular-three").NgtInstanceNode<Scene>>;
+    eventPriority: import("@angular/core").Signal<number>;
+    compute: import("@angular/core").Signal<NgtComputeFunction>;
+    private uvCompute;
+    onPointerOver(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsRenderTexture, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsRenderTexture, "ngts-render-texture", never, { "attach": { "alias": "attach"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, ["content"], never, true, never>;
+}

package/staging/lib/sky.d.ts

@@ -0,0 +1,32 @@
+import { NgtMesh, NgtVector3 } from 'angular-three';
+import { Vector3 } from 'three';
+import { Sky } from 'three-stdlib';
+import * as i0 from "@angular/core";
+export declare function calcPosFromAngles(inclination: number, azimuth: number, vector?: Vector3): Vector3;
+export interface NgtsSkyOptions extends Partial<Omit<NgtMesh, 'scale'>> {
+    distance: number;
+    inclination: number;
+    azimuth: number;
+    mieCoefficient: number;
+    mieDirectionalG: number;
+    rayleigh: number;
+    turbidity: number;
+    sunPosition?: NgtVector3;
+}
+export declare class NgtsSky {
+    options: import("@angular/core").InputSignalWithTransform<NgtsSkyOptions, "" | Partial<NgtsSkyOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsSkyOptions, "distance" | "inclination" | "azimuth" | "mieCoefficient" | "mieDirectionalG" | "turbidity" | "sunPosition">>;
+    distance: import("@angular/core").Signal<number>;
+    turbidity: import("@angular/core").Signal<number>;
+    mieCoefficient: import("@angular/core").Signal<number>;
+    mieDirectionalG: import("@angular/core").Signal<number>;
+    rayleigh: import("@angular/core").Signal<number>;
+    scale: import("@angular/core").Signal<Vector3>;
+    private inclination;
+    private azimuth;
+    private sunPosition;
+    calculatedSunPosition: import("@angular/core").Signal<Vector3>;
+    sky: Sky;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSky, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSky, "ngts-sky", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/staging/lib/spot-light.d.ts

@@ -0,0 +1,119 @@
+import { ElementRef } from '@angular/core';
+import { NgtSpotLight } from 'angular-three';
+import { ColorRepresentation, CylinderGeometry, DepthTexture, Mesh, ShaderMaterial, SpotLight, SpotLightHelper, Texture, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsSpotLightOptions extends Partial<NgtSpotLight> {
+    depthBuffer?: DepthTexture;
+    attenuation?: number;
+    anglePower?: number;
+    radiusTop?: number;
+    radiusBottom?: number;
+    opacity?: number;
+    color?: ColorRepresentation;
+    volumetric?: boolean;
+    debug?: boolean;
+}
+export type NgtsVolumetricMeshOptions = Omit<NgtsSpotLightOptions, 'volumetric'>;
+export declare class NgtsVolumetricMesh {
+    options: import("@angular/core").InputSignalWithTransform<NgtsVolumetricMeshOptions, "" | Partial<NgtsVolumetricMeshOptions>>;
+    meshRef: import("@angular/core").Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>;
+    private store;
+    size: import("@angular/core").Signal<import("angular-three").NgtSize>;
+    dpr: import("@angular/core").Signal<number>;
+    camera: import("@angular/core").Signal<import("angular-three").NgtCameraManual>;
+    private radiusTop;
+    private radiusBottom;
+    private angle;
+    private distance;
+    private normalizedRadiusTop;
+    private normalizedRadiusBottom;
+    material: ShaderMaterial & {
+        depth: Texture | null;
+        opacity: number;
+        attenuation: number;
+        anglePower: number;
+        spotPosition: Vector3;
+        lightColor: import("three").Color;
+        cameraNear: number;
+        cameraFar: number;
+        resolution: import("three").Vector2;
+        transparent: boolean;
+        depthWrite: boolean;
+    };
+    opacity: import("@angular/core").Signal<number | undefined>;
+    color: import("@angular/core").Signal<ColorRepresentation | undefined>;
+    attenuation: import("@angular/core").Signal<number | undefined>;
+    anglePower: import("@angular/core").Signal<number | undefined>;
+    depthBuffer: import("@angular/core").Signal<DepthTexture | undefined>;
+    geometry: import("@angular/core").Signal<CylinderGeometry>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsVolumetricMesh, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsVolumetricMesh, "ngts-volumetric-mesh", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+interface NgtsShadowMeshOptions {
+    distance: number;
+    alphaTest: number;
+    scale: number;
+    width: number;
+    height: number;
+    map?: Texture;
+}
+export declare class NgtsSpotLightShadowShader {
+    protected readonly DoubleSide: 2;
+    shader: import("@angular/core").InputSignal<string>;
+    options: import("@angular/core").InputSignalWithTransform<NgtsShadowMeshOptions, "" | Partial<NgtsShadowMeshOptions>>;
+    mesh: import("@angular/core").Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>;
+    private spotLight;
+    debug: import("@angular/core").Signal<boolean | undefined>;
+    scale: import("@angular/core").Signal<number>;
+    alphaTest: import("@angular/core").Signal<number>;
+    private width;
+    private height;
+    private map;
+    private distance;
+    private renderTarget;
+    texture: import("@angular/core").Signal<Texture>;
+    private fsQuad;
+    private uniforms;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadowShader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLightShadowShader, "ngts-spot-light-shadow-shader", never, { "shader": { "alias": "shader"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+export declare class NgtsSpotLightShadowNoShader {
+    protected readonly DoubleSide: 2;
+    options: import("@angular/core").InputSignalWithTransform<NgtsShadowMeshOptions, "" | Partial<NgtsShadowMeshOptions>>;
+    mesh: import("@angular/core").Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>;
+    private spotLight;
+    debug: import("@angular/core").Signal<boolean | undefined>;
+    alphaTest: import("@angular/core").Signal<number>;
+    scale: import("@angular/core").Signal<number>;
+    map: import("@angular/core").Signal<Texture | undefined>;
+    private width;
+    private height;
+    private distance;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadowNoShader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLightShadowNoShader, "ngts-spot-light-shadow-no-shader", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+export declare class NgtsSpotLightShadow {
+    shader: import("@angular/core").InputSignal<string | undefined>;
+    options: import("@angular/core").InputSignalWithTransform<NgtsShadowMeshOptions, "" | Partial<NgtsShadowMeshOptions>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLightShadow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLightShadow, "ngts-spot-light-shadow", never, { "shader": { "alias": "shader"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class NgtsSpotLight {
+    protected readonly SpotLightHelper: typeof SpotLightHelper;
+    options: import("@angular/core").InputSignalWithTransform<NgtsSpotLightOptions, "" | Partial<NgtsSpotLightOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsSpotLightOptions, "opacity" | "color" | "distance" | "debug" | "depthBuffer" | "angle" | "attenuation" | "anglePower" | "radiusTop" | "radiusBottom" | "volumetric">>;
+    volumetricOptions: import("@angular/core").Signal<Pick<NgtsSpotLightOptions, "opacity" | "color" | "distance" | "debug" | "depthBuffer" | "angle" | "attenuation" | "anglePower" | "radiusTop" | "radiusBottom">>;
+    spotLight: import("@angular/core").Signal<ElementRef<SpotLight>>;
+    debug: import("@angular/core").Signal<boolean | undefined>;
+    angle: import("@angular/core").Signal<number | undefined>;
+    color: import("@angular/core").Signal<ColorRepresentation | undefined>;
+    distance: import("@angular/core").Signal<number | undefined>;
+    volumetric: import("@angular/core").Signal<boolean | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSpotLight, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSpotLight, "ngts-spot-light", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+export {};

package/staging/lib/stage.d.ts

@@ -0,0 +1,352 @@
+import { NgtGroup } from 'angular-three';
+import { Group } from 'three';
+import { NgtsAccumulativeShadowsOptions } from './accumulative-shadows';
+import { NgtsCenterOptions, NgtsCenterState } from './center';
+import { NgtsContactShadowsOptions } from './contact-shadows';
+import { NgtsEnvironmentOptions, NgtsEnvironmentPresets } from './environment';
+import { NgtsRandomizedLightsOptions } from './randomized-lights';
+import * as i0 from "@angular/core";
+type NgtsStageShadowsOptions = Partial<NgtsAccumulativeShadowsOptions> & Partial<NgtsRandomizedLightsOptions> & Partial<NgtsContactShadowsOptions> & {
+    type: 'contact' | 'accumulative';
+    /** Shadow plane offset, default: 0 */
+    offset: number;
+    /** Shadow bias, default: -0.0001 */
+    bias: number;
+    /** Shadow normal bias, default: 0 */
+    normalBias: number;
+    /** Shadow map size, default: 1024 */
+    size: number;
+};
+export interface NgtsStageOptions extends Partial<NgtGroup> {
+    /** Lighting setup, default: "rembrandt" */
+    preset: 'rembrandt' | 'portrait' | 'upfront' | 'soft' | {
+        main: [x: number, y: number, z: number];
+        fill: [x: number, y: number, z: number];
+    };
+    /** Controls the ground shadows, default: "contact" */
+    shadows: boolean | 'contact' | 'accumulative' | NgtsStageShadowsOptions;
+    /** Optionally wraps and thereby centers the models using <Bounds>, can also be a margin, default: true */
+    adjustCamera: boolean | number;
+    /** The default environment, default: "city" */
+    environment: NgtsEnvironmentPresets | Partial<NgtsEnvironmentOptions> | null;
+    /** The lighting intensity, default: 0.5 */
+    intensity: number;
+    /** To adjust centering, default: undefined */
+    center?: Partial<NgtsCenterOptions>;
+}
+export declare class NgtsStageRefit {
+    radius: import("@angular/core").InputSignal<number>;
+    adjustCamera: import("@angular/core").InputSignal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsStageRefit, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsStageRefit, "ngts-stage-refit", never, { "radius": { "alias": "radius"; "required": true; "isSignal": true; }; "adjustCamera": { "alias": "adjustCamera"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class NgtsStage {
+    options: import("@angular/core").InputSignalWithTransform<NgtsStageOptions, "" | Partial<NgtsStageOptions>>;
+    private parameters;
+    centered: import("@angular/core").OutputEmitterRef<NgtsCenterState>;
+    private dims;
+    radius: import("@angular/core").Signal<number>;
+    height: import("@angular/core").Signal<number>;
+    center: import("@angular/core").Signal<Partial<NgtsCenterOptions> | undefined>;
+    adjustCamera: import("@angular/core").Signal<number | boolean>;
+    margin: import("@angular/core").Signal<number>;
+    intensity: import("@angular/core").Signal<number>;
+    shadows: import("@angular/core").Signal<boolean | "contact" | "accumulative" | NgtsStageShadowsOptions>;
+    environment: import("@angular/core").Signal<Partial<NgtsEnvironmentOptions> | "apartment" | "city" | "dawn" | "forest" | "lobby" | "night" | "park" | "studio" | "sunset" | "warehouse" | null>;
+    preset: import("@angular/core").Signal<{
+        main: [x: number, y: number, z: number];
+        fill: [x: number, y: number, z: number];
+    } | "rembrandt" | "portrait" | "upfront" | "soft">;
+    config: import("@angular/core").Signal<{
+        readonly main: readonly [1, 2, 1];
+        readonly fill: readonly [-2, -0.5, -2];
+    } | {
+        readonly main: readonly [-1, 2, 0.5];
+        readonly fill: readonly [-1, 0.5, -1.5];
+    } | {
+        readonly main: readonly [0, 2, 1];
+        readonly fill: readonly [-1, 0.5, -1.5];
+    } | {
+        readonly main: readonly [-2, 4, 4];
+        readonly fill: readonly [-1, 0.5, -1.5];
+    } | {
+        main: [x: number, y: number, z: number];
+        fill: [x: number, y: number, z: number];
+    }>;
+    shadowBias: import("@angular/core").Signal<number>;
+    normalBias: import("@angular/core").Signal<number>;
+    shadowSize: import("@angular/core").Signal<number>;
+    shadowOffset: import("@angular/core").Signal<number>;
+    contactShadow: import("@angular/core").Signal<boolean>;
+    accumulativeShadow: import("@angular/core").Signal<boolean>;
+    shadowOptions: import("@angular/core").Signal<{}>;
+    randomizedLightsOptions: import("@angular/core").Signal<Partial<NgtsRandomizedLightsOptions>>;
+    environmentOptions: import("@angular/core").Signal<Partial<NgtsEnvironmentOptions>>;
+    boundsOptions: import("@angular/core").Signal<{
+        attach?: string | string[] | import("angular-three").NgtAttachFunction | undefined;
+        addEventListener?: ((<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Group<import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Group<import("three").Object3DEventMap>, typeof Group>, ev: import("angular-three").NgtNodeEventMap<Group<import("three").Object3DEventMap>>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtAllObject3DEventsMap>(type: TEventKey, listener: (this: {
+            attach: string | string[] | import("angular-three").NgtAttachFunction;
+            addEventListener: (<TEventKey_1 extends keyof import("angular-three").NgtNodeEventMap<Group<import("three").Object3DEventMap>>>(type: TEventKey_1, listener: (this: import("angular-three").NgtNodeElement<Group<import("three").Object3DEventMap>, typeof Group>, ev: import("angular-three").NgtNodeEventMap<Group<import("three").Object3DEventMap>>[TEventKey_1]) => any) => void) & any;
+            removeEventListener: (<TEventKey_1 extends keyof import("angular-three").NgtNodeEventMap<Group<import("three").Object3DEventMap>>>(type: TEventKey_1, listener: (this: import("angular-three").NgtNodeElement<Group<import("three").Object3DEventMap>, typeof Group>, ev: import("angular-three").NgtNodeEventMap<Group<import("three").Object3DEventMap>>[TEventKey_1]) => any) => void) & (<TEventKey_1 extends keyof import("angular-three").NgtAllObject3DEventsMap>(type: TEventKey_1, listener: (this: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey_1]) => any) => void);
+            __ngt_args__: [];
+            readonly isGroup?: true | undefined;
+            readonly type?: string | undefined;
+            readonly isObject3D?: true | undefined;
+            readonly id?: number | undefined;
+            uuid?: string | undefined;
+            name?: string | undefined;
+            parent?: import("three").Object3D<import("three").Object3DEventMap> | null | undefined;
+            children?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined;
+            readonly modelViewMatrix?: import("three").Matrix4 | undefined;
+            readonly normalMatrix?: import("three").Matrix3 | undefined;
+            matrixWorld?: import("three").Matrix4 | undefined;
+            matrixAutoUpdate?: boolean | undefined;
+            matrixWorldAutoUpdate?: boolean | undefined;
+            matrixWorldNeedsUpdate?: boolean | undefined;
+            visible?: boolean | undefined;
+            castShadow?: boolean | undefined;
+            receiveShadow?: boolean | undefined;
+            frustumCulled?: boolean | undefined;
+            renderOrder?: number | undefined;
+            animations?: import("three").AnimationClip[] | undefined;
+            userData?: Record<string, any> | undefined;
+            customDepthMaterial?: import("three").Material | undefined;
+            customDistanceMaterial?: import("three").Material | undefined;
+            onBeforeShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry, depthMaterial: import("three").Material, group: Group) => void) | undefined;
+            onAfterShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry, depthMaterial: import("three").Material, group: Group) => void) | undefined;
+            onBeforeRender?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, material: import("three").Material, group: Group) => void) | undefined;
+            onAfterRender?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, material: import("three").Material, group: Group) => void) | undefined;
+            applyMatrix4?: ((matrix: import("three").Matrix4) => void) | undefined;
+            applyQuaternion?: ((quaternion: import("three").Quaternion) => Group<import("three").Object3DEventMap>) | undefined;
+            setRotationFromAxisAngle?: ((axis: import("three").Vector3, angle: number) => void) | undefined;
+            setRotationFromEuler?: ((euler: import("three").Euler) => void) | undefined;
+            setRotationFromMatrix?: ((m: import("three").Matrix4) => void) | undefined;
+            setRotationFromQuaternion?: ((q: import("three").Quaternion) => void) | undefined;
+            rotateOnAxis?: ((axis: import("three").Vector3, angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+            rotateOnWorldAxis?: ((axis: import("three").Vector3, angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+            rotateX?: ((angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+            rotateY?: ((angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+            rotateZ?: ((angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+            translateOnAxis?: ((axis: import("three").Vector3, distance: number) => Group<import("three").Object3DEventMap>) | undefined;
+            translateX?: ((distance: number) => Group<import("three").Object3DEventMap>) | undefined;
+            translateY?: ((distance: number) => Group<import("three").Object3DEventMap>) | undefined;
+            translateZ?: ((distance: number) => Group<import("three").Object3DEventMap>) | undefined;
+            localToWorld?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+            worldToLocal?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+            lookAt?: {
+                (vector: import("three").Vector3): void;
+                (x: number, y: number, z: number): void;
+            } | undefined;
+            add?: ((...object: import("three").Object3D[]) => Group<import("three").Object3DEventMap>) | undefined;
+            remove?: ((...object: import("three").Object3D[]) => Group<import("three").Object3DEventMap>) | undefined;
+            removeFromParent?: (() => Group<import("three").Object3DEventMap>) | undefined;
+            clear?: (() => Group<import("three").Object3DEventMap>) | undefined;
+            getObjectById?: ((id: number) => import("three").Object3D | undefined) | undefined;
+            getObjectByName?: ((name: string) => import("three").Object3D | undefined) | undefined;
+            getObjectByProperty?: ((name: string, value: any) => import("three").Object3D | undefined) | undefined;
+            getObjectsByProperty?: ((name: string, value: any, optionalTarget?: import("three").Object3D[]) => import("three").Object3D[]) | undefined;
+            getWorldPosition?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+            getWorldQuaternion?: ((target: import("three").Quaternion) => import("three").Quaternion) | undefined;
+            getWorldScale?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+            getWorldDirection?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+            traverse?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+            traverseVisible?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+            traverseAncestors?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+            updateMatrix?: (() => void) | undefined;
+            updateMatrixWorld?: ((force?: boolean) => void) | undefined;
+            updateWorldMatrix?: ((updateParents: boolean, updateChildren: boolean) => void) | undefined;
+            toJSON?: ((meta?: import("three").JSONMeta) => import("three").Object3DJSON) | undefined;
+            clone?: ((recursive?: boolean) => Group<import("three").Object3DEventMap>) | undefined;
+            copy?: ((object: import("three").Object3D, recursive?: boolean) => Group<import("three").Object3DEventMap>) | undefined;
+            hasEventListener?: (<T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, Group<import("three").Object3DEventMap>>) => boolean) | undefined;
+            dispatchEvent?: (<T extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T> & import("three").Object3DEventMap[T]) => void) | undefined;
+            position: import("angular-three").NgtVector3;
+            up: import("angular-three").NgtVector3;
+            scale: import("angular-three").NgtVector3;
+            rotation: import("angular-three").NgtEuler;
+            matrix: import("angular-three").NgtMatrix4;
+            quaternion: import("angular-three").NgtQuaternion;
+            layers: import("angular-three").NgtLayers;
+            dispose: (() => void) | null;
+            raycast: import("three").Object3D["raycast"] | null;
+        }, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void)) | undefined;
+        removeEventListener?: ((<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Group<import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Group<import("three").Object3DEventMap>, typeof Group>, ev: import("angular-three").NgtNodeEventMap<Group<import("three").Object3DEventMap>>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("angular-three").NgtAllObject3DEventsMap>(type: TEventKey, listener: (this: {
+            attach: string | string[] | import("angular-three").NgtAttachFunction;
+            addEventListener: (<TEventKey_1 extends keyof import("angular-three").NgtNodeEventMap<Group<import("three").Object3DEventMap>>>(type: TEventKey_1, listener: (this: import("angular-three").NgtNodeElement<Group<import("three").Object3DEventMap>, typeof Group>, ev: import("angular-three").NgtNodeEventMap<Group<import("three").Object3DEventMap>>[TEventKey_1]) => any) => void) & (<TEventKey_1 extends keyof import("angular-three").NgtAllObject3DEventsMap>(type: TEventKey_1, listener: (this: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey_1]) => any) => void);
+            removeEventListener: (<TEventKey_1 extends keyof import("angular-three").NgtNodeEventMap<Group<import("three").Object3DEventMap>>>(type: TEventKey_1, listener: (this: import("angular-three").NgtNodeElement<Group<import("three").Object3DEventMap>, typeof Group>, ev: import("angular-three").NgtNodeEventMap<Group<import("three").Object3DEventMap>>[TEventKey_1]) => any) => void) & any;
+            __ngt_args__: [];
+            readonly isGroup?: true | undefined;
+            readonly type?: string | undefined;
+            readonly isObject3D?: true | undefined;
+            readonly id?: number | undefined;
+            uuid?: string | undefined;
+            name?: string | undefined;
+            parent?: import("three").Object3D<import("three").Object3DEventMap> | null | undefined;
+            children?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined;
+            readonly modelViewMatrix?: import("three").Matrix4 | undefined;
+            readonly normalMatrix?: import("three").Matrix3 | undefined;
+            matrixWorld?: import("three").Matrix4 | undefined;
+            matrixAutoUpdate?: boolean | undefined;
+            matrixWorldAutoUpdate?: boolean | undefined;
+            matrixWorldNeedsUpdate?: boolean | undefined;
+            visible?: boolean | undefined;
+            castShadow?: boolean | undefined;
+            receiveShadow?: boolean | undefined;
+            frustumCulled?: boolean | undefined;
+            renderOrder?: number | undefined;
+            animations?: import("three").AnimationClip[] | undefined;
+            userData?: Record<string, any> | undefined;
+            customDepthMaterial?: import("three").Material | undefined;
+            customDistanceMaterial?: import("three").Material | undefined;
+            onBeforeShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry, depthMaterial: import("three").Material, group: Group) => void) | undefined;
+            onAfterShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry, depthMaterial: import("three").Material, group: Group) => void) | undefined;
+            onBeforeRender?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, material: import("three").Material, group: Group) => void) | undefined;
+            onAfterRender?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, material: import("three").Material, group: Group) => void) | undefined;
+            applyMatrix4?: ((matrix: import("three").Matrix4) => void) | undefined;
+            applyQuaternion?: ((quaternion: import("three").Quaternion) => Group<import("three").Object3DEventMap>) | undefined;
+            setRotationFromAxisAngle?: ((axis: import("three").Vector3, angle: number) => void) | undefined;
+            setRotationFromEuler?: ((euler: import("three").Euler) => void) | undefined;
+            setRotationFromMatrix?: ((m: import("three").Matrix4) => void) | undefined;
+            setRotationFromQuaternion?: ((q: import("three").Quaternion) => void) | undefined;
+            rotateOnAxis?: ((axis: import("three").Vector3, angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+            rotateOnWorldAxis?: ((axis: import("three").Vector3, angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+            rotateX?: ((angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+            rotateY?: ((angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+            rotateZ?: ((angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+            translateOnAxis?: ((axis: import("three").Vector3, distance: number) => Group<import("three").Object3DEventMap>) | undefined;
+            translateX?: ((distance: number) => Group<import("three").Object3DEventMap>) | undefined;
+            translateY?: ((distance: number) => Group<import("three").Object3DEventMap>) | undefined;
+            translateZ?: ((distance: number) => Group<import("three").Object3DEventMap>) | undefined;
+            localToWorld?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+            worldToLocal?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+            lookAt?: {
+                (vector: import("three").Vector3): void;
+                (x: number, y: number, z: number): void;
+            } | undefined;
+            add?: ((...object: import("three").Object3D[]) => Group<import("three").Object3DEventMap>) | undefined;
+            remove?: ((...object: import("three").Object3D[]) => Group<import("three").Object3DEventMap>) | undefined;
+            removeFromParent?: (() => Group<import("three").Object3DEventMap>) | undefined;
+            clear?: (() => Group<import("three").Object3DEventMap>) | undefined;
+            getObjectById?: ((id: number) => import("three").Object3D | undefined) | undefined;
+            getObjectByName?: ((name: string) => import("three").Object3D | undefined) | undefined;
+            getObjectByProperty?: ((name: string, value: any) => import("three").Object3D | undefined) | undefined;
+            getObjectsByProperty?: ((name: string, value: any, optionalTarget?: import("three").Object3D[]) => import("three").Object3D[]) | undefined;
+            getWorldPosition?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+            getWorldQuaternion?: ((target: import("three").Quaternion) => import("three").Quaternion) | undefined;
+            getWorldScale?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+            getWorldDirection?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+            traverse?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+            traverseVisible?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+            traverseAncestors?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+            updateMatrix?: (() => void) | undefined;
+            updateMatrixWorld?: ((force?: boolean) => void) | undefined;
+            updateWorldMatrix?: ((updateParents: boolean, updateChildren: boolean) => void) | undefined;
+            toJSON?: ((meta?: import("three").JSONMeta) => import("three").Object3DJSON) | undefined;
+            clone?: ((recursive?: boolean) => Group<import("three").Object3DEventMap>) | undefined;
+            copy?: ((object: import("three").Object3D, recursive?: boolean) => Group<import("three").Object3DEventMap>) | undefined;
+            hasEventListener?: (<T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, Group<import("three").Object3DEventMap>>) => boolean) | undefined;
+            dispatchEvent?: (<T extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T> & import("three").Object3DEventMap[T]) => void) | undefined;
+            position: import("angular-three").NgtVector3;
+            up: import("angular-three").NgtVector3;
+            scale: import("angular-three").NgtVector3;
+            rotation: import("angular-three").NgtEuler;
+            matrix: import("angular-three").NgtMatrix4;
+            quaternion: import("angular-three").NgtQuaternion;
+            layers: import("angular-three").NgtLayers;
+            dispose: (() => void) | null;
+            raycast: import("three").Object3D["raycast"] | null;
+        }, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void)) | undefined;
+        __ngt_args__?: [] | undefined;
+        position?: import("angular-three").NgtVector3 | undefined;
+        up?: import("angular-three").NgtVector3 | undefined;
+        scale?: import("angular-three").NgtVector3 | undefined;
+        rotation?: import("angular-three").NgtEuler | undefined;
+        matrix?: import("angular-three").NgtMatrix4 | undefined;
+        quaternion?: import("angular-three").NgtQuaternion | undefined;
+        layers?: import("angular-three").NgtLayers | undefined;
+        dispose?: (() => void) | null | undefined;
+        raycast?: ((raycaster: import("three").Raycaster, intersects: import("three").Intersection[]) => void) | null | undefined;
+        isGroup?: true | undefined;
+        type?: string | undefined;
+        isObject3D?: true | undefined;
+        id?: number | undefined;
+        uuid?: string | undefined;
+        name?: string | undefined;
+        parent?: import("three").Object3D<import("three").Object3DEventMap> | null | undefined;
+        children?: import("three").Object3D<import("three").Object3DEventMap>[] | undefined;
+        modelViewMatrix?: import("three").Matrix4 | undefined;
+        normalMatrix?: import("three").Matrix3 | undefined;
+        matrixWorld?: import("three").Matrix4 | undefined;
+        matrixAutoUpdate?: boolean | undefined;
+        matrixWorldAutoUpdate?: boolean | undefined;
+        matrixWorldNeedsUpdate?: boolean | undefined;
+        visible?: boolean | undefined;
+        castShadow?: boolean | undefined;
+        receiveShadow?: boolean | undefined;
+        frustumCulled?: boolean | undefined;
+        renderOrder?: number | undefined;
+        animations?: import("three").AnimationClip[] | undefined;
+        userData?: Record<string, any> | undefined;
+        customDepthMaterial?: import("three").Material | undefined;
+        customDistanceMaterial?: import("three").Material | undefined;
+        onBeforeShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry, depthMaterial: import("three").Material, group: Group) => void) | undefined;
+        onAfterShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry, depthMaterial: import("three").Material, group: Group) => void) | undefined;
+        onBeforeRender?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, material: import("three").Material, group: Group) => void) | undefined;
+        onAfterRender?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, material: import("three").Material, group: Group) => void) | undefined;
+        applyMatrix4?: ((matrix: import("three").Matrix4) => void) | undefined;
+        applyQuaternion?: ((quaternion: import("three").Quaternion) => Group<import("three").Object3DEventMap>) | undefined;
+        setRotationFromAxisAngle?: ((axis: import("three").Vector3, angle: number) => void) | undefined;
+        setRotationFromEuler?: ((euler: import("three").Euler) => void) | undefined;
+        setRotationFromMatrix?: ((m: import("three").Matrix4) => void) | undefined;
+        setRotationFromQuaternion?: ((q: import("three").Quaternion) => void) | undefined;
+        rotateOnAxis?: ((axis: import("three").Vector3, angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+        rotateOnWorldAxis?: ((axis: import("three").Vector3, angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+        rotateX?: ((angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+        rotateY?: ((angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+        rotateZ?: ((angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+        translateOnAxis?: ((axis: import("three").Vector3, distance: number) => Group<import("three").Object3DEventMap>) | undefined;
+        translateX?: ((distance: number) => Group<import("three").Object3DEventMap>) | undefined;
+        translateY?: ((distance: number) => Group<import("three").Object3DEventMap>) | undefined;
+        translateZ?: ((distance: number) => Group<import("three").Object3DEventMap>) | undefined;
+        localToWorld?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+        worldToLocal?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+        lookAt?: {
+            (vector: import("three").Vector3): void;
+            (x: number, y: number, z: number): void;
+        } | undefined;
+        add?: ((...object: import("three").Object3D[]) => Group<import("three").Object3DEventMap>) | undefined;
+        remove?: ((...object: import("three").Object3D[]) => Group<import("three").Object3DEventMap>) | undefined;
+        removeFromParent?: (() => Group<import("three").Object3DEventMap>) | undefined;
+        clear?: (() => Group<import("three").Object3DEventMap>) | undefined;
+        getObjectById?: ((id: number) => import("three").Object3D | undefined) | undefined;
+        getObjectByName?: ((name: string) => import("three").Object3D | undefined) | undefined;
+        getObjectByProperty?: ((name: string, value: any) => import("three").Object3D | undefined) | undefined;
+        getObjectsByProperty?: ((name: string, value: any, optionalTarget?: import("three").Object3D[]) => import("three").Object3D[]) | undefined;
+        getWorldPosition?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        getWorldQuaternion?: ((target: import("three").Quaternion) => import("three").Quaternion) | undefined;
+        getWorldScale?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        getWorldDirection?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        traverse?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        traverseVisible?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        traverseAncestors?: ((callback: (object: import("three").Object3D) => any) => void) | undefined;
+        updateMatrix?: (() => void) | undefined;
+        updateMatrixWorld?: ((force?: boolean) => void) | undefined;
+        updateWorldMatrix?: ((updateParents: boolean, updateChildren: boolean) => void) | undefined;
+        toJSON?: ((meta?: import("three").JSONMeta) => import("three").Object3DJSON) | undefined;
+        clone?: ((recursive?: boolean) => Group<import("three").Object3DEventMap>) | undefined;
+        copy?: ((object: import("three").Object3D, recursive?: boolean) => Group<import("three").Object3DEventMap>) | undefined;
+        hasEventListener?: (<T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, Group<import("three").Object3DEventMap>>) => boolean) | undefined;
+        dispatchEvent?: (<T extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T> & import("three").Object3DEventMap[T]) => void) | undefined;
+        fit: boolean;
+        clip: boolean;
+        margin: number;
+        observe: boolean;
+    }>;
+    centerOptions: import("@angular/core").Signal<Partial<NgtsCenterOptions>>;
+    constructor();
+    onCenter($event: NgtsCenterState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsStage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsStage, "ngts-stage", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "centered": "centered"; }, never, ["*"], true, never>;
+}
+export {};

package/stats/README.md

@@ -0,0 +1,3 @@
+# angular-three-soba/stats
+
+Secondary entry point of `angular-three-soba`. It can be used by importing from `angular-three-soba/stats`.

package/stats/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/stats';

package/stats/lib/stats.d.ts

@@ -0,0 +1,14 @@
+import { ElementRef } from '@angular/core';
+import Stats from 'stats-gl';
+import * as i0 from "@angular/core";
+export type NgtsStatsOptions = Partial<Stats> & {
+    showPanel?: number;
+    domClass: string;
+    parent: ElementRef<HTMLElement> | HTMLElement | null | undefined;
+};
+export declare class NgtsStats {
+    options: import("@angular/core").InputSignalWithTransform<NgtsStatsOptions, "" | Partial<NgtsStatsOptions>>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsStats, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsStats, "ngt-canvas[stats]", never, { "options": { "alias": "stats"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/vanilla-exports/README.md

@@ -0,0 +1,3 @@
+# angular-three-soba/vanilla-exports
+
+Secondary entry point of `angular-three-soba`. It can be used by importing from `angular-three-soba/vanilla-exports`.