pixo 0.1.0

data/ext/pixo/patterns/clouds.glsl

@@ -0,0 +1,382 @@
+#version 330 core
+
+#ifdef GL_ES
+precision highp float;
+#endif
+
+uniform float time;
+uniform vec2 mouse;
+uniform vec2 resolution;
+in vec2 surfacePosition;
+in vec2 surfaceSize;
+out vec4 color_out;
+
+vec3   iResolution = vec3(resolution, 1.0);
+float  iGlobalTime = time;
+vec4   iMouse = vec4(mouse, 0.0, 1.0);
+uniform sampler2D iChannel0,iChannel1,bb;
+
+// srtuss, 2015
+// volumetric cloud tunnel, a single light source, lightning and something that is supposed
+// to look like raindrops. :)
+// visuals are inspired by a piece of music, 2d-texture based 3d noise function by iq.
+// the code could need some cleaning, but i don't want to do that right now.
+
+
+// srtuss: Absolutely spectacular sir! My hat off to you 
+
+#define pi 3.1415926535897932384626433832795
+
+struct ITSC
+{
+  vec3 p;
+  float dist;
+  vec3 n;
+    vec2 uv;
+};
+
+ITSC raycylh(vec3 ro, vec3 rd, vec3 c, float r)
+{
+  ITSC i;
+  i.dist = 1e38;
+  vec3 e = ro - c;
+  float a = dot(rd.xy, rd.xy);
+  float b = 2.0 * dot(e.xy, rd.xy);
+  float cc = dot(e.xy, e.xy) - r;
+  float f = b * b - 4.0 * a * cc;
+  if(f > 0.0)
+  {
+    f = sqrt(f);
+    float t = (-b + f) / (2.0 * a);
+    
+    if(t > 0.001)
+    {
+      i.dist = t;
+      i.p = e + rd * t;
+      i.n = -vec3(normalize(i.p.xy), 0.0);
+    }
+  }
+  return i;
+}
+
+void tPlane(inout ITSC hit, vec3 ro, vec3 rd, vec3 o, vec3 n, vec3 tg, vec2 si)
+{
+    vec2 uv;
+    ro -= o;
+    float t = -dot(ro, n) / dot(rd, n);
+    if(t < 0.0)
+        return;
+    vec3 its = ro + rd * t;
+    uv.x = dot(its, tg);
+    uv.y = dot(its, cross(tg, n));
+    if(abs(uv.x) > si.x || abs(uv.y) > si.y)
+        return;
+    
+    //if(t < hit.dist)
+    {
+        hit.dist = t;
+        hit.uv = uv;
+    }
+    return;
+}
+
+
+
+#define noTexture true
+
+mat3 m = mat3( 0.00, 0.90, 0.60, 
+-0.90, 0.36, -0.48, 
+-0.60, -0.48, 0.34 );
+
+//----------------------------------------------------------------------
+float hsh( float n )
+{
+  return fract(sin(n)*43758.5453123);
+}
+
+
+
+float nseI(float x)
+{
+    float fl = floor(x);
+    return mix(hsh(fl), hsh(fl + 1.0), smoothstep(0.0, 1.0, fract(x)));
+}
+
+vec2 rotate(vec2 p, float a)
+{
+  return vec2(p.x * cos(a) - p.y * sin(a), p.x * sin(a) + p.y * cos(a));
+}
+
+float nse3d(in vec3 x)
+{
+  vec3 p = floor(x);
+  vec3 f = fract(x);
+  f = f*f*(3.0-2.0*f);
+
+  #ifdef noTexture
+    float n = p.x + p.y*57.0 + 113.0*p.z;
+    return mix(mix(mix( hsh(n+  0.0), hsh(n+  1.0), f.x), 
+    mix( hsh(n+ 57.0), hsh(n+ 58.0), f.x), f.y), 
+      mix(mix( hsh(n+113.0), hsh(n+114.0), f.x), 
+      mix( hsh(n+170.0), hsh(n+171.0), f.x), f.y), f.z);
+  #else
+    vec2 uv = (p.xy + vec2(37.0, 17.0)*p.z) + f.xy;
+    vec2 rg = texture2D( texture, mod((uv+ 0.5)/256.0, 1.0), -100.0 ).yx;
+    return mix( rg.x, rg.y, f.z );  
+  #endif
+}
+float nse(in vec2 x)
+{
+  vec2 p = floor(x);
+  vec2 f = fract(x);
+  f = f*f*(6.0-4.0*f);
+
+  float n = p.x + p.y*57.0;
+  float res = mix(mix( hsh(n+  0.0), hsh(n+  1.0), f.x), 
+  mix( hsh(n+ 57.0), hsh(n+ 58.0), f.x), f.y);
+  return res;
+}
+float density2(vec2 p, float z, float t)
+{
+    float v = 0.0;
+    float fq = 1.0, am = 0.5, mvfd = 1.0;
+    vec2 rnd = vec2(0.3, 0.7);
+    for(int i = 0; i < 7; i++)
+    {
+        rnd = fract(sin(rnd * 14.4982) * 2987253.28612);
+        v += nse(p * fq + t * (rnd - 0.5)) * am;
+        fq *= 2.0;
+        am *= 0.5;
+        mvfd *= 1.3;
+    }
+    return v * exp(z * z * -2.0);
+}
+
+float densA = 1.0, densB = 2.0;
+
+float fbm(vec3 p)
+{
+    vec3 q = p;
+    q.xy = rotate(p.xy, iGlobalTime);
+    
+    p += (nse3d(p * 3.0) - 0.5) * 0.3;
+    
+    //float v = nse3d(p) * 0.5 + nse3d(p * 2.0) * 0.25 + nse3d(p * 4.0) * 0.125 + nse3d(p * 8.0) * 0.0625;
+    
+    //p.y += iGlobalTime * 0.2;
+    
+    float mtn = iGlobalTime * 0.15;
+    
+    float v = 0.0;
+    float fq = 1.0, am = .45;
+    for(int i = 0; i < 6; i++)
+    {
+        v += nse3d(p * fq + mtn * fq) * am;
+        fq *= 2.;
+        am *= 0.5;
+    }
+    return v;
+}
+
+float fbmHQ(vec3 p)
+{
+    vec3 q = p;
+    q.xy = rotate(p.xy, iGlobalTime);
+    
+    p += (nse3d(p * 3.0) - 0.5) * 0.4;
+    
+    //float v = nse3d(p) * 0.5 + nse3d(p * 2.0) * 0.25 + nse3d(p * 4.0) * 0.125 + nse3d(p * 8.0) * 0.0625;
+    
+    //p.y += iGlobalTime * 0.2;
+    
+    float mtn = iGlobalTime * 0.2;
+    
+    float v = 0.0;
+    float fq = 1.0, am = 0.5;
+    for(int i = 0; i < 9; i++)
+    {
+        v += nse3d(p * fq + mtn * fq) * am;
+        fq *= 2.0;
+        am *= 0.5;
+    }
+    return v;
+}
+
+float density(vec3 p)
+{
+    vec2 pol = vec2(atan(p.y, p.x), length(p.yx));
+    
+    float v = fbm(p);
+    
+    float fo = atan((pol.y - 1.5),(pol.y - 1.5)+(densA + densB) * 0.5);
+    fo *= (densB - densA);
+    v *= exp(fo * fo * -5.0);
+    
+    float edg = .323;
+    return smoothstep(edg, edg + 0.05, v);
+}
+
+float densityHQ(vec3 p)
+{
+    vec2 pol = vec2(atan(p.y, p.x), length(p.yx));
+    
+    float v = fbmHQ(p);
+    
+    float fo = atan((pol.y - 1.5),(pol.y - 1.5)+(densA + densB) * 0.5);
+    fo *= (densB - densA);
+    v *= exp(fo * fo * -5.0);
+    
+    float edg = 0.3;
+    return smoothstep(edg, edg + 0.1, v);
+}
+
+vec2 drop(inout vec2 p)
+{
+    vec2 mv = iGlobalTime * vec2(0.5, -1.0) * 0.15;
+    
+    float drh = 0.0;
+    float hl = 0.0;
+    
+    vec4 rnd = vec4(0.1, 0.2, 0.3, 0.4);
+    for(int i = 0; i < 20; i++)
+    {
+        rnd = fract(sin(rnd * 2.184972) * 190723.58961);
+        float fd = fract(iGlobalTime * 0.2 + rnd.w);
+        fd = exp(fd * -4.0);
+        float r = 0.025 * (rnd.w * 1.5 + 1.0);
+        float sz = 0.35;
+        
+        
+        vec2 q = (fract((p - mv) * sz + rnd.xy) - 0.5) / sz;
+        mv *= 1.06;
+        
+        q.y *= -1.0;
+        float l = length(q + pow(abs(dot(q, vec2(1.0, 0.4))), 0.7) * (fd * 0.2 + 0.1));
+        if(l < r)
+        {
+          float h = sqrt(r * r - l * l);
+          drh = max(drh, h * fd);
+        }
+        hl += exp(length(q - vec2(-0.02, 0.01)) * -30.0) * 0.4 * fd;
+    }
+    p += drh * 5.0;
+    return vec2(drh, hl);
+}
+
+
+float hash1(float p)
+{
+  return fract(sin(p * 172.435) * 29572.683) - 0.5;
+}
+
+float hash2(vec2 p)
+{
+  vec2 r = (456.789 * sin(789.123 * p.xy));
+  return fract(r.x * r.y * (1.0 + p.x));
+}
+
+float ns(float p)
+{
+  float fr = fract(p);
+  float fl = floor(p);
+  return mix(hash1(fl), hash1(fl + 1.0), fr);
+}
+
+float fbm(float p)
+{
+  return (ns(p) * 0.4 + ns(p * 2.0 - 10.0) * 0.125 + ns(p * 8.0 + 10.0) * 0.025);
+}
+
+float fbmd(float p)
+{
+  float h = 0.01;
+  return atan(fbm(p + h) - fbm(p - h), h);
+}
+
+float arcsmp(float x, float seed)
+{
+  return fbm(x * 3.0 + seed * 1111.111) * (1.0 - exp(-x * 5.0));
+}
+
+float arc(vec2 p, float seed, float len)
+{
+  p *= len;
+  //p = rotate(p, iGlobalTime);
+  float v = abs(p.y - arcsmp(p.x, seed));
+  v += exp((2.0 - p.x) * -4.0);
+  v = exp(v * -60.0) + exp(v * -10.0) * 0.6;
+  //v += exp(p.x * -2.0);
+  v *= smoothstep(0.0, 0.05, p.x);
+  return v;
+}
+
+float arcc(vec2 p, float sd)
+{
+  float v = 0.0;
+  float rnd = fract(sd);
+  float sp = 0.0;
+  v += arc(p, sd, 1.0);
+  for(int i = 0; i < 4; i ++)
+  {
+    sp = rnd + 0.01;
+    vec2 mrk = vec2(sp, arcsmp(sp, sd));
+    v += arc(rotate(p - mrk, fbmd(sp)), mrk.x, mrk.x * 0.4 + 1.5);
+    rnd = fract(sin(rnd * 195.2837) * 1720.938);
+  }
+  return v;
+}
+
+void main(void)
+{
+  vec2 uv = gl_FragCoord.xy / iResolution.xy;
+    
+    uv = 2.0 * uv - 1.0;
+    uv.x *= iResolution.x / iResolution.y;
+    
+    vec2 drh = vec2(0,0);//drop(uv);
+    
+    float camtm = iGlobalTime * 1.55;
+    vec3 ro = vec3(0., 0.0, camtm);
+    vec3 rd = normalize(vec3(uv, 1.2));
+   // rd.xz = rotate(rd.xz, sin(camtm) * 0.4);
+   // rd.yz = rotate(rd.yz, sin(camtm * 1.3) * 0.4);
+    
+    vec3 sun = normalize(vec3(0.2, 1.0, 0.1));
+    
+    float sd = sin(gl_FragCoord.x * 0.01 + gl_FragCoord.y * 3.333333333 + iGlobalTime) * 1298729.146861;
+    
+    vec3 col;
+    float dacc = 0.0, lacc = 0.0;
+    
+    vec3 light = vec3(cos(iGlobalTime * 8.0) * 0.5, sin(iGlobalTime * 4.0) * 0.5, ro.z + 4.0 + sin(iGlobalTime));
+    
+    ITSC tunRef;
+    #define STP 10
+    for(int i = 0; i < STP; i++)
+    {
+        ITSC itsc = raycylh(ro, rd, vec3(0.0), densB + float(i) * (densA - densB) / float(STP) + fract(sd) * 0.07);
+        float d = density(itsc.p);
+        vec3 tol = light - itsc.p;
+        float dtol = length(tol);
+        tol = tol * 0.1 / dtol;
+        
+        float dl = density(itsc.p + tol);
+        lacc += max(d - dl, 0.0) * exp(dtol * -0.2);
+        dacc += d;
+        tunRef = itsc;
+    }
+    dacc /= float(STP);
+    ITSC itsc = raycylh(ro, rd, vec3(0.0), 4.0);
+    vec3 sky = vec3(0.6, 0.3, 0.2);
+    sky *= 0.9 * pow(fbmHQ(itsc.p), 2.0);
+    lacc = max(lacc * 0.3 + 0.3, 0.0);
+    vec3 cloud = pow(vec3(lacc), vec3(0.5, 0.0, 0.0) * 1.0);
+    col = mix(sky, cloud, dacc);
+    col *= exp(tunRef.dist * -0.1);
+    col += drh.y;
+    
+   
+    col = pow(col, vec3(1.0, 0.9, 0.6) * 1.4) * 1.1;
+    col = pow(col, vec3(1.0 / 2.2));
+  color_out = vec4(col, 1.0);
+}

