ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/topics/motion/reflection1.rb

@@ -0,0 +1,107 @@
+#
+# Non-orthogonal Reflection 
+# by Ira Greenberg. 
+# 
+# Based on the equation (R = 2N(N*L)-L) where R is the 
+# reflection vector, N is the normal, and L is the incident
+# vector.
+#
+
+attr_reader :base1, :base2, :base_length, :coords, :position, :radius
+attr_reader :direction, :speed, :velocity, :incidence 
+
+def setup
+  size(640, 360)
+  @radius = 6
+  @speed = 3.5
+  fill(128)
+  @base1 = PVector.new(0, height - 150)
+  @base2 = PVector.new(width, height)
+  @coords = create_ground
+  # start ellipse at middle top of screen
+  @position = PVector.new(width/2, 0)  
+  # set initial random direction
+  @direction = PVector.random2D
+  @velocity = PVector.new
+end
+
+def draw
+  # draw background
+  fill(0, 12)
+  no_stroke
+  rect(0, 0, width, height)
+  
+  # draw base
+  fill(200)
+  quad(base1.x, base1.y, base2.x, base2.y, base2.x, height, 0, height)
+  
+  # calculate base top normal
+  base_delta = PVector.sub(base2, base1)
+  base_delta.normalize
+  normal = PVector.new(-base_delta.y, base_delta.x)  
+  # draw ellipse
+  no_stroke
+  fill(255)
+  ellipse(position.x, position.y, radius * 2, radius * 2)
+  
+  # set ellipse velocity
+  @velocity.set(direction)
+  @velocity.mult(speed)
+  
+  # move ellipse
+  @position.add(velocity)
+  
+  # normalized incidence vector
+  @incidence = PVector.mult(direction, -1)
+  
+  # detect and handle collision
+  coords.each do |coord|
+    # check distance between ellipse and base top coordinates
+    if (PVector.dist(position, coord) < radius)
+      
+      # calculate dot product of incident vector and base top normal 
+      dot = incidence.dot(normal)
+      
+      # assign reflection vector to direction vector
+      direction.set(2*normal.x*dot - incidence.x, 2*normal.y*dot - incidence.y, 0)      
+      # draw base top normal at collision point
+      stroke(255, 128, 0)
+      line(position.x, position.y, position.x - normal.x*100, position.y - normal.y*100)
+     end 
+  end
+  
+  # detect boundary collision
+  # right
+  if (position.x > width - radius)
+    @position.x = width - radius
+    @direction.x *= -1
+  end
+  # left 
+  if (position.x < radius)
+    @position.x = radius
+    @direction.x *= -1
+  end
+  # top
+  if (position.y < radius)
+    @position.y = radius
+    @direction.y *= -1
+    # randomize base top
+    @base1.y = rand(height - 100 .. height)
+    @base2.y = rand(height - 100 .. height)
+    @coords = create_ground
+  end
+end
+
+def create_ground
+  # calculate length of base top
+  @base_length = PVector.dist(base1, base2)
+  # fill base top coordinate array
+  coords = []
+  (0 ... base_length.ceil).each do |i|
+     coords << PVector.new(
+     base1.x + ((base2.x - base1.x) / base_length) * i,
+     base1.y + ((base2.y - base1.y) / base_length) * i)
+  end
+  return coords
+end
+

data/samples/processing_app/topics/motion/reflection2.rb

