pixo 0.1.0

data/ext/pixo/patterns/fire.glsl

@@ -0,0 +1,56 @@
+#version 330 core
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+// http://glslsandbox.com/e#30671.1
+#extension GL_OES_standard_derivatives : enable
+
+uniform float time;
+uniform vec2 mouse;
+uniform vec2 resolution;
+out vec4 color_out;
+
+float snoise(vec3 uv, float res)
+{
+	const vec3 s = vec3(1e0, 1e2, 1e3);
+	
+	uv *= res;
+	
+	vec3 uv0 = floor(mod(uv, res))*s;
+	vec3 uv1 = floor(mod(uv+vec3(1.), res))*s;
+	
+	vec3 f = fract(uv); f = f*f*(3.0-2.0*f);
+
+	vec4 v = vec4(uv0.x+uv0.y+uv0.z, uv1.x+uv0.y+uv0.z,
+		      	  uv0.x+uv1.y+uv0.z, uv1.x+uv1.y+uv0.z);
+
+	vec4 r = fract(sin(v*1e-1)*1e3);
+	float r0 = mix(mix(r.x, r.y, f.x), mix(r.z, r.w, f.x), f.y);
+	
+	r = fract(sin((v + uv1.z - uv0.z)*1e-1)*1e3);
+	float r1 = mix(mix(r.x, r.y, f.x), mix(r.z, r.w, f.x), f.y);
+	
+	return mix(r0, r1, f.z)*2.-1.;
+}
+
+
+void main( void ) {	
+	vec2 p = -0.5+( gl_FragCoord.xy / resolution.xy );
+	p.x*=resolution.x/resolution.y;			
+			  	
+	float color = 3.0 - (6.*length(p));		
+	
+		
+	
+	vec3 coord = vec3(atan(p.x,p.y)/6.2832, length(p)*0.4, .5);
+	
+	
+	for(int i = 1; i <= 7; i++){
+		float power = pow(2.0, float(i));
+		color += (1.5 / power) * snoise(coord + vec3(0.,-time*.05, time*.01), power*16.);
+	}
+	
+	color_out = vec4( color, pow(max(color,0.),2.)*0.4, pow(max(color,0.),3.)*0.15 , 1.0);
+	
+}

data/ext/pixo/patterns/fireball.glsl

