ruby-processing 2.6.3 → 2.6.4

data/samples/contributed/circle_collision.rb

@@ -1,129 +0,0 @@
-# Based on http://processing.org/learning/topics/circlecollision.html
-
-load_library :vecmath
-
-
-class Ball
-  attr_accessor :position, :r, :m, :velocity
-  
-  def initialize(x = 0.0, y = 0.0, r = 0.0)
-    @position = Vec2D.new(x, y)
-    @r = r
-    @m = r * 0.1
-    @velocity = Vec2D.new(rand(-3.0..3), rand(-3.0..3))
-  end 
-  
-  def update
-    @position += velocity
-  end
-  
-  def check_boundary width, height 
-    if !(r..width - r).include?(position.x)
-      (position.x > width - r)? position.x = width - r : position.x = r
-      velocity.x *= -1
-    elsif !(r..height - r).include?(position.y)
-      (position.y > height - r)? position.y = height - r : position.y = r
-      velocity.y *= -1
-    end    
-  end
-  
-  def check_collision other_ball    
-    
-    # get distances between the balls components
-    difference = other_ball.position - position
-    
-    # calculate magnitude of the vector separating the balls
-
-    
-    if difference.mag < (r + other_ball.r) 
-      # get angle of difference
-      theta  = difference.heading
-      # precalculate trig values
-      sine = sin(theta)
-      cosine = cos(theta)
-      
-      # ball_array will hold rotated ball positions. You just
-      # need to worry about ball_array[1] position
-      ball_array = [Ball.new, Ball.new]
-      # other_ball's position is relative to ball's
-      # so you can use the vector between them (difference) as the 
-      # reference point in the rotation expressions.
-      # ball_array[0].x and ball_array[0].y will initialize
-      # automatically to 0.0, which is what you want
-      # since other_ball will rotate around ball
-      ball_array[1].position.x  = cosine * difference.x + sine * difference.y
-      ball_array[1].position.y  = cosine * difference.y - sine * difference.x
-      
-      # rotate Temporary velocities
-      velocity_array = [Vec2D.new, Vec2D.new]
-      velocity_array[0].x  = cosine * velocity.x + sine * velocity.y
-      velocity_array[0].y  = cosine * velocity.y - sine * velocity.x
-      velocity_array[1].x  = cosine * other_ball.velocity.x + sine * other_ball.velocity.y
-      velocity_array[1].y  = cosine * other_ball.velocity.y - sine * other_ball.velocity.x
-      
-      # Now that velocities are rotated, you can use 1D
-      # conservation of momentum equations to calculate 
-      # the final velocity along the x-axis.
-      final_velocities = [Vec2D.new, Vec2D.new]
-      # final rotated velocity for ball
-      final_velocities[0].x = ((m - other_ball.m) * velocity_array[0].x + 2 * other_ball.m * velocity_array[1].x) / (m + other_ball.m)
-      final_velocities[0].y = velocity_array[0].y
-      # final rotated velocity for ball
-      final_velocities[1].x = ((other_ball.m - m) * velocity_array[1].x + 2 * m * velocity_array[0].x) / (m + other_ball.m)
-      final_velocities[1].y = velocity_array[1].y
-      
-      # hack to avoid clumping
-      #ball_array[0].position.x += final_velocities[0].x
-      #ball_array[1].position.x += final_velocities[1].x
-      
-      # Rotate ball positions and velocities back
-      # Reverse signs in trig expressions to rotate 
-      # in the opposite direction
-      # rotate balls
-      final_positions = [Vec2D.new, Vec2D.new]
-      final_positions[0].x = cosine * ball_array[0].position.x - sine * ball_array[0].position.y
-      final_positions[0].y = cosine * ball_array[0].position.y + sine * ball_array[0].position.x
-      final_positions[1].x = cosine * ball_array[1].position.x - sine * ball_array[1].position.y
-      final_positions[1].y = cosine * ball_array[1].position.y + sine * ball_array[1].position.x
-      
-      # update balls to screen position
-      other_ball.position = position + final_positions[1]
-      @position += final_positions[0]
-      
-      # update velocities
-      velocity.x = cosine * final_velocities[0].x - sine * final_velocities[0].y
-      velocity.y = cosine * final_velocities[0].y + sine * final_velocities[0].x
-      other_ball.velocity.x = cosine * final_velocities[1].x - sine * final_velocities[1].y
-      other_ball.velocity.y = cosine * final_velocities[1].y + sine * final_velocities[1].x
-      
-    end
-  end
-  
-  def display
-    no_stroke
-    fill(204)
-    ellipse(position.x, position.y, r * 2, r * 2)
-  end
-  
-end
-
-attr_reader :balls
-
-def setup
-  size 640, 360
-  @balls = [Ball.new(100, 40, 20), Ball.new(200, 100, 80)]
-end
-
-
-def draw
-  background(51)  
-  balls.each do |b| 
-    b.update
-    b.display
-    b.check_boundary width, height
-  end
-  
-  balls[0].check_collision(balls[1])
-end
-
-

