@3driseai/3drise-core 1.0.1

package/dist/shaders/StormCloudsPointsMaterial.js

@@ -0,0 +1,389 @@
+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";
+// Vertex shader - combines ShaderEffects functionality with points
+const vertexShader = /*glsl*/ `
+${effectsVertexGLSL}
+
+uniform float uPointSize;
+varying vec2 vTexCoords;
+uniform float uMorphProgress;
+uniform float uNormalizationScale;
+attribute vec3 targetPosition;
+
+// Scale effect uniforms
+uniform bool uScaleEnabled;
+uniform float uScaleIntensity;
+uniform float uMinScale;
+uniform float uMaxScale;
+
+// UV attribute for texture mapping
+attribute vec2 aUV;
+varying vec2 vUV;
+varying vec2 vScreenPosition;
+varying vec3 vPosition;
+
+void main() {
+  // Pass UV and position to fragment shader
+  vUV = aUV;
+  vPosition = position;
+  
+  vec3 pos = position;
+  
+  #include <begin_vertex>
+  
+  vec3 morphedPos = mix(position, targetPosition, uMorphProgress);
+  vec2 rippleCenter = vec2(uGeneralRippleCenterX, uGeneralRippleCenterY);
+  
+  // Apply general effects first (global, always active)
+  
+  // General Wave effect
+  if (uGeneralWaveEnabled) {
+    float waveInput = 0.0;
+    if (uGeneralWaveDirection < 0.5) {
+      waveInput = morphedPos.x;
+    } else if (uGeneralWaveDirection < 1.5) {
+      waveInput = morphedPos.y;
+    } else {
+      waveInput = morphedPos.x + morphedPos.y;
+    }
+    morphedPos.z += sin(waveInput * uGeneralWaveFrequency + u_time * uGeneralWaveSpeed) * uGeneralWaveIntensity;
+  }
+  
+  // General Vortex effect
+  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;
+  }
+  
+  // General Ripple effect
+  if (uGeneralRippleEnabled) {
+    morphedPos = applyGeneralRipple(morphedPos);
+  }
+  
+  // Apply pointer effects
+  vec2 scaledPointer = u_pointer * 5.0;
+  float dist = distance(morphedPos.xy, scaledPointer);
+  float falloff = smoothstep(uPointerEffectRadius, 0.0, dist);
+  
+  // Ripple effect
+  if (uRippleEnabled && falloff > 0.0) {
+    float wave = sin(dist * 5.0 - u_time * uRippleSpeed) * uRippleIntensity;
+    morphedPos.z += wave * falloff * 0.5;
+  }
+  
+  // Displacement effect
+  if (uDisplacementEnabled && falloff > 0.0) {
+    vec2 dir = normalize(morphedPos.xy - scaledPointer);
+    morphedPos.xy += dir * uDisplacementIntensity * falloff * 2.0;
+  }
+  
+  // Vortex effect
+  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;
+  }
+  
+  // Wave effect
+  if (uWaveEnabled && falloff > 0.0) {
+    morphedPos.z += sin(morphedPos.x * uWaveFrequency + u_time) * uWaveIntensity * falloff * 0.5;
+  }
+  
+  vTexCoords = morphedPos.xy;
+  transformed = morphedPos;
+  
+  #include <project_vertex>
+  
+  // Scale effect for point size
+  float sizeMultiplier = 1.0;
+  if (uScaleEnabled && falloff > 0.0) {
+    sizeMultiplier = mix(uMinScale, uMaxScale, falloff * uScaleIntensity);
+  }
+  gl_PointSize = uPointSize * sizeMultiplier;
+  
+  // Pass screen position for fragment shader
+  vScreenPosition = gl_Position.xy / gl_Position.w;
+
+  #include <logdepthbuf_vertex>
+  #include <clipping_planes_vertex>
+  #include <worldpos_vertex>
+  #include <fog_vertex>
+}
+`;
+// Fragment shader - combines Storm Clouds visual with ShaderEffects functionality
+const fragmentShader = /*glsl*/ `
+// Storm Clouds uniforms
+uniform float u_time;
+uniform float u_stormIntensity;
+uniform float u_lightningFreq;
+uniform vec3 u_darkColor;
+uniform vec3 u_lightColor;
+uniform float u_turbulence;
+
+// Shader Effects uniforms
+uniform sampler2D uTexture;
+uniform sampler2D uTargetTexture;
+uniform bool uHasTexture;
+uniform vec3 uColor;
+uniform float uOpacity;
+uniform float uMorphProgress;
+uniform float uParticleUVScale;
+
+// Pointer effects
+uniform vec2 u_pointer;
+uniform float uPointerEffectRadius;
+
+// Fragment effects
+uniform bool uGlowEnabled;
+uniform float uGlowIntensity;
+uniform vec3 uGlowColor;
+uniform bool uColorShiftEnabled;
+uniform float uColorShiftIntensity;
+uniform vec3 uColorShiftTarget;
+uniform bool uBrightnessEnabled;
+uniform float uBrightnessIntensity;
+uniform bool uPulseEnabled;
+uniform float uPulseIntensity;
+uniform float uPulseSpeed;
+
+// Grayscale effects
+uniform bool uGeneralGrayscaleEnabled;
+uniform float uGeneralGrayscaleMode;
+uniform float uGeneralGrayscaleIntensity;
+uniform float uGeneralGrayscaleContrast;
+uniform float uGeneralGrayscaleBrightness;
+uniform float uGeneralGrayscaleWaveFreq;
+uniform float uGeneralGrayscaleWaveSpeed;
+uniform float uGeneralGrayscaleWaveDir;
+uniform float uGeneralGrayscalePulseSpeed;
+uniform float uGeneralGrayscaleRippleSpeed;
+uniform float uGeneralGrayscaleRippleCenterX;
+uniform float uGeneralGrayscaleRippleCenterY;
+uniform bool uPointerGrayscaleEnabled;
+uniform float uPointerGrayscaleIntensity;
+uniform float uPointerGrayscaleContrast;
+uniform float uPointerGrayscaleBrightness;
+
+// Varyings
+varying vec2 vTexCoords;
+varying vec2 vUV;
+varying vec2 vScreenPosition;
+varying vec3 vPosition;
+
+// Common noise functions for storm clouds
+${commonNoiseFunctions}
+
+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;
+  vec4 outColor;
+  
+  // Generate storm clouds effect based on particle position
+  vec3 spherePos = normalize(vPosition);
+  
+  // Heavy, turbulent cloud formation
+  float storm = fbm(spherePos * 2.0 + vec3(u_time * 0.3, u_time * 0.1, 0.0));
+  storm += noise(spherePos * 8.0 + vec3(u_time * u_turbulence)) * 0.3;
+  
+  // Lightning flashes
+  float lightning = sin(u_time * u_lightningFreq) * sin(u_time * u_lightningFreq * 1.7);
+  lightning = max(0.0, lightning);
+  lightning *= noise(spherePos * 10.0 + vec3(u_time * 2.0));
+  
+  // Dark storm clouds with bright lightning
+  vec3 stormColor = mix(u_darkColor, u_lightColor, lightning * 0.8);
+  float density = smoothstep(0.2, 0.8, storm * u_stormIntensity);
+  
+  // Combine with base color
+  outColor = vec4(stormColor * uColor, density);
+  
+  // If texture is provided, blend it with storm effect
+  if (uHasTexture) {
+    vec2 scaledUV = pointUV * uParticleUVScale;
+    scaledUV.y *= -1.0;
+    scaledUV += vUV;
+    vec4 colorA = texture2D(uTexture, scaledUV);
+    vec4 colorB = texture2D(uTargetTexture, scaledUV);
+    vec4 texColor = mix(colorA, colorB, uMorphProgress);
+    outColor = mix(outColor, texColor * vec4(stormColor, 1.0), 0.5);
+  }
+  
+  // Apply circular shape to points
+  float circleAlpha = circle(pointUV, 0.2);
+  outColor.a *= circleAlpha;
+  
+  // Apply pointer fragment effects
+  vec2 scaledPointer = u_pointer * 5.0;
+  float dist = distance(vTexCoords, scaledPointer);
+  float falloff = smoothstep(uPointerEffectRadius, 0.0, dist);
+  
+  // Glow effect
+  if (uGlowEnabled && falloff > 0.0) {
+    outColor.rgb += uGlowColor * uGlowIntensity * falloff;
+  }
+  
+  // Brightness effect
+  if (uBrightnessEnabled && falloff > 0.0) {
+    outColor.rgb *= (1.0 + uBrightnessIntensity * falloff);
+  }
+  
+  // Pulse effect
+  if (uPulseEnabled && falloff > 0.0) {
+    float pulse = sin(u_time * uPulseSpeed) * 0.5 + 0.5;
+    outColor.rgb += vec3(pulse * uPulseIntensity * falloff);
+  }
+  
+  // Color shift effect
+  if (uColorShiftEnabled && falloff > 0.0) {
+    outColor.rgb = mix(outColor.rgb, uColorShiftTarget, uColorShiftIntensity * falloff);
+  }
+  
+  // Pointer Grayscale effect
+  if (uPointerGrayscaleEnabled && falloff > 0.0) {
+    float gray = dot(outColor.rgb, vec3(0.299, 0.587, 0.114));
+    gray = (gray - 0.5) * uPointerGrayscaleContrast + 0.5 + uPointerGrayscaleBrightness;
+    vec3 grayscaleColor = vec3(gray);
+    outColor.rgb = mix(outColor.rgb, grayscaleColor, uPointerGrayscaleIntensity * falloff);
+  }
+  
+  // General Grayscale effect
+  if (uGeneralGrayscaleEnabled) {
+    float grayscaleFactor = 0.0;
+    
+    if (uGeneralGrayscaleMode < 0.5) {
+      // Mode 0: Static
+      grayscaleFactor = uGeneralGrayscaleIntensity;
+    } else if (uGeneralGrayscaleMode < 1.5) {
+      // Mode 1: Wave
+      float wavePos = 0.0;
+      if (uGeneralGrayscaleWaveDir < 0.5) {
+        wavePos = vTexCoords.x;
+      } else if (uGeneralGrayscaleWaveDir < 1.5) {
+        wavePos = vTexCoords.y;
+      } else {
+        wavePos = vTexCoords.x + vTexCoords.y;
+      }
+      grayscaleFactor = (sin(wavePos * uGeneralGrayscaleWaveFreq + u_time * uGeneralGrayscaleWaveSpeed) * 0.5 + 0.5) * uGeneralGrayscaleIntensity;
+    } else if (uGeneralGrayscaleMode < 2.5) {
+      // Mode 2: Pulse
+      grayscaleFactor = (sin(u_time * uGeneralGrayscalePulseSpeed) * 0.5 + 0.5) * uGeneralGrayscaleIntensity;
+    } else {
+      // Mode 3: Ripple
+      vec2 rippleCenter = vec2(uGeneralGrayscaleRippleCenterX, uGeneralGrayscaleRippleCenterY);
+      float rippleDist = distance(vTexCoords, rippleCenter);
+      grayscaleFactor = (sin(rippleDist * 5.0 - u_time * uGeneralGrayscaleRippleSpeed) * 0.5 + 0.5) * uGeneralGrayscaleIntensity;
+    }
+    
+    float gray = dot(outColor.rgb, vec3(0.299, 0.587, 0.114));
+    gray = (gray - 0.5) * uGeneralGrayscaleContrast + 0.5 + uGeneralGrayscaleBrightness;
+    vec3 grayscaleColor = vec3(gray);
+    outColor.rgb = mix(outColor.rgb, grayscaleColor, grayscaleFactor);
+  }
+  
+  outColor.a *= uOpacity;
+  
+  // Soft edges for better blending
+  float edgeFade = 1.0 - length(pointUV * 2.0 - 1.0) * 0.3;
+  outColor.a *= edgeFade;
+  
+  gl_FragColor = outColor;
+}
+`;
+// Create the shader material with all uniforms
+const StormCloudsPointsMaterial = shaderMaterial({
+    // Storm Clouds defaults
+    u_time: 0,
+    u_stormIntensity: 1.2,
+    u_lightningFreq: 3.0,
+    u_darkColor: new Vector3(0.1, 0.1, 0.2),
+    u_lightColor: new Vector3(0.9, 0.9, 1.0),
+    u_turbulence: 0.5,
+    // Shader Effects defaults
+    uTexture: null,
+    uTargetTexture: null,
+    uHasTexture: false,
+    uPointSize: 5.0,
+    u_pointer: new Vector2(),
+    uColor: new Color(1.0, 1.0, 1.0),
+    uMorphProgress: 0.0,
+    uNormalizationScale: 1.0,
+    uOpacity: 1.0,
+    uParticleUVScale: 0.01,
+    // Pointer effects
+    uPointerEffectRadius: 2.5,
+    // Vertex effects
+    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,
+    uWaveEnabled: false,
+    uWaveIntensity: 0.5,
+    uWaveFrequency: 5.0,
+    // Fragment effects
+    uGlowEnabled: false,
+    uGlowIntensity: 0.5,
+    uGlowColor: new Color(1.0, 1.0, 1.0),
+    uColorShiftEnabled: false,
+    uColorShiftIntensity: 0.5,
+    uColorShiftTarget: new Color(1.0, 0.4, 0.0),
+    uBrightnessEnabled: false,
+    uBrightnessIntensity: 0.5,
+    uPulseEnabled: false,
+    uPulseIntensity: 0.5,
+    uPulseSpeed: 2.0,
+    // General effects
+    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,
+    // Grayscale effects
+    uGeneralGrayscaleEnabled: false,
+    uGeneralGrayscaleMode: 0.0,
+    uGeneralGrayscaleIntensity: 1.0,
+    uGeneralGrayscaleContrast: 1.0,
+    uGeneralGrayscaleBrightness: 0.0,
+    uGeneralGrayscaleWaveFreq: 3.0,
+    uGeneralGrayscaleWaveSpeed: 1.0,
+    uGeneralGrayscaleWaveDir: 0.0,
+    uGeneralGrayscalePulseSpeed: 2.0,
+    uGeneralGrayscaleRippleSpeed: 2.0,
+    uGeneralGrayscaleRippleCenterX: 0.0,
+    uGeneralGrayscaleRippleCenterY: 0.0,
+    uPointerGrayscaleEnabled: false,
+    uPointerGrayscaleIntensity: 1.0,
+    uPointerGrayscaleContrast: 1.0,
+    uPointerGrayscaleBrightness: 0.0,
+}, vertexShader, fragmentShader);
+extend({ StormCloudsPointsMaterial });
+export { StormCloudsPointsMaterial };

