@3driseai/3drise-viewer 0.1.1

package/dist/services/AnimationsManager.js

@@ -0,0 +1,58 @@
+import { applyEasing, resolveEasing } from '@3driseai/3drise-core';
+/**
+ * Lightweight AnimationsManager for the viewer package.
+ * Provides the event bus, path registry, and easing helpers.
+ * Sequence playback (GSAP timelines) is handled by the application layer.
+ */
+class AnimationsManager {
+    listeners = new Map([
+        ['sequenceStart', new Set()],
+        ['sequenceEnd', new Set()],
+        ['stepStart', new Set()],
+        ['stepEnd', new Set()],
+    ]);
+    paths = new Map();
+    on(type, listener) {
+        this.listeners.get(type)?.add(listener);
+    }
+    off(type, listener) {
+        this.listeners.get(type)?.delete(listener);
+    }
+    emit(event) {
+        this.listeners.get(event.type)?.forEach(l => {
+            try {
+                l(event);
+            }
+            catch (e) {
+                console.error('[AnimationsManager] listener error:', e);
+            }
+        });
+    }
+    getProgressFromTime(startTime, duration, ease = 'linear') {
+        const linear = Math.min((performance.now() - startTime) / 1000 / duration, 1);
+        return applyEasing(resolveEasing(ease), linear);
+    }
+    reverseSteps(sequence) {
+        return {
+            ...sequence,
+            steps: [...sequence.steps].reverse().map(step => ({
+                ...step,
+                transitions: step.transitions.map(t => ({
+                    ...t,
+                    properties: { from: t.properties.to, to: t.properties.from ?? {} },
+                })),
+            })),
+        };
+    }
+    addPath(path) { this.paths.set(path.id, path); }
+    getPath(id) { return this.paths.get(id); }
+    getAllPaths() { return [...this.paths.values()]; }
+    updatePath(id, updates) {
+        const p = this.paths.get(id);
+        if (p)
+            this.paths.set(id, { ...p, ...updates });
+    }
+    deletePath(id) { this.paths.delete(id); }
+    clearPaths() { this.paths.clear(); }
+}
+export default new AnimationsManager();

package/dist/services/FontManager.d.ts

@@ -0,0 +1,32 @@
+export interface FontInfo {
+    name: string;
+    displayName: string;
+    googleFont: string;
+    threejsFont?: string;
+    category: 'sans-serif' | 'serif' | 'display' | 'monospace';
+    isLoaded: boolean;
+}
+declare class FontManager {
+    private static instance;
+    private fonts;
+    private loadingPromises;
+    private readonly CURATED_FONTS;
+    constructor();
+    static getInstance(): FontManager;
+    getAllFonts(): FontInfo[];
+    getFont(name: string): FontInfo | undefined;
+    getBitmapFont(name: string): string | undefined;
+    get3DFont(name: string): string | undefined;
+    getFontsByCategory(category: FontInfo['category']): FontInfo[];
+    isFontLoaded(name: string): boolean;
+    getDefaultFont(): FontInfo;
+    loadFont(name: string): Promise<void>;
+    getFontOptions(): Array<{
+        value: string;
+        label: string;
+        category: string;
+    }>;
+}
+export declare const fontManager: FontManager;
+export default FontManager;
+//# sourceMappingURL=FontManager.d.ts.map

package/dist/services/FontManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FontManager.d.ts","sourceRoot":"","sources":["../../src/services/FontManager.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,YAAY,GAAG,OAAO,GAAG,SAAS,GAAG,WAAW,CAAC;IAC3D,QAAQ,EAAE,OAAO,CAAC;CACrB;AAmBD,cAAM,WAAW;IACb,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAQ;IAC/B,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAgB5B;;IAMF,MAAM,CAAC,WAAW,IAAI,WAAW;IAKjC,WAAW,IAAI,QAAQ,EAAE;IACzB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAC3C,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAC/C,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAC3C,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,QAAQ,EAAE;IAC9D,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IACnC,cAAc,IAAI,QAAQ;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAc3C,cAAc,IAAI,KAAK,CAAC;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;KACpB,CAAC;CAGb;AACD,eAAO,MAAM,WAAW,EAAE,WAAuC,CAAC;AAClE,eAAe,WAAW,CAAC"}