data/ext/pixo/patterns/cnoise.glsl

@@ -0,0 +1,162 @@
+#version 330 core
+
+#ifdef GL_ES
+precision highp float;
+#endif
+#define PI 3.1415926535897932384626433832795
+
+uniform float time;
+uniform vec2 resolution;
+
+out vec4 color_out;
+
+//
+// GLSL textureless classic 3D noise "cnoise",
+// with an RSL-style periodic variant "pnoise".
+// Author:  Stefan Gustavson (stefan.gustavson@liu.se)
+// Version: 2011-10-11
+//
+// Many thanks to Ian McEwan of Ashima Arts for the
+// ideas for permutation and gradient selection.
+//
+// Copyright (c) 2011 Stefan Gustavson. 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 / 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);
+}
+
+// Classic Perlin noise
+float cnoise(vec3 P)
+{
+  vec3 Pi0 = floor(P); // Integer part for indexing
+  vec3 Pi1 = Pi0 + vec3(1.0); // Integer part + 1
+  Pi0 = mod289(Pi0);
+  Pi1 = mod289(Pi1);
+  vec3 Pf0 = fract(P); // Fractional part for interpolation
+  vec3 Pf1 = Pf0 - vec3(1.0); // Fractional part - 1.0
+  vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+  vec4 iy = vec4(Pi0.yy, Pi1.yy);
+  vec4 iz0 = Pi0.zzzz;
+  vec4 iz1 = Pi1.zzzz;
+
+  vec4 ixy = permute(permute(ix) + iy);
+  vec4 ixy0 = permute(ixy + iz0);
+  vec4 ixy1 = permute(ixy + iz1);
+
+  vec4 gx0 = ixy0 * (1.0 / 7.0);
+  vec4 gy0 = fract(floor(gx0) * (1.0 / 7.0)) - 0.5;
+  gx0 = fract(gx0);
+  vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0);
+  vec4 sz0 = step(gz0, vec4(0.0));
+  gx0 -= sz0 * (step(0.0, gx0) - 0.5);
+  gy0 -= sz0 * (step(0.0, gy0) - 0.5);
+
+  vec4 gx1 = ixy1 * (1.0 / 7.0);
+  vec4 gy1 = fract(floor(gx1) * (1.0 / 7.0)) - 0.5;
+  gx1 = fract(gx1);
+  vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1);
+  vec4 sz1 = step(gz1, vec4(0.0));
+  gx1 -= sz1 * (step(0.0, gx1) - 0.5);
+  gy1 -= sz1 * (step(0.0, gy1) - 0.5);
+
+  vec3 g000 = vec3(gx0.x,gy0.x,gz0.x);
+  vec3 g100 = vec3(gx0.y,gy0.y,gz0.y);
+  vec3 g010 = vec3(gx0.z,gy0.z,gz0.z);
+  vec3 g110 = vec3(gx0.w,gy0.w,gz0.w);
+  vec3 g001 = vec3(gx1.x,gy1.x,gz1.x);
+  vec3 g101 = vec3(gx1.y,gy1.y,gz1.y);
+  vec3 g011 = vec3(gx1.z,gy1.z,gz1.z);
+  vec3 g111 = vec3(gx1.w,gy1.w,gz1.w);
+
+  vec4 norm0 = taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+  g000 *= norm0.x;
+  g010 *= norm0.y;
+  g100 *= norm0.z;
+  g110 *= norm0.w;
+  vec4 norm1 = taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+  g001 *= norm1.x;
+  g011 *= norm1.y;
+  g101 *= norm1.z;
+  g111 *= norm1.w;
+
+  float n000 = dot(g000, Pf0);
+  float n100 = dot(g100, vec3(Pf1.x, Pf0.yz));
+  float n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z));
+  float n110 = dot(g110, vec3(Pf1.xy, Pf0.z));
+  float n001 = dot(g001, vec3(Pf0.xy, Pf1.z));
+  float n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z));
+  float n011 = dot(g011, vec3(Pf0.x, Pf1.yz));
+  float n111 = dot(g111, Pf1);
+
+  vec3 fade_xyz = fade(Pf0);
+  vec4 n_z = mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fade_xyz.z);
+  vec2 n_yz = mix(n_z.xy, n_z.zw, fade_xyz.y);
+  float n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
+  return 2.2 * n_xyz;
+}
+
+float surface3 ( vec3 coord ) {
+	
+	float frequency = 4.0;
+	float n = 0.0;	
+		
+	n += 1.0	* abs( cnoise( coord * frequency * 3.0) );
+//	n += 0.5	* abs( cnoise( coord * frequency * 2.0 ) );
+//	n += 0.25	* abs( cnoise( coord * frequency * 4.0 ) );
+	
+	return n;
+}
+	
+void main( void ) {
+	
+	vec2 position = gl_FragCoord.xy / resolution.xy;
+	
+	float n = surface3(vec3(position, time * 0.1));
+	float ns = abs((n * 2.0) - 1.0);
+	
+	const int colorCount = 5;
+	vec3 color[colorCount];
+	color[0] = vec3(1.0,0.07,0.07);
+	color[1] = vec3(1.0,0.93,0.07);
+	color[2] = vec3(0.87,0.5,1.0);
+	color[3] = vec3(0.25,0.25,1.0);
+	color[4] = vec3(1.0,1.0,1.0);
+	
+	vec3 curColor = color[0];
+	
+	for(int i = 0; i < colorCount; i++) {
+		int cidx = int(floor(float(colorCount) * ns));
+		if(i == cidx) { curColor = color[i]; }
+	}
+	curColor = color[4]*ns;
+  const float rotation = 4.0;
+	color_out = vec4(
+    sin(curColor.x + time/rotation + PI*2.0*1.0/3.0),
+    sin(curColor.y + time/rotation + PI*2.0*2.0/3.0),
+    sin(curColor.z + time/rotation + PI*2.0*3.0/3.0),
+    1.0);
+}
+

