precision mediump float;

uniform vec2 iResolution;
uniform float iTime;
uniform vec2 iMouse;

void mainImage(out vec4 fragColor, in vec2 fragCoord) {
    vec2 uv = fragCoord / iResolution.xy;

    vec3 c1 = vec3(0., 0.4, 0.8);
    vec3 c2 = vec3(0.5, 0.1, 0.3);

    fragColor = vec4(mix(c1, c2, sin(uv.xxx*iTime*uv.x)/cos(uv.yyy*iTime)), 1.0);
}

uniform float brickSize;
uniform float fillSize;
uniform vec2 brickOffset;
uniform vec4 fillColor;
uniform vec4 brickColor;
precision mediump float;
/*
{
  "CATEGORIES" : [
    "Pattern", "Color"
  ],
  "DESCRIPTION" : "Generates a basic brick pattern",
  "ISFVSN" : "2",
  "INPUTS" : [

precision mediump float;
varying vec2 v_texcoord;

vec2 brickTile(vec2 _st, float _zoom){
    _st *= _zoom;
    if (fract(_st.y * 0.5) > 0.5){
        _st.x += 0.5;
    }
    return fract(_st);
}

float box(vec2 _st, vec2 _size){
    _size = vec2(0.5)-_size*0.5;
    vec2 uv = smoothstep(_size,_size+vec2(0.0001),_st);

uniform sampler2D startImage;
uniform sampler2D endImage;
uniform float progress;
uniform float amplitude;
uniform float waves;
uniform float colorSeparation;
precision mediump float;
/*{
    "CATEGORIES": [
        "Distortion"
    ],
    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/ButterflyWaveScrawler.glsl",
    "DESCRIPTION": "",
    "INPUTS": [

uniform float width;
uniform vec2 offset;
uniform vec4 color1;
uniform vec4 color2;
uniform vec2 splitPos;
precision mediump float;
/*
{
  "CATEGORIES" : [
    "Pattern", "Color"
  ],
  "ISFVSN" : "2",
  "INPUTS" : [
    {

precision mediump float;
uniform vec2 resolution;
uniform float time;
float hash(vec2 p){return fract(sin(dot(p,vec2(17.0,59.4)))*43758.5453);} 
void main(){
 vec2 uv=gl_FragCoord.xy/resolution.xy; uv.x*=resolution.x/resolution.y;
 vec2 g=uv*12.0; vec2 id=floor(g); vec2 f=fract(g);
 float rnd=hash(id);
 float h=smoothstep(0.47,0.49,abs(f.y-0.5))*smoothstep(0.51,0.49,abs(f.y-0.5));
 float v=smoothstep(0.47,0.49,abs(f.x-0.5))*smoothstep(0.51,0.49,abs(f.x-0.5));
 float active=step(0.45, sin(rnd*6.283+time*1.5));
 float pads=smoothstep(0.18,0.0,length(f-0.5))*step(0.72,rnd);
 float glow=(h*step(0.35,rnd)+v*step(rnd,0.65)+pads)*active;
 gl_FragColor=vec4(vec3(0.01,0.025,0.04)+glow*vec3(0.0,0.95,0.75),1.0);

precision mediump float;
varying vec2 v_texcoord;
#define PI 3.14159265358979323846

vec2 rotate2D(vec2 _st, float _angle){
  _st -= 0.5;
  _st =  mat2(cos(_angle),-sin(_angle),
              sin(_angle),cos(_angle)) * _st;
  _st += 0.5;
  return _st;
}

vec2 tile(vec2 _st, float _zoom){
  _st *= _zoom;

precision mediump float;
uniform vec2 resolution;
uniform float time;
vec2 hash(vec2 p) { p = vec2(dot(p, vec2(127.1,311.7)), dot(p, vec2(269.5,183.3))); return fract(sin(p) * 43758.5453); }
void main() {
  vec2 uv = gl_FragCoord.xy / resolution.xy;
  uv.x *= resolution.x / resolution.y;
  vec2 g = uv * 7.0;
  vec2 id = floor(g);
  vec2 f = fract(g);
  float d1 = 9.0;
  float d2 = 9.0;
  for (int y=-1; y<=1; y++) for (int x=-1; x<=1; x++) {
    vec2 o = vec2(float(x), float(y));

precision mediump float;

uniform float u_time;
uniform vec2 u_resolution;

void main() {
  vec3 black = vec3(0.0);
  vec3 white = vec3(1.0);
  vec3 color = black;

  vec2 uv = 2.0 * gl_FragCoord.xy / u_resolution - 1.0;
  uv.x = uv.x * u_resolution.x / u_resolution.y;
  color = vec3(uv, 0.0);

uniform float fftImage;
uniform float strokeSize;
uniform float gain;
uniform float minRange;
uniform float maxRange;
uniform vec4 topColor;
uniform vec4 bottomColor;
uniform vec4 strokeColor;
precision mediump float;
/*{
	"DESCRIPTION": "Visualizes an FFT analysis image with custom set colors for frequency domain",
	"CREDIT": "by VIDVOX",
	"ISFVSN": "2",
	"CATEGORIES": [

precision mediump float;
#define GLSLIFY 1
// Common uniforms
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
uniform float u_frame;

// Common varyings
varying vec3 v_position;
varying vec3 v_normal;

/*
 * Returns a value between 1 and 0 that indicates if the pixel is inside the circle

precision mediump float;
uniform float u_time;
varying vec2 v_texcoord;
varying vec3 vNormal;

#define TAU 2.0 * 3.142857

// Hash function uniforms
uniform vec2 uHashFract;
uniform float uHashDot;

// Rand01 uniforms
uniform vec3 uRandFract;
uniform float uRandDot;

precision mediump float;
uniform float u_time;
varying vec2 v_texcoord;

#include "./3DPerlinNoise.glsl";

void main()
{
    // Adding patterns
    float pattern = sin(0.01);
    pattern -= abs(cnoise(vec3(v_texcoord * 5.0, u_time * 0.2)) * 0.15);

    // Colors
    vec3 color1 = vec3(1.0, 0.0, 0.35);

precision mediump float;
varying vec2 v_texcoord;
uniform float u_time;
uniform float uFrequency;
uniform float uAmplitude;

float random(vec2 st) {
    return fract(sin(dot(st.xy, vec2(12.9898, 78.233))) * 43758.5453123);
}

//	Classic Perlin 2D Noise 
//	by Stefan Gustavson
//
vec2 fade(vec2 t) {

precision mediump float;
#define GLSLIFY 1
// Common uniforms
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
uniform float u_frame;

/*
 * Returns a value between 1 and 0 that indicates if the pixel is inside the square
 */