@@ -0,0 +1,122 @@
+#
+# Non-orthogonal Collision with Multiple Segments 
+# by Ira Greenberg. 
+# 
+# Based on Keith Peter's Solution in
+# Foundation Actionscript Animation: Making Things Move!
+
+
+load_library 'ground'
+
+GRAVITY = Vect.new(0, 0.05)
+DAMPING = 0.8
+SEGS = 40
+attr_accessor :orb, :velocity
+attr_reader :ground, :peakHeights
+
+def setup
+  size(640, 360)
+  @orb = Orb.new(50.0, 50.0, 3.0)
+  @velocity = Vect.new(0.5, 0.0)
+  # Initialize ground peak heights 
+  @peakHeights = []
+  (SEGS + 1).times do
+    @peakHeights << rand(height - 40.0 .. height - 30.0)
+  end
+  @ground = []  
+  
+  # Float value required for segment width 
+  # calculations so the ground spans the entire 
+  # display window, regardless of segment number.
+  
+  SEGS.times do |i|
+    @ground << Ground.new(width.to_f/SEGS*i, peakHeights[i], width.to_f/SEGS*(i+1), peakHeights[i+1])
+  end
+end
+
+
+def draw
+  # Background
+  no_stroke
+  fill(0, 0, 40, 15)
+  rect(0, 0, width, height)
+  
+  # Move orb
+  velocity.add(GRAVITY)
+  orb.move(velocity)
+  
+  # Draw ground
+  fill(127, 80, 70)
+  begin_shape()
+  ground.each do |seg|
+    vertex(seg.x1, seg.y1)
+    vertex(seg.x2, seg.y2)
+  end
+  vertex(ground[SEGS - 1].x2, height)
+  vertex(ground[0].x1, height)
+  end_shape(CLOSE)
+  
+  # Draw orb
+  no_stroke
+  fill(200)
+  ellipse(orb.x, orb.y, orb.r * 2, orb.r * 2)
+  
+  # Collision detection
+  check_wall_collision
+  ground.each do |seg|
+    check_ground_collision(seg)
+  end
+end
+
+
+def check_wall_collision
+  if (orb.x > width-orb.r)
+    orb.x = width-orb.r
+    velocity.x *= -DAMPING
+    
+  elsif (orb.x < orb.r)
+    orb.x = orb.r
+    velocity.x *= -DAMPING
+  end
+end
+
+
+def check_ground_collision(ground_segment)
+  
+  # Get difference between orb and ground
+  dx = orb.x - ground_segment.x
+  dy = orb.y - ground_segment.y
+  
+  # Precalculate trig values
+  cosine = cos(ground_segment.rot)
+  sine = sin(ground_segment.rot)
+  
+  #  Rotate ground and velocity to allow 
+  # orthogonal collision calculations
+  ground_x_temp = cosine * dx + sine * dy
+  ground_y_temp = cosine * dy - sine * dx
+  velocity_x_temp = cosine * velocity.x + sine * velocity.y
+  velocity_y_temp = cosine * velocity.y - sine * velocity.x
+  
+  # collision - check for surface 
+  # collision and also that orb is within 
+  # left/rights bounds of ground segment
+  if (ground_y_temp + orb.r) > EPSILON * 5 
+    if (orb.x > ground_segment.x1) && (orb.x < ground_segment.x2)
+      # keep orb from going into ground
+      ground_y_temp = -orb.r 
+      # bounce and slow down orb
+      velocity_y_temp *= -DAMPING
+    end
+  end
+  
+  # Reset ground, velocity and orb
+  dx = cosine * ground_x_temp - sine * ground_y_temp
+  dy = cosine * ground_y_temp + sine * ground_x_temp
+  @velocity.x = cosine * velocity_x_temp - sine * velocity_y_temp
+  @velocity.y = cosine * velocity_y_temp + sine * velocity_x_temp
+  @orb.x = ground_segment.x + dx
+  @orb.y = ground_segment.y + dy
+end
+
+

data/samples/processing_app/topics/shaders/README

@@ -0,0 +1 @@
+Recently I needed to use an external jruby to get some sketches to run OK (otherwise I got method missing errors see external_library/fisica). I thought I may be able to get rid of the included jruby-complete, until I tried to run the shader examples in this folder. I got java lang null pointer exception for these sketches and a few others (notably planets.rb in the demo folder). Needeless to say these sketches run OK using the included jruby-complete!!!

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

@@ -0,0 +1,25 @@
+#
+# Blur Filter
+# 
+# Change the default shader to apply a simple, custom blur filter.
+# 
+# Press the mouse to switch between the custom and default shader.
+#
+
+attr_reader :blur
+
+def setup
+  size(640, 360, P2D)
+  @blur = load_shader("blur.glsl"); 
+  stroke(255, 0, 0)
+  rectMode(CENTER)
+end
+
+def draw
+  filter(blur);  
+  rect(mouse_x, mouse_y, 150, 150); 
+  ellipse(mouse_x, mouse_y, 100, 100)
+end
+
+
+

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

@@ -0,0 +1,40 @@
+# Texture from Jason Liebig's FLICKR collection of vintage labels and wrappers:
+# http://www.flickr.com/photos/jasonliebigstuff/3739263136/in/photostream/
+
+attr_reader :label, :can, :angle, :bw_shader
+
+def setup
+  size(640, 360, P3D)  
+  @label = load_image("lachoy.jpg")
+  @can = create_can(100, 200, 32, label)
+  @bw_shader = load_shader("bwfrag.glsl")
+  @angle = 0
+end
+
+def draw    
+  background(0)  
+  shader(bw_shader)    
+  translate(width/2, height/2)
+  rotate_y(angle)  
+  shape(can)  
+  @angle += 0.01
+end
+
+def create_can(r, h, detail, tex)
+  texture_mode(NORMAL)
+  sh = create_shape
+  sh.begin_shape(QUAD_STRIP)
+  sh.no_stroke
+  sh.texture(tex)
+  (0 .. detail).each do |i|
+    angle = TWO_PI / detail
+    x = sin(i * angle)
+    z = cos(i * angle)
+    u = i.to_f / detail
+    sh.normal(x, 0, z)
+    sh.vertex(x * r, -h/2, z * r, u, 0)
+    sh.vertex(x * r, +h/2, z * r, u, 1)    
+  end
+  sh.end_shape 
+  return sh
+end

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

