angular-three-soba 2.0.0-beta.26 → 2.0.0-beta.261

package/misc/index.d.ts

@@ -1,13 +1,9 @@
-export * from './animations/animations';
-export * from './bake-shadows/bake-shadows';
-export * from './caustics/caustics';
-export * from './decal/decal';
-export * from './depth-buffer/depth-buffer';
-export * from './example/example';
-export * from './fbo/fbo';
-export * from './html/html';
-export * from './sampler/sampler';
-export * from './shadow/shadow';
-export * from './stats-gl/stats-gl';
-export * from './trail-texture/inject-trail-texture';
-export * from './trail/trail';
+export * from './lib/animations';
+export * from './lib/bake-shadows';
+export * from './lib/computed-attribute';
+export * from './lib/constants';
+export * from './lib/decal';
+export * from './lib/deprecated';
+export * from './lib/depth-buffer';
+export * from './lib/fbo';
+export * from './lib/sampler';

package/misc/lib/animations.d.ts

@@ -0,0 +1,14 @@
+import { ElementRef, Injector } from '@angular/core';
+import { AnimationAction, AnimationClip, AnimationMixer, Object3D } from 'three';
+export type NgtsAnimation<TAnimation extends AnimationClip = AnimationClip> = TAnimation[] | {
+    animations: TAnimation[];
+};
+export declare function injectAnimations<TAnimation extends AnimationClip>(animations: () => NgtsAnimation<TAnimation> | undefined | null, object: ElementRef<Object3D> | Object3D | (() => ElementRef<Object3D> | Object3D | undefined | null), { injector }?: {
+    injector?: Injector;
+}): {
+    clips: AnimationClip[];
+    mixer: AnimationMixer;
+    actions: { [key in TAnimation["name"]]: AnimationAction | null; };
+    names: TAnimation["name"][];
+    ready: import("@angular/core").WritableSignal<boolean>;
+};

package/misc/lib/computed-attribute.d.ts

