@3driseai/3drise-core 1.0.1

package/dist/shaders/effects/EffectsFragmentFunctions.glsl.js

@@ -0,0 +1,182 @@
+// Shared fragment shader functions for all shader effects
+export const effectsFragmentGLSL = /*glsl*/ `
+  // ============================================================================
+  // UNIFORMS - All fragment effect uniforms
+  // ============================================================================
+  uniform float u_time;
+  uniform vec2 u_pointer;
+  uniform float uPointerEffectRadius;
+  
+  // General fragment effects - Grayscale
+  uniform bool uGeneralGrayscaleEnabled;
+  uniform float uGeneralGrayscaleMode;
+  uniform float uGeneralGrayscaleIntensity;
+  uniform float uGeneralGrayscaleContrast;
+  uniform float uGeneralGrayscaleBrightness;
+  uniform float uGeneralGrayscaleWaveFreq;
+  uniform float uGeneralGrayscaleWaveSpeed;
+  uniform float uGeneralGrayscaleWaveDir;
+  uniform float uGeneralGrayscalePulseSpeed;
+  uniform float uGeneralGrayscaleRippleSpeed;
+  uniform float uGeneralGrayscaleRippleCenterX;
+  uniform float uGeneralGrayscaleRippleCenterY;
+  
+  // Pointer fragment effects
+  uniform bool uGlowEnabled;
+  uniform float uGlowIntensity;
+  uniform vec3 uGlowColor;
+  uniform bool uColorShiftEnabled;
+  uniform float uColorShiftIntensity;
+  uniform vec3 uColorShiftTarget;
+  uniform bool uBrightnessEnabled;
+  uniform float uBrightnessIntensity;
+  uniform bool uPulseEnabled;
+  uniform float uPulseIntensity;
+  uniform float uPulseSpeed;
+  uniform bool uPointerGrayscaleEnabled;
+  uniform float uPointerGrayscaleIntensity;
+  uniform float uPointerGrayscaleContrast;
+  uniform float uPointerGrayscaleBrightness;
+  
+  // ============================================================================
+  // HELPER FUNCTIONS
+  // ============================================================================
+  
+  // Calculate smooth falloff from pointer position
+  float getFragmentPointerFalloff(vec2 fragPos, vec2 pointer) {
+    float dist = distance(fragPos, pointer);
+    return smoothstep(uPointerEffectRadius, 0.0, dist);
+  }
+  
+  // Convert RGB to grayscale
+  float rgbToGrayscale(vec3 color) {
+    return dot(color, vec3(0.299, 0.587, 0.114));
+  }
+  
+  // Apply contrast and brightness to grayscale value
+  float adjustGrayscale(float gray, float contrast, float brightness) {
+    return (gray - 0.5) * contrast + 0.5 + brightness;
+  }
+  
+  // ============================================================================
+  // GENERAL EFFECTS (Always active when enabled)
+  // ============================================================================
+  
+  vec3 applyGeneralGrayscale(vec3 color, vec2 fragPos) {
+    float grayscaleFactor = 0.0;
+    
+    if (uGeneralGrayscaleMode < 0.5) {
+      // Mode 0: Static
+      grayscaleFactor = uGeneralGrayscaleIntensity;
+    } else if (uGeneralGrayscaleMode < 1.5) {
+      // Mode 1: Wave
+      float wavePos = 0.0;
+      if (uGeneralGrayscaleWaveDir < 0.5) {
+        // Horizontal
+        wavePos = fragPos.x;
+      } else if (uGeneralGrayscaleWaveDir < 1.5) {
+        // Vertical
+        wavePos = fragPos.y;
+      } else {
+        // Diagonal
+        wavePos = fragPos.x + fragPos.y;
+      }
+      grayscaleFactor = (sin(wavePos * uGeneralGrayscaleWaveFreq + u_time * uGeneralGrayscaleWaveSpeed) * 0.5 + 0.5) * uGeneralGrayscaleIntensity;
+    } else if (uGeneralGrayscaleMode < 2.5) {
+      // Mode 2: Pulse
+      grayscaleFactor = (sin(u_time * uGeneralGrayscalePulseSpeed) * 0.5 + 0.5) * uGeneralGrayscaleIntensity;
+    } else {
+      // Mode 3: Ripple
+      vec2 rippleCenter = vec2(uGeneralGrayscaleRippleCenterX, uGeneralGrayscaleRippleCenterY);
+      float rippleDist = distance(fragPos, rippleCenter);
+      grayscaleFactor = (sin(rippleDist * 5.0 - u_time * uGeneralGrayscaleRippleSpeed) * 0.5 + 0.5) * uGeneralGrayscaleIntensity;
+    }
+    
+    float gray = rgbToGrayscale(color);
+    gray = adjustGrayscale(gray, uGeneralGrayscaleContrast, uGeneralGrayscaleBrightness);
+    vec3 grayscaleColor = vec3(gray);
+    return mix(color, grayscaleColor, grayscaleFactor);
+  }
+  
+  // ============================================================================
+  // POINTER EFFECTS (Interactive, based on pointer position)
+  // ============================================================================
+  
+  vec3 applyPointerGlow(vec3 color, vec2 fragPos, vec2 pointer) {
+    float falloff = getFragmentPointerFalloff(fragPos, pointer);
+    if (falloff > 0.0) {
+      color += uGlowColor * uGlowIntensity * falloff;
+    }
+    return color;
+  }
+  
+  vec3 applyPointerColorShift(vec3 color, vec2 fragPos, vec2 pointer) {
+    float falloff = getFragmentPointerFalloff(fragPos, pointer);
+    if (falloff > 0.0) {
+      color = mix(color, uColorShiftTarget, uColorShiftIntensity * falloff);
+    }
+    return color;
+  }
+  
+  vec3 applyPointerBrightness(vec3 color, vec2 fragPos, vec2 pointer) {
+    float falloff = getFragmentPointerFalloff(fragPos, pointer);
+    if (falloff > 0.0) {
+      color *= (1.0 + uBrightnessIntensity * falloff);
+    }
+    return color;
+  }
+  
+  vec3 applyPointerPulse(vec3 color, vec2 fragPos, vec2 pointer) {
+    float falloff = getFragmentPointerFalloff(fragPos, pointer);
+    if (falloff > 0.0) {
+      float pulse = sin(u_time * uPulseSpeed) * 0.5 + 0.5;
+      color += vec3(pulse * uPulseIntensity * falloff);
+    }
+    return color;
+  }
+  
+  vec3 applyPointerGrayscale(vec3 color, vec2 fragPos, vec2 pointer) {
+    float falloff = getFragmentPointerFalloff(fragPos, pointer);
+    if (falloff > 0.0) {
+      float gray = rgbToGrayscale(color);
+      gray = adjustGrayscale(gray, uPointerGrayscaleContrast, uPointerGrayscaleBrightness);
+      vec3 grayscaleColor = vec3(gray);
+      color = mix(color, grayscaleColor, uPointerGrayscaleIntensity * falloff);
+    }
+    return color;
+  }
+  
+  // ============================================================================
+  // APPLY ALL FRAGMENT EFFECTS
+  // ============================================================================
+  
+  vec3 applyAllFragmentEffects(vec3 color, vec2 fragPos, vec2 pointer) {
+    // Apply pointer effects first (interactive)
+    if (uGlowEnabled) {
+      color = applyPointerGlow(color, fragPos, pointer);
+    }
+    
+    if (uBrightnessEnabled) {
+      color = applyPointerBrightness(color, fragPos, pointer);
+    }
+    
+    if (uPulseEnabled) {
+      color = applyPointerPulse(color, fragPos, pointer);
+    }
+    
+    if (uColorShiftEnabled) {
+      color = applyPointerColorShift(color, fragPos, pointer);
+    }
+    
+    if (uPointerGrayscaleEnabled) {
+      color = applyPointerGrayscale(color, fragPos, pointer);
+    }
+    
+    // Apply general effects last (global, always active)
+    if (uGeneralGrayscaleEnabled) {
+      color = applyGeneralGrayscale(color, fragPos);
+    }
+    
+    return color;
+  }
+`;

