@3driseai/3drise-core 1.0.1

package/dist/shaders/SkyboxMaterial.d.ts

@@ -0,0 +1,40 @@
+import { Color } from "three";
+export interface SkyboxMaterialUniforms {
+    uSunAzimuth: {
+        value: number;
+    };
+    uSunElevation: {
+        value: number;
+    };
+    uSunColor: {
+        value: Color;
+    };
+    uSkyColorLow: {
+        value: Color;
+    };
+    uSkyColorHigh: {
+        value: Color;
+    };
+    uSunSize: {
+        value: number;
+    };
+}
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            skyboxMaterial: any;
+        }
+    }
+}
+declare const SkyboxMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    uSunAzimuth: number;
+    uSunElevation: number;
+    uSunColor: Color;
+    uSkyColorLow: Color;
+    uSkyColorHigh: Color;
+    uSunSize: number;
+}> & {
+    key: string;
+};
+export { SkyboxMaterial };
+//# sourceMappingURL=SkyboxMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SkyboxMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/SkyboxMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAG9B,MAAM,WAAW,sBAAsB;IACnC,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,aAAa,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,KAAK,CAAC;KAChB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,KAAK,CAAC;KAChB,CAAC;IACF,aAAa,EAAE;QACX,KAAK,EAAE,KAAK,CAAC;KAChB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAED,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,GAAG,CAAC;QACV,UAAU,iBAAiB;YACvB,cAAc,EAAE,GAAG,CAAC;SACvB;KACJ;CACJ;AAoDD,QAAA,MAAM,cAAc;;;;;;;;;CAOY,CAAC;AAGjC,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/shaders/SkyboxMaterial.js

@@ -0,0 +1,64 @@
+import { Color } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+// Vertex shader
+const vertexShader = /*glsl*/ `
+  varying vec3 vWorldPosition;
+  varying vec3 vDirection;
+
+  void main() {
+    vec4 worldPosition = modelMatrix * vec4(position, 1.0);
+    vWorldPosition = worldPosition.xyz;
+    vDirection = normalize(worldPosition.xyz);
+
+    vec4 pos = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+    gl_Position = pos.xyww;
+  }
+`;
+// Fragment shader
+const fragmentShader = /*glsl*/ `
+  precision mediump float;
+  varying vec3 vWorldPosition;
+  varying vec3 vDirection;
+
+  uniform float uSunAzimuth;
+  uniform float uSunElevation;
+  uniform vec3 uSunColor;
+  uniform vec3 uSkyColorLow;
+  uniform vec3 uSkyColorHigh;
+  uniform float uSunSize;
+
+  void main() {
+    vec3 direction = normalize(vWorldPosition);
+
+    // Sky gradient from horizon to zenith
+    vec3 skyColor = mix(uSkyColorLow, uSkyColorHigh, clamp(direction.y * 0.5 + 0.5, 0.0, 1.0));
+
+    // Calculate sun direction from azimuth and elevation
+    float azimuth = radians(uSunAzimuth);
+    float elevation = radians(uSunElevation);
+    vec3 sunDirection = normalize(vec3(
+      cos(elevation) * sin(azimuth),
+      sin(elevation),
+      cos(elevation) * cos(azimuth)
+    ));
+
+    // Sun disc with intensity falloff
+    float sunIntensity = pow(max(dot(direction, sunDirection), 0.0), 1000.0 / uSunSize);
+    vec3 sunColor = uSunColor * sunIntensity;
+
+    gl_FragColor = vec4(skyColor + sunColor, 1.0);
+  }
+`;
+// Create the shader material with uniforms
+const SkyboxMaterial = shaderMaterial({
+    uSunAzimuth: 216,
+    uSunElevation: 24.68698059628387,
+    uSunColor: new Color(0xffe5b0),
+    uSkyColorLow: new Color(0x6fa2ef),
+    uSkyColorHigh: new Color(0x2053ff),
+    uSunSize: 1
+}, vertexShader, fragmentShader);
+// Extend the material for use in React Three Fiber
+extend({ SkyboxMaterial });
+export { SkyboxMaterial };