@@ -0,0 +1,229 @@
+#version 330 core
+
+// Fireball
+// Awd
+// @AlexWDunn
+
+// http://glslsandbox.com/e#30194.0
+
+#ifdef GL_ES
+precision highp float;
+#endif
+
+uniform vec2 resolution;
+uniform float time;
+uniform vec2 mouse;
+uniform float zoom;
+out vec4 color_out;
+
+#define saturate(oo) clamp(oo, 0.0, 1.0)
+
+// Quality Settings
+#define MarchSteps 1
+// Scene Settings
+#define ExpPosition vec3(0.0)
+#define Radius 2.0
+#define Background vec4(0.0, 0.0, 0.0, 0.0)
+
+// Noise Settings
+#define NoiseSteps 4
+#define NoiseAmplitude 0.1
+#define NoiseFrequency 3.2
+#define Animation vec3(0.0, -3.0, 0.5)
+
+// Colour Gradient
+#define Color1 vec4(1.0, 1.0, 1.0, 1.0)
+#define Color2 vec4(1.0, 0.8, 0.2, 1.0)
+#define Color3 vec4(1.0, 0.03, 0.0, 1.0)
+#define Color4 vec4(0.4, 0.02, 0.02, 1.0)
+
+
+
+// Description : Array and textureless GLSL 2D/3D/4D simplex
+//               noise functions.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : ijm
+//     Lastmod : 20110822 (ijm)
+//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//               https://github.com/ashima/webgl-noise
+//
+
+vec3 mod289(vec3 x) { return x - floor(x * (1.0 / 196.0)) * 196.0; }
+vec4 mod289(vec4 x) { return x - floor(x * (1.0 / 196.0)) * 196.0; }
+vec4 permute(vec4 x) { return mod289(((x*56.0)+1.0)*x); }
+vec4 taylorInvSqrt(vec4 r){ return 1.79284291400159 - 0.85373472095314 * r; }
+
+float snoise(vec3 v)
+{
+	const vec2  C = vec2(1.0/6.0, 1.0/3.0);
+	const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);
+
+	// First corner
+	vec3 i  = floor(v + dot(v, C.yyy));
+	vec3 x0 = v - i + dot(i, C.xxx);
+
+	// Other corners
+	vec3 g = step(x0.yzx, x0.xyz);
+	vec3 l = 1.0 - g;
+	vec3 i1 = min(g.xyz, l.zxy);
+	vec3 i2 = max(g.xyz, l.zxy);
+	vec3 x1 = x0 - i1 + C.xxx;
+	vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
+	vec3 x3 = x0 - D.yyy;      // -1.0+3.0*C.x = -0.5 = -D.y
+
+	// Permutations
+	i = mod289(i);
+	vec4 p = permute( permute( permute( i.z + vec4(0.0, i1.z, i2.z, 1.0)) + i.y + vec4(0.0, i1.y, i2.y, 1.0 )) + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
+
+	// Gradients: 7x7 points over a square, mapped onto an octahedron.
+	// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
+	float n_ = 0.142857142857; // 1.0/7.0
+	vec3  ns = n_ * D.wyz - D.xzx;
+	vec4 j = p - 49.0 * floor(p * ns.z * ns.z);  //  mod(p,7*7)
+
+	vec4 x_ = floor(j * ns.z);
+	vec4 y_ = floor(j - 7.0 * x_);    // mod(j,N)
+
+	vec4 x = x_ *ns.x + ns.yyyy;
+	vec4 y = y_ *ns.x + ns.yyyy;
+
+	vec4 h = 1.0 - abs(x) - abs(y);
+	vec4 b0 = vec4(x.xy, y.xy);
+	vec4 b1 = vec4(x.zw, y.zw);
+
+	vec4 s0 = floor(b0) * 2.0 + 1.0;
+	vec4 s1 = floor(b1) * 2.0 + 1.0;
+	vec4 sh = -step(h, vec4(0.0));
+
+	vec4 a0 = b0.xzyw + s0.xzyw * sh.xxyy;
+	vec4 a1 = b1.xzyw + s1.xzyw * sh.zzww;
+
+	vec3 p0 = vec3(a0.xy, h.x);
+	vec3 p1 = vec3(a0.zw, h.y);
+	vec3 p2 = vec3(a1.xy, h.z);
+	vec3 p3 = vec3(a1.zw, h.w);
+
+	//Normalise gradients
+	vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
+
+	p0 *= norm.x;
+	p1 *= norm.y;
+	p2 *= norm.z;
+	p3 *= norm.w;
+
+	// Mix final noise value
+	vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
+	m = m * m;
+
+	return 35.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1), dot(p2,x2), dot(p3,x3)));
+}
+
+float Turbulence(vec3 position, float minFreq, float maxFreq, float qWidth)
+{
+	float value = 0.0;
+	float cutoff = clamp(0.5/qWidth, 0.0, maxFreq);
+	float fade;
+	float fOut = minFreq;
+
+	for(int i=NoiseSteps ; i>=0 ; i--)
+	{
+		if(fOut >= 0.5 * cutoff) break;
+
+		fOut *= 2.0;
+		value += abs(snoise(position * fOut))/fOut;
+	}
+
+	fade = clamp(2.0 * (cutoff-fOut)/cutoff, 0.0, 1.0);
+	value += fade * abs(snoise(position * fOut))/fOut;
+
+	return 1.0-value;
+}
+
+float SphereDist(vec3 position)
+{
+	return length(position - ExpPosition) - Radius;
+}
+
+vec4 Shade(float distance)
+{
+	float c1 = saturate(distance*5.0 + 0.5);
+	float c2 = saturate(distance*5.0);
+	float c3 = saturate(distance*3.4 - 0.5);
+	
+	vec4 a = mix(Color1,Color2, c1);
+	vec4 b = mix(a,     Color3, c2);
+	return 	 mix(b,     Color4, c3);
+}
+
+
+// Draws the scene
+float RenderScene(vec3 position, out float distance)
+{
+	float noise = Turbulence(position * NoiseFrequency + Animation*time*0.25, 0.1, 1.5, 0.03) * NoiseAmplitude;
+	noise = saturate(abs(noise));
+	distance = SphereDist(position) - noise;
+		
+	return noise;
+}
+
+// Basic ray marching method.
+vec4 March(vec3 rayOrigin, vec3 rayStep)
+{
+	vec3 position = rayOrigin;
+	
+	float distance;
+	float displacement;
+	
+	for(int step = MarchSteps; step >=0  ; --step)
+	{
+		displacement = RenderScene(position, distance);
+	
+		if(distance < 0.05) break;
+		
+		position += rayStep * distance;
+	}
+	return mix(Shade(displacement), Background, float(distance >= 0.5));
+}
+
+bool IntersectSphere(vec3 ro, vec3 rd, vec3 pos, float radius, out vec3 intersectPoint)
+{
+	vec3 relDistance = (ro - pos);
+	
+	float b = dot(relDistance, rd);
+	float c = dot(relDistance, relDistance) - radius*radius;
+	float d = b*b - c;
+	
+	intersectPoint = ro + rd*(-b - sqrt(d));
+	
+	return d >= 0.0;
+}
+
+void main(void)
+{
+	vec2 p = (gl_FragCoord.xy / resolution.xy) * 2.0 - 1.0;
+	
+	p.x *= resolution.x/resolution.y;
+
+	float rotx = mouse.y * 4.0;
+	float roty = -mouse.x * 4.0;
+	float zoom = 5.0;
+
+	// camera
+	vec3 ro = zoom * normalize(vec3(cos(roty), cos(rotx), sin(roty)));
+	vec3 ww = normalize(vec3(0.0, 0.0, 0.0) - ro);
+	vec3 uu = normalize(cross( vec3(0.0, 1.0, 0.0), ww));
+	vec3 vv = normalize(cross(ww, uu));
+	vec3 rd = normalize(p.x*uu + p.y*vv + 1.5*ww);
+
+	vec4 col = Background;
+
+	vec3 origin;
+	
+	if(IntersectSphere(ro, rd, ExpPosition, Radius + NoiseAmplitude*6.0, origin))
+	{
+		col = March(origin, rd);
+	}
+	
+	color_out = col;
+}