data/ext/pixo/patterns/corrente_continua.glsl

@@ -0,0 +1,51 @@
+#version 330 core
+out vec4 color_out;
+
+// Corrente Continua - 1k intro (win32)
+// Zerothehero of Topopiccione
+// 25/jul/2012
+
+//@zerothehero: better formulas, visually improved
+
+// mod by mojovideotech
+// http://glslsandbox.com/e#32862.0
+
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+uniform float time;
+uniform vec2 mouse;
+uniform vec2 resolution;
+const float di = 0.5772156649;
+const float dh = 0.69314718;
+const float twpi = 6.28318530718;
+  
+mat2 rotate2d(float _angle){
+    return mat2(cos(_angle),-sin(_angle),
+                sin(_angle),cos(_angle));
+}
+
+
+void main( void ) 
+{
+  float t = time*12.;
+  float tt = time*0.005;
+  vec2 p = ((gl_FragCoord.xy / resolution.xy )-0.5)*27.;
+  p.x *= resolution.x/resolution.y;
+  float a=0.,b=0.,c=0.,d=0.,e=0.;
+  for (int i=-4; i<4; i++) {
+    p = rotate2d(tt*-twpi)*p;
+    float x = (p.x*di-p.y*dh*0.125);
+    float y = (p.x*di*0.125+p.y*dh);
+    c = (sin(x+t*(float(i))/18.0)+b+y+3.0);
+    d = (cos(y+t*(float(i))/20.0)+x+a+2.0);
+    e = (sin(y+t*(float(i))/17.5)+x-e+1.0);
+    a -= .25/(c*c);
+    b += .5/(d*d);
+    e += .127;
+  }
+  color_out = vec4(log(-e+a+b-1.)/7.-0.2,log(-e-a-b-1.)/4.-0.2,log(e-a+b-1.)/3.-0.1,.3) ;
+
+}

