ruby-processing 1.0.11 → 2.4.1

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

@@ -0,0 +1,64 @@
+#
+# Cubes Contained Within a Cube 
+# by Ira Greenberg.  
+# 
+# Collision detection against all
+# outer cube's surfaces. 
+#
+
+# 20 little internal cubes
+load_library 'cube'
+
+# Size of outer cube
+BOUNDS = 300
+CUBE_NO = 20
+
+# using java_alias to give signatures to overloaded java methods
+# in the sketch class
+java_alias :background_int, :background, [Java::int]
+java_alias :stroke_int, :stroke, [Java::int]
+
+# using java_alias to give signatures to overloaded java method
+# in the cube class, need to call $app.fill_int in cube
+java_alias :fill_int, :fill, [Java::int]
+
+attr_reader :cubies
+
+def setup
+  size(640, 360, P3D)
+  @cubies = []
+  CUBE_NO.times do 
+    # Cubies are randomly sized
+    cubie_size = rand(5 .. 15)
+    cubies << Cube.new(cubie_size, cubie_size, cubie_size)
+  end
+  smooth 8
+end
+
+def draw
+  background_int(50)
+  lights
+  
+  # Center in display window
+  translate(width/2, height/2, -130)
+  
+  # Rotate everything, including external large cube
+  rotate_x(frame_count * 0.001)
+  rotate_y(frame_count * 0.002)
+  rotate_z(frame_count * 0.001)
+  stroke_int(255)
+  
+  
+  # Outer transparent cube, just using box method
+  no_fill 
+  box(BOUNDS)
+  
+  # Move and rotate cubies
+  cubies.each do |c|
+    c.update
+    c.display
+  end
+end
+
+
+

data/samples/processing_app/topics/motion/data/java_args.txt

@@ -0,0 +1,3 @@
+-Djruby.ji.objectProxyCache=false -XX:CompileCommand=dontinline,org.jruby.runtime.invokedynamic.InvokeDynamicSupport::invocationFallback 
+ 
+

data/samples/processing_app/topics/motion/library/cube/cube.rb

@@ -0,0 +1,128 @@
+# Custom Cube Class
+
+
+class Cube
+  include Processing::Proxy
+  
+  # Colors are hardcoded
+  BOUNDS=300
+  COLORS = [0,  51,  102,  153,  204,  255]
+  
+  # Position, velocity vectors
+  attr_reader :position, :velocity, :rotation, :vertices, :w, :h, :d
+  attr_reader :boundary
+  def initialize(w, h, d)
+    @w = w
+    @h = h
+    @d = d
+    @boundary = Boundary.new(-BOUNDS/2, BOUNDS/2)
+    @vertices = []
+    # Start in center
+    @position = Vect.new 0, 0, 0
+    # Random velocity vector
+    @velocity = Vect.random_3d
+    # Random rotation
+    @rotation = Vect.new(rand(40 .. 100), rand(40 .. 100), rand(40 .. 100))
+    
+    # cube composed of 6 quads
+    #front
+    vertices << [-w/2, -h/2, d/2]
+    vertices << [w/2, -h/2, d/2]
+    vertices << [w/2, h/2, d/2]
+    vertices << [-w/2, h/2, d/2]
+    #left
+    vertices << [-w/2, -h/2, d/2]
+    vertices << [-w/2, -h/2, -d/2]
+    vertices << [-w/2, h/2, -d/2]
+    vertices << [-w/2, h/2, d/2]
+    #right
+    vertices << [w/2, -h/2, d/2]
+    vertices << [w/2, -h/2, -d/2]
+    vertices << [w/2, h/2, -d/2]
+    vertices << [w/2, h/2, d/2]
+    #back
+    vertices << [-w/2, -h/2, -d/2]
+    vertices << [w/2, -h/2, -d/2]
+    vertices << [w/2, h/2, -d/2]
+    vertices << [-w/2, h/2, -d/2]
+    #top
+    vertices << [-w/2, -h/2, d/2]
+    vertices << [-w/2, -h/2, -d/2]
+    vertices << [w/2, -h/2, -d/2]
+    vertices << [w/2, -h/2, d/2]
+    #bottom
+    vertices << [-w/2, h/2, d/2]
+    vertices << [-w/2, h/2, -d/2]
+    vertices << [w/2, h/2, -d/2]
+    vertices << [w/2, h/2, d/2]
+  end 
+  
+  # Cube shape itself
+  def draw_cube
+    # Draw cube
+    COLORS.length.times do |i|
+      $app.fill_int(COLORS[i])
+      begin_shape(QUADS)
+        4.times do |j|
+          vertex(*vertices[j + 4 * i]) # splat vertices
+        end
+      end_shape
+    end
+  end
+  
+  # Update location
+  def update
+    position.add(velocity)
+    
+    # Check wall collisions
+    unless boundary.include? position.x
+      velocity.x *= -1
+    end
+    unless boundary.include? position.y
+      velocity.y *= -1
+    end
+    unless boundary.include? position.z
+      velocity.z *= -1
+    end
+  end
+  
+  
+  # Display method
+  def display
+    push_matrix
+    translate(position.x, position.y, position.z)
+    rotate_x(frame_count * PI / rotation.x)
+    rotate_y(frame_count * PI / rotation.y)
+    rotate_z(frame_count * PI /  rotation.z)
+    no_stroke
+    draw_cube # Farm out shape to another method
+    pop_matrix
+  end
+end
+
+# Abstract boundary checking to this
+# lightweight class
+#
+  
+Boundary = Struct.new(:lower, :upper) do
+  def include? x
+    (lower ... upper).cover? x
+  end
+end
+
+# Leaner meaner substitute for vanilla processings
+# PVector class, provides only functionality we need
+#
+Vect = Struct.new(:x, :y, :z) do
+
+  def self.random_3d
+    Vect.new(rand(-1 .. 1.0), rand(-1 .. 1.0), rand(-1 .. 1.0))
+  end
+
+  def add v
+    self.x += v.x
+    self.y += v.y
+    self.z += v.z
+  end
+end
+

