@ntalmagor/3drize-viewer 0.1.2

package/dist/shaders/ShaderEffectsMaterial.d.ts

@@ -0,0 +1,279 @@
+import { Vector2, Texture, Color } from 'three';
+export interface ShaderEffectsMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_pointer: {
+        value: Vector2;
+    };
+    uPointSize: {
+        value: number;
+    };
+    uTexture: {
+        value: Texture | null;
+    };
+    uTargetTexture: {
+        value: Texture | null;
+    };
+    uMorphProgress: {
+        value: number;
+    };
+    uColor: {
+        value: Color;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uPointerEffectRadius: {
+        value: number;
+    };
+    uNormalizationScale: {
+        value: number;
+    };
+    uRippleEnabled: {
+        value: boolean;
+    };
+    uRippleIntensity: {
+        value: number;
+    };
+    uRippleSpeed: {
+        value: number;
+    };
+    uDisplacementEnabled: {
+        value: boolean;
+    };
+    uDisplacementIntensity: {
+        value: number;
+    };
+    uScaleEnabled: {
+        value: boolean;
+    };
+    uScaleIntensity: {
+        value: number;
+    };
+    uMinScale: {
+        value: number;
+    };
+    uMaxScale: {
+        value: number;
+    };
+    uVortexEnabled: {
+        value: boolean;
+    };
+    uVortexIntensity: {
+        value: number;
+    };
+    uVortexSpeed: {
+        value: number;
+    };
+    uWaveEnabled: {
+        value: boolean;
+    };
+    uWaveIntensity: {
+        value: number;
+    };
+    uWaveFrequency: {
+        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;
+    };
+    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;
+    };
+    uGeneralRippleCenterX: {
+        value: number;
+    };
+    uGeneralRippleCenterY: {
+        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;
+    };
+    uPointerGrayscaleEnabled: {
+        value: boolean;
+    };
+    uPointerGrayscaleIntensity: {
+        value: number;
+    };
+    uPointerGrayscaleContrast: {
+        value: number;
+    };
+    uPointerGrayscaleBrightness: {
+        value: number;
+    };
+}
+declare const ShaderEffectsMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    uTexture: Texture | null;
+    uTargetTexture: Texture | null;
+    uHasTexture: false;
+    uPointSize: number;
+    u_pointer: Vector2;
+    uColor: Color;
+    uMorphProgress: number;
+    uNormalizationScale: number;
+    uOpacity: number;
+    uParticleUVScale: 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;
+    uWaveEnabled: false;
+    uWaveIntensity: number;
+    uWaveFrequency: number;
+    uGlowEnabled: false;
+    uGlowIntensity: number;
+    uGlowColor: Color;
+    uColorShiftEnabled: false;
+    uColorShiftIntensity: number;
+    uColorShiftTarget: Color;
+    uBrightnessEnabled: false;
+    uBrightnessIntensity: number;
+    uPulseEnabled: false;
+    uPulseIntensity: number;
+    uPulseSpeed: 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;
+    uGeneralGrayscaleEnabled: false;
+    uGeneralGrayscaleMode: number;
+    uGeneralGrayscaleIntensity: number;
+    uGeneralGrayscaleContrast: number;
+    uGeneralGrayscaleBrightness: number;
+    uGeneralGrayscaleWaveFreq: number;
+    uGeneralGrayscaleWaveSpeed: number;
+    uGeneralGrayscaleWaveDir: number;
+    uGeneralGrayscalePulseSpeed: number;
+    uGeneralGrayscaleRippleSpeed: number;
+    uGeneralGrayscaleRippleCenterX: number;
+    uGeneralGrayscaleRippleCenterY: number;
+    uPointerGrayscaleEnabled: false;
+    uPointerGrayscaleIntensity: number;
+    uPointerGrayscaleContrast: number;
+    uPointerGrayscaleBrightness: number;
+}> & {
+    key: string;
+};
+export { ShaderEffectsMaterial };
+//# sourceMappingURL=ShaderEffectsMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderEffectsMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/ShaderEffectsMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAKhD,MAAM,WAAW,6BAA6B;IAC5C,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1B,SAAS,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IAC9B,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9B,QAAQ,EAAE;QAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAA;KAAE,CAAC;IACpC,cAAc,EAAE;QAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAA;KAAE,CAAC;IAC1C,cAAc,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAClC,MAAM,EAAE;QAAE,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC;IACzB,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5B,oBAAoB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,mBAAmB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACvC,cAAc,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IACnC,gBAAgB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACpC,YAAY,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAChC,oBAAoB,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IACzC,sBAAsB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,aAAa,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IAClC,eAAe,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,SAAS,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7B,SAAS,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7B,cAAc,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IACnC,gBAAgB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACpC,YAAY,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAChC,YAAY,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IACjC,cAAc,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAClC,cAAc,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAClC,YAAY,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IACjC,cAAc,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAClC,UAAU,EAAE;QAAE,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC;IAC7B,kBAAkB,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IACvC,oBAAoB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,iBAAiB,EAAE;QAAE,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC;IACpC,kBAAkB,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IACvC,oBAAoB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,aAAa,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IAClC,eAAe,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,WAAW,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/B,mBAAmB,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IACxC,qBAAqB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,qBAAqB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,iBAAiB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACrC,qBAAqB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,qBAAqB,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IAC1C,uBAAuB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,mBAAmB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACvC,qBAAqB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,qBAAqB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,qBAAqB,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IAC1C,uBAAuB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,mBAAmB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACvC,qBAAqB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,qBAAqB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,wBAAwB,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IAC7C,qBAAqB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,0BAA0B,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9C,yBAAyB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C,2BAA2B,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/C,yBAAyB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C,0BAA0B,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9C,wBAAwB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5C,2BAA2B,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/C,4BAA4B,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAChD,8BAA8B,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAClD,8BAA8B,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAClD,wBAAwB,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IAC7C,0BAA0B,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9C,yBAAyB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C,2BAA2B,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAChD;AAwLD,QAAA,MAAM,qBAAqB;;cAGL,OAAO,GAAG,IAAI;oBACR,OAAO,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsEzC,CAAC;AAIF,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/shaders/ShaderEffectsMaterial.js