package/dist/shaders/SmokeMaterial.d.ts

@@ -0,0 +1,48 @@
+import * as THREE from 'three';
+export interface SmokeUniforms {
+    u_time: number;
+    u_colorDark: THREE.Color;
+    u_colorLight: THREE.Color;
+    u_lightColor: THREE.Color;
+    u_lightDir: THREE.Vector3;
+    u_speed: number;
+    u_turbulence: number;
+    u_transition: number;
+    u_density: number;
+    u_dissipation: number;
+    u_spread: number;
+    u_sway: number;
+    u_windDir: THREE.Vector2;
+    u_radius: number;
+    u_height: number;
+    u_mouse: THREE.Vector3;
+    u_mouseStrength: number;
+}
+export type SmokeMaterialImpl = THREE.ShaderMaterial & SmokeUniforms;
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        smokeMaterial: ThreeElements['shaderMaterial'] & Partial<SmokeUniforms>;
+    }
+}
+export declare const SmokeMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    u_colorDark: THREE.Color;
+    u_colorLight: THREE.Color;
+    u_lightColor: THREE.Color;
+    u_lightDir: THREE.Vector3;
+    u_windDir: THREE.Vector2;
+    u_mouse: THREE.Vector3;
+    u_time: number;
+    u_speed: number;
+    u_turbulence: number;
+    u_transition: number;
+    u_density: number;
+    u_dissipation: number;
+    u_spread: number;
+    u_sway: number;
+    u_radius: number;
+    u_height: number;
+    u_mouseStrength: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=SmokeMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SmokeMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/SmokeMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,MAAM,WAAW,aAAa;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC;IACzB,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC;IAC1B,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC;IAC1B,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,MAAM,iBAAiB,GAAG,KAAK,CAAC,cAAc,GAAG,aAAa,CAAC;AAErE,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,aAAa,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;KAC3E;CACJ;AA2ID,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;CAiBxB,CAAC"}

package/dist/shaders/SmokeMaterial.js

