ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/topics/shaders/data/mask.glsl

@@ -0,0 +1,19 @@
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+#define PROCESSING_TEXTURE_SHADER
+
+uniform sampler2D texture;
+uniform sampler2D mask;
+
+uniform vec2 texOffset;
+varying vec4 vertColor;
+varying vec4 vertTexCoord;
+
+void main() {
+  vec4 texColor = texture2D(texture, vertTexCoord.st).rgba;
+  vec4 maskColor = texture2D(mask, vec2(vertTexCoord.s, 1.0 - vertTexCoord.t)).rgba;
+  gl_FragColor = mix(texColor, vec4(0, 0, 0, 0), 1.0 - maskColor.r);  
+}

data/samples/processing_app/topics/shaders/data/monjori.glsl

@@ -0,0 +1,30 @@
+#define PROCESSING_COLOR_SHADER
+
+uniform vec2 resolution;
+uniform float time;
+
+void main(void) {
+  vec2 p = -1.0 + 2.0 * gl_FragCoord.xy / resolution.xy;
+  float a = time*40.0;
+  float d,e,f,g=1.0/40.0,h,i,r,q;
+  e=400.0*(p.x*0.5+0.5);
+  f=400.0*(p.y*0.5+0.5);
+  i=200.0+sin(e*g+a/150.0)*20.0;
+  d=200.0+cos(f*g/2.0)*18.0+cos(e*g)*7.0;
+  r=sqrt(pow(i-e,2.0)+pow(d-f,2.0));
+  q=f/r;
+  e=(r*cos(q))-a/2.0;f=(r*sin(q))-a/2.0;
+  d=sin(e*g)*176.0+sin(e*g)*164.0+r;
+  h=((f+d)+a/2.0)*g;
+  i=cos(h+r*p.x/1.3)*(e+e+a)+cos(q*g*6.0)*(r+h/3.0);
+  h=sin(f*g)*144.0-sin(e*g)*212.0*p.x;
+  h=(h+(f-e)*q+sin(r-(a+h)/7.0)*10.0+i/4.0)*g;
+  i+=cos(h*2.3*sin(a/350.0-q))*184.0*sin(q-(r*4.3+a/12.0)*g)+tan(r*g+h)*184.0*cos(r*g+h);
+  i=mod(i/5.6,256.0)/64.0;
+  if(i<0.0) i+=4.0;
+  if(i>=2.0) i=4.0-i;
+  d=r/350.0;
+  d+=sin(d*d*8.0)*0.52;
+  f=(sin(a*g)+1.0)/2.0;
+  gl_FragColor=vec4(vec3(f*i/1.6,i/2.0+d/13.0,i)*d*p.x+vec3(i/1.3+d/8.0,i/2.0+d/18.0,i)*d*(1.0-p.x),1.0);
+}

data/samples/processing_app/topics/shaders/data/nebula.glsl