data/ext/pixo/patterns/flame.glsl

@@ -0,0 +1,101 @@
+#version 330 core
+
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+// here i fixed
+
+#extension GL_OES_standard_derivatives : enable
+
+uniform float time;
+uniform vec2 mouse;
+uniform vec2 resolution;
+
+uniform vec3      iResolution;           // viewport resolution (in pixels)
+uniform float     iGlobalTime;           // shader playback time (in seconds)
+uniform float     iTimeDelta;            // render time (in seconds)
+uniform int       iFrame;                // shader playback frame
+uniform float     iChannelTime[4];       // channel playback time (in seconds)
+uniform vec3      iChannelResolution[4]; // channel resolution (in pixels)
+uniform vec4      iMouse;                // mouse pixel coords. xy: current (if MLB down), zw: click
+uniform vec4      iDate;                 // (year, month, day, time in seconds)
+uniform float     iSampleRate;           // sound sample rate (i.e., 44100)
+out vec4 color_out;
+
+float noise(vec3 p) //Thx to Las^Mercury
+{
+  vec3 i = floor(p);
+  vec4 a = dot(i, vec3(1., 57., 21.)) + vec4(0., 57., 21., 78.);
+  vec3 f = cos((p-i)*acos(-1.))*(-.5)+.5;
+  a = mix(sin(cos(a)*a),sin(cos(1.+a)*(1.+a)), f.x);
+  a.xy = mix(a.xz, a.yw, f.y);
+  return mix(a.x, a.y, f.z);
+}
+
+float sphere(vec3 p, vec4 spr)
+{
+  return length(spr.xyz-p) - spr.w;
+}
+
+float flame(vec3 p)
+{
+  float d = sphere(p*vec3(1.,.5,1.), vec4(.0,-1.,.0,1.));
+  return d + (noise(p+vec3(.0,time*2.,.0)) + noise(p*3.+vec3(.0,time*11.,.0))*.5)*.25*(p.y) ;
+}
+
+float scene(vec3 p)
+{
+  return min(100.-length(p) , abs(flame(p)) );
+}
+
+vec4 raymarch(vec3 org, vec3 dir)
+{
+  float d = 0.0, glow = 0.0, eps = 0.02;
+  vec3  p = org;
+  bool glowed = false;
+  
+  for(int i=0; i<64; i++)
+  {
+    d = scene(p) + eps;
+    p += d * dir;
+    if( d>eps )
+    {
+      if(flame(p) < .0)
+        glowed=true;
+      if(glowed)
+            glow = float(i)/64.;
+    }
+  }
+  return vec4(p,glow);
+}
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord )
+{
+  vec2 v = -1.0 + 2.0 * fragCoord.xy / resolution.xy;
+  v.x *= resolution.x/resolution.y;
+  
+  vec3 org = vec3(0., -2., 4.);
+  vec3 dir = normalize(vec3(v.x*1.6, -v.y, -1.5));
+  
+  vec4 p = raymarch(org, dir);
+  float glow = p.w;
+  
+  vec4 col = mix(vec4(1.,.5,.1,1.), vec4(0.1,.5,1.,1.), p.y*.02+.4);
+  
+  fragColor = mix(vec4(0.), col, pow(glow*2.,4.));
+  //fragColor = mix(vec4(1.), mix(vec4(1.,.5,.1,1.),vec4(0.1,.5,1.,1.),p.y*.02+.4), pow(glow*2.,4.));
+
+}
+
+void main( void ) {
+  
+  vec4 fragColor;
+  
+//  vec2 fragCoord = ( gl_FragCoord.xy / resolution.xy ) + mouse / 4.0;
+
+  mainImage(fragColor, gl_FragCoord.xy);
+
+  color_out = fragColor;
+}