data/samples/contributed/drawolver.rb

@@ -1,96 +0,0 @@
-# Drawolver: draw 2D & revolve 3D
-
-# Example to show how to use the VecMath library.
-# ruby replacement for PVector. Also features 
-# the use each_cons, possibly a rare use for this 
-# ruby Enumerable method?
-# 2010-03-22 - fjenett (last revised by monkstone 2014-03-21)
-# now uses 'zip' and 'each', in place of a custom Array object
-# with a 'one_of_each' method
-
-load_library :vecmath
-import 'vecmath'
-attr_reader :drawing_mode, :points, :rot_x, :rot_y, :vertices
-
-def setup 
-  size 1024, 768, P3D
-  frame_rate 30 
-  reset_scene
-end
-
-def draw  
-  background 0    
-  if (!drawing_mode)      
-    translate(width/2, height/2)
-    rotate_x rot_x
-    rotate_y rot_y
-    @rot_x += 0.01
-    @rot_y += 0.02
-    translate(-width/2, -height/2)
-  end 
-  no_fill
-  stroke 255
-  points.each_cons(2) { |ps, pe| line ps.x, ps.y, pe.x, pe.y}
-
-  if (!drawing_mode)    
-    stroke 125
-    fill 120
-    lights 
-    ambient_light 120, 120, 120
-    vertices.each_cons(2) do |r1, r2|
-      begin_shape(TRIANGLE_STRIP)
-      r1.zip(r2).each do |v1, v2|
-        vertex v1.x, v1.y, v1.z
-        vertex v2.x, v2.y, v2.z
-      end
-      end_shape 
-    end
-  end 
-end
-
-def reset_scene 
-  @drawing_mode = true
-  @points = []
-  @rot_x = 0.0
-  @rot_y = 0.0
-end
-
-def mouse_pressed
-  reset_scene
-  points << Vec3D.new(mouse_x, mouse_y)
-end
-
-def mouse_dragged
-  points << Vec3D.new(mouse_x, mouse_y)
-end
-
-def mouse_released
-  points << Vec3D.new(mouse_x, mouse_y)
-  recalculate_shape
-end
-
-def recalculate_shape  
-  @vertices = []
-  points.each_cons(2) do |ps, pe|   
-    b = points.last - points.first
-    # len = b.mag
-    b.normalize!   
-    a = ps - points.first   
-    dot = a.dot b   
-    b = b * dot   
-    normal = points.first + b    
-    c = ps - normal
-    # nlen = c.mag    
-    vertices << []    
-    (0..TAU).step(PI/15) do |ang|     
-      e = normal + c * cos(ang)
-      e.z = c.mag * sin(ang)      
-      vertices.last << e
-    end
-  end
-  @drawing_mode = false
-end
-
-
-
-

data/samples/contributed/elegant_ball.rb

