ruby-processing 2.6.3 → 2.6.4

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

@@ -1,152 +0,0 @@
-# Trefoil, by Andres Colubri
-# A parametric surface is textured procedurally
-# by drawing on an offscreen PGraphics surface.
-#
-# Features (Vec3D).to_normal(renderer) and (Vec3D).to_vertex_uv(renderer, u, v)
-# see line 62 for inititialization of renderer where obj is an instance of PShape
-# renderer = ShapeRender.new(obj)
-
-load_library :vecmath
-
-attr_reader :pg, :trefoil
-
-def setup
-  size(1024, 768, P3D)
-  
-  texture_mode(NORMAL)
-  no_stroke
-
-  # 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(0.0..pg.width), rand(0.0..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. Makes of the Vec3D Render interface (uses ShapeRender here).
-# 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)
-  renderer = ShapeRender.new(obj)
-  (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      
-      n0.to_normal(renderer)
-      (p0 * s).to_vertex_uv(renderer, u0, v0)     
-      n1.to_normal(renderer)
-      (p1 * s).to_vertex_uv(renderer, u0, v1)
-      n2.to_normal(renderer)
-      (p2 * s).to_vertex_uv(renderer, u1, v1)
-
-      p1 = eval_point(u1, v0)
-      n1 = eval_normal(u1, v0)
-
-      # Triangle p0-p2-p1      
-      n0.to_normal(renderer)
-      (p0 * s).to_vertex_uv(renderer, u0, v0) 
-      n2.to_normal(renderer)
-      (p2 * s).to_vertex_uv(renderer, u1, v1) 
-      n1.to_normal(renderer)
-      (p1 * s).to_vertex_uv(renderer, 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 -= p
-  tangV -= p
-  tangV.cross(tangU).normalize! # it is easy to chain Vec3D operations
-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 = TAU * u
-  t = (TAU * (1 - v)) * 2  
-        
-  sint = sin(t)
-  cost = cos(t)
-  sint15 = sin(1.5 * t)
-  cost15 = cos(1.5 * t)
-
-  r = a + b * cost15
-  x = r * cost
-  y = r * sint
-  z = c * sint15
-
-  dv = Vec3D.new(
-  -1.5 * b * sint15 * cost - y,
-  -1.5 * b * sint15 * sint + x,
-  1.5 * c * cost15)
-
-  q = dv.normalize     # regular normalize creates a new Vec3D for us
-  qvn = Vec3D.new(q.y, -q.x, 0).normalize!  # chained Vec3D operations
-
-  ww = q.cross(qvn)
-
-  coss = cos(s)
-  sins = sin(s)
-
-  Vec3D.new(
-  x + d * (qvn.x * coss + ww.x * sins),
-  y + d * (qvn.y * coss + ww.y * sins),
-  z + d * ww.z * sins)
-end

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

@@ -1,287 +0,0 @@
-# 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]
-
-attr_reader :sine, :cosine
- 
-def setup
-  size(1024, 768, P3D);
-  @sine = []
-  @cosine = []
-  wiggling = false 
-  # Dry up that processing code a tiny bit
-  (0..TAU).step(TAU / CIRCLE_RES) do |i|
-    sine << CIRCLE_RAD * sin(i)
-  end
-  (0..TAU).step(TAU / CIRCLE_RES) do |i|
-    cosine << CIRCLE_RAD * cos(i)
-  end
-  @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|
-    x = sine[i]
-    y = cosine[i]
-    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|
-    x = sine[i]
-    y = cosine[i]
-    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|
-    x = CUBE_SIZE / 2
-    y = sine[i]
-    z = cosine[i]
-    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|
-    x = -CUBE_SIZE / 2
-    y = sine[i]
-    z = cosine[i]
-    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|
-    x = sine[i]
-    y = CUBE_SIZE / 2
-    z = cosine[i]
-    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|
-    x = sine[i]
-    y = -CUBE_SIZE / 2
-    z = cosine[i]
-    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|
-    x = sine[i]
-    y = cosine[i]
-    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|
-    x = sine[i]
-    y = cosine[i]
-    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|
-    x = CUBE_SIZE / 2
-    y = sine[i]
-    z = cosine[i]
-    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|
-    x = -CUBE_SIZE / 2
-    y = sine[i]
-    z = cosine[i]
-    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|
-    x = sine[i]
-    y = CUBE_SIZE / 2
-    z = cosine[i]
-    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|
-    x = sine[i]
-    y = -CUBE_SIZE / 2
-    z = cosine[i]
-    face.set_vertex(4 + i, x, y, z)
-  end
-end
-

data/samples/processing_app/demos/performance/cubic_grid_retained.rb

@@ -1,58 +0,0 @@
-########################
-# NB: Bit slow to get going
-# but, performs Ok after
-########################
-
-BOX_SIZE = 20
-MARGIN = BOX_SIZE * 2
-DEPTH = 400
-FINT = 3
-
-attr_reader :box_fill, :grid, :fcount, :lastm, :frate
-
-def setup
-  size(640, 360, P3D)
-  #frame_rate(60)
-  @fcount = 0
-  @lastm = 0
-  no_smooth
-  no_stroke
-  @grid = create_shape(GROUP)
-  # Build grid using multiple translations
-  (-(DEPTH/2 + MARGIN) ... (DEPTH/2 - MARGIN)).step(BOX_SIZE) do |i|
-    (-(height + MARGIN) ... (height - MARGIN)).step(BOX_SIZE) do |j|
-      (-(width + MARGIN) ... (width - MARGIN)).step(BOX_SIZE) do |k|
-        # Base fill color on counter values, abs function
-        # ensures values stay within legal range
-        @box_fill = color(i.abs.to_i, j.abs.to_i, k.abs.to_i, 50)
-        cube = create_shape(BOX, BOX_SIZE.to_f, BOX_SIZE.to_f, BOX_SIZE.to_f)
-        cube.set_fill(box_fill)
-        cube.translate(k, j, i)
-        grid.add_child(cube)
-      end
-    end
-  end
-end
-
-def draw
-  background(255)
-  hint(DISABLE_DEPTH_TEST)
-  # Center and spin grid
-  push_matrix()
-  translate(width/2, height/2, -DEPTH)
-  rotate_y(frame_count * 0.01)
-  rotate_x(frame_count * 0.01)
-  shape(grid)
-  pop_matrix()
-  hint(ENABLE_DEPTH_TEST)
-  @fcount += 1
-  m = millis()
-  if (m - lastm > 1000 * FINT)
-    @frate = fcount / FINT
-    @fcount = 0
-    @lastm = m
-    puts("fps: #{frate}")
-  end
-  fill(0)
-  text("fps: #{frate}", 10, 20)
-end