new sketches

Author: monkstone

samples/processing_app/library/video/capture/data/steinberg.glsl

@@ -0,0 +1,79 @@
+// Original shader by RavenWorks
+// Fake Floyd-Steinberg dithering
+// https://www.shadertoy.com/view/4sjGRD
+
+// Adapted for Ruby-Processing 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);
+			
+	}
+	
+}

samples/processing_app/library/video/capture/mirror2.rb

@@ -0,0 +1,52 @@
+#
+# Mirror 2
+# by Daniel Shiffman.
+#
+# Each pixel from the video source is drawn as a rectangle with size based
+# on brightness.
+
+load_library :video
+include_package 'processing.video'
+
+CELL_SIZE = 15
+
+attr_reader :cols, :rows, :video
+
+def setup
+  size(640, 480)
+  # Set up columns and rows
+  @cols = width / CELL_SIZE
+  @rows = height / CELL_SIZE
+  color_mode(RGB, 255, 255, 255, 100)
+  rect_mode(CENTER)
+  # This the default video input, see the GettingStartedCapture
+  # example if it creates an error
+  @video = Capture.new(self, width, height)
+  # Start capturing the images from the camera
+  video.start
+  background(0)
+end
+
+def draw
+  return unless video.available
+  video.read
+  video.load_pixels
+  background(0, 0, 255)
+  # Begin loop for columns
+  cols.times do |i|
+    # Begin loop for rows
+    rows.times do |j|
+      # Where are we, pixel-wise?
+      x = i * CELL_SIZE
+      y = j * CELL_SIZE
+      # Reversing x to mirror the image
+      loc = (video.width - x - 1) + y * video.width
+      # Each rect is colored white with a size determined by brightness
+      c = video.pixels[loc]
+      sz = (brightness(c) / 255.0) * CELL_SIZE
+      fill(255)
+      no_stroke
+      rect(x + CELL_SIZE / 2, y + CELL_SIZE / 2, sz, sz)
+    end
+  end
+end

samples/processing_app/library/video/capture/steinberg.glsl

@@ -0,0 +1,72 @@
+#ifdef GL_ES
+precision highp float;
+#endif
+
+// This line is optional from Processing 2.1 and up
+#define PROCESSING_TEXTURE_SHADER
+
+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;
+	uv.y = 1.0-uv.y;
+	vec3 sourcePixel = texture2D(texture, uv).rgb;
+	return length(sourcePixel*vec3(0.2126,0.7152,0.0722));
+}
+
+void main( void ) {
+	
+	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) ? gl_FragCoord.y : sketchSize.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);
+			
+	}
+	
+}

samples/processing_app/library/video/capture/steinberg.rb

@@ -0,0 +1,29 @@
+# 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
+load_libraries :video, :video_event
+include_package 'processing.video'
+attr_reader :cam, :my_shader
+
+def setup
+  size(640, 480, P2D)
+  @my_shader = load_shader('steinberg.glsl')
+  my_shader.set('sketchSize', width.to_f, height.to_f)
+  start_capture(width, height)
+end
+
+def start_capture(w, h)
+  @cam = Capture.new(self, w, h)
+  cam.start
+end
+
+def draw
+  image(cam, 0, 0)
+  return if mouse_pressed?
+  filter(my_shader)
+end
+
+# using snake case to match java reflect method
+def captureEvent(c)
+  c.read
+end