@3driseai/3drise-core 1.0.1

package/dist/shaders/ShootingStarMaterial.js

@@ -0,0 +1,42 @@
+import { Color } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+// Vertex shader for the shooting star trail
+const vertexShader = /*glsl*/ `
+  varying vec2 vUv;
+  varying float vProgress;
+  attribute float progress;
+  
+  void main() {
+    vUv = uv;
+    vProgress = progress;
+    
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+// Fragment shader with gradient fade effect
+const fragmentShader = /*glsl*/ `
+  uniform vec3 color;
+  uniform float opacity;
+  varying vec2 vUv;
+  varying float vProgress;
+  
+  void main() {
+    // Create gradient fade from bright (head) to transparent (tail)
+    float alpha = opacity * (1.0 - vProgress) * (1.0 - vProgress);
+    
+    // Add glow effect
+    float glow = 1.0 - vProgress;
+    vec3 glowColor = color * (1.0 + glow * 0.5);
+    
+    gl_FragColor = vec4(glowColor, alpha);
+  }
+`;
+// Create the shader material
+const ShootingStarMaterial = shaderMaterial({
+    color: new Color(1.0, 1.0, 1.0),
+    opacity: 1.0,
+}, vertexShader, fragmentShader);
+// Extend for React Three Fiber
+extend({ ShootingStarMaterial });
+export { ShootingStarMaterial };

package/dist/shaders/SkyCloudsMaterial.d.ts

@@ -0,0 +1,76 @@
+import { Color, Vector2, Vector3 } from "three";
+export interface SkyCloudsMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_cloudColor: {
+        value: Color;
+    };
+    u_ambientColor: {
+        value: Color;
+    };
+    u_cameraPos: {
+        value: Vector3;
+    };
+    u_resolution: {
+        value: Vector2;
+    };
+    u_sunPosition: {
+        value: Vector3;
+    };
+    u_cloudCoverage: {
+        value: number;
+    };
+    u_cloudScale: {
+        value: number;
+    };
+    u_softness: {
+        value: number;
+    };
+    u_windDirection: {
+        value: Vector2;
+    };
+    u_silverLining: {
+        value: number;
+    };
+    u_selfShading: {
+        value: number;
+    };
+    u_godRays: {
+        value: number;
+    };
+    u_storminess: {
+        value: number;
+    };
+    u_bloomIntensity: {
+        value: number;
+    };
+}
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            skyCloudsMaterial: any;
+        }
+    }
+}
+declare const SkyCloudsMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_cloudColor: Color;
+    u_ambientColor: Color;
+    u_cameraPos: Vector3;
+    u_resolution: Vector2;
+    u_sunPosition: Vector3;
+    u_cloudCoverage: number;
+    u_cloudScale: number;
+    u_softness: number;
+    u_windDirection: Vector2;
+    u_silverLining: number;
+    u_selfShading: number;
+    u_godRays: number;
+    u_storminess: number;
+    u_bloomIntensity: number;
+}> & {
+    key: string;
+};
+export { SkyCloudsMaterial };
+//# sourceMappingURL=SkyCloudsMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SkyCloudsMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/SkyCloudsMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAGhD,MAAM,WAAW,yBAAyB;IACtC,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,KAAK,CAAC;KAChB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,KAAK,CAAC;KAChB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,aAAa,EAAE;QACX,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,eAAe,EAAE;QACb,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,eAAe,EAAE;QACb,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,aAAa,EAAE;QACX,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,gBAAgB,EAAE;QACd,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAED,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,GAAG,CAAC;QACV,UAAU,iBAAiB;YACvB,iBAAiB,EAAE,GAAG,CAAC;SAC1B;KACJ;CACJ;AA+LD,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;CAgBS,CAAC;AAGjC,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/shaders/SkyCloudsMaterial.js

@@ -0,0 +1,212 @@
+import { Color, Vector2, Vector3 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+// Vertex shader
+const vertexShader = /*glsl*/ `
+  varying vec2 vUv;
+  varying vec3 vWorldPosition;
+
+  void main() {
+    vUv = uv;
+    vec4 worldPosition = modelMatrix * vec4(position, 1.0);
+    vWorldPosition = worldPosition.xyz;
+
+    vec4 pos = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+    gl_Position = pos.xyww;
+  }
+`;
+// Fragment shader with simplex noise for procedural clouds
+const fragmentShader = /*glsl*/ `
+  uniform float u_time;
+  uniform vec3 u_cloudColor;
+  uniform vec3 u_ambientColor;
+  uniform vec3 u_cameraPos;
+  uniform vec2 u_resolution;
+  uniform vec3 u_sunPosition;
+  uniform float u_cloudCoverage;
+  uniform float u_cloudScale;
+  uniform float u_softness;
+  uniform vec2 u_windDirection;
+  uniform float u_silverLining;
+  uniform float u_selfShading;
+  uniform float u_godRays;
+  uniform float u_storminess;
+  uniform float u_bloomIntensity;
+
+  varying vec2 vUv;
+  varying vec3 vWorldPosition;
+
+  // Simplex noise permutation function
+  vec3 permute(vec3 x) {
+    return mod(((x * 34.0) + 1.0) * x, 289.0);
+  }
+
+  // 2D Simplex noise
+  float snoise(vec2 v) {
+    const vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439);
+    vec2 i  = floor(v + dot(v, C.yy));
+    vec2 x0 = v - i + dot(i, C.xx);
+    vec2 i1;
+    i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+    vec4 x12 = x0.xyxy + C.xxzz;
+    x12.xy -= i1;
+    i = mod(i, 289.0);
+    vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0)) + i.x + vec3(0.0, i1.x, 1.0));
+    vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);
+    m = m * m;
+    m = m * m;
+    vec3 x = 2.0 * fract(p * C.www) - 1.0;
+    vec3 h = abs(x) - 0.5;
+    vec3 ox = floor(x + 0.5);
+    vec3 a0 = x - ox;
+    m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
+    vec3 g;
+    g.x  = a0.x  * x0.x  + h.x  * x0.y;
+    g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+    return 130.0 * dot(m, g);
+  }
+
+  void main() {
+    // Wind-driven UV offset (replaces hardcoded X drift)
+    vec2 windOffset = u_windDirection * u_time / 100.0;
+
+    // Cloud UV with camera-based parallax, wind, and scale
+    vec2 cloudUV = vUv * u_cloudScale + vec2(
+      u_cameraPos.x / 1000.0,
+      u_cameraPos.z / 1000.0
+    ) + windOffset;
+
+    // Storminess adds turbulent UV distortion
+    float stormDistort = u_storminess * 0.3;
+    cloudUV += stormDistort * vec2(
+      snoise(vUv * 4.0 + u_time * 0.1),
+      snoise(vUv * 4.0 + u_time * 0.1 + 100.0)
+    );
+
+    // Multi-octave noise for cloud density
+    float n = snoise(cloudUV * 3.0 + u_time / 50.0) * 0.6
+            + snoise(cloudUV * 6.0 + u_time / 40.0) * 0.3
+            + snoise(cloudUV * 12.0 + u_time / 30.0) * 0.1;
+
+    // Coverage: shift noise range — 0.0 = clear sky, 1.0 = fully overcast
+    // Default coverage 0.5 reproduces original look (threshold centered)
+    float coverageShift = (u_cloudCoverage - 0.5) * 1.6;
+    float rawDensity = 0.5 * n + 0.5 + coverageShift;
+
+    // Softness controls the smoothstep width (0=sharp cumulus, 1=diffuse haze)
+    float softLow = mix(0.3, 0.05, u_softness);
+    float softHigh = mix(0.7, 0.95, u_softness);
+    float cloudDensity = smoothstep(softLow, softHigh, rawDensity);
+
+    // Storminess boosts density
+    cloudDensity = mix(cloudDensity, min(cloudDensity * 1.4, 1.0), u_storminess);
+
+    // Horizon fade to prevent hard edges
+    float horizonFade = smoothstep(0.0, 0.3, 1.0 - abs(vUv.y - 0.5) * 2.0);
+    
+    // Edge fade for smooth blending at cloud boundaries
+    float edgeFade = (1.0 - pow(abs(vUv.x - 0.5) * 2.0, 2.0)) *
+                    (1.0 - pow(abs(vUv.y - 0.5) * 2.0, 2.0));
+
+    float finalOpacity = cloudDensity * horizonFade * edgeFade * 0.7;
+
+    // ---- LIGHTING ----
+    // Sun direction projected to 2D cloud plane (xz → UV)
+    vec3 sunDir = normalize(u_sunPosition);
+    vec2 sunDir2D = normalize(sunDir.xz + vec2(0.001));
+
+    // Noise gradient (finite differences for cheap normal approximation)
+    float eps = 0.01;
+    float nR = snoise((cloudUV + vec2(eps, 0.0)) * 3.0 + u_time / 50.0);
+    float nU = snoise((cloudUV + vec2(0.0, eps)) * 3.0 + u_time / 50.0);
+    vec2 noiseGrad = vec2(nR - n * 0.6 / 0.6, nU - n * 0.6 / 0.6) / eps;
+
+    // Silver lining: bright rim on cloud edges facing the sun
+    float gradSunDot = dot(normalize(noiseGrad + vec2(0.001)), sunDir2D);
+    float silverLining = smoothstep(0.0, 1.0, gradSunDot) * u_silverLining;
+    // Stronger at cloud edges (thin regions)
+    float edgeMask = smoothstep(0.05, 0.4, cloudDensity) * (1.0 - smoothstep(0.4, 0.9, cloudDensity));
+    silverLining *= edgeMask;
+
+    // Self-shading: darken underside (opposite sun direction in Y)
+    // sunDir.y > 0 means sun is above — bottom of clouds should be darker
+    float shadeFactor = u_selfShading * (1.0 - smoothstep(0.0, 0.6, cloudDensity));
+    float sunHeight = clamp(sunDir.y, 0.0, 1.0);
+    shadeFactor *= sunHeight;
+
+    // Blend lit color and ambient/shadow color
+    vec3 litColor = u_cloudColor;
+    vec3 shadowColor = u_ambientColor;
+    // Storminess darkens overall color
+    litColor = mix(litColor, litColor * 0.4, u_storminess);
+    shadowColor = mix(shadowColor, shadowColor * 0.3, u_storminess);
+
+    vec3 baseColor = mix(litColor, shadowColor, shadeFactor);
+    // Add silver lining glow
+    baseColor += vec3(silverLining) * litColor * 1.5;
+
+    // ---- GOD RAYS ----
+    if (u_godRays > 0.0) {
+      // Project sun to UV space
+      vec2 sunUV = sunDir.xz * 0.5 + 0.5;
+      vec2 toSun = sunUV - vUv;
+      float distToSun = length(toSun);
+
+      // Radial sampling: accumulate cloud gaps along ray toward sun
+      float rayAccum = 0.0;
+      const int RAY_STEPS = 8;
+      for (int i = 1; i <= RAY_STEPS; i++) {
+        vec2 samplePos = vUv + toSun * float(i) / float(RAY_STEPS) * 0.5;
+        vec2 sampleCloudUV = samplePos * u_cloudScale + vec2(
+          u_cameraPos.x / 1000.0,
+          u_cameraPos.z / 1000.0
+        ) + windOffset;
+        float sampleN = snoise(sampleCloudUV * 3.0 + u_time / 50.0) * 0.6
+                       + snoise(sampleCloudUV * 6.0 + u_time / 40.0) * 0.3;
+        float sampleDensity = smoothstep(softLow, softHigh, 0.5 * sampleN + 0.5 + coverageShift);
+        rayAccum += (1.0 - sampleDensity);
+      }
+      rayAccum /= float(RAY_STEPS);
+
+      // Rays stronger near sun, fade with distance
+      float rayFalloff = exp(-distToSun * 3.0) * sunHeight;
+      float rays = rayAccum * rayFalloff * u_godRays;
+
+      // Add warm light shaft color
+      vec3 rayColor = litColor * 1.2;
+      baseColor += rayColor * rays * (1.0 - cloudDensity * 0.5);
+      finalOpacity = max(finalOpacity, rays * 0.3 * horizonFade * edgeFade);
+    }
+
+    // Bloom: push lit edges above 1.0 for post-processing bloom interaction
+    baseColor += vec3(silverLining * u_bloomIntensity * 0.5);
+
+    vec3 finalColor = baseColor;
+
+    gl_FragColor = vec4(finalColor, finalOpacity);
+
+    // Discard nearly transparent fragments for performance
+    if (finalOpacity < 0.01) discard;
+  }
+`;
+// Create the shader material with uniforms
+const SkyCloudsMaterial = shaderMaterial({
+    u_time: 0.0,
+    u_cloudColor: new Color(1.0, 1.0, 1.0),
+    u_ambientColor: new Color(0.7, 0.7, 0.8),
+    u_cameraPos: new Vector3(),
+    u_resolution: new Vector2(800, 600),
+    u_sunPosition: new Vector3(0.0, 1.0, 0.0),
+    u_cloudCoverage: 0.5,
+    u_cloudScale: 6.0,
+    u_softness: 0.5,
+    u_windDirection: new Vector2(1.0, 0.0),
+    u_silverLining: 0.0,
+    u_selfShading: 0.0,
+    u_godRays: 0.0,
+    u_storminess: 0.0,
+    u_bloomIntensity: 0.0,
+}, vertexShader, fragmentShader);
+// Extend the material for use in React Three Fiber
+extend({ SkyCloudsMaterial });
+export { SkyCloudsMaterial };

package/dist/shaders/SkyMaterial.d.ts

@@ -0,0 +1,130 @@
+import { Vector3, Vector2 } from "three";
+import type { Texture } from 'three';
+export interface SkyMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_resolution: {
+        value: Vector2;
+    };
+    u_pointer: {
+        value: Vector2;
+    };
+    iChannel0: {
+        value: Texture | null;
+    };
+    R0: {
+        value: number;
+    };
+    Ra: {
+        value: number;
+    };
+    I: {
+        value: number;
+    };
+    SI: {
+        value: number;
+    };
+    g: {
+        value: number;
+    };
+    Hr: {
+        value: number;
+    };
+    Hm: {
+        value: number;
+    };
+    bR: {
+        value: Vector3;
+    };
+    bM: {
+        value: Vector3;
+    };
+    cloudy: {
+        value: number;
+    };
+    haze: {
+        value: number;
+    };
+    rainmulti: {
+        value: number;
+    };
+    cameraheight: {
+        value: number;
+    };
+    mincloudheight: {
+        value: number;
+    };
+    maxcloudheight: {
+        value: number;
+    };
+    xaxiscloud: {
+        value: number;
+    };
+    yaxiscloud: {
+        value: number;
+    };
+    zaxiscloud: {
+        value: number;
+    };
+    cloudnoise: {
+        value: number;
+    };
+    steps: {
+        value: number;
+    };
+    stepss: {
+        value: number;
+    };
+    fov: {
+        value: number;
+    };
+    enableRain: {
+        value: number;
+    };
+    simpleSun: {
+        value: number;
+    };
+    nicehackSun: {
+        value: number;
+    };
+    softSun: {
+        value: number;
+    };
+}
+declare const SkyMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_resolution: Vector2;
+    u_pointer: Vector2;
+    iChannel0: any;
+    R0: number;
+    Ra: number;
+    I: number;
+    SI: number;
+    g: number;
+    Hr: number;
+    Hm: number;
+    bR: Vector3;
+    bM: Vector3;
+    cloudy: number;
+    haze: number;
+    rainmulti: number;
+    cameraheight: number;
+    mincloudheight: number;
+    maxcloudheight: number;
+    xaxiscloud: number;
+    yaxiscloud: number;
+    zaxiscloud: number;
+    cloudnoise: number;
+    steps: number;
+    stepss: number;
+    fov: number;
+    enableRain: number;
+    simpleSun: number;
+    nicehackSun: number;
+    softSun: number;
+}> & {
+    key: string;
+};
+export { SkyMaterial };
+//# sourceMappingURL=SkyMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SkyMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/SkyMaterial.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,mBAAmB;IAChC,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,CAAC;KAClB,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;KACzB,CAAC;IACF,EAAE,EAAE;QACA,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,EAAE,EAAE;QACA,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,CAAC,EAAE;QACC,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,EAAE,EAAE;QACA,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,CAAC,EAAE;QACC,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,EAAE,EAAE;QACA,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,EAAE,EAAE;QACA,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,EAAE,EAAE;QACA,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,EAAE,EAAE;QACA,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,IAAI,EAAE;QACF,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,cAAc,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,KAAK,EAAE;QACH,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,GAAG,EAAE;QACD,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,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,OAAO,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAmMD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCe,CAAC;AAGjC,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/shaders/SkyMaterial.js

@@ -0,0 +1,237 @@
+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);
+  }
+`;
+// Fragment shader - simplified and working version
+const fragmentShader = /*glsl*/ `
+  uniform float u_time;
+  uniform vec2 u_resolution;
+  uniform vec2 u_pointer;
+  uniform sampler2D iChannel0;
+  
+  // Environment constants
+  uniform float R0; // planet radius
+  uniform float Ra; // atmosphere radius
+  uniform float I; // sun light power
+  uniform float SI; // sun intensity
+  uniform float g; // light concentration
+  uniform float Hr; // Rayleigh scattering top
+  uniform float Hm; // Mie scattering top
+  
+  // Scattering coefficients
+  uniform vec3 bR; // Rayleigh scattering
+  uniform vec3 bM; // Mie scattering
+  
+  // Cloud parameters
+  uniform float cloudy;
+  uniform float haze;
+  uniform float rainmulti;
+  uniform float cameraheight;
+  uniform float mincloudheight;
+  uniform float maxcloudheight;
+  uniform float xaxiscloud;
+  uniform float yaxiscloud;
+  uniform float zaxiscloud;
+  uniform float cloudnoise;
+  
+  // Rendering parameters
+  uniform float steps;
+  uniform float stepss;
+  
+  // Sun parameters
+  uniform float fov;
+  
+  // Feature toggles
+  uniform float enableRain;
+  uniform float simpleSun;
+  uniform float nicehackSun;
+  uniform float softSun;
+  
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  varying vec3 vWorldPosition;
+  
+  #define PI 3.14159265358979323846
+  
+  // Simple noise function
+  float hash(vec2 p) {
+    return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
+  }
+  
+  float noise(vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);
+    vec2 u = f * f * (3.0 - 2.0 * f);
+    return 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);
+  }
+  
+  // Fractal noise
+  float fbm(vec2 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;
+  }
+  
+  // Simple atmospheric scattering
+  vec3 atmosphere(vec3 rayDir, vec3 sunDir) {
+    float sunDot = dot(rayDir, sunDir);
+    
+    // Sky gradient
+    float skyGradient = 1.0 - abs(rayDir.y);
+    vec3 skyColor = mix(vec3(0.1, 0.3, 0.8), vec3(0.8, 0.9, 1.0), skyGradient);
+    
+    // Sun
+    float sunSize = 1.0 - distance(rayDir, sunDir);
+    sunSize = max(sunSize, 0.0);
+    vec3 sunColor = vec3(1.0, 0.8, 0.6) * pow(sunSize, 256.0) * 50.0;
+    
+    // Sun glow
+    float sunGlow = 1.0 - distance(rayDir, sunDir);
+    sunGlow = max(sunGlow, 0.0);
+    vec3 glowColor = vec3(1.0, 0.6, 0.3) * pow(sunGlow, 8.0) * 0.5;
+    
+    return skyColor + sunColor + glowColor;
+  }
+  
+  // Simple cloud generation
+  vec3 clouds(vec2 uv, float time) {
+    vec2 cloudUV = uv * 2.0 + vec2(time * 0.1, 0.0);
+    float cloudNoise = fbm(cloudUV * 3.0);
+    cloudNoise = smoothstep(0.4, 0.8, cloudNoise);
+    
+    vec3 cloudColor = vec3(1.0) * cloudNoise * cloudy;
+    return cloudColor;
+  }
+  
+  // Simple star field
+  vec3 stars(vec2 uv) {
+    vec2 starUV = uv * 100.0;
+    float starNoise = hash(floor(starUV));
+    starNoise = step(0.99, starNoise);
+    
+    vec3 starColor = vec3(1.0) * starNoise * 0.5;
+    return starColor;
+  }
+  
+  // Aurora effect
+  vec3 aurora(vec2 uv, float time) {
+    vec2 auroraUV = uv + vec2(sin(time * 0.5) * 0.1, 0.0);
+    float auroraPattern = sin(auroraUV.x * 10.0 + time) * sin(auroraUV.y * 5.0);
+    auroraPattern = max(auroraPattern, 0.0);
+    auroraPattern = pow(auroraPattern, 3.0);
+    
+    vec3 auroraColor = vec3(0.2, 1.0, 0.5) * auroraPattern * 0.3;
+    return auroraColor;
+  }
+  
+  void main() {
+    vec2 uv = (gl_FragCoord.xy - 0.5 * u_resolution.xy) / u_resolution.y;
+    
+    // Mouse position for sun direction
+    vec2 mouse = u_pointer.xy / u_resolution.xy;
+    if (mouse.x == 0.0 && mouse.y == 0.0) {
+      mouse = vec2(0.5, 0.7); // Default sun position
+    }
+    
+    // Ray direction
+    vec3 rayDir = normalize(vec3(uv, -1.0));
+    
+    // Sun direction
+    vec3 sunDir = normalize(vec3(
+      (mouse.x - 0.5) * 2.0,
+      (mouse.y - 0.5) * 2.0,
+      -0.5
+    ));
+    
+    // Base atmosphere
+    vec3 color = atmosphere(rayDir, sunDir);
+    
+    // Add clouds
+    if (cloudy > 0.0) {
+      vec3 cloudColor = clouds(uv, u_time);
+      color = mix(color, color + cloudColor, 0.5);
+    }
+    
+    // Add stars (only visible when looking up and sun is low)
+    if (rayDir.y > 0.0 && mouse.y < 0.3) {
+      vec3 starColor = stars(uv);
+      color += starColor;
+    }
+    
+    // Add aurora (only when sun is very low)
+    if (mouse.y < 0.2 && rayDir.y > 0.2) {
+      vec3 auroraColor = aurora(uv, u_time);
+      color += auroraColor;
+    }
+    
+    // Tone mapping and gamma correction
+    color = color / (color + vec3(1.0));
+    color = pow(color, vec3(1.0 / 2.2));
+    
+    gl_FragColor = vec4(color, 1.0);
+  }
+`;
+// Create the shader material with uniforms
+const SkyMaterial = shaderMaterial({
+    u_time: 0,
+    u_resolution: new Vector2(800, 600),
+    u_pointer: new Vector2(0, 0),
+    iChannel0: null,
+    // Environment constants
+    R0: 6360e3, // planet radius
+    Ra: 6380e3, // atmosphere radius
+    I: 10.0, // sun light power
+    SI: 5.0, // sun intensity
+    g: 0.45, // light concentration
+    Hr: 8e3, // Rayleigh scattering top
+    Hm: 1.2e3, // Mie scattering top
+    // Scattering coefficients
+    bR: new Vector3(5.8e-6, 13.5e-6, 33.1e-6), // Rayleigh scattering (normal earth)
+    bM: new Vector3(21e-6, 21e-6, 21e-6), // Mie scattering
+    // Cloud parameters
+    cloudy: 0.5,
+    haze: 0.01,
+    rainmulti: 5.0,
+    cameraheight: 5e1,
+    mincloudheight: 5e3,
+    maxcloudheight: 8e3,
+    xaxiscloud: 0, // Will be set to t*5e2 in animation
+    yaxiscloud: 0.0,
+    zaxiscloud: 0, // Will be set to t*6e2 in animation
+    cloudnoise: 2e-4,
+    // Rendering parameters
+    steps: 16,
+    stepss: 16,
+    // Sun parameters
+    fov: Math.tan(Math.PI / 3), // 60 degrees
+    // Feature toggles
+    enableRain: 0,
+    simpleSun: 0,
+    nicehackSun: 1,
+    softSun: 1
+}, vertexShader, fragmentShader);
+// Extend the material for use in React Three Fiber
+extend({ SkyMaterial });
+export { SkyMaterial };