ruby-processing 2.4.4 → 2.5.0

data/samples/processing_app/topics/lsystems/snake_kolam.rb

@@ -1,37 +1,37 @@
 #######################################################
-# Lindenmayer System in ruby-processing by Martin Prout
-# snake_kolam.rb using l-systems
+# Lindenmayer System in ruby-procesDegLut.sing by Martin Prout
+# snake_kolam.rb uDegLut.sing l-systems
 #######################################################
 
-load_library 'grammar'
+load_library :grammar, :fastmath
 
 class SnakeKolam
   include Processing::Proxy
-  import 'grammar'
+
   attr_accessor :axiom, :start_length, :xpos, :ypos, :grammar, :production, :draw_length, :gen
   XPOS = 0
   YPOS = 1
   ANGLE = 2
-  DELTA = (PI/180) * 90.0 # convert degrees to radians
+  DELTA = 90 # degrees 
   
   def initialize xpos, ypos
     setup_grammar
     @start_length = 120.0
-    @theta = (PI/180) * 90.0 # convert degrees to radians
+    @theta = 90 # degrees 
     @draw_length = start_length
     @xpos = xpos 
     @ypos = ypos 
   end
   
   def setup_grammar
-    @axiom = "FX+F+FX+F"
+    @axiom = 'FX+F+FX+F'
     @grammar = Grammar.new(
       axiom,
-      {"X" => "X-F-F+FX+F+FX-F-F+FX"}
+      {'X' => 'X-F-F+FX+F+FX-F-F+FX'}
       )
   end
     
-  def render                     # NB not using affine transforms here
+  def render                     # NB not uDegLut.sing affine transforms here
     turtle = [xpos, ypos, 0.0]
     production.each do |element|
       case element
@@ -61,13 +61,13 @@ class SnakeKolam
   
   private
   ######################################################
-  # draws line using current turtle and length parameters
+  # draws line uDegLut.sing current turtle and length parameters
   # returns a turtle corresponding to the new position
   ######################################################
   
   def draw_line(turtle, length)
-    new_xpos = turtle[XPOS] + length * Math.cos(turtle[ANGLE])
-    new_ypos = turtle[YPOS] + length * Math.sin(turtle[ANGLE])
+    new_xpos = turtle[XPOS] + length * DegLut.cos(turtle[ANGLE])
+    new_ypos = turtle[YPOS] + length * DegLut.sin(turtle[ANGLE])
     line(turtle[XPOS], turtle[YPOS], new_xpos, new_ypos)
     turtle = [new_xpos, new_ypos, turtle[ANGLE]]
   end
@@ -78,7 +78,7 @@ attr_reader :kolam
 
 def setup
   size 500, 500
-  @kolam = SnakeKolam.new width/8, height*0.8
+  @kolam = SnakeKolam.new width / 8, height * 0.8
   kolam.create_grammar 3          # create grammar from rules
   no_loop
 end

data/samples/processing_app/topics/lsystems/stochastic_test.rb

@@ -2,54 +2,51 @@
 # stochastic_test.rb
 #
 # Lindenmayer System in ruby-processing by Martin Prout
-# Exploring terminals with minimum logic 
+# Exploring terminals with minimum logic
 ########################################################
 
-load_library 'stochastic_grammar'
+
+load_library :stochastic_grammar, :fastmath
+
+Turtle = Struct.new(:x, :y, :angle)
 
 class StochasticPlant
   include Processing::Proxy
 
-  attr_reader :grammar, :axiom, :draw_length, :theta, :xpos, :ypos, :production
-
-  XPOS = 0     # placeholders for turtle array
-  YPOS = 1
-  ANGLE = 2
+  attr_reader :grammar, :axiom, :draw_length, :turtle, :production
 
-  DELTA = PI/8
+  DELTA = 23
 
-  def initialize xpos_, ypos_   
+  def initialize xpos, ypos
     @draw_length = 350