package/dist/services/FontManager.js

@@ -0,0 +1,76 @@
+const loadGoogleFont = (fontUrl) => {
+    return new Promise((resolve, reject) => {
+        if (typeof document === 'undefined') {
+            resolve();
+            return;
+        }
+        if (document.querySelector(`link[href="${fontUrl}"]`)) {
+            resolve();
+            return;
+        }
+        const link = document.createElement('link');
+        link.rel = 'stylesheet';
+        link.href = fontUrl;
+        link.onload = () => resolve();
+        link.onerror = () => reject(new Error(`Failed to load font: ${fontUrl}`));
+        document.head.appendChild(link);
+    });
+};
+class FontManager {
+    static instance = null;
+    fonts = new Map();
+    loadingPromises = new Map();
+    CURATED_FONTS = [
+        { name: 'roboto', displayName: 'Roboto', googleFont: 'https://fonts.gstatic.com/s/roboto/v30/KFOmCnqEu92Fr1Me5WZLCzYlKw.ttf', threejsFont: 'https://threejs.org/examples/fonts/droid/droid_sans_regular.typeface.json', category: 'sans-serif' },
+        { name: 'opensans', displayName: 'Open Sans', googleFont: 'https://fonts.gstatic.com/s/opensans/v34/memSYaGs126MiZpBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsjZ0C4nY1M2xLER.ttf', threejsFont: 'https://threejs.org/examples/fonts/helvetiker_regular.typeface.json', category: 'sans-serif' },
+        { name: 'lato', displayName: 'Lato', googleFont: 'https://fonts.gstatic.com/s/lato/v24/S6uyw4BMUTPHvxk6XweuBCY.ttf', threejsFont: 'https://threejs.org/examples/fonts/helvetiker_regular.typeface.json', category: 'sans-serif' },
+        { name: 'poppins', displayName: 'Poppins', googleFont: 'https://fonts.gstatic.com/s/poppins/v20/pxiEyp8kv8JHgFVrFJDUc1NECPY.ttf', threejsFont: 'https://threejs.org/examples/fonts/helvetiker_regular.typeface.json', category: 'sans-serif' },
+        { name: 'merriweather', displayName: 'Merriweather', googleFont: 'https://fonts.gstatic.com/s/merriweather/v30/u-440qyriQwlOrhSvowK_l5OeyxNV-bnrw.ttf', threejsFont: 'https://threejs.org/examples/fonts/droid/droid_serif_regular.typeface.json', category: 'serif' },
+        { name: 'playfair', displayName: 'Playfair Display', googleFont: 'https://fonts.gstatic.com/s/playfairdisplay/v30/nuFvD-vYSZviVYUb_rj3ij__anPXJzDwcbmjWBN2PKdFvUDQZNLo_U2r.ttf', threejsFont: 'https://threejs.org/examples/fonts/droid/droid_serif_bold.typeface.json', category: 'serif' },
+        { name: 'bebas', displayName: 'Bebas Neue', googleFont: 'https://fonts.gstatic.com/s/bebasneue/v10/JTUSjIg69CK48gW7PXooxW5rygbi49c.ttf', threejsFont: 'https://threejs.org/examples/fonts/gentilis_bold.typeface.json', category: 'display' },
+        { name: 'lobster', displayName: 'Lobster', googleFont: 'https://fonts.gstatic.com/s/lobster/v30/neILzCirqoswsqX9_oWsMqEzSJQ.ttf', threejsFont: 'https://threejs.org/examples/fonts/gentilis_regular.typeface.json', category: 'display' },
+        { name: 'robotomono', displayName: 'Roboto Mono', googleFont: 'https://fonts.gstatic.com/s/robotomono/v23/L0xuDF4xlVMF-BfR8bXMIhJHg45mwgGEFl0_3vuPQ--5Ip2sSQ.ttf', threejsFont: 'https://threejs.org/examples/fonts/helvetiker_regular.typeface.json', category: 'monospace' },
+        { name: 'jetbrainsmono', displayName: 'JetBrains Mono', googleFont: 'https://fonts.gstatic.com/s/jetbrainsmono/v18/tDbY2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yK1jPVmUsaaDhw.ttf', threejsFont: 'https://threejs.org/examples/fonts/helvetiker_regular.typeface.json', category: 'monospace' },
+        { name: 'courierprime', displayName: 'Courier Prime', googleFont: 'https://fonts.gstatic.com/s/courierprime/v9/u-450q2lgwslOqpF_6gQ8kELWwZjW-_-tvg.ttf', threejsFont: 'https://threejs.org/examples/fonts/helvetiker_regular.typeface.json', category: 'monospace' },
+        { name: 'ubuntumono', displayName: 'Ubuntu Mono', googleFont: 'https://fonts.gstatic.com/s/ubuntumono/v17/KFOjCneDtsqEr0keqCMhbBc9AMX6lJBP.ttf', threejsFont: 'https://threejs.org/examples/fonts/helvetiker_regular.typeface.json', category: 'monospace' },
+        { name: 'ptmono', displayName: 'PT Mono', googleFont: 'https://fonts.gstatic.com/s/ptmono/v13/9oRONYoBnWILk-9ArCg5MtPyAcg.ttf', threejsFont: 'https://threejs.org/examples/fonts/helvetiker_regular.typeface.json', category: 'monospace' },
+        { name: 'cousine', displayName: 'Cousine', googleFont: 'https://fonts.gstatic.com/s/cousine/v27/d6lIkaiiRdih4SpPzSMlzTbtz9k.ttf', threejsFont: 'https://threejs.org/examples/fonts/helvetiker_regular.typeface.json', category: 'monospace' },
+        { name: 'novamono', displayName: 'Nova Mono', googleFont: 'https://fonts.gstatic.com/s/novamono/v18/Cn-0JtiGWQ5Ajb--MRKfYGxYrdM9Sg.ttf', threejsFont: 'https://threejs.org/examples/fonts/helvetiker_regular.typeface.json', category: 'monospace' },
+    ];
+    constructor() {
+        this.CURATED_FONTS.forEach(fontData => {
+            this.fonts.set(fontData.name, { ...fontData, isLoaded: false });
+        });
+    }
+    static getInstance() {
+        if (!FontManager.instance)
+            FontManager.instance = new FontManager();
+        return FontManager.instance;
+    }
+    getAllFonts() { return Array.from(this.fonts.values()); }
+    getFont(name) { return this.fonts.get(name); }
+    getBitmapFont(name) { return this.fonts.get(name)?.googleFont; }
+    get3DFont(name) { return this.fonts.get(name)?.threejsFont; }
+    getFontsByCategory(category) { return Array.from(this.fonts.values()).filter(f => f.category === category); }
+    isFontLoaded(name) { return this.fonts.get(name)?.isLoaded || false; }
+    getDefaultFont() { return this.fonts.get('roboto'); }
+    async loadFont(name) {
+        const font = this.fonts.get(name);
+        if (!font)
+            throw new Error(`Font not found: ${name}`);
+        if (font.isLoaded)
+            return;
+        if (this.loadingPromises.has(name))
+            return this.loadingPromises.get(name);
+        const promise = loadGoogleFont(font.googleFont)
+            .then(() => { font.isLoaded = true; this.loadingPromises.delete(name); })
+            .catch(error => { this.loadingPromises.delete(name); throw error; });
+        this.loadingPromises.set(name, promise);
+        return promise;
+    }
+    getFontOptions() {
+        return Array.from(this.fonts.values()).map(f => ({ value: f.name, label: f.displayName, category: f.category }));
+    }
+}
+export const fontManager = FontManager.getInstance();
+export default FontManager;

