@3driseai/3drise-core 1.0.1

package/dist/shaders/effects/registry/hueShift.js

@@ -0,0 +1,40 @@
+export const hueShiftEffect = {
+    id: 'hueShift',
+    label: 'Hue shift',
+    stage: 'fragment',
+    allowedScopes: ['global', 'pointer'],
+    helpers: /*glsl*/ `
+    // Cheap hue rotation matrix (no full HSV conversion). amount is in radians.
+    vec3 rotateHue(vec3 color, float amount) {
+      const vec3 k = vec3(0.57735);
+      float c = cos(amount);
+      vec3 rotated = color * c
+                   + cross(k, color) * sin(amount)
+                   + k * dot(k, color) * (1.0 - c);
+      return rotated;
+    }
+  `,
+    uniforms: {
+        intensity: {
+            glslType: 'float',
+            default: 1.0,
+            control: { kind: 'slider', label: 'Intensity', min: 0, max: 1, step: 0.01 },
+        },
+        speed: {
+            glslType: 'float',
+            default: 1.0,
+            control: { kind: 'slider', label: 'Speed', min: -5, max: 5, step: 0.05 },
+        },
+        spatial: {
+            glslType: 'float',
+            default: 0.0,
+            control: { kind: 'slider', label: 'Spatial', min: 0, max: 5, step: 0.05 },
+        },
+    },
+    fragmentBody: /*glsl*/ `
+    float hueAngle = u_time * {{prefix}}speed
+                   + (vTexCoords.x + vTexCoords.y) * {{prefix}}spatial;
+    vec3 shifted = rotateHue(outColor.rgb, hueAngle);
+    outColor.rgb = mix(outColor.rgb, shifted, {{prefix}}intensity * effectScopeFactor);
+  `,
+};

package/dist/shaders/effects/registry/index.d.ts

@@ -0,0 +1,9 @@
+import type { EffectDescriptor, EffectShaderStage, EffectScope } from "../types";
+export declare const EFFECT_REGISTRY: Record<string, EffectDescriptor>;
+export declare function registerEffect(descriptor: EffectDescriptor): void;
+export declare function getDescriptor(id: string): EffectDescriptor | undefined;
+export declare function listDescriptors(filter?: {
+    stage?: EffectShaderStage;
+    scope?: EffectScope;
+}): EffectDescriptor[];
+//# sourceMappingURL=index.d.ts.map

package/dist/shaders/effects/registry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/shaders/effects/registry/index.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AA4BjF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAA6D,CAAC;AAC3H,wBAAgB,cAAc,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI,CAKjE;AACD,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAEtE;AACD,wBAAgB,eAAe,CAAC,MAAM,CAAC,EAAE;IAC7B,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B,KAAK,CAAC,EAAE,WAAW,CAAC;CACvB,GAAG,gBAAgB,EAAE,CAW7B"}

package/dist/shaders/effects/registry/index.js

