angular-three-soba 2.0.0-beta.3 → 2.0.0-beta.30

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/adaptive → performances/adaptive-events}/adaptive-events.d.ts

@@ -1,5 +1,8 @@
 import * as i0 from "@angular/core";
 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,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,79 @@
+import { 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;
+    }): {
+        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): {
+        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,92 @@
+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;
+    }): {
+        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): {
+        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,124 @@
+import { 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;
+    }): 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/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 './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';
 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';