package/dist/shaders/SunCoreMaterial.d.ts

@@ -0,0 +1,69 @@
+import { Vector3 } from "three";
+export interface SunCoreMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_speed: {
+        value: number;
+    };
+    u_cellScale: {
+        value: number;
+    };
+    u_warpStrength: {
+        value: number;
+    };
+    u_boilAmplitude: {
+        value: number;
+    };
+    u_crackIntensity: {
+        value: number;
+    };
+    u_spotIntensity: {
+        value: number;
+    };
+    u_rimIntensity: {
+        value: number;
+    };
+    u_brightness: {
+        value: number;
+    };
+    u_rimColor: {
+        value: Vector3;
+    };
+    u_color1: {
+        value: Vector3;
+    };
+    u_color2: {
+        value: Vector3;
+    };
+    u_color3: {
+        value: Vector3;
+    };
+    u_color4: {
+        value: Vector3;
+    };
+    u_color5: {
+        value: Vector3;
+    };
+}
+declare const SunCoreMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_speed: number;
+    u_cellScale: number;
+    u_warpStrength: number;
+    u_boilAmplitude: number;
+    u_crackIntensity: number;
+    u_spotIntensity: number;
+    u_rimIntensity: number;
+    u_brightness: number;
+    u_rimColor: Vector3;
+    u_color1: Vector3;
+    u_color2: Vector3;
+    u_color3: Vector3;
+    u_color4: Vector3;
+    u_color5: Vector3;
+}> & {
+    key: string;
+};
+export { SunCoreMaterial };
+//# sourceMappingURL=SunCoreMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SunCoreMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/SunCoreMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAIhC,MAAM,WAAW,uBAAuB;IACpC,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,OAAO,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,eAAe,EAAE;QACb,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,gBAAgB,EAAE;QACd,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,eAAe,EAAE;QACb,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;CACL;AAyGD,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;CAgBW,CAAC;AAGjC,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/shaders/SunCoreMaterial.js