@@ -0,0 +1,70 @@
+import { waveEffect } from './wave.js';
+import { vortexEffect } from './vortex.js';
+import { rippleEffect } from './ripple.js';
+import { scaleEffect } from './scale.js';
+import { displacementEffect } from './displacement.js';
+import { noiseEffect } from './noise.js';
+import { twistEffect } from './twist.js';
+import { magnetEffect } from './magnet.js';
+import { jitterEffect } from './jitter.js';
+import { explodeEffect } from './explode.js';
+import { spiralEffect } from './spiral.js';
+import { grayscaleEffect } from './grayscale.js';
+import { glowEffect } from './glow.js';
+import { colorShiftEffect } from './colorShift.js';
+import { brightnessEffect } from './brightness.js';
+import { pulseEffect } from './pulse.js';
+import { hueShiftEffect } from './hueShift.js';
+import { saturationEffect } from './saturation.js';
+import { sparkleEffect } from './sparkle.js';
+import { flickerEffect } from './flicker.js';
+import { depthFadeEffect } from './depthFade.js';
+import { rainbowEffect } from './rainbow.js';
+const ALL_DESCRIPTORS = [
+    // Vertex
+    waveEffect,
+    vortexEffect,
+    rippleEffect,
+    scaleEffect,
+    displacementEffect,
+    noiseEffect,
+    twistEffect,
+    magnetEffect,
+    jitterEffect,
+    explodeEffect,
+    spiralEffect,
+    // Fragment
+    grayscaleEffect,
+    glowEffect,
+    colorShiftEffect,
+    brightnessEffect,
+    pulseEffect,
+    hueShiftEffect,
+    saturationEffect,
+    sparkleEffect,
+    flickerEffect,
+    depthFadeEffect,
+    rainbowEffect,
+];
+export const EFFECT_REGISTRY = Object.fromEntries(ALL_DESCRIPTORS.map((d) => [d.id, d]));
+export function registerEffect(descriptor) {
+    if (EFFECT_REGISTRY[descriptor.id]) {
+        console.warn(`[effects] descriptor "${descriptor.id}" already registered; overwriting`);
+    }
+    EFFECT_REGISTRY[descriptor.id] = descriptor;
+}
+export function getDescriptor(id) {
+    return EFFECT_REGISTRY[id];
+}
+export function listDescriptors(filter) {
+    const all = Object.values(EFFECT_REGISTRY);
+    if (!filter)
+        return all;
+    return all.filter((d) => {
+        if (filter.stage && d.stage !== filter.stage)
+            return false;
+        if (filter.scope && !d.allowedScopes.includes(filter.scope))
+            return false;
+        return true;
+    });
+}

package/dist/shaders/effects/registry/jitter.d.ts

@@ -0,0 +1,3 @@
+import type { EffectDescriptor } from "../types";
+export declare const jitterEffect: EffectDescriptor;
+//# sourceMappingURL=jitter.d.ts.map

package/dist/shaders/effects/registry/jitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jitter.d.ts","sourceRoot":"","sources":["../../../../src/shaders/effects/registry/jitter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,eAAO,MAAM,YAAY,EAAE,gBA8B1B,CAAC"}

package/dist/shaders/effects/registry/jitter.js

@@ -0,0 +1,31 @@
+export const jitterEffect = {
+    id: 'jitter',
+    label: 'Jitter',
+    stage: 'vertex',
+    allowedScopes: ['global', 'pointer'],
+    uniforms: {
+        intensity: {
+            glslType: 'float',
+            default: 0.05,
+            control: { kind: 'slider', label: 'Intensity', min: 0, max: 1, step: 0.005 },
+        },
+        speed: {
+            glslType: 'float',
+            default: 10.0,
+            control: { kind: 'slider', label: 'Speed', min: 0, max: 60, step: 0.5 },
+        },
+    },
+    vertexBody: /*glsl*/ `
+    // Per-particle pseudo-random vibration. Uses the unmodified position as a
+    // stable seed so each particle gets its own distinct jitter direction, with
+    // u_time stepped by 'speed' for the temporal frequency.
+    float jitterT = floor(u_time * {{prefix}}speed);
+    vec3 jitterSeed = position + vec3(jitterT * 0.137);
+    vec3 jitterOffset = vec3(
+      fract(sin(dot(jitterSeed, vec3(12.9898, 78.233, 37.719))) * 43758.5453) - 0.5,
+      fract(sin(dot(jitterSeed, vec3(93.9898, 47.233, 12.719))) * 43758.5453) - 0.5,
+      fract(sin(dot(jitterSeed, vec3(54.9898, 31.233, 89.719))) * 43758.5453) - 0.5
+    );
+    morphedPos += jitterOffset * {{prefix}}intensity * 2.0 * effectScopeFactor;
+  `,
+};

package/dist/shaders/effects/registry/magnet.d.ts

@@ -0,0 +1,3 @@
+import type { EffectDescriptor } from "../types";
+export declare const magnetEffect: EffectDescriptor;
+//# sourceMappingURL=magnet.d.ts.map