@@ -0,0 +1,257 @@
+import { Vector2, Color } from 'three';
+import { extend } from '@react-three/fiber';
+import { shaderMaterial } from '@react-three/drei';
+import { effectsVertexGLSL } from './effects/EffectsVertexFunctions.glsl';
+const vertexShader = /*glsl*/ `
+${effectsVertexGLSL}
+
+uniform float uPointSize;
+varying vec2 vTexCoords;
+uniform float uMorphProgress;
+uniform float uNormalizationScale;
+uniform bool uScaleEnabled;
+uniform float uScaleIntensity;
+uniform float uMinScale;
+uniform float uMaxScale;
+attribute vec2 aUV;
+varying vec2 vUV;
+varying vec2 vScreenPosition;
+
+void main() {
+  vUV = aUV;
+  vec3 pos = position;
+  #include <begin_vertex>
+  vec3 morphedPos = mix(position, position, uMorphProgress);
+  vec2 rippleCenter = vec2(uGeneralRippleCenterX, uGeneralRippleCenterY);
+
+  if (uGeneralWaveEnabled) {
+    float waveInput = 0.0;
+    if (uGeneralWaveDirection < 0.5) { waveInput = morphedPos.x; }
+    else if (uGeneralWaveDirection < 1.5) { waveInput = morphedPos.y; }
+    else { waveInput = 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) {
+    float wave = sin(dist * 5.0 - u_time * uRippleSpeed) * uRippleIntensity;
+    morphedPos.z += wave * 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;
+  }
+  if (uWaveEnabled && falloff > 0.0) {
+    morphedPos.z += sin(morphedPos.x * uWaveFrequency + u_time) * uWaveIntensity * falloff * 0.5;
+  }
+
+  vTexCoords = morphedPos.xy;
+  transformed = morphedPos;
+  #include <project_vertex>
+
+  float sizeMultiplier = 1.0;
+  if (uScaleEnabled && falloff > 0.0) {
+    sizeMultiplier = mix(uMinScale, uMaxScale, falloff * uScaleIntensity);
+  }
+  gl_PointSize = uPointSize * sizeMultiplier;
+  vScreenPosition = gl_Position.xy / gl_Position.w;
+  #include <logdepthbuf_vertex>
+  #include <clipping_planes_vertex>
+  #include <worldpos_vertex>
+  #include <fog_vertex>
+}
+`;
+const fragmentShader = /*glsl*/ `
+uniform sampler2D uTexture;
+uniform sampler2D uTargetTexture;
+uniform bool uHasTexture;
+uniform vec3 uColor;
+uniform float uOpacity;
+varying vec2 vTexCoords;
+varying vec2 vUV;
+uniform float uMorphProgress;
+uniform float u_time;
+uniform float uParticleUVScale;
+uniform vec2 u_pointer;
+uniform float uPointerEffectRadius;
+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 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;
+uniform bool uPointerGrayscaleEnabled;
+uniform float uPointerGrayscaleIntensity;
+uniform float uPointerGrayscaleContrast;
+uniform float uPointerGrayscaleBrightness;
+varying vec2 vScreenPosition;
+
+float circle(vec2 uv, float border) {
+  float radius = 0.5;
+  float dist = radius - distance(uv, vec2(0.5));
+  return smoothstep(0.0, border, dist);
+}
+
+void main() {
+  vec4 outColor;
+  if (uHasTexture) {
+    vec2 scaledUV = gl_PointCoord * uParticleUVScale;
+    scaledUV.y *= -1.0;
+    scaledUV += vUV;
+    vec4 colorA = texture2D(uTexture, scaledUV) * vec4(uColor, 1.0);
+    vec4 colorB = texture2D(uTargetTexture, scaledUV) * vec4(uColor, 1.0);
+    outColor = mix(colorA, colorB, uMorphProgress);
+  } else {
+    outColor = vec4(uColor, 1.0);
+  }
+
+  outColor.a *= circle(gl_PointCoord, 0.2);
+
+  vec2 scaledPointer = u_pointer * 5.0;
+  float dist = distance(vTexCoords, scaledPointer);
+  float falloff = smoothstep(uPointerEffectRadius, 0.0, dist);
+
+  if (uGlowEnabled && falloff > 0.0) outColor.rgb += uGlowColor * uGlowIntensity * falloff;
+  if (uBrightnessEnabled && falloff > 0.0) outColor.rgb *= (1.0 + uBrightnessIntensity * falloff);
+  if (uPulseEnabled && falloff > 0.0) {
+    float pulse = sin(u_time * uPulseSpeed) * 0.5 + 0.5;
+    outColor.rgb += vec3(pulse * uPulseIntensity * falloff);
+  }
+  if (uColorShiftEnabled && falloff > 0.0) outColor.rgb = mix(outColor.rgb, uColorShiftTarget, uColorShiftIntensity * falloff);
+  if (uPointerGrayscaleEnabled && falloff > 0.0) {
+    float gray = dot(outColor.rgb, vec3(0.299, 0.587, 0.114));
+    gray = (gray - 0.5) * uPointerGrayscaleContrast + 0.5 + uPointerGrayscaleBrightness;
+    outColor.rgb = mix(outColor.rgb, vec3(gray), uPointerGrayscaleIntensity * falloff);
+  }
+  if (uGeneralGrayscaleEnabled) {
+    float grayscaleFactor = 0.0;
+    if (uGeneralGrayscaleMode < 0.5) {
+      grayscaleFactor = uGeneralGrayscaleIntensity;
+    } else if (uGeneralGrayscaleMode < 1.5) {
+      float wavePos = uGeneralGrayscaleWaveDir < 0.5 ? vTexCoords.x : (uGeneralGrayscaleWaveDir < 1.5 ? vTexCoords.y : vTexCoords.x + vTexCoords.y);
+      grayscaleFactor = (sin(wavePos * uGeneralGrayscaleWaveFreq + u_time * uGeneralGrayscaleWaveSpeed) * 0.5 + 0.5) * uGeneralGrayscaleIntensity;
+    } else if (uGeneralGrayscaleMode < 2.5) {
+      grayscaleFactor = (sin(u_time * uGeneralGrayscalePulseSpeed) * 0.5 + 0.5) * uGeneralGrayscaleIntensity;
+    } else {
+      vec2 rippleCenter = vec2(uGeneralGrayscaleRippleCenterX, uGeneralGrayscaleRippleCenterY);
+      float rippleDist = distance(vTexCoords, rippleCenter);
+      grayscaleFactor = (sin(rippleDist * 5.0 - u_time * uGeneralGrayscaleRippleSpeed) * 0.5 + 0.5) * uGeneralGrayscaleIntensity;
+    }
+    float gray = dot(outColor.rgb, vec3(0.299, 0.587, 0.114));
+    gray = (gray - 0.5) * uGeneralGrayscaleContrast + 0.5 + uGeneralGrayscaleBrightness;
+    outColor.rgb = mix(outColor.rgb, vec3(gray), grayscaleFactor);
+  }
+
+  outColor.a *= uOpacity;
+  gl_FragColor = outColor;
+}
+`;
+const ShaderEffectsMaterial = shaderMaterial({
+    u_time: 0,
+    uTexture: null,
+    uTargetTexture: null,
+    uHasTexture: false,
+    uPointSize: 1.0,
+    u_pointer: new Vector2(),
+    uColor: new Color(1.0, 1.0, 1.0),
+    uMorphProgress: 0.0,
+    uNormalizationScale: 1.0,
+    uOpacity: 1.0,
+    uParticleUVScale: 0.01,
+    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,
+    uWaveEnabled: false,
+    uWaveIntensity: 0.5,
+    uWaveFrequency: 5.0,
+    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,
+    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,
+    uGeneralGrayscaleEnabled: false,
+    uGeneralGrayscaleMode: 0.0,
+    uGeneralGrayscaleIntensity: 1.0,
+    uGeneralGrayscaleContrast: 1.0,
+    uGeneralGrayscaleBrightness: 0.0,
+    uGeneralGrayscaleWaveFreq: 3.0,
+    uGeneralGrayscaleWaveSpeed: 1.0,
+    uGeneralGrayscaleWaveDir: 0.0,
+    uGeneralGrayscalePulseSpeed: 2.0,
+    uGeneralGrayscaleRippleSpeed: 2.0,
+    uGeneralGrayscaleRippleCenterX: 0.0,
+    uGeneralGrayscaleRippleCenterY: 0.0,
+    uPointerGrayscaleEnabled: false,
+    uPointerGrayscaleIntensity: 1.0,
+    uPointerGrayscaleContrast: 1.0,
+    uPointerGrayscaleBrightness: 0.0,
+}, vertexShader, fragmentShader);
+extend({ ShaderEffectsMaterial });
+export { ShaderEffectsMaterial };

