shaders-oneshot 0.0.81-shared.1

package/dist/shaders/static-mesh-gradient.js

@@ -0,0 +1,131 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ *                    Paper Shaders                    *
+ *       https://github.com/paper-design/shaders       *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+import {
+} from "../shader-sizing.js";
+import { declarePI, rotation2, proceduralHash21 } from "../shader-utils.js";
+const staticMeshGradientMeta = {
+  maxColorCount: 10
+};
+const staticMeshGradientFragmentShader = `#version 300 es
+precision mediump float;
+
+uniform vec4 u_colors[${staticMeshGradientMeta.maxColorCount}];
+uniform float u_colorsCount;
+
+uniform float u_positions;
+uniform float u_waveX;
+uniform float u_waveXShift;
+uniform float u_waveY;
+uniform float u_waveYShift;
+uniform float u_mixing;
+uniform float u_grainMixer;
+uniform float u_grainOverlay;
+
+in vec2 v_objectUV;
+out vec4 fragColor;
+
+${declarePI}
+${rotation2}
+${proceduralHash21}
+
+float valueNoise(vec2 st) {
+  vec2 i = floor(st);
+  vec2 f = fract(st);
+  float a = hash21(i);
+  float b = hash21(i + vec2(1.0, 0.0));
+  float c = hash21(i + vec2(0.0, 1.0));
+  float d = hash21(i + vec2(1.0, 1.0));
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  float x1 = mix(a, b, u.x);
+  float x2 = mix(c, d, u.x);
+  return mix(x1, x2, u.y);
+}
+
+float noise(vec2 n, vec2 seedOffset) {
+  return valueNoise(n + seedOffset);
+}
+
+vec2 getPosition(int i, float t) {
+  float a = float(i) * .37;
+  float b = .6 + mod(float(i), 3.) * .3;
+  float c = .8 + mod(float(i + 1), 4.) * 0.25;
+
+  float x = sin(t * b + a);
+  float y = cos(t * c + a * 1.5);
+
+  return .5 + .5 * vec2(x, y);
+}
+
+void main() {
+  vec2 uv = v_objectUV;
+  uv += .5;
+  vec2 grainUV = uv * 1000.;
+
+  float mixerGrain = 0.;
+  if (u_grainMixer > 0.) {
+    mixerGrain = .4 * u_grainMixer * (noise(grainUV, vec2(0.)) - .5);
+  }
+
+  float radius = smoothstep(0., 1., length(uv - .5));
+  float center = 1. - radius;
+  for (float i = 1.; i <= 2.; i++) {
+    uv.x += u_waveX * center / i * cos(TWO_PI * u_waveXShift + i * 2. * smoothstep(.0, 1., uv.y));
+    uv.y += u_waveY * center / i * cos(TWO_PI * u_waveYShift + i * 2. * smoothstep(.0, 1., uv.x));
+  }
+
+  vec3 color = vec3(0.);
+  float opacity = 0.;
+  float totalWeight = 0.;
+  float positionSeed = 25. + .33 * u_positions;
+
+  for (int i = 0; i < ${staticMeshGradientMeta.maxColorCount}; i++) {
+    if (i >= int(u_colorsCount)) break;
+
+    vec2 pos = getPosition(i, positionSeed) + mixerGrain;
+    float dist = length(uv - pos);
+
+    vec3 colorFraction = u_colors[i].rgb * u_colors[i].a;
+    float opacityFraction = u_colors[i].a;
+
+    float mixing = pow(u_mixing, .7);
+    float power = mix(2., 1., mixing);
+    dist = pow(dist, power);
+
+    float w = 1. / (dist + 1e-3);
+    float baseSharpness = mix(.0, 8., clamp(w, 0., 1.));
+    float sharpness = mix(baseSharpness, 1., mixing);
+    w = pow(w, sharpness);
+    color += colorFraction * w;
+    opacity += opacityFraction * w;
+    totalWeight += w;
+  }
+
+  color /= max(1e-4, totalWeight);
+  opacity /= max(1e-4, totalWeight);
+
+  if (u_grainOverlay > 0.) {
+    float grainOverlay = valueNoise(rotate(grainUV, 1.) + vec2(3.));
+    grainOverlay = mix(grainOverlay, valueNoise(rotate(grainUV, 2.) + vec2(-1.)), .5);
+    grainOverlay = pow(grainOverlay, 1.3);
+
+    float grainOverlayV = grainOverlay * 2. - 1.;
+    vec3 grainOverlayColor = vec3(step(0., grainOverlayV));
+    float grainOverlayStrength = u_grainOverlay * abs(grainOverlayV);
+    grainOverlayStrength = pow(grainOverlayStrength, .8);
+    color = mix(color, grainOverlayColor, .35 * grainOverlayStrength);
+
+    opacity += .5 * grainOverlayStrength;
+  }
+  opacity = clamp(opacity, 0., 1.);
+
+  fragColor = vec4(color, opacity);
+}
+`;
+export {
+  staticMeshGradientFragmentShader,
+  staticMeshGradientMeta
+};
+//# sourceMappingURL=static-mesh-gradient.js.map