@@ -0,0 +1,111 @@
+#define PROCESSING_COLOR_SHADER
+
+uniform float time;
+uniform vec2 resolution;
+
+// NEBULA - CoffeeBreakStudios.com (CBS)
+// Work in progress...
+//
+// 3148.26: Switched from classic to simplex noise
+// 3148.27: Reduced number of stars
+// 3249.0:  Switched to fast computed 3D noise. Less quality but ~ 2x faster
+// 3249.5:  Removed use of random number generator to gain performance
+// 3265.0:  Added rotation: glsl.heroku.com/e#3005.1
+
+//Utility functions
+
+vec3 fade(vec3 t) {
+  return vec3(1.0,1.0,1.0);//t*t*t*(t*(t*6.0-15.0)+10.0);
+}
+
+vec2 rotate(vec2 point, float rads) {
+	float cs = cos(rads);
+	float sn = sin(rads);
+	return point * mat2(cs, -sn, sn, cs);
+}	
+
+vec4 randomizer4(const vec4 x)
+{
+    vec4 z = mod(x, vec4(5612.0));
+    z = mod(z, vec4(3.1415927 * 2.0));
+    return(fract(cos(z) * vec4(56812.5453)));
+}
+
+// Fast computed noise
+// http://www.gamedev.net/topic/502913-fast-computed-noise/
+
+const float A = 1.0;
+const float B = 57.0;
+const float C = 113.0;
+const vec3 ABC = vec3(A, B, C);
+const vec4 A3 = vec4(0, B, C, C+B);
+const vec4 A4 = vec4(A, A+B, C+A, C+A+B);
+
+float cnoise4(const in vec3 xx)
+{
+    vec3 x = mod(xx + 32768.0, 65536.0);
+    vec3 ix = floor(x);
+    vec3 fx = fract(x);
+    vec3 wx = fx*fx*(3.0-2.0*fx);
+    float nn = dot(ix, ABC);
+
+    vec4 N1 = nn + A3;
+    vec4 N2 = nn + A4;
+    vec4 R1 = randomizer4(N1);
+    vec4 R2 = randomizer4(N2);
+    vec4 R = mix(R1, R2, wx.x);
+    float re = mix(mix(R.x, R.y, wx.y), mix(R.z, R.w, wx.y), wx.z);
+
+    return 1.0 - 2.0 * re;
+}
+float surface3 ( vec3 coord, float frequency ) {
+	
+	float n = 0.0;	
+		
+	n += 1.0	* abs( cnoise4( coord * frequency ) );
+	n += 0.5	* abs( cnoise4( coord * frequency * 2.0 ) );
+	n += 0.25	* abs( cnoise4( coord * frequency * 4.0 ) );
+	n += 0.125	* abs( cnoise4( coord * frequency * 8.0 ) );
+	n += 0.0625	* abs( cnoise4( coord * frequency * 16.0 ) );
+	
+	return n;
+}
+	
+void main( void ) {
+	float rads = radians(time*3.15);
+	vec2 position = gl_FragCoord.xy / resolution.xy;
+	position += rotate(position, rads);
+	float n = surface3(vec3(position*sin(time*0.1), time * 0.05)*mat3(1,0,0,0,.8,.6,0,-.6,.8),0.9);
+	float n2 = surface3(vec3(position*cos(time*0.1), time * 0.04)*mat3(1,0,0,0,.8,.6,0,-.6,.8),0.8);
+    	float lum = length(n);
+    	float lum2 = length(n2);
+
+	vec3 tc = pow(vec3(1.0-lum),vec3(sin(position.x)+cos(time)+4.0,8.0+sin(time)+4.0,8.0));
+	vec3 tc2 = pow(vec3(1.1-lum2),vec3(5.0,position.y+cos(time)+7.0,sin(position.x)+sin(time)+2.0));
+	vec3 curr_color = (tc*0.8) + (tc2*0.5);
+	
+	
+	//Let's draw some stars
+	
+	float scale = sin(0.3 * time) + 5.0;
+	vec2 position2 = (((gl_FragCoord.xy / resolution) - 0.5) * scale);
+	float gradient = 0.0;
+	vec3 color = vec3(0.0);
+	float fade = 0.0;
+	float z = 0.0;
+ 	vec2 centered_coord = position2 - vec2(sin(time*0.1),sin(time*0.1));
+	centered_coord = rotate(centered_coord, rads);
+	
+	for (float i=1.0; i<=60.0; i++)
+	{
+		vec2 star_pos = vec2(sin(i) * 250.0, sin(i*i*i) * 250.0);
+		float z = mod(i*i - 10.0*time, 256.0);
+		float fade = (256.0 - z) /256.0;
+		vec2 blob_coord = star_pos / z;
+		gradient += ((fade / 384.0) / pow(length(centered_coord - blob_coord), 1.5)) * ( fade);
+	}
+
+	curr_color += gradient;
+	
+	gl_FragColor = vec4(curr_color, 1.0);
+}

data/samples/processing_app/topics/shaders/data/sep_blur.glsl

