@3driseai/3drise-core 1.0.1

package/dist/shaders/OceanMaterial.js

@@ -0,0 +1,240 @@
+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;
+  void main() {
+    vUv = uv;
+    vPosition = position;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+// Fragment shader - converted from the original Seascape shader
+const fragmentShader = /*glsl*/ `
+  uniform float u_time;
+  uniform vec2 u_resolution;
+  uniform vec2 u_pointer;
+  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 float u_iterGeometry;
+  uniform float u_iterFragment;
+  uniform float u_numSteps;
+  
+  varying vec2 vUv;
+  varying vec3 vPosition;
+
+  const float PI = 3.141592;
+  const float EPSILON = 1e-3;
+  
+  // math
+  mat3 fromEuler(vec3 ang) {
+    vec2 a1 = vec2(sin(ang.x),cos(ang.x));
+    vec2 a2 = vec2(sin(ang.y),cos(ang.y));
+    vec2 a3 = vec2(sin(ang.z),cos(ang.z));
+    mat3 m;
+    m[0] = vec3(a1.y*a3.y+a1.x*a2.x*a3.x,a1.y*a2.x*a3.x+a3.y*a1.x,-a2.y*a3.x);
+    m[1] = vec3(-a2.y*a1.x,a1.y*a2.y,a2.x);
+    m[2] = vec3(a3.y*a1.x*a2.x+a1.y*a3.x,a1.x*a3.x-a1.y*a3.y*a2.x,a2.y*a3.y);
+    return m;
+  }
+  
+  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);
+  }
+
+  // lighting
+  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) / (PI * 8.0);
+    return pow(max(dot(reflect(e,n),l),0.0),s) * nrm;
+  }
+
+  // sky
+  vec3 getSkyColor(vec3 e) {
+    e.y = (max(e.y,0.0)*0.8+0.2)*0.8;
+    return vec3(pow(1.0-e.y,2.0), 1.0-e.y, 0.6+(1.0-e.y)*0.4) * 1.1;
+  }
+
+  // sea
+  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);
+  }
+
+  float map(vec3 p) {
+    float freq = u_seaFreq;
+    float amp = u_seaHeight;
+    float choppy = u_seaChoppy;
+    vec2 uv = p.xz; 
+    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++) {        
+      if(float(i) >= u_iterGeometry) break;
+      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 p.y - h;
+  }
+
+  float map_detailed(vec3 p) {
+    float freq = u_seaFreq;
+    float amp = u_seaHeight;
+    float choppy = u_seaChoppy;
+    vec2 uv = p.xz; 
+    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 < 5; i++) {        
+      if(float(i) >= u_iterFragment) break;
+      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 p.y - h;
+  }
+
+  vec3 getSeaColor(vec3 p, vec3 n, vec3 l, vec3 eye, vec3 dist) {  
+    float fresnel = clamp(1.0 - dot(n, -eye), 0.0, 1.0);
+    fresnel = min(fresnel * fresnel * fresnel, 0.5);
+    
+    vec3 reflected = getSkyColor(reflect(eye, n));    
+    vec3 refracted = u_seaBaseColor + diffuse(n, l, 80.0) * u_seaWaterColor * 0.12; 
+    
+    vec3 color = mix(refracted, reflected, fresnel);
+    
+    float atten = max(1.0 - dot(dist, dist) * 0.001, 0.0);
+    color += u_seaWaterColor * (p.y - u_seaHeight) * 0.18 * atten;
+    
+    color += specular(n, l, eye, 600.0 * inversesqrt(dot(dist,dist)));
+    
+    return color;
+  }
+
+  // tracing
+  vec3 getNormal(vec3 p, float eps) {
+    vec3 n;
+    n.y = map_detailed(p);    
+    n.x = map_detailed(vec3(p.x+eps,p.y,p.z)) - n.y;
+    n.z = map_detailed(vec3(p.x,p.y,p.z+eps)) - n.y;
+    n.y = eps;
+    return normalize(n);
+  }
+
+  float heightMapTracing(vec3 ori, vec3 dir, out vec3 p) {  
+    float tm = 0.0;
+    float tx = 1000.0;    
+    float hx = map(ori + dir * tx);
+    if(hx > 0.0) {
+      p = ori + dir * tx;
+      return tx;   
+    }
+    float hm = map(ori);    
+    for(int i = 0; i < 32; i++) {
+      if(float(i) >= u_numSteps) break;
+      float tmid = mix(tm, tx, hm / (hm - hx));
+      p = ori + dir * tmid;
+      float hmid = map(p);        
+      if(hmid < 0.0) {
+        tx = tmid;
+        hx = hmid;
+      } else {
+        tm = tmid;
+        hm = hmid;
+      }        
+      if(abs(hmid) < EPSILON) break;
+    }
+    return mix(tm, tx, hm / (hm - hx));
+  }
+
+  vec3 getPixel(in vec2 coord, float time) {    
+    vec2 uv = coord / u_resolution.xy;
+    uv = uv * 2.0 - 1.0;
+    uv.x *= u_resolution.x / u_resolution.y;    
+        
+    // ray
+    vec3 ang = vec3(sin(time*3.0)*0.1,sin(time)*0.2+0.3,time);    
+    vec3 ori = vec3(0.0,3.5,time*5.0);
+    vec3 dir = normalize(vec3(uv.xy,-2.0)); 
+    dir.z += length(uv) * 0.14;
+    dir = normalize(dir) * fromEuler(ang);
+    
+    // tracing
+    vec3 p;
+    heightMapTracing(ori,dir,p);
+    vec3 dist = p - ori;
+    float EPSILON_NRM = 0.1 / u_resolution.x;
+    vec3 n = getNormal(p, dot(dist,dist) * EPSILON_NRM);
+    vec3 light = normalize(vec3(0.0,1.0,0.8)); 
+             
+    // color
+    return mix(
+      getSkyColor(dir),
+      getSeaColor(p,n,light,dir,dist),
+      pow(smoothstep(0.0,-0.02,dir.y),0.2));
+  }
+
+  void main() {
+    float time = u_time * 0.3 + u_pointer.x*0.01;
+    vec3 color = getPixel(gl_FragCoord.xy, time);
+    
+    // post processing
+    gl_FragColor = vec4(pow(color,vec3(0.65)), 1.0);
+  }
+`;
+// Create the shader material with uniforms
+const OceanMaterial = shaderMaterial({
+    u_time: 0,
+    u_resolution: new Vector2(800, 600),
+    u_pointer: new Vector2(0, 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_iterGeometry: 3,
+    u_iterFragment: 5,
+    u_numSteps: 32
+}, vertexShader, fragmentShader);
+// Extend the material for use in React Three Fiber
+extend({ OceanMaterial });
+export { OceanMaterial };

package/dist/shaders/PainterlyCloudsMaterial.d.ts

@@ -0,0 +1,49 @@
+import { Vector2, Vector3 } from "three";
+import type { Texture } from 'three';
+export interface PainterlyCloudsUniforms {
+    u_time: {
+        value: number;
+    };
+    u_resolution: {
+        value: Vector2;
+    };
+    u_cameraPos: {
+        value: Vector3;
+    };
+    u_cloudColor: {
+        value: Vector3;
+    };
+    u_brushSize: {
+        value: number;
+    };
+    u_paintTexture: {
+        value: Texture | null;
+    };
+    u_baseColor: {
+        value: Vector3;
+    };
+    u_highlightColor: {
+        value: Vector3;
+    };
+    u_brushStrokes: {
+        value: number;
+    };
+    u_hasText: {
+        value: number;
+    };
+}
+export declare const PainterlyCloudsMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_resolution: Vector2;
+    u_cameraPos: Vector3;
+    u_cloudColor: Vector3;
+    u_brushSize: number;
+    u_paintTexture: any;
+    u_baseColor: Vector3;
+    u_highlightColor: Vector3;
+    u_brushStrokes: number;
+    u_hasText: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=PainterlyCloudsMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PainterlyCloudsMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/PainterlyCloudsMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAIrC,MAAM,WAAW,uBAAuB;IACpC,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,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;KACzB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,gBAAgB,EAAE;QACd,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAqDD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;CAWc,CAAC"}

package/dist/shaders/PainterlyCloudsMaterial.js

@@ -0,0 +1,68 @@
+import { Vector2, Vector3 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+import { commonNoiseFunctions } from "./CommonNoiseFunctions.js";
+const painterlyCloudsVertex = /*glsl*/ `
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  
+  void main() {
+    vUv = uv;
+    vPosition = position;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const painterlyCloudsFragment = /*glsl*/ `
+  uniform float u_time;
+  uniform vec2 u_resolution;
+  uniform vec3 u_cameraPos;
+  uniform vec3 u_cloudColor;
+  uniform float u_brushSize;
+  uniform sampler2D u_paintTexture;
+  uniform vec3 u_baseColor;
+  uniform vec3 u_highlightColor;
+  uniform float u_brushStrokes;
+  uniform float u_hasText;
+  
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  
+  ${commonNoiseFunctions}
+  
+  void main() {
+    vec3 spherePos = normalize(vPosition);
+    
+    // Create painterly brush stroke patterns
+    vec2 brushUV = vUv * u_brushSize + vec2(u_time * 0.02, 0.0);
+    float brushPattern = noise(vec3(brushUV * u_brushStrokes, u_time * 0.1));
+    
+    // Cloud formation with artistic distortion
+    float cloud = fbm(spherePos * 2.0 + vec3(u_time * 0.05));
+    cloud = smoothstep(0.3, 0.8, cloud + brushPattern * 0.3);
+    
+    // Paint texture sampling (if available)
+    vec3 paintColor = u_baseColor;
+    if (u_hasText > 0.5) {
+      vec4 paint = texture2D(u_paintTexture, brushUV);
+      paintColor = mix(u_baseColor, u_highlightColor, paint.r);
+    }
+    
+    // Artistic color variation
+    vec3 color = mix(paintColor, u_highlightColor, brushPattern * 0.5);
+    
+    gl_FragColor = vec4(color, cloud);
+  }
+`;
+export const PainterlyCloudsMaterial = shaderMaterial({
+    u_time: 0,
+    u_resolution: new Vector2(800, 600),
+    u_cameraPos: new Vector3(0, 0, 0),
+    u_cloudColor: new Vector3(0.9, 0.9, 0.95),
+    u_brushSize: 2.0,
+    u_paintTexture: null,
+    u_baseColor: new Vector3(0.9, 0.9, 0.95),
+    u_highlightColor: new Vector3(1.0, 0.95, 0.8),
+    u_brushStrokes: 8.0,
+    u_hasText: 0.0
+}, painterlyCloudsVertex, painterlyCloudsFragment);
+extend({ PainterlyCloudsMaterial });

package/dist/shaders/PainterlyCloudsPointsMaterial.d.ts

@@ -0,0 +1,69 @@
+import { Vector3, Vector2, Color } from "three";
+export interface PainterlyCloudsPointsMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_baseColor: {
+        value: Vector3;
+    };
+    u_highlightColor: {
+        value: Vector3;
+    };
+    u_brushStrokes: {
+        value: number;
+    };
+    u_pointer: {
+        value: Vector2;
+    };
+    uPointSize: {
+        value: number;
+    };
+    uColor: {
+        value: Color;
+    };
+    uOpacity: {
+        value: number;
+    };
+}
+export declare const PainterlyCloudsPointsMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_baseColor: Vector3;
+    u_highlightColor: Vector3;
+    u_brushStrokes: number;
+    uPointSize: number;
+    u_pointer: Vector2;
+    uColor: Color;
+    uOpacity: number;
+    uMorphProgress: number;
+    uPointerEffectRadius: number;
+    uRippleEnabled: false;
+    uRippleIntensity: number;
+    uRippleSpeed: number;
+    uDisplacementEnabled: false;
+    uDisplacementIntensity: number;
+    uScaleEnabled: false;
+    uScaleIntensity: number;
+    uMinScale: number;
+    uMaxScale: number;
+    uVortexEnabled: false;
+    uVortexIntensity: number;
+    uVortexSpeed: number;
+    uGeneralWaveEnabled: false;
+    uGeneralWaveIntensity: number;
+    uGeneralWaveFrequency: number;
+    uGeneralWaveSpeed: number;
+    uGeneralWaveDirection: number;
+    uGeneralVortexEnabled: false;
+    uGeneralVortexIntensity: number;
+    uGeneralVortexSpeed: number;
+    uGeneralVortexCenterX: number;
+    uGeneralVortexCenterY: number;
+    uGeneralRippleEnabled: false;
+    uGeneralRippleIntensity: number;
+    uGeneralRippleSpeed: number;
+    uGeneralRippleCenterX: number;
+    uGeneralRippleCenterY: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=PainterlyCloudsPointsMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PainterlyCloudsPointsMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/PainterlyCloudsPointsMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAKhD,MAAM,WAAW,qCAAqC;IAClD,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,gBAAgB,EAAE;QACd,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,MAAM,EAAE;QACJ,KAAK,EAAE,KAAK,CAAC;KAChB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAiGD,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCV,CAAC"}

package/dist/shaders/PainterlyCloudsPointsMaterial.js

@@ -0,0 +1,140 @@
+import { Vector3, Vector2, Color } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+import { commonNoiseFunctions } from "./CommonNoiseFunctions.js";
+import { effectsVertexGLSL } from "./effects/EffectsVertexFunctions.glsl.js";
+const vertexShader = /*glsl*/ `
+${effectsVertexGLSL}
+
+uniform float uPointSize;
+varying vec2 vTexCoords;
+uniform float uMorphProgress;
+attribute vec3 targetPosition;
+uniform bool uScaleEnabled;
+uniform float uScaleIntensity;
+uniform float uMinScale;
+uniform float uMaxScale;
+attribute vec2 aUV;
+varying vec2 vUV;
+varying vec3 vPosition;
+
+void main() {
+  vUV = aUV;
+  vPosition = position;
+  
+  vec3 morphedPos = mix(position, targetPosition, uMorphProgress);
+  
+  if (uGeneralWaveEnabled) {
+    float waveInput = uGeneralWaveDirection < 0.5 ? morphedPos.x : 
+                      uGeneralWaveDirection < 1.5 ? morphedPos.y : 
+                      morphedPos.x + morphedPos.y;
+    morphedPos.z += sin(waveInput * uGeneralWaveFrequency + u_time * uGeneralWaveSpeed) * uGeneralWaveIntensity;
+  }
+  
+  if (uGeneralVortexEnabled) {
+    vec2 generalCenter = vec2(uGeneralVortexCenterX, uGeneralVortexCenterY);
+    vec2 toCenter = morphedPos.xy - generalCenter;
+    float angle = uGeneralVortexIntensity * u_time * uGeneralVortexSpeed;
+    mat2 rotation = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));
+    morphedPos.xy = generalCenter + rotation * toCenter;
+  }
+  
+  if (uGeneralRippleEnabled) {
+    morphedPos = applyGeneralRipple(morphedPos);
+  }
+  
+  vec2 scaledPointer = u_pointer * 5.0;
+  float dist = distance(morphedPos.xy, scaledPointer);
+  float falloff = smoothstep(uPointerEffectRadius, 0.0, dist);
+  
+  if (uRippleEnabled && falloff > 0.0) {
+    morphedPos.z += sin(dist * 5.0 - u_time * uRippleSpeed) * uRippleIntensity * falloff * 0.5;
+  }
+  
+  if (uDisplacementEnabled && falloff > 0.0) {
+    vec2 dir = normalize(morphedPos.xy - scaledPointer);
+    morphedPos.xy += dir * uDisplacementIntensity * falloff * 2.0;
+  }
+  
+  if (uVortexEnabled && falloff > 0.0) {
+    vec2 toPointer = morphedPos.xy - scaledPointer;
+    float angle = uVortexIntensity * falloff * u_time * uVortexSpeed;
+    mat2 rotation = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));
+    morphedPos.xy = scaledPointer + rotation * toPointer;
+  }
+  
+  vTexCoords = morphedPos.xy;
+  
+  vec4 mvPosition = modelViewMatrix * vec4(morphedPos, 1.0);
+  gl_Position = projectionMatrix * mvPosition;
+  
+  float sizeMultiplier = 1.0;
+  if (uScaleEnabled && falloff > 0.0) {
+    sizeMultiplier = mix(uMinScale, uMaxScale, falloff * uScaleIntensity);
+  }
+  gl_PointSize = uPointSize * sizeMultiplier;
+}
+`;
+const fragmentShader = /*glsl*/ `
+uniform float u_time;
+uniform vec3 u_baseColor;
+uniform vec3 u_highlightColor;
+uniform float u_brushStrokes;
+uniform vec3 uColor;
+uniform float uOpacity;
+varying vec3 vPosition;
+
+${commonNoiseFunctions}
+
+float circle(vec2 uv, float border) {
+  return smoothstep(0.0, border, 0.5 - distance(uv, vec2(0.5)));
+}
+
+void main() {
+  vec3 spherePos = normalize(vPosition);
+  float brush = fbm(spherePos * u_brushStrokes + vec3(u_time * 0.05));
+  vec3 paintColor = mix(u_baseColor, u_highlightColor, brush);
+  
+  gl_FragColor = vec4(paintColor * uColor, brush * uOpacity * circle(gl_PointCoord, 0.2));
+}
+`;
+export const PainterlyCloudsPointsMaterial = shaderMaterial({
+    u_time: 0,
+    u_baseColor: new Vector3(0.7, 0.8, 0.9),
+    u_highlightColor: new Vector3(1.0, 1.0, 1.0),
+    u_brushStrokes: 4.0,
+    uPointSize: 5.0,
+    u_pointer: new Vector2(),
+    uColor: new Color(1.0, 1.0, 1.0),
+    uOpacity: 1.0,
+    uMorphProgress: 0.0,
+    uPointerEffectRadius: 2.5,
+    uRippleEnabled: false,
+    uRippleIntensity: 0.5,
+    uRippleSpeed: 2.0,
+    uDisplacementEnabled: false,
+    uDisplacementIntensity: 0.5,
+    uScaleEnabled: false,
+    uScaleIntensity: 0.5,
+    uMinScale: 0.5,
+    uMaxScale: 2.0,
+    uVortexEnabled: false,
+    uVortexIntensity: 0.5,
+    uVortexSpeed: 1.0,
+    uGeneralWaveEnabled: false,
+    uGeneralWaveIntensity: 0.3,
+    uGeneralWaveFrequency: 3.0,
+    uGeneralWaveSpeed: 1.0,
+    uGeneralWaveDirection: 0.0,
+    uGeneralVortexEnabled: false,
+    uGeneralVortexIntensity: 0.5,
+    uGeneralVortexSpeed: 0.5,
+    uGeneralVortexCenterX: 0.0,
+    uGeneralVortexCenterY: 0.0,
+    uGeneralRippleEnabled: false,
+    uGeneralRippleIntensity: 0.3,
+    uGeneralRippleSpeed: 2.0,
+    uGeneralRippleCenterX: 0.0,
+    uGeneralRippleCenterY: 0.0,
+}, vertexShader, fragmentShader);
+extend({ PainterlyCloudsPointsMaterial });

package/dist/shaders/RainMaterial.d.ts

@@ -0,0 +1,36 @@
+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 global {
+    namespace JSX {
+        interface IntrinsicElements {
+            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,CAAC,MAAM,CAAC;IACX,UAAU,GAAG,CAAC;QACV,UAAU,iBAAiB;YACvB,YAAY,EAAE,GAAG,CAAC;SACrB;KACJ;CACJ;AAqED,QAAA,MAAM,YAAY;;;;;;;;CAMc,CAAC;AAEjC,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/shaders/RainMaterial.js

@@ -0,0 +1,79 @@
+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);
+
+    // Larger point size to give room for the streak shape
+    // The streak is drawn inside the point via fragment shader
+    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() {
+    // Transform gl_PointCoord to -0.5..0.5 centered UV
+    vec2 uv = gl_PointCoord - vec2(0.5);
+
+    // Rotate UV by wind angle so streaks tilt with the wind
+    // Default streak direction is vertical (falling down = screen Y)
+    // windAngle rotates the streak in screen-space
+    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
+    );
+
+    // Elongate vertically: stretch X (cross-axis) to make a thin streak
+    // streakLength controls how elongated (higher = thinner & longer)
+    float aspectRatio = max(streakLength, 1.0);
+    rotUv.x *= aspectRatio;
+
+    float dist = length(rotUv);
+
+    // Soft raindrop shape: bright center, fading outward
+    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;
+
+    // Slight vertical gradient: brighter at leading edge (bottom)
+    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 };