package/dist/shaders/static-mesh-gradient.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/shaders/static-mesh-gradient.ts"],
+  "sourcesContent": ["import type { vec4 } from '../types.js';\r\nimport type { ShaderMotionParams } from '../shader-mount.js';\r\nimport {\r\n  type ShaderSizingParams,\r\n  type ShaderSizingUniforms,\r\n} from '../shader-sizing.js';\r\nimport { declarePI, rotation2, proceduralHash21 } from '../shader-utils.js';\r\n\r\nexport const staticMeshGradientMeta = {\r\n  maxColorCount: 10,\r\n} as const;\r\n\r\n/**\r\n * Multi-point mesh gradient with up to 10 color spots, enhanced by two-direction warping,\r\n * adjustable blend sharpness, and grain controls.\r\n *\r\n * Fragment shader uniforms:\r\n * - u_colors (vec4[]): Up to 10 gradient colors in RGBA\r\n * - u_colorsCount (float): Number of active colors\r\n * - u_positions (float): Color spots placement seed (0 to 100)\r\n * - u_waveX (float): Strength of sine wave distortion along X axis (0 to 1)\r\n * - u_waveXShift (float): Phase offset applied to the X-axis wave, needs waveX > 0 (0 to 1)\r\n * - u_waveY (float): Strength of sine wave distortion along Y axis (0 to 1)\r\n * - u_waveYShift (float): Phase offset applied to the Y-axis wave, needs waveY > 0 (0 to 1)\r\n * - u_mixing (float): Blending behavior, 0 = hard stripes, 0.5 = smooth, 1 = gradual blend (0 to 1)\r\n * - u_grainMixer (float): Strength of grain distortion applied to shape edges (0 to 1)\r\n * - u_grainOverlay (float): Post-processing black/white grain overlay (0 to 1)\r\n *\r\n * Vertex shader outputs (used in fragment shader):\r\n * - v_objectUV (vec2): Object box UV coordinates with global sizing (scale, rotation, offsets, etc) applied\r\n *\r\n * Vertex shader uniforms:\r\n * - u_resolution (vec2): Canvas resolution in pixels\r\n * - u_pixelRatio (float): Device pixel ratio\r\n * - u_originX (float): Reference point for positioning world width in the canvas (0 to 1)\r\n * - u_originY (float): Reference point for positioning world height in the canvas (0 to 1)\r\n * - u_worldWidth (float): Virtual width of the graphic before it's scaled to fit the canvas\r\n * - u_worldHeight (float): Virtual height of the graphic before it's scaled to fit the canvas\r\n * - u_fit (float): How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)\r\n * - u_scale (float): Overall zoom level of the graphics (0.01 to 4)\r\n * - u_rotation (float): Overall rotation angle of the graphics in degrees (0 to 360)\r\n * - u_offsetX (float): Horizontal offset of the graphics center (-1 to 1)\r\n * - u_offsetY (float): Vertical offset of the graphics center (-1 to 1)\r\n *\r\n */\r\n\r\n// language=GLSL\r\nexport const staticMeshGradientFragmentShader: string = `#version 300 es\r\nprecision mediump float;\r\n\r\nuniform vec4 u_colors[${ staticMeshGradientMeta.maxColorCount }];\r\nuniform float u_colorsCount;\r\n\r\nuniform float u_positions;\r\nuniform float u_waveX;\r\nuniform float u_waveXShift;\r\nuniform float u_waveY;\r\nuniform float u_waveYShift;\r\nuniform float u_mixing;\r\nuniform float u_grainMixer;\r\nuniform float u_grainOverlay;\r\n\r\nin vec2 v_objectUV;\r\nout vec4 fragColor;\r\n\r\n${ declarePI }\r\n${ rotation2 }\r\n${ proceduralHash21 }\r\n\r\nfloat valueNoise(vec2 st) {\r\n  vec2 i = floor(st);\r\n  vec2 f = fract(st);\r\n  float a = hash21(i);\r\n  float b = hash21(i + vec2(1.0, 0.0));\r\n  float c = hash21(i + vec2(0.0, 1.0));\r\n  float d = hash21(i + vec2(1.0, 1.0));\r\n  vec2 u = f * f * (3.0 - 2.0 * f);\r\n  float x1 = mix(a, b, u.x);\r\n  float x2 = mix(c, d, u.x);\r\n  return mix(x1, x2, u.y);\r\n}\r\n\r\nfloat noise(vec2 n, vec2 seedOffset) {\r\n  return valueNoise(n + seedOffset);\r\n}\r\n\r\nvec2 getPosition(int i, float t) {\r\n  float a = float(i) * .37;\r\n  float b = .6 + mod(float(i), 3.) * .3;\r\n  float c = .8 + mod(float(i + 1), 4.) * 0.25;\r\n\r\n  float x = sin(t * b + a);\r\n  float y = cos(t * c + a * 1.5);\r\n\r\n  return .5 + .5 * vec2(x, y);\r\n}\r\n\r\nvoid main() {\r\n  vec2 uv = v_objectUV;\r\n  uv += .5;\r\n  vec2 grainUV = uv * 1000.;\r\n\r\n  float mixerGrain = 0.;\r\n  if (u_grainMixer > 0.) {\r\n    mixerGrain = .4 * u_grainMixer * (noise(grainUV, vec2(0.)) - .5);\r\n  }\r\n\r\n  float radius = smoothstep(0., 1., length(uv - .5));\r\n  float center = 1. - radius;\r\n  for (float i = 1.; i <= 2.; i++) {\r\n    uv.x += u_waveX * center / i * cos(TWO_PI * u_waveXShift + i * 2. * smoothstep(.0, 1., uv.y));\r\n    uv.y += u_waveY * center / i * cos(TWO_PI * u_waveYShift + i * 2. * smoothstep(.0, 1., uv.x));\r\n  }\r\n\r\n  vec3 color = vec3(0.);\r\n  float opacity = 0.;\r\n  float totalWeight = 0.;\r\n  float positionSeed = 25. + .33 * u_positions;\r\n\r\n  for (int i = 0; i < ${ staticMeshGradientMeta.maxColorCount }; i++) {\r\n    if (i >= int(u_colorsCount)) break;\r\n\r\n    vec2 pos = getPosition(i, positionSeed) + mixerGrain;\r\n    float dist = length(uv - pos);\r\n\r\n    vec3 colorFraction = u_colors[i].rgb * u_colors[i].a;\r\n    float opacityFraction = u_colors[i].a;\r\n\r\n    float mixing = pow(u_mixing, .7);\r\n    float power = mix(2., 1., mixing);\r\n    dist = pow(dist, power);\r\n\r\n    float w = 1. / (dist + 1e-3);\r\n    float baseSharpness = mix(.0, 8., clamp(w, 0., 1.));\r\n    float sharpness = mix(baseSharpness, 1., mixing);\r\n    w = pow(w, sharpness);\r\n    color += colorFraction * w;\r\n    opacity += opacityFraction * w;\r\n    totalWeight += w;\r\n  }\r\n\r\n  color /= max(1e-4, totalWeight);\r\n  opacity /= max(1e-4, totalWeight);\r\n\r\n  if (u_grainOverlay > 0.) {\r\n    float grainOverlay = valueNoise(rotate(grainUV, 1.) + vec2(3.));\r\n    grainOverlay = mix(grainOverlay, valueNoise(rotate(grainUV, 2.) + vec2(-1.)), .5);\r\n    grainOverlay = pow(grainOverlay, 1.3);\r\n\r\n    float grainOverlayV = grainOverlay * 2. - 1.;\r\n    vec3 grainOverlayColor = vec3(step(0., grainOverlayV));\r\n    float grainOverlayStrength = u_grainOverlay * abs(grainOverlayV);\r\n    grainOverlayStrength = pow(grainOverlayStrength, .8);\r\n    color = mix(color, grainOverlayColor, .35 * grainOverlayStrength);\r\n\r\n    opacity += .5 * grainOverlayStrength;\r\n  }\r\n  opacity = clamp(opacity, 0., 1.);\r\n\r\n  fragColor = vec4(color, opacity);\r\n}\r\n`;\r\n\r\nexport interface StaticMeshGradientUniforms extends ShaderSizingUniforms {\r\n  u_colors: vec4[];\r\n  u_colorsCount: number;\r\n  u_positions: number;\r\n  u_waveX: number;\r\n  u_waveXShift: number;\r\n  u_waveY: number;\r\n  u_waveYShift: number;\r\n  u_mixing: number;\r\n  u_grainMixer: number;\r\n  u_grainOverlay: number;\r\n}\r\n\r\nexport interface StaticMeshGradientParams extends ShaderSizingParams, ShaderMotionParams {\r\n  colors?: string[];\r\n  positions?: number;\r\n  waveX?: number;\r\n  waveXShift?: number;\r\n  waveY?: number;\r\n  waveYShift?: number;\r\n  mixing?: number;\r\n  grainMixer?: number;\r\n  grainOverlay?: number;\r\n}\r\n"],
+  "mappings": ";;;;;AAEA;AAAA,OAGO;AACP,SAAS,WAAW,WAAW,wBAAwB;AAEhD,MAAM,yBAAyB;AAAA,EACpC,eAAe;AACjB;AAqCO,MAAM,mCAA2C;AAAA;AAAA;AAAA,wBAG/B,uBAAuB,aAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAe3D,SAAU;AAAA,EACV,SAAU;AAAA,EACV,gBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAoDK,uBAAuB,aAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/shaders/static-radial-gradient.d.ts