@@ -1,165 +0,0 @@
-# elegant_ball.rb
-# After a vanilla processing sketch by
-# Ben Notorianni aka lazydog
-#
-
-# elegant.rb
-
-
-load_library :vecmath
-
-attr_reader :start_t, :renderer
-
-def setup()
-  size(800, 800, P3D)
-  @renderer = AppRender.new(self) 
-  color_mode(RGB, 1)
-end
-
-
-
-def draw()
-  #background(0.25)
-  background(0)
-  # Move the origin so that the scene is centered on the screen.
-  translate(width/2, height/2, 0.0)
-  # Set up the lighting.
-  setup_lights
-  # Rotate the local coordinate system.
-  smooth_rotation(5.0, 6.7, 7.3)
-  # Draw the inner object.
-  no_stroke()
-  fill(smooth_colour(10.0, 12.0, 7.0))
-  draw_icosahedron(5, 60.0, false)
-  # Rotate the local coordinate system again.
-  smooth_rotation(4.5, 3.7, 7.3)
-  # Draw the outer object.
-  stroke(0.2)
-  fill(smooth_colour(6.0, 9.2, 0.7))
-  draw_icosahedron(5, 200.0, true)
-end
-
-def setup_lights
-  ambient_light(0.025, 0.025, 0.025)
-  directional_light(0.2, 0.2, 0.2, -1, -1, -1)
-  spot_light(1.0, 1.0, 1.0, -200, 0, 300, 1, 0, -1, Math::PI/4, 20)
-end
-
-##
-# Generate a vector whose components change smoothly over time in the range [ 0, 1 ].
-# Each component uses a Math.sin() function to map the current time in milliseconds somewhere
-# in the range [ 0, 1 ].A 'speed' factor is specified for each component.
-#
-def smooth_vector(s1, s2, s3)
-  mills = millis * 0.00003 ## Lazydogs factor
-  # mills = millis * 0.0000001 ## worked for me a bit slower!!
-  x = 0.5 * Math.sin(mills * s1) + 0.5
-  y = 0.5 * Math.sin(mills * s2) + 0.5
-  z = 0.5 * Math.sin(mills * s3) + 0.5
-  Vec3D.new(x, y, z)
-end
-
-##
-# Generate a colour which smoothly changes over time.
-# The speed of each component is controlled by the parameters s1, s2 and s3.
-#
-def smooth_colour(s1, s2, s3)
-  v = smooth_vector(s1, s2, s3)
-  color(v.x, v.y, v.z)
-end
-
-##
-# Rotate the current coordinate system.
-# Uses smooth_vector() to smoothly animate the rotation.
-#
-def smooth_rotation(s1, s2, s3)
-  r1 = smooth_vector(s1, s2, s3)
-  rotate_x(2.0 * Math::PI * r1.x)
-  rotate_y(2.0 * Math::PI * r1.y)
-  rotate_x(2.0 * Math::PI * r1.z)
-end
-
-##
-# Draw an icosahedron defined by a radius r and recursive depth d.
-# Geometry data will be saved into dst. If spherical is true then the icosahedron
-# is projected onto the sphere with radius r.
-#
-def draw_icosahedron(depth, r, spherical)
-  # Calculate the vertex data for an icosahedron inscribed by a sphere radius 'r'.
-  # Use 4 Golden Ratio rectangles as the basis.
-  gr = (1.0 + Math.sqrt(5.0)) / 2.0
-  h = r / Math.sqrt(1.0 + gr * gr)
-  v =
-    [
-    Vec3D.new(0, -h, h*gr), Vec3D.new(0, -h, -h*gr), Vec3D.new(0, h, -h*gr), Vec3D.new(0, h, h*gr),
-    Vec3D.new(h, -h*gr, 0), Vec3D.new(h, h*gr, 0), Vec3D.new(-h, h*gr, 0), Vec3D.new(-h, -h*gr, 0),
-    Vec3D.new(-h*gr, 0, h), Vec3D.new(-h*gr, 0, -h), Vec3D.new(h*gr, 0, -h), Vec3D.new(h*gr, 0, h)
-  ]
-
-  # Draw the 20 triangular faces of the icosahedron.
-  unless spherical then
-    r = 0.0
-  end
-
-  begin_shape(TRIANGLES)
-   
-  draw_triangle(depth, r, v[0], v[7],v[4])
-  draw_triangle(depth, r, v[0], v[4], v[11])
-  draw_triangle(depth, r, v[0], v[11], v[3])
-  draw_triangle(depth, r, v[0], v[3], v[8])
-  draw_triangle(depth, r, v[0], v[8], v[7])
-
-  draw_triangle(depth, r, v[1], v[4], v[7])
-  draw_triangle(depth, r, v[1], v[10], v[4])
-  draw_triangle(depth, r, v[10], v[11], v[4])
-  draw_triangle(depth, r, v[11], v[5], v[10])
-  draw_triangle(depth, r, v[5], v[3], v[11])
-  draw_triangle(depth, r, v[3], v[6], v[5])
-  draw_triangle(depth, r, v[6], v[8], v[3])
-  draw_triangle(depth, r, v[8], v[9], v[6])
-  draw_triangle(depth, r, v[9], v[7], v[8])
-  draw_triangle(depth, r, v[7], v[1], v[9])
-
-  draw_triangle(depth, r, v[2], v[1], v[9])
-  draw_triangle(depth, r, v[2], v[10], v[1])
-  draw_triangle(depth, r, v[2], v[5], v[10])
-  draw_triangle(depth, r, v[2], v[6], v[5])
-  draw_triangle(depth, r, v[2], v[9], v[6])
- 
-  end_shape()
-end
-
-##
-# Draw a triangle either immediately or subdivide it first.
-# If depth is 1 then draw the triangle otherwise subdivide first.
-#
-def draw_triangle(depth, r, p1, p2, p3)
-
-  if (depth == 1) then
-    p1.to_vertex(renderer)
-    p2.to_vertex(renderer)
-    p3.to_vertex(renderer)
-  else
-    # Calculate the mid points of this triangle.
-    v1 = (p1 + p2) * 0.5
-    v2 = (p2 + p3) * 0.5
-    v3 = (p3 + p1) * 0.5
-  unless (r == 0.0) then
-    # Project the verticies out onto the sphere with radius r.
-    v1.normalize!
-    v1 *= r
-    v2.normalize!
-    v2 *= r
-    v3.normalize!
-    v3 *= r
-  end
-    ## Generate the next level of detail
-    depth -= 1
-    draw_triangle(depth, r, p1, v1, v3)
-    draw_triangle(depth, r, v1, p2, v2)
-    draw_triangle(depth, r, v2, p3, v3)
-    # Uncomment out the next line to include the central part of the triangle.
-    # draw_triangle(depth, r, v1, v2, v3)
-  end
-end
-

