ruby-processing 2.6.3 → 2.6.4

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

@@ -1,62 +0,0 @@
-#
-# 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]
-
-
-
-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

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

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

@@ -1,128 +0,0 @@
-# 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|
-      fill(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 the 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

@@ -1,42 +0,0 @@
-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

@@ -1,25 +0,0 @@
-#
-# 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

@@ -1,84 +0,0 @@
-#
-# Morph.
-# see vecmath library for a variant using Vec2D instead of PVector
-# 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((angle - 135).radians)
-    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

@@ -1,46 +0,0 @@
-#
-# 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 + 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

@@ -1,78 +0,0 @@
-#
-# 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(angle[i].radians)*radii_x[i]
-      py[i] = head_y + cos(angle[i].radians)*radii_y[i]
-    else
-      px[i] = px[i-1] + cos(angle[i].radians)*radii_x[i]
-      py[i] = py[i-1] + sin(angle[i].radians)*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
-