@@ -0,0 +1,72 @@
+import type { vec4 } from '../types.js';
+import type { ShaderMotionParams } from '../shader-mount.js';
+import { type ShaderSizingParams, type ShaderSizingUniforms } from '../shader-sizing.js';
+export declare const staticRadialGradientMeta: {
+    readonly maxColorCount: 10;
+};
+/**
+ * Radial gradient with up to 10 blended colors, featuring advanced mixing modes, focal point controls,
+ * shape distortion, and grain effects.
+ *
+ * Fragment shader uniforms:
+ * - u_colorBack (vec4): Background color in RGBA
+ * - u_colors (vec4[]): Up to 10 gradient colors in RGBA
+ * - u_colorsCount (float): Number of active colors
+ * - u_radius (float): Size of the shape (0 to 3)
+ * - u_focalDistance (float): Distance of the focal point from center (0 to 3)
+ * - u_focalAngle (float): Angle of the focal point in degrees, needs focalDistance > 0 (0 to 360)
+ * - u_falloff (float): Gradient decay, 0 = equal color distribution (-1 to 1)
+ * - u_mixing (float): Blending behavior, 0 = hard stripes, 1 = smooth gradient (0 to 1)
+ * - u_distortion (float): Strength of radial distortion (0 to 1)
+ * - u_distortionShift (float): Radial distortion offset, needs distortion > 0 (-1 to 1)
+ * - u_distortionFreq (float): Radial distortion frequency, needs distortion > 0 (0 to 20)
+ * - u_grainMixer (float): Strength of grain distortion applied to shape edges (0 to 1)
+ * - u_grainOverlay (float): Post-processing black/white grain overlay (0 to 1)
+ *
+ * Vertex shader outputs (used in fragment shader):
+ * - v_objectUV (vec2): Object box UV coordinates with global sizing (scale, rotation, offsets, etc) applied
+ *
+ * Vertex shader uniforms:
+ * - u_resolution (vec2): Canvas resolution in pixels
+ * - u_pixelRatio (float): Device pixel ratio
+ * - u_originX (float): Reference point for positioning world width in the canvas (0 to 1)
+ * - u_originY (float): Reference point for positioning world height in the canvas (0 to 1)
+ * - u_worldWidth (float): Virtual width of the graphic before it's scaled to fit the canvas
+ * - u_worldHeight (float): Virtual height of the graphic before it's scaled to fit the canvas
+ * - u_fit (float): How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)
+ * - u_scale (float): Overall zoom level of the graphics (0.01 to 4)
+ * - u_rotation (float): Overall rotation angle of the graphics in degrees (0 to 360)
+ * - u_offsetX (float): Horizontal offset of the graphics center (-1 to 1)
+ * - u_offsetY (float): Vertical offset of the graphics center (-1 to 1)
+ *
+ */
+export declare const staticRadialGradientFragmentShader: string;
+export interface StaticRadialGradientUniforms extends ShaderSizingUniforms {
+    u_colorBack: [number, number, number, number];
+    u_colors: vec4[];
+    u_colorsCount: number;
+    u_radius: number;
+    u_focalDistance: number;
+    u_focalAngle: number;
+    u_falloff: number;
+    u_mixing: number;
+    u_distortion: number;
+    u_distortionShift: number;
+    u_distortionFreq: number;
+    u_grainMixer: number;
+    u_grainOverlay: number;
+}
+export interface StaticRadialGradientParams extends ShaderSizingParams, ShaderMotionParams {
+    colorBack?: string;
+    colors?: string[];
+    radius?: number;
+    focalDistance?: number;
+    focalAngle?: number;
+    falloff?: number;
+    mixing?: number;
+    distortion?: number;
+    distortionShift?: number;
+    distortionFreq?: number;
+    grainMixer?: number;
+    grainOverlay?: number;
+}

package/dist/shaders/static-radial-gradient.js