package/dist/shaders/ShootingStarMaterial.d.ts

@@ -0,0 +1,14 @@
+import { Color } from 'three';
+declare const ShootingStarMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    color: Color;
+    opacity: number;
+}> & {
+    key: string;
+};
+export { ShootingStarMaterial };
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        shootingStarMaterial: any;
+    }
+}
+//# sourceMappingURL=ShootingStarMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ShootingStarMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/ShootingStarMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AA8B9B,QAAA,MAAM,oBAAoB;;;;;CAOzB,CAAC;AAIF,OAAO,EAAE,oBAAoB,EAAE,CAAC;AAEhC,OAAO,QAAQ,oBAAoB,CAAC;IAClC,UAAU,aAAa;QACrB,oBAAoB,EAAE,GAAG,CAAC;KAC3B;CACF"}

package/dist/shaders/ShootingStarMaterial.js

@@ -0,0 +1,33 @@
+import { Color } from 'three';
+import { extend } from '@react-three/fiber';
+import { shaderMaterial } from '@react-three/drei';
+const vertexShader = /*glsl*/ `
+  varying vec2 vUv;
+  varying float vProgress;
+  attribute float progress;
+
+  void main() {
+    vUv = uv;
+    vProgress = progress;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const fragmentShader = /*glsl*/ `
+  uniform vec3 color;
+  uniform float opacity;
+  varying vec2 vUv;
+  varying float vProgress;
+
+  void main() {
+    float alpha = opacity * (1.0 - vProgress) * (1.0 - vProgress);
+    float glow = 1.0 - vProgress;
+    vec3 glowColor = color * (1.0 + glow * 0.5);
+    gl_FragColor = vec4(glowColor, alpha);
+  }
+`;
+const ShootingStarMaterial = shaderMaterial({
+    color: new Color(1.0, 1.0, 1.0),
+    opacity: 1.0,
+}, vertexShader, fragmentShader);
+extend({ ShootingStarMaterial });
+export { ShootingStarMaterial };

package/dist/shaders/SkyboxMaterial.d.ts

@@ -0,0 +1,38 @@
+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 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 };
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        skyboxMaterial: any;
+    }
+}
+//# 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;AAI9B,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/B,aAAa,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACjC,SAAS,EAAE;QAAE,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC;IAC5B,YAAY,EAAE;QAAE,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC;IAC/B,aAAa,EAAE;QAAE,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC;IAChC,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAC7B;AAgDD,QAAA,MAAM,cAAc;;;;;;;;;CAWnB,CAAC;AAIF,OAAO,EAAE,cAAc,EAAE,CAAC;AAE1B,OAAO,QAAQ,oBAAoB,CAAC;IAClC,UAAU,aAAa;QACrB,cAAc,EAAE,GAAG,CAAC;KACrB;CACF"}

package/dist/shaders/SkyboxMaterial.js

@@ -0,0 +1,57 @@
+import { Color } from 'three';
+import { extend } from '@react-three/fiber';
+import { shaderMaterial } from '@react-three/drei';
+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;
+  }
+`;
+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);
+
+    vec3 skyColor = mix(uSkyColorLow, uSkyColorHigh, clamp(direction.y * 0.5 + 0.5, 0.0, 1.0));
+
+    float azimuth = radians(uSunAzimuth);
+    float elevation = radians(uSunElevation);
+    vec3 sunDirection = normalize(vec3(
+      cos(elevation) * sin(azimuth),
+      sin(elevation),
+      cos(elevation) * cos(azimuth)
+    ));
+
+    float sunIntensity = pow(max(dot(direction, sunDirection), 0.0), 1000.0 / uSunSize);
+    vec3 sunColor = uSunColor * sunIntensity;
+
+    gl_FragColor = vec4(skyColor + sunColor, 1.0);
+  }
+`;
+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({ SkyboxMaterial });
+export { SkyboxMaterial };