-    @xpos = xpos_
-    @ypos = ypos_
-    @theta = HALF_PI                  # this way is up?
+    # use Struct as turtle
+    @turtle = Turtle.new(xpos, ypos, 90)        # this way is up?
     setup_grammar
   end
 
   def setup_grammar
-    @axiom = "F"
-    @grammar = StochasticGrammar.new(axiom)           
-    grammar.add_rule("F", "F[+F]F[-F]F", 0.1)     
-    grammar.add_rule("F", "F[+F]F", 0.45)           
-    grammar.add_rule("F", "F[-F]F", 0.45)
+    @axiom = 'F'
+    @grammar = StochasticGrammar.new(axiom)
+    grammar.add_rule('F', 'F[+F]F[-F]F', 0.1)
+    grammar.add_rule('F', 'F[+F]F', 0.45)
+    grammar.add_rule('F', 'F[-F]F', 0.45)
     @production = axiom
   end
 
   def render
     stack = []                     # ruby array as the turtle stack
-    turtle = [xpos, ypos, theta]   # ruby array as a turtle
     production.each_char do |element|
       case element
       when 'F'                     # NB NOT using affine transforms
-        turtle = draw_line(turtle, draw_length)
+        @turtle = draw_line(turtle, draw_length)
       when '+'
-        turtle[ANGLE] += DELTA
+        turtle.angle += DELTA
       when '-'
-        turtle[ANGLE] -= DELTA   
+        turtle.angle -= DELTA
       when '['
-        stack.push(turtle.dup)    # push a copy of the current turtle to stack 
+        stack << turtle.dup    # push a copy of the current turtle to stack
       when ']'
-        turtle = stack.pop        # assign current turtle to an instance popped from the stack
+        @turtle = stack.pop        # assign current turtle to an instance popped from the stack
       else
         puts "Character '#{element}' is not in grammar"
       end
@@ -64,14 +61,14 @@ class StochasticPlant
   private
   ######################################################
   # draws a line using current turtle and length parameters
-  # returns a turtle corresponding to the new position
+  # returns a new turtle corresponding to the next position
   ######################################################
 
   def draw_line(turtle, length)
-    new_xpos = turtle[XPOS] + length * cos(turtle[ANGLE])
-    new_ypos = turtle[YPOS] - length * sin(turtle[ANGLE])
-    line(turtle[XPOS], turtle[YPOS], new_xpos, new_ypos) 
-    turtle = [new_xpos, new_ypos, turtle[ANGLE]]
+    new_xpos = turtle.x + length * DegLut.cos(turtle.angle)
+    new_ypos = turtle.y - length * DegLut.sin(turtle.angle)
+    line(turtle.x, turtle.y, new_xpos, new_ypos)
+    Turtle.new(new_xpos, new_ypos, turtle.angle)
   end
 end
 

data/samples/processing_app/topics/lsystems/three_d_tree.rb

@@ -6,21 +6,22 @@
 load_libraries :stochastic_grammar, :control_panel
 attr_reader :plant, :zoom, :rot_y, :panel
 
-def setup() 
+def setup 
   size(800, 800, P3D)
   camera(400.0, 500.0, 200.0, 0.0, -160.0, 0.0, 
        0.0, 1.0, 0.0)
   setup_panel
   @plant = Plant.new
   plant.create_grammar(5)
-  no_stroke()
+  no_stroke
   @rot_y = 0
 end
 
 
 def setup_panel
   control_panel do |c|
-    c.title = "Control:"
+    c.title = 'Control:'
+    c.look_feel 'Metal'
     c.slider :zoom, 1..8, 3
     c.slider :rot_y, -PI..PI, 0
     c.button :reset
@@ -33,7 +34,7 @@ def reset
   @zoom = 1     
 end
 
-def draw() 
+def draw 
   panel.set_visible true if self.visible
   background(0) 
   rotate_y rot_y