@@ -0,0 +1,159 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '@react-three/drei';
+import { extend } from '@react-three/fiber';
+const defaults = {
+    u_time: 0,
+    u_colorDark: new THREE.Color(0.06, 0.06, 0.07),
+    u_colorLight: new THREE.Color(0.58, 0.58, 0.62),
+    u_lightColor: new THREE.Color(1.0, 0.95, 0.85),
+    u_lightDir: new THREE.Vector3(-0.6, 0.7, 0.0),
+    u_speed: 0.35,
+    u_turbulence: 1.6,
+    u_transition: 0.32,
+    u_density: 1.0,
+    u_dissipation: 0.45,
+    u_spread: 0.9,
+    u_sway: 0.5,
+    u_windDir: new THREE.Vector2(0.3, 0.0),
+    u_radius: 1.0,
+    u_height: 3.0,
+    u_mouse: new THREE.Vector3(0, -1000, 0),
+    u_mouseStrength: 0.0,
+};
+const vertexShader = /*glsl*/ `
+  uniform float u_radius;
+  uniform float u_height;
+
+  varying vec2 vUv;
+
+  void main() {
+    // x in [-1,1], y in [0,1] — smoke-space, geometry-size independent.
+    vUv = vec2(uv.x * 2.0 - 1.0, uv.y);
+
+    // Cylindrical world-space billboard around the mesh origin, rising on +Y.
+    vec3 center   = (modelMatrix * vec4(0.0, 0.0, 0.0, 1.0)).xyz;
+    vec3 camRight = vec3(viewMatrix[0][0], viewMatrix[1][0], viewMatrix[2][0]);
+    vec3 right    = normalize(vec3(camRight.x, 0.0, camRight.z) + vec3(1e-5));
+
+    vec3 world = center
+      + right * vUv.x * u_radius
+      + vec3(0.0, 1.0, 0.0) * vUv.y * u_height;
+
+    gl_Position = projectionMatrix * viewMatrix * vec4(world, 1.0);
+  }
+`;
+const fragmentShader = /*glsl*/ `
+  precision highp float;
+
+  uniform float u_time;
+  uniform vec3  u_colorDark;
+  uniform vec3  u_colorLight;
+  uniform vec3  u_lightColor;
+  uniform vec3  u_lightDir;
+  uniform float u_speed;
+  uniform float u_turbulence;
+  uniform float u_transition;
+  uniform float u_density;
+  uniform float u_dissipation;
+  uniform float u_spread;
+  uniform float u_sway;
+  uniform vec2  u_windDir;
+  uniform vec3  u_mouse;
+  uniform float u_mouseStrength;
+
+  varying vec2 vUv;
+
+  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 vnoise(vec2 p){
+    vec2 i = floor(p), f = fract(p);
+    vec2 u = f * f * (3.0 - 2.0 * f);
+    return mix(mix(hash21(i),                hash21(i+vec2(1,0)), u.x),
+               mix(hash21(i+vec2(0,1)),      hash21(i+vec2(1,1)), u.x), u.y);
+  }
+  const mat2 ROT = mat2(0.8, 0.6, -0.6, 0.8);
+  float fbm(vec2 p){ float s=0.0, a=0.5; for(int i=0;i<5;i++){ s+=a*vnoise(p); p=ROT*p*2.03+vec2(1.7); a*=0.5; } return s; }
+
+  // Density of the smoke column at a smoke-space point. Real smoke rises as a
+  // coherent LAMINAR thread near the source, then crosses a transition height
+  // (u_transition) where it rolls up into TURBULENT vortices — modelled with
+  // curl noise (a divergence-free swirl field) whose strength ramps in with
+  // height — widening and breaking into puffs before it dissipates.
+  float smokeField(vec2 uv){
+    float y = clamp(uv.y, 0.0, 1.0);
+    float gust = clamp(u_mouseStrength, 0.0, 1.0);
+
+    // laminar below the transition, turbulent above; the cursor breaks it sooner
+    float turbRamp = smoothstep(u_transition, min(u_transition + 0.4, 1.0), y);
+    turbRamp = clamp(turbRamp + gust * 0.4, 0.0, 1.0);
+
+    // thin & coherent at the base, billows out only once it goes turbulent
+    float w = 0.16 + u_spread * (0.12 * y + 0.88 * turbRamp * y);
+
+    // coherent sway (wind + cursor lean) plus a laminar wobble that amplifies
+    float lateral = u_windDir.x + u_mouse.x * gust * 1.5;
+    float meander = sin(y * 6.0 - u_time * u_speed * 1.2) * 0.05 * turbRamp;
+    float x = uv.x + lateral * pow(y, 1.4) * u_sway + meander;
+    float lx = x / w;
+
+    // rising sampling coords; detail enlarges & slows higher up (buoyant)
+    float freq = mix(3.4, 1.5, y);
+    vec2 p = vec2(lx * freq, y * freq * 1.2 - u_time * u_speed);
+
+    // curl noise: stream function psi -> perpendicular gradient = a swirling,
+    // roughly divergence-free flow. Displace the sample by it to roll up vortices.
+    float e = 0.15;
+    float psi0 = fbm(p);
+    float psiX = fbm(p + vec2(e, 0.0));
+    float psiY = fbm(p + vec2(0.0, e));
+    vec2 curl = vec2(psiY - psi0, -(psiX - psi0)) / e;
+    vec2 ps = p + curl * (u_turbulence * turbRamp) * 0.35;
+
+    // density from the swirled field, with a light secondary warp for richness
+    float q = fbm(ps);
+    vec2 r = vec2(fbm(ps + q + vec2(2.1, 5.7)), fbm(ps + q + vec2(7.4, 1.3)));
+    float n = fbm(ps + (0.4 + 0.7 * turbRamp) * r);
+
+    float lat  = 1.0 - smoothstep(0.5, 1.05, abs(lx));         // soft round column
+    float base = smoothstep(0.0, 0.10, y);                     // emerge at the source
+    float top  = 1.0 - smoothstep(1.0 - u_dissipation, 1.0, y);// dissolve into air
+
+    float dens = n * lat * base * top;
+    dens *= mix(0.9, 1.18, turbRamp);   // turbulent region reads as discrete billows
+    return clamp(dens, 0.0, 1.0);
+  }
+
+  void main() {
+    float d = smokeField(vUv);
+    if (d <= 0.002) discard;
+
+    // Soft self-shadow: compare density toward the light. Denser ahead = occluded.
+    vec2 lo = normalize(u_lightDir.xy + vec2(1e-4)) * 0.06;
+    float dL = smokeField(vUv + lo);
+    float shadow = clamp((dL - d) * 3.0, 0.0, 1.0);
+
+    vec3 lit = u_colorLight * u_lightColor;
+    vec3 col = mix(lit, u_colorDark, shadow);
+
+    float alpha = clamp(d * u_density, 0.0, 1.0);
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+export const SmokeMaterial = shaderMaterial({
+    ...defaults,
+    u_colorDark: defaults.u_colorDark.clone(),
+    u_colorLight: defaults.u_colorLight.clone(),
+    u_lightColor: defaults.u_lightColor.clone(),
+    u_lightDir: defaults.u_lightDir.clone(),
+    u_windDir: defaults.u_windDir.clone(),
+    u_mouse: defaults.u_mouse.clone(),
+}, vertexShader, fragmentShader, (m) => {
+    if (!m)
+        return;
+    // Absorptive translucent smoke: normal alpha blend, no depth write, two-sided.
+    m.transparent = true;
+    m.blending = THREE.NormalBlending;
+    m.depthWrite = false;
+    m.side = THREE.DoubleSide;
+    // No derivatives extension needed — edges are soft from smoothstep, not bump.
+});
+extend({ SmokeMaterial });

package/dist/shaders/SmokeRibbonMaterial.d.ts

@@ -0,0 +1,48 @@
+import * as THREE from 'three';
+export interface SmokeRibbonUniforms {
+    u_time: number;
+    u_color: THREE.Color;
+    u_colorTop: THREE.Color;
+    u_speed: number;
+    u_detail: number;
+    u_remapLow: number;
+    u_remapHigh: number;
+    u_edgeX: number;
+    u_edgeY: number;
+    u_density: number;
+    u_twistStrength: number;
+    u_twistSpeed: number;
+    u_twistScale: number;
+    u_twistStart: number;
+    u_windDir: THREE.Vector2;
+    u_mouse: THREE.Vector2;
+    u_mouseStrength: number;
+}
+export type SmokeRibbonMaterialImpl = THREE.ShaderMaterial & SmokeRibbonUniforms;
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        smokeRibbonMaterial: ThreeElements['shaderMaterial'] & Partial<SmokeRibbonUniforms>;
+    }
+}
+export declare const SmokeRibbonMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    u_color: THREE.Color;
+    u_colorTop: THREE.Color;
+    u_windDir: THREE.Vector2;
+    u_mouse: THREE.Vector2;
+    u_time: number;
+    u_speed: number;
+    u_detail: number;
+    u_remapLow: number;
+    u_remapHigh: number;
+    u_edgeX: number;
+    u_edgeY: number;
+    u_density: number;
+    u_twistStrength: number;
+    u_twistSpeed: number;
+    u_twistScale: number;
+    u_twistStart: number;
+    u_mouseStrength: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=SmokeRibbonMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SmokeRibbonMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/SmokeRibbonMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,MAAM,WAAW,mBAAmB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC;IACrB,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC;IACzB,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,MAAM,uBAAuB,GAAG,KAAK,CAAC,cAAc,GAAG,mBAAmB,CAAC;AAEjF,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,mBAAmB,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;KACvF;CACJ;AAwGD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;CAa9B,CAAC"}

package/dist/shaders/SmokeRibbonMaterial.js

@@ -0,0 +1,120 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '@react-three/drei';
+import { extend } from '@react-three/fiber';
+const defaults = {
+    u_time: 0,
+    u_color: new THREE.Color(0.95, 0.95, 0.97),
+    u_colorTop: new THREE.Color(0.7, 0.72, 0.78),
+    u_speed: 0.18,
+    u_detail: 1.4,
+    u_remapLow: 0.38,
+    u_remapHigh: 1.0,
+    u_edgeX: 0.4,
+    u_edgeY: 0.32,
+    u_density: 1.0,
+    u_twistStrength: 9.0,
+    u_twistSpeed: 0.4,
+    u_twistScale: 0.9,
+    u_twistStart: 0.18,
+    u_windDir: new THREE.Vector2(0.15, 0.0),
+    u_mouse: new THREE.Vector2(0, 0),
+    u_mouseStrength: 0.0,
+};
+// Shared GLSL noise (kept identical in both stages so twist & density agree).
+const noiseGLSL = /*glsl*/ `
+  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 vnoise(vec2 p){
+    vec2 i = floor(p), f = fract(p);
+    vec2 u = f * f * (3.0 - 2.0 * f);
+    return mix(mix(hash21(i),           hash21(i+vec2(1,0)), u.x),
+               mix(hash21(i+vec2(0,1)), hash21(i+vec2(1,1)), u.x), u.y);
+  }
+`;
+const vertexShader = /*glsl*/ `
+  uniform float u_time;
+  uniform float u_twistStrength;
+  uniform float u_twistSpeed;
+  uniform float u_twistScale;
+  uniform float u_twistStart;
+  uniform vec2  u_windDir;
+  uniform vec2  u_mouse;
+  uniform float u_mouseStrength;
+
+  varying vec2 vUv;
+
+  ${noiseGLSL}
+
+  vec2 rotate2D(vec2 v, float a){ float s = sin(a), c = cos(a); return mat2(c, s, -s, c) * v; }
+
+  void main() {
+    vUv = uv;
+    float y = uv.y;                                   // 0 at the source, 1 at the tip
+    float gust = clamp(u_mouseStrength, 0.0, 1.0);
+
+    // twist ramps in with height -> coherent stem, spiralling top
+    float ramp = smoothstep(u_twistStart, 1.0, y);
+    float nv = vnoise(vec2(0.37, y * u_twistScale - u_time * u_twistSpeed));
+    float angle = (nv - 0.5) * u_twistStrength * (ramp + gust * 0.5);
+
+    vec3 pos = position;
+    pos.xz = rotate2D(pos.xz, angle);
+
+    // lateral drift: wind + a lean toward the cursor, growing toward the top
+    float lean = u_windDir.x + u_mouse.x * gust * 1.5;
+    pos.x += lean * pow(y, 1.5);
+
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
+  }
+`;
+const fragmentShader = /*glsl*/ `
+  precision highp float;
+
+  uniform float u_time;
+  uniform vec3  u_color;
+  uniform vec3  u_colorTop;
+  uniform float u_speed;
+  uniform float u_detail;
+  uniform float u_remapLow;
+  uniform float u_remapHigh;
+  uniform float u_edgeX;
+  uniform float u_edgeY;
+  uniform float u_density;
+
+  varying vec2 vUv;
+
+  ${noiseGLSL}
+
+  const mat2 ROT = mat2(0.8, 0.6, -0.6, 0.8);
+  float fbm(vec2 p){ float s=0.0, a=0.5; for(int i=0;i<5;i++){ s+=a*vnoise(p); p=ROT*p*2.03+vec2(1.7); a*=0.5; } return s; }
+
+  void main() {
+    // procedural density, scrolling upward; detail enlarges a touch with height
+    vec2 p = vec2(vUv.x * u_detail * 4.0, vUv.y * u_detail * 3.4 - u_time * u_speed);
+    float n = fbm(p);
+    n = smoothstep(u_remapLow, u_remapHigh, n);
+
+    // fade all four edges so the ribbon dissolves at its borders
+    float fade = smoothstep(0.0, u_edgeX, vUv.x) * smoothstep(1.0, 1.0 - u_edgeX, vUv.x)
+               * smoothstep(0.0, u_edgeY, vUv.y) * smoothstep(1.0, 1.0 - u_edgeY, vUv.y);
+
+    float alpha = clamp(n * fade * u_density, 0.0, 1.0);
+    vec3 col = mix(u_color, u_colorTop, vUv.y);
+
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+export const SmokeRibbonMaterial = shaderMaterial({
+    ...defaults,
+    u_color: defaults.u_color.clone(),
+    u_colorTop: defaults.u_colorTop.clone(),
+    u_windDir: defaults.u_windDir.clone(),
+    u_mouse: defaults.u_mouse.clone(),
+}, vertexShader, fragmentShader, (m) => {
+    if (!m)
+        return;
+    m.transparent = true;
+    m.blending = THREE.NormalBlending;
+    m.depthWrite = false;
+    m.side = THREE.DoubleSide;
+});
+extend({ SmokeRibbonMaterial });

package/dist/shaders/SparklesBurstMaterial.d.ts

@@ -0,0 +1,65 @@
+import * as THREE from "three";
+export interface SparklesBurstMaterialUniforms {
+    uTime: {
+        value: number;
+    };
+    /** 0→1 over `durationMs`; JS-driven. */
+    uProgress: {
+        value: number;
+    };
+    uRayCount: {
+        value: number;
+    };
+    uCoreColor: {
+        value: THREE.Color;
+    };
+    uBurstColor: {
+        value: THREE.Color;
+    };
+    uIntensity: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    /** Color a burst shifts toward when the cursor is hovering near it. */
+    uHoverColor: {
+        value: THREE.Color;
+    };
+    /** Radius of the hover-glow falloff in NDC units. */
+    uHoverRadius: {
+        value: number;
+    };
+    /** Strength of the hover effect. 0 = off. */
+    uHoverIntensity: {
+        value: number;
+    };
+    /** Auto-populated each frame by animateUniforms (NDC pointer, -1..1). */
+    u_mouse: {
+        value: THREE.Vector2;
+    };
+}
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            sparklesBurstMaterial: any;
+        }
+    }
+}
+declare const SparklesBurstMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    uTime: number;
+    uProgress: number;
+    uRayCount: number;
+    uCoreColor: THREE.Color;
+    uBurstColor: THREE.Color;
+    uIntensity: number;
+    uOpacity: number;
+    uHoverColor: THREE.Color;
+    uHoverRadius: number;
+    uHoverIntensity: number;
+    u_mouse: THREE.Vector2;
+}> & {
+    key: string;
+};
+export { SparklesBurstMaterial };
+//# sourceMappingURL=SparklesBurstMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SparklesBurstMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/SparklesBurstMaterial.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,wCAAwC;IACxC,SAAS,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;KACtB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;KACtB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,uEAAuE;IACvE,WAAW,EAAE;QACT,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;KACtB,CAAC;IACF,qDAAqD;IACrD,YAAY,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,6CAA6C;IAC7C,eAAe,EAAE;QACb,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,yEAAyE;IACzE,OAAO,EAAE;QACL,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC;KACxB,CAAC;CACL;AAED,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,GAAG,CAAC;QACV,UAAU,iBAAiB;YACvB,qBAAqB,EAAE,GAAG,CAAC;SAC9B;KACJ;CACJ;AAmFD,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;CAYK,CAAC;AAEjC,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/shaders/SparklesBurstMaterial.js