package/dist/shaders/effects/registry/magnet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"magnet.d.ts","sourceRoot":"","sources":["../../../../src/shaders/effects/registry/magnet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,eAAO,MAAM,YAAY,EAAE,gBA0C1B,CAAC"}

package/dist/shaders/effects/registry/magnet.js

@@ -0,0 +1,43 @@
+export const magnetEffect = {
+    id: 'magnet',
+    label: 'Magnet (attract)',
+    stage: 'vertex',
+    allowedScopes: ['global', 'pointer'],
+    uniforms: {
+        intensity: {
+            glslType: 'float',
+            default: 0.5,
+            control: { kind: 'slider', label: 'Intensity', min: 0, max: 5, step: 0.01 },
+        },
+        centerX: {
+            glslType: 'float',
+            default: 0,
+            control: { kind: 'slider', label: 'Center X', min: -5, max: 5, step: 0.05 },
+        },
+        centerY: {
+            glslType: 'float',
+            default: 0,
+            control: { kind: 'slider', label: 'Center Y', min: -5, max: 5, step: 0.05 },
+        },
+        centerZ: {
+            glslType: 'float',
+            default: 0,
+            control: { kind: 'slider', label: 'Center Z', min: -5, max: 5, step: 0.05 },
+        },
+        falloffPower: {
+            glslType: 'float',
+            default: 1.0,
+            control: { kind: 'slider', label: 'Falloff power', min: 0, max: 3, step: 0.05 },
+        },
+    },
+    vertexBody: /*glsl*/ `
+    // Pull each particle toward a center point. Power=0 → constant pull,
+    // power=1 → linear distance, power=2 → 1/r² (inverse-square).
+    vec3 magCenter = vec3({{prefix}}centerX, {{prefix}}centerY, {{prefix}}centerZ);
+    vec3 toCenter = magCenter - morphedPos;
+    float dist = max(length(toCenter), 0.001);
+    vec3 dir = toCenter / dist;
+    float strength = {{prefix}}intensity * effectScopeFactor / pow(dist, {{prefix}}falloffPower);
+    morphedPos += dir * min(strength, dist); // clamp to not overshoot center
+  `,
+};

package/dist/shaders/effects/registry/noise.d.ts

@@ -0,0 +1,3 @@
+import type { EffectDescriptor } from "../types";
+export declare const noiseEffect: EffectDescriptor;
+//# sourceMappingURL=noise.d.ts.map

package/dist/shaders/effects/registry/noise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noise.d.ts","sourceRoot":"","sources":["../../../../src/shaders/effects/registry/noise.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,eAAO,MAAM,WAAW,EAAE,gBA2DzB,CAAC"}

package/dist/shaders/effects/registry/noise.js

@@ -0,0 +1,61 @@
+import { noiseLibGLSL, NOISE_TYPE_OPTIONS } from '../noiseLib.glsl.js';
+export const noiseEffect = {
+    id: 'noise',
+    label: 'Noise displacement',
+    stage: 'vertex',
+    allowedScopes: ['global', 'pointer'],
+    helpers: noiseLibGLSL,
+    uniforms: {
+        intensity: {
+            glslType: 'float',
+            default: 0.3,
+            control: { kind: 'slider', label: 'Intensity', min: 0, max: 5, step: 0.01 },
+        },
+        frequency: {
+            glslType: 'float',
+            default: 1.0,
+            control: { kind: 'slider', label: 'Frequency', min: 0.01, max: 10, step: 0.05 },
+        },
+        speed: {
+            glslType: 'float',
+            default: 0.3,
+            control: { kind: 'slider', label: 'Speed', min: 0, max: 3, step: 0.01 },
+        },
+        noiseType: {
+            glslType: 'float',
+            default: 1, // simplex by default — smoother than perlin
+            control: { kind: 'select', label: 'Noise type', options: NOISE_TYPE_OPTIONS },
+        },
+        axis: {
+            glslType: 'float',
+            default: 2, // 0=X 1=Y 2=Z 3=all
+            control: {
+                kind: 'select',
+                label: 'Axis',
+                options: [
+                    { value: 0, label: 'X' },
+                    { value: 1, label: 'Y' },
+                    { value: 2, label: 'Z' },
+                    { value: 3, label: 'All' },
+                ],
+            },
+        },
+    },
+    vertexBody: /*glsl*/ `
+    vec2 noisePos = morphedPos.xy * {{prefix}}frequency + vec2(u_time * {{prefix}}speed);
+    float n = sampleNoise({{prefix}}noiseType, noisePos);
+    float push = n * {{prefix}}intensity * effectScopeFactor;
+    if ({{prefix}}axis < 0.5) {
+      morphedPos.x += push;
+    } else if ({{prefix}}axis < 1.5) {
+      morphedPos.y += push;
+    } else if ({{prefix}}axis < 2.5) {
+      morphedPos.z += push;
+    } else {
+      // All axes — sample three offset noise positions for variety
+      morphedPos.x += sampleNoise({{prefix}}noiseType, noisePos) * {{prefix}}intensity * effectScopeFactor;
+      morphedPos.y += sampleNoise({{prefix}}noiseType, noisePos + vec2(31.7, 5.2)) * {{prefix}}intensity * effectScopeFactor;
+      morphedPos.z += sampleNoise({{prefix}}noiseType, noisePos + vec2(11.3, 27.1)) * {{prefix}}intensity * effectScopeFactor;
+    }
+  `,
+};

