ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/demos/graphics/planets.rb

@@ -0,0 +1,51 @@
+# Planets, by Andres Colubri
+#
+# Sun and mercury textures from http://planetpixelemporium.com
+# Star field picture from http://www.galacticimages.com/
+
+attr_reader :starfield, :sun, :suntex, :planet1, :surftex1, :cloudtex, :planet2, :surftex2
+
+def setup
+  size(1024, 768, P3D)  
+  @starfield = load_image("starfield.jpg")
+  @suntex = load_image("sun.jpg")  
+  @surftex1 = load_image("planet.jpg")    
+  @surftex2 = load_image("mercury.jpg")  
+  no_stroke
+  fill(255)
+  sphere_detail(40)
+  @sun = create_shape(SPHERE, 150)
+  @sun.set_texture(suntex)  
+  @planet1 = create_shape(SPHERE, 150)
+  planet1.set_texture(surftex1)  
+  @planet2 = create_shape(SPHERE, 50)
+  planet2.set_texture(surftex2)
+end
+
+def draw
+  # Even we draw a full screen image after this, it is recommended to use
+  # background to clear the screen anyways, otherwise A3D will think
+  # you want to keep each drawn frame in the framebuffer, which results in 
+  # slower rendering.
+  background(0)  
+  # Disabling writing to the depth mask so the 
+  # background image doesn't occludes any 3D object.
+  hint(DISABLE_DEPTH_MASK)
+  image(starfield, 0, 0, width, height)
+  hint(ENABLE_DEPTH_MASK)   
+  push_matrix
+  translate(width/2, height/2, -300)   
+  push_matrix
+  rotate_y(PI * frame_count / 500)
+  shape(sun)
+  pop_matrix
+  point_light(255,  255,  255,  0,  0,  0)  
+  rotate_y(PI * frame_count / 300)
+  translate(0, 0, 300)
+  shape(planet2)    
+  pop_matrix  
+  no_lights
+  point_light(255,  255,  255,  0,  0,  -150)   
+  translate(0.75 * width,  0.6 * height,  50)
+  shape(planet1)
+end

data/samples/processing_app/demos/graphics/trefoil.rb

