angular-three-soba 2.0.0-beta.7 → 2.0.0-beta.8

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.1.7", ngImport: i0, type: NgtsSobaContent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.7", type: NgtsSobaContent, isStandalone: true, selector: "ng-template[ngtsSobaContent]", exportAs: ["sobaContent"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", 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/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 { GLTF, GLTFLoader } 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 { 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>;
 }

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

@@ -1,6 +1,7 @@
-import { NgtSignalStore } from 'angular-three';
+import { type NgtShaderMaterial } from 'angular-three';
+import { NgtsMeshTranmissionMaterialState } from '../mesh-transmission-material/mesh-transmission-material';
 import * as i0 from "@angular/core";
-export interface NgtsMeshRefractionMaterialState {
+export type NgtsMeshRefractionMaterialState = {
     /** Environment map */
     envMap: THREE.CubeTexture | THREE.Texture;
     /** Number of ray-cast bounces, it can be expensive to have too many, 2 */
@@ -15,36 +16,47 @@ export interface NgtsMeshRefractionMaterialState {
     color: THREE.ColorRepresentation;
     /** If this is on it uses fewer ray casts for the RGB shift sacrificing physical accuracy, true */
     fastChroma: boolean;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-shader-material
+         */
+        'ngts-mesh-refraction-material': NgtsMeshTranmissionMaterialState & NgtShaderMaterial;
+    }
 }
-export declare class NgtsMeshRefractionMaterial extends NgtSignalStore<NgtsMeshRefractionMaterialState> {
-    #private;
+export declare class NgtsMeshRefractionMaterial {
+    private inputs;
     materialRef: import("angular-three").NgtInjectedRef<import("three").ShaderMaterial>;
     /** Environment map */
-    set envMap(envMap: THREE.CubeTexture | THREE.Texture);
+    set _envMap(envMap: THREE.CubeTexture | THREE.Texture);
     /** Number of ray-cast bounces, it can be expensive to have too many, 2 */
-    set bounces(bounces: number);
+    set _bounces(bounces: number);
     /** Refraction index, 2.4 */
-    set ior(ior: number);
+    set _ior(ior: number);
     /** Fresnel (strip light), 0 */
-    set fresnel(fresnel: number);
+    set _fresnel(fresnel: number);
     /** RGB shift intensity, can be expensive, 0 */
-    set aberrationStrength(aberrationStrength: number);
+    set _aberrationStrength(aberrationStrength: number);
     /** Color, white */
-    set color(color: THREE.ColorRepresentation);
+    set _color(color: THREE.ColorRepresentation);
     /** If this is on it uses fewer ray casts for the RGB shift sacrificing physical accuracy, true */
-    set fastChroma(fastChroma: boolean);
-    readonly refractionEnvMap: import("@angular/core").Signal<import("three").Texture | import("three").CubeTexture>;
-    readonly refractionBounces: import("@angular/core").Signal<number>;
-    readonly refractionIor: import("@angular/core").Signal<number>;
-    readonly refractionFresnel: import("@angular/core").Signal<number>;
-    readonly refractionAberrationStrength: import("@angular/core").Signal<number>;
-    readonly refractionColor: import("@angular/core").Signal<import("three").ColorRepresentation>;
-    readonly refractionFastChroma: import("@angular/core").Signal<boolean>;
-    readonly defines: import("@angular/core").Signal<{
+    set _fastChroma(fastChroma: boolean);
+    envMap: import("@angular/core").Signal<import("three").Texture | import("three").CubeTexture>;
+    bounces: import("@angular/core").Signal<number>;
+    ior: import("@angular/core").Signal<number>;
+    fresnel: import("@angular/core").Signal<number>;
+    aberrationStrength: import("@angular/core").Signal<number>;
+    color: import("@angular/core").Signal<import("three").ColorRepresentation>;
+    fastChroma: import("@angular/core").Signal<boolean>;
+    private store;
+    private size;
+    defines: import("@angular/core").Signal<{
         [key: string]: string;
     } | null>;
-    readonly resolution: import("@angular/core").Signal<number[]>;
+    resolution: import("@angular/core").Signal<number[]>;
     constructor();
+    private setupGeometry;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshRefractionMaterial, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshRefractionMaterial, "ngts-mesh-refraction-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "envMap": { "alias": "envMap"; "required": true; }; "bounces": { "alias": "bounces"; "required": false; }; "ior": { "alias": "ior"; "required": false; }; "fresnel": { "alias": "fresnel"; "required": false; }; "aberrationStrength": { "alias": "aberrationStrength"; "required": false; }; "color": { "alias": "color"; "required": false; }; "fastChroma": { "alias": "fastChroma"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshRefractionMaterial, "ngts-mesh-refraction-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "_envMap": { "alias": "envMap"; "required": true; }; "_bounces": { "alias": "bounces"; "required": false; }; "_ior": { "alias": "ior"; "required": false; }; "_fresnel": { "alias": "fresnel"; "required": false; }; "_aberrationStrength": { "alias": "aberrationStrength"; "required": false; }; "_color": { "alias": "color"; "required": false; }; "_fastChroma": { "alias": "fastChroma"; "required": false; }; }, {}, never, ["*"], true, never>;
 }

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

@@ -1,8 +1,8 @@
-import { NgtSignalStore } from 'angular-three';
+import { type NgtMeshPhysicalMaterial } from 'angular-three';
 import { MeshTransmissionMaterial } from 'angular-three-soba/shaders';
 import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export interface NgtsMeshTranmissionMaterialState {
+export type NgtsMeshTranmissionMaterialState = {
     /** transmissionSampler, you can use the threejs transmission sampler texture that is
      *  generated once for all transmissive materials. The upside is that it can be faster if you
      *  use multiple MeshPhysical and Transmission materials, the downside is that transmissive materials
@@ -25,6 +25,7 @@ export interface NgtsMeshTranmissionMaterialState {
     roughness: number;
     chromaticAberration: number;
     anisotropy: number;
+    anisotropicBlur: number;
     distortion: number;
     distortionScale: number;
     temporalDistortion: number;
@@ -32,9 +33,17 @@ export interface NgtsMeshTranmissionMaterialState {
     buffer: THREE.Texture | null;
     /** Internals */
     time: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-mesh-physical-material
+         */
+        'ngts-mesh-transmission-material': NgtsMeshTranmissionMaterialState & NgtMeshPhysicalMaterial;
+    }
 }
-export declare class NgtsMeshTranmissionMaterial extends NgtSignalStore<NgtsMeshTranmissionMaterialState> {
-    #private;
+export declare class NgtsMeshTranmissionMaterial {
+    private inputs;
     materialRef: import("angular-three").NgtInjectedRef<MeshTransmissionMaterial & {
         time: number;
         buffer?: THREE.Texture | undefined;
@@ -43,49 +52,56 @@ export declare class NgtsMeshTranmissionMaterial extends NgtSignalStore<NgtsMesh
      *  generated once for all transmissive materials. The upside is that it can be faster if you
      *  use multiple MeshPhysical and Transmission materials, the downside is that transmissive materials
      *  using this can't see other transparent or transmissive objects, default: false */
-    set transmissionSampler(transmissionSampler: boolean);
+    set _transmissionSampler(transmissionSampler: boolean);
     /** Render the backside of the material (more cost, better results), default: false */
-    set backside(backside: boolean);
+    set _backside(backside: boolean);
     /** Backside thickness (when backside is true), default: 0 */
-    set backsideThickness(backsideThickness: number);
+    set _backsideThickness(backsideThickness: number);
     /** Resolution of the local buffer, default: undefined (fullscreen) */
-    set resolution(resolution: number);
+    set _resolution(resolution: number);
     /** Resolution of the local buffer for backfaces, default: undefined (fullscreen) */
-    set backsideResolution(backsideResolution: number);
+    set _backsideResolution(backsideResolution: number);
     /** Refraction samples, default: 10 */
-    set samples(samples: number);
+    set _samples(samples: number);
     /** Buffer scene background (can be a texture, a cubetexture or a color), default: null */
-    set background(background: THREE.Texture | THREE.Color);
-    set transmission(transmission: number);
-    set thickness(thickness: number);
-    set roughness(roughness: number);
-    set chromaticAberration(chromaticAberration: number);
-    set anisotropy(anisotropy: number);
-    set distortion(distortion: number);
-    set distortionScale(distortionScale: number);
-    set temporalDistortion(temporalDistortion: number);
+    set _background(background: THREE.Texture | THREE.Color);
+    set _transmission(transmission: number);
+    set _thickness(thickness: number);
+    set _roughness(roughness: number);
+    set _chromaticAberration(chromaticAberration: number);
+    set _anisotropy(anisotropy: number);
+    set _anisotropicBlur(anisotropicBlur: number);
+    set _distortion(distortion: number);
+    set _distortionScale(distortionScale: number);
+    set _temporalDistortion(temporalDistortion: number);
     /** The scene rendered into a texture (use it to share a texture between materials), default: null  */
-    set buffer(buffer: THREE.Texture);
+    set _buffer(buffer: THREE.Texture);
     /** Internals */
-    set time(time: number);
-    readonly transmissionTransmissionSampler: import("@angular/core").Signal<boolean>;
-    readonly transmissionBackside: import("@angular/core").Signal<boolean>;
-    readonly transmissionTransmission: import("@angular/core").Signal<number>;
-    readonly transmissionThickness: import("@angular/core").Signal<number>;
-    readonly transmissionBacksideThickness: import("@angular/core").Signal<number>;
-    readonly transmissionSamples: import("@angular/core").Signal<number>;
-    readonly transmissionRoughness: import("@angular/core").Signal<number>;
-    readonly transmissionAnisotropy: import("@angular/core").Signal<number>;
-    readonly transmissionChromaticAberration: import("@angular/core").Signal<number>;
-    readonly transmissionDistortion: import("@angular/core").Signal<number>;
-    readonly transmissionDistortionScale: import("@angular/core").Signal<number>;
-    readonly transmissionTemporalDistortion: import("@angular/core").Signal<number>;
-    readonly transmissionBuffer: import("@angular/core").Signal<THREE.Texture | null>;
-    readonly transmissionTime: import("@angular/core").Signal<number>;
-    readonly fboBackRef: import("@angular/core").Signal<THREE.WebGLRenderTarget>;
-    readonly fboMainRef: import("@angular/core").Signal<THREE.WebGLRenderTarget>;
-    readonly side: 0;
+    set _time(time: number);
+    transmissionSampler: import("@angular/core").Signal<boolean>;
+    backside: import("@angular/core").Signal<boolean>;
+    transmission: import("@angular/core").Signal<number>;
+    thickness: import("@angular/core").Signal<number>;
+    backsideThickness: import("@angular/core").Signal<number>;
+    samples: import("@angular/core").Signal<number>;
+    roughness: import("@angular/core").Signal<number>;
+    anisotropy: import("@angular/core").Signal<number>;
+    anisotropicBlur: import("@angular/core").Signal<number>;
+    chromaticAberration: import("@angular/core").Signal<number>;
+    distortion: import("@angular/core").Signal<number>;
+    distortionScale: import("@angular/core").Signal<number>;
+    temporalDistortion: import("@angular/core").Signal<number>;
+    buffer: import("@angular/core").Signal<THREE.Texture | null>;
+    time: import("@angular/core").Signal<number>;
+    private discardMaterial;
+    private backsideResolution;
+    private resolution;
+    private fboBackSettings;
+    private fboMainSettings;
+    fboBackRef: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget<THREE.Texture> | null>;
+    fboMainRef: import("angular-three").NgtInjectedRef<THREE.WebGLRenderTarget<THREE.Texture> | null>;
+    side: 0;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshTranmissionMaterial, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshTranmissionMaterial, "ngts-mesh-transmission-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "transmissionSampler": { "alias": "transmissionSampler"; "required": false; }; "backside": { "alias": "backside"; "required": false; }; "backsideThickness": { "alias": "backsideThickness"; "required": false; }; "resolution": { "alias": "resolution"; "required": false; }; "backsideResolution": { "alias": "backsideResolution"; "required": false; }; "samples": { "alias": "samples"; "required": false; }; "background": { "alias": "background"; "required": false; }; "transmission": { "alias": "transmission"; "required": false; }; "thickness": { "alias": "thickness"; "required": false; }; "roughness": { "alias": "roughness"; "required": false; }; "chromaticAberration": { "alias": "chromaticAberration"; "required": false; }; "anisotropy": { "alias": "anisotropy"; "required": false; }; "distortion": { "alias": "distortion"; "required": false; }; "distortionScale": { "alias": "distortionScale"; "required": false; }; "temporalDistortion": { "alias": "temporalDistortion"; "required": false; }; "buffer": { "alias": "buffer"; "required": false; }; "time": { "alias": "time"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshTranmissionMaterial, "ngts-mesh-transmission-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "_transmissionSampler": { "alias": "transmissionSampler"; "required": false; }; "_backside": { "alias": "backside"; "required": false; }; "_backsideThickness": { "alias": "backsideThickness"; "required": false; }; "_resolution": { "alias": "resolution"; "required": false; }; "_backsideResolution": { "alias": "backsideResolution"; "required": false; }; "_samples": { "alias": "samples"; "required": false; }; "_background": { "alias": "background"; "required": false; }; "_transmission": { "alias": "transmission"; "required": false; }; "_thickness": { "alias": "thickness"; "required": false; }; "_roughness": { "alias": "roughness"; "required": false; }; "_chromaticAberration": { "alias": "chromaticAberration"; "required": false; }; "_anisotropy": { "alias": "anisotropy"; "required": false; }; "_anisotropicBlur": { "alias": "anisotropicBlur"; "required": false; }; "_distortion": { "alias": "distortion"; "required": false; }; "_distortionScale": { "alias": "distortionScale"; "required": false; }; "_temporalDistortion": { "alias": "temporalDistortion"; "required": false; }; "_buffer": { "alias": "buffer"; "required": false; }; "_time": { "alias": "time"; "required": false; }; }, {}, never, never, true, never>;
 }

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

@@ -1,20 +1,29 @@
-import { NgtSignalStore } from 'angular-three';
+import { type NgtMeshStandardMaterial } from 'angular-three';
 import { MeshWobbleMaterial } from 'angular-three-soba/shaders';
 import * as i0 from "@angular/core";
-export interface NgtsMeshWobbleMaterialState {
+export type NgtsMeshWobbleMaterialState = {
     time: number;
     factor: number;
     speed: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-mesh-standard-material
+         */
+        'ngts-mesh-wobble-material': NgtsMeshWobbleMaterialState & NgtMeshStandardMaterial;
+    }
 }
-export declare class NgtsMeshWobbleMaterial extends NgtSignalStore<NgtsMeshWobbleMaterialState> {
-    readonly material: MeshWobbleMaterial;
+export declare class NgtsMeshWobbleMaterial {
+    private inputs;
     materialRef: import("angular-three").NgtInjectedRef<MeshWobbleMaterial>;
-    set time(time: number);
-    set factor(factor: number);
-    set speed(speed: number);
-    readonly wobbleTime: import("@angular/core").Signal<number>;
-    readonly wobbleFactor: import("@angular/core").Signal<number>;
+    set _time(time: number);
+    set _factor(factor: number);
+    set _speed(speed: number);
+    material: MeshWobbleMaterial;
+    time: import("@angular/core").Signal<number>;
+    factor: import("@angular/core").Signal<number>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsMeshWobbleMaterial, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshWobbleMaterial, "ngts-mesh-wobble-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "time": { "alias": "time"; "required": false; }; "factor": { "alias": "factor"; "required": false; }; "speed": { "alias": "speed"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsMeshWobbleMaterial, "ngts-mesh-wobble-material", never, { "materialRef": { "alias": "materialRef"; "required": false; }; "_time": { "alias": "time"; "required": false; }; "_factor": { "alias": "factor"; "required": false; }; "_speed": { "alias": "speed"; "required": false; }; }, {}, never, never, true, never>;
 }

package/materials/point-material/point-material.d.ts

@@ -0,0 +1,24 @@
+import { type NgtPointsMaterial } from 'angular-three';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export declare class PointMaterial extends THREE.PointsMaterial {
+    constructor(parameters: THREE.PointsMaterialParameters);
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-points-material
+         */
+        'ngt-point-material': NgtPointsMaterial;
+        /**
+         * @extends ngt-points-material
+         */
+        'ngts-point-material': NgtPointsMaterial;
+    }
+}
+export declare class NgtsPointMaterial {
+    pointMaterialRef: import("angular-three").NgtInjectedRef<PointMaterial>;
+    material: PointMaterial;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPointMaterial, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsPointMaterial, "ngts-point-material", never, { "pointMaterialRef": { "alias": "pointMaterialRef"; "required": false; }; }, {}, never, never, true, never>;
+}