package/dist/services/TexturesManager.d.ts

@@ -0,0 +1,17 @@
+import type { Texture } from 'three';
+export type TextureType = 'clouds' | 'grass' | 'terrain' | 'grounds' | 'images';
+declare class TexturesManager {
+    private textures;
+    private texturesByType;
+    private loader;
+    constructor();
+    loadTexture(name: string, url: string, type?: TextureType): Promise<Texture>;
+    getTextureByUrl(url: string): Texture | undefined;
+    getTexture(key: string): Texture | undefined;
+    addTexture(key: string, texture: Texture, width: number, height: number, isLandscape: boolean): void;
+    removeTexture(key: string): void;
+    clear(): void;
+}
+declare const texturesManager: TexturesManager;
+export default texturesManager;
+//# sourceMappingURL=TexturesManager.d.ts.map

package/dist/services/TexturesManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TexturesManager.d.ts","sourceRoot":"","sources":["../../src/services/TexturesManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AACrC,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEhF,cAAM,eAAe;IACjB,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,MAAM,CAAC;;IAKT,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBlF,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAOjD,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAG5C,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,GAAG,IAAI;IAGpG,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAChC,KAAK,IAAI,IAAI;CAChB;AACD,QAAA,MAAM,eAAe,EAAE,eAAuC,CAAC;AAC/D,eAAe,eAAe,CAAC"}