@@ -0,0 +1,59 @@
+// Adapted from:
+// http://callumhay.blogspot.com/2010/09/gaussian-blur-shader-glsl.html
+
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+#define PROCESSING_TEXTURE_SHADER
+
+uniform sampler2D texture;
+
+// The inverse of the texture dimensions along X and Y
+uniform vec2 texOffset;
+
+varying vec4 vertColor;
+varying vec4 vertTexCoord;
+
+uniform int blurSize;       
+uniform int horizontalPass; // 0 or 1 to indicate vertical or horizontal pass
+uniform float sigma;        // The sigma value for the gaussian function: higher value means more blur
+                            // A good value for 9x9 is around 3 to 5
+                            // A good value for 7x7 is around 2.5 to 4
+                            // A good value for 5x5 is around 2 to 3.5
+                            // ... play around with this based on what you need :)
+
+const float pi = 3.14159265;
+
+void main() {  
+  float numBlurPixelsPerSide = float(blurSize / 2); 
+  
+  vec2 blurMultiplyVec = 0 < horizontalPass ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+
+  // Incremental Gaussian Coefficent Calculation (See GPU Gems 3 pp. 877 - 889)
+  vec3 incrementalGaussian;
+  incrementalGaussian.x = 1.0 / (sqrt(2.0 * pi) * sigma);
+  incrementalGaussian.y = exp(-0.5 / (sigma * sigma));
+  incrementalGaussian.z = incrementalGaussian.y * incrementalGaussian.y;
+
+  vec4 avgValue = vec4(0.0, 0.0, 0.0, 0.0);
+  float coefficientSum = 0.0;
+
+  // Take the central sample first...
+  avgValue += texture2D(texture, vertTexCoord.st) * incrementalGaussian.x;
+  coefficientSum += incrementalGaussian.x;
+  incrementalGaussian.xy *= incrementalGaussian.yz;
+
+  // Go through the remaining 8 vertical samples (4 on each side of the center)
+  for (float i = 1.0; i <= numBlurPixelsPerSide; i++) { 
+    avgValue += texture2D(texture, vertTexCoord.st - i * texOffset * 
+                          blurMultiplyVec) * incrementalGaussian.x;         
+    avgValue += texture2D(texture, vertTexCoord.st + i * texOffset * 
+                          blurMultiplyVec) * incrementalGaussian.x;         
+    coefficientSum += 2.0 * incrementalGaussian.x;
+    incrementalGaussian.xy *= incrementalGaussian.yz;
+  }
+
+  gl_FragColor = avgValue / coefficientSum;
+}

data/samples/processing_app/topics/shaders/deform.rb

@@ -0,0 +1,28 @@
+#
+# Deform. 
+# 
+# A GLSL version of the oldschool 2D deformation effect, by Inigo Quilez.
+# Ported from the webGL version available in ShaderToy:
+# http://www.iquilezles.org/apps/shadertoy/
+# (Look for Deform under the Plane Deformations Presets)
+# 
+#
+ 
+attr_reader :tex, :deform
+
+def setup
+  size(640, 360, P2D)
+  
+  textureWrap(REPEAT)
+  @tex = loadImage("tex1.jpg")
+ 
+  @deform = loadShader("deform.glsl")
+  deform.set("resolution", width.to_f, height.to_f)
+end
+
+def draw
+  deform.set("time", millis / 1000.0)
+  deform.set("mouse", mouse_x.to_f, mouse_y.to_f)
+  shader(deform)
+  image(tex, 0, 0, width, height)
+end

data/samples/processing_app/topics/shaders/dome_projection.rb

