@3driseai/3drise-core 1.0.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"BubblesPointsMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/BubblesPointsMaterial.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,MAAM,WAAW,6BAA6B;IAC1C,KAAK,EAAE;QACH,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,OAAO,EAAE;QACL,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;KACtB,CAAC;IACF,OAAO,EAAE;QACL,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;KACtB,CAAC;IACF,OAAO,EAAE;QACL,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;KACtB,CAAC;IACF,QAAQ,EAAE;QACN,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,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAED,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,GAAG,CAAC;QACV,UAAU,iBAAiB;YACvB,qBAAqB,EAAE,GAAG,CAAC;SAC9B;KACJ;CACJ;AAiFD,QAAA,MAAM,qBAAqB;;;;;;;;;;;;CAUK,CAAC;AAEjC,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/shaders/BubblesPointsMaterial.js

@@ -0,0 +1,95 @@
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+import * as THREE from "three";
+const vertexShader = /* glsl */ `
+  attribute float aAge;
+  attribute float aLife;
+  attribute float aBaseSize;
+  attribute float aPhase;
+  uniform float uTime;
+  uniform float uScale;
+  uniform float uPopWindow;
+  uniform float uSpeed;
+  varying float vAgeN;
+  varying float vPopN;
+  varying float vPhase;
+  void main() {
+    vAgeN = clamp(aAge / max(aLife, 1.0), 0.0, 1.0);
+    float popStart = 1.0 - uPopWindow;
+    vPopN = (vAgeN > popStart) ? (vAgeN - popStart) / uPopWindow : 0.0;
+    vPhase = aPhase;
+    vec4 mv = modelViewMatrix * vec4(position, 1.0);
+    float wobble = 1.0 + sin(uTime * uSpeed * 2.0 + aPhase) * 0.06;
+    float popBurst = 1.0 + vPopN * 1.5;
+    float size = aBaseSize * wobble * popBurst * uScale;
+    gl_PointSize = size * (300.0 / -mv.z);
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform vec3  uColorA;
+  uniform vec3  uColorB;
+  uniform vec3  uColorC;
+  uniform float uOpacity;
+  uniform float uIridescence;
+  uniform float uTime;
+  uniform float uSpeed;
+  varying float vAgeN;
+  varying float vPopN;
+  varying float vPhase;
+
+  // Cycle three colors smoothly as t advances. t wraps to [0,1).
+  vec3 cycleColors(float t) {
+    t = fract(t);
+    float s = t * 3.0;
+    if (s < 1.0) return mix(uColorA, uColorB, s);
+    if (s < 2.0) return mix(uColorB, uColorC, s - 1.0);
+    return mix(uColorC, uColorA, s - 2.0);
+  }
+
+  vec3 thinFilm(float fresnel, float phase) {
+    float t = fresnel + phase * 0.15 + uTime * uSpeed * 0.05;
+    return cycleColors(t);
+  }
+
+  void main() {
+    vec2 c = gl_PointCoord * 2.0 - 1.0;
+    float r = length(c);
+    if (r > 1.0) discard;
+
+    float z = sqrt(max(0.0, 1.0 - r * r));
+    vec3 n = vec3(c.x, c.y, z);
+    vec3 viewDir = vec3(0.0, 0.0, 1.0);
+    float fresnel = pow(1.0 - max(dot(n, viewDir), 0.0), 2.5);
+
+    vec3 film = thinFilm(fresnel, vPhase);
+    // Base color is the average of the three palette colors so iridescence=0
+    // still picks a sensible neutral.
+    vec3 baseColor = (uColorA + uColorB + uColorC) / 3.0;
+    vec3 col = mix(baseColor, film, uIridescence);
+
+    float spec = pow(max(dot(n, normalize(vec3(-0.4, 0.6, 0.7))), 0.0), 32.0);
+
+    float popFlash = vPopN * (1.0 - vPopN) * 4.0;
+
+    float lifeFade = 1.0 - smoothstep(0.85, 1.0, vAgeN) * (vPopN > 0.0 ? 0.0 : 1.0);
+    float baseAlpha = (fresnel * 0.85 + spec * 0.5 + popFlash * 0.6);
+    float alpha = baseAlpha * uOpacity * lifeFade;
+    if (alpha < 0.004) discard;
+
+    gl_FragColor = vec4(col * (1.0 + spec + popFlash), alpha);
+  }
+`;
+const BubblesPointsMaterial = shaderMaterial({
+    uTime: 0,
+    uScale: 0.1,
+    uColorA: new THREE.Color('#aaccff'),
+    uColorB: new THREE.Color('#ffaadd'),
+    uColorC: new THREE.Color('#aaffcc'),
+    uOpacity: 0.6,
+    uIridescence: 0.7,
+    uPopWindow: 0.18,
+    uSpeed: 1.0,
+}, vertexShader, fragmentShader);
+extend({ BubblesPointsMaterial });
+export { BubblesPointsMaterial };

