first upload

Author: Eugene Kogan

ColorShaders/ColorShaders.pde

@@ -0,0 +1,104 @@
+String[] shaders = new String[]{ 
+  "blobby.glsl", "drip.glsl", "electro.glsl", 
+  "eye.glsl", "bands.glsl", "sinewave.glsl", "noisy.glsl", 
+  "nebula.glsl", "landscape.glsl", "monjori.glsl" };
+
+PShader shade;
+int idxShader = 0;
+
+void setup() 
+{
+  size(640, 480, P2D);
+  textSize(22);
+  fill(255);
+  shade = loadShader(shaders[idxShader]);
+}
+
+void draw() 
+{ 
+  setShaderParameters();
+  
+  // turn on shader and display movie
+  shader(shade);
+  rect(0, 0, width, height);
+  
+  // turn off shader before displaying filename
+  resetShader();
+  text(shaders[idxShader], 5, 20);
+}
+
+void setShaderParameters() 
+{
+  shade.set("time", (float) millis()/1000.0);
+  shade.set("resolution", float(width), float(height));
+  
+  // blobby
+  if (idxShader == 0) {
+    shade.set("depth", map(mouseY, 0, height, 0, 2));
+    shade.set("rate", map(mouseX, 0, width, 0, 2));
+  }
+    
+  // drip
+  else if (idxShader == 1) {  
+    shade.set("intense", 0.5);
+    shade.set("speed", 0.9);
+    shade.set("graininess", (float)mouseX/width, (float)mouseY/height);
+  }
+  
+  // electro
+  else if (idxShader == 2) {      
+    shade.set("rings",  map(mouseY, 0, height, 5, 40));  
+    shade.set("complexity", map(mouseX, 0, width, 1, 60));
+  }
+
+  // eye
+  else if (idxShader == 3) {    
+    shade.set("mouse", (float)mouseX, (float)mouseY); 
+  }
+
+  // bands
+  else if (idxShader == 4) {
+    shade.set("noiseFactor", map(mouseX, 0, width, 5, 100));
+    shade.set("stripes", map(mouseY, 0, height, 0, 100));
+  }
+
+  // sinewaves
+  else if (idxShader == 5) {
+    shade.set("colorMult", 2.5, 1.2);
+    shade.set("coefficients", 30, map(mouseY, 0, height, 0, 80),  map(mouseX, 0, width, 1, 200)); 
+  }
+  
+  // water noise
+  else if (idxShader == 6) {
+    shade.set("noiseFactor", map(mouseX, 0, width, 0, 2), map(mouseX, 0, width, 0, 2));
+    shade.set("noiseFactorTime", map(mouseY, 0, height, 0, 2));
+  }
+
+  // nebula
+  else if (idxShader == 7) {
+    shade.set("starspeed", map(mouseX, 0, width, 0, 100));
+  }
+ 
+  // landscape
+  else if (idxShader == 8) {
+    shade.set("dir", map(mouseX, 0, width, 1.5, 5));
+  }
+
+  // monjori
+  else if (idxShader == 9) {
+    shade.set("graininess", map(mouseX, 0, width, 10, 100));
+    shade.set("pace", 50.0);
+    shade.set("twist", map(mouseY, 0, height, 0, 100));
+  }
+}
+
+void keyPressed() {
+  if      (keyCode==LEFT) {
+    idxShader = (idxShader + shaders.length - 1) % shaders.length;
+    shade = loadShader(shaders[idxShader]);
+  }    
+  else if (keyCode==RIGHT) {
+    idxShader = (idxShader + 1) % shaders.length;
+    shade = loadShader(shaders[idxShader]);
+  }
+}

ColorShaders/data/bands.glsl

@@ -0,0 +1,56 @@
+#define PROCESSING_COLOR_SHADER
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+uniform float time;
+uniform float noiseFactor;
+uniform vec2 resolution;
+uniform float stripes;
+
+// Gradient Noise (http://en.wikipedia.org/wiki/Gradient_noise)
+// Created by inigo quilez - iq/2013
+// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
+// Noise implementation from https://www.shadertoy.com/view/XdXGW8
+vec2 hash( vec2 p )
+{
+	p = vec2( dot(p,vec2(127.1,311.7)),
+			  dot(p,vec2(269.5,183.3)) );
+
+	return -1.0 + 2.0*fract(sin(p)*43758.5453123);
+}
+
+float noise( in vec2 p )
+{
+    vec2 i = floor( p );
+    vec2 f = fract( p );
+	
+	vec2 u = f*f*(3.0-2.0*f);
+
+    return mix( mix( dot( hash( i + vec2(0.0,0.0) ), f - vec2(0.0,0.0) ), 
+                     dot( hash( i + vec2(1.0,0.0) ), f - vec2(1.0,0.0) ), u.x),
+                mix( dot( hash( i + vec2(0.0,1.0) ), f - vec2(0.0,1.0) ), 
+                     dot( hash( i + vec2(1.0,1.0) ), f - vec2(1.0,1.0) ), u.x), u.y);
+}
+
+
+void main( void ) {
+	vec2 position = ( gl_FragCoord.xy / resolution.xy );
+	
+	float stripeNumber = floor(position.x * stripes);
+	float stripePosition = fract(position.x * stripes);
+
+	float color = (noise(vec2(position.y * noiseFactor - 2.0*time, stripeNumber+noise(vec2(5.0*stripeNumber, time*0.1))*time*0.2)) + 1.0) / 2.0;	
+	color = smoothstep(color, 0.2, 0.4);
+	color -= 0.2*mod(color, 0.2*position.x*position.y);
+	//color = (noise(vec2(position.y * 0.1 + time * 0.2 * fract(stripeNumber * 1.3), stripeNumber)) + 1.0) / 2.0;
+	if (stripePosition < 0.3)
+		color -=0.9;
+
+	vec3 col = vec3(color);
+	col.r = mod(col.g, position.x);
+	col.g = mod(col.b, position.y);
+	gl_FragColor = vec4(col, 1.0);
+
+}