package/dist/shaders/effects/EffectsUniforms.d.ts

@@ -0,0 +1,230 @@
+import { Vector2, Color } from "three";
+export interface EffectsUniforms {
+    u_pointer: {
+        value: Vector2;
+    };
+    uPointerEffectRadius: {
+        value: number;
+    };
+    uGeneralWaveEnabled: {
+        value: boolean;
+    };
+    uGeneralWaveIntensity: {
+        value: number;
+    };
+    uGeneralWaveFrequency: {
+        value: number;
+    };
+    uGeneralWaveSpeed: {
+        value: number;
+    };
+    uGeneralWaveDirection: {
+        value: number;
+    };
+    uGeneralVortexEnabled: {
+        value: boolean;
+    };
+    uGeneralVortexIntensity: {
+        value: number;
+    };
+    uGeneralVortexSpeed: {
+        value: number;
+    };
+    uGeneralVortexCenterX: {
+        value: number;
+    };
+    uGeneralVortexCenterY: {
+        value: number;
+    };
+    uGeneralRippleEnabled: {
+        value: boolean;
+    };
+    uGeneralRippleIntensity: {
+        value: number;
+    };
+    uGeneralRippleSpeed: {
+        value: number;
+    };
+    uGeneralRippleFrequency: {
+        value: number;
+    };
+    uGeneralRippleCenterX: {
+        value: number;
+    };
+    uGeneralRippleCenterY: {
+        value: number;
+    };
+    uRippleEnabled: {
+        value: boolean;
+    };
+    uRippleIntensity: {
+        value: number;
+    };
+    uRippleSpeed: {
+        value: number;
+    };
+    uDisplacementEnabled: {
+        value: boolean;
+    };
+    uDisplacementIntensity: {
+        value: number;
+    };
+    uVortexEnabled: {
+        value: boolean;
+    };
+    uVortexIntensity: {
+        value: number;
+    };
+    uVortexSpeed: {
+        value: number;
+    };
+    uWaveEnabled: {
+        value: boolean;
+    };
+    uWaveIntensity: {
+        value: number;
+    };
+    uWaveFrequency: {
+        value: number;
+    };
+    uGeneralGrayscaleEnabled: {
+        value: boolean;
+    };
+    uGeneralGrayscaleMode: {
+        value: number;
+    };
+    uGeneralGrayscaleIntensity: {
+        value: number;
+    };
+    uGeneralGrayscaleContrast: {
+        value: number;
+    };
+    uGeneralGrayscaleBrightness: {
+        value: number;
+    };
+    uGeneralGrayscaleWaveFreq: {
+        value: number;
+    };
+    uGeneralGrayscaleWaveSpeed: {
+        value: number;
+    };
+    uGeneralGrayscaleWaveDir: {
+        value: number;
+    };
+    uGeneralGrayscalePulseSpeed: {
+        value: number;
+    };
+    uGeneralGrayscaleRippleSpeed: {
+        value: number;
+    };
+    uGeneralGrayscaleRippleCenterX: {
+        value: number;
+    };
+    uGeneralGrayscaleRippleCenterY: {
+        value: number;
+    };
+    uGlowEnabled: {
+        value: boolean;
+    };
+    uGlowIntensity: {
+        value: number;
+    };
+    uGlowColor: {
+        value: Color;
+    };
+    uColorShiftEnabled: {
+        value: boolean;
+    };
+    uColorShiftIntensity: {
+        value: number;
+    };
+    uColorShiftTarget: {
+        value: Color;
+    };
+    uBrightnessEnabled: {
+        value: boolean;
+    };
+    uBrightnessIntensity: {
+        value: number;
+    };
+    uPulseEnabled: {
+        value: boolean;
+    };
+    uPulseIntensity: {
+        value: number;
+    };
+    uPulseSpeed: {
+        value: number;
+    };
+    uPointerGrayscaleEnabled: {
+        value: boolean;
+    };
+    uPointerGrayscaleIntensity: {
+        value: number;
+    };
+    uPointerGrayscaleContrast: {
+        value: number;
+    };
+    uPointerGrayscaleBrightness: {
+        value: number;
+    };
+}
+export declare const effectsUniforms: {
+    u_pointer: Vector2;
+    uPointerEffectRadius: number;
+    uGeneralWaveEnabled: boolean;
+    uGeneralWaveIntensity: number;
+    uGeneralWaveFrequency: number;
+    uGeneralWaveSpeed: number;
+    uGeneralWaveDirection: number;
+    uGeneralVortexEnabled: boolean;
+    uGeneralVortexIntensity: number;
+    uGeneralVortexSpeed: number;
+    uGeneralVortexCenterX: number;
+    uGeneralVortexCenterY: number;
+    uGeneralRippleEnabled: boolean;
+    uGeneralRippleIntensity: number;
+    uGeneralRippleSpeed: number;
+    uGeneralRippleFrequency: number;
+    uGeneralRippleCenterX: number;
+    uGeneralRippleCenterY: number;
+    uRippleEnabled: boolean;
+    uRippleIntensity: number;
+    uRippleSpeed: number;
+    uDisplacementEnabled: boolean;
+    uDisplacementIntensity: number;
+    uVortexEnabled: boolean;
+    uVortexIntensity: number;
+    uVortexSpeed: number;
+    uWaveEnabled: boolean;
+    uWaveIntensity: number;
+    uWaveFrequency: number;
+    uGeneralGrayscaleEnabled: boolean;
+    uGeneralGrayscaleMode: number;
+    uGeneralGrayscaleIntensity: number;
+    uGeneralGrayscaleContrast: number;
+    uGeneralGrayscaleBrightness: number;
+    uGeneralGrayscaleWaveFreq: number;
+    uGeneralGrayscaleWaveSpeed: number;
+    uGeneralGrayscaleWaveDir: number;
+    uGeneralGrayscalePulseSpeed: number;
+    uGeneralGrayscaleRippleSpeed: number;
+    uGeneralGrayscaleRippleCenterX: number;
+    uGeneralGrayscaleRippleCenterY: number;
+    uGlowEnabled: boolean;
+    uGlowIntensity: number;
+    uGlowColor: Color;
+    uColorShiftEnabled: boolean;
+    uColorShiftIntensity: number;
+    uColorShiftTarget: Color;
+    uBrightnessEnabled: boolean;
+    uBrightnessIntensity: number;
+    uPulseEnabled: boolean;
+    uPulseIntensity: number;
+    uPulseSpeed: number;
+    uPointerGrayscaleEnabled: boolean;
+    uPointerGrayscaleIntensity: number;
+    uPointerGrayscaleContrast: number;
+    uPointerGrayscaleBrightness: number;
+};
+//# sourceMappingURL=EffectsUniforms.d.ts.map