package/dist/shaders/CartoonCloudsMaterial.d.ts

@@ -0,0 +1,36 @@
+import { Vector2, Vector3 } from "three";
+export interface CartoonCloudsUniforms {
+    u_time: {
+        value: number;
+    };
+    u_resolution: {
+        value: Vector2;
+    };
+    u_cameraPos: {
+        value: Vector3;
+    };
+    u_cloudColor: {
+        value: Vector3;
+    };
+    u_rimColor: {
+        value: Vector3;
+    };
+    u_puffiness: {
+        value: number;
+    };
+    u_softness: {
+        value: number;
+    };
+}
+export declare const CartoonCloudsMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_resolution: Vector2;
+    u_cameraPos: Vector3;
+    u_cloudColor: Vector3;
+    u_rimColor: Vector3;
+    u_puffiness: number;
+    u_softness: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=CartoonCloudsMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CartoonCloudsMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/CartoonCloudsMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAIzC,MAAM,WAAW,qBAAqB;IAClC,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,UAAU,EAAE;QACR,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AA+CD,eAAO,MAAM,qBAAqB;;;;;;;;;;CAQY,CAAC"}

package/dist/shaders/CartoonCloudsMaterial.js

@@ -0,0 +1,59 @@
+import { Vector2, Vector3 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+import { commonNoiseFunctions } from "./CommonNoiseFunctions.js";
+const cartoonCloudsVertex = /*glsl*/ `
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  
+  void main() {
+    vUv = uv;
+    vPosition = position;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const cartoonCloudsFragment = /*glsl*/ `
+  uniform float u_time;
+  uniform vec2 u_resolution;
+  uniform vec3 u_cameraPos;
+  uniform vec3 u_cloudColor;
+  uniform vec3 u_rimColor;
+  uniform float u_puffiness;
+  uniform float u_softness;
+
+  
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  
+  ${commonNoiseFunctions}
+  
+  void main() {
+    vec2 uv = vUv;
+    vec3 spherePos = normalize(vPosition);
+    
+    // Create puffy cloud shapes
+    float cloud = fbm(spherePos * 3.0 + vec3(u_time, 0.0, u_time * 0.5));
+    cloud = smoothstep(0.3, 0.7, cloud + u_puffiness);
+    
+    // Add rim lighting effect
+    float rim = 1.0 - dot(spherePos, vec3(0.0, 0.0, 1.0));
+    rim = pow(rim, 2.0);
+    
+    // Soft edges
+    cloud = smoothstep(0.0, u_softness, cloud);
+    
+    vec3 color = mix(u_cloudColor, u_rimColor, rim * 0.5);
+    
+    gl_FragColor = vec4(color, cloud);
+  }
+`;
+export const CartoonCloudsMaterial = shaderMaterial({
+    u_time: 0,
+    u_resolution: new Vector2(800, 600),
+    u_cameraPos: new Vector3(0, 0, 0),
+    u_cloudColor: new Vector3(0.95, 0.95, 1.0),
+    u_rimColor: new Vector3(1.0, 0.9, 0.7),
+    u_puffiness: 0.2,
+    u_softness: 0.3,
+}, cartoonCloudsVertex, cartoonCloudsFragment);
+extend({ CartoonCloudsMaterial });

package/dist/shaders/CartoonCloudsPointsMaterial.d.ts

@@ -0,0 +1,65 @@
+import { Vector3, Vector2, Color } from "three";
+export interface CartoonCloudsPointsMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_cloudColor: {
+        value: Vector3;
+    };
+    u_edgeThickness: {
+        value: number;
+    };
+    u_pointer: {
+        value: Vector2;
+    };
+    uPointSize: {
+        value: number;
+    };
+    uColor: {
+        value: Color;
+    };
+    uOpacity: {
+        value: number;
+    };
+}
+export declare const CartoonCloudsPointsMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_cloudColor: Vector3;
+    u_edgeThickness: 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=CartoonCloudsPointsMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CartoonCloudsPointsMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/CartoonCloudsPointsMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAKhD,MAAM,WAAW,mCAAmC;IAChD,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,eAAe,EAAE;QACb,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;AAgGD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCR,CAAC"}

package/dist/shaders/CartoonCloudsPointsMaterial.js

@@ -0,0 +1,138 @@
+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_cloudColor;
+uniform float u_edgeThickness;
+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 cloud = fbm(spherePos * 3.0 + vec3(u_time * 0.1));
+  float stepped = floor(cloud * 3.0) / 3.0;
+  
+  gl_FragColor = vec4(u_cloudColor * uColor, stepped * uOpacity * circle(gl_PointCoord, 0.2));
+}
+`;
+export const CartoonCloudsPointsMaterial = shaderMaterial({
+    u_time: 0,
+    u_cloudColor: new Vector3(1.0, 1.0, 1.0),
+    u_edgeThickness: 0.1,
+    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({ CartoonCloudsPointsMaterial });

package/dist/shaders/CirrusCloudsMaterial.d.ts

@@ -0,0 +1,36 @@
+import { Vector2, Vector3 } from "three";
+export interface CirrusCloudsUniforms {
+    u_time: {
+        value: number;
+    };
+    u_resolution: {
+        value: Vector2;
+    };
+    u_cameraPos: {
+        value: Vector3;
+    };
+    u_cloudColor: {
+        value: Vector3;
+    };
+    u_windSpeed: {
+        value: number;
+    };
+    u_transparency: {
+        value: number;
+    };
+    u_streakiness: {
+        value: number;
+    };
+}
+export declare const CirrusCloudsMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_resolution: Vector2;
+    u_cameraPos: Vector3;
+    u_cloudColor: Vector3;
+    u_windSpeed: number;
+    u_transparency: number;
+    u_streakiness: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=CirrusCloudsMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CirrusCloudsMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/CirrusCloudsMaterial.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,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,aAAa,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AA2CD,eAAO,MAAM,oBAAoB;;;;;;;;;;CAQW,CAAC"}

package/dist/shaders/CirrusCloudsMaterial.js

@@ -0,0 +1,55 @@
+import { Vector2, Vector3 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+import { commonNoiseFunctions } from "./CommonNoiseFunctions.js";
+const cirrusCloudsVertex = /*glsl*/ `
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  
+  void main() {
+    vUv = uv;
+    vPosition = position;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const cirrusCloudsFragment = /*glsl*/ `
+  uniform float u_time;
+  uniform vec2 u_resolution;
+  uniform vec3 u_cameraPos;
+  uniform vec3 u_cloudColor;
+  uniform float u_windSpeed;
+  uniform float u_transparency;
+  uniform float u_streakiness;
+  
+  varying vec2 vUv;
+  varying vec3 vPosition;
+  
+  ${commonNoiseFunctions}
+  
+  void main() {
+    vec3 spherePos = normalize(vPosition);
+    
+    // Create streaky, wispy patterns
+    vec3 windOffset = vec3(u_time * u_windSpeed, 0.0, u_time * u_windSpeed * 0.3);
+    float cirrus = noise(spherePos * 4.0 + windOffset);
+    
+    // Add streakiness
+    float streaks = noise(vec3(spherePos.x * u_streakiness, spherePos.y * 2.0, spherePos.z) + windOffset);
+    cirrus *= streaks;
+    
+    // Very thin, transparent clouds
+    float alpha = smoothstep(0.3, 0.7, cirrus) * u_transparency;
+    
+    gl_FragColor = vec4(u_cloudColor, alpha);
+  }
+`;
+export const CirrusCloudsMaterial = shaderMaterial({
+    u_time: 0,
+    u_resolution: new Vector2(800, 600),
+    u_cameraPos: new Vector3(0, 0, 0),
+    u_cloudColor: new Vector3(1.0, 1.0, 1.0),
+    u_windSpeed: 0.05,
+    u_transparency: 0.4,
+    u_streakiness: 8.0,
+}, cirrusCloudsVertex, cirrusCloudsFragment);
+extend({ CirrusCloudsMaterial });

package/dist/shaders/CirrusCloudsPointsMaterial.d.ts

@@ -0,0 +1,69 @@
+import { Vector3, Vector2, Color } from "three";
+export interface CirrusCloudsPointsMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_windSpeed: {
+        value: number;
+    };
+    u_wispy: {
+        value: number;
+    };
+    u_cloudColor: {
+        value: Vector3;
+    };
+    u_pointer: {
+        value: Vector2;
+    };
+    uPointSize: {
+        value: number;
+    };
+    uColor: {
+        value: Color;
+    };
+    uOpacity: {
+        value: number;
+    };
+}
+export declare const CirrusCloudsPointsMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_windSpeed: number;
+    u_wispy: number;
+    u_cloudColor: Vector3;
+    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=CirrusCloudsPointsMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CirrusCloudsPointsMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/CirrusCloudsPointsMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAKhD,MAAM,WAAW,kCAAkC;IAC/C,MAAM,EAAE;QACJ,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;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,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,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCP,CAAC"}