@ntalmagor/3drize-viewer 0.1.2

package/dist/index.js

@@ -0,0 +1,109 @@
+// Core services
+export { default as animationsManager } from '../../core/src/services/AnimationsManager';
+export { fontManager } from '../../core/src/services/FontManager';
+// Components
+export { AnimatedObject, default as AnimatedObjectDefault } from './components/AnimatedObject';
+export { CameraController, default as CameraControllerDefault } from './components/CameraController';
+export { default as CreatedObject } from './components/CreatedObject';
+export { default as CustomPrimitive } from './components/CustomPrimitive';
+export { default as EffectsGenerator } from './components/EffectsGenerator';
+export { default as EffectsGroup } from './components/EffectsGroup';
+export { default as Frame } from './components/Frame';
+export { FrameGeometry } from './components/FrameGeometry';
+export { FrameImage } from './components/FrameImage';
+export { default as GalleryLayout } from './components/GalleryLayout';
+export { default as GridHelper } from './components/GridHelper';
+export { ImageGeometry } from './components/ImageGeometry';
+export { default as Letter } from './components/Letter';
+export { default as Letters } from './components/Letters';
+export { default as LightsManager } from './components/LightsManager';
+export { default as Lines } from './components/Lines';
+export { default as MaterialLibrary } from './components/MaterialLibrary';
+export { default as ObjectNode } from './components/ObjectNode';
+export { default as ObjectsRenderer } from './components/ObjectsRenderer';
+export { default as ParticlesR3f } from './components/ParticlesR3f';
+export { default as Skybox } from './components/Skybox';
+export { default as SkyMesh } from './components/SkyMesh';
+export { default as Moon } from './components/Moon';
+export { default as SkyController } from './components/SkyController';
+export { default as Lensflare, createFlareTexture } from './components/Lensflare';
+export { default as SunLight } from './components/SunLight';
+export { default as Clouds } from './components/Clouds';
+export { default as Stars, generateStarsGeometry } from './components/Stars';
+export { default as ShootingStar } from './components/ShootingStar';
+export { default as ShootingStars } from './components/ShootingStars';
+export { default as Galaxy } from './components/Galaxy';
+export { default as SkySystem } from './components/SkySystem';
+export { default as Rain } from './components/Rain';
+export { default as SceneFog } from './components/SceneFog';
+export { default as EnvironmentManager } from './components/EnvironmentManager';
+export { default as Ocean } from './components/Ocean';
+export { LoadingIndicator } from './components/LoadingIndicator';
+export { default as Path } from './components/Path';
+export { default as PathGeometry } from './components/PathGeometry';
+export { default as PathRenderer } from './components/PathRenderer';
+export { default as Text2D } from './components/Text2D';
+export { default as Text3D } from './components/Text3D';
+export { default as SceneBuilder } from './components/SceneBuilder';
+export { default as ProjectLoader } from './components/ProjectLoader';
+// Generative effect components
+export { default as AuraEffect } from './components/effects/AuraEffect';
+export { default as AuroraEffect } from './components/effects/AuroraEffect';
+export { default as BlackHoleEffect } from './components/effects/BlackHoleEffect';
+export { default as ConstellationEffect } from './components/effects/ConstellationEffect';
+export { default as DataStreamEffect } from './components/effects/DataStreamEffect';
+export { default as DnaHelixEffect } from './components/effects/DnaHelixEffect';
+export { default as FireEffect } from './components/effects/FireEffect';
+export { default as ForcefieldEffect } from './components/effects/ForcefieldEffect';
+export { default as HologramEffect } from './components/effects/HologramEffect';
+export { default as IceCrystalsEffect } from './components/effects/IceCrystalsEffect';
+export { default as LightningEffect } from './components/effects/LightningEffect';
+export { default as MoleculesEffect } from './components/effects/MoleculesEffect';
+export { default as NeuralNetworkEffect } from './components/effects/NeuralNetworkEffect';
+export { default as OrbEffect } from './components/effects/OrbEffect';
+export { default as PortalEffect } from './components/effects/PortalEffect';
+export { default as ShockwaveEffect } from './components/effects/ShockwaveEffect';
+export { default as SmokePlumeEffect } from './components/effects/SmokePlumeEffect';
+export { default as SmokeRingEffect } from './components/effects/SmokeRingEffect';
+export { default as VolumetricFogEffect } from './components/effects/VolumetricFogEffect';
+// Hooks
+export * from './hooks/useAnimationEvents';
+export * from './hooks/useCameraAnimation';
+export * from './hooks/useContinuousEffects';
+export * from './hooks/useFrameEffects';
+export * from './hooks/useInteractionEffects';
+export * from './hooks/useKey';
+export * from './hooks/useLightHandlers';
+export * from './hooks/useMaterialApplication';
+export * from './hooks/useMaterialOptions';
+export * from './hooks/useMaterialUniforms';
+export * from './hooks/useMouseHandlers';
+export * from './hooks/useObjectAnimation';
+export * from './hooks/useObjectEdges';
+export * from './hooks/useParticlePositions';
+export * from './hooks/useParticlesColors';
+export * from './hooks/useParticlesTextures';
+export * from './hooks/usePathAnimation';
+export * from './hooks/useTransformControls';
+export * from './hooks/useSkySystem';
+export * from './hooks/useCubeCamera';
+export * from './hooks/useEnvironmentEffects';
+export * from './hooks/useSkyUniforms';
+export * from './hooks/useSkyAnimation';
+export * from './hooks/useMeshController';
+export { useWaterEnvironment } from './hooks/useWaterEnvironment';
+export { useWaterReflections } from './hooks/useWaterReflections';
+// Utils
+export { cameraManager } from './utils/CameraSingleton';
+export { update3driseShaderUniforms } from './utils/shaderUtils';
+export { applyAnchorSettings, createCurves, createSunPosition, randomRange, } from './utils/utils3d';
+export { applyAnchorSettings as applyAnchorSettingsLegacy } from './utils/anchorUtils';
+export { DEBUG_GENERATIVE_EFFECTS, applyGenerativeAnimations, } from './utils/handleGenerativeEffectsAnimations';
+export { hasHoverAnimation } from './utils/hasHoverAnimation';
+export { findById } from './utils/sceneQuery';
+export * from './utils/textEffects';
+// Shaders
+export { ShaderEffectsMaterial } from './shaders/ShaderEffectsMaterial';
+export { SkyboxMaterial } from './shaders/SkyboxMaterial';
+export { ShootingStarMaterial } from './shaders/ShootingStarMaterial';
+export { RainMaterial } from './shaders/RainMaterial';