data/ext/pixo/patterns/drain.glsl

@@ -0,0 +1,32 @@
+#version 330 core
+
+// http://glslsandbox.com/e#32563.0
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+ 
+uniform float time;
+uniform vec2 mouse;
+uniform vec2 resolution;
+
+out vec4 color_out;
+
+#define PI 3.1415927
+#define PI2 (PI*2.0)
+
+// http://glsl.heroku.com/e#7109.0 simplified by logos7@o2.pl
+
+void main(void)
+{
+  vec2 position = 100.0 * ((2.0 * gl_FragCoord.xy - resolution) / resolution.x);
+
+  float r = length(position) * 2.;
+  float a = atan(position.y, position.x);
+  float d = r - a + PI2;
+  float n = PI2 * float(int(d / PI2));
+  float k = a + n;
+  float rand = tan(floor(0.025 * k * k + time * 1.));
+
+  color_out.rgba = vec4(fract(rand*vec3(2, 1., 1)) * 2. - 0.6, 1.);
+}

data/ext/pixo/patterns/dual_spiral.glsl

@@ -0,0 +1,21 @@
+#version 330 core
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+uniform float time;
+in vec2 surfacePosition;
+out vec4 color_out;
+
+void main(void) {
+  vec2 pos = surfacePosition;
+  float dist = length(pos) / 2.0;
+
+  vec3 color = vec3(0.0);
+  float ang = atan(pos.y, pos.x) / 3.14159265;
+  if(mod(ang - dist + time / 5.0, 0.05) < 0.01 || dist < 0.01) color = vec3(0.55, 0.25, 1.0);
+  if(mod(ang + dist - time / 10.0, 0.05) < 0.01) color = vec3(0.05, 0.45, 0.85);
+  color_out = vec4(vec3(color), 1.0 );
+
+}

