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

package/fesm2022/angular-three-soba-utils.mjs

@@ -0,0 +1,22 @@
+import * as i0 from '@angular/core';
+import { inject, Injector, TemplateRef, Directive } from '@angular/core';
+
+class NgtsSobaContent {
+    constructor() {
+        this.injector = inject(Injector);
+        this.template = inject(TemplateRef);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSobaContent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtsSobaContent, isStandalone: true, selector: "ng-template[ngtsSobaContent]", exportAs: ["sobaContent"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSobaContent, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[ngtsSobaContent]', standalone: true, exportAs: 'sobaContent' }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { NgtsSobaContent };
+//# sourceMappingURL=angular-three-soba-utils.mjs.map

package/fesm2022/angular-three-soba-utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular-three-soba-utils.mjs","sources":["../../../../libs/soba/utils/src/content/content.ts","../../../../libs/soba/utils/src/angular-three-soba-utils.ts"],"sourcesContent":["import { Directive, Injector, TemplateRef, inject } from '@angular/core';\n\n@Directive({ selector: 'ng-template[ngtsSobaContent]', standalone: true, exportAs: 'sobaContent' })\nexport class NgtsSobaContent {\n\tinjector = inject(Injector);\n\ttemplate = inject(TemplateRef);\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;MAGa,eAAe,CAAA;AAD5B,IAAA,WAAA,GAAA;AAEC,QAAA,IAAA,CAAA,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;AAC5B,QAAA,IAAA,CAAA,QAAQ,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;AAC/B,KAAA;8GAHY,eAAe,EAAA,IAAA,EAAA,EAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,SAAA,EAAA,CAAA,CAAA,EAAA;kGAAf,eAAe,EAAA,YAAA,EAAA,IAAA,EAAA,QAAA,EAAA,8BAAA,EAAA,QAAA,EAAA,CAAA,aAAA,CAAA,EAAA,QAAA,EAAA,EAAA,EAAA,CAAA,CAAA,EAAA;;2FAAf,eAAe,EAAA,UAAA,EAAA,CAAA;kBAD3B,SAAS;mBAAC,EAAE,QAAQ,EAAE,8BAA8B,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,aAAa,EAAE,CAAA;;;ACFlG;;AAEG;;;;"}

package/gizmos/README.md

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

package/gizmos/gizmo-helper/gizmo-helper.d.ts

@@ -0,0 +1,69 @@
+import { EventEmitter, TemplateRef, type Signal } from '@angular/core';
+import { type NgtGroup } from 'angular-three';
+import { Group, OrthographicCamera, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+export type NgtsGizmoHelperState = {
+    alignment: 'top-left' | 'top-right' | 'bottom-right' | 'bottom-left' | 'bottom-center' | 'center-right' | 'center-left' | 'center-center' | 'top-center';
+    margin: [number, number];
+    renderPriority: number;
+    autoClear?: boolean;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-gizmo-helper': NgtsGizmoHelperState & NgtGroup;
+    }
+}
+export declare const injectNgtsGizmoHelperApi: {
+    (): {
+        tweenCamera: (direction: Vector3) => void;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false | undefined;
+    }): {
+        tweenCamera: (direction: Vector3) => void;
+    };
+    (injectOptions: import("@angular/core").InjectOptions): {
+        tweenCamera: (direction: Vector3) => void;
+    } | null;
+}, provideNgtsGizmoHelperApi: (value?: {
+    tweenCamera: (direction: Vector3) => void;
+} | undefined) => import("@angular/core").Provider;
+export declare class NgtsGizmoHelper {
+    private inputs;
+    gizmoRef: import("angular-three").NgtInjectedRef<Group>;
+    set _alignment(alignment: 'top-left' | 'top-right' | 'bottom-right' | 'bottom-left' | 'bottom-center' | 'center-right' | 'center-left' | 'center-center' | 'top-center');
+    set _margin(margin: [number, number]);
+    set _renderPriority(renderPriority: number);
+    set _autoClear(autoClear: boolean);
+    update: EventEmitter<any>;
+    content: TemplateRef<unknown>;
+    private store;
+    private mainCamera;
+    private defaultControls;
+    private invalidate;
+    private size;
+    private animating;
+    private q1;
+    private q2;
+    private turnRate;
+    private matrix;
+    private radius;
+    private focusPoint;
+    private defaultUp;
+    private target;
+    private targetPosition;
+    private dummy;
+    private margin;
+    private alignment;
+    virtualCamRef: import("angular-three").NgtInjectedRef<OrthographicCamera>;
+    renderPriority: Signal<number>;
+    gizmoPosition: Signal<number[]>;
+    api: {
+        tweenCamera: (direction: Vector3) => void;
+    };
+    constructor();
+    private trackMainCameraUp;
+    private beforeRender;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoHelper, "ngts-gizmo-helper", never, { "gizmoRef": { "alias": "gizmoRef"; "required": false; }; "_alignment": { "alias": "alignment"; "required": false; }; "_margin": { "alias": "margin"; "required": false; }; "_renderPriority": { "alias": "renderPriority"; "required": false; }; "_autoClear": { "alias": "autoClear"; "required": false; }; }, { "update": "update"; }, ["content"], never, true, never>;
+}

package/gizmos/gizmo-helper/gizmo-viewcube/gizmo-viewcube-edge.d.ts

@@ -0,0 +1,22 @@
+import { type NgtThreeEvent } from 'angular-three';
+import { Vector3 } from 'three';
+import { NgtsGizmoViewcubeInput } from './gizmo-viewcube-input';
+import * as i0 from "@angular/core";
+export declare class NgtsGizmoViewcubeEdgeCube {
+    private inputs;
+    gizmoApi: {
+        tweenCamera: (direction: Vector3) => void;
+    };
+    viewcubeInput: NgtsGizmoViewcubeInput;
+    hover: import("@angular/core").WritableSignal<boolean>;
+    set _dimensions(dimensions: [number, number, number]);
+    set _position(position: Vector3);
+    position: import("@angular/core").Signal<Vector3>;
+    dimensions: import("@angular/core").Signal<[number, number, number]>;
+    constructor();
+    onPointerMove(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerOut(event: NgtThreeEvent<PointerEvent>): void;
+    onClick(event: NgtThreeEvent<MouseEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewcubeEdgeCube, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewcubeEdgeCube, "ngts-gizmo-viewcube-edge-cube", never, { "_dimensions": { "alias": "dimensions"; "required": true; }; "_position": { "alias": "position"; "required": true; }; }, {}, never, never, true, never>;
+}

package/gizmos/gizmo-helper/gizmo-viewcube/gizmo-viewcube-face.d.ts

@@ -0,0 +1,29 @@
+import { type NgtThreeEvent } from 'angular-three';
+import { CanvasTexture } from 'three';
+import { NgtsGizmoViewcubeInput } from './gizmo-viewcube-input';
+import * as i0 from "@angular/core";
+export declare class NgtsGizmoViewcubeFaceMaterial {
+    private inputs;
+    private document;
+    private store;
+    gl: import("@angular/core").Signal<import("three").WebGLRenderer>;
+    viewcubeInput: NgtsGizmoViewcubeInput;
+    set _index(index: number);
+    set _hover(hover: boolean);
+    index: import("@angular/core").Signal<number>;
+    hover: import("@angular/core").Signal<boolean>;
+    texture: import("@angular/core").Signal<CanvasTexture>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewcubeFaceMaterial, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewcubeFaceMaterial, "ngts-gizmo-viewcube-face-material", never, { "_index": { "alias": "index"; "required": true; }; "_hover": { "alias": "hover"; "required": true; }; }, {}, never, never, true, never>;
+}
+export declare class NgtsGizmoViewcubeFaceCube {
+    private gizmoApi;
+    private viewcubeInput;
+    hover: import("@angular/core").WritableSignal<number>;
+    onPointerMove(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerOut(event: NgtThreeEvent<PointerEvent>): void;
+    onClick(event: NgtThreeEvent<MouseEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewcubeFaceCube, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewcubeFaceCube, "ngts-gizmo-viewcube-face-cube", never, {}, {}, never, never, true, never>;
+}

package/gizmos/gizmo-helper/gizmo-viewcube/gizmo-viewcube-input.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter } from '@angular/core';
+import { type NgtThreeEvent } from 'angular-three';
+import * as i0 from "@angular/core";
+export type NgtsGizmoViewCubeInputState = {
+    opacity: number;
+    hoverColor: string;
+    textColor: string;
+    strokeColor: string;
+    faces: string[];
+    font?: string;
+    color?: string;
+    clickEmitter: EventEmitter<NgtThreeEvent<MouseEvent>>;
+};
+export declare abstract class NgtsGizmoViewcubeInput {
+    inputs: import("angular-three").NgtSignalStore<NgtsGizmoViewCubeInputState>;
+    set _opacity(opacity: number);
+    set _hoverColor(hoverColor: string);
+    set _textColor(textColor: string);
+    set _strokeColor(strokeColor: string);
+    set _faces(faces: string[]);
+    set _font(font: string);
+    set _color(color: string);
+    viewcubeClick: EventEmitter<NgtThreeEvent<MouseEvent>>;
+    hoverColor: import("@angular/core").Signal<string>;
+    opacity: import("@angular/core").Signal<number>;
+    textColor: import("@angular/core").Signal<string>;
+    strokeColor: import("@angular/core").Signal<string>;
+    faces: import("@angular/core").Signal<string[]>;
+    font: import("@angular/core").Signal<string | undefined>;
+    color: import("@angular/core").Signal<string | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewcubeInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsGizmoViewcubeInput, never, never, { "_opacity": { "alias": "opacity"; "required": false; }; "_hoverColor": { "alias": "hoverColor"; "required": false; }; "_textColor": { "alias": "textColor"; "required": false; }; "_strokeColor": { "alias": "strokeColor"; "required": false; }; "_faces": { "alias": "faces"; "required": false; }; "_font": { "alias": "font"; "required": false; }; "_color": { "alias": "color"; "required": false; }; }, { "viewcubeClick": "viewcubeClick"; }, never, never, false, never>;
+}

package/gizmos/gizmo-helper/gizmo-viewcube/gizmo-viewcube.d.ts

@@ -0,0 +1,10 @@
+import { NgtsGizmoViewcubeInput } from './gizmo-viewcube-input';
+import * as i0 from "@angular/core";
+export declare class NgtsGizmoViewcube extends NgtsGizmoViewcubeInput {
+    edges: import("three").Vector3[];
+    edgeDimensions: [number, number, number][];
+    corners: import("three").Vector3[];
+    cornerDimensions: [number, number, number];
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewcube, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewcube, "ngts-gizmo-viewcube", never, {}, {}, never, never, true, never>;
+}

package/gizmos/gizmo-helper/gizmo-viewport/gizmo-viewport-axis.d.ts

@@ -0,0 +1,40 @@
+import { EventEmitter } from '@angular/core';
+import { type NgtThreeEvent } from 'angular-three';
+import { CanvasTexture } from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtsGizmoViewportAxis {
+    private inputs;
+    set _color(color: string);
+    set _rotation(rotation: [number, number, number]);
+    set _scale(scale: [number, number, number]);
+    rotation: import("@angular/core").Signal<[number, number, number]>;
+    color: import("@angular/core").Signal<string>;
+    scale: import("@angular/core").Signal<[number, number, number]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewportAxis, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewportAxis, "ngts-gizmo-viewport-axis", never, { "_color": { "alias": "color"; "required": true; }; "_rotation": { "alias": "rotation"; "required": true; }; "_scale": { "alias": "scale"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class NgtsGizmoViewportAxisHead {
+    private inputs;
+    private document;
+    private store;
+    capabilities: import("@angular/core").Signal<import("three").WebGLCapabilities>;
+    set _arcStyle(arcStyle: string);
+    set _label(label: string);
+    set _labelColor(labelColor: string);
+    set _axisHeadScale(axisHeadScale: number);
+    set _disabled(disabled: boolean);
+    set _font(font: string);
+    viewportClickEmitter?: EventEmitter<NgtThreeEvent<MouseEvent>>;
+    active: import("@angular/core").WritableSignal<boolean>;
+    private arcStyle;
+    private labelColor;
+    private font;
+    private axisHeadScale;
+    label: import("@angular/core").Signal<string>;
+    texture: import("@angular/core").Signal<CanvasTexture>;
+    scale: import("@angular/core").Signal<number>;
+    onPointerOver(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerOut(event: NgtThreeEvent<PointerEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewportAxisHead, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewportAxisHead, "ngts-gizmo-viewport-axis-head", never, { "_arcStyle": { "alias": "arcStyle"; "required": false; }; "_label": { "alias": "label"; "required": false; }; "_labelColor": { "alias": "labelColor"; "required": false; }; "_axisHeadScale": { "alias": "axisHeadScale"; "required": false; }; "_disabled": { "alias": "disabled"; "required": false; }; "_font": { "alias": "font"; "required": false; }; "viewportClickEmitter": { "alias": "viewportClickEmitter"; "required": false; }; }, {}, never, never, true, never>;
+}

package/gizmos/gizmo-helper/gizmo-viewport/gizmo-viewport.d.ts

@@ -0,0 +1,30 @@
+import { EventEmitter } from '@angular/core';
+import { type NgtThreeEvent } from 'angular-three';
+import * as i0 from "@angular/core";
+export declare class NgtsGizmoViewport {
+    private inputs;
+    private gizmoApi;
+    Math: Math;
+    set _axisColors(axisColors: [string, string, string]);
+    set _axisScale(axisScale: [number, number, number]);
+    set _labels(labels: [string, string, string]);
+    set _axisHeadScale(axisHeadScale: number);
+    set _labelColor(labelColor: string);
+    set _hideNegativeAxes(hideNegativeAxes: boolean);
+    set _hideAxisHeads(hideAxisHeads: boolean);
+    set _disabled(disabled: boolean);
+    set _font(font: string);
+    viewportClick: EventEmitter<NgtThreeEvent<MouseEvent>>;
+    axisColors: import("@angular/core").Signal<[string, string, string]>;
+    axisScale: import("@angular/core").Signal<[number, number, number]>;
+    labels: import("@angular/core").Signal<[string, string, string]>;
+    axisHeadScale: import("@angular/core").Signal<number>;
+    labelColor: import("@angular/core").Signal<string>;
+    hideNegativeAxes: import("@angular/core").Signal<boolean>;
+    hideAxisHeads: import("@angular/core").Signal<boolean>;
+    disabled: import("@angular/core").Signal<boolean>;
+    font: import("@angular/core").Signal<string>;
+    onPointerDown(event: NgtThreeEvent<PointerEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewport, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewport, "ngts-gizmo-viewport", never, { "_axisColors": { "alias": "axisColors"; "required": false; }; "_axisScale": { "alias": "axisScale"; "required": false; }; "_labels": { "alias": "labels"; "required": false; }; "_axisHeadScale": { "alias": "axisHeadScale"; "required": false; }; "_labelColor": { "alias": "labelColor"; "required": false; }; "_hideNegativeAxes": { "alias": "hideNegativeAxes"; "required": false; }; "_hideAxisHeads": { "alias": "hideAxisHeads"; "required": false; }; "_disabled": { "alias": "disabled"; "required": false; }; "_font": { "alias": "font"; "required": false; }; }, { "viewportClick": "viewportClick"; }, never, never, true, never>;
+}

package/gizmos/index.d.ts

@@ -0,0 +1,3 @@
+export * from './gizmo-helper/gizmo-helper';
+export * from './gizmo-helper/gizmo-viewcube/gizmo-viewcube';
+export * from './gizmo-helper/gizmo-viewport/gizmo-viewport';

package/loaders/gltf-loader/gltf-loader.d.ts

@@ -1,9 +1,10 @@
-import { Injector, Signal } from '@angular/core';
+import type { Injector, Signal } from '@angular/core';
 import { type NgtLoaderResults, type NgtObjectMap } from 'angular-three';
-import { GLTF, GLTFLoader } from 'three-stdlib/loaders/GLTFLoader';
+import { GLTFLoader, type GLTF } from 'three-stdlib';
+export type NgtsGLTF<T extends Partial<NgtObjectMap>> = GLTF & NgtObjectMap & T;
 export declare function injectNgtsGLTFLoader<TUrl extends string | string[] | Record<string, string>>(path: () => TUrl, { useDraco, useMeshOpt, injector, extensions, }?: {
     useDraco?: boolean | string;
     useMeshOpt?: boolean;
     injector?: Injector;
     extensions?: (loader: GLTFLoader) => void;
-}): Signal<NgtLoaderResults<TUrl, GLTF & NgtObjectMap>>;
+}): Signal<NgtLoaderResults<TUrl, GLTF & NgtObjectMap> | null>;

package/loaders/loader/loader.d.ts

@@ -1,5 +1,4 @@
 import { ElementRef } from '@angular/core';
-import { NgtSignalStore } from 'angular-three';
 import * as i0 from "@angular/core";
 export interface NgtsLoaderState {
     containerClass?: string;
@@ -9,23 +8,26 @@ export interface NgtsLoaderState {
     dataInterpolation: (value: number) => string;
     initialState: (value: boolean) => boolean;
 }
-export declare class NgtsLoader extends NgtSignalStore<NgtsLoaderState> {
-    #private;
-    readonly active: import("@angular/core").Signal<boolean>;
-    readonly progress: import("@angular/core").Signal<number>;
-    readonly container: import("@angular/core").Signal<string | undefined>;
-    readonly inner: import("@angular/core").Signal<string | undefined>;
-    readonly bar: import("@angular/core").Signal<string | undefined>;
-    readonly data: import("@angular/core").Signal<string | undefined>;
-    set containerClass(containerClass: string);
-    set innerClass(innerClass: string);
-    set barClass(barClass: string);
-    set dataClass(dataClass: string);
-    set dataInterpolation(dataInterpolation: (value: number) => string);
-    set initialState(initialState: (value: boolean) => boolean);
+export declare class NgtsLoader {
+    private inputs;
+    private progressState;
+    active: import("@angular/core").Signal<boolean>;
+    progress: import("@angular/core").Signal<number>;
+    container: import("@angular/core").Signal<string | undefined>;
+    inner: import("@angular/core").Signal<string | undefined>;
+    bar: import("@angular/core").Signal<string | undefined>;
+    data: import("@angular/core").Signal<string | undefined>;
+    set _containerClass(containerClass: string);
+    set _innerClass(innerClass: string);
+    set _barClass(barClass: string);
+    set _dataClass(dataClass: string);
+    set _dataInterpolation(dataInterpolation: (value: number) => string);
+    set _initialState(initialState: (value: boolean) => boolean);
     progressSpanRef?: ElementRef<HTMLSpanElement>;
-    readonly shown: import("@angular/core").WritableSignal<boolean>;
+    shown: import("@angular/core").WritableSignal<boolean>;
     constructor();
+    private setShown;
+    private updateProgress;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsLoader, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsLoader, "ngts-loader", never, { "containerClass": { "alias": "containerClass"; "required": false; }; "innerClass": { "alias": "innerClass"; "required": false; }; "barClass": { "alias": "barClass"; "required": false; }; "dataClass": { "alias": "dataClass"; "required": false; }; "dataInterpolation": { "alias": "dataInterpolation"; "required": false; }; "initialState": { "alias": "initialState"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsLoader, "ngts-loader", never, { "_containerClass": { "alias": "containerClass"; "required": false; }; "_innerClass": { "alias": "innerClass"; "required": false; }; "_barClass": { "alias": "barClass"; "required": false; }; "_dataClass": { "alias": "dataClass"; "required": false; }; "_dataInterpolation": { "alias": "dataInterpolation"; "required": false; }; "_initialState": { "alias": "initialState"; "required": false; }; }, {}, never, never, true, never>;
 }

package/loaders/progress/progress.d.ts

@@ -1,4 +1,4 @@
-import { Injector } from '@angular/core';
+import { type Injector } from '@angular/core';
 export declare function injectNgtsProgress(injector?: Injector): import("@angular/core").Signal<{
     errors: string[];
     active: boolean;

package/loaders/texture-loader/texture-loader.d.ts

@@ -1,7 +1,7 @@
-import { Injector, type Signal } from '@angular/core';
+import { type Injector, type Signal } from '@angular/core';
 import { type NgtLoaderResults } from 'angular-three';
 import * as THREE from 'three';
 export declare function injectNgtsTextureLoader<TInput extends string[] | string | Record<string, string>>(input: () => TInput, { onLoad, injector, }?: {
     onLoad?: (texture: THREE.Texture | THREE.Texture[]) => void;
     injector?: Injector;
-}): Signal<NgtLoaderResults<TInput, THREE.Texture>>;
+}): Signal<NgtLoaderResults<TInput, THREE.Texture> | null>;

package/materials/index.d.ts

@@ -3,3 +3,4 @@ export * from './mesh-reflector-material/mesh-reflector-material';
 export * from './mesh-refraction-material/mesh-refraction-material';
 export * from './mesh-transmission-material/mesh-transmission-material';
 export * from './mesh-wobble-material/mesh-wobble-material';
+export * from './point-material/point-material';

package/materials/mesh-distort-material/mesh-distort-material.d.ts

@@ -1,30 +1,40 @@
-import { NgtSignalStore } from 'angular-three';
+import { type NgtMeshPhysicalMaterial } from 'angular-three';
 import * as i0 from "@angular/core";
-export interface NgtsMeshDistortMaterialState {
+export type NgtsMeshDistortMaterialState = {
     time: number;
     distort: number;
     radius: number;
     speed: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-mesh-physical-material
+         */
+        'ngts-mesh-distort-material': NgtsMeshDistortMaterialState & NgtMeshPhysicalMaterial;
+    }
 }
-export declare class NgtsMeshDistortMaterial extends NgtSignalStore<NgtsMeshDistortMaterialState> {
-    readonly material: {
+export declare class NgtsMeshDistortMaterial {
+    private inputs;
+    materialRef: import("angular-three").NgtInjectedRef<{
         time: number;
         distort: number;
         radius: number;
-    } & import("three").MeshPhysicalMaterial;
-    materialRef: import("angular-three").NgtInjectedRef<{
+    } & import("three").MeshPhysicalMaterial>;
+    set _time(time: number);
+    set _distort(distort: number);
+    set _radius(radius: number);
+    set _speed(speed: number);
+    private MeshDistortMaterial;
+    material: {
         time: number;
         distort: number;
         radius: number;
-    } & import("three").MeshPhysicalMaterial>;
-    set time(time: number);
-    set distort(distort: number);
-    set radius(radius: number);
-    set speed(speed: number);
-    readonly distortTime: import("@angular/core").Signal<number>;
-    readonly distortDistort: import("@angular/core").Signal<number>;
-    readonly distortRadius: import("@angular/core").Signal<number>;
+    } & import("three").MeshPhysicalMaterial;
+    time: import("@angular/core").Signal<number>;
+    distort: import("@angular/core").Signal<number>;
+    radius: import("@angular/core").Signal<number>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshDistortMaterial, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshDistortMaterial, "ngts-mesh-distort-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "time": { "alias": "time"; "required": false; }; "distort": { "alias": "distort"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "speed": { "alias": "speed"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshDistortMaterial, "ngts-mesh-distort-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "_time": { "alias": "time"; "required": false; }; "_distort": { "alias": "distort"; "required": false; }; "_radius": { "alias": "radius"; "required": false; }; "_speed": { "alias": "speed"; "required": false; }; }, {}, never, never, true, never>;
 }

package/materials/mesh-reflector-material/mesh-reflector-material.d.ts

@@ -1,8 +1,8 @@
-import { NgtSignalStore } from 'angular-three';
+import { type NgtMeshStandardMaterial } from 'angular-three';
 import { MeshReflectorMaterial } from 'angular-three-soba/shaders';
 import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export interface NgtsMeshReflectorMaterialState {
+export type NgtsMeshReflectorMaterialState = {
     resolution: number;
     mixBlur: number;
     mixStrength: number;
@@ -16,66 +16,84 @@ export interface NgtsMeshReflectorMaterialState {
     distortion: number;
     mixContrast: number;
     reflectorOffset: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-mesh-standard-material
+         */
+        'ngts-mesh-reflector-material': NgtsMeshReflectorMaterialState & NgtMeshStandardMaterial;
+    }
 }
-export declare class NgtsMeshReflectorMaterial extends NgtSignalStore<NgtsMeshReflectorMaterialState> {
-    #private;
+export declare class NgtsMeshReflectorMaterial {
+    private inputs;
     materialRef: import("angular-three").NgtInjectedRef<MeshReflectorMaterial>;
-    set resolution(resolution: number);
-    set mixBlur(mixBlur: number);
-    set mixStrength(mixStrength: number);
-    set blur(blur: [number, number] | number);
-    set mirror(mirror: number);
-    set minDepthThreshold(minDepthThreshold: number);
-    set maxDepthThreshold(maxDepthThreshold: number);
-    set depthScale(depthScale: number);
-    set depthToBlurRatioBias(depthToBlurRatioBias: number);
-    set distortionMap(distortionMap: THREE.Texture);
-    set distortion(distortion: number);
-    set mixContrast(mixContrast: number);
-    set reflectorOffset(reflectorOffset: number);
-    readonly reflectorProps: import("@angular/core").Signal<{
-        mirror: number;
-        textureMatrix: THREE.Matrix4;
-        mixBlur: number;
-        tDiffuse: THREE.Texture;
-        tDepth: THREE.DepthTexture;
-        tDiffuseBlur: THREE.Texture;
-        hasBlur: boolean;
-        mixStrength: number;
-        minDepthThreshold: number;
-        maxDepthThreshold: number;
-        depthScale: number;
-        depthToBlurRatioBias: number;
-        distortion: number;
-        distortionMap: THREE.Texture | undefined;
-        mixContrast: number;
-        defines: {
-            USE_BLUR: string | undefined;
-            USE_DEPTH: string | undefined;
-            USE_DISTORTION: string | undefined;
-        };
-    }>;
-    readonly defines: import("@angular/core").Signal<{
+    set _resolution(resolution: number);
+    set _mixBlur(mixBlur: number);
+    set _mixStrength(mixStrength: number);
+    set _blur(blur: [number, number] | number);
+    set _mirror(mirror: number);
+    set _minDepthThreshold(minDepthThreshold: number);
+    set _maxDepthThreshold(maxDepthThreshold: number);
+    set _depthScale(depthScale: number);
+    set _depthToBlurRatioBias(depthToBlurRatioBias: number);
+    set _distortionMap(distortionMap: THREE.Texture);
+    set _distortion(distortion: number);
+    set _mixContrast(mixContrast: number);
+    set _reflectorOffset(reflectorOffset: number);
+    private reflectorProps;
+    defines: import("@angular/core").Signal<{
         USE_BLUR: string | undefined;
         USE_DEPTH: string | undefined;
         USE_DISTORTION: string | undefined;
     }>;
-    readonly reflectorMirror: import("@angular/core").Signal<number>;
-    readonly reflectorTextureMatrix: import("@angular/core").Signal<THREE.Matrix4>;
-    readonly reflectorMixBlur: import("@angular/core").Signal<number>;
-    readonly reflectorTDiffuse: import("@angular/core").Signal<THREE.Texture>;
-    readonly reflectorTDepth: import("@angular/core").Signal<THREE.DepthTexture>;
-    readonly reflectorTDiffuseBlur: import("@angular/core").Signal<THREE.Texture>;
-    readonly reflectorHasBlur: import("@angular/core").Signal<boolean>;
-    readonly reflectorMixStrength: import("@angular/core").Signal<number>;
-    readonly reflectorMinDepthThreshold: import("@angular/core").Signal<number>;
-    readonly reflectorMaxDepthThreshold: import("@angular/core").Signal<number>;
-    readonly reflectorDepthScale: import("@angular/core").Signal<number>;
-    readonly reflectorDepthToBlurRatioBias: import("@angular/core").Signal<number>;
-    readonly reflectorDistortion: import("@angular/core").Signal<number>;
-    readonly reflectorDistortionMap: import("@angular/core").Signal<THREE.Texture | undefined>;
-    readonly reflectorMixContrast: import("@angular/core").Signal<number>;
+    mirror: import("@angular/core").Signal<number>;
+    textureMatrix: import("@angular/core").Signal<THREE.Matrix4>;
+    mixBlur: import("@angular/core").Signal<number>;
+    tDiffuse: import("@angular/core").Signal<THREE.Texture>;
+    tDepth: import("@angular/core").Signal<THREE.DepthTexture>;
+    tDiffuseBlur: import("@angular/core").Signal<THREE.Texture>;
+    hasBlur: import("@angular/core").Signal<boolean>;
+    mixStrength: import("@angular/core").Signal<number>;
+    minDepthThreshold: import("@angular/core").Signal<number>;
+    maxDepthThreshold: import("@angular/core").Signal<number>;
+    depthScale: import("@angular/core").Signal<number>;
+    depthToBlurRatioBias: import("@angular/core").Signal<number>;
+    distortion: import("@angular/core").Signal<number>;
+    distortionMap: import("@angular/core").Signal<THREE.Texture | undefined>;
+    mixContrast: import("@angular/core").Signal<number>;
+    private store;
+    private gl;
+    private reflectorPlane;
+    private normal;
+    private reflectorWorldPosition;
+    private cameraWorldPosition;
+    private rotationMatrix;
+    private lookAtPosition;
+    private clipPlane;
+    private view;
+    private target;
+    private q;
+    private virtualCamera;
+    private _textureMatrix;
+    private __blur;
+    private __resolution;
+    private __mirror;
+    private __mixBlur;
+    private __mixStrength;
+    private __minDepthThreshold;
+    private __maxDepthThreshold;
+    private __depthScale;
+    private __depthToBlurRatioBias;
+    private __distortion;
+    private __distortionMap;
+    private __mixContrast;
+    private normalizedBlur;
+    private __hasBlur;
+    private states;
     constructor();
+    private onBeforeRender;
+    private beforeRender;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshReflectorMaterial, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshReflectorMaterial, "ngts-mesh-reflector-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "resolution": { "alias": "resolution"; "required": false; }; "mixBlur": { "alias": "mixBlur"; "required": false; }; "mixStrength": { "alias": "mixStrength"; "required": false; }; "blur": { "alias": "blur"; "required": false; }; "mirror": { "alias": "mirror"; "required": false; }; "minDepthThreshold": { "alias": "minDepthThreshold"; "required": false; }; "maxDepthThreshold": { "alias": "maxDepthThreshold"; "required": false; }; "depthScale": { "alias": "depthScale"; "required": false; }; "depthToBlurRatioBias": { "alias": "depthToBlurRatioBias"; "required": false; }; "distortionMap": { "alias": "distortionMap"; "required": false; }; "distortion": { "alias": "distortion"; "required": false; }; "mixContrast": { "alias": "mixContrast"; "required": false; }; "reflectorOffset": { "alias": "reflectorOffset"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshReflectorMaterial, "ngts-mesh-reflector-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "_resolution": { "alias": "resolution"; "required": false; }; "_mixBlur": { "alias": "mixBlur"; "required": false; }; "_mixStrength": { "alias": "mixStrength"; "required": false; }; "_blur": { "alias": "blur"; "required": false; }; "_mirror": { "alias": "mirror"; "required": false; }; "_minDepthThreshold": { "alias": "minDepthThreshold"; "required": false; }; "_maxDepthThreshold": { "alias": "maxDepthThreshold"; "required": false; }; "_depthScale": { "alias": "depthScale"; "required": false; }; "_depthToBlurRatioBias": { "alias": "depthToBlurRatioBias"; "required": false; }; "_distortionMap": { "alias": "distortionMap"; "required": false; }; "_distortion": { "alias": "distortion"; "required": false; }; "_mixContrast": { "alias": "mixContrast"; "required": false; }; "_reflectorOffset": { "alias": "reflectorOffset"; "required": false; }; }, {}, never, ["*"], true, never>;
 }