package/dist/shaders/effects/registry/pulse.d.ts

@@ -0,0 +1,3 @@
+import type { EffectDescriptor } from "../types";
+export declare const pulseEffect: EffectDescriptor;
+//# sourceMappingURL=pulse.d.ts.map

package/dist/shaders/effects/registry/pulse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pulse.d.ts","sourceRoot":"","sources":["../../../../src/shaders/effects/registry/pulse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,eAAO,MAAM,WAAW,EAAE,gBAuBzB,CAAC"}

package/dist/shaders/effects/registry/pulse.js

@@ -0,0 +1,24 @@
+export const pulseEffect = {
+    id: 'pulse',
+    label: 'Pulse',
+    stage: 'fragment',
+    allowedScopes: ['global', 'pointer'],
+    uniforms: {
+        intensity: {
+            glslType: 'float',
+            default: 0.5,
+            control: { kind: 'slider', label: 'Intensity', min: 0, max: 5, step: 0.01 },
+        },
+        speed: {
+            glslType: 'float',
+            default: 2.0,
+            control: { kind: 'slider', label: 'Speed', min: 0, max: 10, step: 0.1 },
+        },
+    },
+    fragmentBody: /*glsl*/ `
+    // Bidirectional multiplicative pulse so it's visible on any base color
+    // (additive pulse on white particles saturates and is invisible).
+    float pulseValue = sin(u_time * {{prefix}}speed);
+    outColor.rgb *= 1.0 + pulseValue * {{prefix}}intensity * effectScopeFactor;
+  `,
+};

package/dist/shaders/effects/registry/rainbow.d.ts

@@ -0,0 +1,3 @@
+import type { EffectDescriptor } from "../types";
+export declare const rainbowEffect: EffectDescriptor;
+//# sourceMappingURL=rainbow.d.ts.map

package/dist/shaders/effects/registry/rainbow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rainbow.d.ts","sourceRoot":"","sources":["../../../../src/shaders/effects/registry/rainbow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,eAAO,MAAM,aAAa,EAAE,gBAsD3B,CAAC"}

package/dist/shaders/effects/registry/rainbow.js

