filters with glvideo

Author: monkstone

processing_app/library/glvideo/data/bwfrag.glsl

@@ -0,0 +1,23 @@
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+#define PROCESSING_TEXTURE_SHADER
+
+uniform sampler2D texture;
+
+varying vec4 vertColor;
+varying vec4 vertTexCoord;
+
+const vec4 lumcoeff = vec4(0.299, 0.587, 0.114, 0);
+
+void main() {
+  vec4 col = texture2D(texture, vertTexCoord.st);
+  float lum = dot(col, lumcoeff);
+  if (0.5 < lum) {
+    gl_FragColor = vertColor;
+  } else {
+    gl_FragColor = vec4(0, 0, 0, 1);
+  }     
+}

processing_app/library/glvideo/data/droste.glsl

@@ -0,0 +1,63 @@
+// This implementation is based on GLSL code by ArKano22:
+// http://www.gamedev.net/topic/590070-glsl-droste/
+uniform float globalTime;
+uniform sampler2D texture; // iChannel0 in Shadertoy
+uniform vec2 sketchSize; // iResolution in Shadertoy
+uniform int mode;
+
+const float TWO_PI = 3.141592*2.0;
+//ADJUSTABLE PARAMETERS:
+const float Branches = 1.0;
+const float scale = 0.4;
+const float off = 0.6;
+//Complex Math:
+vec2 complexExp(in vec2 z){
+	return vec2(exp(z.x)*cos(z.y),exp(z.x)*sin(z.y));
+}
+vec2 complexLog(in vec2 z){
+	return vec2(log(length(z)), atan(z.y, z.x));
+}
+vec2 complexMult(in vec2 a,in vec2 b){
+	return vec2(a.x*b.x - a.y*b.y, a.x*b.y + a.y*b.x);
+}
+float complexMag(in vec2 z){
+	return float(pow(length(z), 2.0));
+}
+vec2 complexReciprocal(in vec2 z){
+	return vec2(z.x / complexMag(z), -z.y / complexMag(z));
+}
+vec2 complexDiv(in vec2 a,in vec2 b){
+	return complexMult(a, complexReciprocal(b));
+}
+vec2 complexPower(in vec2 a, in vec2 b){
+	return complexExp( complexMult(b,complexLog(a))  );
+}
+//Misc Functions:
+float nearestPower(in float a, in float base){
+	return pow(base,  ceil(  log(abs(a))/log(base)  )-1.0 );
+}
+float map(float value, float istart, float istop, float ostart, float ostop) {
+	   return ostart + (ostop - ostart) * ((value - istart) / (istop - istart));
+}
+
+void main( void ){
+
+	//SHIFT AND SCALE COORDINATES
+	vec2 uv=gl_FragCoord.xy/sketchSize.xy - off;
+
+	//ESCHER GRID TRANSFORM:
+	float factor = pow(1.0/scale,Branches);
+	uv= complexPower(uv, complexDiv(vec2( log(factor) ,TWO_PI), vec2(0.0,TWO_PI) ) );
+
+	//RECTANGULAR DROSTE EFFECT:
+	float FT = fract(globalTime);
+	FT = log(FT+1.)/log(2.);
+	uv *= 1.0+FT*(scale-1.0);
+
+  float npower = max(nearestPower(uv.x,scale),nearestPower(uv.y,scale));
+	uv.x = map(uv.x,-npower,npower,-1.0,1.0);
+	uv.y = map(uv.y,-npower,npower,-1.0,1.0);
+
+	//UNDO SHIFT AND SCALE:
+	gl_FragColor =  texture(texture,uv*off+vec2(off));
+}

processing_app/library/glvideo/data/steinberg.glsl

