ruby-processing 1.0.11 → 2.4.1

data/samples/contributed/mandelbrot.rb

@@ -0,0 +1,82 @@
+# Mandelbrot Set example
+# by Jordan Scales (http://jordanscales.com)
+# 27 Dec 2012
+
+
+# default size 900x600
+# no need to loop
+def setup
+  size 900, 600
+  no_loop
+end
+
+# main drawing method
+def draw
+  (0..900).each do |x|
+    (0..600).each do |y|
+      c = Complex.new(map(x, 0, 900, -3, 1.5), map(y, 0, 600, -1.5, 1.5))
+  
+      # mandel will return 0 to 20 (20 is strong)
+      #   map this to 0, 255 (and flip it)
+      set(x, y, color(255 - map(mandel(c,20), 0, 20, 0, 255).to_i))
+    end
+  end
+end
+
+# calculates the "accuracy" of a given point in the mandelbrot set
+#    : how many iterations the number survives without becoming chaotic
+def mandel(z, max = 10)
+  score = 0
+  c = z.clone
+  while score < max do
+    # z = z^2 + c
+    z.square
+    z.add c
+    break if z.abs > 2
+
+    score += 1
+  end
+
+  score
+end
+
+
+# rolled my own Complex class
+#   stripped of all functionality, except for what I needed (abs, square, add, to_s)
+#   
+#   Using this class, runs in ~12.5s on my MacBook Air
+#     compared to ~22s using ruby's Complex struct
+class Complex
+
+  attr_accessor :real, :imag
+
+  def initialize(real, imag)
+    @real = real
+    @imag = imag
+  end
+
+  # squares a complex number - overwriting it
+  def square
+    r = real * real - imag * imag
+    i = 2 * real * imag
+
+    @real = r
+    @imag = i
+  end
+
+  # adds a given complex number
+  def add(c)
+    @real += c.real
+    @imag += c.imag
+  end
+
+  # computes the magnitude
+  def abs
+    sqrt(real * real + imag * imag)
+  end
+
+  def to_s
+    "#{real} + #{imag}i"
+  end
+
+end

data/samples/contributed/orbit.rb

@@ -2,20 +2,21 @@
 
 # This sketch demonstrates how to use the frame rate as orbital state,
 # as well as how to use system fonts in Ruby-Processing.
+attr_reader :d_font
 
 def setup
   size 450, 450
   frame_rate 30
   smooth
   fill 0
-  @font = create_font('Helvetica', 40)
+  @d_font = create_font('Helvetica', 40)
 end
 
 def draw
   background 255
   translate 225, 225
 
-  text_font @font
+  text_font d_font
   ellipse 0, 0, 10, 10
   text 'sun', 10, 0
 
@@ -27,12 +28,12 @@ def draw
 
     translate 120, 0
     ellipse 0, 0, 10, 10
-    text_font @font, 22
+    text_font d_font, 22
     text 'planet', 10, 0
 
     rotate frame_count / -30.0 * PI 
     line 0, 0, 30, 0
-    text_font @font, 15
+    text_font d_font, 15
     text 'moon', 32, 0
 
     pop_matrix

data/samples/contributed/pong.rb

@@ -1,175 +1,177 @@
 # Simple pong clone to demonstrate keyboard input and basic collision detection
 # Left paddle is controlled with 'a' and 'z', right with ''' and '/'
 
-class Sketch < Processing::App
-  def setup
-    smooth
-    ellipse_mode(CENTER)
-    no_fill
-    stroke(255)
-    frame_rate(60)
+def setup
+  size 800, 400
+  ellipse_mode(CENTER)
+  no_fill
+  stroke(255)
+  frame_rate(60)
+  @left_paddle = Paddle.new(width / 4, height / 2)
+  @right_paddle = Paddle.new(width / 4 * 3, height / 2)
+  @ball = Ball.new(width / 2, height / 2)
+end
 
-    @left_paddle = Paddle.new(width / 4, height / 2)
-    @right_paddle = Paddle.new(width / 4 * 3, height / 2)
-    @ball = Ball.new(width / 2, height / 2)
-  end
+def draw
+  background(0)
+  
+  paddles.each { |paddle| paddle.update }
+  
+  @ball.collide_with_boundaries
+  paddles.each { |paddle| @ball.collide_with_paddle(paddle) }
+  @ball.move
+  
+  paddles.each { |paddle| paddle.draw }
+  @ball.draw
+end
 
-  def draw
-    background(0)
+def paddles
+  return @left_paddle, @right_paddle
+end
 
-    paddles.each { |paddle| paddle.update }
+def key_pressed
+  case key
+  when 'a'  then  @left_paddle.direction = -1
+  when 'z'  then  @left_paddle.direction = 1
+  when '\'' then  @right_paddle.direction = -1
+  when '/'  then  @right_paddle.direction = 1
+  end
+end
 