float square(vec2 pixel, vec2 bottom_left, float side) {
    vec2 top_right = bottom_left + side;

precision mediump float;
#define GLSLIFY 1
// Common uniforms
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
uniform float u_frame;

// Common varyings
varying vec3 v_position;
varying vec3 v_normal;

/*
 *  Calculates the diffuse factor produced by the light illumination

uniform sampler2D startImage;
uniform sampler2D endImage;
uniform float progress;
uniform float pause;
uniform float dividerWidth;
uniform float randomness;
uniform vec4 bgcolor;
uniform vec2 size;
precision mediump float;
/*{
    "CATEGORIES": [
        "Wipe"
    ],
    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/GridFlip.glsl",

uniform float spectrum;
uniform float mat_scale;
uniform vec2 mat_offset;
uniform float mat_rotation;
uniform int mat_auto;
uniform float mat_mspeed;
uniform float mat_amplitude;
uniform float mat_audio_level;
uniform float mat_line_thickness;
uniform float mat_pattern_complexity;
uniform vec4 mat_mainColor;
uniform vec4 mat_bgColor;
uniform int mat_strobeActivated;
uniform float mat_speedStrobe;

uniform float level;
uniform float radius;
uniform vec2 center;
uniform vec4 bgColor;
uniform vec4 lineColor;
uniform int majorDivisions;
uniform int minorHDivisions;
uniform int minorVDivisions;
uniform float majorDivisionLineWidth;
uniform int square;
precision mediump float;
/*{
    "CATEGORIES": [
        "Geometry"

uniform sampler2D inputImage;
uniform float size;
uniform float sides;
uniform float rotation;
uniform float angle;
uniform vec2 slide1;
uniform vec2 slide2;
uniform vec2 shift;
precision mediump float;
/*{
    "CATEGORIES": [
    	"Kaleidoscope",
        "Tile Effect"
    ],

precision mediump float;
uniform vec2 resolution;
uniform float time;
void main(){
 vec2 uv=gl_FragCoord.xy/resolution.xy; uv.x*=resolution.x/resolution.y;
 float a=sin((uv.x*18.0 + sin(uv.y*9.0+time)*2.0) - time*1.4);
 float b=sin((uv.y*22.0 + cos(uv.x*8.0-time)*2.0) + time*1.1);
 float lines=smoothstep(0.82,1.0,abs(a))*0.7 + smoothstep(0.86,1.0,abs(b))*0.7;
 vec3 bg=vec3(0.015,0.02,0.07);
 vec3 c=mix(vec3(1.0,0.12,0.6), vec3(0.1,0.9,1.0), step(a,b));
 gl_FragColor=vec4(bg + c*lines,1.0);
}

precision mediump float;
uniform float u_time;
varying vec2 v_texcoord;
#define PI 3.14159265358979323846

float rows = 10.0;

vec2 brickTile(vec2 _st, float _zoom){
  _st *= _zoom;
  if (fract(_st.y * 0.5) > 0.5){
      _st.x += 0.5;
  }
  return fract(_st);
}

precision mediump float;
uniform vec2 resolution;
uniform float time;
void main(){
 vec2 uv=(gl_FragCoord.xy*2.0-resolution.xy)/min(resolution.x,resolution.y);
 float r=length(uv); float a=atan(uv.y,uv.x);
 vec2 p=uv + 0.18*sin(vec2(uv.y,uv.x)*8.0+time) + 0.08*vec2(cos(a*6.0+time),sin(a*5.0-time));
 float c=mod(floor(p.x*9.0)+floor(p.y*9.0),2.0);
 float rings=0.5+0.5*sin(r*28.0-time*1.2);
 vec3 col=mix(vec3(0.02),vec3(0.96),c); col=mix(col,col.bgr,rings*.35);
 gl_FragColor=vec4(col,1.0);
}

uniform sampler2D inputImage;
uniform float maxGlitchSize;
uniform float glitchRate;
uniform int patternMode;
precision mediump float;
/*
{
  "CATEGORIES" : [
    "Glitch"
  ],
  "DESCRIPTION" : "Applies randomized effects to different parts of the image.",
  "ISFVSN" : "2",
  "INPUTS" : [
    {

uniform sampler2D startImage;
uniform sampler2D endImage;
uniform float progress;
uniform float dots;
uniform vec2 center;
precision mediump float;
/*{
    "CATEGORIES": [
        "Wipe"
    ],
    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/PolkaDotsCurtain.glsl",
    "DESCRIPTION": "",
    "INPUTS": [
        {

uniform sampler2D inputImage;
uniform float size;
uniform float rotation;
uniform float angle;
uniform vec2 slide1;
uniform vec2 slide2;
uniform vec2 shift;
precision mediump float;
/*{
    "CATEGORIES": [
        "Tile Effect"
    ],
    "CREDIT": "by VIDVOX",
    "INPUTS": [

uniform float width;
uniform vec2 offset;
uniform float hue;
uniform float saturation;
uniform float brightness;
uniform int randHue;
uniform int randSaturation;
uniform int randBright;
uniform int randAlpha;
uniform float rSeed;
precision mediump float;
/*{
    "CATEGORIES": [
        "Pattern", "Color"

precision mediump float;
uniform float u_time;
varying vec2 v_texcoord;
#define PI 3.14159265358979323846
#define TWO_PI 6.28318530717958647693

vec2 rotate2D(vec2 _st, float _angle){
  _st -= 0.5;
  _st =  mat2(cos(_angle),-sin(_angle),
              sin(_angle),cos(_angle)) * _st;
  _st += 0.5;
  return _st;
}

uniform sampler2D inputImage;
uniform float positionVal;
uniform float distortion;
uniform float magnitude;
uniform vec2 center;
uniform int background;
precision mediump float;
/*{
  "DESCRIPTION": "",
  "CREDIT": "by VIDVOX",
  "CATEGORIES": [
    "Distortion Effect"
  ],
  "INPUTS": [

uniform sampler2D inputImage;
uniform int pulse;
uniform float rate;
uniform float magnitude;
uniform float distortion;
uniform vec2 center;
precision mediump float;
/*
{
  "CATEGORIES" : [
    "Distortion Effect"
  ],
  "DESCRIPTION" : "",
  "ISFVSN" : "2",

precision mediump float;
varying vec2 v_texcoord;
vec2 tile(vec2 _st, float _zoom){
  _st *= _zoom;
  return fract(_st);
}

float X(vec2 _st, float _width){
  float pct0 = smoothstep(_st.x-_width,_st.x,_st.y);
  pct0 *= 1.-smoothstep(_st.x,_st.x+_width,_st.y);

  float pct1 = smoothstep(_st.x-_width,_st.x,1.0-_st.y);
  pct1 *= 1.-smoothstep(_st.x,_st.x+_width,1.0-_st.y);

uniform sampler2D inputImage;
uniform float size;
uniform float rotation;
uniform float angle;
uniform vec2 shift;
precision mediump float;
/*{
    "CATEGORIES": [
        "Kaleidoscope",
        "Tile Effect"
    ],
    "CREDIT": "by VIDVOX",
    "INPUTS": [
        {

precision mediump float;

uniform float u_time;
uniform vec2 u_resolution;

// reference: https://iquilezles.org/articles/distfunctions2d/
float sdBox(in vec2 p, in vec2 b) {
  vec2 d = abs(p) - b;
  return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
}

void main() {
  vec2 uv = 2.0 * gl_FragCoord.xy / u_resolution - 1.0;
  uv.x = uv.x * u_resolution.x / u_resolution.y;

precision mediump float;
uniform vec2 resolution;
uniform float time;
vec2 hash(vec2 p){p=vec2(dot(p,vec2(127.1,311.7)),dot(p,vec2(269.5,183.3)));return fract(sin(p)*43758.5453);} 
void main(){
 vec2 uv=gl_FragCoord.xy/resolution.xy; uv.x*=resolution.x/resolution.y;
 vec2 g=uv*8.0,id=floor(g),f=fract(g); float d=9.0; vec2 cell=vec2(0.0);
 for(int y=-1;y<=1;y++)for(int x=-1;x<=1;x++){vec2 o=vec2(float(x),float(y));vec2 r=hash(id+o);float nd=length(o+r-f);if(nd<d){d=nd;cell=id+o;}}
 float lead=smoothstep(0.06,0.025,d);
 vec3 glass=0.5+0.5*cos(vec3(0.0,2.2,4.4)+hash(cell).x*6.283+time*0.05);
 gl_FragColor=vec4(mix(glass*0.85,vec3(0.02),lead),1.0);
}

precision mediump float;
uniform float u_time;
varying vec2 v_texcoord;
#define PI 3.14159265358979323846
#define TWO_PI 6.28318530717958647693
#define PHI 1.618033988749894848204586834

vec2 radialTile(vec2 _st, vec2 _vel, float _zoom){
  vec2 toExtreme = vec2(0.5)-_st;
  vec2 polar = vec2( (PI+atan(toExtreme.y,toExtreme.x))/TWO_PI,   // Angle
                      log(length(toExtreme))*PHI*0.1);            // Radius
  polar *= _zoom;

  polar.y += _vel.y;

uniform int pattern;
uniform float brightness;
uniform float contrast;
uniform float saturation;
uniform float hue;
uniform float rotation;
uniform float timeSpeed;
uniform float audioFlow;
precision mediump float;
/*{
  "DESCRIPTION": "Full-featured scope test shader with rotating patterns, animated luma, and time-controlled generative visuals",
  "CREDIT": "Cornelius // ProjectileObjects",
  "CATEGORIES": [ "Test Pattern", "Utility" ],
  "INPUTS": [

precision mediump float;
uniform vec2 resolution;
uniform float time;
float hash(vec2 p){return fract(sin(dot(p,vec2(113.5,271.9)))*43758.5453);} 
float noise(vec2 p){vec2 i=floor(p),f=fract(p);f=f*f*(3.0-2.0*f);return mix(mix(hash(i),hash(i+vec2(1,0)),f.x),mix(hash(i+vec2(0,1)),hash(i+1.0),f.x),f.y);} 
float fbm(vec2 p){float v=0.0,a=0.5;for(int i=0;i<5;i++){v+=a*noise(p);p*=2.0;a*=0.5;}return v;}
void main(){
 vec2 uv=gl_FragCoord.xy/resolution.xy; uv.x*=resolution.x/resolution.y;
 float h=fbm(uv*4.0+0.05*sin(time));
 float lines=1.0-smoothstep(0.0,0.035,abs(fract(h*12.0)-0.5));
 vec3 land=mix(vec3(0.05,0.13,0.08),vec3(0.72,0.55,0.28),h);
 gl_FragColor=vec4(land+lines*vec3(0.9,0.85,0.55),1.0);
}

uniform float tSize;
uniform float nSeed;
uniform vec4 color1;
uniform vec4 color2;
uniform int lineMode;
precision mediump float;
/*{
    "CATEGORIES": [
        "Geometry"
    ],
    "CREDIT": "pjkarlik",
    "DESCRIPTION": "Creates a Truchet Tile pattern",
    "INPUTS": [
        {

precision mediump float;
varying vec2 v_texcoord;
#define PI 3.14159265358979323846

float plotX(vec2 _st, float _pct,float _antia){
  return  smoothstep( _pct-_antia, _pct, _st.x) - 
          smoothstep( _pct, _pct+_antia, _st.x);
}

float plotY(vec2 _st, float _pct,float _antia){
  return  smoothstep( _pct-_antia, _pct, _st.y) - 
          smoothstep( _pct, _pct+_antia, _st.y);
}

precision mediump float;
varying vec2 v_texCoord;
uniform sampler2D u_texture;
uniform vec2 u_resolution;
uniform float u_amplitude; // px
uniform float u_frequency; // waves across image
uniform int   u_direction; // 0=horizontal, 1=vertical, 2=radial

void main() {
  vec2 uv = v_texCoord;
  float amp = u_amplitude / u_resolution.x;
  float freq = u_frequency * 6.28318;
  float offset = 0.0;

uniform sampler2D inputImage;
uniform float audio;
uniform float displaceX;
uniform float displaceY;
uniform float detailX;
uniform float detailY;
precision mediump float;
/*{
    "CATEGORIES": [
        "Audio Visualizer",
        "Distortion Effect"
    ],
    "CREDIT": "icalvin102 (calvin@icalvin.de)",
    "DESCRIPTION": "Displaces image with audio waveform",

uniform float scale;
uniform float speed;
uniform int reverse;
uniform vec4 foregroundColor;
uniform vec4 backgroundColor;
uniform float brightness;
uniform float contrast;
precision mediump float;
/*{
    "CREDIT": "Mad Team",
    "DESCRIPTION": "Dunes to Zebra Stripes.",
    "VSN": "1.0",
    "TAGS": "graphic",
    "INPUTS": [