package/dist/shaders/effects/EffectsUniforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectsUniforms.d.ts","sourceRoot":"","sources":["../../../src/shaders/effects/EffectsUniforms.ts"],"names":[],"mappings":"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"}

package/dist/shaders/effects/EffectsUniforms.js

@@ -0,0 +1,66 @@
+import { Vector2, Color } from "three";
+// Shared uniform definitions for all shader effects
+export const effectsUniforms = {
+    // Pointer tracking
+    u_pointer: new Vector2(0, 0),
+    // Pointer effects global settings
+    uPointerEffectRadius: 2.5,
+    // Vertex effects - General (always active when enabled)
+    uGeneralWaveEnabled: false,
+    uGeneralWaveIntensity: 0.3,
+    uGeneralWaveFrequency: 3.0,
+    uGeneralWaveSpeed: 1.0,
+    uGeneralWaveDirection: 0.0, // 0=horizontal, 1=vertical, 2=diagonal
+    uGeneralVortexEnabled: false,
+    uGeneralVortexIntensity: 0.5,
+    uGeneralVortexSpeed: 0.5,
+    uGeneralVortexCenterX: 0.0,
+    uGeneralVortexCenterY: 0.0,
+    uGeneralRippleEnabled: false,
+    uGeneralRippleIntensity: 0.3,
+    uGeneralRippleSpeed: 2.0,
+    uGeneralRippleFrequency: 5.0,
+    uGeneralRippleCenterX: 0.0,
+    uGeneralRippleCenterY: 0.0,
+    // Vertex effects - Pointer (interactive)
+    uRippleEnabled: false,
+    uRippleIntensity: 0.5,
+    uRippleSpeed: 2.0,
+    uDisplacementEnabled: false,
+    uDisplacementIntensity: 0.5,
+    uVortexEnabled: false,
+    uVortexIntensity: 0.5,
+    uVortexSpeed: 1.0,
+    uWaveEnabled: false,
+    uWaveIntensity: 0.5,
+    uWaveFrequency: 5.0,
+    // Fragment effects - General
+    uGeneralGrayscaleEnabled: false,
+    uGeneralGrayscaleMode: 0.0, // 0=static, 1=wave, 2=pulse, 3=ripple
+    uGeneralGrayscaleIntensity: 1.0,
+    uGeneralGrayscaleContrast: 1.0,
+    uGeneralGrayscaleBrightness: 0.0,
+    uGeneralGrayscaleWaveFreq: 3.0,
+    uGeneralGrayscaleWaveSpeed: 1.0,
+    uGeneralGrayscaleWaveDir: 0.0, // 0=horizontal, 1=vertical, 2=diagonal
+    uGeneralGrayscalePulseSpeed: 2.0,
+    uGeneralGrayscaleRippleSpeed: 2.0,
+    uGeneralGrayscaleRippleCenterX: 0.0,
+    uGeneralGrayscaleRippleCenterY: 0.0,
+    // Fragment effects - Pointer
+    uGlowEnabled: false,
+    uGlowIntensity: 0.5,
+    uGlowColor: new Color(1.0, 1.0, 1.0),
+    uColorShiftEnabled: false,
+    uColorShiftIntensity: 0.5,
+    uColorShiftTarget: new Color(1.0, 0.4, 0.0),
+    uBrightnessEnabled: false,
+    uBrightnessIntensity: 0.5,
+    uPulseEnabled: false,
+    uPulseIntensity: 0.5,
+    uPulseSpeed: 2.0,
+    uPointerGrayscaleEnabled: false,
+    uPointerGrayscaleIntensity: 1.0,
+    uPointerGrayscaleContrast: 1.0,
+    uPointerGrayscaleBrightness: 0.0,
+};