ColorShaders/data/blobby.glsl

@@ -0,0 +1,25 @@
+#define PROCESSING_COLOR_SHADER
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+uniform float time;
+uniform vec2 resolution;
+uniform float depth;
+uniform float rate;
+
+#define N 16
+
+void main( void ) {
+	vec2 v=(gl_FragCoord.xy-(resolution*0.5))/min(resolution.y,resolution.x)*10.0;
+	float t=time * 0.3,r=2.0;
+	for (int i=1;i<N;i++){
+		float d=(3.14159265 / float(N))*(float(i)*14.0);
+		r+=length(vec2(rate*v.y,rate*v.x))+1.21;
+		v = vec2(v.x+cos(v.y+cos(r)+d)+cos(t),v.y-sin(v.x+cos(r)+d)+sin(t));
+	}
+        r = (sin(r*0.09)*0.5)+0.5;
+	r = pow(r, depth);
+	gl_FragColor = vec4(r,pow(max(r-0.55,0.0)*2.2,2.0),pow(max(r-4.875,0.1)*3.0,6.0), 1.0 );
+}

ColorShaders/data/drip.glsl

@@ -0,0 +1,32 @@
+#define PROCESSING_COLOR_SHADER
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+uniform vec2 resolution;
+uniform float time;
+uniform float intense;
+uniform float speed;
+uniform vec2 graininess;
+
+const float offset = 20.0;
+const int complexity = 38;
+const float Pi = 3.14159;
+
+void main()
+{
+  	vec2 p=(2.0*gl_FragCoord.xy-resolution)/max(resolution.x,resolution.y);
+
+  	for(int i=1;i<complexity;i++)
+  	{
+    	vec2 newp=p;
+    	newp.x+=graininess.x/float(i)*sin(float(i)*p.y+time/speed+0.3*float(i))+offset;
+    	newp.y+=graininess.y/float(i)*sin(float(i)*p.x+time/speed+0.3*float(i+100))+offset;
+    	p=newp;
+  	}
+  	vec3 col=vec3(intense*sin(3.0*p.x)+intense,intense*sin(3.0*p.y)+intense,intense*sin(p.x+p.y)+intense);
+	col.g = col.r;
+//	col.b = col.r;
+  	gl_FragColor=vec4(col, 1.0);
+}

ColorShaders/data/electro.glsl

@@ -0,0 +1,35 @@
+// Electrocardiogram Effect
+// Imported from http://www.geeks3d.com/20111223/shader-library-electrocardiogram-effect-glsl/
+
+#define PROCESSING_COLOR_SHADER
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+uniform vec2 resolution;
+uniform float time;
+uniform float complexity;
+uniform float rings;
+
+float viewAngle = 0.0;//0.040*sin(0.1*time);
+float speed = -1.0;
+float rate = .50;
+float baseamp = 0.10;
+
+void main(void)
+{
+  vec2 p = -1.0 + 2.0 * (gl_FragCoord.xy / resolution.xy);
+  vec2 op = p;
+  p = vec2(distance(p, vec2(0, 0)), sin(0.40*time+atan(p.x, p.y) * complexity));
+  float x = speed * viewAngle * time + rate * p.x;
+  float base = (0.1 + 3.0*tan(x*0.7 + time)) * (2.37 + 2.5*sin(x*rings + time));
+  float z = fract(0.05*x);
+  z = max(z, 100.0-z);
+  z = pow(z, 50.0);
+  float pulse = exp(-1000000.0 * z);
+  vec4 ecg_color = vec4(0.3, 1.0, 0.4, 1.0);
+  vec4 c = pow(1.0-abs(p.y-(baseamp*base+pulse-0.5)), 4.0) * ecg_color;
+  vec3 d = 1.0-vec3(c.r, c.r, c.r);
+  gl_FragColor = vec4(d, 1.0);
+}

ColorShaders/data/eye.glsl