@@ -0,0 +1,142 @@
+# Trefoil, by Andres Colubri
+# A parametric surface is textured procedurally
+# by drawing on an offscreen PGraphics surface.
+
+attr_reader :pg, :trefoil
+
+def setup
+  size(1024, 768, P3D)
+  
+  texture_mode(NORMAL)
+  noStroke
+
+  # Creating offscreen surface for 3D rendering.
+  @pg = create_graphics(32, 512, P3D)
+  pg.begin_draw
+  pg.background(0, 0)
+  pg.noStroke
+  pg.fill(255, 0, 0, 200)
+  pg.end_draw 
+
+  # Saving trefoil surface into a PShape3D object
+  @trefoil = create_trefoil(350, 60, 15, pg)
+end
+
+def draw
+  background(0)
+  
+  pg.begin_draw    
+  pg.ellipse(rand * pg.width, rand * pg.height, 4, 4)
+  pg.end_draw 
+
+  ambient(250, 250, 250)
+  pointLight(255, 255, 255, 0, 0, 200)
+     
+  push_matrix
+  translate(width/2, height/2, -200)
+  rotate_x(frame_count * PI / 500)
+  rotate_y(frame_count * PI / 500)      
+  shape(trefoil)
+  pop_matrix
+end
+
+# Code to draw a trefoil knot surface, with normals and texture 
+# coordinates.
+# Adapted from the parametric equations example by Philip Rideout:
+# http:#iphone-3d-programming.labs.oreilly.com/ch03.html
+
+# This function draws a trefoil knot surface as a triangle mesh derived
+# from its parametric equation.
+def create_trefoil(s, ny, nx, tex)
+ 
+  obj = create_shape()
+  obj.begin_shape(TRIANGLES)
+  obj.texture(tex)
+    
+  (0 ... nx).each do |j|
+    u0 = j.to_f / nx
+    u1 = (j + 1).to_f / nx
+    (0 ... ny).each do |i|
+      v0 = i.to_f / ny
+      v1 = (i + 1).to_f / ny
+      
+      p0 = eval_point(u0, v0)
+      n0 = eval_normal(u0, v0)
+      
+      p1 = eval_point(u0, v1)
+      n1 = eval_normal(u0, v1)
+      
+      p2 = eval_point(u1, v1)
+      n2 = eval_normal(u1, v1)
+
+      # Triangle p0-p1-p2      
+      obj.normal(n0.x, n0.y, n0.z)
+      obj.vertex(s * p0.x, s * p0.y, s * p0.z, u0, v0)      
+      obj.normal(n1.x, n1.y, n1.z)
+      obj.vertex(s * p1.x, s * p1.y, s * p1.z, u0, v1)
+      obj.normal(n2.x, n2.y, n2.z)
+      obj.vertex(s * p2.x, s * p2.y, s * p2.z, u1, v1)
+
+      p1 = eval_point(u1, v0)
+      n1 = eval_normal(u1, v0)
+
+      # Triangle p0-p2-p1      
+      obj.normal(n0.x, n0.y, n0.z)
+      obj.vertex(s * p0.x, s * p0.y, s * p0.z, u0, v0)      
+      obj.normal(n2.x, n2.y, n2.z)
+      obj.vertex(s * p2.x, s * p2.y, s * p2.z, u1, v1)
+      obj.normal(n1.x, n1.y, n1.z)
+      obj.vertex(s * p1.x, s * p1.y, s * p1.z, u1, v0)      
+    end
+  end
+  obj.end_shape
+  return obj
+end
+
+# Evaluates the surface normal corresponding to normalized 
+# parameters (u, v)
+def eval_normal(u, v)
+  # Compute the tangents and their cross product.
+  p = eval_point(u, v)
+  tangU = eval_point(u + 0.01, v)
+  tangV = eval_point(u, v + 0.01)
+  tangU.sub(p)
+  tangV.sub(p)
+  
+  normUV = tangV.cross(tangU)
+  normUV.normalize
+  return normUV
+end
+
+# Evaluates the surface point corresponding to normalized 
+# parameters (u, v)
+def eval_point(u, v)
+  a = 0.5
+  b = 0.3
+  c = 0.5
+  d = 0.1
+  s = TWO_PI * u
+  t = (TWO_PI * (1 - v)) * 2  
+        
+  r = a + b * cos(1.5 * t)
+  x = r * cos(t)
+  y = r * sin(t)
+  z = c * sin(1.5 * t)
+        
+  dv = PVector.new
+  dv.x = -1.5 * b * sin(1.5 * t) * cos(t) - (a + b * cos(1.5 * t)) * sin(t)
+  dv.y = -1.5 * b * sin(1.5 * t) * sin(t) + (a + b * cos(1.5 * t)) * cos(t)
+  dv.z = 1.5 * c * cos(1.5 * t)
+        
+  q = dv      
+  q.normalize
+  qvn = PVector.new(q.y, -q.x, 0)
+  qvn.normalize
+  ww = q.cross(qvn)
+        
+  pt = PVector.new
+  pt.x = x + d * (qvn.x * cos(s) + ww.x * sin(s))
+  pt.y = y + d * (qvn.y * cos(s) + ww.y * sin(s))
+  pt.z = z + d * ww.z * sin(s)
+  return pt
+end

data/samples/processing_app/demos/graphics/wiggling.rb