package/dist/shaders/effects/EffectsVertexFunctions.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const effectsVertexGLSL = "\n  // ============================================================================\n  // UNIFORMS - All effect uniforms\n  // ============================================================================\n  uniform float u_time;\n  uniform vec2 u_pointer;\n  uniform float uPointerEffectRadius;\n  \n  // General vortex effects\n  uniform bool uGeneralWaveEnabled;\n  uniform float uGeneralWaveIntensity;\n  uniform float uGeneralWaveFrequency;\n  uniform float uGeneralWaveSpeed;\n  uniform float uGeneralWaveDirection;\n  uniform bool uGeneralVortexEnabled;\n  uniform float uGeneralVortexIntensity;\n  uniform float uGeneralVortexSpeed;\n  uniform float uGeneralVortexCenterX;\n  uniform float uGeneralVortexCenterY;\n  uniform bool uGeneralRippleEnabled;\n  uniform float uGeneralRippleIntensity;\n  uniform float uGeneralRippleSpeed;\n  uniform float uGeneralRippleFrequency;\n  uniform float uGeneralRippleCenterX;\n  uniform float uGeneralRippleCenterY;\n  \n  // Pointer vortex effects\n  uniform bool uRippleEnabled;\n  uniform float uRippleIntensity;\n  uniform float uRippleSpeed;\n  uniform bool uDisplacementEnabled;\n  uniform float uDisplacementIntensity;\n  uniform bool uVortexEnabled;\n  uniform float uVortexIntensity;\n  uniform float uVortexSpeed;\n  uniform bool uWaveEnabled;\n  uniform float uWaveIntensity;\n  uniform float uWaveFrequency;\n  \n  // ============================================================================\n  // HELPER FUNCTIONS\n  // ============================================================================\n  \n  // Calculate smooth falloff from pointer position\n  float getPointerFalloff(vec3 position, vec2 pointer) {\n    float dist = distance(position.xy, pointer);\n    return smoothstep(uPointerEffectRadius, 0.0, dist);\n  }\n  \n  // ============================================================================\n  // GENERAL EFFECTS (Always active when enabled)\n  // ============================================================================\n  \n  vec3 applyGeneralWave(vec3 pos) {\n    float waveInput = 0.0;\n    if (uGeneralWaveDirection < 0.5) {\n      // Horizontal\n      waveInput = pos.x;\n    } else if (uGeneralWaveDirection < 1.5) {\n      // Vertical\n      waveInput = pos.y;\n    } else {\n      // Diagonal\n      waveInput = pos.x + pos.y;\n    }\n    pos.z += sin(waveInput * uGeneralWaveFrequency + u_time * uGeneralWaveSpeed) * uGeneralWaveIntensity;\n    return pos;\n  }\n  \n  vec3 applyGeneralVortex(vec3 pos) {\n    vec2 center = vec2(uGeneralVortexCenterX, uGeneralVortexCenterY);\n    vec2 toCenter = pos.xy - center;\n    float angle = uGeneralVortexIntensity * u_time * uGeneralVortexSpeed;\n    mat2 rotation = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));\n    pos.xy = center + rotation * toCenter;\n    return pos;\n  }\n  \n  vec3 applyGeneralRipple(vec3 pos) {\n    vec2 center = vec2(uGeneralRippleCenterX, uGeneralRippleCenterY);\n    float rippleDist = distance(pos.xy, center);\n    float rippleWave = sin(rippleDist * uGeneralRippleFrequency - u_time * uGeneralRippleSpeed) * uGeneralRippleIntensity;\n    pos.z += rippleWave;\n    return pos;\n  }\n  \n  // ============================================================================\n  // POINTER EFFECTS (Interactive, based on pointer position)\n  // ============================================================================\n  \n  vec3 applyPointerRipple(vec3 pos, vec2 pointer) {\n    float falloff = getPointerFalloff(pos, pointer);\n    if (falloff > 0.0) {\n      float dist = distance(pos.xy, pointer);\n      float wave = sin(dist * 5.0 - u_time * uRippleSpeed) * uRippleIntensity;\n      pos.z += wave * falloff * 0.5;\n    }\n    return pos;\n  }\n  \n  vec3 applyPointerDisplacement(vec3 pos, vec2 pointer) {\n    float falloff = getPointerFalloff(pos, pointer);\n    if (falloff > 0.0) {\n      vec2 dir = normalize(pos.xy - pointer);\n      pos.xy += dir * uDisplacementIntensity * falloff * 2.0;\n    }\n    return pos;\n  }\n  \n  vec3 applyPointerVortex(vec3 pos, vec2 pointer) {\n    float falloff = getPointerFalloff(pos, pointer);\n    if (falloff > 0.0) {\n      vec2 toPointer = pos.xy - pointer;\n      float angle = uVortexIntensity * falloff * u_time * uVortexSpeed;\n      mat2 rotation = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));\n      pos.xy = pointer + rotation * toPointer;\n    }\n    return pos;\n  }\n  \n  vec3 applyPointerWave(vec3 pos, vec2 pointer) {\n    float falloff = getPointerFalloff(pos, pointer);\n    if (falloff > 0.0) {\n      pos.z += sin(pos.x * uWaveFrequency + u_time) * uWaveIntensity * falloff * 0.5;\n    }\n    return pos;\n  }\n  \n  // ============================================================================\n  // APPLY ALL VERTEX EFFECTS\n  // ============================================================================\n  \n  vec3 applyAllVertexEffects(vec3 pos, vec2 pointer) {\n    // Apply general effects first (global, always active)\n    if (uGeneralWaveEnabled) {\n      pos = applyGeneralWave(pos);\n    }\n    \n    if (uGeneralVortexEnabled) {\n      pos = applyGeneralVortex(pos);\n    }\n    \n    if (uGeneralRippleEnabled) {\n      pos = applyGeneralRipple(pos);\n    }\n    \n    // Apply pointer effects (interactive)\n    if (uRippleEnabled) {\n      pos = applyPointerRipple(pos, pointer);\n    }\n    \n    if (uDisplacementEnabled) {\n      pos = applyPointerDisplacement(pos, pointer);\n    }\n    \n    if (uVortexEnabled) {\n      pos = applyPointerVortex(pos, pointer);\n    }\n    \n    if (uWaveEnabled) {\n      pos = applyPointerWave(pos, pointer);\n    }\n    \n    return pos;\n  }\n";
+//# sourceMappingURL=EffectsVertexFunctions.glsl.d.ts.map

