precision mediump float;

#endif

​

#define TWO_PI 6.28318530718

uniform vec2 resolution;

uniform float t;

uniform float noise;

​

uniform int grad_count;

const int max_grad_count = 100;

uniform vec4 grads[max_grad_count];

uniform vec3 colors[max_grad_count];

​

// Noise

vec3 mod289(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }

vec4 mod289(vec4 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }

vec4 permute(vec4 x) { return mod289(((x*34.0)+1.0)*x); }

vec4 taylorInvSqrt(vec4 r) { return 1.79284291400159 - 0.85373472095314 * r; }

vec3 fade(vec3 t) { return t*t*t*(t*(t*6.0-15.0)+10.0); }

float perlinNoise(vec3 P) {

    vec3 i0 = mod289(floor(P)), i1 = mod289(i0 + vec3(1.0));

    vec3 f0 = fract(P), f1 = f0 - vec3(1.0), f = fade(f0);

    vec4 ix = vec4(i0.x, i1.x, i0.x, i1.x), iy = vec4(i0.yy, i1.yy);

    vec4 iz0 = i0.zzzz, iz1 = i1.zzzz;

    vec4 ixy = permute(permute(ix) + iy), ixy0 = permute(ixy + iz0), ixy1 = permute(ixy + iz1);

    vec4 gx0 = ixy0 * (1.0 / 7.0), gy0 = fract(floor(gx0) * (1.0 / 7.0)) - 0.5;

    vec4 gx1 = ixy1 * (1.0 / 7.0), gy1 = fract(floor(gx1) * (1.0 / 7.0)) - 0.5;

    gx0 = fract(gx0); gx1 = fract(gx1);

    vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0), sz0 = step(gz0, vec4(0.0));

    vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1), sz1 = step(gz1, vec4(0.0));

    gx0 -= sz0 * (step(0.0, gx0) - 0.5); gy0 -= sz0 * (step(0.0, gy0) - 0.5);

    gx1 -= sz1 * (step(0.0, gx1) - 0.5); gy1 -= sz1 * (step(0.0, gy1) - 0.5);

    vec3 g0 = vec3(gx0.x,gy0.x,gz0.x), g1 = vec3(gx0.y,gy0.y,gz0.y),

        g2 = vec3(gx0.z,gy0.z,gz0.z), g3 = vec3(gx0.w,gy0.w,gz0.w),

        g4 = vec3(gx1.x,gy1.x,gz1.x), g5 = vec3(gx1.y,gy1.y,gz1.y),

        g6 = vec3(gx1.z,gy1.z,gz1.z), g7 = vec3(gx1.w,gy1.w,gz1.w);

    vec4 norm0 = taylorInvSqrt(vec4(dot(g0,g0), dot(g2,g2), dot(g1,g1), dot(g3,g3)));

    vec4 norm1 = taylorInvSqrt(vec4(dot(g4,g4), dot(g6,g6), dot(g5,g5), dot(g7,g7)));

    g0 *= norm0.x; g2 *= norm0.y; g1 *= norm0.z; g3 *= norm0.w;

    g4 *= norm1.x; g6 *= norm1.y; g5 *= norm1.z; g7 *= norm1.w;

    vec4 nz = mix(vec4(dot(g0, vec3(f0.x, f0.y, f0.z)), dot(g1, vec3(f1.x, f0.y, f0.z)),

        dot(g2, vec3(f0.x, f1.y, f0.z)), dot(g3, vec3(f1.x, f1.y, f0.z))),

        vec4(dot(g4, vec3(f0.x, f0.y, f1.z)), dot(g5, vec3(f1.x, f0.y, f1.z)),

            dot(g6, vec3(f0.x, f1.y, f1.z)), dot(g7, vec3(f1.x, f1.y, f1.z))), f.z);

    return 2.2 * mix(mix(nz.x,nz.z,f.y), mix(nz.y,nz.w,f.y), f.x);

}

float perlinNoise(vec2 P) { return perlinNoise(vec3(P, 0.0)); }

​

float turbulence(vec3 P) {

    float f = 0., s = 1.;

    for (int i = 0 ; i < 9 ; i++) {

        f += abs(perlinNoise(s * P)) / s;

        s *= 2.;

        P = vec3(.866 * P.x + .5 * P.z, P.y + 100., -.5 * P.x + .866 * P.z);

    }

    return f;

}

​

float turbulence(vec2 P) { return turbulence(vec3(P, 0.0)); }

​

// wrap angle between -0.5 and 0.5

float modAngle(float v) {

  return mod(v + 0.5, 1.) - 0.5;

}

​

// asymptote at y = 1

float asymp(float v) {

  v = max(0., v);

  return v / sqrt(v * v + 1.);

}

​

float rand(vec2 co) {

  float v1 = cos(co.x * 1032.31 / co.y);

  float v2 = cos(v1 * 1023.201202 + co.y * 1023.2301021);

  return fract(v1 + v2);

}

​

// gradient strength

float gradStr(vec4 grad, vec2 co) {

  vec2 pos = vec2(grad.xy);

​

  float aOffset = grad.z;

  float aRange = grad.q;

  float a = atan(pos.y - co.y, co.x - pos.x) / TWO_PI;

  a = modAngle(a + aOffset);

  float dv = length(pos - co); // distance value

  float av = (abs(a) * pow(1. - aRange, 2.0)); // angle value

  float v = 1. - asymp(

    (av + dv) * 100.

  );

  return v;

}

​

float sinn(float v) {

  return sin(v * TWO_PI) * 0.5 + 0.5;

}

​

void main (void) {  

  vec2 dimVec = resolution.x > resolution.y 

    ? vec2(resolution.x / resolution.y, 1.) 

    : vec2(1., resolution.y / resolution.x);

​

  vec2 co = gl_FragCoord.xy/resolution.xy; // view space coordinates

  co *= dimVec; // fit square coordinates inside rectangular view

  co -= (dimVec - 1.) * 0.5; // center coordinates

  vec4 col = vec4(0);

  float totalGradStr = 0.;

  for (int i=0; i<max_grad_count; i++) {

    if (i >= grad_count)

        break;

    totalGradStr += gradStr(grads[i], co);

  }

  for (int i=0; i<max_grad_count; i++) {

    if (i >= grad_count)

      break;

​

    vec3 c = colors[i];

    float str = gradStr(grads[i], co);

    float strV = str / totalGradStr;

    float noiseV = rand(co) * noise;

    col += vec4(

      c * mix(strV, 1., noiseV) * strV * 2.5, 

      pow(strV, 1.) * .9

    );

  }

  // strV * 0.5

  vec3 bgCol = vec3(

   perlinNoise(vec3(co * 5., sinn(t) * 0.5))

  ) * 5. * vec3(0 ,1, sinn(t) + 1.);

  gl_FragColor = vec4(mix(bgCol, col.rgb, min(col.a, 1.)), 1);

}

​

​

​