@3driseai/3drise-core 1.0.1

package/dist/shaders/MyGridMaterial.d.ts

@@ -0,0 +1,61 @@
+import * as THREE from 'three';
+export type MyGridLineMode = 0 | 1 | 2 | 3 | 4;
+export type MyGridCellMode = 0 | 1 | 2 | 3 | 4;
+export interface MyGridMaterialUniforms {
+    u_time: number;
+    u_cellSize: number;
+    u_lineWidth: number;
+    u_sectionSize: number;
+    u_sectionWidth: number;
+    u_lineColor: THREE.Color;
+    u_sectionColor: THREE.Color;
+    u_cellColor: THREE.Color;
+    u_glowColor: THREE.Color;
+    u_bgColor: THREE.Color;
+    u_bgOpacity: number;
+    u_lineMode: number;
+    u_cellMode: number;
+    u_animSpeed: number;
+    u_animScale: number;
+    u_animIntensity: number;
+    u_fadeDistance: number;
+    u_fadeStrength: number;
+    /** ripple/pulse origin in local grid coords */
+    u_focus: THREE.Vector2;
+    /** mouse in NDC (Vector2) — 3drize convention; host may map it into u_focus */
+    u_mouse: THREE.Vector2;
+    /** vertex displacement amount along the plane normal (needs a segmented plane) */
+    u_displace: number;
+}
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        myGridMaterial: ThreeElements['shaderMaterial'] & Partial<MyGridMaterialUniforms>;
+    }
+}
+export declare const myGridMaterialDefaults: MyGridMaterialUniforms;
+export declare const MyGridMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    u_time: number;
+    u_cellSize: number;
+    u_lineWidth: number;
+    u_sectionSize: number;
+    u_sectionWidth: number;
+    u_lineColor: THREE.Color;
+    u_sectionColor: THREE.Color;
+    u_cellColor: THREE.Color;
+    u_glowColor: THREE.Color;
+    u_bgColor: THREE.Color;
+    u_bgOpacity: number;
+    u_lineMode: number;
+    u_cellMode: number;
+    u_animSpeed: number;
+    u_animScale: number;
+    u_animIntensity: number;
+    u_fadeDistance: number;
+    u_fadeStrength: number;
+    u_focus: THREE.Vector2;
+    u_mouse: THREE.Vector2;
+    u_displace: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=MyGridMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MyGridMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/MyGridMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE/C,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE/C,MAAM,WAAW,sBAAsB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC;IACzB,cAAc,EAAE,KAAK,CAAC,KAAK,CAAC;IAC5B,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC;IACzB,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC;IACzB,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,+CAA+C;IAC/C,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC;IACvB,+EAA+E;IAC/E,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC;IACvB,kFAAkF;IAClF,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,cAAc,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;KACrF;CACJ;AAED,eAAO,MAAM,sBAAsB,EAAE,sBAsBpC,CAAC;AA+HF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;CAsBP,CAAC"}

package/dist/shaders/MyGridMaterial.js

