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

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "angular-three-soba",
-  "version": "1.14.1",
+  "version": "2.0.0-beta.10",
   "publishConfig": {
     "access": "public"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/angular-threejs/soba"
+    "url": "https://github.com/angular-threejs/angular-three/tree/main/libs/soba"
   },
   "author": {
     "name": "Chau Tran",
@@ -17,7 +17,9 @@
   "keywords": [
     "angular",
     "threejs",
-    "renderer"
+    "renderer",
+    "utilities",
+    "shaders"
   ],
   "license": "MIT",
   "exports": {
@@ -37,23 +39,17 @@
       "esm": "./esm2022/abstractions/angular-three-soba-abstractions.mjs",
       "default": "./fesm2022/angular-three-soba-abstractions.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"
-    },
     "./cameras": {
       "types": "./cameras/index.d.ts",
       "esm2022": "./esm2022/cameras/angular-three-soba-cameras.mjs",
       "esm": "./esm2022/cameras/angular-three-soba-cameras.mjs",
       "default": "./fesm2022/angular-three-soba-cameras.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"
     },
     "./loaders": {
       "types": "./loaders/index.d.ts",
@@ -61,17 +57,29 @@
       "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"
+    },
     "./misc": {
       "types": "./misc/index.d.ts",
       "esm2022": "./esm2022/misc/angular-three-soba-misc.mjs",
       "esm": "./esm2022/misc/angular-three-soba-misc.mjs",
       "default": "./fesm2022/angular-three-soba-misc.mjs"
     },
-    "./performance": {
-      "types": "./performance/index.d.ts",
-      "esm2022": "./esm2022/performance/angular-three-soba-performance.mjs",
-      "esm": "./esm2022/performance/angular-three-soba-performance.mjs",
-      "default": "./fesm2022/angular-three-soba-performance.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"
     },
     "./shaders": {
       "types": "./shaders/index.d.ts",
@@ -84,28 +92,31 @@
       "esm2022": "./esm2022/staging/angular-three-soba-staging.mjs",
       "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"
     }
   },
   "peerDependencies": {
-    "@angular/common": "^15.1.0 || ^16.0.0",
-    "@angular/core": "^15.1.0 || ^16.0.0",
-    "angular-three": "^1.0.0",
+    "@angular/common": "^16.0.0",
+    "@angular/core": "^16.0.0",
+    "angular-three": "^2.0.0",
+    "meshline": "^3.1.0",
+    "stats-gl": "^1.0.0",
     "stats.js": "^0.17.0",
-    "three": "^0.148.0 || ^0.149.0 || ^0.150.0 || ^0.151.0 || ^0.152.0",
-    "three-mesh-bvh": "^0.5.0",
+    "three": ">=0.148.0",
+    "three-mesh-bvh": "^0.5.0 || ^0.6.0",
     "three-stdlib": "^2.0.0",
-    "troika-three-text": "^0.47.0",
-    "rxjs": "7.8.1",
-    "@rx-angular/state": "15.0.0"
+    "troika-three-text": "^0.47.0"
   },
   "dependencies": {
-    "tslib": "^2.3.0",
-    "@nx/devkit": "^15.0.0 || ^16.0.0",
-    "nx": "^15.0.0 || ^16.0.0"
+    "tslib": "^2.3.0"
   },
   "sideEffects": false,
-  "generators": "./plugin/generators.json",
-  "schematics": "./plugin/generators.json",
+  "web-types": "./web-types.json",
   "module": "fesm2022/angular-three-soba.mjs",
   "typings": "index.d.ts"
 }

package/performances/README.md

@@ -0,0 +1,3 @@
+# angular-three-soba/performances
+
+Secondary entry point of `angular-three-soba`. It can be used by importing from `angular-three-soba/performances`.

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';