data/ext/pixo/patterns/flower.glsl

@@ -0,0 +1,27 @@
+#version 330 core
+out vec4 color_out;
+// http://glslsandbox.com/e#39265.0
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+uniform float time;
+uniform vec2 resolution;
+// Leadlight by @hintz 2013-05-02
+// modified by Harry   2014-01-05
+void main()
+{
+  /// integers values align perfectly
+  float numSides = 9.;
+  
+  float brightness = 1. + abs(cos(time/5.) * 3.);
+  float size = 7. + sin(time/20.) * 50.;
+  
+  vec2 position = (gl_FragCoord.xy - 0.5*resolution) / resolution.xx ;
+  float r = length(position);
+  float a = atan(position.y, position.x);
+  float t = time + size/(r+1.0);  
+  float light = brightness*abs(0.05*(sin(t)+sin(time+a*numSides) ) );
+  vec3 color = vec3(-sin(r*5.0-a-time+sin(r+t)), sin(r*3.0+a-time+sin(r+t)), cos(r+a*2.0+a+time)-sin(r+t));
+  color_out = vec4((normalize(color)+1.7) * light , 1.0);
+}

data/ext/pixo/patterns/galaxy.glsl

@@ -0,0 +1,50 @@
+#version 330 core
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+uniform float time;
+uniform vec2 resolution;
+out vec4 color_out;
+
+void main()
+{
+
+    vec2 uv = (gl_FragCoord.xy/resolution.xy)-.5;
+
+    float time = time * .1 + ((.25+.05*sin(time*.1))/(length(uv.xy)+.07))* 2.2;
+    float si = sin(time);
+    float co = cos(time);
+    mat2 ma = mat2(co, si, -si, co);
+
+    float c = 0.0;
+    float v1 = 0.0;
+    float v2 = 0.0;
+
+    for (int i = 0; i < 100; i++)
+    {
+        float s = float(i) * .035;
+        vec3 p = s * vec3(uv, 0.0);
+        p.xy *= ma;
+        p += vec3(.22,.3, s-1.5-sin(time*.13)*.1);
+        for (int i = 0; i < 8; i++)
+        {
+            p = abs(p) / dot(p,p) - 0.659;
+        }
+        v1 += dot(p,p)*.0015 * (1.8+sin(length(uv.xy*13.0)+.5-time*.2));
+        v2 += dot(p,p)*.0015 * (1.5+sin(length(uv.xy*13.5)+2.2-time*.3));
+        c = length(p.xy*.5) * .35;
+    }
+
+    float len = length(uv);
+    v1 *= smoothstep(.7, .0, len);
+    v2 *= smoothstep(.6, .0, len);
+
+    float re = clamp(c, 0.0, 1.0);
+    float gr = clamp((v1+c)*.25, 0.0, 1.0);
+    float bl = clamp(v2, 0.0, 1.0);
+    vec3 col = vec3(re, gr, bl) + smoothstep(0.15, .0, len) * .9;
+
+    color_out=vec4(col, 1.0);
+}

