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

package/abstractions/lib/gradient-texture.d.ts

@@ -0,0 +1,24 @@
+import { NgtAttachable, NgtTexture } from 'angular-three';
+import { ColorRepresentation } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsGradientTextureOptions extends Partial<Omit<NgtTexture, 'type'>> {
+    size: number;
+    width: number;
+    type: 'linear' | 'radial';
+    innerCircleRadius: number;
+    outerCircleRadius: string | number;
+}
+export declare class NgtsGradientTexture {
+    attach: import("@angular/core").InputSignal<NgtAttachable>;
+    stops: import("@angular/core").InputSignal<number[]>;
+    colors: import("@angular/core").InputSignal<ColorRepresentation[]>;
+    options: import("@angular/core").InputSignalWithTransform<NgtsGradientTextureOptions, "" | Partial<NgtsGradientTextureOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsGradientTextureOptions, "type" | "size" | "width" | "innerCircleRadius" | "outerCircleRadius">>;
+    private store;
+    gl: import("@angular/core").Signal<import("three").WebGLRenderer>;
+    private document;
+    canvas: import("@angular/core").Signal<HTMLCanvasElement>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGradientTexture, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGradientTexture, "ngts-gradient-texture", never, { "attach": { "alias": "attach"; "required": false; "isSignal": true; }; "stops": { "alias": "stops"; "required": true; "isSignal": true; }; "colors": { "alias": "colors"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/abstractions/lib/grid.d.ts

@@ -0,0 +1,315 @@
+import { ElementRef } from '@angular/core';
+import { GridMaterialOptions } from 'angular-three-soba/shaders';
+import { Mesh, PlaneGeometry, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtsGrid {
+    options: import("@angular/core").InputSignalWithTransform<Partial<{
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        addEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], 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<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], 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__: [geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined, material?: import("three").Material | import("three").Material[] | 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: import("three").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: import("three").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: import("three").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: import("three").Group) => void) | undefined;
+        applyMatrix4?: ((matrix: import("three").Matrix4) => void) | undefined;
+        applyQuaternion?: ((quaternion: import("three").Quaternion) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], 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) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateOnWorldAxis?: ((axis: Vector3, angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateX?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateY?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateZ?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateOnAxis?: ((axis: Vector3, distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateX?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateY?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateZ?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], 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: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        remove?: ((...object: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        removeFromParent?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        clear?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], 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: 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: 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").MeshJSON) | undefined;
+        clone?: ((recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        copy?: ((object: import("three").Object3D, recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        hasEventListener?: (<T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>) => boolean) | undefined;
+        dispatchEvent?: (<T extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T> & import("three").Object3DEventMap[T]) => void) | undefined;
+        geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined;
+        material?: import("three").Material | import("three").Material[] | undefined;
+        readonly isMesh?: true | undefined;
+        morphTargetInfluences?: number[] | undefined;
+        morphTargetDictionary?: {
+            [key: string]: number;
+        } | undefined;
+        updateMorphTargets?: (() => void) | undefined;
+        getVertexPosition?: ((index: number, target: Vector3) => Vector3) | 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;
+    }> & GridMaterialOptions & {
+        planeArgs: ConstructorParameters<typeof PlaneGeometry>;
+    }, "" | Partial<Partial<{
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        addEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], 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<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], 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__: [geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined, material?: import("three").Material | import("three").Material[] | 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: import("three").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: import("three").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: import("three").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: import("three").Group) => void) | undefined;
+        applyMatrix4?: ((matrix: import("three").Matrix4) => void) | undefined;
+        applyQuaternion?: ((quaternion: import("three").Quaternion) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], 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) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateOnWorldAxis?: ((axis: Vector3, angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateX?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateY?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateZ?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateOnAxis?: ((axis: Vector3, distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateX?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateY?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateZ?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], 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: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        remove?: ((...object: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        removeFromParent?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        clear?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], 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: 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: 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").MeshJSON) | undefined;
+        clone?: ((recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        copy?: ((object: import("three").Object3D, recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        hasEventListener?: (<T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>) => boolean) | undefined;
+        dispatchEvent?: (<T extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T> & import("three").Object3DEventMap[T]) => void) | undefined;
+        geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined;
+        material?: import("three").Material | import("three").Material[] | undefined;
+        readonly isMesh?: true | undefined;
+        morphTargetInfluences?: number[] | undefined;
+        morphTargetDictionary?: {
+            [key: string]: number;
+        } | undefined;
+        updateMorphTargets?: (() => void) | undefined;
+        getVertexPosition?: ((index: number, target: Vector3) => Vector3) | 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;
+    }> & GridMaterialOptions & {
+        planeArgs: ConstructorParameters<typeof PlaneGeometry>;
+    }>>;
+    parameters: import("@angular/core").Signal<Omit<Partial<{
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        addEventListener: (<TEventKey extends keyof import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], 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<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>, typeof Mesh>, ev: import("angular-three").NgtNodeEventMap<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], 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__: [geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined, material?: import("three").Material | import("three").Material[] | 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: import("three").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: import("three").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: import("three").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: import("three").Group) => void) | undefined;
+        applyMatrix4?: ((matrix: import("three").Matrix4) => void) | undefined;
+        applyQuaternion?: ((quaternion: import("three").Quaternion) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], 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) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateOnWorldAxis?: ((axis: Vector3, angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateX?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateY?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        rotateZ?: ((angle: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateOnAxis?: ((axis: Vector3, distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateX?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateY?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        translateZ?: ((distance: number) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], 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: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        remove?: ((...object: import("three").Object3D[]) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        removeFromParent?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        clear?: (() => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], 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: 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: 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").MeshJSON) | undefined;
+        clone?: ((recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        copy?: ((object: import("three").Object3D, recursive?: boolean) => Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>) | undefined;
+        hasEventListener?: (<T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>) => boolean) | undefined;
+        dispatchEvent?: (<T extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T> & import("three").Object3DEventMap[T]) => void) | undefined;
+        geometry?: import("three").BufferGeometry<import("three").NormalBufferAttributes> | undefined;
+        material?: import("three").Material | import("three").Material[] | undefined;
+        readonly isMesh?: true | undefined;
+        morphTargetInfluences?: number[] | undefined;
+        morphTargetDictionary?: {
+            [key: string]: number;
+        } | undefined;
+        updateMorphTargets?: (() => void) | undefined;
+        getVertexPosition?: ((index: number, target: Vector3) => Vector3) | 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;
+    }> & GridMaterialOptions & {
+        planeArgs: ConstructorParameters<typeof PlaneGeometry>;
+    }, "side" | "planeArgs" | "cellSize" | "cellThickness" | "cellColor" | "sectionSize" | "sectionThickness" | "sectionColor" | "infiniteGrid" | "followCamera" | "fadeDistance" | "fadeStrength" | "fadeFrom">>;
+    meshRef: import("@angular/core").Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>;
+    private plane;
+    private upVector;
+    private zeroVector;
+    planeArgs: import("@angular/core").Signal<[width?: number | undefined, height?: number | undefined, widthSegments?: number | undefined, heightSegments?: number | undefined]>;
+    side: import("@angular/core").Signal<import("three").Side>;
+    uniforms: import("@angular/core").Signal<{
+        cellSize: number;
+        sectionSize: number;
+        cellColor: import("three").ColorRepresentation;
+        sectionColor: import("three").ColorRepresentation;
+        cellThickness: number;
+        sectionThickness: number;
+        fadeDistance: number;
+        fadeStrength: number;
+        fadeFrom: number;
+        infiniteGrid: boolean;
+        followCamera: boolean;
+    }>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGrid, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGrid, "ngts-grid", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/abstractions/lib/helper.d.ts

@@ -0,0 +1,25 @@
+import { ElementRef, Injector } from '@angular/core';
+import { Object3D } from 'three';
+import * as i0 from "@angular/core";
+type HelperArgs<T> = T extends [infer _, ...infer R] ? R : never;
+export declare function injectHelper<TConstructor extends new (...args: any[]) => Object3D, THelperInstance extends InstanceType<TConstructor> & {
+    update: () => void;
+    dispose: () => void;
+}>(object: () => ElementRef<Object3D> | Object3D | undefined | null, helperConstructor: () => TConstructor, { injector, args, }?: {
+    injector?: Injector;
+    args?: () => HelperArgs<ConstructorParameters<TConstructor>>;
+}): import("@angular/core").Signal<THelperInstance | null>;
+export declare class NgtsHelper<TConstructor extends new (...args: any[]) => Object3D> {
+    type: import("@angular/core").InputSignal<TConstructor>;
+    options: import("@angular/core").InputSignal<HelperArgs<ConstructorParameters<TConstructor>>>;
+    helperRef: import("@angular/core").Signal<ElementRef<Object3D<import("three").Object3DEventMap>>>;
+    private parent;
+    helper: import("@angular/core").Signal<(InstanceType<TConstructor> & {
+        update: () => void;
+        dispose: () => void;
+    }) | null>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsHelper<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsHelper<any>, "ngts-helper", never, { "type": { "alias": "type"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/abstractions/lib/line.d.ts

@@ -0,0 +1,41 @@
+import { ElementRef } from '@angular/core';
+import { NgtAfterAttach, NgtObject3DNode } from 'angular-three';
+import { ColorRepresentation, Vector2, Vector3 } from 'three';
+import { Line2, LineGeometry, LineMaterial, LineMaterialParameters, LineSegments2, LineSegmentsGeometry } from 'three-stdlib';
+import * as i0 from "@angular/core";
+export type NgtLine2 = NgtObject3DNode<Line2, typeof Line2>;
+export type NgtLineMaterial = NgtObject3DNode<LineMaterial, [LineMaterialParameters]>;
+export type NgtsLineOptions = Omit<LineMaterialParameters, 'vertexColors' | 'color'> & Omit<Partial<NgtLine2>, '__ngt_args__'> & Omit<Partial<NgtLineMaterial>, 'color' | 'vertexColors' | '__ngt_args__'> & {
+    /** Array of colors, [0, 0, 0] */
+    vertexColors?: Array<ColorRepresentation | [number, number, number] | [number, number, number, number]>;
+    /** Line width, 1 */
+    lineWidth: number;
+    /** Segments, false */
+    segments: boolean;
+    /** Color */
+    color?: ColorRepresentation;
+};
+export declare class NgtsLine {
+    points: import("@angular/core").InputSignal<(number | Vector3 | Vector2 | [number, number, number] | [number, number])[]>;
+    options: import("@angular/core").InputSignalWithTransform<NgtsLineOptions, "" | Partial<NgtsLineOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsLineOptions, "vertexColors" | "color" | "dashed" | "linewidth" | "lineWidth" | "segments">>;
+    lineRef: import("@angular/core").Signal<ElementRef<Line2 | LineSegments2> | undefined>;
+    private store;
+    private size;
+    private segments;
+    private vertexColors;
+    dashed: import("@angular/core").Signal<boolean | undefined>;
+    color: import("@angular/core").Signal<ColorRepresentation | undefined>;
+    lineWidth: import("@angular/core").Signal<number>;
+    linewidth: import("@angular/core").Signal<number | undefined>;
+    vertex: import("@angular/core").Signal<boolean>;
+    resolution: import("@angular/core").Signal<number[]>;
+    line2: import("@angular/core").Signal<LineSegments2>;
+    lineMaterial: LineMaterial;
+    itemSize: import("@angular/core").Signal<3 | 4>;
+    lineGeometry: import("@angular/core").Signal<LineSegmentsGeometry>;
+    onGeometryAttached({ parent }: NgtAfterAttach<LineGeometry, Line2 | LineSegments2>): void;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsLine, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsLine, "ngts-line", never, { "points": { "alias": "points"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/abstractions/lib/prism-geometry.d.ts

@@ -0,0 +1,32 @@
+import { ElementRef } from '@angular/core';
+import { NgtAttachable } from 'angular-three';
+import { ExtrudeGeometry, ExtrudeGeometryOptions, Shape, Vector2 } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsPrismGeometryOptions extends Omit<ExtrudeGeometryOptions, 'depth'> {
+    /** Height */
+    height: number;
+}
+export declare class NgtsPrismGeometry {
+    attach: import("@angular/core").InputSignal<NgtAttachable>;
+    vertices: import("@angular/core").InputSignal<(Vector2 | [number, number])[]>;
+    options: import("@angular/core").InputSignalWithTransform<NgtsPrismGeometryOptions, "" | Partial<NgtsPrismGeometryOptions>>;
+    parameters: import("@angular/core").Signal<{
+        depth: number;
+        /** Height */
+        height: number;
+        curveSegments?: number | undefined;
+        steps?: number | undefined;
+        bevelEnabled?: boolean | undefined;
+        bevelThickness?: number | undefined;
+        bevelSize?: number | undefined;
+        bevelOffset?: number | undefined;
+        bevelSegments?: number | undefined;
+        extrudePath?: import("three").Curve<import("three").Vector3> | undefined;
+        UVGenerator?: import("three").UVGenerator | undefined;
+    }>;
+    shape: import("@angular/core").Signal<Shape>;
+    geometryRef: import("@angular/core").Signal<ElementRef<ExtrudeGeometry> | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPrismGeometry, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsPrismGeometry, "ngts-prism-geometry", never, { "attach": { "alias": "attach"; "required": false; "isSignal": true; }; "vertices": { "alias": "vertices"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/abstractions/lib/quadratic-bezier-line.d.ts

@@ -0,0 +1,21 @@
+import { Vector3 } from 'three';
+import { NgtsLine, NgtsLineOptions } from './line';
+import * as i0 from "@angular/core";
+export interface NgtsQuadraticBezierLineOptions extends Omit<NgtsLineOptions, 'segments'> {
+    segments?: number;
+}
+export declare class NgtsQuadraticBezierLine {
+    start: import("@angular/core").InputSignal<Vector3 | [number, number, number]>;
+    end: import("@angular/core").InputSignal<Vector3 | [number, number, number]>;
+    mid: import("@angular/core").InputSignal<Vector3 | [number, number, number] | undefined>;
+    options: import("@angular/core").InputSignalWithTransform<NgtsQuadraticBezierLineOptions, "" | Partial<NgtsQuadraticBezierLineOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsQuadraticBezierLineOptions, "segments">>;
+    private segments;
+    line: import("@angular/core").Signal<NgtsLine>;
+    points: import("@angular/core").Signal<Vector3[]>;
+    private curve;
+    setPoints(start: Vector3 | [number, number, number], end: Vector3 | [number, number, number], mid: Vector3 | [number, number, number]): void;
+    private getPoints;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsQuadraticBezierLine, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsQuadraticBezierLine, "ngts-quadratic-bezier-line", never, { "start": { "alias": "start"; "required": false; "isSignal": true; }; "end": { "alias": "end"; "required": false; "isSignal": true; }; "mid": { "alias": "mid"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/abstractions/lib/rounded-box.d.ts

@@ -0,0 +1,41 @@
+import { ElementRef } from '@angular/core';
+import { NgtMesh } from 'angular-three';
+import { ExtrudeGeometry, Mesh, Shape } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsRoundedBoxOptions extends Partial<NgtMesh> {
+    width: number;
+    height: number;
+    depth: number;
+    radius: number;
+    smoothness: number;
+    bevelSegments: number;
+    steps: number;
+    creaseAngle: number;
+}
+export declare class NgtsRoundedBox {
+    options: import("@angular/core").InputSignalWithTransform<NgtsRoundedBoxOptions, "" | Partial<NgtsRoundedBoxOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsRoundedBoxOptions, "width" | "height" | "depth" | "steps" | "bevelSegments" | "radius" | "smoothness" | "creaseAngle">>;
+    private width;
+    private height;
+    private depth;
+    private radius;
+    private smoothness;
+    private bevelSegments;
+    private steps;
+    private creaseAngle;
+    meshRef: import("@angular/core").Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>;
+    geometryRef: import("@angular/core").Signal<ElementRef<ExtrudeGeometry> | undefined>;
+    shape: import("@angular/core").Signal<Shape>;
+    params: import("@angular/core").Signal<{
+        depth: number;
+        bevelEnabled: boolean;
+        bevelSegments: number;
+        steps: number;
+        bevelSize: number;
+        bevelThickness: number;
+        curveSegments: number;
+    }>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsRoundedBox, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsRoundedBox, "ngts-rounded-box", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}