@@ -0,0 +1,143 @@
+#
+# DomeProjection
+# 
+# This sketch uses use environmental mapping to render the output 
+# on a full spherical dome.
+# 
+# Based on the FullDome_template code from Christopher Warnow: 
+# https://github.com/mphasize/FullDome
+# 
+#
+
+attr_reader :fbo, :cube_map_shader, :dome_sphere, :env_map_texture_id
+
+ENV_MAP_SIZE = 1024
+
+def setup
+  size(640, 640, P3D) 
+  init_cube_map  
+end
+
+def draw
+  background(0)
+  draw_cube_map 
+end
+
+def draw_scene   
+  background(0)
+  stroke(255, 0, 0)
+  stroke_weight(2)
+  
+  (-width ... 2 * width).step(50) do |i|	
+    line(i, -height, -100, i, 2 * height, -100)
+  end
+  (-height ... 2 * height).step(50) do |i|	
+    line(-width, i, -100, 2 * width, i, -100)
+  end
+  
+  lights
+  no_stroke
+  translate(mouse_x, mouse_y, 200)
+  rotate_x(frame_count * 0.01)
+  rotate_y(frame_count * 0.01) 
+  box(100) 
+end
+
+java_import "java.nio.IntBuffer"
+
+def init_cube_map
+  sphere_detail(50)
+  @dome_sphere = create_shape(SPHERE, height/2.0)
+  dome_sphere.rotate_x(HALF_PI)
+  dome_sphere.set_stroke(false)
+
+  pgl = beginPGL
+
+  @env_map_texture_id = IntBuffer.allocate(1)
+  pgl.gen_textures(1, env_map_texture_id)
+  pgl.bind_texture(PGL::TEXTURE_CUBE_MAP, env_map_texture_id.get(0))
+  pgl.texParameteri(PGL::TEXTURE_CUBE_MAP, PGL::TEXTURE_WRAP_S, PGL::CLAMP_TO_EDGE)
+  pgl.texParameteri(PGL::TEXTURE_CUBE_MAP, PGL::TEXTURE_WRAP_T, PGL::CLAMP_TO_EDGE)
+  pgl.texParameteri(PGL::TEXTURE_CUBE_MAP, PGL::TEXTURE_WRAP_R, PGL::CLAMP_TO_EDGE)
+  pgl.texParameteri(PGL::TEXTURE_CUBE_MAP, PGL::TEXTURE_MIN_FILTER, PGL::NEAREST)
+  pgl.texParameteri(PGL::TEXTURE_CUBE_MAP, PGL::TEXTURE_MAG_FILTER, PGL::NEAREST)
+  (PGL::TEXTURE_CUBE_MAP_POSITIVE_X ... PGL::TEXTURE_CUBE_MAP_POSITIVE_X + 6).each do |i|
+    pgl.texImage2D(i, 0, PGL::RGBA8, ENV_MAP_SIZE, ENV_MAP_SIZE, 0, PGL::RGBA, PGL::UNSIGNED_BYTE, nil)
+  end
+
+  # Init fbo, rbo
+  @fbo = IntBuffer.allocate(1)
+  rbo = IntBuffer.allocate(1)
+  pgl.genFramebuffers(1, fbo)
+  pgl.bindFramebuffer(PGL::FRAMEBUFFER, fbo.get(0))
+  pgl.framebufferTexture2D(PGL::FRAMEBUFFER, PGL::COLOR_ATTACHMENT0, PGL::TEXTURE_CUBE_MAP_POSITIVE_X, env_map_texture_id.get(0), 0)
+
+  pgl.genRenderbuffers(1, rbo)
+  pgl.bindRenderbuffer(PGL::RENDERBUFFER, rbo.get(0))
+  pgl.renderbufferStorage(PGL::RENDERBUFFER, PGL::DEPTH_COMPONENT24, ENV_MAP_SIZE, ENV_MAP_SIZE)
+
+  # Attach depth buffer to FBO
+  pgl.framebufferRenderbuffer(PGL::FRAMEBUFFER, PGL::DEPTH_ATTACHMENT, PGL::RENDERBUFFER, rbo.get(0))   
+
+  pgl.enable(PGL::TEXTURE_CUBE_MAP)
+  pgl.active_texture(PGL::TEXTURE1)
+  pgl.bind_texture(PGL::TEXTURE_CUBE_MAP, env_map_texture_id.get(0))    
+
+  endPGL
+
+  # Load cubemap shader.
+  @cube_map_shader = load_shader("cubemapfrag.glsl", "cubemapvert.glsl")
+  cube_map_shader.set("cubemap", 1)
+end
+
+def draw_cube_map
+  regenerateEnvMap
+  drawDomeMaster
+end
+
+def drawDomeMaster
+  ortho
+  reset_matrix
+  shader(cube_map_shader)
+  shape(dome_sphere)
+  reset_shader
+end
+
+# Called to regenerate the envmap
+def regenerateEnvMap     
+  pgl = beginPGL
+
+  # bind fbo
+  pgl.bindFramebuffer(PGL::FRAMEBUFFER, fbo.get(0))
+
+  # generate 6 views from origin(0, 0, 0)
+  pgl.viewport(0, 0, ENV_MAP_SIZE, ENV_MAP_SIZE)   
+  perspective(90.0 * DEG_TO_RAD, 1.0, 1.0, 1025.0) 
+  (PGL::TEXTURE_CUBE_MAP_POSITIVE_X ... PGL::TEXTURE_CUBE_MAP_NEGATIVE_Z).each do |face|
+    reset_matrix
+    case face
+    when PGL::TEXTURE_CUBE_MAP_POSITIVE_X
+      camera(0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, -1.0, 0.0)
+    when PGL::TEXTURE_CUBE_MAP_NEGATIVE_X
+      camera(0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, -1.0, 0.0)
+    when PGL::TEXTURE_CUBE_MAP_POSITIVE_Y
+      camera(0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, -1.0) 
+    when PGL::TEXTURE_CUBE_MAP_NEGATIVE_Y
+      camera(0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)
+    when PGL::TEXTURE_CUBE_MAP_POSITIVE_Z
+      camera(0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, -1.0, 0.0)   
+    end
+    
+    scale(-1, 1, -1)
+    translate(-width * 0.5, -height * 0.5, -500)
+    pgl.framebufferTexture2D(PGL::FRAMEBUFFER, PGL::COLOR_ATTACHMENT0, face, env_map_texture_id.get(0), 0)
+    draw_scene# Draw objects in the scene
+    flush# Make sure that the geometry in the scene is pushed to the GPU    
+    no_lights # Disabling lights to avoid adding many times
+    pgl.framebufferTexture2D(PGL::FRAMEBUFFER, PGL::COLOR_ATTACHMENT0, face, 0, 0)
+  end
+  
+  endPGL
+end
+
+