@@ -53,42 +54,42 @@ class Plant
   attr_reader :grammar, :axiom, :production, :premis, :rule, 
   :theta, :scale_factor, :distance, :phi
   
-  def initialize() 
-    @axiom = "F"
+  def initialize 
+    @axiom = 'F'
     @grammar = StochasticGrammar.new(axiom)
     @production = axiom
-    @premis = "F"
-    @rule = "F[&+F]F[->F][->F][&F]"
+    @premis = 'F'
+    @rule = 'F[&+F]F[->F][->F][&F]'
     @scale_factor = 0.8
     @distance = 8
-    @theta = radians(28)
-    @phi = radians(28) 
+    @theta = 28.radians
+    @phi = 28.radians
     grammar.add_rule(premis, rule)
-    no_stroke()
+    no_stroke
   end
   
-  def render() 
+  def render 
     production.each_char do |ch|
       case(ch)
-      when "F"     
+      when 'F'     
         fill(0, 200, 0)
+        translate(0, distance / -2, 0)
+        box(distance / 4 , distance, distance / 4)
         translate(0, distance/-2, 0)
-        box(distance/4 , distance, distance/4)
-        translate(0, distance/-2, 0)
-      when "-"
+      when '-'
         rotateX(-theta)
-      when "+"
+      when '+'
         rotateX(theta)
-      when "&"
-        rotateY(-phi % TWO_PI)
-      when ">"
-        rotateZ(phi % TWO_PI)
-      when "<"
+      when '&'
+        rotateY(-phi % TAU)
+      when '>'
+        rotateZ(phi % TAU)
+      when '<'
         rotateZ(-phi)
-      when "["
+      when '['
         push_matrix
         @distance = distance * scale_factor
-      when "]"
+      when ']'
         pop_matrix
         @distance = distance / scale_factor
       else

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

@@ -1,7 +1,7 @@
 #
-# Bouncy Bubbles  
-# based on code from Keith Peters. 
-# 
+# Bouncy Bubbles
+# based on code from Keith Peters.
+#
 # Multiple-object collision.
 #
 
@@ -13,7 +13,7 @@ NUM_BALLS = 12
 attr_reader :balls, :id
 
 def setup
-  size(640, 360)  
+  size(640, 360)
   @balls = []
   (0 ... NUM_BALLS).each do |i|
     balls << Ball.new(rand(width), rand(height), rand(30 .. 70), i, balls)
@@ -24,9 +24,9 @@ end
 
 def draw
   background(0)
-  (0 ... NUM_BALLS).each do |i| 
-    balls[i].collide 
-    balls[i].move 
+  (0 ... NUM_BALLS).each do |i|
+    balls[i].collide
+    balls[i].move
     balls[i].display
   end
 end
@@ -34,7 +34,7 @@ end
 class Ball
   attr_accessor :vx, :vy
   attr_reader :x, :y, :diameter, :others, :id, :width, :height
-  
+
   def initialize(xin, yin, din, idin, oin)
     @x = xin
     @y = yin
@@ -45,8 +45,8 @@ class Ball
     @others = oin
     @width = $app.width
     @height = $app.height
-  end 
-  
+  end
+
   def collide
     ((id + 1) ... NUM_BALLS).each do |i|
       dx = others[i].x - x
@@ -54,7 +54,7 @@ class Ball
       sq_dist = dx*dx + dy*dy
       min_dist = (others[i].diameter/2 + diameter/2)
       sq_min_dist = min_dist * min_dist
-      if (sq_dist < sq_min_dist)  
+      if (sq_dist < sq_min_dist)
         angle = atan2(dy, dx)
         target_x = x + cos(angle) * min_dist
         target_y = y + sin(angle) * min_dist
@@ -65,30 +65,30 @@ class Ball
         others[i].vx += ax
         others[i].vy += ay
       end
-      
+
     end