data/ext/pixo/patterns/goop.glsl

@@ -0,0 +1,117 @@
+#version 330 core
+out vec4 color_out;
+
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+// #extension GL_OES_standard_derivatives : enable
+
+uniform float time;
+uniform vec2 mouse;
+uniform vec2 resolution;
+
+//----------------------------------------------------------
+// metaballss by pailhead in 2014-Jun-2
+// original:  https://www.shadertoy.com/view/4sXXWM
+// small modifications & antialiasing by I.G.P. 2016-09-24
+// This must be nice in 3d too...
+//----------------------------------------------------------
+// http://glslsandbox.com/e#35480.0
+
+#define COUNT 55
+
+#define SPEED 0.1
+
+#define SIZE 44.
+
+//----------------------------------------------------------
+float rn(float x)
+{
+    return  fract(sin(x*.4686)*3718.927);
+}
+
+//----------------------------------------------------------
+void mainImage( out vec4 fragColor, in vec2 fragCoord ) 
+{
+	float ts = time * SPEED;   // time scaled
+	
+	vec3 COLOR_MASKS[16];  // blob colors
+	COLOR_MASKS[0] = vec3(1.00, 0.50, 0.00 );
+  	COLOR_MASKS[1] = vec3(0.53, 0.85, 0.25 );
+  	COLOR_MASKS[2] = vec3(1.00, 0.56, 0.15 );
+  	COLOR_MASKS[3] = vec3(1.00, 0.00, 0.30 );
+  	COLOR_MASKS[4] = vec3(0.05, 0.55, 0.30 );
+	COLOR_MASKS[5] = vec3(0.50, 1.00, 0.40 );
+  	COLOR_MASKS[6] = vec3(1.00, 0.15, 1.00 );
+  	COLOR_MASKS[7] = vec3(0.20, 0.30, 0.50 );
+  	COLOR_MASKS[8] = vec3(0.35, 1.00, 0.50 );
+  	COLOR_MASKS[9] = vec3(0.70, 0.60, 0.50 );
+  	COLOR_MASKS[10]= vec3(0.34, 1.00, 0.50 );
+  	COLOR_MASKS[11]= vec3(0.20, 0.50, 0.50 );
+  	COLOR_MASKS[12]= vec3(0.60, 0.10, 0.65 );
+  	COLOR_MASKS[13]= vec3(0.40, 0.40, 0.85 );
+  	COLOR_MASKS[14]= vec3(1.00, 0.30, 0.35 );
+  	COLOR_MASKS[15]= vec3(1.00, 0.00, 0.50 );
+	
+	//screen space
+	float aspect = resolution.x / resolution.y;
+	vec2 fragPN = (fragCoord / resolution.xy) * 2.0 - 1.0;   //-1 .. 1
+	fragPN.x *= aspect;
+	float vH = 10.0;   // camera disance - fov
+	vec3 vD = normalize(vec3(-fragPN,vH));   // view dir
+	//vec3 lD = normalize(vec3(cos(time),.750,sin(time)));   // light dir	
+	
+	vec3 lD = normalize(vec3(mouse.xy-vec2(0.5), 0.5));   // light dir	
+	
+	vec3 ld = normalize(vec3(.7, .750,2.));
+	
+	vec2 mbPos[COUNT];  // blob position
+	vec3 nn = vec3(.0);
+	vec3 cc = vec3(.0);
+
+	for(int i=0; i<COUNT; i++)
+	{
+		vec3 bC = COLOR_MASKS[i-(i/15)*15]; // blob color
+		float rn1 = rn(float(i+47));
+		float rn2 = rn(float(i-21));
+		float rn3 = rn(float(i-52));
+		
+		if (i==0)   // set blob[0] to mouse position
+		     mbPos[i] = 1.25*(mouse.xy*2. -1.) * vec2(aspect,1.);   // mouse position
+		else mbPos[i] = vec2(sin(rn1*6.14+ts * rn2)*aspect,
+			        cos(rn2*6.14+ts * rn3));  // calc position
+		
+		mbPos[i] = fragPN - mbPos[i]*.8;
+		float rr = cos(rn3*6.28 +ts * rn1)*.2 +.5;
+		mbPos[i] *= rr * (1000. / SIZE);   // blob coord
+		float bL = length( mbPos[i] );     // blob length
+		float bH = exp(-bL*2.15678);
+		vec3 bN = vec3(mbPos[i] * .3 *bH, bH-.01);
+		bC *= bH;
+		nn += vec3(mbPos[i]*.5*bH,bH);
+		cc += bC;
+	}
+	
+	vec3 n = normalize( vec3(nn.x, nn.y, nn.z-0.1) );
+	float aB = smoothstep(0.0, 0.5, n.z);  // antialiasing edge !!!
+	cc /= nn.z;
+	float ndl = 0.3 + 0.7 * dot(n,lD);   //wrap
+	vec3 h = normalize(vD+lD);
+	float ndh = 0.5 + 0.5 * dot(n,h);
+	ndh = pow(ndh,1.+2000.0 *(mouse.x))*(0.2 + .65*mouse.x);  // light reflection
+	vec3 fc = cc*ndl +ndh;
+	
+	float frs = dot(n,vD);
+	frs = 1.0-clamp(frs,.0,1.);
+	frs = pow(frs,100.0);
+	frs = frs*.4 +.121;
+	fc += frs;
+	fragColor = vec4( fc*aB, 1.);
+}
+
+void main( void ) 
+{
+	mainImage( color_out, gl_FragCoord.xy );
+}