@@ -0,0 +1,176 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '@react-three/drei';
+import { extend } from '@react-three/fiber';
+export const myGridMaterialDefaults = {
+    u_time: 0,
+    u_cellSize: 1.0,
+    u_lineWidth: 1.0,
+    u_sectionSize: 5.0,
+    u_sectionWidth: 1.6,
+    u_lineColor: new THREE.Color(0.28, 0.5, 0.72),
+    u_sectionColor: new THREE.Color(0.5, 0.78, 1.0),
+    u_cellColor: new THREE.Color(0.1, 0.35, 0.6),
+    u_glowColor: new THREE.Color(0.2, 0.62, 1.0),
+    u_bgColor: new THREE.Color(0.02, 0.03, 0.05),
+    u_bgOpacity: 0.0,
+    u_lineMode: 0,
+    u_cellMode: 0,
+    u_animSpeed: 1.0,
+    u_animScale: 0.5,
+    u_animIntensity: 1.0,
+    u_fadeDistance: 20.0,
+    u_fadeStrength: 0.65,
+    u_focus: new THREE.Vector2(0, 0),
+    u_mouse: new THREE.Vector2(0, 0),
+    u_displace: 0.0,
+};
+const vertex = /*glsl*/ `
+  uniform float u_time;
+  uniform float u_cellSize;
+  uniform float u_displace;
+  uniform float u_animSpeed;
+  uniform float u_animScale;
+
+  varying vec2 vGridPos;
+
+  float gridHeight(vec2 p){
+    float t = u_time * u_animSpeed;
+    float d = length(p) / max(u_cellSize, 1e-4);
+    return sin(d * u_animScale - t);
+  }
+
+  void main(){
+    vGridPos = position.xy;
+    vec3 pos = position;
+    if (u_displace > 0.0){
+      pos.z += gridHeight(position.xy) * u_displace;
+    }
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
+  }
+`;
+const fragment = /*glsl*/ `
+  precision highp float;
+
+  uniform float u_time;
+  uniform float u_cellSize;
+  uniform float u_lineWidth;
+  uniform float u_sectionSize;
+  uniform float u_sectionWidth;
+  uniform vec3  u_lineColor;
+  uniform vec3  u_sectionColor;
+  uniform vec3  u_cellColor;
+  uniform vec3  u_glowColor;
+  uniform vec3  u_bgColor;
+  uniform float u_bgOpacity;
+  uniform float u_lineMode;
+  uniform float u_cellMode;
+  uniform float u_animSpeed;
+  uniform float u_animScale;
+  uniform float u_animIntensity;
+  uniform float u_fadeDistance;
+  uniform float u_fadeStrength;
+  uniform vec2  u_focus;
+
+  varying vec2 vGridPos;
+
+  const float TAU = 6.28318530718;
+
+  float hash21(vec2 p){
+    p = fract(p * vec2(123.34, 456.21));
+    p += dot(p, p + 45.32);
+    return fract(p.x * p.y);
+  }
+
+  float gridLines(vec2 coord, float width){
+    vec2 d = fwidth(coord);
+    vec2 g = abs(fract(coord - 0.5) - 0.5) / max(d * width, 1e-5);
+    return 1.0 - clamp(min(g.x, g.y), 0.0, 1.0);
+  }
+
+  void main(){
+    vec2 coord = vGridPos / max(u_cellSize, 1e-4);
+    float t = u_time * u_animSpeed;
+
+    float minor = gridLines(coord, u_lineWidth);
+    float major = 0.0;
+    if (u_sectionWidth > 0.0 && u_sectionSize > 0.0){
+      major = gridLines(coord / u_sectionSize, u_sectionWidth);
+    }
+
+    float lineAnim = 1.0;
+    if (u_lineMode > 0.5 && u_lineMode < 1.5){
+      float dist = length(vGridPos - u_focus) / max(u_cellSize, 1e-4);
+      lineAnim = 0.5 + 0.5 * sin(dist * u_animScale - t);
+    } else if (u_lineMode < 2.5){
+      float fx = 0.5 + 0.5 * sin(coord.y * u_animScale - t);
+      float fy = 0.5 + 0.5 * sin(coord.x * u_animScale - t);
+      lineAnim = max(fx, fy);
+    } else if (u_lineMode < 3.5){
+      float s = fract((coord.x + coord.y) * 0.05 * u_animScale - t * 0.15);
+      lineAnim = 0.25 + smoothstep(0.0, 0.15, s) * (1.0 - smoothstep(0.15, 0.35, s));
+    } else if (u_lineMode < 4.5){
+      lineAnim = 0.5 + 0.5 * sin(t);
+    }
+    lineAnim = mix(1.0, lineAnim, u_animIntensity);
+
+    vec2 cellId = floor(coord);
+    float cell = 0.0;
+    if (u_cellMode > 0.5 && u_cellMode < 1.5){
+      cell = 0.5 + 0.5 * sin(dot(cellId, vec2(0.7, 0.3)) * u_animScale - t);
+    } else if (u_cellMode < 2.5){
+      float h = hash21(cellId);
+      cell = 0.5 + 0.5 * sin(t * (0.6 + h) + h * TAU);
+    } else if (u_cellMode < 3.5){
+      float d = length((cellId + 0.5) * u_cellSize - u_focus) / max(u_cellSize, 1e-4);
+      cell = smoothstep(0.6, 1.0, sin(d * u_animScale - t));
+    } else if (u_cellMode < 4.5){
+      cell = mod(cellId.x + cellId.y, 2.0) * (0.5 + 0.5 * sin(t));
+    }
+    cell *= u_animIntensity;
+    vec2 f = abs(fract(coord) - 0.5);
+    cell *= smoothstep(0.5, 0.35, max(f.x, f.y));
+
+    float r = length(vGridPos) / max(u_fadeDistance, 1e-4);
+    float fade = 1.0 - smoothstep(1.0 - u_fadeStrength, 1.0, r);
+
+    vec3 col = u_bgColor * u_bgOpacity;
+    float a  = u_bgOpacity;
+
+    col += u_cellColor * cell;            a = max(a, cell * 0.9);
+    float minorI = minor * lineAnim;
+    col += u_lineColor * minorI;          a = max(a, minorI);
+    float majorI = major * lineAnim;
+    col += u_sectionColor * majorI;       a = max(a, majorI);
+    col += u_glowColor * (minorI + cell) * 0.25 * u_animIntensity;
+
+    col *= fade;
+    a   *= fade;
+
+    if (a < 0.002) discard;
+    gl_FragColor = vec4(col, a);
+  }
+`;
+export const MyGridMaterial = shaderMaterial({
+    u_time: myGridMaterialDefaults.u_time,
+    u_cellSize: myGridMaterialDefaults.u_cellSize,
+    u_lineWidth: myGridMaterialDefaults.u_lineWidth,
+    u_sectionSize: myGridMaterialDefaults.u_sectionSize,
+    u_sectionWidth: myGridMaterialDefaults.u_sectionWidth,
+    u_lineColor: myGridMaterialDefaults.u_lineColor.clone(),
+    u_sectionColor: myGridMaterialDefaults.u_sectionColor.clone(),
+    u_cellColor: myGridMaterialDefaults.u_cellColor.clone(),
+    u_glowColor: myGridMaterialDefaults.u_glowColor.clone(),
+    u_bgColor: myGridMaterialDefaults.u_bgColor.clone(),
+    u_bgOpacity: myGridMaterialDefaults.u_bgOpacity,
+    u_lineMode: myGridMaterialDefaults.u_lineMode,
+    u_cellMode: myGridMaterialDefaults.u_cellMode,
+    u_animSpeed: myGridMaterialDefaults.u_animSpeed,
+    u_animScale: myGridMaterialDefaults.u_animScale,
+    u_animIntensity: myGridMaterialDefaults.u_animIntensity,
+    u_fadeDistance: myGridMaterialDefaults.u_fadeDistance,
+    u_fadeStrength: myGridMaterialDefaults.u_fadeStrength,
+    u_focus: myGridMaterialDefaults.u_focus.clone(),
+    u_mouse: myGridMaterialDefaults.u_mouse.clone(),
+    u_displace: myGridMaterialDefaults.u_displace,
+}, vertex, fragment);
+extend({ MyGridMaterial });