@@ -0,0 +1,115 @@
+#define PROCESSING_COLOR_SHADER
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+
+uniform float time;
+uniform vec2 resolution;
+uniform vec2 mouse;
+
+mat2 m = mat2( 0.8,  0.6, -0.6,  0.6 );
+
+float hash( float n )
+{
+	return fract(sin(n)*43758.5453);
+}
+
+float noise( in vec2 x )
+{
+	vec2 p = floor(x);
+	vec2 f = fract(x);
+	f = f*f*(3.0-2.0*f);
+	float n = p.x + p.y*57.0;
+	float res = mix(mix( hash(n+  0.0), hash(n+  1.0),f.x), mix( hash(n+ 57.0), hash(n+ 58.0),f.x),f.y);
+	return res;
+}
+
+float fbm( vec2 p )
+{
+	float f = 0.0;
+	f += 0.50000*noise( p ); p = m*p*2.02;
+	f += 0.25000*noise( p ); p = m*p*2.03;
+	f += 0.12500*noise( p ); p = m*p*2.01;
+	f += 0.06250*noise( p ); p = m*p*2.04;
+	f += 0.03125*noise( p );
+	return f/0.984375;
+}
+
+float length2( vec2 p )
+{
+	float ax = abs(p.x);
+	float ay = abs(p.y);
+	return pow( pow(ax,4.0) + pow(ay,4.0), 1.0/4.0 );
+}
+
+void main(void)
+{    
+	vec2 q = gl_FragCoord.xy / resolution.xy;
+	vec2 p = -1.0 + 2.0 * q;
+	vec2 m = -1.0 + 2.0 * mouse.xy / resolution.xy;
+	m.y = -m.y;
+	p.x *= (resolution.x/resolution.y);
+
+	float rad_eye = 0.94;
+	float rad_iris = 0.6 + 0.05 * sin(time);
+	float rad_pupil = 0.4 + 0.03 * sin(0.5*time);
+	
+	vec2 ctr1 = 0.55 * m;
+	vec2 ctr2 = 0.40 * m;
+	vec2 ctr3 = 0.03 * m;
+	
+	float r1 = length(p-ctr1);
+	float r2 = length(p-ctr2);
+	float r3 = length(p-ctr3);
+
+	// start with base color of iris
+	vec3 col = vec3( 0.0, 0.3, 0.4 );
+	
+	// colors for iris/pupils
+//	vec3 iris1, iris2; = vec3(0.2, 0.5, 0.4);
+//	vec3 iris2 = vec3(0.9, 0.6, 0.2);
+	vec3 iris1, iris2;
+	
+	iris1.x = 0.1 + 0.3*fbm(2.3*p + vec2(time*0.4, time*0.5));
+	iris1.y = 0.3 + 0.4*fbm(4.3*p + vec2(time*0.1, time*0.2));
+	iris1.z = 0.2 + 0.4*fbm(1.3*p + vec2(time*0.3, time*0.3));
+
+	iris2.x = 0.8 + 0.2*fbm(1.7*p + vec2(time*0.2, time*0.3));
+	iris2.y = 0.4 + 0.4*fbm(3.1*p + vec2(time*0.3, time*0.4));
+	iris2.z = 0.0 + 0.4*fbm(2.3*p + vec2(time*0.1, time*0.2));
+	
+	
+	// add some noise to iris
+	float f = fbm( 5.0*(p-ctr2)+time );
+	col = mix( col, iris1, f );
+	
+	// add yellow
+	col = mix( col, iris2, smoothstep(0.6,0.2, (r1+r2)/2.0) );
+    
+	// add some white streaks to iris
+	float a = atan( abs(p.y-ctr1.y), p.x-ctr1.x );
+	a += 0.05*fbm( 10.0*p+time*0.5 );
+	f = smoothstep( 0.3, 1.0, fbm( vec2(20.0*a,6.0*r2) ) );
+	col = mix( col, vec3(0.8, 0.85, 0.93), f );
+    
+
+	// add light reflection to top right
+	f = smoothstep( 0.4, 0.9, fbm( vec2(15.0*a,10.0*((r1+r3)/2.0)) ) );
+	col *= 1.0-0.5*f;
+	col *= 1.0-0.25*smoothstep( 0.6,0.8, r2 );
+	
+	// add pupil	
+	col = mix(col, vec3(0.0, 0.0, 0.0), smoothstep(rad_pupil, rad_pupil - 0.25, r1) );
+	
+	// add light reflection to top right
+	f = 1.0 - smoothstep( 0.0, 0.6, length2( mat2(0.6,0.8,-0.8,0.6)*(p-ctr1-vec2(0.35,0.4) )*vec2(1.0,2.0)) );
+	col += vec3(1.0,0.9,0.9)*f*0.985;
+	col *= vec3(0.8+0.2*cos(r2*a));
+
+	col = mix(col, vec3(1.0, 1.0, 1.0), smoothstep(rad_iris , rad_iris + 0.09, r2) );
+	col = mix(col, vec3(0.0, 0.0, 0.0), smoothstep(rad_eye  , rad_eye + 0.05, r3) );
+
+	gl_FragColor = vec4(col,1.0);
+}