@@ -0,0 +1,188 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ *                    Paper Shaders                    *
+ *       https://github.com/paper-design/shaders       *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+import {
+} from "../shader-sizing.js";
+import { declarePI, rotation2, proceduralHash21 } from "../shader-utils.js";
+const staticRadialGradientMeta = {
+  maxColorCount: 10
+};
+const staticRadialGradientFragmentShader = `#version 300 es
+precision mediump float;
+
+uniform vec4 u_colorBack;
+uniform vec4 u_colors[${staticRadialGradientMeta.maxColorCount}];
+uniform float u_colorsCount;
+
+uniform float u_radius;
+uniform float u_focalDistance;
+uniform float u_focalAngle;
+uniform float u_falloff;
+uniform float u_mixing;
+uniform float u_distortion;
+uniform float u_distortionShift;
+uniform float u_distortionFreq;
+uniform float u_grainMixer;
+uniform float u_grainOverlay;
+
+in vec2 v_objectUV;
+out vec4 fragColor;
+
+${declarePI}
+${rotation2}
+${proceduralHash21}
+
+float valueNoise(vec2 st) {
+  vec2 i = floor(st);
+  vec2 f = fract(st);
+  float a = hash21(i);
+  float b = hash21(i + vec2(1.0, 0.0));
+  float c = hash21(i + vec2(0.0, 1.0));
+  float d = hash21(i + vec2(1.0, 1.0));
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  float x1 = mix(a, b, u.x);
+  float x2 = mix(c, d, u.x);
+  return mix(x1, x2, u.y);
+}
+
+float noise(vec2 n, vec2 seedOffset) {
+  return valueNoise(n + seedOffset);
+}
+
+vec2 getPosition(int i, float t) {
+  float a = float(i) * .37;
+  float b = .6 + mod(float(i), 3.) * .3;
+  float c = .8 + mod(float(i + 1), 4.) * 0.25;
+
+  float x = sin(t * b + a);
+  float y = cos(t * c + a * 1.5);
+
+  return .5 + .5 * vec2(x, y);
+}
+
+void main() {
+  vec2 uv = 2. * v_objectUV;
+  vec2 grainUV = uv * 1000.;
+
+  vec2 center = vec2(0.);
+  float angleRad = -radians(u_focalAngle + 90.);
+  vec2 focalPoint = vec2(cos(angleRad), sin(angleRad)) * u_focalDistance;
+  float radius = u_radius;
+
+  vec2 c_to_uv = uv - center;
+  vec2 f_to_uv = uv - focalPoint;
+  vec2 f_to_c = center - focalPoint;
+  float r = length(c_to_uv);
+
+  float fragAngle = atan(c_to_uv.y, c_to_uv.x);
+  float angleDiff = fract((fragAngle - angleRad + PI) / TWO_PI) * TWO_PI - PI;
+
+  float halfAngle = acos(clamp(radius / max(u_focalDistance, 1e-4), 0.0, 1.0));
+  float e0 = 0.6 * PI, e1 = halfAngle;
+  float lo = min(e0, e1), hi = max(e0, e1);
+  float s  = smoothstep(lo, hi, abs(angleDiff));
+  float isInSector = (e1 >= e0) ? (1.0 - s) : s;
+
+  float a = dot(f_to_uv, f_to_uv);
+  float b = -2.0 * dot(f_to_uv, f_to_c);
+  float c = dot(f_to_c, f_to_c) - radius * radius;
+
+  float discriminant = b * b - 4.0 * a * c;
+  float t = 1.0;
+
+  if (discriminant >= 0.0) {
+    float sqrtD = sqrt(discriminant);
+    float div = max(1e-4, 2.0 * a);
+    float t0 = (-b - sqrtD) / div;
+    float t1 = (-b + sqrtD) / div;
+    t = max(t0, t1);
+    if (t < 0.0) t = 0.0;
+  }
+
+  float dist = length(f_to_uv);
+  float normalized = dist / max(1e-4, length(f_to_uv * t));
+  float shape = clamp(normalized, 0.0, 1.0);
+
+  float falloffMapped = mix(.2 + .8 * max(0., u_falloff + 1.), mix(1., 15., u_falloff * u_falloff), step(.0, u_falloff));
+
+  float falloffExp = mix(falloffMapped, 1., shape);
+  shape = pow(shape, falloffExp);
+  shape = 1. - clamp(shape, 0., 1.);
+
+
+  float outerMask = .002;
+  float outer = 1.0 - smoothstep(radius - outerMask, radius + outerMask, r);
+  outer = mix(outer, 1., isInSector);
+
+  shape = mix(0., shape, outer);
+  shape *= 1. - smoothstep(radius - .01, radius, r);
+
+  float angle = atan(f_to_uv.y, f_to_uv.x);
+  shape -= pow(u_distortion, 2.) * shape * pow(abs(sin(PI * clamp(length(f_to_uv) - 0.2 + u_distortionShift, 0.0, 1.0))), 4.0) * (sin(u_distortionFreq * angle) + cos(floor(0.65 * u_distortionFreq) * angle));
+
+  float mixerGrain = 0.;
+  if (u_grainMixer > 0.) {
+    mixerGrain = .4 * u_grainMixer * (noise(grainUV, vec2(0.)) - .5);
+  }
+
+  float mixer = shape * u_colorsCount + mixerGrain;
+  vec4 gradient = u_colors[0];
+  gradient.rgb *= gradient.a;
+
+  float outerShape = 0.;
+  for (int i = 1; i < ${staticRadialGradientMeta.maxColorCount + 1}; i++) {
+    if (i > int(u_colorsCount)) break;
+    float mLinear = clamp(mixer - float(i - 1), 0.0, 1.0);
+
+    float aa = fwidth(mLinear);
+    float width = min(u_mixing, 0.5);
+    float t = clamp((mLinear - (0.5 - width - aa)) / (2. * width + 2. * aa), 0., 1.);
+    float p = mix(2., 1., clamp((u_mixing - 0.5) * 2., 0., 1.));
+    float m = t < 0.5
+      ? 0.5 * pow(2. * t, p)
+      : 1. - 0.5 * pow(2. * (1. - t), p);
+
+    float quadBlend = clamp((u_mixing - 0.5) * 2., 0., 1.);
+    m = mix(m, m * m, 0.5 * quadBlend);
+    
+    if (i == 1) {
+      outerShape = m;
+    }
+
+    vec4 c = u_colors[i - 1];
+    c.rgb *= c.a;
+    gradient = mix(gradient, c, m);
+  }
+
+  vec3 color = gradient.rgb * outerShape;
+  float opacity = gradient.a * outerShape;
+
+  vec3 bgColor = u_colorBack.rgb * u_colorBack.a;
+  color = color + bgColor * (1.0 - opacity);
+  opacity = opacity + u_colorBack.a * (1.0 - opacity);
+
+  if (u_grainOverlay > 0.) {
+    float grainOverlay = valueNoise(rotate(grainUV, 1.) + vec2(3.));
+    grainOverlay = mix(grainOverlay, valueNoise(rotate(grainUV, 2.) + vec2(-1.)), .5);
+    grainOverlay = pow(grainOverlay, 1.3);
+
+    float grainOverlayV = grainOverlay * 2. - 1.;
+    vec3 grainOverlayColor = vec3(step(0., grainOverlayV));
+    float grainOverlayStrength = u_grainOverlay * abs(grainOverlayV);
+    grainOverlayStrength = pow(grainOverlayStrength, .8);
+    color = mix(color, grainOverlayColor, .35 * grainOverlayStrength);
+
+    opacity += .5 * grainOverlayStrength;
+  }
+  opacity = clamp(opacity, 0., 1.);
+
+  fragColor = vec4(color, opacity);
+}
+`;
+export {
+  staticRadialGradientFragmentShader,
+  staticRadialGradientMeta
+};
+//# sourceMappingURL=static-radial-gradient.js.map

