@3driseai/3drise-core 1.0.1

package/dist/services/UniformConverter.js

@@ -0,0 +1,252 @@
+// =============================================================================
+// UNIFORM CONVERTER - TYPE-SAFE SHADER UNIFORM PROCESSING
+// =============================================================================
+import { TextureLoader, Vector2, Vector3 } from "three";
+// =============================================================================
+// UNIFORM TYPE PROCESSORS
+// =============================================================================
+class UniformProcessor {
+}
+class ColorProcessor extends UniformProcessor {
+    canProcess(key, value) {
+        return key.includes('Color') || key.includes('color') || value?.isColor;
+    }
+    toSetting(value) {
+        if (typeof value === 'number') {
+            return '#' + value.toString(16).padStart(6, '0');
+        }
+        if (value?.isVector3) {
+            return this.vector3ToHex(value);
+        }
+        return value === null ? null : String(value);
+    }
+    toUniform(value) {
+        if (typeof value === 'string' && value.startsWith('#')) {
+            return this.hexToVector3(value);
+        }
+        return value;
+    }
+    vector3ToHex(vec3) {
+        const r = Math.floor(Math.max(0, Math.min(1, vec3.x)) * 255).toString(16).padStart(2, '0');
+        const g = Math.floor(Math.max(0, Math.min(1, vec3.y)) * 255).toString(16).padStart(2, '0');
+        const b = Math.floor(Math.max(0, Math.min(1, vec3.z)) * 255).toString(16).padStart(2, '0');
+        return '#' + r + g + b;
+    }
+    hexToVector3(hexColor) {
+        const r = parseInt(hexColor.slice(1, 3), 16) / 255;
+        const g = parseInt(hexColor.slice(3, 5), 16) / 255;
+        const b = parseInt(hexColor.slice(5, 7), 16) / 255;
+        return new Vector3(r, g, b);
+    }
+}
+class Vector3Processor extends UniformProcessor {
+    canProcess(key, value, uniform) {
+        return (value?.isVector3) ||
+            (Array.isArray(value) && value.length === 3 && this.isVector3Key(key)) ||
+            (uniform?.value?.isVector3);
+    }
+    toSetting(value) {
+        if (value?.isVector3) {
+            return [value.x, value.y, value.z];
+        }
+        if (value && typeof value === 'object' && 'x' in value && 'y' in value && 'z' in value) {
+            return [value.x, value.y, value.z];
+        }
+        return value;
+    }
+    toUniform(value) {
+        if (Array.isArray(value) && value.length === 3) {
+            return new Vector3(value[0], value[1], value[2]);
+        }
+        return value;
+    }
+    isVector3Key(key) {
+        return key.includes('Position') ||
+            key.includes('Direction') ||
+            key.includes('Scale') ||
+            key.includes('Rotation');
+    }
+}
+class Vector2Processor extends UniformProcessor {
+    canProcess(key, value, uniform) {
+        return (value?.isVector2) ||
+            (Array.isArray(value) && value.length === 2) ||
+            (uniform?.value?.isVector2) ||
+            (this.isVector2Key(key) && (value?.isVector2 || Array.isArray(value) || uniform?.value?.isVector2));
+    }
+    toSetting(value) {
+        console.log("Vector2Processor toSetting:", value);
+        if (value?.isVector2) {
+            return [value.x, value.y];
+        }
+        if (value && typeof value === 'object' && 'x' in value && 'y' in value && !('z' in value)) {
+            return [value.x, value.y];
+        }
+        return value;
+    }
+    toUniform(value) {
+        if (Array.isArray(value) && value.length === 2) {
+            return new Vector2(value[0], value[1]);
+        }
+        return value;
+    }
+    isVector2Key(key) {
+        return key.includes('mouse') ||
+            key.includes('resolution') ||
+            key.includes('size');
+    }
+}
+class BooleanProcessor extends UniformProcessor {
+    canProcess(key, value) {
+        return typeof value === 'boolean';
+    }
+    toSetting(value) {
+        return value;
+    }
+    toUniform(value) {
+        return typeof value === 'boolean' ? (value ? 1.0 : 0.0) : value;
+    }
+}
+class NullProcessor extends UniformProcessor {
+    canProcess(key, value) {
+        return value === null;
+    }
+    toSetting(value) {
+        return null;
+    }
+    toUniform(value) {
+        return null;
+    }
+}
+class DefaultProcessor extends UniformProcessor {
+    canProcess() {
+        return true; // Always can process as fallback
+    }
+    toSetting(value) {
+        return value;
+    }
+    toUniform(value) {
+        return value;
+    }
+}
+// =============================================================================
+// UNIFORM CONVERTER
+// =============================================================================
+export class UniformConverter {
+    processors = [
+        new Vector3Processor(),
+        new NullProcessor(),
+        new ColorProcessor(),
+        new Vector2Processor(),
+        new BooleanProcessor(),
+        new DefaultProcessor(), // Must be last as fallback
+    ];
+    loader = new TextureLoader();
+    excludedUniforms = ["u_type", "visible", "materialType", "materialVariant"];
+    /**
+     * Convert shader uniforms to UI-friendly settings
+     */
+    convertToSettings(uniforms) {
+        const settings = {};
+        Object.keys(uniforms).forEach(key => {
+            if (this.excludedUniforms.includes(key))
+                return;
+            const uniform = uniforms[key];
+            const value = uniform.value;
+            // const propName = key.replace('u_', '');
+            const processor = this.processors.find(p => p.canProcess(key, value, uniform));
+            if (processor) {
+                settings[key] = processor.toSetting(value);
+            }
+        });
+        return settings;
+    }
+    /**
+     * Convert UI settings back to shader uniforms
+     */
+    async loadTexture(name, url) {
+        // console.log('Loading texture:', name, url);
+        // if (this.texturesByType.get(type)?.has(name)) {
+        //   return this.texturesByType.get(type)?.get(name)?.texture!;
+        // }
+        // const img = await new Promise<HTMLImageElement>((resolve, reject) => {
+        //   const image = new window.Image();
+        //   image.crossOrigin = 'Anonymous';
+        //   image.onload = () => resolve(image);
+        //   image.onerror = reject;
+        //   image.src = url;
+        // });
+        // const width = img.width;
+        // const height = img.height;
+        // const isLandscape =  width > height;
+        return new Promise((resolve, reject) => {
+            this.loader.load(url, (texture) => {
+                // this.texturesByType.get(type)?.set(name, {
+                //   texture,
+                //   width,
+                //   height,
+                //   isLandscape
+                // });
+                console.log('Texture loaded:', name, texture);
+                // console.log(this.texturesByType);
+                resolve(texture);
+            }, undefined, (err) => reject(err));
+        });
+    }
+    convertToUniforms(settings) {
+        // console.log("Converting settings to uniforms:", settings);
+        const uniforms = {};
+        Object.keys(settings).forEach(async (key) => {
+            if (this.excludedUniforms.includes(key))
+                return;
+            const value = settings[key];
+            const processor = this.processors.find(p => p.canProcess(key, value, settings));
+            if (processor) {
+                // Convert the value and assign it to the uniform's value property
+                // console.log({processor})
+                uniforms[key] = processor.toUniform(value);
+            }
+            else {
+                console.warn(`No processor found for uniform key: ${key} with value:`, value);
+            }
+        });
+        // Remove excluded uniforms from the result
+        this.excludedUniforms.forEach(excludedKey => {
+            delete uniforms[excludedKey];
+        });
+        return uniforms;
+    }
+    /**
+     * Add a custom processor for specific uniform types
+     */
+    addProcessor(processor, index) {
+        if (index !== undefined) {
+            this.processors.splice(index, 0, processor);
+        }
+        else {
+            // Insert before the default processor (which should always be last)
+            this.processors.splice(-1, 0, processor);
+        }
+    }
+    /**
+     * Remove excluded uniform keys
+     */
+    addExcludedUniform(uniformKey) {
+        if (!this.excludedUniforms.includes(uniformKey)) {
+            this.excludedUniforms.push(uniformKey);
+        }
+    }
+    /**
+     * Remove excluded uniform keys
+     */
+    removeExcludedUniform(uniformKey) {
+        const index = this.excludedUniforms.indexOf(uniformKey);
+        if (index > -1) {
+            this.excludedUniforms.splice(index, 1);
+        }
+    }
+}
+// Export a singleton instance for convenience
+export const uniformConverter = new UniformConverter();
+// Export the base class for custom processors
+export { UniformProcessor };

