@3driseai/3drise-core 1.0.1

package/dist/shaders/CirrusCloudsPointsMaterial.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 float u_windSpeed;
+uniform float u_wispy;
+uniform vec3 u_cloudColor;
+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 cirrus = fbm(spherePos * 5.0 + vec3(u_time * u_windSpeed, 0.0, 0.0));
+  cirrus = pow(cirrus, u_wispy);
+  
+  gl_FragColor = vec4(u_cloudColor * uColor, cirrus * uOpacity * circle(gl_PointCoord, 0.2));
+}
+`;
+export const CirrusCloudsPointsMaterial = shaderMaterial({
+    u_time: 0,
+    u_windSpeed: 0.3,
+    u_wispy: 2.0,
+    u_cloudColor: new Vector3(1.0, 1.0, 1.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({ CirrusCloudsPointsMaterial });

package/dist/shaders/CloudsMaterial.d.ts

@@ -0,0 +1,47 @@
+import { Vector3, Vector2 } from "three";
+import type { Texture } from 'three';
+export interface CloudsMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_resolution: {
+        value: Vector2;
+    };
+    u_mouse: {
+        value: Vector2;
+    };
+    u_noise: {
+        type: string;
+        value: Texture | null;
+    };
+    u_texture: {
+        value: Texture | null;
+    };
+    u_scroll: {
+        value: number;
+    };
+    u_cloudColor: {
+        value: Vector3;
+    };
+    u_lightColor: {
+        value: Vector3;
+    };
+    u_useOriginalImage: {
+        value: 1.0 | 0.0;
+    };
+}
+declare const CloudsMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_resolution: Vector2;
+    u_mouse: Vector2;
+    u_noise: any;
+    u_texture: any;
+    u_scroll: number;
+    u_cloudColor: Vector3;
+    u_lightColor: Vector3;
+    u_useOriginalImage: number;
+}> & {
+    key: string;
+};
+export { CloudsMaterial };
+//# sourceMappingURL=CloudsMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CloudsMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/CloudsMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAGrC,MAAM,WAAW,sBAAsB;IACnC,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,OAAO,EAAE;QACL,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,OAAO,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;KACzB,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;KACzB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,kBAAkB,EAAE;QAChB,KAAK,EAAE,GAAG,GAAG,GAAG,CAAC;KACpB,CAAC;CACL;AA6GD,QAAA,MAAM,cAAc;;;;;;;;;;;;CAUY,CAAC;AAGjC,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/shaders/CloudsMaterial.js

@@ -0,0 +1,124 @@
+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
+const fragmentShader = /*glsl*/ `
+  uniform vec2 u_resolution;
+  uniform vec2 u_mouse;
+  uniform float u_time;
+  uniform sampler2D u_noise;
+  uniform sampler2D u_texture;
+  uniform float u_scroll;
+  uniform vec3 u_cloudColor; 
+  uniform vec3 u_lightColor;
+  uniform float u_useOriginalImage;
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  
+
+  float mod289(float x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+  vec4 mod289(vec4 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+  vec4 perm(vec4 x) { return mod289(((x * 34.0) + 1.0) * x); }
+
+  float noise(vec3 p) {
+    vec3 a = floor(p);
+    vec3 d = p - a;
+    d = d * d * (3.0 - 2.0 * d);
+
+    vec4 b = a.xxyy + vec4(0.0, 1.0, 0.0, 1.0);
+    vec4 k1 = perm(b.xyxy);
+    vec4 k2 = perm(k1.xyxy + b.zzww);
+
+    vec4 c = k2 + a.zzzz;
+    vec4 k3 = perm(c);
+    vec4 k4 = perm(c + 1.0);
+
+    vec4 o1 = fract(k3 * (1.0 / 41.0));
+    vec4 o2 = fract(k4 * (1.0 / 41.0));
+
+    vec4 o3 = o2 * d.z + o1 * (1.0 - d.z);
+    vec2 o4 = o3.yw * d.x + o3.xz * (1.0 - d.x);
+
+    return o4.y * d.y + o4.x * (1.0 - d.y);
+  }
+  
+  void main() {
+    vec4 bgColor = texture2D(u_texture, vUv);
+
+    // Spherical UV coordinate processing
+    vec2 sphereUV = vUv;
+    
+    // Compensate for pole distortion by adjusting V coordinate
+    float poleCompensation = sin(sphereUV.y * 3.14159);
+    poleCompensation = max(poleCompensation, 0.1); // Prevent division by zero at poles
+    
+    // Create base UV coordinates optimized for sphere geometry
+    vec2 uv = sphereUV;
+    uv.x *= 2.0; // Stretch horizontally to reduce seam visibility
+    uv = (uv - 0.5) * 2.0; // Center and scale
+    
+    // Use 3D position for more natural noise distribution
+    vec3 spherePos = normalize(vPosition);
+    
+    // Generate noise using both UV and 3D position for better sphere distribution
+    float noise1 = noise(vec3(uv * 2.0 + spherePos.xy * 0.5, u_time * 2.0)) * 2.0;
+    float noise2 = noise(vec3(spherePos * 3.0 + vec3(u_time * 1.357 - 10.0)));
+
+    // Apply scroll effect with pole compensation
+    uv.y -= u_scroll * 0.0001 * poleCompensation;
+
+    // Texture sampling with proper sphere scaling
+    uv += texture2D(u_texture, uv * 0.8 - vec2(u_time * 0.05, 0.0)).rg * 0.08 + noise1 * 0.008 * (1.0 - clamp(noise1 * noise1 * 2.0 + 0.2, 0.0, 1.0));
+
+    vec3 tex = texture2D(u_texture, uv * 0.8 - vec2(u_time * 0.02, 0.0)).rgb;
+
+    uv.y -= u_scroll * 0.0001 * poleCompensation;
+    vec3 tex1 = texture2D(u_texture, uv * 0.8 - vec2(u_time * 0.08, 0.0)).rgb;
+
+    uv.y -= u_scroll * 0.0001 * poleCompensation;
+    vec3 tex2 = texture2D(u_texture, uv * 0.6 + 0.2 - vec2(u_time * 0.1, 0.0)).rgb;
+
+    vec3 fragcolour = tex;
+
+    float shade = tex.r;
+    shade *= clamp(noise1 * noise2 * sin(u_time * 3.0), 0.2, 10.0);
+    shade += shade * shade * 3.0;
+    shade -= (1.0 - clamp(tex1 * 4.0, 0.0, 1.0).r) * 0.2;
+    shade -= (1.0 - clamp(tex2 * 4.0, 0.0, 1.0).r) * 0.1;
+
+    // Conditional color mixing
+    if (u_useOriginalImage > 0.5) {
+
+    } else {
+      // Use custom cloud colors
+      fragcolour = mix(u_cloudColor, u_lightColor, shade);
+    }
+    gl_FragColor = vec4(fragcolour, 1.0);
+    // gl_FragColor = bgColor;
+  }
+`;
+// Create the shader material with uniforms
+const CloudsMaterial = shaderMaterial({
+    u_time: 0,
+    u_resolution: new Vector2(),
+    u_mouse: new Vector2(),
+    u_noise: null,
+    u_texture: null,
+    u_scroll: 0.0,
+    u_cloudColor: new Vector3(0.07, 0.0, 0.24),
+    u_lightColor: new Vector3(0.25, 0.6, 1.0),
+    u_useOriginalImage: 0.0
+}, vertexShader, fragmentShader);
+// Extend the material for use in React Three Fiber
+extend({ CloudsMaterial });
+export { CloudsMaterial };

package/dist/shaders/CloudsPointsMaterial.d.ts

@@ -0,0 +1,82 @@
+import { Vector3, Vector2, Color } from "three";
+import type { Texture } from 'three';
+export interface CloudsPointsMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_resolution: {
+        value: Vector2;
+    };
+    u_texture: {
+        value: Texture | null;
+    };
+    u_cloudColor: {
+        value: Vector3;
+    };
+    u_lightColor: {
+        value: Vector3;
+    };
+    u_useOriginalImage: {
+        value: number;
+    };
+    u_pointer: {
+        value: Vector2;
+    };
+    uPointSize: {
+        value: number;
+    };
+    uColor: {
+        value: Color;
+    };
+    uOpacity: {
+        value: number;
+    };
+}
+declare const CloudsPointsMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_resolution: Vector2;
+    u_texture: any;
+    u_cloudColor: Vector3;
+    u_lightColor: Vector3;
+    u_useOriginalImage: 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;
+    uGlowEnabled: false;
+    uGlowIntensity: number;
+    uGlowColor: Color;
+    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;
+};
+export { CloudsPointsMaterial };
+//# sourceMappingURL=CloudsPointsMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CloudsPointsMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/CloudsPointsMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAIrC,MAAM,WAAW,4BAA4B;IACzC,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;KACzB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,kBAAkB,EAAE;QAChB,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;AAwJD,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CM,CAAC;AAEjC,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/shaders/CloudsPointsMaterial.js

@@ -0,0 +1,200 @@
+import { Vector3, Vector2, Color } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+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 sampler2D u_texture;
+uniform vec3 u_cloudColor;
+uniform vec3 u_lightColor;
+uniform float u_useOriginalImage;
+uniform vec3 uColor;
+uniform float uOpacity;
+uniform vec2 u_pointer;
+uniform float uPointerEffectRadius;
+uniform bool uGlowEnabled;
+uniform float uGlowIntensity;
+uniform vec3 uGlowColor;
+
+varying vec2 vTexCoords;
+varying vec2 vUV;
+varying vec3 vPosition;
+
+float mod289(float x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+vec4 mod289(vec4 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+vec4 perm(vec4 x) { return mod289(((x * 34.0) + 1.0) * x); }
+
+float noise(vec3 p) {
+  vec3 a = floor(p);
+  vec3 d = p - a;
+  d = d * d * (3.0 - 2.0 * d);
+  vec4 b = a.xxyy + vec4(0.0, 1.0, 0.0, 1.0);
+  vec4 k1 = perm(b.xyxy);
+  vec4 k2 = perm(k1.xyxy + b.zzww);
+  vec4 c = k2 + a.zzzz;
+  vec4 k3 = perm(c);
+  vec4 k4 = perm(c + 1.0);
+  vec4 o1 = fract(k3 * (1.0 / 41.0));
+  vec4 o2 = fract(k4 * (1.0 / 41.0));
+  vec4 o3 = o2 * d.z + o1 * (1.0 - d.z);
+  vec2 o4 = o3.yw * d.x + o3.xz * (1.0 - d.x);
+  return o4.y * d.y + o4.x * (1.0 - d.y);
+}
+
+float circle(vec2 uv, float border) {
+  float radius = 0.5;
+  float dist = radius - distance(uv, vec2(0.5));
+  return smoothstep(0.0, border, dist);
+}
+
+void main() {
+  vec2 pointUV = gl_PointCoord;
+  vec3 spherePos = normalize(vPosition);
+  
+  float noise1 = noise(vec3(vUV * 2.0 + spherePos.xy * 0.5, u_time * 2.0)) * 2.0;
+  float noise2 = noise(vec3(spherePos * 3.0 + vec3(u_time * 1.357 - 10.0)));
+  
+  vec2 uv = vUV;
+  uv += noise1 * 0.008 * (1.0 - clamp(noise1 * noise1 * 2.0 + 0.2, 0.0, 1.0));
+  
+  float shade = noise1;
+  shade *= clamp(noise1 * noise2 * sin(u_time * 3.0), 0.2, 10.0);
+  shade += shade * shade * 3.0;
+  
+  vec3 cloudColor = u_useOriginalImage > 0.5 ? 
+    vec3(shade) : 
+    mix(u_cloudColor, u_lightColor, shade);
+  
+  vec4 outColor = vec4(cloudColor * uColor, shade * 0.8);
+  outColor.a *= circle(pointUV, 0.2);
+  
+  vec2 scaledPointer = u_pointer * 5.0;
+  float dist = distance(vTexCoords, scaledPointer);
+  float falloff = smoothstep(uPointerEffectRadius, 0.0, dist);
+  
+  if (uGlowEnabled && falloff > 0.0) {
+    outColor.rgb += uGlowColor * uGlowIntensity * falloff;
+  }
+  
+  outColor.a *= uOpacity;
+  gl_FragColor = outColor;
+}
+`;
+const CloudsPointsMaterial = shaderMaterial({
+    u_time: 0,
+    u_resolution: new Vector2(),
+    u_texture: null,
+    u_cloudColor: new Vector3(0.07, 0.0, 0.24),
+    u_lightColor: new Vector3(0.25, 0.6, 1.0),
+    u_useOriginalImage: 0.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,
+    uGlowEnabled: false,
+    uGlowIntensity: 0.5,
+    uGlowColor: new Color(1.0, 1.0, 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({ CloudsPointsMaterial });
+export { CloudsPointsMaterial };

package/dist/shaders/CommonNoiseFunctions.d.ts

@@ -0,0 +1,2 @@
+export declare const commonNoiseFunctions = "\n  float mod289(float x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }\n  vec4 mod289(vec4 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }\n  vec4 perm(vec4 x) { return mod289(((x * 34.0) + 1.0) * x); }\n\n  float noise(vec3 p) {\n    vec3 a = floor(p);\n    vec3 d = p - a;\n    d = d * d * (3.0 - 2.0 * d);\n\n    vec4 b = a.xxyy + vec4(0.0, 1.0, 0.0, 1.0);\n    vec4 k1 = perm(b.xyxy);\n    vec4 k2 = perm(k1.xyxy + b.zzww);\n\n    vec4 c = k2 + a.zzzz;\n    vec4 k3 = perm(c);\n    vec4 k4 = perm(c + 1.0);\n\n    vec4 o1 = fract(k3 * (1.0 / 41.0));\n    vec4 o2 = fract(k4 * (1.0 / 41.0));\n\n    vec4 o3 = o2 * d.z + o1 * (1.0 - d.z);\n    vec2 o4 = o3.yw * d.x + o3.xz * (1.0 - d.x);\n\n    return o4.y * d.y + o4.x * (1.0 - d.y);\n  }\n\n  float fbm(vec3 p) {\n    float value = 0.0;\n    float amplitude = 0.5;\n    float frequency = 1.0;\n    \n    for (int i = 0; i < 4; i++) {\n      value += amplitude * noise(p * frequency);\n      amplitude *= 0.5;\n      frequency *= 2.0;\n    }\n    return value;\n  }\n";
+//# sourceMappingURL=CommonNoiseFunctions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CommonNoiseFunctions.d.ts","sourceRoot":"","sources":["../../src/shaders/CommonNoiseFunctions.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,oBAAoB,0gCAuChC,CAAC"}

package/dist/shaders/CommonNoiseFunctions.js

@@ -0,0 +1,41 @@
+// Common noise functions used across multiple shaders
+export const commonNoiseFunctions = /*glsl*/ `
+  float mod289(float x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+  vec4 mod289(vec4 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+  vec4 perm(vec4 x) { return mod289(((x * 34.0) + 1.0) * x); }
+
+  float noise(vec3 p) {
+    vec3 a = floor(p);
+    vec3 d = p - a;
+    d = d * d * (3.0 - 2.0 * d);
+
+    vec4 b = a.xxyy + vec4(0.0, 1.0, 0.0, 1.0);
+    vec4 k1 = perm(b.xyxy);
+    vec4 k2 = perm(k1.xyxy + b.zzww);
+
+    vec4 c = k2 + a.zzzz;
+    vec4 k3 = perm(c);
+    vec4 k4 = perm(c + 1.0);
+
+    vec4 o1 = fract(k3 * (1.0 / 41.0));
+    vec4 o2 = fract(k4 * (1.0 / 41.0));
+
+    vec4 o3 = o2 * d.z + o1 * (1.0 - d.z);
+    vec2 o4 = o3.yw * d.x + o3.xz * (1.0 - d.x);
+
+    return o4.y * d.y + o4.x * (1.0 - d.y);
+  }
+
+  float fbm(vec3 p) {
+    float value = 0.0;
+    float amplitude = 0.5;
+    float frequency = 1.0;
+    
+    for (int i = 0; i < 4; i++) {
+      value += amplitude * noise(p * frequency);
+      amplitude *= 0.5;
+      frequency *= 2.0;
+    }
+    return value;
+  }
+`;

package/dist/shaders/CoronaMaterial.d.ts

@@ -0,0 +1,41 @@
+import { Vector3 } from "three";
+export interface CoronaMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_intensity: {
+        value: number;
+    };
+    u_falloff: {
+        value: number;
+    };
+    u_pulseSpeed: {
+        value: number;
+    };
+    u_pulseAmount: {
+        value: number;
+    };
+    u_shellScale: {
+        value: number;
+    };
+    u_innerColor: {
+        value: Vector3;
+    };
+    u_outerColor: {
+        value: Vector3;
+    };
+}
+declare const CoronaMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_intensity: number;
+    u_falloff: number;
+    u_pulseSpeed: number;
+    u_pulseAmount: number;
+    u_shellScale: number;
+    u_innerColor: Vector3;
+    u_outerColor: Vector3;
+}> & {
+    key: string;
+};
+export { CoronaMaterial };
+//# sourceMappingURL=CoronaMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CoronaMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/CoronaMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAGhC,MAAM,WAAW,sBAAsB;IACnC,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,aAAa,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;CACL;AAwCD,QAAA,MAAM,cAAc;;;;;;;;;;;CASY,CAAC;AAGjC,OAAO,EAAE,cAAc,EAAE,CAAC"}