package/dist/shaders/static-radial-gradient.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/shaders/static-radial-gradient.ts"],
+  "sourcesContent": ["import type { vec4 } from '../types.js';\r\nimport type { ShaderMotionParams } from '../shader-mount.js';\r\nimport {\r\n  type ShaderSizingParams,\r\n  type ShaderSizingUniforms,\r\n} from '../shader-sizing.js';\r\nimport { declarePI, rotation2, proceduralHash21 } from '../shader-utils.js';\r\n\r\nexport const staticRadialGradientMeta = {\r\n  maxColorCount: 10,\r\n} as const;\r\n\r\n/**\r\n * Radial gradient with up to 10 blended colors, featuring advanced mixing modes, focal point controls,\r\n * shape distortion, and grain effects.\r\n *\r\n * Fragment shader uniforms:\r\n * - u_colorBack (vec4): Background color in RGBA\r\n * - u_colors (vec4[]): Up to 10 gradient colors in RGBA\r\n * - u_colorsCount (float): Number of active colors\r\n * - u_radius (float): Size of the shape (0 to 3)\r\n * - u_focalDistance (float): Distance of the focal point from center (0 to 3)\r\n * - u_focalAngle (float): Angle of the focal point in degrees, needs focalDistance > 0 (0 to 360)\r\n * - u_falloff (float): Gradient decay, 0 = equal color distribution (-1 to 1)\r\n * - u_mixing (float): Blending behavior, 0 = hard stripes, 1 = smooth gradient (0 to 1)\r\n * - u_distortion (float): Strength of radial distortion (0 to 1)\r\n * - u_distortionShift (float): Radial distortion offset, needs distortion > 0 (-1 to 1)\r\n * - u_distortionFreq (float): Radial distortion frequency, needs distortion > 0 (0 to 20)\r\n * - u_grainMixer (float): Strength of grain distortion applied to shape edges (0 to 1)\r\n * - u_grainOverlay (float): Post-processing black/white grain overlay (0 to 1)\r\n *\r\n * Vertex shader outputs (used in fragment shader):\r\n * - v_objectUV (vec2): Object box UV coordinates with global sizing (scale, rotation, offsets, etc) applied\r\n *\r\n * Vertex shader uniforms:\r\n * - u_resolution (vec2): Canvas resolution in pixels\r\n * - u_pixelRatio (float): Device pixel ratio\r\n * - u_originX (float): Reference point for positioning world width in the canvas (0 to 1)\r\n * - u_originY (float): Reference point for positioning world height in the canvas (0 to 1)\r\n * - u_worldWidth (float): Virtual width of the graphic before it's scaled to fit the canvas\r\n * - u_worldHeight (float): Virtual height of the graphic before it's scaled to fit the canvas\r\n * - u_fit (float): How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)\r\n * - u_scale (float): Overall zoom level of the graphics (0.01 to 4)\r\n * - u_rotation (float): Overall rotation angle of the graphics in degrees (0 to 360)\r\n * - u_offsetX (float): Horizontal offset of the graphics center (-1 to 1)\r\n * - u_offsetY (float): Vertical offset of the graphics center (-1 to 1)\r\n *\r\n */\r\n\r\n// language=GLSL\r\nexport const staticRadialGradientFragmentShader: string = `#version 300 es\r\nprecision mediump float;\r\n\r\nuniform vec4 u_colorBack;\r\nuniform vec4 u_colors[${ staticRadialGradientMeta.maxColorCount }];\r\nuniform float u_colorsCount;\r\n\r\nuniform float u_radius;\r\nuniform float u_focalDistance;\r\nuniform float u_focalAngle;\r\nuniform float u_falloff;\r\nuniform float u_mixing;\r\nuniform float u_distortion;\r\nuniform float u_distortionShift;\r\nuniform float u_distortionFreq;\r\nuniform float u_grainMixer;\r\nuniform float u_grainOverlay;\r\n\r\nin vec2 v_objectUV;\r\nout vec4 fragColor;\r\n\r\n${ declarePI }\r\n${ rotation2 }\r\n${ proceduralHash21 }\r\n\r\nfloat valueNoise(vec2 st) {\r\n  vec2 i = floor(st);\r\n  vec2 f = fract(st);\r\n  float a = hash21(i);\r\n  float b = hash21(i + vec2(1.0, 0.0));\r\n  float c = hash21(i + vec2(0.0, 1.0));\r\n  float d = hash21(i + vec2(1.0, 1.0));\r\n  vec2 u = f * f * (3.0 - 2.0 * f);\r\n  float x1 = mix(a, b, u.x);\r\n  float x2 = mix(c, d, u.x);\r\n  return mix(x1, x2, u.y);\r\n}\r\n\r\nfloat noise(vec2 n, vec2 seedOffset) {\r\n  return valueNoise(n + seedOffset);\r\n}\r\n\r\nvec2 getPosition(int i, float t) {\r\n  float a = float(i) * .37;\r\n  float b = .6 + mod(float(i), 3.) * .3;\r\n  float c = .8 + mod(float(i + 1), 4.) * 0.25;\r\n\r\n  float x = sin(t * b + a);\r\n  float y = cos(t * c + a * 1.5);\r\n\r\n  return .5 + .5 * vec2(x, y);\r\n}\r\n\r\nvoid main() {\r\n  vec2 uv = 2. * v_objectUV;\r\n  vec2 grainUV = uv * 1000.;\r\n\r\n  vec2 center = vec2(0.);\r\n  float angleRad = -radians(u_focalAngle + 90.);\r\n  vec2 focalPoint = vec2(cos(angleRad), sin(angleRad)) * u_focalDistance;\r\n  float radius = u_radius;\r\n\r\n  vec2 c_to_uv = uv - center;\r\n  vec2 f_to_uv = uv - focalPoint;\r\n  vec2 f_to_c = center - focalPoint;\r\n  float r = length(c_to_uv);\r\n\r\n  float fragAngle = atan(c_to_uv.y, c_to_uv.x);\r\n  float angleDiff = fract((fragAngle - angleRad + PI) / TWO_PI) * TWO_PI - PI;\r\n\r\n  float halfAngle = acos(clamp(radius / max(u_focalDistance, 1e-4), 0.0, 1.0));\r\n  float e0 = 0.6 * PI, e1 = halfAngle;\r\n  float lo = min(e0, e1), hi = max(e0, e1);\r\n  float s  = smoothstep(lo, hi, abs(angleDiff));\r\n  float isInSector = (e1 >= e0) ? (1.0 - s) : s;\r\n\r\n  float a = dot(f_to_uv, f_to_uv);\r\n  float b = -2.0 * dot(f_to_uv, f_to_c);\r\n  float c = dot(f_to_c, f_to_c) - radius * radius;\r\n\r\n  float discriminant = b * b - 4.0 * a * c;\r\n  float t = 1.0;\r\n\r\n  if (discriminant >= 0.0) {\r\n    float sqrtD = sqrt(discriminant);\r\n    float div = max(1e-4, 2.0 * a);\r\n    float t0 = (-b - sqrtD) / div;\r\n    float t1 = (-b + sqrtD) / div;\r\n    t = max(t0, t1);\r\n    if (t < 0.0) t = 0.0;\r\n  }\r\n\r\n  float dist = length(f_to_uv);\r\n  float normalized = dist / max(1e-4, length(f_to_uv * t));\r\n  float shape = clamp(normalized, 0.0, 1.0);\r\n\r\n  float falloffMapped = mix(.2 + .8 * max(0., u_falloff + 1.), mix(1., 15., u_falloff * u_falloff), step(.0, u_falloff));\r\n\r\n  float falloffExp = mix(falloffMapped, 1., shape);\r\n  shape = pow(shape, falloffExp);\r\n  shape = 1. - clamp(shape, 0., 1.);\r\n\r\n\r\n  float outerMask = .002;\r\n  float outer = 1.0 - smoothstep(radius - outerMask, radius + outerMask, r);\r\n  outer = mix(outer, 1., isInSector);\r\n\r\n  shape = mix(0., shape, outer);\r\n  shape *= 1. - smoothstep(radius - .01, radius, r);\r\n\r\n  float angle = atan(f_to_uv.y, f_to_uv.x);\r\n  shape -= pow(u_distortion, 2.) * shape * pow(abs(sin(PI * clamp(length(f_to_uv) - 0.2 + u_distortionShift, 0.0, 1.0))), 4.0) * (sin(u_distortionFreq * angle) + cos(floor(0.65 * u_distortionFreq) * angle));\r\n\r\n  float mixerGrain = 0.;\r\n  if (u_grainMixer > 0.) {\r\n    mixerGrain = .4 * u_grainMixer * (noise(grainUV, vec2(0.)) - .5);\r\n  }\r\n\r\n  float mixer = shape * u_colorsCount + mixerGrain;\r\n  vec4 gradient = u_colors[0];\r\n  gradient.rgb *= gradient.a;\r\n\r\n  float outerShape = 0.;\r\n  for (int i = 1; i < ${ staticRadialGradientMeta.maxColorCount + 1 }; i++) {\r\n    if (i > int(u_colorsCount)) break;\r\n    float mLinear = clamp(mixer - float(i - 1), 0.0, 1.0);\r\n\r\n    float aa = fwidth(mLinear);\r\n    float width = min(u_mixing, 0.5);\r\n    float t = clamp((mLinear - (0.5 - width - aa)) / (2. * width + 2. * aa), 0., 1.);\r\n    float p = mix(2., 1., clamp((u_mixing - 0.5) * 2., 0., 1.));\r\n    float m = t < 0.5\r\n      ? 0.5 * pow(2. * t, p)\r\n      : 1. - 0.5 * pow(2. * (1. - t), p);\r\n\r\n    float quadBlend = clamp((u_mixing - 0.5) * 2., 0., 1.);\r\n    m = mix(m, m * m, 0.5 * quadBlend);\r\n    \r\n    if (i == 1) {\r\n      outerShape = m;\r\n    }\r\n\r\n    vec4 c = u_colors[i - 1];\r\n    c.rgb *= c.a;\r\n    gradient = mix(gradient, c, m);\r\n  }\r\n\r\n  vec3 color = gradient.rgb * outerShape;\r\n  float opacity = gradient.a * outerShape;\r\n\r\n  vec3 bgColor = u_colorBack.rgb * u_colorBack.a;\r\n  color = color + bgColor * (1.0 - opacity);\r\n  opacity = opacity + u_colorBack.a * (1.0 - opacity);\r\n\r\n  if (u_grainOverlay > 0.) {\r\n    float grainOverlay = valueNoise(rotate(grainUV, 1.) + vec2(3.));\r\n    grainOverlay = mix(grainOverlay, valueNoise(rotate(grainUV, 2.) + vec2(-1.)), .5);\r\n    grainOverlay = pow(grainOverlay, 1.3);\r\n\r\n    float grainOverlayV = grainOverlay * 2. - 1.;\r\n    vec3 grainOverlayColor = vec3(step(0., grainOverlayV));\r\n    float grainOverlayStrength = u_grainOverlay * abs(grainOverlayV);\r\n    grainOverlayStrength = pow(grainOverlayStrength, .8);\r\n    color = mix(color, grainOverlayColor, .35 * grainOverlayStrength);\r\n\r\n    opacity += .5 * grainOverlayStrength;\r\n  }\r\n  opacity = clamp(opacity, 0., 1.);\r\n\r\n  fragColor = vec4(color, opacity);\r\n}\r\n`;\r\n\r\nexport interface StaticRadialGradientUniforms extends ShaderSizingUniforms {\r\n  u_colorBack: [number, number, number, number];\r\n  u_colors: vec4[];\r\n  u_colorsCount: number;\r\n  u_radius: number;\r\n  u_focalDistance: number;\r\n  u_focalAngle: number;\r\n  u_falloff: number;\r\n  u_mixing: number;\r\n  u_distortion: number;\r\n  u_distortionShift: number;\r\n  u_distortionFreq: number;\r\n  u_grainMixer: number;\r\n  u_grainOverlay: number;\r\n}\r\n\r\nexport interface StaticRadialGradientParams extends ShaderSizingParams, ShaderMotionParams {\r\n  colorBack?: string;\r\n  colors?: string[];\r\n  radius?: number;\r\n  focalDistance?: number;\r\n  focalAngle?: number;\r\n  falloff?: number;\r\n  mixing?: number;\r\n  distortion?: number;\r\n  distortionShift?: number;\r\n  distortionFreq?: number;\r\n  grainMixer?: number;\r\n  grainOverlay?: number;\r\n}\r\n"],
+  "mappings": ";;;;;AAEA;AAAA,OAGO;AACP,SAAS,WAAW,WAAW,wBAAwB;AAEhD,MAAM,2BAA2B;AAAA,EACtC,eAAe;AACjB;AAwCO,MAAM,qCAA6C;AAAA;AAAA;AAAA;AAAA,wBAIjC,yBAAyB,aAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiB7D,SAAU;AAAA,EACV,SAAU;AAAA,EACV,gBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAoGK,yBAAyB,gBAAgB,CAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/shaders/swirl.d.ts