@@ -0,0 +1,26 @@
+# GLSL version of Conway's game of life, ported from GLSL sandbox:
+# http://glsl.heroku.com/e/207.3
+# Exemplifies the use of the buffer uniform in the shader, that gives
+# access to the previous frame.
+attr_accessor :pg, :conway
+
+def setup
+  size(400, 400, P3D)    
+  @pg = createGraphics(400, 400, P2D)
+  pg.no_smooth
+  @conway = load_shader("data/conway.glsl")
+  conway.set("resolution", width.to_f, height.to_f)  
+end
+
+def draw
+  conway.set("time", millis() / 1000.0)  
+  xm = map(mouse_x, 0, width, 0, 1)
+  ym = map(mouse_y, 0, height, 1, 0)
+  conway.set("mouse", xm, ym) 
+  pg.begin_draw
+  pg.background(0)
+  pg.shader(conway)
+  pg.rect(0, 0, pg.width, pg.height)  
+  pg.end_draw  
+  image(pg, 0, 0, width, height)  
+end

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

@@ -0,0 +1,44 @@
+// Copyright (C) 2007 Dave Griffiths
+// Copyright (C) 2007 Dave Griffiths
+// Licence: GPLv2 (see COPYING)
+// Fluxus Shader Library
+// ---------------------
+// Glossy Specular Reflection Shader
+// A more controllable version of blinn shading,
+// Useful for ceramic or fluids - from Advanced 
+// Renderman, thanks to Larry Gritz
+
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+uniform vec3 AmbientColour;
+uniform vec3 DiffuseColour;
+uniform vec3 SpecularColour;
+uniform float AmbientIntensity;
+uniform float DiffuseIntensity;
+uniform float SpecularIntensity;
+uniform float Roughness;
+uniform float Sharpness;
+
+varying vec3 N;
+varying vec3 P;
+varying vec3 V;
+varying vec3 L;
+    
+void main() { 
+  float w = 0.18*(1.0-Sharpness);
+	
+  vec3 l = normalize(L);
+  vec3 n = normalize(N);
+  vec3 v = normalize(V);
+  vec3 h = normalize(l+v);
+
+  float diffuse = dot(l,n);
+  float specular = smoothstep(0.72-w,0.72+w,pow(max(0.0,dot(n,h)),1.0/Roughness));
+    
+  gl_FragColor = vec4(AmbientColour*AmbientIntensity + 
+                      DiffuseColour*diffuse*DiffuseIntensity +
+                      SpecularColour*specular*SpecularIntensity,1);
+}

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

@@ -0,0 +1,33 @@
+// Copyright (C) 2007 Dave Griffiths
+// Licence: GPLv2 (see COPYING)
+// Fluxus Shader Library
+// ---------------------
+// Glossy Specular Reflection Shader
+// A more controllable version of blinn shading,
+// Useful for ceramic or fluids - from Advanced 
+// Renderman, thanks to Larry Gritz
+
+#define PROCESSING_LIGHT_SHADER
+
+uniform mat4 modelview;
+uniform mat4 transform;
+uniform mat3 normalMatrix;
+
+uniform vec4 lightPosition[8];
+
+attribute vec4 vertex;
+attribute vec3 normal;
+
+varying vec3 N;
+varying vec3 P;
+varying vec3 V;
+varying vec3 L;
+
+void main() {    
+  N = normalize(normalMatrix * normal); 
+  P = vertex.xyz;
+  V = -vec3(modelview * vertex);
+  L = vec3(modelview * (lightPosition[0] - vertex));
+  gl_Position = transform * vertex;
+}
+

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

@@ -0,0 +1,25 @@
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+varying vec3 vertNormal;
+varying vec3 vertLightDir;
+
+void main() {  
+  float intensity;
+  vec4 color;
+  intensity = max(0.0, dot(vertLightDir, vertNormal));
+
+  if (intensity > 0.95) {
+    color = vec4(1.0, 0.5, 0.5, 1.0);
+  } else if (intensity > 0.5) {
+    color = vec4(0.6, 0.3, 0.3, 1.0);
+  } else if (intensity > 0.25) {
+    color = vec4(0.4, 0.2, 0.2, 1.0);
+  } else {
+    color = vec4(0.2, 0.1, 0.1, 1.0);
+  }
+
+  gl_FragColor = color;  
+}

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

@@ -0,0 +1,31 @@
+// Toon shader using per-pixel lighting. Based on the glsl 
+// tutorial from lighthouse 3D:
+// http://www.lighthouse3d.com/tutorials/glsl-tutorial/toon-shader-version-ii/
+
+#define PROCESSING_LIGHT_SHADER
+
+uniform mat4 modelview;
+uniform mat4 transform;
+uniform mat3 normalMatrix;
+
+uniform vec3 lightNormal[8];
+
+attribute vec4 vertex;
+attribute vec3 normal;
+
+varying vec3 vertNormal;
+varying vec3 vertLightDir;
+
+void main() {
+  // Vertex in clip coordinates
+  gl_Position = transform * vertex;
+  
+  // Normal vector in eye coordinates is passed
+  // to the fragment shader
+  vertNormal = normalize(normalMatrix * normal);
+  
+  // Assuming that there is only one directional light.
+  // Its normal vector is passed to the fragment shader
+  // in order to perform per-pixel lighting calculation.  
+  vertLightDir = -lightNormal[0]; 
+}