package/dist/shaders/MyParticlesMaterial.d.ts

@@ -0,0 +1,65 @@
+import { Vector3, Vector2, Color } from "three";
+export interface MyParticlesMaterialUniforms {
+    uColor: {
+        value: Color;
+    };
+    targetColor: {
+        value: Color;
+    };
+    targetPoint: {
+        value: Vector3;
+    };
+    pointer: {
+        value: Vector2;
+    };
+    pointSize: {
+        value: number;
+    };
+    minX: {
+        value: number;
+    };
+    maxX: {
+        value: number;
+    };
+    minY: {
+        value: number;
+    };
+    maxY: {
+        value: number;
+    };
+    minZ: {
+        value: number;
+    };
+    maxZ: {
+        value: number;
+    };
+    time: {
+        value: number;
+    };
+    f: {
+        value: number;
+    };
+    a: {
+        value: number;
+    };
+}
+declare const MyParticlesMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    uColor: Color;
+    targetColor: Color;
+    targetPoint: Vector3;
+    pointer: Vector2;
+    pointSize: number;
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+    minZ: number;
+    maxZ: number;
+    time: number;
+    f: number;
+    a: number;
+}> & {
+    key: string;
+};
+export { MyParticlesMaterial };
+//# sourceMappingURL=MyParticlesMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MyParticlesMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/MyParticlesMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAGhD,MAAM,WAAW,2BAA2B;IACxC,MAAM,EAAE;QACJ,KAAK,EAAE,KAAK,CAAC;KAChB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,KAAK,CAAC;KAChB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,OAAO,EAAE;QACL,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,IAAI,EAAE;QACF,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,IAAI,EAAE;QACF,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,IAAI,EAAE;QACF,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,IAAI,EAAE;QACF,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,IAAI,EAAE;QACF,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,IAAI,EAAE;QACF,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,IAAI,EAAE;QACF,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,CAAC,EAAE;QACC,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,CAAC,EAAE;QACC,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AA0GD,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;CAeO,CAAC;AAGjC,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/shaders/MyParticlesMaterial.js