@@ -0,0 +1,63 @@
+import type { vec4 } from '../types.js';
+import type { ShaderMotionParams } from '../shader-mount.js';
+import { type ShaderSizingParams, type ShaderSizingUniforms } from '../shader-sizing.js';
+export declare const swirlMeta: {
+    readonly maxColorCount: 10;
+};
+/**
+ * Animated bands of color twisting and bending, producing spirals, arcs, and flowing circular patterns.
+ *
+ * Fragment shader uniforms:
+ * - u_time (float): Animation time
+ * - u_colorBack (vec4): Background color in RGBA
+ * - u_colors (vec4[]): Up to 10 stripe colors in RGBA
+ * - u_colorsCount (float): Number of active colors
+ * - u_bandCount (float): Number of color bands, 0 = concentric ripples (0 to 15)
+ * - u_twist (float): Vortex power, 0 = straight sectoral shapes (0 to 1)
+ * - u_center (float): How far from the center the swirl colors begin to appear, needs twist > 0 (0 to 1)
+ * - u_proportion (float): Blend point between colors, 0.5 = equal distribution (0 to 1)
+ * - u_softness (float): Color transition sharpness, 0 = hard edge, 1 = smooth gradient (0 to 1)
+ * - u_noise (float): Strength of noise distortion, needs noiseFrequency > 0 (0 to 1)
+ * - u_noiseFrequency (float): Noise frequency, needs noise > 0 (0 to 1)
+ *
+ * Vertex shader outputs (used in fragment shader):
+ * - v_objectUV (vec2): Object box UV coordinates with global sizing (scale, rotation, offsets, etc) applied
+ *
+ * Vertex shader uniforms:
+ * - u_resolution (vec2): Canvas resolution in pixels
+ * - u_pixelRatio (float): Device pixel ratio
+ * - u_originX (float): Reference point for positioning world width in the canvas (0 to 1)
+ * - u_originY (float): Reference point for positioning world height in the canvas (0 to 1)
+ * - u_worldWidth (float): Virtual width of the graphic before it's scaled to fit the canvas
+ * - u_worldHeight (float): Virtual height of the graphic before it's scaled to fit the canvas
+ * - u_fit (float): How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)
+ * - u_scale (float): Overall zoom level of the graphics (0.01 to 4)
+ * - u_rotation (float): Overall rotation angle of the graphics in degrees (0 to 360)
+ * - u_offsetX (float): Horizontal offset of the graphics center (-1 to 1)
+ * - u_offsetY (float): Vertical offset of the graphics center (-1 to 1)
+ *
+ */
+export declare const swirlFragmentShader: string;
+export interface SwirlUniforms extends ShaderSizingUniforms {
+    u_colorBack: [number, number, number, number];
+    u_colors: vec4[];
+    u_colorsCount: number;
+    u_bandCount: number;
+    u_twist: number;
+    u_center: number;
+    u_proportion: number;
+    u_softness: number;
+    u_noiseFrequency: number;
+    u_noise: number;
+}
+export interface SwirlParams extends ShaderSizingParams, ShaderMotionParams {
+    colorBack?: string;
+    colors?: string[];
+    bandCount?: number;
+    twist?: number;
+    center?: number;
+    proportion?: number;
+    softness?: number;
+    noiseFrequency?: number;
+    noise?: number;
+}