package/dist/shaders/effects/EffectsVertexFunctions.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectsVertexFunctions.glsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/effects/EffectsVertexFunctions.glsl.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,iBAAiB,kiLAqK7B,CAAC"}

package/dist/shaders/effects/EffectsVertexFunctions.glsl.js

@@ -0,0 +1,167 @@
+// Shared vortex shader functions for all shader effects
+export const effectsVertexGLSL = /*glsl*/ `
+  // ============================================================================
+  // UNIFORMS - All effect uniforms
+  // ============================================================================
+  uniform float u_time;
+  uniform vec2 u_pointer;
+  uniform float uPointerEffectRadius;
+  
+  // General vortex effects
+  uniform bool uGeneralWaveEnabled;
+  uniform float uGeneralWaveIntensity;
+  uniform float uGeneralWaveFrequency;
+  uniform float uGeneralWaveSpeed;
+  uniform float uGeneralWaveDirection;
+  uniform bool uGeneralVortexEnabled;
+  uniform float uGeneralVortexIntensity;
+  uniform float uGeneralVortexSpeed;
+  uniform float uGeneralVortexCenterX;
+  uniform float uGeneralVortexCenterY;
+  uniform bool uGeneralRippleEnabled;
+  uniform float uGeneralRippleIntensity;
+  uniform float uGeneralRippleSpeed;
+  uniform float uGeneralRippleFrequency;
+  uniform float uGeneralRippleCenterX;
+  uniform float uGeneralRippleCenterY;
+  
+  // Pointer vortex effects
+  uniform bool uRippleEnabled;
+  uniform float uRippleIntensity;
+  uniform float uRippleSpeed;
+  uniform bool uDisplacementEnabled;
+  uniform float uDisplacementIntensity;
+  uniform bool uVortexEnabled;
+  uniform float uVortexIntensity;
+  uniform float uVortexSpeed;
+  uniform bool uWaveEnabled;
+  uniform float uWaveIntensity;
+  uniform float uWaveFrequency;
+  
+  // ============================================================================
+  // HELPER FUNCTIONS
+  // ============================================================================
+  
+  // Calculate smooth falloff from pointer position
+  float getPointerFalloff(vec3 position, vec2 pointer) {
+    float dist = distance(position.xy, pointer);
+    return smoothstep(uPointerEffectRadius, 0.0, dist);
+  }
+  
+  // ============================================================================
+  // GENERAL EFFECTS (Always active when enabled)
+  // ============================================================================
+  
+  vec3 applyGeneralWave(vec3 pos) {
+    float waveInput = 0.0;
+    if (uGeneralWaveDirection < 0.5) {
+      // Horizontal
+      waveInput = pos.x;
+    } else if (uGeneralWaveDirection < 1.5) {
+      // Vertical
+      waveInput = pos.y;
+    } else {
+      // Diagonal
+      waveInput = pos.x + pos.y;
+    }
+    pos.z += sin(waveInput * uGeneralWaveFrequency + u_time * uGeneralWaveSpeed) * uGeneralWaveIntensity;
+    return pos;
+  }
+  
+  vec3 applyGeneralVortex(vec3 pos) {
+    vec2 center = vec2(uGeneralVortexCenterX, uGeneralVortexCenterY);
+    vec2 toCenter = pos.xy - center;
+    float angle = uGeneralVortexIntensity * u_time * uGeneralVortexSpeed;
+    mat2 rotation = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));
+    pos.xy = center + rotation * toCenter;
+    return pos;
+  }
+  
+  vec3 applyGeneralRipple(vec3 pos) {
+    vec2 center = vec2(uGeneralRippleCenterX, uGeneralRippleCenterY);
+    float rippleDist = distance(pos.xy, center);
+    float rippleWave = sin(rippleDist * uGeneralRippleFrequency - u_time * uGeneralRippleSpeed) * uGeneralRippleIntensity;
+    pos.z += rippleWave;
+    return pos;
+  }
+  
+  // ============================================================================
+  // POINTER EFFECTS (Interactive, based on pointer position)
+  // ============================================================================
+  
+  vec3 applyPointerRipple(vec3 pos, vec2 pointer) {
+    float falloff = getPointerFalloff(pos, pointer);
+    if (falloff > 0.0) {
+      float dist = distance(pos.xy, pointer);
+      float wave = sin(dist * 5.0 - u_time * uRippleSpeed) * uRippleIntensity;
+      pos.z += wave * falloff * 0.5;
+    }
+    return pos;
+  }
+  
+  vec3 applyPointerDisplacement(vec3 pos, vec2 pointer) {
+    float falloff = getPointerFalloff(pos, pointer);
+    if (falloff > 0.0) {
+      vec2 dir = normalize(pos.xy - pointer);
+      pos.xy += dir * uDisplacementIntensity * falloff * 2.0;
+    }
+    return pos;
+  }
+  
+  vec3 applyPointerVortex(vec3 pos, vec2 pointer) {
+    float falloff = getPointerFalloff(pos, pointer);
+    if (falloff > 0.0) {
+      vec2 toPointer = pos.xy - pointer;
+      float angle = uVortexIntensity * falloff * u_time * uVortexSpeed;
+      mat2 rotation = mat2(cos(angle), -sin(angle), sin(angle), cos(angle));
+      pos.xy = pointer + rotation * toPointer;
+    }
+    return pos;
+  }
+  
+  vec3 applyPointerWave(vec3 pos, vec2 pointer) {
+    float falloff = getPointerFalloff(pos, pointer);
+    if (falloff > 0.0) {
+      pos.z += sin(pos.x * uWaveFrequency + u_time) * uWaveIntensity * falloff * 0.5;
+    }
+    return pos;
+  }
+  
+  // ============================================================================
+  // APPLY ALL VERTEX EFFECTS
+  // ============================================================================
+  
+  vec3 applyAllVertexEffects(vec3 pos, vec2 pointer) {
+    // Apply general effects first (global, always active)
+    if (uGeneralWaveEnabled) {
+      pos = applyGeneralWave(pos);
+    }
+    
+    if (uGeneralVortexEnabled) {
+      pos = applyGeneralVortex(pos);
+    }
+    
+    if (uGeneralRippleEnabled) {
+      pos = applyGeneralRipple(pos);
+    }
+    
+    // Apply pointer effects (interactive)
+    if (uRippleEnabled) {
+      pos = applyPointerRipple(pos, pointer);
+    }
+    
+    if (uDisplacementEnabled) {
+      pos = applyPointerDisplacement(pos, pointer);
+    }
+    
+    if (uVortexEnabled) {
+      pos = applyPointerVortex(pos, pointer);
+    }
+    
+    if (uWaveEnabled) {
+      pos = applyPointerWave(pos, pointer);
+    }
+    
+    return pos;
+  }
+`;