package/dist/services/AnimationsManager.d.ts

@@ -0,0 +1,33 @@
+import type { AnimationSequence, TransitionStep, PathConfig } from '@ntalmagor/3drize-core';
+export type AnimationEventType = 'sequenceStart' | 'sequenceEnd' | 'stepStart' | 'stepEnd';
+export interface AnimationEvent {
+    type: AnimationEventType;
+    sequenceId: string;
+    sequence: AnimationSequence;
+    step?: TransitionStep;
+    stepIndex?: number;
+}
+type Listener = (event: AnimationEvent) => void;
+/**
+ * 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.
+ */
+declare class AnimationsManager {
+    private listeners;
+    private paths;
+    on(type: AnimationEventType, listener: Listener): void;
+    off(type: AnimationEventType, listener: Listener): void;
+    emit(event: AnimationEvent): void;
+    getProgressFromTime(startTime: number, duration: number, ease?: string): number;
+    reverseSteps(sequence: AnimationSequence): AnimationSequence;
+    addPath(path: PathConfig): void;
+    getPath(id: string): PathConfig | undefined;
+    getAllPaths(): PathConfig[];
+    updatePath(id: string, updates: Partial<Omit<PathConfig, 'id'>>): void;
+    deletePath(id: string): void;
+    clearPaths(): void;
+}
+declare const _default: AnimationsManager;
+export default _default;
+//# sourceMappingURL=AnimationsManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AnimationsManager.d.ts","sourceRoot":"","sources":["../../src/services/AnimationsManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAG5F,MAAM,MAAM,kBAAkB,GAAG,eAAe,GAAG,aAAa,GAAG,WAAW,GAAG,SAAS,CAAC;AAE3F,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,kBAAkB,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,KAAK,QAAQ,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;AAEhD;;;;GAIG;AACH,cAAM,iBAAiB;IACrB,OAAO,CAAC,SAAS,CAKd;IACH,OAAO,CAAC,KAAK,CAAiC;IAE9C,EAAE,CAAC,IAAI,EAAE,kBAAkB,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAItD,GAAG,CAAC,IAAI,EAAE,kBAAkB,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAIvD,IAAI,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAMjC,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,SAAW,GAAG,MAAM;IAKjF,YAAY,CAAC,QAAQ,EAAE,iBAAiB,GAAG,iBAAiB;IAa5D,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAC/B,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAC3C,WAAW,IAAI,UAAU,EAAE;IAC3B,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI;IAItE,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAC5B,UAAU,IAAI,IAAI;CACnB;;AAED,wBAAuC"}

package/dist/services/AnimationsManager.js

@@ -0,0 +1,58 @@
+import { applyEasing, resolveEasing } from '@ntalmagor/3drize-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;
+    private 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;IACvB,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;CACnB;AAeD,cAAM,WAAW;IACf,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA4B;IACnD,OAAO,CAAC,KAAK,CAAoC;IACjD,OAAO,CAAC,eAAe,CAAyC;IAEhE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAgB5B;IAEF,OAAO;IAMP,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;IAEpB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAY3C,cAAc,IAAI,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CAG5E;AAED,eAAO,MAAM,WAAW,aAA4B,CAAC;AACrD,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":"AAAA,OAAO,EAAiB,KAAK,OAAO,EAAE,MAAM,OAAO,CAAC;AAEpD,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;AAIhF,cAAM,eAAe;IACnB,OAAO,CAAC,QAAQ,CAAyC;IACzD,OAAO,CAAC,cAAc,CAA2D;IACjF,OAAO,CAAC,MAAM,CAAgB;;IASxB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IA0BlF,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAOjD,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAI5C,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,GAAG,IAAI;IAIpG,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAChC,KAAK,IAAI,IAAI;CACd;AAED,QAAA,MAAM,eAAe,iBAAwB,CAAC;AAC9C,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 const RainMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    uColor: THREE.Color;
+    opacity: number;
+    windAngle: number;
+    windTilt: number;
+    streakLength: number;
+}> & {
+    key: string;
+};
+export { RainMaterial };
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        rainMaterial: any;
+    }
+}
+//# 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;AAE/B,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE;QAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAA;KAAE,CAAC;IAC/B,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3B,SAAS,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7B,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5B,YAAY,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CACjC;AAgDD,QAAA,MAAM,YAAY;;;;;;;;CAUjB,CAAC;AAIF,OAAO,EAAE,YAAY,EAAE,CAAC;AAExB,OAAO,QAAQ,oBAAoB,CAAC;IAClC,UAAU,aAAa;QACrB,YAAY,EAAE,GAAG,CAAC;KACnB;CACF"}

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