-    @ball.collide_with_boundaries
-    paddles.each { |paddle| @ball.collide_with_paddle(paddle) }
-    @ball.move
+def key_released
+  case key
+  when 'a',  'z' then @left_paddle.direction = 0
+  when '\'', '/' then @right_paddle.direction = 0
+  end
+end
 
-    paddles.each { |paddle| paddle.draw }
-    @ball.draw
+class Paddle
+  attr_accessor :position, :radius, :direction, :width, :height, :speed
+  
+  def initialize(x, y)
+    @width, @height = $app.width, $app.height
+    @position = Vector.new(x, y) 
+    @radius = 20
+    @direction = 0
+    @speed = 2
   end
   
-  def paddles
-    return @left_paddle, @right_paddle
+  def draw
+    stroke_weight(2)
+    ellipse(position.x, position.y, radius * 2, radius * 2)
   end
-
-  def key_pressed
-    case key
-      when 'a'  then  @left_paddle.direction = -1
-      when 'z'  then  @left_paddle.direction = 1
-      when '\'' then  @right_paddle.direction = -1
-      when '/'  then  @right_paddle.direction = 1
-    end
+  
+  def update
+    move
+    collide_with_boundaries
   end
-
-  def key_released
-    case key
-      when 'a',  'z' then @left_paddle.direction = 0
-      when '\'', '/' then @right_paddle.direction = 0
-    end
+  
+  def move
+    @position.y += direction * speed
   end
-
-  class Paddle
-    attr_accessor :position, :radius, :direction
-
-    def initialize(x, y)
-      @position = Vector.new(x, y)
-      @radius = 20
-      @direction = 0
-      @speed = 2
-    end
-
-    def draw
-      stroke_weight(2)
-      ellipse(@position.x, @position.y, @radius * 2, @radius * 2)
-    end
-
-    def update
-      move
-      collide_with_boundaries
-    end
-
-    def move
-      @position.y += @direction * @speed
-    end
-
-    def collide_with_boundaries
-      @position.y = @position.y < @radius ? @radius : @position.y > height - @radius ? height - @radius : @position.y
-    end
+  
+  def collide_with_boundaries
+    @position.y = position.y < radius ? radius : position.y > height - radius ? height - radius : position.y
   end
+end
 
-  class Ball
-    attr_accessor :position, :velocity, :radius
-
-    def initialize(x, y)
-      @position = Vector.new(x, y)
-      @velocity = Vector.new(2, 0)
-      @radius = 5
-    end
-
-    def draw
-      stroke_weight(1)
-      ellipse(@position.x, @position.y, @radius * 2, @radius * 2)
-    end
-
-    def move
-      @position += @velocity
-    end
-
-    def collide_with_boundaries
-      if position.x <= radius || position.x >= width - radius
-        velocity.x *= -1
-      elsif position.y <= radius || position.y >= height - radius
-        velocity.y *= -1
-      end
-    end
-
-    def collide_with_paddle(paddle)
-      # Check for collision
-      distance_vector = position - paddle.position
-      return unless distance_vector.squared_length <= (radius + paddle.radius) ** 2
-
-      # Calculate new velocity
-      normal = distance_vector.normal.normalized
-      @velocity = normal * (velocity * normal) * 2 - velocity
-
-      # Move ball to correct position
-      @position = paddle.position + distance_vector.normalized * (2 * (radius + paddle.radius) - distance_vector.length)
-    end
+class Ball
+  attr_accessor :position, :velocity, :radius, :width, :height
+  
+  def initialize(x, y)
+    @width, @height = $app.width, $app.height
+    @position = Vector.new(x, y)
+    @velocity = Vector.new(2, 0)
+    @radius = 5
   end
-
-  class Vector
-    attr_accessor :x, :y
-
-    def initialize(x, y)
-      @x, @y = x, y
-    end
-
-    def +(other)
-      if other.is_a?(Numeric)
-        Vector.new(@x + other, @y + other)
-      elsif other.is_a?(Vector)
-        Vector.new(@x + other.x, @y + other.y)
-      else
-        self
-      end
-    end
-
-    def -(other)
-      if other.is_a?(Numeric)
-        Vector.new(@x - other, @y - other)
-      elsif other.is_a?(Vector)
-        Vector.new(@x - other.x, @y - other.y)
-      else
-        self
-      end
-    end
-
-    def *(other)
-      if other.is_a?(Numeric)
-        Vector.new(@x * other, @y * other)
-      elsif other.is_a?(Vector)
-        @x * other.x + @y * other.y
-      else
-        self
-      end
+  
+  def draw
+    stroke_weight(1)
+    ellipse(position.x, position.y, radius * 2, radius * 2)
+  end
+  
+  def move
+    @position += velocity
+  end
+  
+  def collide_with_boundaries
+    if position.x <= radius || position.x >= width - radius
+      velocity.x *= -1
+    elsif position.y <= radius || position.y >= height - radius
+      velocity.y *= -1
     end