data/ext/pixo/patterns/ether.glsl

@@ -0,0 +1,35 @@
+#version 330 core
+out vec4 color_out;
+
+//Ether by nimitz (twitter: @stormoid)
+
+// https://www.shadertoy.com/view/MsjSW3
+
+uniform float iGlobalTime;
+uniform vec2 iMouse;
+uniform vec2 iResolution;
+
+#define t iGlobalTime
+mat2 m(float a){float c=cos(a), s=sin(a);return mat2(c,-s,s,c);}
+float map(vec3 p){
+    p.xz*= m(t*0.4);p.xy*= m(t*0.3);
+    vec3 q = p*2.+t;
+    return length(p+vec3(sin(t*0.7)))*log(length(p)+1.) + sin(q.x+sin(q.z+sin(q.y)))*0.5 - 1.;
+}
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord ){	
+	vec2 p = fragCoord.xy/iResolution.y - vec2(.9,.5);
+    vec3 cl = vec3(0.);
+    float d = 2.5;
+    for(int i=0; i<=5; i++)	{
+		vec3 p = vec3(0,0,5.) + normalize(vec3(p, -1.))*d;
+        float rz = map(p);
+		float f =  clamp((rz - map(p+.1))*0.5, -.1, 1. );
+        vec3 l = vec3(0.1,0.3,.4) + vec3(5., 2.5, 3.)*f;
+        cl = cl*l + (1.-smoothstep(0., 2.5, rz))*.7*l;
+		d += min(rz, 1.);
+	}
+    fragColor = vec4(cl, 1.);
+}
+
+void main(){mainImage(color_out,gl_FragCoord.xy);}