-    
+
     def move
       @vy += GRAVITY
       @x += vx
       @y += vy
       if (x + diameter/2 > width)
         @x = width - diameter/2
-        @vx *= FRICTION         
+        @vx *= FRICTION
       elsif (x - diameter/2 < 0)
         @x = diameter/2
         @vx *= FRICTION
       end
-      
+
       if (y + diameter/2 > height)
         @y = height - diameter/2
-        @vy *= FRICTION 
+        @vy *= FRICTION
       elsif (y - diameter/2 < 0)
         @y = diameter/2
         @vy *= FRICTION
       end
     end
-    
+
     def display
       ellipse(x, y, diameter, diameter)
     end

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

@@ -18,9 +18,7 @@ CUBE_NO = 20
 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
 

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

@@ -7,7 +7,7 @@ class Cube
   # 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
@@ -61,7 +61,7 @@ class Cube
   def draw_cube
     # Draw cube
     COLORS.length.times do |i|
-      $app.fill_int(COLORS[i])
+      fill(COLORS[i])
       begin_shape(QUADS)
         4.times do |j|
           vertex(*vertices[j + 4 * i]) # splat vertices

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

@@ -47,7 +47,7 @@ def draw
   
   # Draw ground
   fill(127, 80, 70)
-  begin_shape()
+  begin_shape
   ground.each do |seg|
     vertex(seg.x1, seg.y1)
     vertex(seg.x2, seg.y2)

data/samples/processing_app/topics/shaders/blur_filter.rb

@@ -10,14 +10,14 @@ attr_reader :blur
 
 def setup
   size(640, 360, P2D)
-  @blur = load_shader("blur.glsl"); 
+  @blur = load_shader('blur.glsl') 
   stroke(255, 0, 0)
   rectMode(CENTER)
 end
 
 def draw
-  filter(blur);  
-  rect(mouse_x, mouse_y, 150, 150); 
+  filter(blur)  
+  rect(mouse_x, mouse_y, 150, 150) 
   ellipse(mouse_x, mouse_y, 100, 100)
 end
 

data/samples/processing_app/topics/shaders/bw_shader.rb

@@ -5,9 +5,9 @@ attr_reader :label, :can, :angle, :bw_shader
 
 def setup
   size(640, 360, P3D)  
-  @label = load_image("lachoy.jpg")
+  @label = load_image('lachoy.jpg')
   @can = create_can(100, 200, 32, label)
-  @bw_shader = load_shader("bwfrag.glsl")
+  @bw_shader = load_shader('bwfrag.glsl')
   @angle = 0
 end
 
@@ -27,7 +27,7 @@ def create_can(r, h, detail, tex)
   sh.no_stroke
   sh.texture(tex)
   (0 .. detail).each do |i|
-    angle = TWO_PI / detail
+    angle = TAU / detail
     x = sin(i * angle)
     z = cos(i * angle)
     u = i.to_f / detail

data/samples/processing_app/topics/shaders/conway.rb

@@ -8,15 +8,15 @@ def setup
   size(400, 400, P3D)    
   @pg = createGraphics(400, 400, P2D)
   pg.no_smooth
-  @conway = load_shader("data/conway.glsl")
-  conway.set("resolution", width.to_f, height.to_f)  
+  @conway = load_shader('data/conway.glsl')
+  conway.set('resolution', width.to_f, height.to_f)  
 end
 
 def draw
-  conway.set("time", millis() / 1000.0)  
-  xm = map(mouse_x, 0, width, 0, 1)
+  conway.set('time', millis / 1000.0)  
+  xm = map(mouse_x, 0, width, 0, 1)       # NB: processings map function
   ym = map(mouse_y, 0, height, 1, 0)
-  conway.set("mouse", xm, ym) 
+  conway.set('mouse', xm, ym) 
   pg.begin_draw
   pg.background(0)
   pg.shader(conway)