+  end
+  
+  def collide_with_paddle(paddle)
+    # Check for collision
+    distance_vector = position - paddle.position
+    return unless distance_vector.squared_length <= (radius + paddle.radius) ** 2
+    
+    # Calculate new velocity
+    normal = distance_vector.normal.normalized
+    @velocity = normal * (velocity * normal) * 2 - velocity
+    
+    # Move ball to correct position
+    @position = paddle.position + distance_vector.normalized * (2 * (radius + paddle.radius) - distance_vector.length)
+  end
+end
 
-    def length
-      Math::sqrt(@x * @x + @y * @y)
-    end
 
-    def squared_length
-      @x * @x + @y * @y
+#####################################################################
+# Vector class only for illustration you could use PVector instead
+#####################################################################
+class Vector
+  attr_accessor :x, :y
+  
+  def initialize(x, y)
+    @x, @y = x, y
+  end
+  
+  def +(other)
+    if other.is_a?(Numeric)
+      Vector.new(x + other, y + other)
+    elsif other.is_a?(Vector)
+      Vector.new(x + other.x, y + other.y)
+    else
+      self
     end
-
-    def normal
-      Vector.new(-@y, @x)
+  end
+  
+  def -(other)
+    if other.is_a?(Numeric)
+      Vector.new(x - other, y - other)
+    elsif other.is_a?(Vector)
+      Vector.new(x - other.x, y - other.y)
+    else
+      self
     end
-
-    def normalized
-      length = self.length
-      Vector.new(@x / length, @y / length)
+  end
+  
+  def *(other)
+    if other.is_a?(Numeric)
+      Vector.new(x * other, y * other)
+    elsif other.is_a?(Vector)
+      x * other.x + y * other.y
+    else
+      self
     end
   end
+  
+  def length
+    sqrt(x * x + y * y)
+  end
+  
+  def squared_length
+    x * x + y * y
+  end
+  
+  def normal
+    Vector.new(-y, x)
+  end
+  
+  def normalized
+    length = self.length
+    Vector.new(x / length, y / length)
+  end
 end
 
-Sketch.new :width => 800, :height => 400

data/samples/contributed/quadraticvertex.rb

@@ -0,0 +1,98 @@
+# sketch by Jan Vantomme
+# Part of a series of articles on Processing 2.
+# Blog post here:
+# http://vormplus.be/blog/article/drawing-shapes-with-quadratic-vertices
+# translated for ruby-processing by Martin Prout 
+# Note how to specify fill and background using hexadecimal string for color, 
+# this is different from vanilla processing
+#
+
+load_library :control_panel
+
+attr_reader :debug, :save_one, :step_angle, :cr, :detail, :panel
+
+def setup
+  size 450, 320
+  control_panel do |c|
+    c.title = "controller"
+    c.menu(:detail, ['4', '5', '6', '7', '8', '9', '10' ], '7')
+    c.button :toggle_debug
+    c.button :save_image
+    @panel = c
+  end
+  
+  @debug = false
+  @save_one = false  
+  smooth 8
+end
+
+def draw
+  panel.set_visible true
+  background color('#BDF018')
+  translate width / 2, height / 2 
+  @step_angle = TWO_PI / (detail.to_i - 1)
+  fill color('#ffffff')
+  no_stroke
+  @cr = map(mouse_x, 0, width, 20, 200)
+  begin_shape
+  detail.to_i.times do |i|  
+    if (i == 0) 
+      vertex cos_x(i), sin_y(i) 
+    else 
+      quadratic_vertex cos_cx(i), sin_cy(i), cos_x(i), sin_y(i)
+    end
+  end
+  end_shape(CLOSE)
+  
+  if (debug)    
+    # draw lines between points
+    stroke_weight(1)
+    no_fill
+    stroke(0)
+    
+    begin_shape
+    detail.to_i.times do |i|          
+      vertex cos_cx(i), sin_cy(i) unless i == 0          
+      vertex cos_x(i), sin_y(i) 
+    end
+    end_shape CLOSE
+    
+    # draw points
+    stroke_weight 8    
+    detail.to_i.times do |i|  
+      stroke 0 
+      point cos_x(i), sin_y(i)      
+      stroke 255, 0, 0 
+      point cos_cx(i), sin_cy(i) 
+    end
+  end
+  
+  if (save_one) 
+    save_frame("images/quadraticvertex-#####.png")
+    @save_one = false
+  end
+end
+
+def cos_x(n)
+  cos(step_angle * n) * 100
+end
+
+def sin_y(n)
+  sin(step_angle * n) * 100
+end
+
+def cos_cx(n)
+  cos(step_angle * n - (step_angle / 2 )) * cr
+end
+
+def sin_cy(n)
+  sin(step_angle * n - (step_angle / 2 )) * cr
+end
+
+def toggle_debug
+  @debug = !debug
+end
+
+def save_image
+  @save_one = true
+end