@@ -0,0 +1,79 @@
+// Original shader by RavenWorks
+// Fake Floyd-Steinberg dithering
+// https://www.shadertoy.com/view/4sjGRD
+
+// Adapted for JRubyArt by Martin Prout <@monkstoneT>
+
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+uniform sampler2D texture; // iChannel0 in Shadertoy
+uniform vec2 sketchSize; // iResolution in Shadertoy
+
+const int lookupSize = 64;
+const float errorCarry = 0.3;
+
+float getGrayscale(vec2 coords){
+	vec2 uv = coords / sketchSize.xy;
+	// processing is already using inverted y coordinates
+  //	uv.y = 1.0-uv.y; 
+	vec3 sourcePixel = texture2D(texture, uv).rgb;
+	return length(sourcePixel*vec3(0.2126,0.7152,0.0722));
+}
+
+// in regular glsl was
+// void mainImage( out vec4 fragColor, in vec2 fragCoord )
+
+void main() {
+	
+	int topGapY = int(sketchSize.y - gl_FragCoord.y);
+	
+	int cornerGapX = int((gl_FragCoord.x < 10.0) ? gl_FragCoord.x : sketchSize.x - gl_FragCoord.x);
+	int cornerGapY = int((gl_FragCoord.y < 10.0) ? sketchSize.y : gl_FragCoord.y - gl_FragCoord.y);
+	int cornerThreshhold = ((cornerGapX == 0) || (topGapY == 0)) ? 5 : 4;
+	
+	if (cornerGapX+cornerGapY < cornerThreshhold) {
+				
+		gl_FragColor = vec4(0,0,0,1);
+		
+	} else if (topGapY < 20) {
+			
+			if (topGapY == 19) {
+				
+				gl_FragColor = vec4(0,0,0,1);
+				
+			} else {
+		
+				gl_FragColor = vec4(1,1,1,1);
+				
+			}
+		
+	} else {
+		
+		float xError = 0.0;
+		for(int xLook=0; xLook<lookupSize; xLook++){
+			float grayscale = getGrayscale(gl_FragCoord.xy + vec2(-lookupSize+xLook,0));
+			grayscale += xError;
+			float bit = grayscale >= 0.5 ? 1.0 : 0.0;
+			xError = (grayscale - bit)*errorCarry;
+		}
+		
+		float yError = 0.0;
+		for(int yLook=0; yLook<lookupSize; yLook++){
+			float grayscale = getGrayscale(gl_FragCoord.xy + vec2(0,-lookupSize+yLook));
+			grayscale += yError;
+			float bit = grayscale >= 0.5 ? 1.0 : 0.0;
+			yError = (grayscale - bit)*errorCarry;
+		}
+		
+		float finalGrayscale = getGrayscale(gl_FragCoord.xy);
+		finalGrayscale += xError*0.5 + yError*0.5;
+		float finalBit = finalGrayscale >= 0.5 ? 1.0 : 0.0;
+		
+		gl_FragColor = vec4(finalBit,finalBit,finalBit,1);
+			
+	}
+	
+}

processing_app/library/glvideo/droste.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env jruby
+require 'propane'
+
+# hold down mouse to see unfiltered output
+class Droste < Propane::App
+  load_library :glvideo
+  include_package 'gohai.glvideo'
+  attr_reader :cam, :my_filter, :origin
+
+  def settings
+    size(1280, 960, P2D)
+  end
+
+  def setup
+    sketch_title 'Droste'
+    @origin = Time.now
+    @my_filter = load_shader(data_path('droste.glsl'))
+    my_filter.set('sketchSize', width.to_f, height.to_f)
+    start_capture
+  end
+
+  def time
+    (Time.now - origin) * 0.5
+  end
+
+  def start_capture
+    @cam = GLCapture.new(self)
+    cam.start
+  end
+
+  def draw
+    background 0
+    cam.read if cam.available
+    image(cam, 0, 0, width, height)
+    my_filter.set('globalTime', time)
+    return if mouse_pressed?
+    filter(my_filter)
+  end
+end
+
+Droste.new

processing_app/library/glvideo/steinberg.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env jruby
+require 'propane'
+# Because this sketch uses a glsl shader it needs to run using
+# jruby-complete (typically rp5 --nojruby sketch.rb)
+# hold down mouse to see unfiltered output
+class Steinberg < Propane::App
+  load_library :glvideo
+  include_package 'gohai.glvideo'
+  attr_reader :cam, :my_shader
+
+  def settings
+    size(640, 480, P2D)
+  end
+
+  def setup
+    sketch_title 'Steinberg'
+    @my_shader = load_shader(data_path('steinberg.glsl'))
+    my_shader.set('sketchSize', width.to_f, height.to_f)
+    start_capture(width, height)
+  end
+
+  def start_capture(w, h)
+    @cam = GLCapture.new(self)
+    cam.start
+  end
+
+  def draw
+    background 0
+    cam.read if cam.available
+    image(cam, 0, 0, width, height)
+    return if mouse_pressed?
+    filter(my_shader)
+  end
+end
+
+Steinberg.new