@@ -0,0 +1,99 @@
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+import * as THREE from "three";
+const vertexShader = /* glsl */ `
+  varying vec2 vUv;
+  varying vec4 vClipPos;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+    vClipPos = gl_Position;
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform float uTime;
+  uniform float uProgress;
+  uniform float uRayCount;
+  uniform vec3  uCoreColor;
+  uniform vec3  uBurstColor;
+  uniform float uIntensity;
+  uniform float uOpacity;
+  uniform vec3  uHoverColor;
+  uniform float uHoverRadius;
+  uniform float uHoverIntensity;
+  uniform vec2  u_mouse;
+  varying vec2  vUv;
+  varying vec4  vClipPos;
+
+  #define PI 3.14159265359
+
+  void main() {
+    // Polar coords centered on the quad
+    vec2 p = (vUv - 0.5) * 2.0;
+    float r = length(p);
+    float theta = atan(p.y, p.x);
+
+    // Ease-out cubic expansion: front of the wave reaches r=1 at uProgress=1
+    float expand = 1.0 - pow(1.0 - uProgress, 3.0);
+
+    // N rays radiating outward, each as a tapered bright slice
+    float angularPhase = theta * uRayCount * 0.5 / PI;
+    float rays = pow(0.5 + 0.5 * cos(angularPhase * 2.0 * PI), 12.0);
+
+    // Thin wavefront ring at r = expand
+    float wf = smoothstep(expand - 0.04, expand - 0.005, r)
+             * (1.0 - smoothstep(expand + 0.005, expand + 0.04, r));
+
+    // Tapered ray length: bright at base, fades at the leading edge
+    float rayLen = rays
+      * smoothstep(0.02, 0.18, r)
+      * (1.0 - smoothstep(expand * 0.4, expand * 1.05, r));
+
+    // Bright soft core that fades during the latter half
+    float core = pow(max(0.0, 1.0 - r * 4.0), 4.0)
+               * (1.0 - smoothstep(0.25, 0.7, uProgress));
+
+    // Tiny sparkles travelling outward along each ray
+    float sparkleR = fract(r * 4.5 - uTime * 1.2);
+    float sparkle = pow(1.0 - 2.0 * abs(sparkleR - 0.5), 18.0) * rays;
+
+    float intensity = wf * 1.4 + rayLen * 1.0 + core * 1.2 + sparkle * 0.9;
+
+    // Color gradient: hot core color inner → outer burst color
+    vec3 col = mix(uCoreColor, uBurstColor, smoothstep(0.05, expand * 0.9, r));
+    col *= 1.0 + intensity * 0.9 * uIntensity;
+
+    // Hover: per-fragment NDC distance to the cursor with smoothstep falloff
+    // — 1.0 at cursor, 0.0 at the radius edge. Color and brightness both
+    // use the gradient; gated off when uHoverIntensity == 0.
+    vec2 fragNdc = vClipPos.xy / vClipPos.w;
+    float mouseDist = length(fragNdc - u_mouse);
+    float radius = max(uHoverRadius, 0.0001);
+    float hoverActive = step(0.0001, uHoverIntensity);
+    float hoverFalloff = (1.0 - smoothstep(0.0, radius, mouseDist)) * hoverActive;
+    float hoverEffect = hoverFalloff * uHoverIntensity;
+    col = mix(col, uHoverColor, hoverFalloff);
+    col *= 1.0 + hoverEffect * 2.0;
+
+    // Overall fade-out across the action lifetime
+    float fade = 1.0 - smoothstep(0.7, 1.0, uProgress);
+    float alpha = intensity * fade * uOpacity;
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const SparklesBurstMaterial = shaderMaterial({
+    uTime: 0,
+    uProgress: 0,
+    uRayCount: 8,
+    uCoreColor: new THREE.Color('#ffffff'),
+    uBurstColor: new THREE.Color('#ffaa00'),
+    uIntensity: 1.0,
+    uOpacity: 1.0,
+    uHoverColor: new THREE.Color('#ffffff'),
+    uHoverRadius: 0.3,
+    uHoverIntensity: 0.0,
+    u_mouse: new THREE.Vector2(0, 0),
+}, vertexShader, fragmentShader);
+extend({ SparklesBurstMaterial });
+export { SparklesBurstMaterial };