data/samples/contributed/empathy.rb

@@ -1,78 +0,0 @@
-# Empathy
-# original by Kyle McDonald
-# http://www.openprocessing.org/visuals/?visualID=1182
-
-# This sketch takes advantage of multiple processors by running calculations
-# in a separate thread.
-
-CELL_COUNT      = 5000
-SLOW_DOWN       = 0.97
-ROTATION        = 0.004
-LINE_LENGTH     = 37
-MULTI_THREADED  = true
-
-attr_reader :cells
-
-def setup
-  size(500, 500, P3D)
-  stroke(0, 0, 0, 25)
-  initialize_cells
-  start_cell_updates if MULTI_THREADED
-end
-
-def initialize_cells
-  @cells  = []
-  n = CELL_COUNT
-  n.times do |i|
-    a = i + rand(PI / 9.0)
-    r = ((i / n.to_f) * (width / 2) * (((n - i) / n.to_f) * 3.3)) + rand(6.0)
-    cells << Cell.new((r * cos(a) + width / 2).to_i, (r * sin(a) + height / 2).to_i)
-  end
-end
-
-def start_cell_updates
-  Thread.new { Kernel.loop { cells.each { |cell| cell.update } } }
-end
-
-def draw
-  background 255
-  cells.each { |cell| cell.sense } if started?
-end
-
-def started?
-  pmouse_x != 0 || pmouse_y != 0
-end
-
-def mouse_pressed
-  cells.each { |cell| cell.reset }
-end
-
-##
-# The cell responds to mouse movement
-##
-
-class Cell
-  attr_reader :x, :y, :spin, :angle
-  def initialize(x, y)
-    @x, @y  = x, y
-    @spin   = 0
-    @angle  = 0
-  end
-
-  def reset
-    @spin, @angle = 0, 0
-  end
-
-  def update
-    det = ((pmouse_x - x) * (mouse_y - y) - (mouse_x - x) * (pmouse_y - y)).to_f
-    @spin += ROTATION * det / dist(x, y, mouse_x, mouse_y).to_f
-    @spin *= SLOW_DOWN
-    @angle += spin
-  end
-
-  def sense
-    update unless MULTI_THREADED
-    d = LINE_LENGTH * spin + 0.001
-    line(x, y, x + d * cos(angle), y + d * sin(angle))
-  end
-end