package/dist/services/TexturesManager.js

@@ -0,0 +1,48 @@
+import { TextureLoader } from 'three';
+class TexturesManager {
+    textures = new Map();
+    texturesByType = new Map();
+    loader;
+    constructor() {
+        this.loader = new TextureLoader();
+        ['images', 'clouds', 'grass', 'terrain', 'grounds'].forEach(t => this.texturesByType.set(t, new Map()));
+    }
+    async loadTexture(name, url, type) {
+        if (type && this.texturesByType.get(type)?.has(name)) {
+            return this.texturesByType.get(type).get(name).texture;
+        }
+        const img = await new Promise((resolve, reject) => {
+            const image = new window.Image();
+            image.crossOrigin = 'Anonymous';
+            image.onload = () => resolve(image);
+            image.onerror = reject;
+            image.src = url;
+        });
+        const { width, height } = img;
+        const isLandscape = width > height;
+        return new Promise((resolve, reject) => {
+            this.loader.load(url, (texture) => {
+                if (type)
+                    this.texturesByType.get(type)?.set(name, { texture, width, height, isLandscape });
+                resolve(texture);
+            }, undefined, reject);
+        });
+    }
+    getTextureByUrl(url) {
+        for (const [, value] of this.textures.entries()) {
+            if (value.texture.image?.src === url)
+                return value.texture;
+        }
+        return undefined;
+    }
+    getTexture(key) {
+        return this.textures.get(key)?.texture;
+    }
+    addTexture(key, texture, width, height, isLandscape) {
+        this.textures.set(key, { texture, width, height, isLandscape });
+    }
+    removeTexture(key) { this.textures.delete(key); }
+    clear() { this.textures.clear(); }
+}
+const texturesManager = new TexturesManager();
+export default texturesManager;

package/dist/shaders/RainMaterial.d.ts

@@ -0,0 +1,34 @@
+import * as THREE from "three";
+export interface RainMaterialUniforms {
+    uColor: {
+        value: THREE.Color;
+    };
+    opacity: {
+        value: number;
+    };
+    windAngle: {
+        value: number;
+    };
+    windTilt: {
+        value: number;
+    };
+    streakLength: {
+        value: number;
+    };
+}
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        rainMaterial: any;
+    }
+}
+declare const RainMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    uColor: THREE.Color;
+    opacity: number;
+    windAngle: number;
+    windTilt: number;
+    streakLength: number;
+}> & {
+    key: string;
+};
+export { RainMaterial };
+//# sourceMappingURL=RainMaterial.d.ts.map

package/dist/shaders/RainMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RainMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/RainMaterial.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,MAAM,WAAW,oBAAoB;IACjC,MAAM,EAAE;QACJ,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;KACtB,CAAC;IACF,OAAO,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAED,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,YAAY,EAAE,GAAG,CAAC;KACrB;CACJ;AA8CD,QAAA,MAAM,YAAY;;;;;;;;CAMc,CAAC;AAEjC,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/shaders/RainMaterial.js