data/samples/processing_app/topics/motion/library/ground/ground.rb

@@ -0,0 +1,42 @@
+class Ground  
+  attr_accessor :x, :y, :len, :rot 
+  attr_reader :x1, :y1, :x2, :y2 
+  
+  def initialize(x1, y1, x2, y2)
+    @x1, @y1, @x2, @y2 = x1, y1, x2, y2
+    @x = (x1 + x2) / 2.0
+    @y = (y1 + y2) / 2.0
+    @len = dist(x1, y1, x2, y2)
+    @rot = Math.atan2((y2 - y1), (x2 - x1))
+  end
+  
+  def dist(x1, y1, x2, y2)
+    Math.sqrt( (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) )
+  end
+end
+
+class Orb
+  attr_accessor :x, :y, :r  
+  def initialize (x, y, r)
+    @x, @y, @r = x, y, r
+  end
+
+  def move v
+    @x += v.x
+    @y += v.y
+  end
+end
+
+class Vect
+  attr_accessor :x, :y
+
+  def initialize(x, y)
+    @x, @y = x, y
+  end
+  
+  def add v
+    @x += v.x
+    @y += v.y
+  end
+end
+

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

@@ -0,0 +1,25 @@
+#
+# Linear Motion. 
+# 
+# Changing a variable to create a moving line.  
+# When the line moves off the edge of the window, 
+# the variable is set to 0, which places the line
+# back at the bottom of the screen. 
+#
+ 
+attr_reader :a
+
+def setup
+  size(640, 360)
+  stroke(255)
+  @a = height/2
+end
+
+def draw
+  background(51)
+  line(0, a, width, a) 
+  @a = a - 0.5
+  if (a < 0) 
+    @a = height; 
+  end
+end

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

@@ -0,0 +1,84 @@
+#
+# Morph. 
+# 
+# Changing one shape into another by interpolating
+# vertices from one to another
+#
+
+attr_reader :circle, :square, :morph, :state
+
+def setup
+  size(640, 360)
+  @circle = []
+  @square = []
+  @morph = []
+  @state = false
+  # Create a circle using vectors pointing from center
+  (0 .. 360).step(9) do |angle|
+    # Note we are not starting from 0 in order to match the
+    # path of a circle.  
+    v = PVector.from_angle(radians(angle-135))
+    v.mult(100)
+    circle << v
+    # Let's fill out morph Array with blank PVectors while we are at it
+    morph << PVector.new
+  end
+
+  # A square is a bunch of vertices along straight lines
+  # Top of square
+  (-50 .. 50).step(10) do |x|
+    square << PVector.new(x, -50)
+  end
+  # Right side
+  (-50 .. 50).step(10) do |y|
+    square << PVector.new(50, y)
+  end
+  # Bottom, NB: can't negative step ruby so use your loaf
+  5.downto(-5) do |x|
+    square << PVector.new(x * 10, 50)
+  end
+  # Left side
+  5.downto(-5) do |y|
+    square << PVector.new(-50, y * 10)
+  end
+end
+
+def draw
+  background(51)
+
+  # We will keep how far the vertices are from their target
+  total_distance = 0
+  
+  # Look at each vertex
+  circle.length.times do |i|
+    # Are we lerping to the circle or square?
+    v1 = (state)?  circle[i] : square[i]
+    # Get the vertex we will draw
+    v2 = morph[i]
+    
+    # Lerp to the target
+    v2.lerp(v1, 0.1)
+    # Check how far we are from target
+    total_distance += PVector.dist(v1, v2)
+  end
+  
+  # If all the vertices are close, switch shape
+  if (total_distance < 0.1)
+    @state = !state
+  end
+  
+  # Draw relative to center
+  translate(width/2, height/2)
+  stroke_weight(4)
+  # Draw a polygon that makes up all the vertices
+  begin_shape
+  no_fill
+  stroke(255)
+  morph.each do |v|
+    vertex(v.x, v.y)
+  end
+  end_shape(CLOSE)
+end
+
+
+

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