@@ -0,0 +1,69 @@
+import { ElementRef } from '@angular/core';
+import { BufferAttribute, BufferGeometry } from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtsComputedAttribute {
+    compute: import("@angular/core").InputSignal<(geometry: BufferGeometry) => BufferAttribute>;
+    name: import("@angular/core").InputSignal<string>;
+    options: import("@angular/core").InputSignal<Partial<{
+        name?: string | undefined;
+        clone?: (() => BufferAttribute) | undefined;
+        toJSON?: (() => {
+            itemSize: number;
+            type: string;
+            array: number[];
+            normalized: boolean;
+        }) | undefined;
+        array?: import("three").TypedArray | undefined;
+        itemSize?: number | undefined;
+        usage?: import("three").Usage | undefined;
+        gpuType?: import("three").AttributeGPUType | undefined;
+        updateRange?: {
+            offset: number;
+            count: number;
+        } | undefined;
+        updateRanges?: {
+            start: number;
+            count: number;
+        }[] | undefined;
+        version?: number | undefined;
+        normalized?: boolean | undefined;
+        readonly count?: number | undefined;
+        needsUpdate?: boolean | undefined;
+        readonly isBufferAttribute?: true | undefined;
+        onUploadCallback?: (() => void) | undefined;
+        onUpload?: ((callback: () => void) => BufferAttribute) | undefined;
+        setUsage?: ((usage: import("three").Usage) => BufferAttribute) | undefined;
+        addUpdateRange?: ((start: number, count: number) => void) | undefined;
+        clearUpdateRanges?: (() => void) | undefined;
+        copy?: ((source: BufferAttribute) => BufferAttribute) | undefined;
+        copyAt?: ((index1: number, attribute: BufferAttribute, index2: number) => BufferAttribute) | undefined;
+        copyArray?: ((array: ArrayLike<number>) => BufferAttribute) | undefined;
+        applyMatrix3?: ((m: import("three").Matrix3) => BufferAttribute) | undefined;
+        applyMatrix4?: ((m: import("three").Matrix4) => BufferAttribute) | undefined;
+        applyNormalMatrix?: ((m: import("three").Matrix3) => BufferAttribute) | undefined;
+        transformDirection?: ((m: import("three").Matrix4) => BufferAttribute) | undefined;
+        set?: ((value: ArrayLike<number> | ArrayBufferView, offset?: number) => BufferAttribute) | undefined;
+        getComponent?: ((index: number, component: number) => number) | undefined;
+        setComponent?: ((index: number, component: number, value: number) => void) | undefined;
+        getX?: ((index: number) => number) | undefined;
+        setX?: ((index: number, x: number) => BufferAttribute) | undefined;
+        getY?: ((index: number) => number) | undefined;
+        setY?: ((index: number, y: number) => BufferAttribute) | undefined;
+        getZ?: ((index: number) => number) | undefined;
+        setZ?: ((index: number, z: number) => BufferAttribute) | undefined;
+        getW?: ((index: number) => number) | undefined;
+        setW?: ((index: number, z: number) => BufferAttribute) | undefined;
+        setXY?: ((index: number, x: number, y: number) => BufferAttribute) | undefined;
+        setXYZ?: ((index: number, x: number, y: number, z: number) => BufferAttribute) | undefined;
+        setXYZW?: ((index: number, x: number, y: number, z: number, w: number) => BufferAttribute) | undefined;
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        addEventListener: <TEventKey extends keyof import("angular-three").NgtNodeEventMap<BufferAttribute>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<BufferAttribute, typeof BufferAttribute>, ev: import("angular-three").NgtNodeEventMap<BufferAttribute>[TEventKey]) => any) => void;
+        removeEventListener: <TEventKey extends keyof import("angular-three").NgtNodeEventMap<BufferAttribute>>(type: TEventKey, listener: (this: import("angular-three").NgtNodeElement<BufferAttribute, typeof BufferAttribute>, ev: import("angular-three").NgtNodeEventMap<BufferAttribute>[TEventKey]) => any) => void;
+        __ngt_args__: [array: import("three").TypedArray, itemSize: number, normalized?: boolean | undefined];
+    }>>;
+    bufferAttribute: BufferAttribute;
+    primitive: import("@angular/core").Signal<ElementRef<BufferAttribute> | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsComputedAttribute, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsComputedAttribute, "ngts-computed-attribute", never, { "compute": { "alias": "compute"; "required": true; "isSignal": true; }; "name": { "alias": "name"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/misc/lib/constants.d.ts

@@ -0,0 +1 @@
+export declare function getVersion(): number;

package/misc/lib/decal.d.ts

@@ -0,0 +1,27 @@
+import { ElementRef } from '@angular/core';
+import { NgtMesh } from 'angular-three';
+import { Mesh, Texture } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsDecalOptions extends Partial<NgtMesh> {
+    polygonOffsetFactor: number;
+    depthTest: boolean;
+    debug: boolean;
+    map?: Texture;
+}
+export declare class NgtsDecal {
+    mesh: import("@angular/core").InputSignal<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> | ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>> | null | undefined>;
+    options: import("@angular/core").InputSignalWithTransform<NgtsDecalOptions, "" | Partial<NgtsDecalOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsDecalOptions, "position" | "scale" | "rotation" | "polygonOffsetFactor" | "depthTest" | "debug" | "map">>;
+    meshRef: import("@angular/core").Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>;
+    helperRef: import("@angular/core").Signal<ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>> | undefined>;
+    map: import("@angular/core").Signal<Texture | undefined>;
+    depthTest: import("@angular/core").Signal<boolean>;
+    polygonOffsetFactor: import("@angular/core").Signal<number>;
+    debug: import("@angular/core").Signal<boolean>;
+    private position;
+    private rotation;
+    private scale;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsDecal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsDecal, "ngts-decal", never, { "mesh": { "alias": "mesh"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/misc/lib/deprecated.d.ts

@@ -0,0 +1,14 @@
+import { BufferAttribute } from 'three';
+/**
+ * NOTE: Sets `BufferAttribute.updateRange` since r159.
+ */
+export declare const setUpdateRange: (attribute: BufferAttribute, updateRange: {
+    offset: number;
+    count: number;
+}) => void;
+export declare const LinearEncoding = 3000;
+export declare const sRGBEncoding = 3001;
+/**
+ * NOTE: TextureEncoding was deprecated in r152, and removed in r162.
+ */
+export type TextureEncoding = typeof LinearEncoding | typeof sRGBEncoding;

package/misc/lib/depth-buffer.d.ts

@@ -0,0 +1,8 @@
+import { Injector } from '@angular/core';
+import { DepthTexture } from 'three';
+export declare function injectDepthBuffer(params?: () => {
+    size?: number;
+    frames?: number;
+}, { injector }?: {
+    injector?: Injector;
+}): import("@angular/core").Signal<DepthTexture | null>;

package/misc/lib/fbo.d.ts

@@ -0,0 +1,47 @@
+import { Injector, TemplateRef, ViewContainerRef } from '@angular/core';
+import { ColorSpace, DepthTexture, MagnificationTextureFilter, MinificationTextureFilter, TextureDataType, WebGLRenderTarget, Wrapping } from 'three';
+import { TextureEncoding } from './deprecated';
+import * as i0 from "@angular/core";
+interface FBOSettings {
+    /** Defines the count of MSAA samples. Can only be used with WebGL 2. Default: 0 */
+    samples?: number;
+    /** If set, the scene depth will be rendered into buffer.depthTexture. Default: false */
+    depth?: boolean;
+    wrapS?: Wrapping | undefined;
+    wrapT?: Wrapping | undefined;
+    magFilter?: MagnificationTextureFilter | undefined;
+    minFilter?: MinificationTextureFilter | undefined;
+    format?: number | undefined;
+    type?: TextureDataType | undefined;
+    anisotropy?: number | undefined;
+    depthBuffer?: boolean | undefined;
+    stencilBuffer?: boolean | undefined;
+    generateMipmaps?: boolean | undefined;
+    depthTexture?: DepthTexture | undefined;
+    encoding?: TextureEncoding | undefined;
+    colorSpace?: ColorSpace | undefined;
+}
+export interface NgtsFBOParams {
+    width?: number | FBOSettings;
+    height?: number;
+    settings?: FBOSettings;
+}
+export declare function injectFBO(params: () => NgtsFBOParams, { injector }?: {
+    injector?: Injector;
+}): import("@angular/core").Signal<WebGLRenderTarget<import("three").Texture>>;
+export declare class NgtsFBO {
+    fbo: import("@angular/core").InputSignal<{
+        width: NgtsFBOParams["width"];
+        height: NgtsFBOParams["height"];
+    } & FBOSettings>;
+    template: TemplateRef<any>;
+    viewContainerRef: ViewContainerRef;
+    fboTarget: import("@angular/core").Signal<WebGLRenderTarget<import("three").Texture>>;
+    constructor();
+    static ngTemplateContextGuard(_: NgtsFBO, ctx: unknown): ctx is {
+        $implicit: ReturnType<typeof injectFBO>;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsFBO, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsFBO, "ng-template[fbo]", never, { "fbo": { "alias": "fbo"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/misc/lib/sampler.d.ts

@@ -0,0 +1,73 @@
+import { ElementRef, Injector } from '@angular/core';
+import { NgtGroup } from 'angular-three';
+import { BufferGeometry, Color, Group, InstancedBufferAttribute, InstancedMesh, Mesh, Object3D, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+interface SamplePayload {
+    /**
+     * The position of the sample.
+     */
+    position: Vector3;
+    /**
+     * The normal of the mesh at the sampled position.
+     */
+    normal: Vector3;
+    /**
+     * The vertex color of the mesh at the sampled position.
+     */
+    color: Color;
+}
+export type TransformFn = (payload: TransformPayload, i: number) => void;
+interface TransformPayload extends SamplePayload {
+    /**
+     * The dummy object used to transform each instance.
+     * This object's matrix will be updated after transforming & it will be used
+     * to set the instance's matrix.
+     */
+    dummy: Object3D;
+    /**
+     * The mesh that's initially passed to the sampler.
+     * Use this if you need to apply transforms from your mesh to your instances
+     * or if you need to grab attributes from the geometry.
+     */
+    sampledMesh: Mesh;
+}
+export declare function injectSurfaceSampler(mesh: () => ElementRef<Mesh> | Mesh | null | undefined, options?: () => {
+    count?: number;
+    transform?: TransformFn;
+    weight?: string;
+    instanceMesh?: ElementRef<InstancedMesh> | InstancedMesh | null;
+}, { injector }?: {
+    injector?: Injector;
+}): import("@angular/core").Signal<InstancedBufferAttribute>;
+export interface NgtsSamplerOptions extends Partial<NgtGroup> {
+    /**
+     * The NAME of the weight attribute to use when sampling.
+     *
+     * @see https://threejs.org/docs/#examples/en/math/MeshSurfaceSampler.setWeightAttribute
+     */
+    weight?: string;
+    /**
+     * Transformation to be applied to each instance.
+     * Receives a dummy object3D with all the sampled data ( @see TransformPayload ).
+     * It should mutate `transformPayload.dummy`.
+     *
+     * @see ( @todo add link to example )
+     *
+     * There is no need to update the dummy's matrix
+     */
+    transform?: TransformFn;
+    count: number;
+}
+export declare class NgtsSampler {
+    mesh: import("@angular/core").InputSignal<Mesh<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> | ElementRef<Mesh<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>> | null>;
+    instances: import("@angular/core").InputSignal<InstancedMesh<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").InstancedMeshEventMap> | ElementRef<InstancedMesh<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").InstancedMeshEventMap>> | null>;
+    options: import("@angular/core").InputSignalWithTransform<NgtsSamplerOptions, "" | Partial<NgtsSamplerOptions>>;
+    parameters: import("@angular/core").Signal<Omit<NgtsSamplerOptions, "count" | "transform" | "weight">>;
+    group: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    private meshToSample;
+    private instancedToSample;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsSampler, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsSampler, "ngts-sampler", never, { "mesh": { "alias": "mesh"; "required": false; "isSignal": true; }; "instances": { "alias": "instances"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-three-soba",
-  "version": "2.0.0-beta.26",
+  "version": "2.0.0-beta.261",
   "publishConfig": {
     "access": "public"
   },
@@ -45,29 +45,17 @@
       "esm": "./esm2022/cameras/angular-three-soba-cameras.mjs",
       "default": "./fesm2022/angular-three-soba-cameras.mjs"
     },
-    "./gizmos": {
-      "types": "./gizmos/index.d.ts",
-      "esm2022": "./esm2022/gizmos/angular-three-soba-gizmos.mjs",
-      "esm": "./esm2022/gizmos/angular-three-soba-gizmos.mjs",
-      "default": "./fesm2022/angular-three-soba-gizmos.mjs"
-    },
-    "./controls": {
-      "types": "./controls/index.d.ts",
-      "esm2022": "./esm2022/controls/angular-three-soba-controls.mjs",
-      "esm": "./esm2022/controls/angular-three-soba-controls.mjs",
-      "default": "./fesm2022/angular-three-soba-controls.mjs"
-    },
     "./loaders": {
       "types": "./loaders/index.d.ts",
       "esm2022": "./esm2022/loaders/angular-three-soba-loaders.mjs",
       "esm": "./esm2022/loaders/angular-three-soba-loaders.mjs",
       "default": "./fesm2022/angular-three-soba-loaders.mjs"
     },
-    "./materials": {
-      "types": "./materials/index.d.ts",
-      "esm2022": "./esm2022/materials/angular-three-soba-materials.mjs",
-      "esm": "./esm2022/materials/angular-three-soba-materials.mjs",
-      "default": "./fesm2022/angular-three-soba-materials.mjs"
+    "./controls": {
+      "types": "./controls/index.d.ts",
+      "esm2022": "./esm2022/controls/angular-three-soba-controls.mjs",
+      "esm": "./esm2022/controls/angular-three-soba-controls.mjs",
+      "default": "./fesm2022/angular-three-soba-controls.mjs"
     },
     "./misc": {
       "types": "./misc/index.d.ts",
@@ -75,17 +63,11 @@
       "esm": "./esm2022/misc/angular-three-soba-misc.mjs",
       "default": "./fesm2022/angular-three-soba-misc.mjs"
     },
-    "./modifiers": {
-      "types": "./modifiers/index.d.ts",
-      "esm2022": "./esm2022/modifiers/angular-three-soba-modifiers.mjs",
-      "esm": "./esm2022/modifiers/angular-three-soba-modifiers.mjs",
-      "default": "./fesm2022/angular-three-soba-modifiers.mjs"
-    },
-    "./performances": {
-      "types": "./performances/index.d.ts",
-      "esm2022": "./esm2022/performances/angular-three-soba-performances.mjs",
-      "esm": "./esm2022/performances/angular-three-soba-performances.mjs",
-      "default": "./fesm2022/angular-three-soba-performances.mjs"
+    "./materials": {
+      "types": "./materials/index.d.ts",
+      "esm2022": "./esm2022/materials/angular-three-soba-materials.mjs",
+      "esm": "./esm2022/materials/angular-three-soba-materials.mjs",
+      "default": "./fesm2022/angular-three-soba-materials.mjs"
     },
     "./shaders": {
       "types": "./shaders/index.d.ts",
@@ -99,30 +81,70 @@
       "esm": "./esm2022/staging/angular-three-soba-staging.mjs",
       "default": "./fesm2022/angular-three-soba-staging.mjs"
     },
-    "./utils": {
-      "types": "./utils/index.d.ts",
-      "esm2022": "./esm2022/utils/angular-three-soba-utils.mjs",
-      "esm": "./esm2022/utils/angular-three-soba-utils.mjs",
-      "default": "./fesm2022/angular-three-soba-utils.mjs"
+    "./vanilla-exports": {
+      "types": "./vanilla-exports/index.d.ts",
+      "esm2022": "./esm2022/vanilla-exports/angular-three-soba-vanilla-exports.mjs",
+      "esm": "./esm2022/vanilla-exports/angular-three-soba-vanilla-exports.mjs",
+      "default": "./fesm2022/angular-three-soba-vanilla-exports.mjs"
     }
   },
   "peerDependencies": {
-    "@angular/common": "^16.0.0",
-    "@angular/core": "^16.0.0",
-    "angular-three": "^2.0.0",
+    "@angular/common": ">=18.0.0",
+    "@angular/core": ">=18.0.0",
+    "@monogrid/gainmap-js": "^3.0.0",
+    "@pmndrs/vanilla": "^1.19.0",
+    "camera-controls": "^2.8.0",
+    "hls.js": "^1.5.0",
     "meshline": "^3.1.0",
     "stats-gl": "^1.0.0",
     "stats.js": "^0.17.0",
     "three": ">=0.148.0",
+    "three-custom-shader-material": "^5.4.0",
     "three-mesh-bvh": "^0.5.0 || ^0.6.0",
     "three-stdlib": "^2.0.0",
     "troika-three-text": "^0.47.0"
   },
+  "peerDependenciesMeta": {
+    "@monogrid/gainmap-js": {
+      "optional": true
+    },
+    "@pmndrs/vanilla": {
+      "optional": true
+    },
+    "hls.js": {
+      "optional": true
+    },
+    "troika-three-text": {
+      "optional": true
+    },
+    "three-custom-shader-material": {
+      "optional": true
+    },
+    "three-mesh-bvh": {
+      "optional": true
+    },
+    "meshline": {
+      "optional": true
+    },
+    "camera-controls": {
+      "optional": true
+    },
+    "stats-gl": {
+      "optional": true
+    },
+    "stats.js": {
+      "optional": true
+    }
+  },
   "dependencies": {
     "tslib": "^2.3.0"
   },
   "sideEffects": false,
-  "web-types": "./web-types.json",
+  "web-types": [
+    "../../node_modules/angular-three/web-types.json",
+    "../../node_modules/angular-three-soba/web-types.json",
+    "./web-types.json"
+  ],
   "module": "fesm2022/angular-three-soba.mjs",
   "typings": "index.d.ts"
 }

package/shaders/index.d.ts

@@ -1,17 +1,2 @@
-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';
+export * from './lib/grid-material';
+export * from './lib/mesh-refraction-material';

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

@@ -0,0 +1,69 @@
+import { NgtMaterial } from 'angular-three';
+import { Color, ColorRepresentation, Side, Vector3 } from 'three';
+export interface GridMaterialOptions {
+    /** Cell size, default: 0.5 */
+    cellSize: number;
+    /** Cell thickness, default: 0.5 */
+    cellThickness: number;
+    /** Cell color, default: black */
+    cellColor: ColorRepresentation;
+    /** Section size, default: 1 */
+    sectionSize: number;
+    /** Section thickness, default: 1 */
+    sectionThickness: number;
+    /** Section color, default: #2080ff */
+    sectionColor: 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;
+    /** Fade from camera (1) or origin (0), or somewhere in between, default: camera */
+    fadeFrom: number;
+    /** Material side, default: THREE.BackSide */
+    side: Side;
+}
+export declare const GridMaterial: (new (parameters?: (import("three").ShaderMaterialParameters & Partial<{
+    cellSize: number;
+    sectionSize: number;
+    fadeDistance: number;
+    fadeStrength: number;
+    fadeFrom: number;
+    cellThickness: number;
+    sectionThickness: number;
+    cellColor: Color;
+    sectionColor: Color;
+    infiniteGrid: false;
+    followCamera: false;
+    worldCamProjPosition: Vector3;
+    worldPlanePosition: Vector3;
+}>) | undefined) => import("three").ShaderMaterial & {
+    cellSize: number;
+    sectionSize: number;
+    fadeDistance: number;
+    fadeStrength: number;
+    fadeFrom: number;
+    cellThickness: number;
+    sectionThickness: number;
+    cellColor: Color;
+    sectionColor: Color;
+    infiniteGrid: false;
+    followCamera: false;
+    worldCamProjPosition: Vector3;
+    worldPlanePosition: Vector3;
+}) & {
+    key: string;
+};
+export type NgtGridMaterial = NgtMaterial<InstanceType<typeof GridMaterial>, [GridMaterialOptions]>;
+declare global {
+    interface HTMLElementTagNameMap {
+        /**
+         * @extends ngt-shader-material
+         * @options GridMaterialOptions
+         */
+        'ngt-grid-material': NgtGridMaterial;
+    }
+}

package/shaders/lib/mesh-refraction-material.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+declare module 'three-mesh-bvh' {
+    const shaderIntersectFunction: string;
+}
+export declare const MeshRefractionMaterial: (new (parameters?: (THREE.ShaderMaterialParameters & Partial<{
+    [name: string]: number | boolean | any[] | THREE.Color | THREE.CubeTexture | THREE.Texture | Int32Array | Float32Array | THREE.Matrix4 | THREE.Matrix3 | THREE.Quaternion | THREE.Vector4 | THREE.Vector3 | THREE.Vector2 | null;
+}>) | undefined) => THREE.ShaderMaterial & {
+    [name: string]: number | boolean | any[] | THREE.Color | THREE.CubeTexture | THREE.Texture | Int32Array | Float32Array | THREE.Matrix4 | THREE.Matrix3 | THREE.Quaternion | THREE.Vector4 | THREE.Vector3 | THREE.Vector2 | null;
+}) & {
+    key: string;
+};