@@ -0,0 +1,56 @@
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+import * as THREE from "three";
+const vertexShader = /*glsl*/ `
+  attribute float speed;
+  varying float vSpeed;
+  uniform float windAngle;
+  uniform float windTilt;
+  uniform float streakLength;
+
+  void main() {
+    vSpeed = speed;
+    vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
+    gl_PointSize = 12.0 * streakLength * (200.0 / -mvPosition.z);
+    gl_PointSize = clamp(gl_PointSize, 1.0, 64.0);
+    gl_Position = projectionMatrix * mvPosition;
+  }
+`;
+const fragmentShader = /*glsl*/ `
+  varying float vSpeed;
+  uniform vec3 uColor;
+  uniform float opacity;
+  uniform float windAngle;
+  uniform float windTilt;
+  uniform float streakLength;
+
+  void main() {
+    vec2 uv = gl_PointCoord - vec2(0.5);
+    float angle = windAngle * windTilt;
+    float ca = cos(angle);
+    float sa = sin(angle);
+    vec2 rotUv = vec2(
+      uv.x * ca - uv.y * sa,
+      uv.x * sa + uv.y * ca
+    );
+    float aspectRatio = max(streakLength, 1.0);
+    rotUv.x *= aspectRatio;
+    float dist = length(rotUv);
+    float core = 1.0 - smoothstep(0.0, 0.15, dist);
+    float glow = (1.0 - smoothstep(0.1, 0.4, dist)) * 0.3;
+    float alpha = (core + glow) * opacity;
+    float gradient = smoothstep(-0.5, 0.2, rotUv.y) * 0.3 + 0.7;
+    alpha *= gradient;
+    if (alpha < 0.01) discard;
+    gl_FragColor = vec4(uColor, alpha);
+  }
+`;
+const RainMaterial = shaderMaterial({
+    uColor: new THREE.Color(0.7, 0.75, 0.85),
+    opacity: 0.5,
+    windAngle: 0.0,
+    windTilt: 0.0,
+    streakLength: 3.0,
+}, vertexShader, fragmentShader);
+extend({ RainMaterial });
+export { RainMaterial };

package/dist/shaders/ShaderEffectsMaterial.d.ts

