angular-three-soba 1.14.0 → 2.0.0-beta.10

package/performances/adaptive-dpr/adaptive-dpr.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+export declare class NgtsAdaptiveDpr {
+    private pixelated;
+    set _pixelated(pixelated: boolean);
+    private store;
+    private current;
+    private active;
+    private setDpr;
+    private initialDpr;
+    private domElement;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsAdaptiveDpr, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsAdaptiveDpr, "ngts-adaptive-dpr", never, { "_pixelated": { "alias": "pixelated"; "required": false; }; }, {}, never, never, true, never>;
+}

package/{performance/lib/adaptive → performances/adaptive-events}/adaptive-events.d.ts

@@ -1,10 +1,9 @@
-import { OnInit } from '@angular/core';
-import { NgtRxStore } from 'angular-three';
 import * as i0 from "@angular/core";
-export declare class NgtsAdaptiveEvents extends NgtRxStore implements OnInit {
-    private readonly store;
-    private readonly actions;
-    ngOnInit(): void;
+export declare class NgtsAdaptiveEvents {
+    private store;
+    private setEvents;
+    private current;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsAdaptiveEvents, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsAdaptiveEvents, "ngts-adaptive-events", never, {}, {}, never, never, true, never>;
 }

package/performances/index.d.ts

@@ -0,0 +1,5 @@
+export * from './adaptive-dpr/adaptive-dpr';
+export * from './adaptive-events/adaptive-events';
+export * from './points/points';
+export * from './segments/segment-object';
+export * from './segments/segments';

package/performances/points/points-input.d.ts

@@ -0,0 +1,32 @@
+import type { Points } from 'three';
+import * as i0 from "@angular/core";
+export type NgtsPointsInstancesState = {
+    limit: number;
+    range?: number;
+};
+export type NgtsPointsBuffersState = {
+    positions: Float32Array;
+    colors?: Float32Array;
+    sizes?: Float32Array;
+    stride: 2 | 3;
+};
+export declare abstract class NgtsPointsInput {
+    protected inputs: import("angular-three").NgtSignalStore<NgtsPointsBuffersState & NgtsPointsInstancesState>;
+    pointsRef: import("angular-three").NgtInjectedRef<Points<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[]>>;
+    set _range(range: number);
+    set _limit(limit: number);
+    set _positions(positions: Float32Array);
+    set _colors(colors: Float32Array);
+    set _sizes(sizes: Float32Array);
+    set _stride(stride: 2 | 3);
+    limit: import("@angular/core").Signal<number>;
+    range: import("@angular/core").Signal<number | undefined>;
+    positions: import("@angular/core").Signal<Float32Array>;
+    colors: import("@angular/core").Signal<Float32Array | undefined>;
+    colorsLength: import("@angular/core").Signal<number>;
+    sizes: import("@angular/core").Signal<Float32Array | undefined>;
+    sizesLength: import("@angular/core").Signal<number>;
+    stride: import("@angular/core").Signal<2 | 3>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPointsInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsPointsInput, never, never, { "pointsRef": { "alias": "pointsRef"; "required": false; }; "_range": { "alias": "range"; "required": false; }; "_limit": { "alias": "limit"; "required": false; }; "_positions": { "alias": "positions"; "required": false; }; "_colors": { "alias": "colors"; "required": false; }; "_sizes": { "alias": "sizes"; "required": false; }; "_stride": { "alias": "stride"; "required": false; }; }, {}, never, never, false, never>;
+}

package/performances/points/points.d.ts

@@ -0,0 +1,92 @@
+import { Injector, OnInit, TemplateRef } from '@angular/core';
+import { type NgtGroup, type NgtPoints, type NgtRef } from 'angular-three';
+import * as THREE from 'three';
+import { NgtsPointsInput, type NgtsPointsBuffersState, type NgtsPointsInstancesState } from './points-input';
+import { PositionPoint } from './position-point';
+import * as i0 from "@angular/core";
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-points
+         */
+        'ngts-points-instances': NgtsPointsInstancesState & NgtPoints;
+        /**
+         * @extends ngt-points
+         */
+        'ngts-points-buffers': NgtsPointsBuffersState & NgtPoints;
+        /**
+         * @extends ngt-points
+         */
+        'ngts-points': (NgtsPointsBuffersState | NgtsPointsInstancesState) & NgtsPoints;
+        /**
+         * @extends ngt-group
+         */
+        'ngt-position-point': PositionPoint & NgtGroup;
+    }
+}
+export declare const injectNgtsPointsInstanceApi: {
+    (): import("@angular/core").Signal<{
+        getParent: () => import("angular-three").NgtInjectedRef<THREE.Points<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+        subscribe: (pointRef: NgtRef<PositionPoint>) => () => void;
+    }>;
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false | undefined;
+    }): import("@angular/core").Signal<{
+        getParent: () => import("angular-three").NgtInjectedRef<THREE.Points<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+        subscribe: (pointRef: NgtRef<PositionPoint>) => () => void;
+    }>;
+    (injectOptions: import("@angular/core").InjectOptions): import("@angular/core").Signal<{
+        getParent: () => import("angular-three").NgtInjectedRef<THREE.Points<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+        subscribe: (pointRef: NgtRef<PositionPoint>) => () => void;
+    }> | null;
+}, provideNgtsPointsInstancesApi: (value?: import("@angular/core").Signal<{
+    getParent: () => import("angular-three").NgtInjectedRef<THREE.Points<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    subscribe: (pointRef: NgtRef<PositionPoint>) => () => void;
+}> | undefined) => import("@angular/core").Provider;
+export declare class NgtsPointsInstances {
+    nullRaycast: () => null;
+    DynamicDrawUsage: 35048;
+    pointsInput: NgtsPointsInput;
+    private positionPoints;
+    private parentMatrix;
+    private position;
+    points: import("@angular/core").Signal<NgtRef<PositionPoint>[]>;
+    positions: import("@angular/core").Signal<Float32Array>;
+    colors: import("@angular/core").Signal<Float32Array>;
+    sizes: import("@angular/core").Signal<Float32Array>;
+    injector: Injector;
+    api: import("@angular/core").Signal<{
+        getParent: () => import("angular-three").NgtInjectedRef<THREE.Points<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+        subscribe: (pointRef: NgtRef<PositionPoint>) => () => void;
+    }>;
+    constructor();
+    private checkUpdatePositionAttribute;
+    private beforeRender;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPointsInstances, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsPointsInstances, "ngts-points-instances", never, {}, {}, never, ["*"], true, never>;
+}
+export declare class NgtsPoint implements OnInit {
+    pointRef: import("angular-three").NgtInjectedRef<PositionPoint>;
+    private zone;
+    private injector;
+    pointsInstancesApi: import("@angular/core").Signal<{
+        getParent: () => import("angular-three").NgtInjectedRef<THREE.Points<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+        subscribe: (pointRef: NgtRef<PositionPoint>) => () => void;
+    }>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPoint, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsPoint, "ngts-point", never, { "pointRef": { "alias": "pointRef"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+export declare class NgtsPointsBuffers {
+    DynamicDrawUsage: 35048;
+    pointsInput: NgtsPointsInput;
+    store: import("angular-three").NgtSignalStore<import("angular-three").NgtState>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPointsBuffers, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsPointsBuffers, "ngts-points-buffers", never, {}, {}, never, ["*"], true, never>;
+}
+export declare class NgtsPoints extends NgtsPointsInput {
+    content: TemplateRef<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPoints, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsPoints, "ngts-points", never, {}, {}, ["content"], never, true, never>;
+}

package/performances/points/position-point.d.ts

@@ -0,0 +1,11 @@
+import { ElementRef } from '@angular/core';
+import * as THREE from 'three';
+export declare class PositionPoint extends THREE.Group {
+    size: number;
+    color: THREE.Color;
+    instance: ElementRef<THREE.Points | undefined>;
+    instanceKey: ElementRef<any>;
+    constructor();
+    get geometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes> | undefined;
+    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
+}

package/performances/segments/segment-object.d.ts

@@ -0,0 +1,7 @@
+import * as THREE from 'three';
+export declare class SegmentObject {
+    color: THREE.Color;
+    start: THREE.Vector3;
+    end: THREE.Vector3;
+    constructor();
+}

package/performances/segments/segments.d.ts

@@ -0,0 +1,124 @@
+import { OnInit } from '@angular/core';
+import { NgtRef, type NgtColor, type NgtVector3 } from 'angular-three';
+import * as THREE from 'three';
+import { Line2, LineMaterial, LineSegmentsGeometry } from 'three-stdlib';
+import { SegmentObject } from './segment-object';
+import * as i0 from "@angular/core";
+export type NgtsSegmentState = {
+    start?: NgtVector3;
+    end?: NgtVector3;
+    color?: NgtColor;
+};
+export type NgtsSegmentsState = {
+    limit: number;
+    lineWidth: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngt-segment-object': SegmentObject;
+        'ngts-segment': NgtsSegmentState;
+        'ngts-segments': NgtsSegmentsState;
+    }
+}
+export declare const injectNgtsSegmentsApi: {
+    (): import("@angular/core").Signal<{
+        subscribe: (segmentRef: NgtRef<SegmentObject>) => () => void;
+    }>;
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false | undefined;
+    }): import("@angular/core").Signal<{
+        subscribe: (segmentRef: NgtRef<SegmentObject>) => () => void;
+    }>;
+    (injectOptions: import("@angular/core").InjectOptions): import("@angular/core").Signal<{
+        subscribe: (segmentRef: NgtRef<SegmentObject>) => () => void;
+    }> | null;
+}, provideNgtsSegmentsApi: (value?: import("@angular/core").Signal<{
+    subscribe: (segmentRef: NgtRef<SegmentObject>) => () => void;
+}> | undefined) => import("@angular/core").Provider;
+export declare class NgtsSegment implements OnInit {
+    private inputs;
+    segmentRef: import("angular-three").NgtInjectedRef<SegmentObject>;
+    set _start(start: NgtVector3);
+    set _end(end: NgtVector3);
+    set _color(color: NgtColor);
+    private segmentsApi;
+    private injector;
+    private zone;
+    private start;
+    private end;
+    normalizedStart: import("@angular/core").Signal<THREE.Vector3>;
+    normalizedEnd: import("@angular/core").Signal<THREE.Vector3>;
+    color: import("@angular/core").Signal<import("angular-three").NgtExtendedColors<import("angular-three").NgtOverwrite<Partial<{
+        [Symbol.iterator]: () => Generator<number, void, unknown>;
+        set: {
+            (color: THREE.ColorRepresentation): THREE.Color;
+            (r: number, g: number, b: number): THREE.Color;
+        };
+        setScalar: (scalar: number) => THREE.Color;
+        add: (color: THREE.Color) => THREE.Color;
+        toJSON: () => number;
+        clone: () => THREE.Color;
+        copy: (color: THREE.Color) => THREE.Color;
+        readonly isColor: true;
+        r: number;
+        g: number;
+        b: number;
+        setFromVector3: (vector: THREE.Vector3) => THREE.Color;
+        setHex: (hex: number, colorSpace?: THREE.ColorSpace | undefined) => THREE.Color;
+        setRGB: (r: number, g: number, b: number, colorSpace?: THREE.ColorSpace | undefined) => THREE.Color;
+        setHSL: (h: number, s: number, l: number, colorSpace?: THREE.ColorSpace | undefined) => THREE.Color;
+        setStyle: (style: string, colorSpace?: THREE.ColorSpace | undefined) => THREE.Color;
+        setColorName: (style: string, colorSpace?: THREE.ColorSpace | undefined) => THREE.Color;
+        copySRGBToLinear: (color: THREE.Color) => THREE.Color;
+        copyLinearToSRGB: (color: THREE.Color) => THREE.Color;
+        convertSRGBToLinear: () => THREE.Color;
+        convertLinearToSRGB: () => THREE.Color;
+        getHex: (colorSpace?: THREE.ColorSpace | undefined) => number;
+        getHexString: (colorSpace?: THREE.ColorSpace | undefined) => string;
+        getHSL: (target: THREE.HSL, colorSpace?: THREE.ColorSpace | undefined) => THREE.HSL;
+        getRGB: (target: THREE.RGB, colorSpace?: THREE.ColorSpace | undefined) => THREE.RGB;
+        getStyle: (colorSpace?: THREE.ColorSpace | undefined) => string;
+        offsetHSL: (h: number, s: number, l: number) => THREE.Color;
+        addColors: (color1: THREE.Color, color2: THREE.Color) => THREE.Color;
+        addScalar: (s: number) => THREE.Color;
+        applyMatrix3: (m: THREE.Matrix3) => THREE.Color;
+        sub: (color: THREE.Color) => THREE.Color;
+        multiply: (color: THREE.Color) => THREE.Color;
+        multiplyScalar: (s: number) => THREE.Color;
+        lerp: (color: THREE.Color, alpha: number) => THREE.Color;
+        lerpColors: (color1: THREE.Color, color2: THREE.Color, alpha: number) => THREE.Color;
+        lerpHSL: (color: THREE.Color, alpha: number) => THREE.Color;
+        equals: (color: THREE.Color) => boolean;
+        fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => THREE.Color;
+        toArray: {
+            (array?: number[] | undefined, offset?: number | undefined): number[];
+            (xyz: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+        };
+        fromBufferAttribute: (attribute: THREE.BufferAttribute | THREE.InterleavedBufferAttribute, index: number) => THREE.Color;
+    }>, import("angular-three").NgtNodeElement<THREE.Color, THREE.ColorRepresentation>>> | undefined>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSegment, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSegment, "ngts-segment", never, { "segmentRef": { "alias": "segmentRef"; "required": false; }; "_start": { "alias": "start"; "required": false; }; "_end": { "alias": "end"; "required": false; }; "_color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class NgtsSegments {
+    private inputs;
+    segmentsRef: import("angular-three").NgtInjectedRef<Line2>;
+    set _limit(limit: number);
+    set _lineWidth(lineWidth: number);
+    private segments;
+    private limit;
+    private positions;
+    private colors;
+    resolution: THREE.Vector2;
+    lineWidth: import("@angular/core").Signal<number>;
+    line: Line2;
+    material: LineMaterial;
+    geometry: LineSegmentsGeometry;
+    api: import("@angular/core").Signal<{
+        subscribe: (segmentRef: NgtRef<SegmentObject>) => () => void;
+    }>;
+    constructor();
+    private beforeRender;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSegments, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSegments, "ngts-segments", never, { "segmentsRef": { "alias": "segmentsRef"; "required": false; }; "_limit": { "alias": "limit"; "required": false; }; "_lineWidth": { "alias": "lineWidth"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/shaders/{lib/blur-pass → blur-pass}/blur-pass.d.ts

@@ -1,4 +1,4 @@
-import { Camera, Mesh, Scene, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { Camera, Mesh, Scene, WebGLRenderTarget, WebGLRenderer } from 'three';
 import { ConvolutionMaterial } from '../convolution-material/convolution-material';
 export interface BlurPassProps {
     gl: WebGLRenderer;
@@ -19,5 +19,5 @@ export declare class BlurPass {
     readonly screen: Mesh;
     renderToScreen: boolean;
     constructor({ gl, resolution, width, height, minDepthThreshold, maxDepthThreshold, depthScale, depthToBlurRatioBias, }: BlurPassProps);
-    render(renderer: WebGLRenderer, inputBuffer: any, outputBuffer: any): void;
+    render(renderer: WebGLRenderer, inputBuffer: WebGLRenderTarget, outputBuffer: WebGLRenderTarget): void;
 }

package/shaders/grid-material/grid-material.d.ts

@@ -0,0 +1,37 @@
+import type { NgtShaderMaterial } from 'angular-three';
+import * as THREE from 'three';
+export declare const GridMaterial: typeof THREE.ShaderMaterial & {
+    key: string;
+};
+export type NgtGridMaterialState = {
+    /** Cell size, default: 0.5 */
+    cellSize?: number;
+    /** Cell thickness, default: 0.5 */
+    cellThickness?: number;
+    /** Cell color, default: black */
+    cellColor?: THREE.ColorRepresentation;
+    /** Section size, default: 1 */
+    sectionSize?: number;
+    /** Section thickness, default: 1 */
+    sectionThickness?: number;
+    /** Section color, default: #2080ff */
+    sectionColor?: THREE.ColorRepresentation;
+    /** Follow camera, default: false */
+    followCamera?: boolean;
+    /** Display the grid infinitely, default: false */
+    infiniteGrid?: boolean;
+    /** Fade distance, default: 100 */
+    fadeDistance?: number;
+    /** Fade strength, default: 1 */
+    fadeStrength?: number;
+    /** Material side, default: THREE.BackSide */
+    side?: THREE.Side;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-shader-material
+         */
+        'ngt-grid-material': NgtGridMaterialState & NgtShaderMaterial;
+    }
+}

package/shaders/index.d.ts

@@ -1,14 +1,17 @@
-export * from './lib/blur-pass/blur-pass';
-export * from './lib/caustics-material/caustics-material';
-export * from './lib/caustics-projection-material/caustics-projection-material';
-export * from './lib/convolution-material/convolution-material';
-export * from './lib/discard-material/discard-material';
-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 './lib/shader-material/shader-material';
-export * from './lib/soft-shadow-material/soft-shadow-material';
-export * from './lib/spot-light-material/spot-light-material';
-export * from './lib/star-field-material/star-field-material';
+export * from './blur-pass/blur-pass';
+export * from './caustics/caustics-material';
+export * from './caustics/caustics-projection-material';
+export * from './convolution-material/convolution-material';
+export * from './discard-material/discard-material';
+export * from './grid-material/grid-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 './shader-material/shader-material';
+export * from './soft-shadow-material/soft-shadow-material';
+export * from './sparkles-material/sparkles-material';
+export * from './spot-light-material/spot-light-material';
+export * from './star-field-material/star-field-material';
+export * from './wireframe-material/wireframe-material';

package/shaders/{lib/mesh-distort-material → mesh-distort-material}/mesh-distort-material.d.ts

@@ -4,10 +4,17 @@ interface Uniform<T> {
     value: T;
 }
 /**
- * npm i -D raw-loader glslify-loader
+ * npm i -D raw-loader glslify-loader glsl-noise
  * Usage: import distort from 'raw-loader!glslify-loader!angular-three-soba/assets/distort.vert.glsl'
  *
- * provideNgtsMeshDistortMaterialShader(distort)
+ * using provider:
+ * - provideNgtsMeshDistortMaterialShader(distort)
+ * - readonly MeshDistortMaterial = injectNgtsMeshDistortMaterial()
+ * - material = new this.MeshDistortMaterial(); // then use this with primitive
+ *
+ * using createMeshDistortMaterial: createMeshDistortMaterial(distort);
+ * - const MeshDistortMaterial = createMeshDistortMaterial(distort);
+ * - extend({ MeshDistortMaterial }); // then use as ngt-mesh-distort-material
  */
 export type MeshDistortMaterial = Type<{
     time: number;
@@ -15,6 +22,140 @@ export type MeshDistortMaterial = Type<{
     radius: number;
 } & THREE.MeshPhysicalMaterial>;
 export declare const NGTS_DISTORT_MATERIAL_SHADER: InjectionToken<MeshDistortMaterial>;
+export declare function injectNgtsMeshDistortMaterial(): MeshDistortMaterial;
+export declare function createMeshDistortMaterial(distortShader: string): {
+    new (parameters?: THREE.MeshPhysicalMaterialParameters): {
+        _time: Uniform<number>;
+        _distort: Uniform<number>;
+        _radius: Uniform<number>;
+        onBeforeCompile(shader: THREE.Shader): void;
+        time: number;
+        distort: number;
+        radius: number;
+        type: string;
+        defines: {
+            [key: string]: any;
+        };
+        clearcoat: number;
+        clearcoatMap: THREE.Texture | null;
+        clearcoatRoughness: number;
+        clearcoatRoughnessMap: THREE.Texture | null;
+        clearcoatNormalScale: THREE.Vector2;
+        clearcoatNormalMap: THREE.Texture | null;
+        reflectivity: number;
+        ior: number;
+        sheen: number;
+        sheenColor: THREE.Color;
+        sheenColorMap: THREE.Texture | null;
+        sheenRoughness: number;
+        sheenRoughnessMap: THREE.Texture | null;
+        transmission: number;
+        transmissionMap: THREE.Texture | null;
+        thickness: number;
+        thicknessMap: THREE.Texture | null;
+        attenuationDistance: number;
+        attenuationColor: THREE.Color;
+        specularIntensity: number;
+        specularColor: THREE.Color;
+        specularIntensityMap: THREE.Texture | null;
+        specularColorMap: THREE.Texture | null;
+        iridescenceMap: THREE.Texture | null;
+        iridescenceIOR: number;
+        iridescence: number;
+        iridescenceThicknessRange: [number, number];
+        iridescenceThicknessMap: THREE.Texture | null;
+        anisotropy?: number | undefined;
+        anisotropyRotation?: number | undefined;
+        anisotropyMap?: THREE.Texture | null | undefined;
+        color: THREE.Color;
+        roughness: number;
+        metalness: number;
+        map: THREE.Texture | null;
+        lightMap: THREE.Texture | null;
+        lightMapIntensity: number;
+        aoMap: THREE.Texture | null;
+        aoMapIntensity: number;
+        emissive: THREE.Color;
+        emissiveIntensity: number;
+        emissiveMap: THREE.Texture | null;
+        bumpMap: THREE.Texture | null;
+        bumpScale: number;
+        normalMap: THREE.Texture | null;
+        normalMapType: THREE.NormalMapTypes;
+        normalScale: THREE.Vector2;
+        displacementMap: THREE.Texture | null;
+        displacementScale: number;
+        displacementBias: number;
+        roughnessMap: THREE.Texture | null;
+        metalnessMap: THREE.Texture | null;
+        alphaMap: THREE.Texture | null;
+        envMap: THREE.Texture | null;
+        envMapIntensity: number;
+        wireframe: boolean;
+        wireframeLinewidth: number;
+        wireframeLinecap: string;
+        wireframeLinejoin: string;
+        flatShading: boolean;
+        fog: boolean;
+        isMeshStandardMaterial: boolean;
+        setValues(parameters: THREE.MeshStandardMaterialParameters): void;
+        alphaHash: boolean;
+        alphaTest: number;
+        alphaToCoverage: boolean;
+        blendDst: THREE.BlendingDstFactor;
+        blendDstAlpha: number | null;
+        blendEquation: THREE.BlendingEquation;
+        blendEquationAlpha: number | null;
+        blending: THREE.Blending;
+        blendSrc: 210 | THREE.BlendingDstFactor;
+        blendSrcAlpha: number | null;
+        clipIntersection: boolean;
+        clippingPlanes: any;
+        clipShadows: boolean;
+        colorWrite: boolean;
+        depthFunc: THREE.DepthModes;
+        depthTest: boolean;
+        depthWrite: boolean;
+        id: number;
+        stencilWrite: boolean;
+        stencilFunc: THREE.StencilFunc;
+        stencilRef: number;
+        stencilWriteMask: number;
+        stencilFuncMask: number;
+        stencilFail: THREE.StencilOp;
+        stencilZFail: THREE.StencilOp;
+        stencilZPass: THREE.StencilOp;
+        readonly isMaterial: true;
+        name: string;
+        needsUpdate: boolean;
+        opacity: number;
+        polygonOffset: boolean;
+        polygonOffsetFactor: number;
+        polygonOffsetUnits: number;
+        precision: "highp" | "mediump" | "lowp" | null;
+        premultipliedAlpha: boolean;
+        forceSinglePass: boolean;
+        dithering: boolean;
+        side: THREE.Side;
+        shadowSide: THREE.Side | null;
+        toneMapped: boolean;
+        transparent: boolean;
+        uuid: string;
+        vertexColors: boolean;
+        visible: boolean;
+        userData: any;
+        version: number;
+        clone(): any;
+        copy(material: THREE.Material): any;
+        dispose(): void;
+        customProgramCacheKey(): string;
+        toJSON(meta?: any): any;
+        addEventListener<T extends string>(type: T, listener: THREE.EventListener<THREE.Event, T, any>): void;
+        hasEventListener<T_1 extends string>(type: T_1, listener: THREE.EventListener<THREE.Event, T_1, any>): boolean;
+        removeEventListener<T_2 extends string>(type: T_2, listener: THREE.EventListener<THREE.Event, T_2, any>): void;
+        dispatchEvent(event: THREE.Event): void;
+    };
+};
 export declare function provideNgtsMeshDistortMaterialShader(distortShader: string): {
     provide: InjectionToken<MeshDistortMaterial>;
     useFactory: () => {
@@ -58,6 +199,9 @@ export declare function provideNgtsMeshDistortMaterialShader(distortShader: stri
             iridescence: number;
             iridescenceThicknessRange: [number, number];
             iridescenceThicknessMap: THREE.Texture | null;
+            anisotropy?: number | undefined;
+            anisotropyRotation?: number | undefined;
+            anisotropyMap?: THREE.Texture | null | undefined;
             color: THREE.Color;
             roughness: number;
             metalness: number;
@@ -90,6 +234,7 @@ export declare function provideNgtsMeshDistortMaterialShader(distortShader: stri
             fog: boolean;
             isMeshStandardMaterial: boolean;
             setValues(parameters: THREE.MeshStandardMaterialParameters): void;
+            alphaHash: boolean;
             alphaTest: number;
             alphaToCoverage: boolean;
             blendDst: THREE.BlendingDstFactor;

package/shaders/{lib/mesh-transmission-material → mesh-transmission-material}/mesh-transmission-material.d.ts

@@ -13,7 +13,7 @@ export declare class MeshTransmissionMaterial extends THREE.MeshPhysicalMaterial
         thicknessMap: Uniform<THREE.Texture | null>;
         attenuationDistance: Uniform<number>;
         attenuationColor: Uniform<THREE.Color>;
-        anisotropy: Uniform<number>;
+        anisotropicBlur: Uniform<number>;
         time: Uniform<number>;
         distortion: Uniform<number>;
         distortionScale: Uniform<number>;

package/shaders/{lib/mesh-wobble-material → mesh-wobble-material}/mesh-wobble-material.d.ts

@@ -11,5 +11,6 @@ export declare class MeshWobbleMaterial extends THREE.MeshStandardMaterial {
     set time(v: number);
     get factor(): number;
     set factor(v: number);
+    speed: number;
 }
 export {};

package/shaders/{lib/shader-material → shader-material}/shader-material.d.ts

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
-export declare function shaderMaterial(uniforms: {
+export declare function shaderMaterial<Uniforms extends {
     [name: string]: THREE.CubeTexture | THREE.Texture | Int32Array | Float32Array | THREE.Matrix4 | THREE.Matrix3 | THREE.Quaternion | THREE.Vector4 | THREE.Vector3 | THREE.Vector2 | THREE.Color | number | boolean | Array<any> | null;
-}, vertexShader: string, fragmentShader: string, onInit?: (material?: THREE.ShaderMaterial) => void): typeof THREE.ShaderMaterial & {
+}>(uniforms: Uniforms, vertexShader: string, fragmentShader: string, onInit?: (material?: THREE.ShaderMaterial) => void): typeof THREE.ShaderMaterial & {
     key: string;
 };

package/shaders/soft-shadow-material/soft-shadow-material.d.ts

@@ -0,0 +1,19 @@
+import type { NgtShaderMaterial } from 'angular-three';
+import * as THREE from 'three';
+export declare const SoftShadowMaterial: typeof THREE.ShaderMaterial & {
+    key: string;
+};
+export type NgtSoftShadowMaterialState = {
+    map: THREE.Texture;
+    color?: THREE.ColorRepresentation;
+    alphaTest?: number;
+    blend?: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         *  @extends ngt-shader-material
+         */
+        'ngt-soft-shadow-material': NgtSoftShadowMaterialState & NgtShaderMaterial;
+    }
+}

package/shaders/sparkles-material/sparkles-material.d.ts

@@ -0,0 +1,17 @@
+import type { NgtShaderMaterial } from 'angular-three';
+import * as THREE from 'three';
+export declare const SparklesMaterial: typeof THREE.ShaderMaterial & {
+    key: string;
+};
+export type NgtSparklesMaterialState = {
+    time?: number;
+    pixelRatio?: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-shader-material
+         */
+        'ngt-sparkles-material': NgtSparklesMaterialState & NgtShaderMaterial;
+    }
+}

package/shaders/spot-light-material/spot-light-material.d.ts

@@ -0,0 +1,13 @@
+import type { NgtShaderMaterial } from 'angular-three';
+import * as THREE from 'three';
+export declare class SpotLightMaterial extends THREE.ShaderMaterial {
+    constructor();
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-shader-material
+         */
+        'ngt-spot-light-material': NgtShaderMaterial;
+    }
+}