data/samples/processing_app/topics/shaders/edge_detect.rb

@@ -0,0 +1,30 @@
+#
+# Edge Detection
+# 
+# Change the default shader to apply a simple, custom edge detection filter.
+# 
+# Press the mouse to switch between the custom and default shader.
+#
+attr_reader :edges, :img , :enabled
+
+
+def setup
+  size(640, 360, P2D)
+  @enabled = true
+  @img = load_image("leaves.jpg");      
+  @edges = load_shader("edges.glsl")
+end
+
+def draw
+  if (enabled == true)
+    shader(edges)
+  end
+  image(img, 0, 0)
+end
+
+def mousePressed
+  @enabled = !enabled
+  if (!enabled == true)
+    resetShader
+  end
+end

data/samples/processing_app/topics/shaders/glossy_fish_eye.rb

@@ -0,0 +1,63 @@
+#
+# Glossy Fish Eye
+# 
+# A fish-eye shader is used on the main surface and 
+# a glossy specular reflection shader is used on the
+# offscreen canvas. 
+#
+
+attr_reader :ball, :canvas, :glossy, :fisheye, :img, :use_fish_eye
+
+def setup
+  size(640, 640, P3D)  
+  @canvas = create_graphics(width, height, P3D)
+  @use_fish_eye = true
+  @fisheye = load_shader("FishEye.glsl")
+  fisheye.set("aperture", 180.0)
+  
+  @glossy = load_shader("GlossyFrag.glsl", "GlossyVert.glsl")  
+  glossy.set("AmbientColour", 0.0, 0.0, 0.0)
+  glossy.set("DiffuseColour", 0.9, 0.2, 0.2)
+  glossy.set("SpecularColour", 1.0, 1.0, 1.0)
+  glossy.set("AmbientIntensity", 1.0)
+  glossy.set("DiffuseIntensity", 1.0)
+  glossy.set("SpecularIntensity", 0.7)
+  glossy.set("Roughness", 0.7)
+  glossy.set("Sharpness", 0.0)
+  
+  @ball = create_shape(SPHERE, 50)
+  ball.set_stroke(false)
+end
+
+def draw
+  canvas.begin_draw
+  canvas.shader(glossy)
+  canvas.no_stroke
+  canvas.background(0)
+  canvas.push_matrix
+  canvas.rotate_y(frame_count * 0.01)
+  canvas.point_light(204, 204, 204, 1000, 1000, 1000)
+  canvas.pop_matrix  
+  (0 ... canvas.width + 100).step(100) do |x|
+    (0 ... canvas.width + 100).step(100) do |y|
+      (0 ... canvas.width + 100).step(100) do |z|
+        canvas.push_matrix
+        canvas.translate(x, y, -z)
+        canvas.shape(ball)
+        canvas.pop_matrix
+      end
+    end
+  end
+  canvas.end_draw   
+  shader(fisheye) if use_fish_eye  
+  image(canvas, 0, 0, width, height)
+end
+
+def mousePressed
+  if (use_fish_eye)
+    @use_fish_eye = false
+    reset_shader    
+  else
+    @use_fish_eye = true
+  end
+end