@@ -0,0 +1,55 @@
+export const rainbowEffect = {
+    id: 'rainbow',
+    label: 'Rainbow',
+    stage: 'fragment',
+    allowedScopes: ['global', 'pointer'],
+    helpers: /*glsl*/ `
+    // Cheap HSV → RGB conversion (Sam Hocevar style).
+    vec3 hsv2rgb(vec3 c) {
+      vec4 K = vec4(1.0, 2.0/3.0, 1.0/3.0, 3.0);
+      vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+      return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+    }
+  `,
+    uniforms: {
+        intensity: {
+            glslType: 'float',
+            default: 1.0,
+            control: { kind: 'slider', label: 'Intensity', min: 0, max: 1, step: 0.01 },
+        },
+        speed: {
+            glslType: 'float',
+            default: 0.3,
+            control: { kind: 'slider', label: 'Speed', min: -3, max: 3, step: 0.01 },
+        },
+        spatial: {
+            glslType: 'float',
+            default: 0.5,
+            control: { kind: 'slider', label: 'Spatial', min: 0, max: 5, step: 0.05 },
+        },
+        direction: {
+            glslType: 'float',
+            default: 0,
+            control: {
+                kind: 'select',
+                label: 'Direction',
+                options: [
+                    { value: 0, label: 'Horizontal' },
+                    { value: 1, label: 'Vertical' },
+                    { value: 2, label: 'Diagonal' },
+                    { value: 3, label: 'Radial' },
+                ],
+            },
+        },
+    },
+    fragmentBody: /*glsl*/ `
+    float rainbowAxis =
+      ({{prefix}}direction < 0.5) ? vTexCoords.x :
+      ({{prefix}}direction < 1.5) ? vTexCoords.y :
+      ({{prefix}}direction < 2.5) ? (vTexCoords.x + vTexCoords.y) :
+                                     length(vTexCoords);
+    float hue = fract(rainbowAxis * {{prefix}}spatial + u_time * {{prefix}}speed);
+    vec3 rainbowColor = hsv2rgb(vec3(hue, 1.0, 1.0));
+    outColor.rgb = mix(outColor.rgb, rainbowColor, {{prefix}}intensity * effectScopeFactor);
+  `,
+};

package/dist/shaders/effects/registry/ripple.d.ts

@@ -0,0 +1,3 @@
+import type { EffectDescriptor } from "../types";
+export declare const rippleEffect: EffectDescriptor;
+//# sourceMappingURL=ripple.d.ts.map

package/dist/shaders/effects/registry/ripple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ripple.d.ts","sourceRoot":"","sources":["../../../../src/shaders/effects/registry/ripple.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,eAAO,MAAM,YAAY,EAAE,gBAsC1B,CAAC"}

package/dist/shaders/effects/registry/ripple.js

@@ -0,0 +1,39 @@
+export const rippleEffect = {
+    id: 'ripple',
+    label: 'Ripple',
+    stage: 'vertex',
+    allowedScopes: ['global', 'pointer'],
+    uniforms: {
+        intensity: {
+            glslType: 'float',
+            default: 0.3,
+            control: { kind: 'slider', label: 'Intensity', min: 0, max: 2, step: 0.01 },
+        },
+        frequency: {
+            glslType: 'float',
+            default: 5.0,
+            control: { kind: 'slider', label: 'Frequency', min: 0, max: 20, step: 0.1 },
+        },
+        speed: {
+            glslType: 'float',
+            default: 2.0,
+            control: { kind: 'slider', label: 'Speed', min: 0, max: 10, step: 0.1 },
+        },
+        centerX: {
+            glslType: 'float',
+            default: 0,
+            control: { kind: 'slider', label: 'Center X', min: -5, max: 5, step: 0.1 },
+        },
+        centerY: {
+            glslType: 'float',
+            default: 0,
+            control: { kind: 'slider', label: 'Center Y', min: -5, max: 5, step: 0.1 },
+        },
+    },
+    vertexBody: /*glsl*/ `
+    vec2 rippleCenter = vec2({{prefix}}centerX, {{prefix}}centerY);
+    float rippleDist = distance(morphedPos.xy, rippleCenter);
+    morphedPos.z += sin(rippleDist * {{prefix}}frequency - u_time * {{prefix}}speed)
+                  * {{prefix}}intensity * effectScopeFactor;
+  `,
+};

package/dist/shaders/effects/registry/saturation.d.ts

@@ -0,0 +1,3 @@
+import type { EffectDescriptor } from "../types";
+export declare const saturationEffect: EffectDescriptor;
+//# sourceMappingURL=saturation.d.ts.map