@@ -0,0 +1,126 @@
+import { Vector3, Vector2, Color } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+// Vertex shader
+// Tutorial: https://www.youtube.com/watch?v=f4s1h2YETNY
+const vertexShader = /*glsl*/ ` 
+  varying vec2 vUv;
+  uniform float time;
+  varying float vProgress;
+  varying vec3 vPosition;
+  attribute vec3 targetPoint;
+  uniform float animationProgress;
+  uniform float pointSize;
+  uniform float maxX;
+  uniform float maxZ;
+  uniform float maxY;
+  uniform float minX;
+  uniform float minZ;
+  uniform float minY;
+  uniform vec3 pointer;
+  uniform float f;
+  uniform float a;
+
+  float graph(float x, float z, float factor) {
+    return sin(f * (pow(x, 2.0) + pow(z, 2.0) + time)) * a * factor;
+  }
+  
+  float rand(vec2 co) {
+      return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+  }
+  
+  void main() {
+    vUv = uv;   
+    vPosition = position;
+    bool isInXRange = (vPosition.x >= minX && vPosition.x <= maxX);
+    float centerX = (maxX + minX) * 0.5;
+    vec3 displacedPosition;
+    
+    if (time == 0.0) {
+      displacedPosition = vPosition;
+    } else if (time == 1.0) {
+      displacedPosition = targetPoint;
+    } else if (time < 1.0 && time > 0.0) {
+      displacedPosition = mix(vPosition, targetPoint, time);
+    }
+    
+    float targetY = vPosition.y;
+    float distanceFromCenterX = abs(centerX - vPosition.x);
+    
+    if (isInXRange) {
+      targetY = (maxX - centerX - distanceFromCenterX) * 0.2;
+      // float factor = ((maxX - minX) - distanceFromCenterX) * 0.1;
+      displacedPosition = vec3(vPosition.x, targetY, vPosition.z);
+    } 
+    
+    gl_PointSize = pointSize;
+    // gl_PointSize = pointSize + abs(displacedPosition.x * 3.);
+    // if (vPosition.x > centerX - 0.01 && vPosition.x < centerX + 0.01) {
+    //   gl_PointSize = pointSize * 10.;
+    // }
+    gl_PointSize = rand(vPosition.xy) * 3.;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(displacedPosition, 1.0);
+  }
+`;
+// Fragment shader
+const fragmentShader = /*glsl*/ `
+  uniform float time;
+  varying float vProgress;
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  uniform vec3 uColor;
+  uniform vec3 targetColor;
+  uniform vec3 pointer;
+  uniform float maxX;
+  uniform float maxZ;
+  uniform float maxY;
+  uniform float minX;
+  uniform float minZ;
+  uniform float minY;
+
+  float rand(vec2 co) {
+      return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+  }
+  
+  void main() {
+    float disc = length(gl_PointCoord.xy - vec2(0.5));
+    float opacity = 0.8 * smoothstep(0.5, 0.4, disc);
+    // vec3 finalColor = uColor;
+    // vec3 finalColor = vec3(uColor.x * abs(vPosition.z), uColor.y, uColor.z);
+    vec3 finalColor = mix(uColor, uColor * 0.5, vProgress);
+    
+    if (abs(vPosition.z) >= minZ && abs(vPosition.z) <= maxZ ||
+     vPosition.x >= minX && vPosition.x <= maxX) {
+      finalColor = mix(uColor, targetColor, abs(vPosition.x));
+    }
+    
+    // opacity = rand(gl_FragCoord.xy);
+    gl_FragColor.rgba = vec4(vec3(finalColor), 1.);
+    gl_FragColor.rgba = vec4(
+      finalColor.x + (pointer.x * 1.), 
+      finalColor.y, 
+      finalColor.z + (pointer.y * 1.), 
+      opacity 
+    );
+  }
+`;
+// Create the shader material with uniforms
+const MyParticlesMaterial = shaderMaterial({
+    uColor: new Color(0.1, 0.5, 0.6),
+    targetColor: new Color(1., 0.5, 0.6),
+    targetPoint: new Vector3(0, 1, 1),
+    pointer: new Vector2(),
+    pointSize: 1.0,
+    minX: 0,
+    maxX: 0,
+    minY: 0,
+    maxY: 0,
+    minZ: 0,
+    maxZ: 0,
+    time: 0.0,
+    f: 0.001,
+    a: 0.01,
+}, vertexShader, fragmentShader);
+// Extend the material for use in React Three Fiber
+extend({ MyParticlesMaterial });
+export { MyParticlesMaterial };

