angular-three-soba 2.0.0-beta.4 → 2.0.0-beta.40

package/performances/index.d.ts

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

package/performances/instances/instances.d.ts

@@ -0,0 +1,83 @@
+import { Injector, TemplateRef } from '@angular/core';
+import { type NgtGroup, type NgtInstancedMesh, type NgtRef } from 'angular-three';
+import * as THREE from 'three';
+import { PositionMesh } from './position-mesh';
+import * as i0 from "@angular/core";
+export type NgtsInstancesState = {
+    range?: number;
+    limit: number;
+    frames: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-group
+         */
+        'ngt-position-mesh': PositionMesh & NgtGroup;
+        /**
+         * @extends ngt-instanced-mesh
+         */
+        'ngts-instances': NgtsInstancesState & NgtInstancedMesh;
+    }
+}
+export declare const injectNgtsInstancesApi: {
+    (): {
+        getParent: () => import("angular-three").NgtInjectedRef<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+        subscribe: (meshRef: NgtRef<PositionMesh>) => () => void;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false | undefined;
+    } & {
+        injector?: Injector | undefined;
+    }): {
+        getParent: () => import("angular-three").NgtInjectedRef<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+        subscribe: (meshRef: NgtRef<PositionMesh>) => () => void;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        injector?: Injector | undefined;
+    }): {
+        getParent: () => import("angular-three").NgtInjectedRef<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+        subscribe: (meshRef: NgtRef<PositionMesh>) => () => void;
+    } | null;
+}, provideNgtsInstancesApi: (value?: {
+    getParent: () => import("angular-three").NgtInjectedRef<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    subscribe: (meshRef: NgtRef<PositionMesh>) => () => void;
+} | undefined) => import("@angular/core").Provider;
+export declare class NgtsInstance {
+    instanceRef: import("angular-three").NgtInjectedRef<PositionMesh>;
+    private zone;
+    private injector;
+    instancesApi: {
+        getParent: () => import("angular-three").NgtInjectedRef<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+        subscribe: (meshRef: NgtRef<PositionMesh>) => () => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsInstance, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsInstance, "ngts-instance", never, { "instanceRef": { "alias": "instanceRef"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+export declare class NgtsInstances {
+    DynamicDrawUsage: 35048;
+    nullRaycast: () => null;
+    private inputs;
+    instancesRef: import("angular-three").NgtInjectedRef<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    set _range(range: number);
+    set _limit(limit: number);
+    set _frames(frames: number);
+    content: TemplateRef<unknown>;
+    private limit;
+    private positionMeshes;
+    meshes: import("@angular/core").Signal<NgtRef<PositionMesh>[]>;
+    buffers: import("@angular/core").Signal<{
+        matrices: Float32Array;
+        colors: Float32Array;
+    }>;
+    api: {
+        getParent: () => import("angular-three").NgtInjectedRef<THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+        subscribe: (meshRef: NgtRef<PositionMesh>) => () => void;
+    };
+    constructor();
+    private checkUpdate;
+    private beforeRender;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsInstances, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsInstances, "ngts-instances", never, { "instancesRef": { "alias": "instancesRef"; "required": false; }; "_range": { "alias": "range"; "required": false; }; "_limit": { "alias": "limit"; "required": false; }; "_frames": { "alias": "frames"; "required": false; }; }, {}, ["content"], never, true, never>;
+}

package/{performance → performances}/instances/position-mesh.d.ts

@@ -5,6 +5,6 @@ export declare class PositionMesh extends THREE.Group {
     instance: ElementRef<THREE.InstancedMesh | undefined>;
     instanceKey: ElementRef<PositionMesh | undefined>;
     constructor();
-    get geometry(): THREE.BufferGeometry | undefined;
+    get geometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes> | undefined;
     raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
 }

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,96 @@
+import { Injector, TemplateRef, type OnInit } 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: {
+    (): {
+        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;
+    } & {
+        injector?: Injector | undefined;
+    }): {
+        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 & {
+        injector?: Injector | undefined;
+    }): {
+        getParent: () => import("angular-three").NgtInjectedRef<THREE.Points<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+        subscribe: (pointRef: NgtRef<PositionPoint>) => () => void;
+    } | null;
+}, provideNgtsPointsInstancesApi: (value?: {
+    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: {
+        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: {
+        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<PositionPoint | undefined>;
+    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,128 @@
+import { Injector, type OnInit } from '@angular/core';
+import { type NgtColor, type NgtRef, 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;
+    } & {
+        injector?: Injector | undefined;
+    }): import("@angular/core").Signal<{
+        subscribe: (segmentRef: NgtRef<SegmentObject>) => () => void;
+    }>;
+    (injectOptions: import("@angular/core").InjectOptions & {
+        injector?: Injector | undefined;
+    }): 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/grid-material/grid-material.d.ts

@@ -1,4 +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,6 +1,6 @@
 export * from './blur-pass/blur-pass';
-export * from './caustics-material/caustics-material';
-export * from './caustics-material/caustics-projection-material';
+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';
@@ -9,7 +9,9 @@ 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/mesh-distort-material/mesh-distort-material.d.ts

@@ -7,7 +7,14 @@ interface Uniform<T> {
  * 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,151 @@ 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: THREE.Plane[];
+        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 "dispose">(type: T, listener: THREE.EventListener<{
+            dispose: {};
+        }[T], T, any>): void;
+        addEventListener<T_1 extends string>(type: T_1, listener: THREE.EventListener<{}, T_1, any>): void;
+        hasEventListener<T_2 extends "dispose">(type: T_2, listener: THREE.EventListener<{
+            dispose: {};
+        }[T_2], T_2, any>): boolean;
+        hasEventListener<T_3 extends string>(type: T_3, listener: THREE.EventListener<{}, T_3, any>): boolean;
+        removeEventListener<T_4 extends "dispose">(type: T_4, listener: THREE.EventListener<{
+            dispose: {};
+        }[T_4], T_4, any>): void;
+        removeEventListener<T_5 extends string>(type: T_5, listener: THREE.EventListener<{}, T_5, any>): void;
+        dispatchEvent<T_6 extends "dispose">(event: THREE.BaseEvent<T_6> & {
+            dispose: {};
+        }[T_6]): void;
+    };
+};
 export declare function provideNgtsMeshDistortMaterialShader(distortShader: string): {
     provide: InjectionToken<MeshDistortMaterial>;
     useFactory: () => {
@@ -58,6 +210,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 +245,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;
@@ -100,7 +256,7 @@ export declare function provideNgtsMeshDistortMaterialShader(distortShader: stri
             blendSrc: 210 | THREE.BlendingDstFactor;
             blendSrcAlpha: number | null;
             clipIntersection: boolean;
-            clippingPlanes: any;
+            clippingPlanes: THREE.Plane[];
             clipShadows: boolean;
             colorWrite: boolean;
             depthFunc: THREE.DepthModes;
@@ -140,10 +296,21 @@ export declare function provideNgtsMeshDistortMaterialShader(distortShader: stri
             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;
+            addEventListener<T extends "dispose">(type: T, listener: THREE.EventListener<{
+                dispose: {};
+            }[T], T, any>): void;
+            addEventListener<T_1 extends string>(type: T_1, listener: THREE.EventListener<{}, T_1, any>): void;
+            hasEventListener<T_2 extends "dispose">(type: T_2, listener: THREE.EventListener<{
+                dispose: {};
+            }[T_2], T_2, any>): boolean;
+            hasEventListener<T_3 extends string>(type: T_3, listener: THREE.EventListener<{}, T_3, any>): boolean;
+            removeEventListener<T_4 extends "dispose">(type: T_4, listener: THREE.EventListener<{
+                dispose: {};
+            }[T_4], T_4, any>): void;
+            removeEventListener<T_5 extends string>(type: T_5, listener: THREE.EventListener<{}, T_5, any>): void;
+            dispatchEvent<T_6 extends "dispose">(event: THREE.BaseEvent<T_6> & {
+                dispose: {};
+            }[T_6]): void;
         };
     };
 };