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

package/staging/lib/bounds.d.ts

@@ -0,0 +1,47 @@
+import { ElementRef, Signal } from '@angular/core';
+import { NgtGroup } from 'angular-three';
+import { Box3, Group, Object3D, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsBoundsOptions extends Partial<NgtGroup> {
+    maxDuration: number;
+    margin: number;
+    observe: boolean;
+    fit: boolean;
+    clip: boolean;
+    interpolateFunc: (t: number) => number;
+}
+export declare class NgtsBounds {
+    options: import("@angular/core").InputSignalWithTransform<NgtsBoundsOptions, "" | Partial<NgtsBoundsOptions>>;
+    groupRef: Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    private store;
+    private camera;
+    private invalidate;
+    private size;
+    private controls;
+    private clipOption;
+    private fitOption;
+    private observe;
+    private origin;
+    private goal;
+    private animationState;
+    private t;
+    private box;
+    constructor();
+    getSize(): {
+        box: Box3;
+        size: Vector3;
+        center: Vector3;
+        distance: number;
+    };
+    refresh(object?: Object3D | Box3): this;
+    reset(): this;
+    moveTo(position: Vector3 | [number, number, number]): this;
+    lookAt({ target, up }: {
+        target: Vector3 | [number, number, number];
+        up?: Vector3 | [number, number, number];
+    }): this;
+    fit(): this;
+    clip(): this;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsBounds, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsBounds, "ngts-bounds", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,29 @@
+import * as i0 from "@angular/core";
+export interface NgtsCameraShakeOptions {
+    intensity: number;
+    decay?: boolean;
+    decayRate: number;
+    maxYaw: number;
+    maxPitch: number;
+    maxRoll: number;
+    yawFrequency: number;
+    pitchFrequency: number;
+    rollFrequency: number;
+}
+export declare class NgtsCameraShake {
+    options: import("@angular/core").InputSignalWithTransform<NgtsCameraShakeOptions, "" | Partial<NgtsCameraShakeOptions>>;
+    private autoEffect;
+    private store;
+    private camera;
+    private defaultControls;
+    private initialRotation;
+    private intensityOption;
+    get intensity(): number;
+    set intensity(val: number);
+    private yawNoise;
+    private pitchNoise;
+    private rollNoise;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCameraShake, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsCameraShake, "ngts-camera-shake", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/staging/lib/caustics.d.ts

@@ -0,0 +1,53 @@
+import { ElementRef } from '@angular/core';
+import { NgtGroup } from 'angular-three';
+import { ColorRepresentation, Group, Object3D } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsCausticsOptions extends Partial<NgtGroup> {
+    /** How many frames it will render, set it to Infinity for runtime, default: 1 */
+    frames: number;
+    /** Enables visual cues to help you stage your scene, default: false */
+    debug: boolean;
+    /** Will display caustics only and skip the models, default: false */
+    causticsOnly: boolean;
+    /** Will include back faces and enable the backsideIOR prop, default: false */
+    backside: boolean;
+    /** The IOR refraction index, default: 1.1 */
+    ior: number;
+    /** The IOR refraction index for back faces (only available when backside is enabled), default: 1.1 */
+    backsideIOR: number;
+    /** The texel size, default: 0.3125 */
+    worldRadius: number;
+    /** Intensity of the prjected caustics, default: 0.05 */
+    intensity: number;
+    /** Caustics color, default: white */
+    color: ColorRepresentation;
+    /** Buffer resolution, default: 2048 */
+    resolution: number;
+    /** Camera position, it will point towards the contents bounds center, default: [5, 5, 5] */
+    lightSource: [x: number, y: number, z: number] | ElementRef<Object3D> | Object3D;
+}
+export declare class NgtsCaustics {
+    protected readonly Math: Math;
+    protected readonly CustomBlending: 5;
+    protected readonly OneFactor: 201;
+    protected readonly SrcAlphaFactor: 204;
+    options: import("@angular/core").InputSignalWithTransform<NgtsCausticsOptions, "" | Partial<NgtsCausticsOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsCausticsOptions, "frames" | "color" | "resolution" | "debug" | "causticsOnly" | "backside" | "ior" | "backsideIOR" | "worldRadius" | "intensity" | "lightSource">>;
+    debug: import("@angular/core").Signal<boolean>;
+    color: import("@angular/core").Signal<ColorRepresentation>;
+    private resolution;
+    groupRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    private sceneRef;
+    private cameraRef;
+    private planeRef;
+    private normalTargetParams;
+    private normalTarget;
+    private normalTargetB;
+    private causticsTargetParams;
+    causticsTarget: import("@angular/core").Signal<import("three").WebGLRenderTarget<import("three").Texture>>;
+    causticsTargetB: import("@angular/core").Signal<import("three").WebGLRenderTarget<import("three").Texture>>;
+    private cameraHelper;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCaustics, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCaustics, "ngts-caustics", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/staging/lib/center.d.ts

@@ -0,0 +1,390 @@
+import { ElementRef } from '@angular/core';
+import { Box3, Group, Object3D, Sphere, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsCenterState {
+    /** The next parent above <Center> */
+    parent: Object3D;
+    /** The outmost container group of the <Center> component */
+    container: Object3D;
+    width: number;
+    height: number;
+    depth: number;
+    boundingBox: Box3;
+    boundingSphere: Sphere;
+    center: Vector3;
+    verticalAlignment: number;
+    horizontalAlignment: number;
+    depthAlignment: number;
+}
+export interface NgtsCenterOptions {
+    top?: boolean;
+    right?: boolean;
+    bottom?: boolean;
+    left?: boolean;
+    front?: boolean;
+    back?: boolean;
+    /** Disable all axes */
+    disable?: boolean;
+    /** Disable x-axis centering */
+    disableX?: boolean;
+    /** Disable y-axis centering */
+    disableY?: boolean;
+    /** Disable z-axis centering */
+    disableZ?: boolean;
+    /** See https://threejs.org/docs/index.html?q=box3#api/en/math/Box3.setFromObject */
+    precise: boolean;
+    /** Optional cacheKey to keep the component from recalculating on every render */
+    cacheKey: any;
+}
+export declare class NgtsCenter {
+    options: import("@angular/core").InputSignalWithTransform<Partial<{
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        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: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
+        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: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => 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?: Object3D<import("three").Object3DEventMap> | null | undefined;
+        children?: 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: 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: Vector3, angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+        rotateOnWorldAxis?: ((axis: 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: 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: Vector3) => Vector3) | undefined;
+        worldToLocal?: ((vector: Vector3) => Vector3) | undefined;
+        lookAt?: {
+            (vector: Vector3): void;
+            (x: number, y: number, z: number): void;
+        } | undefined;
+        add?: ((...object: Object3D[]) => Group<import("three").Object3DEventMap>) | undefined;
+        remove?: ((...object: Object3D[]) => Group<import("three").Object3DEventMap>) | undefined;
+        removeFromParent?: (() => Group<import("three").Object3DEventMap>) | undefined;
+        clear?: (() => Group<import("three").Object3DEventMap>) | undefined;
+        getObjectById?: ((id: number) => Object3D | undefined) | undefined;
+        getObjectByName?: ((name: string) => Object3D | undefined) | undefined;
+        getObjectByProperty?: ((name: string, value: any) => Object3D | undefined) | undefined;
+        getObjectsByProperty?: ((name: string, value: any, optionalTarget?: Object3D[]) => Object3D[]) | undefined;
+        getWorldPosition?: ((target: Vector3) => Vector3) | undefined;
+        getWorldQuaternion?: ((target: import("three").Quaternion) => import("three").Quaternion) | undefined;
+        getWorldScale?: ((target: Vector3) => Vector3) | undefined;
+        getWorldDirection?: ((target: Vector3) => Vector3) | undefined;
+        traverse?: ((callback: (object: Object3D) => any) => void) | undefined;
+        traverseVisible?: ((callback: (object: Object3D) => any) => void) | undefined;
+        traverseAncestors?: ((callback: (object: 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: 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: Object3D["raycast"] | null;
+    }> & NgtsCenterOptions, "" | Partial<Partial<{
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        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: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
+        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: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => 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?: Object3D<import("three").Object3DEventMap> | null | undefined;
+        children?: 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: 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: Vector3, angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+        rotateOnWorldAxis?: ((axis: 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: 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: Vector3) => Vector3) | undefined;
+        worldToLocal?: ((vector: Vector3) => Vector3) | undefined;
+        lookAt?: {
+            (vector: Vector3): void;
+            (x: number, y: number, z: number): void;
+        } | undefined;
+        add?: ((...object: Object3D[]) => Group<import("three").Object3DEventMap>) | undefined;
+        remove?: ((...object: Object3D[]) => Group<import("three").Object3DEventMap>) | undefined;
+        removeFromParent?: (() => Group<import("three").Object3DEventMap>) | undefined;
+        clear?: (() => Group<import("three").Object3DEventMap>) | undefined;
+        getObjectById?: ((id: number) => Object3D | undefined) | undefined;
+        getObjectByName?: ((name: string) => Object3D | undefined) | undefined;
+        getObjectByProperty?: ((name: string, value: any) => Object3D | undefined) | undefined;
+        getObjectsByProperty?: ((name: string, value: any, optionalTarget?: Object3D[]) => Object3D[]) | undefined;
+        getWorldPosition?: ((target: Vector3) => Vector3) | undefined;
+        getWorldQuaternion?: ((target: import("three").Quaternion) => import("three").Quaternion) | undefined;
+        getWorldScale?: ((target: Vector3) => Vector3) | undefined;
+        getWorldDirection?: ((target: Vector3) => Vector3) | undefined;
+        traverse?: ((callback: (object: Object3D) => any) => void) | undefined;
+        traverseVisible?: ((callback: (object: Object3D) => any) => void) | undefined;
+        traverseAncestors?: ((callback: (object: 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: 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: Object3D["raycast"] | null;
+    }> & NgtsCenterOptions>>;
+    parameters: import("@angular/core").Signal<Omit<Partial<{
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        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: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
+        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: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => 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?: Object3D<import("three").Object3DEventMap> | null | undefined;
+        children?: 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: 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: Vector3, angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+        rotateOnWorldAxis?: ((axis: 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: 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: Vector3) => Vector3) | undefined;
+        worldToLocal?: ((vector: Vector3) => Vector3) | undefined;
+        lookAt?: {
+            (vector: Vector3): void;
+            (x: number, y: number, z: number): void;
+        } | undefined;
+        add?: ((...object: Object3D[]) => Group<import("three").Object3DEventMap>) | undefined;
+        remove?: ((...object: Object3D[]) => Group<import("three").Object3DEventMap>) | undefined;
+        removeFromParent?: (() => Group<import("three").Object3DEventMap>) | undefined;
+        clear?: (() => Group<import("three").Object3DEventMap>) | undefined;
+        getObjectById?: ((id: number) => Object3D | undefined) | undefined;
+        getObjectByName?: ((name: string) => Object3D | undefined) | undefined;
+        getObjectByProperty?: ((name: string, value: any) => Object3D | undefined) | undefined;
+        getObjectsByProperty?: ((name: string, value: any, optionalTarget?: Object3D[]) => Object3D[]) | undefined;
+        getWorldPosition?: ((target: Vector3) => Vector3) | undefined;
+        getWorldQuaternion?: ((target: import("three").Quaternion) => import("three").Quaternion) | undefined;
+        getWorldScale?: ((target: Vector3) => Vector3) | undefined;
+        getWorldDirection?: ((target: Vector3) => Vector3) | undefined;
+        traverse?: ((callback: (object: Object3D) => any) => void) | undefined;
+        traverseVisible?: ((callback: (object: Object3D) => any) => void) | undefined;
+        traverseAncestors?: ((callback: (object: 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: 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: Object3D["raycast"] | null;
+    }> & NgtsCenterOptions, "disable" | "top" | "right" | "bottom" | "left" | "front" | "back" | "disableX" | "disableY" | "disableZ" | "precise" | "cacheKey">>;
+    centered: import("@angular/core").OutputEmitterRef<NgtsCenterState>;
+    groupRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    private outerRef;
+    private innerRef;
+    centerOptions: import("@angular/core").Signal<Pick<Partial<{
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        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: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
+        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: any, ev: import("angular-three").NgtAllObject3DEventsMap[TEventKey]) => 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?: Object3D<import("three").Object3DEventMap> | null | undefined;
+        children?: 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: 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: Vector3, angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+        rotateOnWorldAxis?: ((axis: 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: 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: Vector3) => Vector3) | undefined;
+        worldToLocal?: ((vector: Vector3) => Vector3) | undefined;
+        lookAt?: {
+            (vector: Vector3): void;
+            (x: number, y: number, z: number): void;
+        } | undefined;
+        add?: ((...object: Object3D[]) => Group<import("three").Object3DEventMap>) | undefined;
+        remove?: ((...object: Object3D[]) => Group<import("three").Object3DEventMap>) | undefined;
+        removeFromParent?: (() => Group<import("three").Object3DEventMap>) | undefined;
+        clear?: (() => Group<import("three").Object3DEventMap>) | undefined;
+        getObjectById?: ((id: number) => Object3D | undefined) | undefined;
+        getObjectByName?: ((name: string) => Object3D | undefined) | undefined;
+        getObjectByProperty?: ((name: string, value: any) => Object3D | undefined) | undefined;
+        getObjectsByProperty?: ((name: string, value: any, optionalTarget?: Object3D[]) => Object3D[]) | undefined;
+        getWorldPosition?: ((target: Vector3) => Vector3) | undefined;
+        getWorldQuaternion?: ((target: import("three").Quaternion) => import("three").Quaternion) | undefined;
+        getWorldScale?: ((target: Vector3) => Vector3) | undefined;
+        getWorldDirection?: ((target: Vector3) => Vector3) | undefined;
+        traverse?: ((callback: (object: Object3D) => any) => void) | undefined;
+        traverseVisible?: ((callback: (object: Object3D) => any) => void) | undefined;
+        traverseAncestors?: ((callback: (object: 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: 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: Object3D["raycast"] | null;
+    }> & NgtsCenterOptions, "disable" | "top" | "right" | "bottom" | "left" | "front" | "back" | "disableX" | "disableY" | "disableZ" | "precise" | "cacheKey">>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCenter, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCenter, "ngts-center", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "centered": "centered"; }, never, ["*"], true, never>;
+}

package/staging/lib/contact-shadows.d.ts

@@ -0,0 +1,55 @@
+import { ElementRef } from '@angular/core';
+import { NgtGroup } from 'angular-three';
+import { ColorRepresentation, Group, OrthographicCamera, PlaneGeometry } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsContactShadowsOptions extends Partial<Omit<NgtGroup, 'scale'>> {
+    opacity: number;
+    width: number;
+    height: number;
+    blur: number;
+    near: number;
+    far: number;
+    smooth: boolean;
+    resolution: number;
+    frames: number;
+    scale: number | [x: number, y: number];
+    color: ColorRepresentation;
+    depthWrite: boolean;
+}
+export declare class NgtsContactShadows {
+    Math: Math;
+    options: import("@angular/core").InputSignalWithTransform<NgtsContactShadowsOptions, "" | Partial<NgtsContactShadowsOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsContactShadowsOptions, "scale" | "renderOrder" | "frames" | "opacity" | "color" | "resolution" | "depthWrite" | "near" | "far" | "width" | "height" | "blur" | "smooth">>;
+    contactShadowsRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    shadowsCameraRef: import("@angular/core").Signal<ElementRef<OrthographicCamera> | undefined>;
+    private store;
+    private scene;
+    private gl;
+    private scaledWidth;
+    private scaledHeight;
+    private resolution;
+    private color;
+    private near;
+    private far;
+    private smooth;
+    private frames;
+    private blur;
+    private renderTarget;
+    private renderTargetBlur;
+    planeGeometry: import("@angular/core").Signal<PlaneGeometry>;
+    private blurPlane;
+    private depthMaterial;
+    private horizontalBlurMaterial;
+    private verticalBlurMaterial;
+    renderOrder: import("@angular/core").Signal<number | undefined>;
+    opacity: import("@angular/core").Signal<number>;
+    depthWrite: import("@angular/core").Signal<boolean>;
+    texture: import("@angular/core").Signal<import("three").Texture>;
+    cameraArgs: import("@angular/core").Signal<number[]>;
+    constructor();
+    private renderShadows;
+    private blurShadows;
+    private createRenderTarget;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsContactShadows, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsContactShadows, "ngts-contact-shadows", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}