package/dist/services/index.d.ts

@@ -0,0 +1,19 @@
+import texturesManager from './TexturesManager';
+export type { MaterialDefinition, MaterialInstance, MaterialVariant, ShaderSource, UniformInfo, } from './MaterialRegistry';
+export type { FontInfo } from './FontManager';
+export type { AnimationEvent, AnimationEventType } from './AnimationsManager';
+export type { SkyTimeState, TimeOfDayLabel } from './SkySystemManager';
+export { MaterialRegistry, default as MaterialRegistryAPI } from './MaterialRegistry';
+export * from '../utils/MaterialCompiler';
+export { default as ObjectManager } from './ObjectManager';
+export { texturesManager };
+export { fontManager, default as FontManager } from './FontManager';
+export { default as AnimationsManager } from './AnimationsManager';
+export { PositionsCreator } from './PositionsCreator';
+export * from './NoiseGenerator';
+export { TextureResolverService, textureResolver } from './TextureResolver';
+export { UniformConverter, UniformProcessor, uniformConverter } from './UniformConverter';
+export { SkySystemManager, skySystemManager } from './SkySystemManager';
+export { CubeCameraManager, cubeCameraManager } from './CubeCameraManager';
+export { default as SceneStore } from './SceneStore';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,eAAe,EAAE,YAAY,EAAE,WAAW,GAAG,MAAM,oBAAoB,CAAC;AAE5H,YAAY,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9E,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEvE,OAAO,EAAE,gBAAgB,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACtF,cAAc,2BAA2B,CAAC;AAC1C,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,CAAC;AAC3B,OAAO,EAAE,WAAW,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC5E,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC1F,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC"}