@@ -0,0 +1,46 @@
+#
+# Moving On Curves. 
+# 
+# In this example, the circles moves along the curve y = x^4.
+# Click the mouse to have it move to a new position.
+#
+STEP = 0.01       # Size of each step along the path
+
+attr_reader :exponent, :begin_x, :begin_y, :end_x, :end_y, :dist_x, :dist_y, :pct, :x, :y
+
+def setup
+  size(640, 360)
+  @begin_x = 20.0  # Initial x-coordinate
+  @begin_y = 10.0  # Initial y-coordinate
+  @end_x = 570.0   # Final x-coordinate
+  @end_y = 320.0   # Final y-coordinate  
+  @exponent = 4   # Determines the curve
+  @x = 0.0        # Current x-coordinate
+  @y = 0.0        # Current y-coordinate
+  @pct = 0.0      # Percentage traveled (0.0 to 1.0)
+  no_stroke
+  @dist_x = end_x - begin_x
+  @dist_y = end_y - begin_y
+end
+
+def draw
+  fill(0, 2)
+  rect(0, 0, width, height)
+  @pct += STEP
+  if (pct < 1.0)
+    @x = begin_x + (pct * dist_x)
+    @y = begin_y + (pow(pct, exponent) * dist_y)
+  end
+  fill(255)
+  ellipse(x, y, 20, 20)
+end
+
+def mouse_pressed
+  @pct = 0.0
+  @begin_x = x
+  @begin_y = y
+  end_x = mouse_x
+  end_y = mouse_y
+  @dist_x = end_x - begin_x
+  @dist_y = end_y - begin_y
+end

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

@@ -0,0 +1,78 @@
+#
+# Puff  
+# by Ira Greenberg.  
+# 
+# Series of ellipses simulating a multi-segmented 
+# organism, utilizing a follow the leader algorithm.
+# Collision detection occurs on the organism's head, 
+# controlling overall direction, and on the individual 
+# body segments, controlling body shape and jitter.
+#
+
+CELLS = 1000
+attr_accessor :px, :py, :speed_x, :speed_y
+attr_reader :radii_x, :radii_y, :angle, :frequency, :cell_radius, :head_x, :head_y
+
+def setup  
+  size(640, 360)
+  # Begin in the center
+  @head_x = width/2
+  @head_y = height/2
+  @speed_x = 0.7
+  @speed_y = 0.9
+  # Fill body arrays
+  @radii_x = Array.new(CELLS, rand(-7 .. 7)) 
+  @radii_y = Array.new(CELLS, rand(-7 .. 7) )
+  @frequency = Array.new(CELLS, rand(-7 .. 7) )
+  @cell_radius= Array.new(CELLS, rand(16 .. 30) )
+  @angle = Array.new(CELLS, 0)
+  @px = Array.new(CELLS, 0)
+  @py = Array.new(CELLS, 0)
+  frameRate(30)
+end
+
+def draw
+  background(0)
+  no_stroke
+  fill(255, 255, 255, 5)
+  
+  # Follow the leader
+  (0 ... CELLS).each do |i|
+    if (i == 0)
+      px[i] = head_x + sin(radians(angle[i]))*radii_x[i]
+      py[i] = head_y + cos(radians(angle[i]))*radii_y[i]
+    else
+      px[i] = px[i-1] + cos(radians(angle[i]))*radii_x[i]
+      py[i] = py[i-1] + sin(radians(angle[i]))*radii_y[i]
+      
+      # Check collision of body
+      if ((px[i] >= width-cell_radius[i] / 2) || (px[i] <= cell_radius[i] / 2))
+        radii_x[i]*=-1
+        cell_radius[i] = random(1, 40)
+        frequency[i]= random(-13, 13)
+      end
+      if ((py[i] >= height-cell_radius[i] / 2) || (py[i] <= cell_radius[i] / 2))
+        radii_y[i]*=-1
+        cell_radius[i] = random(1, 40)
+        frequency[i]= random(-9, 9)
+      end
+    end
+    # Draw puff
+    ellipse(px[i], py[i], cell_radius[i], cell_radius[i])
+    # Set speed of body
+    angle[i] += frequency[i]
+  end
+  
+  # Set velocity of head
+  @head_x += speed_x
+  @head_y += speed_y
+  
+  # Check boundary collision of head
+  if ((head_x >= width-cell_radius[0] / 2) || (head_x <=cell_radius[0] / 2))
+    @speed_x*=-1
+  end
+  if ((head_y >= height-cell_radius[0] / 2) || (head_y <= cell_radius[0] / 2))
+    @speed_y*=-1
+  end
+end
+