package/dist/shaders/NebulaCloudsMaterial.d.ts

@@ -0,0 +1,44 @@
+import { Vector2, Vector3 } from "three";
+export interface NebulaCloudsUniforms {
+    u_time: {
+        value: number;
+    };
+    u_resolution: {
+        value: Vector2;
+    };
+    u_cameraPos: {
+        value: Vector3;
+    };
+    u_cloudColor: {
+        value: Vector3;
+    };
+    u_color1: {
+        value: Vector3;
+    };
+    u_color2: {
+        value: Vector3;
+    };
+    u_color3: {
+        value: Vector3;
+    };
+    u_glowIntensity: {
+        value: number;
+    };
+    u_complexity: {
+        value: number;
+    };
+}
+export declare const NebulaCloudsMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_resolution: Vector2;
+    u_cameraPos: Vector3;
+    u_cloudColor: Vector3;
+    u_color1: Vector3;
+    u_color2: Vector3;
+    u_color3: Vector3;
+    u_glowIntensity: number;
+    u_complexity: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=NebulaCloudsMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NebulaCloudsMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/NebulaCloudsMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAIzC,MAAM,WAAW,oBAAoB;IACjC,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,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,eAAe,EAAE;QACb,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAiDD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;CAUW,CAAC"}

package/dist/shaders/NebulaCloudsMaterial.js

@@ -0,0 +1,63 @@
+import { Vector2, Vector3 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+import { commonNoiseFunctions } from "./CommonNoiseFunctions.js";
+const nebulaCloudsVertex = /*glsl*/ `
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  
+  void main() {
+    vUv = uv;
+    vPosition = position;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const nebulaCloudsFragment = /*glsl*/ `
+  uniform float u_time;
+  uniform vec2 u_resolution;
+  uniform vec3 u_cameraPos;
+  uniform vec3 u_cloudColor;
+  uniform vec3 u_color1;
+  uniform vec3 u_color2;
+  uniform vec3 u_color3;
+  uniform float u_glowIntensity;
+  uniform float u_complexity;
+  
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  
+  ${commonNoiseFunctions}
+  
+  void main() {
+    vec3 spherePos = normalize(vPosition);
+    
+    // Multi-layered nebula effect
+    float nebula1 = fbm(spherePos * u_complexity + vec3(u_time * 0.1));
+    float nebula2 = fbm(spherePos * u_complexity * 0.5 + vec3(u_time * 0.05, u_time * 0.08, 0.0));
+    float nebula3 = fbm(spherePos * u_complexity * 2.0 + vec3(0.0, u_time * 0.03, u_time * 0.07));
+    
+    // Color mixing based on noise layers
+    vec3 color = u_color1 * nebula1;
+    color += u_color2 * nebula2 * 0.7;
+    color += u_color3 * nebula3 * 0.5;
+    
+    // Add glow effect
+    color *= u_glowIntensity;
+    
+    float alpha = (nebula1 + nebula2 * 0.7 + nebula3 * 0.5) / 2.2;
+    
+    gl_FragColor = vec4(color, alpha);
+  }
+`;
+export const NebulaCloudsMaterial = shaderMaterial({
+    u_time: 0,
+    u_resolution: new Vector2(800, 600),
+    u_cameraPos: new Vector3(0, 0, 0),
+    u_cloudColor: new Vector3(0.6, 0.3, 0.8),
+    u_color1: new Vector3(0.8, 0.2, 0.9),
+    u_color2: new Vector3(0.2, 0.6, 1.0),
+    u_color3: new Vector3(1.0, 0.4, 0.2),
+    u_glowIntensity: 1.5,
+    u_complexity: 3.0
+}, nebulaCloudsVertex, nebulaCloudsFragment);
+extend({ NebulaCloudsMaterial });