package/dist/services/index.js

@@ -0,0 +1,14 @@
+import texturesManager from './TexturesManager.js';
+export { MaterialRegistry, default as MaterialRegistryAPI } from './MaterialRegistry.js';
+export * from '../utils/MaterialCompiler.js';
+export { default as ObjectManager } from './ObjectManager.js';
+export { texturesManager };
+export { fontManager, default as FontManager } from './FontManager.js';
+export { default as AnimationsManager } from './AnimationsManager.js';
+export { PositionsCreator } from './PositionsCreator.js';
+export * from './NoiseGenerator.js';
+export { TextureResolverService, textureResolver } from './TextureResolver.js';
+export { UniformConverter, UniformProcessor, uniformConverter } from './UniformConverter.js';
+export { SkySystemManager, skySystemManager } from './SkySystemManager.js';
+export { CubeCameraManager, cubeCameraManager } from './CubeCameraManager.js';
+export { default as SceneStore } from './SceneStore.js';

package/dist/shaders/BasicSkyMaterial.d.ts

@@ -0,0 +1,49 @@
+import { Vector3, Vector2 } from "three";
+export interface BasicSkyMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_resolution: {
+        value: Vector2;
+    };
+    sunPosition: {
+        value: Vector3;
+    };
+    skyColor: {
+        value: Vector3;
+    };
+    horizonColor: {
+        value: Vector3;
+    };
+    sunColor: {
+        value: Vector3;
+    };
+    sunSize: {
+        value: number;
+    };
+    sunIntensity: {
+        value: number;
+    };
+    atmosphereThickness: {
+        value: number;
+    };
+    scatteringStrength: {
+        value: number;
+    };
+}
+declare const BasicSkyMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_resolution: Vector2;
+    sunPosition: Vector3;
+    skyColor: Vector3;
+    horizonColor: Vector3;
+    sunColor: Vector3;
+    sunSize: number;
+    sunIntensity: number;
+    atmosphereThickness: number;
+    scatteringStrength: number;
+}> & {
+    key: string;
+};
+export { BasicSkyMaterial };
+//# sourceMappingURL=BasicSkyMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BasicSkyMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/BasicSkyMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAGzC,MAAM,WAAW,wBAAwB;IACrC,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,OAAO,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,mBAAmB,EAAE;QACjB,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,kBAAkB,EAAE;QAChB,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AA4ED,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;CAaU,CAAC;AAGjC,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/shaders/BasicSkyMaterial.js