@@ -0,0 +1,289 @@
+# Press 'w' to start wiggling, space to restore
+# original positions.
+
+attr_reader :cube, :wiggling
+CUBE_SIZE = 320.0
+CIRCLE_RAD = 100.0
+CIRCLE_RES = 40
+NOISE_MAG = 1.0
+
+# signature-specific alias for overloaded method 
+java_alias :background_int, :background, [Java::int]
+
+ 
+def setup
+  size(1024, 768, P3D);    
+  wiggling = false
+  @cube = create_cube
+end
+
+def draw
+  background_int(0)
+  
+  translate(width/2, height/2)
+  rotate_x(frame_count * 0.01)
+  rotate_y(frame_count * 0.01)
+  
+  shape(cube)
+  
+  if (wiggling)
+    (0 ... cube.get_child_count).each do |i|
+      face = cube.get_child(i)
+      face.get_vertex_count.times do |j|
+      x, y, z = face.get_vertex_x(j), face.get_vertex_y(j), face.get_vertex_z(j)
+      x += rand(-NOISE_MAG/2 .. NOISE_MAG/2)
+      y += rand(-NOISE_MAG/2 .. NOISE_MAG/2)
+      z += rand(-NOISE_MAG/2 .. NOISE_MAG/2)
+      face.set_vertex(j, x, y, z)
+    end
+  end
+end
+
+end
+
+def key_pressed
+  case key
+  when 'w'
+    @wiggling = !wiggling
+  when ' '
+    restore_cube
+  when '1'
+    cube.set_stroke_weight(1)
+  when '2'
+    cube.set_stroke_weight(5)
+  when '3'
+    cube.set_stroke_weight(10)
+  end
+end
+
+def create_cube
+  cube = create_shape(GROUP)   
+  
+  # Front face         
+  face = create_shape
+  face.begin_shape(POLYGON)
+  face.stroke(255, 0, 0)
+  face.fill(255)
+  face.begin_contour
+  face.vertex(-CUBE_SIZE / 2, -CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.vertex(CUBE_SIZE / 2, -CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.vertex(CUBE_SIZE / 2, CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.vertex(-CUBE_SIZE / 2, CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.end_contour
+  face.begin_contour
+  CIRCLE_RES.times do |i|
+    angle = TAU * i / CIRCLE_RES
+    x = CIRCLE_RAD * sin(angle)
+    y = CIRCLE_RAD * cos(angle)
+    z = CUBE_SIZE / 2
+    face.vertex(x, y, z)
+  end
+  face.end_contour
+  face.end_shape(CLOSE)
+  cube.add_child(face)
+  
+  # Back face
+  face = create_shape
+  face.begin_shape(POLYGON)
+  face.stroke(255, 0, 0)
+  face.fill(255)
+  face.begin_contour
+  face.vertex(CUBE_SIZE / 2, -CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.vertex(-CUBE_SIZE / 2, -CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.vertex(-CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.vertex(CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.end_contour
+  face.begin_contour
+  CIRCLE_RES.times do |i|
+    angle = TAU * i / CIRCLE_RES
+    x = CIRCLE_RAD * sin(angle)
+    y = CIRCLE_RAD * cos(angle)
+    z = -CUBE_SIZE / 2
+    face.vertex(x, y, z)
+  end
+  face.end_contour
+  face.end_shape(CLOSE)
+  cube.add_child(face)
+  
+  # Right face
+  face = create_shape
+  face.begin_shape(POLYGON)
+  face.stroke(255, 0, 0)
+  face.fill(255)
+  face.begin_contour
+  face.vertex(CUBE_SIZE / 2.0, -CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.vertex(CUBE_SIZE / 2.0, -CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.vertex(CUBE_SIZE / 2.0, CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.vertex(CUBE_SIZE / 2.0, CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.end_contour
+  face.begin_contour
+  CIRCLE_RES.times do |i|
+    angle = TAU * i / CIRCLE_RES
+    x = CUBE_SIZE / 2
+    y = CIRCLE_RAD * sin(angle)
+    z = CIRCLE_RAD * cos(angle)
+    face.vertex(x, y, z)
+  end
+  face.end_contour
+  face.end_shape(CLOSE)
+  cube.add_child(face)
+  
+  # Left face
+  face = create_shape
+  face.begin_shape(POLYGON)
+  face.stroke(255, 0, 0)
+  face.fill(255)
+  face.begin_contour
+  face.vertex(-CUBE_SIZE / 2, -CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.vertex(-CUBE_SIZE / 2, -CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.vertex(-CUBE_SIZE / 2, CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.vertex(-CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.end_contour
+  face.begin_contour
+  CIRCLE_RES.times do |i|
+    angle = TAU * i / CIRCLE_RES
+    x = -CUBE_SIZE / 2
+    y = CIRCLE_RAD * sin(angle)
+    z = CIRCLE_RAD * cos(angle)
+    face.vertex(x, y, z)
+  end
+  face.end_contour
+  face.end_shape(CLOSE)
+  cube.add_child(face)
+  
+  # Top face
+  face = create_shape
+  face.begin_shape(POLYGON)
+  face.stroke(255, 0, 0)
+  face.fill(255)
+  face.begin_contour
+  face.vertex(-CUBE_SIZE / 2, CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.vertex(CUBE_SIZE / 2, CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.vertex(CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.vertex(-CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.end_contour
+  face.begin_contour
+  CIRCLE_RES.times do |i|
+    angle = TAU * i / CIRCLE_RES
+    x = CIRCLE_RAD * sin(angle)
+    y = CUBE_SIZE / 2
+    z = CIRCLE_RAD * cos(angle)
+    face.vertex(x, y, z)
+  end
+  face.end_contour
+  face.end_shape(CLOSE)
+  cube.add_child(face);     
+  
+  # Bottom face
+  face = create_shape
+  face.begin_shape(POLYGON)
+  face.stroke(255, 0, 0)
+  face.fill(255)
+  face.begin_contour
+  face.vertex(CUBE_SIZE / 2, -CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.vertex(-CUBE_SIZE / 2, -CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.vertex(-CUBE_SIZE / 2, -CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.vertex(CUBE_SIZE / 2, -CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.end_contour
+  face.begin_contour
+  CIRCLE_RES.times do |i|
+    angle = TAU * i / CIRCLE_RES
+    x = CIRCLE_RAD * sin(angle)
+    y = -CUBE_SIZE / 2
+    z = CIRCLE_RAD * cos(angle)
+    face.vertex(x, y, z)
+  end
+  face.end_contour
+  face.end_shape(CLOSE)
+  cube.add_child(face)
+  return cube
+end
+
+def restore_cube
+  
+  
+  # Front face
+  face = cube.get_child(0)
+  face.set_vertex(0, -CUBE_SIZE / 2, -CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.set_vertex(1, CUBE_SIZE / 2, -CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.set_vertex(2, CUBE_SIZE / 2, CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.set_vertex(3, -CUBE_SIZE / 2, CUBE_SIZE / 2, CUBE_SIZE / 2)
+  CIRCLE_RES.times do |i|
+    angle = TAU * i / CIRCLE_RES
+    x = CIRCLE_RAD * sin(angle)
+    y = CIRCLE_RAD * cos(angle)
+    z = CUBE_SIZE / 2
+    face.set_vertex(4 + i, x, y, z)
+  end
+  
+  # Back face
+  face = cube.get_child(1)
+  face.set_vertex(0, CUBE_SIZE / 2, -CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.set_vertex(1, -CUBE_SIZE / 2, -CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.set_vertex(2, -CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.set_vertex(3, CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  CIRCLE_RES.times do |i|
+    angle = TAU * i / CIRCLE_RES
+    x = CIRCLE_RAD * sin(angle)
+    y = CIRCLE_RAD * cos(angle)
+    z = -CUBE_SIZE / 2
+    face.set_vertex(4 + i, x, y, z)
+  end
+  
+  # Right face
+  face = cube.get_child(2)
+  face.set_vertex(0, CUBE_SIZE / 2, -CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.set_vertex(1, CUBE_SIZE / 2, -CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.set_vertex(2, CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.set_vertex(3, CUBE_SIZE / 2, CUBE_SIZE / 2, CUBE_SIZE / 2)
+  CIRCLE_RES.times do |i|
+    angle = TAU * i / CIRCLE_RES
+    x = CUBE_SIZE / 2
+    y = CIRCLE_RAD * sin(angle)
+    z = CIRCLE_RAD * cos(angle)
+    face.set_vertex(4 + i, x, y, z)
+  end
+  
+  # Left face
+  face = cube.get_child(3)
+  face.set_vertex(0, -CUBE_SIZE / 2, -CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.set_vertex(1, -CUBE_SIZE / 2, -CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.set_vertex(2, -CUBE_SIZE / 2, CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.set_vertex(3, -CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  CIRCLE_RES.times do |i|
+    angle = TAU * i / CIRCLE_RES
+    x = -CUBE_SIZE / 2
+    y = CIRCLE_RAD * sin(angle)
+    z = CIRCLE_RAD * cos(angle)
+    face.set_vertex(4 + i, x, y, z)
+  end    
+  
+  # Top face
+  face = cube.get_child(4)
+  face.set_vertex(0, -CUBE_SIZE / 2, CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.set_vertex(1, CUBE_SIZE / 2, CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.set_vertex(2, CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.set_vertex(3, -CUBE_SIZE / 2, CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  CIRCLE_RES.times do |i|
+    angle = TAU * i / CIRCLE_RES
+    x = CIRCLE_RAD * sin(angle)
+    y = CUBE_SIZE / 2
+    z = CIRCLE_RAD * cos(angle)
+    face.set_vertex(4 + i, x, y, z)
+  end    
+  
+  # Bottom face
+  face = cube.get_child(5)
+  face.set_vertex(0, CUBE_SIZE / 2, -CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.set_vertex(1, -CUBE_SIZE / 2, -CUBE_SIZE / 2, CUBE_SIZE / 2)
+  face.set_vertex(2, -CUBE_SIZE / 2, -CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  face.set_vertex(3, CUBE_SIZE / 2, -CUBE_SIZE / 2, -CUBE_SIZE / 2)
+  CIRCLE_RES.times do |i|
+    angle = TAU * i / CIRCLE_RES
+    x = CIRCLE_RAD * sin(angle)
+    y = -CUBE_SIZE / 2
+    z = CIRCLE_RAD * cos(angle)
+    face.set_vertex(4 + i, x, y, z)
+  end
+end
+