@@ -0,0 +1,228 @@
+import { Vector2, Color } from 'three';
+import type { Texture } from 'three';
+export interface ShaderEffectsMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_pointer: {
+        value: Vector2;
+    };
+    uPointSize: {
+        value: number;
+    };
+    uTexture: {
+        value: Texture | null;
+    };
+    uTargetTexture: {
+        value: Texture | null;
+    };
+    uMorphProgress: {
+        value: number;
+    };
+    uColor: {
+        value: Color;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uNormalizationScale: {
+        value: number;
+    };
+    uGenVertexType: {
+        value: number;
+    };
+    uGenVertexEnabled: {
+        value: boolean;
+    };
+    uGenVertexIntensity: {
+        value: number;
+    };
+    uGenVertexSpeed: {
+        value: number;
+    };
+    uGenVertexFrequency: {
+        value: number;
+    };
+    uGenVertexDirection: {
+        value: number;
+    };
+    uGenVertexCenterX: {
+        value: number;
+    };
+    uGenVertexCenterY: {
+        value: number;
+    };
+    uGenVertexMinScale: {
+        value: number;
+    };
+    uGenVertexMaxScale: {
+        value: number;
+    };
+    uPtrRadius: {
+        value: number;
+    };
+    uPtrVertexType: {
+        value: number;
+    };
+    uPtrVertexEnabled: {
+        value: boolean;
+    };
+    uPtrVertexIntensity: {
+        value: number;
+    };
+    uPtrVertexSpeed: {
+        value: number;
+    };
+    uPtrVertexFrequency: {
+        value: number;
+    };
+    uPtrVertexDirection: {
+        value: number;
+    };
+    uPtrVertexCenterX: {
+        value: number;
+    };
+    uPtrVertexCenterY: {
+        value: number;
+    };
+    uPtrVertexMinScale: {
+        value: number;
+    };
+    uPtrVertexMaxScale: {
+        value: number;
+    };
+    uGenFragmentType: {
+        value: number;
+    };
+    uGenFragmentEnabled: {
+        value: boolean;
+    };
+    uGenFragmentIntensity: {
+        value: number;
+    };
+    uGenFragmentSpeed: {
+        value: number;
+    };
+    uGenFragmentColor: {
+        value: Color;
+    };
+    uGenGrayscaleMode: {
+        value: number;
+    };
+    uGenGrayscaleContrast: {
+        value: number;
+    };
+    uGenGrayscaleBrightness: {
+        value: number;
+    };
+    uGenGrayscaleWaveFreq: {
+        value: number;
+    };
+    uGenGrayscaleWaveDir: {
+        value: number;
+    };
+    uGenGrayscaleCenterX: {
+        value: number;
+    };
+    uGenGrayscaleCenterY: {
+        value: number;
+    };
+    uPtrFragmentType: {
+        value: number;
+    };
+    uPtrFragmentEnabled: {
+        value: boolean;
+    };
+    uPtrFragmentIntensity: {
+        value: number;
+    };
+    uPtrFragmentSpeed: {
+        value: number;
+    };
+    uPtrFragmentColor: {
+        value: Color;
+    };
+    uPtrGrayscaleMode: {
+        value: number;
+    };
+    uPtrGrayscaleContrast: {
+        value: number;
+    };
+    uPtrGrayscaleBrightness: {
+        value: number;
+    };
+    uPtrGrayscaleWaveFreq: {
+        value: number;
+    };
+    uPtrGrayscaleWaveDir: {
+        value: number;
+    };
+    uPtrGrayscaleCenterX: {
+        value: number;
+    };
+    uPtrGrayscaleCenterY: {
+        value: number;
+    };
+}
+declare const ShaderEffectsMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_pointer: Vector2;
+    uPointSize: number;
+    uTexture: any;
+    uTargetTexture: any;
+    uHasTexture: false;
+    uMorphProgress: number;
+    uColor: Color;
+    uOpacity: number;
+    uNormalizationScale: number;
+    uParticleUVScale: number;
+    uGenVertexType: number;
+    uGenVertexEnabled: false;
+    uGenVertexIntensity: number;
+    uGenVertexSpeed: number;
+    uGenVertexFrequency: number;
+    uGenVertexDirection: number;
+    uGenVertexCenterX: number;
+    uGenVertexCenterY: number;
+    uGenVertexMinScale: number;
+    uGenVertexMaxScale: number;
+    uPtrRadius: number;
+    uPtrVertexType: number;
+    uPtrVertexEnabled: false;
+    uPtrVertexIntensity: number;
+    uPtrVertexSpeed: number;
+    uPtrVertexFrequency: number;
+    uPtrVertexDirection: number;
+    uPtrVertexCenterX: number;
+    uPtrVertexCenterY: number;
+    uPtrVertexMinScale: number;
+    uPtrVertexMaxScale: number;
+    uGenFragmentType: number;
+    uGenFragmentEnabled: false;
+    uGenFragmentIntensity: number;
+    uGenFragmentSpeed: number;
+    uGenFragmentColor: Color;
+    uGenGrayscaleMode: number;
+    uGenGrayscaleContrast: number;
+    uGenGrayscaleBrightness: number;
+    uGenGrayscaleWaveFreq: number;
+    uGenGrayscaleWaveDir: number;
+    uGenGrayscaleCenterX: number;
+    uGenGrayscaleCenterY: number;
+    uPtrFragmentType: number;
+    uPtrFragmentEnabled: false;
+    uPtrFragmentIntensity: number;
+    uPtrFragmentSpeed: number;
+    uPtrFragmentColor: Color;
+    uPtrGrayscaleMode: number;
+    uPtrGrayscaleContrast: number;
+    uPtrGrayscaleBrightness: number;
+    uPtrGrayscaleWaveFreq: number;
+    uPtrGrayscaleWaveDir: number;
+    uPtrGrayscaleCenterX: number;
+    uPtrGrayscaleCenterY: number;
+}> & {
+    key: string;
+};
+export { ShaderEffectsMaterial };
+//# sourceMappingURL=ShaderEffectsMaterial.d.ts.map

package/dist/shaders/ShaderEffectsMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderEffectsMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/ShaderEffectsMaterial.ts"],"names":[],"mappings":"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"}