@@ -0,0 +1,94 @@
+import { Vector3, Vector2 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+// Vertex shader
+const vertexShader = /*glsl*/ `
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  varying vec3 vWorldPosition;
+  
+  void main() {
+    vUv = uv;
+    vPosition = position;
+    vWorldPosition = (modelMatrix * vec4(position, 1.0)).xyz;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+// Simplified fragment shader
+const fragmentShader = /*glsl*/ `
+  uniform float u_time;
+  uniform vec2 u_resolution;
+  
+  // Basic sky parameters
+  uniform vec3 sunPosition;
+  uniform vec3 skyColor;
+  uniform vec3 horizonColor;
+  uniform vec3 sunColor;
+  uniform float sunSize;
+  uniform float sunIntensity;
+  
+  // Simple atmosphere
+  uniform float atmosphereThickness;
+  uniform float scatteringStrength;
+  
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  varying vec3 vWorldPosition;
+  
+  #define PI 3.14159265358979323846
+  
+  void main() {
+    vec2 uv = (gl_FragCoord.xy - 0.5 * u_resolution.xy) / u_resolution.y;
+    
+    // Ray direction from camera
+    vec3 rayDir = normalize(vec3(uv, -1.0));
+    
+    // Normalized sun direction
+    vec3 sunDir = normalize(sunPosition);
+    
+    // Sky gradient based on ray direction
+    float skyGradient = smoothstep(-0.5, 0.5, rayDir.y);
+    vec3 baseColor = mix(horizonColor, skyColor, skyGradient);
+    
+    // Sun calculation
+    float sunDot = dot(rayDir, sunDir);
+    float sunDisc = smoothstep(sunSize - 0.01, sunSize, sunDot);
+    float sunGlow = pow(max(sunDot, 0.0), 8.0) * 0.3;
+    
+    // Atmospheric scattering effect
+    float scattering = pow(1.0 - abs(rayDir.y), atmosphereThickness) * scatteringStrength;
+    vec3 scatterColor = sunColor * scattering;
+    
+    // Combine all effects
+    vec3 color = baseColor;
+    color += sunColor * sunDisc * sunIntensity;
+    color += sunColor * sunGlow;
+    color += scatterColor;
+    
+    // Simple tone mapping
+    color = color / (color + vec3(1.0));
+    
+    // Gamma correction
+    color = pow(color, vec3(1.0 / 2.2));
+    
+    gl_FragColor = vec4(color, 1.0);
+  }
+`;
+// Create the basic sky material with simplified uniforms
+const BasicSkyMaterial = shaderMaterial({
+    u_time: 0,
+    u_resolution: new Vector2(800, 600),
+    // Basic sky parameters with sensible defaults
+    sunPosition: new Vector3(0.5, 0.8, -0.5),
+    skyColor: new Vector3(0.3, 0.6, 1.0), // Blue sky
+    horizonColor: new Vector3(1.0, 0.8, 0.6), // Orange horizon
+    sunColor: new Vector3(1.0, 0.9, 0.7), // Warm sun
+    sunSize: 0.998, // Sun disc size
+    sunIntensity: 2.0, // Sun brightness
+    // Simple atmosphere
+    atmosphereThickness: 2.0,
+    scatteringStrength: 0.5
+}, vertexShader, fragmentShader);
+// Extend the material for use in React Three Fiber
+extend({ BasicSkyMaterial });
+export { BasicSkyMaterial };

package/dist/shaders/BasicWaterMaterial.d.ts

@@ -0,0 +1,41 @@
+import { Vector3 } from "three";
+export interface BasicWaterMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_seaHeight: {
+        value: number;
+    };
+    u_seaChoppy: {
+        value: number;
+    };
+    u_seaSpeed: {
+        value: number;
+    };
+    u_seaFreq: {
+        value: number;
+    };
+    u_seaBaseColor: {
+        value: Vector3;
+    };
+    u_seaWaterColor: {
+        value: Vector3;
+    };
+    u_reflectionColor: {
+        value: Vector3;
+    };
+}
+declare const BasicWaterMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_seaHeight: number;
+    u_seaChoppy: number;
+    u_seaSpeed: number;
+    u_seaFreq: number;
+    u_seaBaseColor: Vector3;
+    u_seaWaterColor: Vector3;
+    u_reflectionColor: Vector3;
+}> & {
+    key: string;
+};
+export { BasicWaterMaterial };
+//# sourceMappingURL=BasicWaterMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BasicWaterMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/BasicWaterMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAGhC,MAAM,WAAW,0BAA0B;IACvC,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,eAAe,EAAE;QACb,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,iBAAiB,EAAE;QACf,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;CACL;AA6ID,QAAA,MAAM,kBAAkB;;;;;;;;;;;CASQ,CAAC;AAGjC,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/shaders/BasicWaterMaterial.js

@@ -0,0 +1,155 @@
+import { Vector3 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+// Vertex shader - pass world position for mesh sync
+const vertexShader = /*glsl*/ `
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  varying vec3 vWorldPosition;
+  
+  void main() {
+    vUv = uv;
+    vPosition = position;
+    vWorldPosition = (modelMatrix * vec4(position, 1.0)).xyz;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+// Fragment shader - simplified water with mesh coordinate sync
+const fragmentShader = /*glsl*/ `
+  uniform float u_time;
+  uniform float u_seaHeight;
+  uniform float u_seaChoppy;
+  uniform float u_seaSpeed;
+  uniform float u_seaFreq;
+  uniform vec3 u_seaBaseColor;
+  uniform vec3 u_seaWaterColor;
+  uniform vec3 u_reflectionColor;
+  
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  varying vec3 vWorldPosition;
+
+  float hash(vec2 p) {
+    float h = dot(p, vec2(127.1, 311.7));	
+    return fract(sin(h) * 43758.5453123);
+  }
+  
+  float noise(in vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);	
+    vec2 u = f * f * (3.0 - 2.0 * f);
+    return -1.0 + 2.0 * mix(
+      mix(hash(i + vec2(0.0, 0.0)), hash(i + vec2(1.0, 0.0)), u.x),
+      mix(hash(i + vec2(0.0, 1.0)), hash(i + vec2(1.0, 1.0)), u.x), 
+      u.y
+    );
+  }
+
+  // Simplified sea wave function
+  float sea_octave(vec2 uv, float choppy) {
+    uv += noise(uv);        
+    vec2 wv = 1.0 - abs(sin(uv));
+    vec2 swv = abs(cos(uv));    
+    wv = mix(wv, swv, wv);
+    return pow(1.0 - pow(wv.x * wv.y, 0.65), choppy);
+  }
+
+  // Generate water height using world position (syncs with mesh rotation)
+  float getWaterHeight(vec2 worldPos) {
+    float freq = u_seaFreq;
+    float amp = u_seaHeight;
+    float choppy = u_seaChoppy;
+    
+    // Use world position for wave calculations - this makes waves move with mesh
+    vec2 uv = worldPos; 
+    uv.x *= 0.75;
+    
+    float SEA_TIME = 1.0 + u_time * u_seaSpeed;
+    mat2 octave_m = mat2(1.6, 1.2, -1.2, 1.6);
+    
+    float d, h = 0.0;    
+    for(int i = 0; i < 3; i++) {        
+      d = sea_octave((uv + SEA_TIME) * freq, choppy);
+      d += sea_octave((uv - SEA_TIME) * freq, choppy);
+      h += d * amp;        
+      uv *= octave_m; 
+      freq *= 1.9; 
+      amp *= 0.22;
+      choppy = mix(choppy, 1.0, 0.2);
+    }
+    return h;
+  }
+
+  // Calculate water normal using world position
+  vec3 getWaterNormal(vec2 worldPos, float eps) {
+    float h = getWaterHeight(worldPos);
+    float hx = getWaterHeight(worldPos + vec2(eps, 0.0)) - h;
+    float hz = getWaterHeight(worldPos + vec2(0.0, eps)) - h;
+    return normalize(vec3(-hx, eps, -hz));
+  }
+
+  // Lighting calculation
+  float diffuse(vec3 n, vec3 l, float p) {
+    return pow(dot(n, l) * 0.4 + 0.6, p);
+  }
+  
+  float specular(vec3 n, vec3 l, vec3 e, float s) {    
+    float nrm = (s + 8.0) / (3.141592 * 8.0);
+    return pow(max(dot(reflect(e, n), l), 0.0), s) * nrm;
+  }
+
+  void main() {
+    // Use world position for wave calculations (syncs with mesh rotation)
+    vec2 waterPos = vWorldPosition.xz;
+    
+    // Calculate water height and normal
+    float waterHeight = getWaterHeight(waterPos);
+    vec3 normal = getWaterNormal(waterPos, 0.1);
+    
+    // Calculate view direction
+    vec3 viewDir = normalize(cameraPosition - vWorldPosition);
+    
+    // Calculate Fresnel effect
+    float fresnel = clamp(1.0 - dot(normal, viewDir), 0.0, 1.0);
+    fresnel = fresnel * fresnel * fresnel;
+    fresnel = min(fresnel, 0.5);
+    
+    // Base water color
+    vec3 waterColor = u_seaBaseColor + u_seaWaterColor * 0.12;
+    
+    // Mix water color with reflection
+    vec3 color = mix(waterColor, u_reflectionColor, fresnel);
+    
+    // Add depth variation based on wave height
+    color += u_seaWaterColor * waterHeight * 0.18;
+    
+    // Add specular highlights
+    vec3 lightDir = normalize(vec3(0.0, 1.0, 0.8));
+    float spec = specular(normal, lightDir, viewDir, 60.0);
+    color += vec3(spec * 0.5);
+    
+    // Apply lighting
+    float lighting = diffuse(normal, lightDir, 1.0);
+    color *= lighting;
+    
+    // Add some surface foam based on wave activity
+    float foam = smoothstep(0.0, 0.1, abs(waterHeight)) * 0.3;
+    color = mix(color, vec3(1.0), foam);
+    
+    gl_FragColor = vec4(pow(color, vec3(0.65)), 1.0);
+  }
+`;
+// Create the shader material with uniforms
+const BasicWaterMaterial = shaderMaterial({
+    u_time: 0,
+    u_seaHeight: 0.6,
+    u_seaChoppy: 4.0,
+    u_seaSpeed: 0.8,
+    u_seaFreq: 0.16,
+    u_seaBaseColor: new Vector3(0.0, 0.09, 0.18),
+    u_seaWaterColor: new Vector3(0.8 * 0.6, 0.9 * 0.6, 0.6 * 0.6),
+    u_reflectionColor: new Vector3(0.5, 0.7, 1.0)
+}, vertexShader, fragmentShader);
+// Extend the material for use in React Three Fiber
+extend({ BasicWaterMaterial });
+export { BasicWaterMaterial };

package/dist/shaders/BubblesPointsMaterial.d.ts

@@ -0,0 +1,52 @@
+import * as THREE from "three";
+export interface BubblesPointsMaterialUniforms {
+    uTime: {
+        value: number;
+    };
+    uScale: {
+        value: number;
+    };
+    uColorA: {
+        value: THREE.Color;
+    };
+    uColorB: {
+        value: THREE.Color;
+    };
+    uColorC: {
+        value: THREE.Color;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uIridescence: {
+        value: number;
+    };
+    uPopWindow: {
+        value: number;
+    };
+    uSpeed: {
+        value: number;
+    };
+}
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            bubblesPointsMaterial: any;
+        }
+    }
+}
+declare const BubblesPointsMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    uTime: number;
+    uScale: number;
+    uColorA: THREE.Color;
+    uColorB: THREE.Color;
+    uColorC: THREE.Color;
+    uOpacity: number;
+    uIridescence: number;
+    uPopWindow: number;
+    uSpeed: number;
+}> & {
+    key: string;
+};
+export { BubblesPointsMaterial };
+//# sourceMappingURL=BubblesPointsMaterial.d.ts.map