package/dist/shaders/effects/baseFragment.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const baseFragmentTemplate = "\nprecision highp float;\n\nuniform sampler2D uTexture;\nuniform sampler2D uTargetTexture;\nuniform bool uHasTexture;\nuniform vec3 uColor;\nuniform float uOpacity;\nuniform float uTextureMorph;\nuniform float u_time;\nuniform vec2 u_pointer;\nuniform float uPointerEffectRadius;\nuniform float uParticleUVScale;\n\nvarying vec2 vTexCoords;\nvarying vec2 vUV;\nvarying vec2 vScreenPosition;\nvarying float vPointerFalloff;\n\n// __EFFECT_HELPERS__\n// __EFFECT_UNIFORMS__\n\nfloat circle(vec2 uv, float border) {\n  float radius = 0.5;\n  float dist = radius - distance(uv, vec2(0.5));\n  return smoothstep(0.0, border, dist);\n}\n\nvoid main() {\n  vec4 outColor;\n\n  if (uHasTexture) {\n    vec2 scaledUV = gl_PointCoord * uParticleUVScale;\n    scaledUV.y *= -1.0;\n    scaledUV += vUV;\n    vec4 colorA = texture2D(uTexture, scaledUV) * vec4(uColor, 1.0);\n    vec4 colorB = texture2D(uTargetTexture, scaledUV) * vec4(uColor, 1.0);\n    outColor = mix(colorA, colorB, uTextureMorph);\n  } else {\n    outColor = vec4(uColor, 1.0);\n  }\n\n  outColor.a *= circle(gl_PointCoord, 0.2);\n\n  float falloff = vPointerFalloff;\n\n  // __EFFECT_FRAGMENT_BODY__\n\n  outColor.a *= uOpacity;\n\n  gl_FragColor = outColor;\n}\n";
+//# sourceMappingURL=baseFragment.glsl.d.ts.map

package/dist/shaders/effects/baseFragment.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseFragment.glsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/effects/baseFragment.glsl.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,2sCAoDhC,CAAC"}