data/ext/pixo/patterns/hypno_rings.glsl

@@ -0,0 +1,13 @@
+#version 330 core
+out vec4 color_out;
+
+uniform float time;
+uniform vec2 mouse;
+in vec2 surfacePosition;
+
+void main( void ) {
+
+  float len = length(surfacePosition*100.);
+  color_out = vec4( (vec3(0.5+0.5*sin(time-vec3(20.*len/pow(len,0.88))+(3.14*sin(len/pow(vec3(len),vec3(.77,.66,.45))))))), 1.0 );
+
+}

data/ext/pixo/patterns/lightning.glsl

@@ -0,0 +1,111 @@
+#version 330 core
+out vec4 color_out;
+
+// Lightning
+//
+// Modified by: Eivind Magnus Hvidevold
+// hvidevold at gmail dot com
+//
+// By: Brandon Fogerty
+// bfogerty at gmail dot com 
+// xdpixel.com
+
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+uniform float time;
+uniform vec2 mouse;
+uniform vec2 resolution;
+
+float random( vec2 p )
+{
+  return fract( sin( fract( sin( p.x ) ) + p.y) * 42.17563);
+}
+
+float worley( vec2 p, float timeSpeed )
+{
+  float d = 10.0;
+  for( int xo = -1; xo <= 1; xo++ )
+  {
+    for( int yo = -1; yo <= 1; yo++ )
+      {
+      vec2 test_cell = floor(p) + vec2( xo, yo );
+      
+      float f1 = random( test_cell );
+      float f2 = random( test_cell + vec2(1.0,83.0) );
+      
+      float xp = mix( f1, f2, sin(f1*time*timeSpeed) );
+      float yp = mix( f1, f2, cos(f2*time*timeSpeed) );
+      
+      vec2 c = test_cell + vec2(xp,yp);
+      
+      vec2 cTop = p - c;
+      d = min( d, dot(cTop,cTop) );
+    }
+  }
+  return d;
+}
+
+float pass( vec2 uv, float timeSpeed )
+{
+  float t = worley( gl_FragCoord.xy * 0.05, timeSpeed );
+  //t = pow(t, 2.0 );
+  
+  return t;
+}
+
+float Hash( vec2 p)
+{
+     vec3 p2 = vec3(p.xy,1.0);
+    return fract(sin(dot(p2,vec3(35.234234231,21.2342323437, 1242.245234354)))*3758.5453123);
+}
+
+float noise(in vec2 p)
+{
+    vec2 i = floor(p);
+     vec2 f = fract(p);
+     f *= f * (3.0-2.0*f);
+
+    return mix(mix(Hash(i + vec2(0.,0.)), Hash(i + vec2(1.,0.)),f.x),
+               mix(Hash(i + vec2(0.,1.)), Hash(i + vec2(1.,1.)),f.x),
+               f.y);
+}
+
+float fbm(vec2 p)
+{
+     float v = 0.0;
+     v += noise(p*1.0)*.5;
+     v += noise(p*2.)*.25;
+     v += noise(p*4.)*.125;
+     return v;
+}
+
+void main( void ) 
+{
+
+  vec2 uv = ( gl_FragCoord.xy / resolution.xy ) * 2.0 - 1.0;
+  //uv.x *= resolution.x/resolution.y;
+  vec2 uvNonPolar = uv;
+  uv = vec2((sqrt(uv.x*uv.x+uv.y*uv.y)-1.0)*(sin(time)+2.0)/2.0, sin(atan(uv.y, uv.x)*2.0+time));
+  
+  float timeVal = time;
+  vec3 finalColor = vec3( 0.0 );
+  for( int i=0; i < 20; ++i )
+  {
+    float indexAsFloat = float(i);
+    float p = pass(uvNonPolar, 6.0);
+    float indexScale = indexAsFloat / 20.0;
+    float amp = 125.0 + (indexAsFloat*0.01);
+    float period = 0. + (indexAsFloat*0.01+.5) + sin(p)/1000.0;
+    float thickness = mix( 0.7, 1.0, noise(uv*10.0) ) * 0.1;
+    float t = abs( 1.0 / (sin(uv.x + fbm( uv + timeVal * period) ) * amp) * thickness );
+    
+    finalColor += t * vec3( indexScale*0.87, 0.43, 0.63 ) * 5.0;
+    //finalColor *= pass(uv, 6.0);
+  }
+  
+  color_out = vec4( finalColor, 1.0 );
+
+}