package/dist/shaders/effects/registry/saturation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saturation.d.ts","sourceRoot":"","sources":["../../../../src/shaders/effects/registry/saturation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,eAAO,MAAM,gBAAgB,EAAE,gBAkB9B,CAAC"}

package/dist/shaders/effects/registry/saturation.js

@@ -0,0 +1,19 @@
+export const saturationEffect = {
+    id: 'saturation',
+    label: 'Saturation',
+    stage: 'fragment',
+    allowedScopes: ['global', 'pointer'],
+    uniforms: {
+        intensity: {
+            glslType: 'float',
+            default: 0.5,
+            control: { kind: 'slider', label: 'Intensity', min: -1, max: 2, step: 0.01 },
+        },
+    },
+    fragmentBody: /*glsl*/ `
+    // intensity = 0 → unchanged, -1 → grayscale, +1 → +100% chroma boost.
+    float satGray = dot(outColor.rgb, vec3(0.299, 0.587, 0.114));
+    float satAmount = 1.0 + {{prefix}}intensity * effectScopeFactor;
+    outColor.rgb = mix(vec3(satGray), outColor.rgb, satAmount);
+  `,
+};

package/dist/shaders/effects/registry/scale.d.ts

@@ -0,0 +1,3 @@
+import type { EffectDescriptor } from "../types";
+export declare const scaleEffect: EffectDescriptor;
+//# sourceMappingURL=scale.d.ts.map

package/dist/shaders/effects/registry/scale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scale.d.ts","sourceRoot":"","sources":["../../../../src/shaders/effects/registry/scale.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,eAAO,MAAM,WAAW,EAAE,gBAyBzB,CAAC"}

package/dist/shaders/effects/registry/scale.js

@@ -0,0 +1,26 @@
+export const scaleEffect = {
+    id: 'scale',
+    label: 'Scale (point size)',
+    stage: 'vertex',
+    allowedScopes: ['pointer'],
+    uniforms: {
+        intensity: {
+            glslType: 'float',
+            default: 0.5,
+            control: { kind: 'slider', label: 'Intensity', min: 0, max: 1, step: 0.01 },
+        },
+        minScale: {
+            glslType: 'float',
+            default: 0.5,
+            control: { kind: 'slider', label: 'Min scale', min: 0, max: 5, step: 0.05 },
+        },
+        maxScale: {
+            glslType: 'float',
+            default: 2.0,
+            control: { kind: 'slider', label: 'Max scale', min: 0, max: 10, step: 0.05 },
+        },
+    },
+    vertexBody: /*glsl*/ `
+    sizeMultiplier *= mix({{prefix}}minScale, {{prefix}}maxScale, effectScopeFactor * {{prefix}}intensity);
+  `,
+};

package/dist/shaders/effects/registry/sparkle.d.ts

@@ -0,0 +1,3 @@
+import type { EffectDescriptor } from "../types";
+export declare const sparkleEffect: EffectDescriptor;
+//# sourceMappingURL=sparkle.d.ts.map

package/dist/shaders/effects/registry/sparkle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparkle.d.ts","sourceRoot":"","sources":["../../../../src/shaders/effects/registry/sparkle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,eAAO,MAAM,aAAa,EAAE,gBAiC3B,CAAC"}

package/dist/shaders/effects/registry/sparkle.js

