angular-three-soba 1.14.1 → 2.0.0-beta.11

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

@@ -1 +1 @@
-{"version":3,"file":"angular-three-soba.mjs","sources":["../../../../libs/angular-three-soba/src/index.ts","../../../../libs/angular-three-soba/src/angular-three-soba.ts"],"sourcesContent":["export default void 0;\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"AAAA,YAAe,KAAK,CAAC;;ACArB;;AAEG"}
+{"version":3,"file":"angular-three-soba.mjs","sources":["../../../../libs/soba/src/index.ts","../../../../libs/soba/src/angular-three-soba.ts"],"sourcesContent":["export default void 0;\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"AAAA,YAAe,KAAK,CAAC;;ACArB;;AAEG"}

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

@@ -0,0 +1,10 @@
+import type { Injector, Signal } from '@angular/core';
+import { type NgtLoaderResults, type NgtObjectMap } from 'angular-three';
+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> | null>;

package/loaders/index.d.ts

@@ -1,5 +1,4 @@
-export * from './lib/cube-texture-loader/cube-texture-loader';
-export * from './lib/gltf-loader/gltf-loader';
-export * from './lib/loader/loader';
-export * from './lib/progress/progress';
-export * from './lib/texture-loader/texture-loader';
+export * from './gltf-loader/gltf-loader';
+export * from './loader/loader';
+export * from './progress/progress';
+export * from './texture-loader/texture-loader';

package/loaders/loader/loader.d.ts

@@ -0,0 +1,33 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface NgtsLoaderState {
+    containerClass?: string;
+    innerClass?: string;
+    barClass?: string;
+    dataClass?: string;
+    dataInterpolation: (value: number) => string;
+    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>;
+    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>;
+}

package/loaders/progress/progress.d.ts

@@ -0,0 +1,9 @@
+import { type Injector } from '@angular/core';
+export declare function injectNgtsProgress(injector?: Injector): import("@angular/core").Signal<{
+    errors: string[];
+    active: boolean;
+    progress: number;
+    item: string;
+    loaded: number;
+    total: number;
+}>;

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

@@ -0,0 +1,7 @@
+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> | null>;

package/materials/index.d.ts

@@ -1,5 +1,6 @@
-export * from './lib/mesh-distort-material/mesh-distort-material';
-export * from './lib/mesh-reflector-material/mesh-reflector-material';
-export * from './lib/mesh-refraction-material/mesh-refraction-material';
-export * from './lib/mesh-transmission-material/mesh-transmission-material';
-export * from './lib/mesh-wobble-material/mesh-wobble-material';
+export * from './mesh-distort-material/mesh-distort-material';
+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

@@ -0,0 +1,40 @@
+import { type NgtMeshPhysicalMaterial } from 'angular-three';
+import * as i0 from "@angular/core";
+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 {
+    private inputs;
+    materialRef: import("angular-three").NgtInjectedRef<{
+        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);
+    private MeshDistortMaterial;
+    material: {
+        time: number;
+        distort: number;
+        radius: 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>;
+}

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

@@ -0,0 +1,99 @@
+import { NgtMeshStandardMaterial } from 'angular-three';
+import { MeshReflectorMaterial } from 'angular-three-soba/shaders';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export type NgtsMeshReflectorMaterialState = {
+    resolution: number;
+    mixBlur: number;
+    mixStrength: number;
+    blur: [number, number] | number;
+    mirror: number;
+    minDepthThreshold: number;
+    maxDepthThreshold: number;
+    depthScale: number;
+    depthToBlurRatioBias: number;
+    distortionMap?: THREE.Texture;
+    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 {
+    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);
+    private reflectorProps;
+    defines: import("@angular/core").Signal<{
+        USE_BLUR: string | undefined;
+        USE_DEPTH: string | undefined;
+        USE_DISTORTION: string | undefined;
+    }>;
+    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>;
+}

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

@@ -0,0 +1,62 @@
+import { type NgtShaderMaterial } from 'angular-three';
+import { NgtsMeshTranmissionMaterialState } from '../mesh-transmission-material/mesh-transmission-material';
+import * as i0 from "@angular/core";
+export type NgtsMeshRefractionMaterialState = {
+    /** Environment map */
+    envMap: THREE.CubeTexture | THREE.Texture;
+    /** Number of ray-cast bounces, it can be expensive to have too many, 2 */
+    bounces: number;
+    /** Refraction index, 2.4 */
+    ior: number;
+    /** Fresnel (strip light), 0 */
+    fresnel: number;
+    /** RGB shift intensity, can be expensive, 0 */
+    aberrationStrength: number;
+    /** Color, white */
+    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 {
+    private inputs;
+    materialRef: import("angular-three").NgtInjectedRef<import("three").ShaderMaterial>;
+    /** Environment map */
+    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);
+    /** Refraction index, 2.4 */
+    set _ior(ior: number);
+    /** Fresnel (strip light), 0 */
+    set _fresnel(fresnel: number);
+    /** RGB shift intensity, can be expensive, 0 */
+    set _aberrationStrength(aberrationStrength: number);
+    /** Color, white */
+    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);
+    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>;
+    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>;
+}

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

@@ -0,0 +1,107 @@
+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 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
+     *  using this can't see other transparent or transmissive objects, default: false */
+    transmissionSampler: boolean;
+    /** Render the backside of the material (more cost, better results), default: false */
+    backside: boolean;
+    /** Backside thickness (when backside is true), default: 0 */
+    backsideThickness: number;
+    /** Resolution of the local buffer, default: undefined (fullscreen) */
+    resolution: number;
+    /** Resolution of the local buffer for backfaces, default: undefined (fullscreen) */
+    backsideResolution: number;
+    /** Refraction samples, default: 10 */
+    samples: number;
+    /** Buffer scene background (can be a texture, a cubetexture or a color), default: null */
+    background: THREE.Texture | THREE.Color;
+    transmission: number;
+    thickness: number;
+    roughness: number;
+    chromaticAberration: number;
+    anisotropy: number;
+    anisotropicBlur: number;
+    distortion: number;
+    distortionScale: number;
+    temporalDistortion: number;
+    /** The scene rendered into a texture (use it to share a texture between materials), default: null  */
+    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 {
+    private inputs;
+    materialRef: import("angular-three").NgtInjectedRef<MeshTransmissionMaterial & {
+        time: number;
+        buffer?: THREE.Texture | undefined;
+    }>;
+    /** 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
+     *  using this can't see other transparent or transmissive objects, default: false */
+    set _transmissionSampler(transmissionSampler: boolean);
+    /** Render the backside of the material (more cost, better results), default: false */
+    set _backside(backside: boolean);
+    /** Backside thickness (when backside is true), default: 0 */
+    set _backsideThickness(backsideThickness: number);
+    /** Resolution of the local buffer, default: undefined (fullscreen) */
+    set _resolution(resolution: number);
+    /** Resolution of the local buffer for backfaces, default: undefined (fullscreen) */
+    set _backsideResolution(backsideResolution: number);
+    /** Refraction samples, default: 10 */
+    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 _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);
+    /** Internals */
+    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; }; "_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

@@ -0,0 +1,29 @@
+import { type NgtMeshStandardMaterial } from 'angular-three';
+import { MeshWobbleMaterial } from 'angular-three-soba/shaders';
+import * as i0 from "@angular/core";
+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 {
+    private inputs;
+    materialRef: import("angular-three").NgtInjectedRef<MeshWobbleMaterial>;
+    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>;
+}

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>;
+}