package/dist/shaders/swirl.js

@@ -0,0 +1,104 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ *                    Paper Shaders                    *
+ *       https://github.com/paper-design/shaders       *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+import {} from "../shader-sizing.js";
+import { simplexNoise, declarePI, rotation2, colorBandingFix } from "../shader-utils.js";
+const swirlMeta = {
+  maxColorCount: 10
+};
+const swirlFragmentShader = `#version 300 es
+precision mediump float;
+
+uniform float u_time;
+
+uniform vec4 u_colorBack;
+uniform vec4 u_colors[${swirlMeta.maxColorCount}];
+uniform float u_colorsCount;
+uniform float u_bandCount;
+uniform float u_twist;
+uniform float u_center;
+uniform float u_proportion;
+uniform float u_softness;
+uniform float u_noise;
+uniform float u_noiseFrequency;
+
+in vec2 v_objectUV;
+
+out vec4 fragColor;
+
+${declarePI}
+${simplexNoise}
+${rotation2}
+
+void main() {
+  vec2 shape_uv = v_objectUV;
+
+  float l = length(shape_uv);
+  l = max(1e-4, l);
+
+  float t = u_time;
+
+  float angle = ceil(u_bandCount) * atan(shape_uv.y, shape_uv.x) + t;
+  float angle_norm = angle / TWO_PI;
+
+  float twist = 3. * clamp(u_twist, 0., 1.);
+  float offset = pow(l, -twist) + angle_norm;
+
+  float shape = fract(offset);
+  shape = 1. - abs(2. * shape - 1.);
+  if (u_noise > 0.) {
+    shape += u_noise * snoise(15. * pow(u_noiseFrequency, 2.) * shape_uv);
+  }
+
+  float mid = smoothstep(.2, .2 + .8 * u_center, pow(l, twist));
+  shape = mix(0., shape, mid);
+
+  float proportion = clamp(u_proportion, 0., 1.);
+  float exponent = mix(.25, 1., proportion * 2.);
+  exponent = mix(exponent, 10., max(0., proportion * 2. - 1.));
+  shape = pow(shape, exponent);
+
+  float mixer = shape * u_colorsCount;
+  vec4 gradient = u_colors[0];
+  gradient.rgb *= gradient.a;
+
+  float outerShape = 0.;
+  for (int i = 1; i < ${swirlMeta.maxColorCount + 1}; i++) {
+    if (i > int(u_colorsCount)) break;
+
+    float m = clamp(mixer - float(i - 1), 0., 1.);
+    float aa = fwidth(m);
+    m = smoothstep(.5 - .5 * u_softness - aa, .5 + .5 * u_softness + aa, m);
+
+    if (i == 1) {
+      outerShape = m;
+    }
+
+    vec4 c = u_colors[i - 1];
+    c.rgb *= c.a;
+    gradient = mix(gradient, c, m);
+  }
+
+  float midAA = .1 * fwidth(pow(l, -twist));
+  float outerMid = smoothstep(.2, .2 + midAA, pow(l, twist));
+  outerShape = mix(0., outerShape, outerMid);
+
+  vec3 color = gradient.rgb * outerShape;
+  float opacity = gradient.a * outerShape;
+
+  vec3 bgColor = u_colorBack.rgb * u_colorBack.a;
+  color = color + bgColor * (1.0 - opacity);
+  opacity = opacity + u_colorBack.a * (1.0 - opacity);
+
+  ${colorBandingFix}
+
+  fragColor = vec4(color, opacity);
+}
+`;
+export {
+  swirlFragmentShader,
+  swirlMeta
+};
+//# sourceMappingURL=swirl.js.map