@@ -0,0 +1,127 @@
+import { Vector3 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+import { NOISE_GLSL } from "./sunNoise.js";
+// Vertex shader
+const vertexShader = /*glsl*/ `
+  uniform float u_time;
+  uniform float u_speed;
+  uniform float u_boilAmplitude;
+  varying vec3 vPosition;
+  varying vec3 vNormal;
+  varying vec3 vViewDir;
+
+  ${NOISE_GLSL}
+
+  void main() {
+    vPosition = position;
+    vNormal = normalize(normalMatrix * normal);
+
+    float t = u_time * u_speed;
+    float boil = fbm(position * 1.1 + vec3(0.0, t * 0.04, t * 0.03));
+    vec3 displaced = position + normal * boil * u_boilAmplitude;
+
+    vec4 mv = modelViewMatrix * vec4(displaced, 1.0);
+    vViewDir = normalize(-mv.xyz);
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+// Fragment shader
+const fragmentShader = /*glsl*/ `
+  uniform float u_time;
+  uniform float u_speed;
+  uniform float u_cellScale;
+  uniform float u_warpStrength;
+  uniform float u_crackIntensity;
+  uniform float u_spotIntensity;
+  uniform float u_rimIntensity;
+  uniform float u_brightness;
+  uniform vec3 u_rimColor;
+  uniform vec3 u_color1;
+  uniform vec3 u_color2;
+  uniform vec3 u_color3;
+  uniform vec3 u_color4;
+  uniform vec3 u_color5;
+  varying vec3 vPosition;
+  varying vec3 vNormal;
+  varying vec3 vViewDir;
+
+  ${NOISE_GLSL}
+
+  vec3 sunRamp(float t) {
+    t = clamp(t, 0.0, 1.0);
+    vec3 col = mix(u_color1, u_color2, smoothstep(0.00, 0.28, t));
+    col = mix(col, u_color3, smoothstep(0.28, 0.55, t));
+    col = mix(col, u_color4, smoothstep(0.55, 0.78, t));
+    col = mix(col, u_color5, smoothstep(0.78, 1.00, t));
+    return col;
+  }
+
+  void main() {
+    float t = u_time * u_speed;
+
+    vec3 p = vPosition * u_cellScale;
+
+    // Double domain warp: plasma smears and curls instead of scrolling.
+    vec3 q = vec3(
+      fbm(p + vec3(0.0, 0.0,  t * 0.07)),
+      fbm(p + vec3(5.2, 1.3,  t * 0.06)),
+      fbm(p + vec3(2.8, 8.3, -t * 0.06))
+    );
+
+    vec3 r = vec3(
+      fbm(p + 1.8 * u_warpStrength * q + vec3(1.7, 9.2, t * 0.12)),
+      fbm(p + 1.8 * u_warpStrength * q + vec3(8.3, 2.8, t * 0.11)),
+      fbm(p + 1.8 * u_warpStrength * q + vec3(4.1, 5.6, t * 0.10))
+    );
+
+    float flow = fbm(p + 2.0 * u_warpStrength * r + vec3(0.0, 0.0, t * 0.04));
+    flow = flow * 0.5 + 0.5;
+
+    // Bright filament cracks between convection cells.
+    float cracks = ridgedFbm(p * 0.9 + r * 1.2 + vec3(0.0, t * 0.05, 0.0));
+    cracks = smoothstep(1.05, 1.55, cracks);
+
+    // Sunspots: rare dark patches with a dimmed penumbra ring.
+    float spotField = fbm(vPosition * 1.1 + vec3(13.7, 7.1, t * 0.015));
+    float spots = smoothstep(0.42, 0.72, spotField);
+    float penumbra = smoothstep(0.30, 0.42, spotField) - spots;
+
+    float temp = flow * 0.85 + length(q) * 0.18;
+    temp += cracks * u_crackIntensity;
+    temp -= spots * 0.85 * u_spotIntensity;
+    temp -= penumbra * 0.35 * u_spotIntensity;
+
+    vec3 col = sunRamp(temp);
+
+    float fresnel = pow(1.0 - clamp(dot(normalize(vNormal), normalize(vViewDir)), 0.0, 1.0), 2.5);
+    col += u_rimColor * fresnel * u_rimIntensity;
+    col += vec3(1.0, 0.85, 0.55) * cracks * u_crackIntensity * 0.6;
+
+    col *= u_brightness;
+    col = col / (1.0 + 0.18 * col);
+
+    gl_FragColor = vec4(col, 1.0);
+  }
+`;
+// Create the shader material with uniforms
+const SunCoreMaterial = shaderMaterial({
+    u_time: 0,
+    u_speed: 0.1,
+    u_cellScale: 1.3,
+    u_warpStrength: 1.0,
+    u_boilAmplitude: 0.028,
+    u_crackIntensity: 0.3,
+    u_spotIntensity: 1.0,
+    u_rimIntensity: 1.6,
+    u_brightness: 1.0,
+    u_rimColor: new Vector3(1.0, 0.45, 0.08),
+    u_color1: new Vector3(0.18, 0.005, 0.0),
+    u_color2: new Vector3(0.62, 0.07, 0.005),
+    u_color3: new Vector3(1.0, 0.34, 0.02),
+    u_color4: new Vector3(1.0, 0.72, 0.18),
+    u_color5: new Vector3(1.0, 0.97, 0.78)
+}, vertexShader, fragmentShader);
+// Extend the material for use in React Three Fiber
+extend({ SunCoreMaterial });
+export { SunCoreMaterial };

package/dist/shaders/VolumetricCloudsMaterial.d.ts

@@ -0,0 +1,56 @@
+import { Vector2, Vector3 } from "three";
+export interface VolumetricCloudsUniforms {
+    u_time: {
+        value: number;
+    };
+    u_resolution: {
+        value: Vector2;
+    };
+    u_cameraPos: {
+        value: Vector3;
+    };
+    u_cloudColor: {
+        value: Vector3;
+    };
+    u_lightDirection: {
+        value: Vector3;
+    };
+    u_cloudDensity: {
+        value: number;
+    };
+    u_cloudCoverage: {
+        value: number;
+    };
+    u_cloudScale: {
+        value: number;
+    };
+    u_lightColor: {
+        value: Vector3;
+    };
+    u_shadowColor: {
+        value: Vector3;
+    };
+    u_absorption: {
+        value: number;
+    };
+    u_scattering: {
+        value: number;
+    };
+}
+export declare const VolumetricCloudsMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_resolution: Vector2;
+    u_cameraPos: Vector3;
+    u_cloudColor: Vector3;
+    u_lightDirection: Vector3;
+    u_cloudDensity: number;
+    u_cloudCoverage: number;
+    u_cloudScale: number;
+    u_lightColor: Vector3;
+    u_shadowColor: Vector3;
+    u_absorption: number;
+    u_scattering: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=VolumetricCloudsMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VolumetricCloudsMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/VolumetricCloudsMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAIzC,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,YAAY,EAAE;QACV,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,eAAe,EAAE;QACb,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,aAAa,EAAE;QACX,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AA4ED,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;CAae,CAAC"}