@@ -0,0 +1,34 @@
+export const sparkleEffect = {
+    id: 'sparkle',
+    label: 'Sparkle',
+    stage: 'fragment',
+    allowedScopes: ['global', 'pointer'],
+    uniforms: {
+        intensity: {
+            glslType: 'float',
+            default: 1.0,
+            control: { kind: 'slider', label: 'Intensity', min: 0, max: 5, step: 0.01 },
+        },
+        density: {
+            glslType: 'float',
+            default: 0.05,
+            control: { kind: 'slider', label: 'Density', min: 0, max: 0.5, step: 0.005 },
+        },
+        speed: {
+            glslType: 'float',
+            default: 4.0,
+            control: { kind: 'slider', label: 'Speed', min: 0, max: 20, step: 0.1 },
+        },
+    },
+    fragmentBody: /*glsl*/ `
+    // Per-particle random twinkle. Uses vTexCoords as a stable per-particle seed
+    // and steps time in chunks so flashes feel discrete instead of smeared.
+    float sparkleStep = floor(u_time * {{prefix}}speed);
+    float sparkleSeed = dot(vTexCoords, vec2(12.9898, 78.233)) + sparkleStep * 17.31;
+    float sparkleRand = fract(sin(sparkleSeed) * 43758.5453);
+    float sparkleAlive = step(1.0 - {{prefix}}density, sparkleRand);
+    float sparkleFade = smoothstep(0.0, 0.5, fract(u_time * {{prefix}}speed));
+    sparkleFade = sparkleFade * (1.0 - sparkleFade) * 4.0; // 0→1→0 within step
+    outColor.rgb += vec3(sparkleAlive * sparkleFade * {{prefix}}intensity * effectScopeFactor);
+  `,
+};

package/dist/shaders/effects/registry/spiral.d.ts

@@ -0,0 +1,3 @@
+import type { EffectDescriptor } from "../types";
+export declare const spiralEffect: EffectDescriptor;
+//# sourceMappingURL=spiral.d.ts.map

package/dist/shaders/effects/registry/spiral.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spiral.d.ts","sourceRoot":"","sources":["../../../../src/shaders/effects/registry/spiral.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,eAAO,MAAM,YAAY,EAAE,gBA6C1B,CAAC"}

package/dist/shaders/effects/registry/spiral.js

@@ -0,0 +1,46 @@
+export const spiralEffect = {
+    id: 'spiral',
+    label: 'Spiral',
+    stage: 'vertex',
+    allowedScopes: ['global', 'pointer'],
+    uniforms: {
+        intensity: {
+            glslType: 'float',
+            default: 1.0,
+            control: { kind: 'slider', label: 'Rotation', min: -5, max: 5, step: 0.05 },
+        },
+        radialSpeed: {
+            glslType: 'float',
+            default: 0.2,
+            control: { kind: 'slider', label: 'Radial drift', min: -3, max: 3, step: 0.01 },
+        },
+        speed: {
+            glslType: 'float',
+            default: 1.0,
+            control: { kind: 'slider', label: 'Speed', min: -5, max: 5, step: 0.05 },
+        },
+        centerX: {
+            glslType: 'float',
+            default: 0,
+            control: { kind: 'slider', label: 'Center X', min: -5, max: 5, step: 0.05 },
+        },
+        centerY: {
+            glslType: 'float',
+            default: 0,
+            control: { kind: 'slider', label: 'Center Y', min: -5, max: 5, step: 0.05 },
+        },
+    },
+    vertexBody: /*glsl*/ `
+    // Rotation around (centerX, centerY) plus radial drift over time.
+    // Positive radial → outward like a galaxy arm; negative → inward like a drain.
+    vec2 spiralCenter = vec2({{prefix}}centerX, {{prefix}}centerY);
+    vec2 toCenter = morphedPos.xy - spiralCenter;
+    float r = length(toCenter);
+    float a = atan(toCenter.y, toCenter.x);
+    float deltaA = u_time * {{prefix}}speed * {{prefix}}intensity * effectScopeFactor;
+    float deltaR = u_time * {{prefix}}radialSpeed * effectScopeFactor;
+    a += deltaA;
+    r = max(0.0, r + deltaR);
+    morphedPos.xy = spiralCenter + r * vec2(cos(a), sin(a));
+  `,
+};

package/dist/shaders/effects/registry/twist.d.ts

@@ -0,0 +1,3 @@
+import type { EffectDescriptor } from "../types";
+export declare const twistEffect: EffectDescriptor;
+//# sourceMappingURL=twist.d.ts.map

package/dist/shaders/effects/registry/twist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"twist.d.ts","sourceRoot":"","sources":["../../../../src/shaders/effects/registry/twist.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,eAAO,MAAM,WAAW,EAAE,gBAsDzB,CAAC"}