package/dist/shaders/swirl.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/shaders/swirl.ts"],
+  "sourcesContent": ["import type { vec4 } from '../types.js';\r\nimport type { ShaderMotionParams } from '../shader-mount.js';\r\nimport { type ShaderSizingParams, type ShaderSizingUniforms } from '../shader-sizing.js';\r\nimport { simplexNoise, declarePI, rotation2, colorBandingFix } from '../shader-utils.js';\r\n\r\nexport const swirlMeta = {\r\n  maxColorCount: 10,\r\n} as const;\r\n\r\n/**\r\n * Animated bands of color twisting and bending, producing spirals, arcs, and flowing circular patterns.\r\n *\r\n * Fragment shader uniforms:\r\n * - u_time (float): Animation time\r\n * - u_colorBack (vec4): Background color in RGBA\r\n * - u_colors (vec4[]): Up to 10 stripe colors in RGBA\r\n * - u_colorsCount (float): Number of active colors\r\n * - u_bandCount (float): Number of color bands, 0 = concentric ripples (0 to 15)\r\n * - u_twist (float): Vortex power, 0 = straight sectoral shapes (0 to 1)\r\n * - u_center (float): How far from the center the swirl colors begin to appear, needs twist > 0 (0 to 1)\r\n * - u_proportion (float): Blend point between colors, 0.5 = equal distribution (0 to 1)\r\n * - u_softness (float): Color transition sharpness, 0 = hard edge, 1 = smooth gradient (0 to 1)\r\n * - u_noise (float): Strength of noise distortion, needs noiseFrequency > 0 (0 to 1)\r\n * - u_noiseFrequency (float): Noise frequency, needs noise > 0 (0 to 1)\r\n *\r\n * Vertex shader outputs (used in fragment shader):\r\n * - v_objectUV (vec2): Object box UV coordinates with global sizing (scale, rotation, offsets, etc) applied\r\n *\r\n * Vertex shader uniforms:\r\n * - u_resolution (vec2): Canvas resolution in pixels\r\n * - u_pixelRatio (float): Device pixel ratio\r\n * - u_originX (float): Reference point for positioning world width in the canvas (0 to 1)\r\n * - u_originY (float): Reference point for positioning world height in the canvas (0 to 1)\r\n * - u_worldWidth (float): Virtual width of the graphic before it's scaled to fit the canvas\r\n * - u_worldHeight (float): Virtual height of the graphic before it's scaled to fit the canvas\r\n * - u_fit (float): How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)\r\n * - u_scale (float): Overall zoom level of the graphics (0.01 to 4)\r\n * - u_rotation (float): Overall rotation angle of the graphics in degrees (0 to 360)\r\n * - u_offsetX (float): Horizontal offset of the graphics center (-1 to 1)\r\n * - u_offsetY (float): Vertical offset of the graphics center (-1 to 1)\r\n *\r\n */\r\n\r\n// language=GLSL\r\nexport const swirlFragmentShader: string = `#version 300 es\r\nprecision mediump float;\r\n\r\nuniform float u_time;\r\n\r\nuniform vec4 u_colorBack;\r\nuniform vec4 u_colors[${ swirlMeta.maxColorCount }];\r\nuniform float u_colorsCount;\r\nuniform float u_bandCount;\r\nuniform float u_twist;\r\nuniform float u_center;\r\nuniform float u_proportion;\r\nuniform float u_softness;\r\nuniform float u_noise;\r\nuniform float u_noiseFrequency;\r\n\r\nin vec2 v_objectUV;\r\n\r\nout vec4 fragColor;\r\n\r\n${ declarePI }\r\n${ simplexNoise }\r\n${ rotation2 }\r\n\r\nvoid main() {\r\n  vec2 shape_uv = v_objectUV;\r\n\r\n  float l = length(shape_uv);\r\n  l = max(1e-4, l);\r\n\r\n  float t = u_time;\r\n\r\n  float angle = ceil(u_bandCount) * atan(shape_uv.y, shape_uv.x) + t;\r\n  float angle_norm = angle / TWO_PI;\r\n\r\n  float twist = 3. * clamp(u_twist, 0., 1.);\r\n  float offset = pow(l, -twist) + angle_norm;\r\n\r\n  float shape = fract(offset);\r\n  shape = 1. - abs(2. * shape - 1.);\r\n  if (u_noise > 0.) {\r\n    shape += u_noise * snoise(15. * pow(u_noiseFrequency, 2.) * shape_uv);\r\n  }\r\n\r\n  float mid = smoothstep(.2, .2 + .8 * u_center, pow(l, twist));\r\n  shape = mix(0., shape, mid);\r\n\r\n  float proportion = clamp(u_proportion, 0., 1.);\r\n  float exponent = mix(.25, 1., proportion * 2.);\r\n  exponent = mix(exponent, 10., max(0., proportion * 2. - 1.));\r\n  shape = pow(shape, exponent);\r\n\r\n  float mixer = shape * u_colorsCount;\r\n  vec4 gradient = u_colors[0];\r\n  gradient.rgb *= gradient.a;\r\n\r\n  float outerShape = 0.;\r\n  for (int i = 1; i < ${ swirlMeta.maxColorCount + 1 }; i++) {\r\n    if (i > int(u_colorsCount)) break;\r\n\r\n    float m = clamp(mixer - float(i - 1), 0., 1.);\r\n    float aa = fwidth(m);\r\n    m = smoothstep(.5 - .5 * u_softness - aa, .5 + .5 * u_softness + aa, m);\r\n\r\n    if (i == 1) {\r\n      outerShape = m;\r\n    }\r\n\r\n    vec4 c = u_colors[i - 1];\r\n    c.rgb *= c.a;\r\n    gradient = mix(gradient, c, m);\r\n  }\r\n\r\n  float midAA = .1 * fwidth(pow(l, -twist));\r\n  float outerMid = smoothstep(.2, .2 + midAA, pow(l, twist));\r\n  outerShape = mix(0., outerShape, outerMid);\r\n\r\n  vec3 color = gradient.rgb * outerShape;\r\n  float opacity = gradient.a * outerShape;\r\n\r\n  vec3 bgColor = u_colorBack.rgb * u_colorBack.a;\r\n  color = color + bgColor * (1.0 - opacity);\r\n  opacity = opacity + u_colorBack.a * (1.0 - opacity);\r\n\r\n  ${ colorBandingFix }\r\n\r\n  fragColor = vec4(color, opacity);\r\n}\r\n`;\r\n\r\nexport interface SwirlUniforms extends ShaderSizingUniforms {\r\n  u_colorBack: [number, number, number, number];\r\n  u_colors: vec4[];\r\n  u_colorsCount: number;\r\n  u_bandCount: number;\r\n  u_twist: number;\r\n  u_center: number;\r\n  u_proportion: number;\r\n  u_softness: number;\r\n  u_noiseFrequency: number;\r\n  u_noise: number;\r\n}\r\n\r\nexport interface SwirlParams extends ShaderSizingParams, ShaderMotionParams {\r\n  colorBack?: string;\r\n  colors?: string[];\r\n  bandCount?: number;\r\n  twist?: number;\r\n  center?: number;\r\n  proportion?: number;\r\n  softness?: number;\r\n  noiseFrequency?: number;\r\n  noise?: number;\r\n}\r\n"],
+  "mappings": ";;;;;AAEA,eAAmE;AACnE,SAAS,cAAc,WAAW,WAAW,uBAAuB;AAE7D,MAAM,YAAY;AAAA,EACvB,eAAe;AACjB;AAqCO,MAAM,sBAA8B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAMlB,UAAU,aAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAc9C,SAAU;AAAA,EACV,YAAa;AAAA,EACb,SAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAmCY,UAAU,gBAAgB,CAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IA2BhD,eAAgB;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}