ruby-processing 1.0.8 → 1.0.9

data/samples/gravity.rb

@@ -0,0 +1,113 @@
+# After Gravity by Christian Hahn
+
+attr_reader :particles, :grabbed
+
+def setup
+  @particles  = []
+  @grabbed    = nil
+  
+  size 600, 500
+  background 0
+  smooth
+  stroke_weight 4
+  ellipse_mode CENTER_DIAMETER
+  color_mode RGB, 255
+end
+
+def draw
+  no_stroke
+  fill 0, 60
+  rect 0, 0, width, height
+  @particles.each {|p| p.collect_force; p.move; p.render }
+end
+
+def mouse_pressed
+  return if mouse_x == 0 || mouse_y == 0
+  return if particle_grab
+  @particles << Particle.new(mouse_x, mouse_y, rand * 8 + 0.1)
+end
+
+def mouse_released
+  @grabbed = nil
+end
+
+def particle_grab
+  @grabbed = @particles.detect {|p| dist(mouse_x, mouse_y, p.x1, p.y1) < p.radius }
+end
+
+
+class Particle
+  
+  GRAVITY = 1.0
+  
+  attr_reader :x0, :y0, :x1, :y1, :radius, :mass_amount
+  
+  def initialize(x, y, mass)
+    @x0, @y0, @x1, @y1  = x, y, x, y
+    @x_speed, @y_speed  = 0, 0
+    @x_accel, @y_accel  = 0, 0
+    @mass_amount        = mass
+    @diameter           = Math.sqrt(@mass_amount) * 20
+    @radius             = @diameter / 2.0
+  end
+  
+  def collect_force
+    @x_accel, @y_accel = 0, 0
+    @min_dist = 1000
+    $app.particles.each do |p|
+      next if p == self
+      g_dist  = dist(@x0, @y0, p.x0, p.y0)
+      g_theta = -(angleOf(@x0, @y0, p.x0, p.y0)).radians
+      @min_dist = g_dist if g_dist < @min_dist
+      force = (GRAVITY * @mass_amount * p.mass_amount) / g_dist
+      if g_dist.abs > @diameter
+        @x_accel += force / @mass_amount * Math.cos(g_theta)
+        @y_accel += force / @mass_amount * Math.sin(g_theta)
+      end
+    end
+  end
+  
+  def move
+    @x_speed, @y_speed = 0, 0 if grabbed?
+    @x_speed += @x_accel
+    @y_speed += @y_accel
+    @x1, @y1 = @x0 + @x_speed, @y0 + @y_speed
+  end
+  
+  def grabbed?
+    $app.grabbed == self
+  end
+  
+  def render
+    no_stroke
+    grabbed? ? render_grabbed : render_free
+  end
+  
+  def render_free
+    charge_col  = 1000.0 / @min_dist / 50.0
+    tot_col_1   = 100 + charge_col * 6
+    tot_col_2   = 150 + charge_col*charge_col
+    tot_col_3   = @diameter + 8 + charge_col
+    fill(tot_col_1, tot_col_1, 255, charge_col * 150 + 3)
+    ellipse(@x1, @y1, tot_col_3, tot_col_3)
+    fill 0, 255
+    stroke tot_col_2, tot_col_2, 255, charge_col * 255 + 3
+    ellipse @x1, @y1, @diameter, @diameter
+    @x0, @y0 = @x1, @y1
+  end
+  
+  def render_grabbed
+    fill 150, 150, 255, 100
+    ellipse mouse_x, mouse_y, @diameter + 8, @diameter + 8
+    fill 0, 255
+    stroke 150, 150, 255, 255
+    ellipse mouse_x, mouse_y, @diameter, @diameter
+    @x0, @y0 = mouse_x, mouse_y
+  end
+  
+  def angleOf(x1, y1, x2, y2)
+    xd, yd = x1 - x2, y1 - y2
+    180 + (-(180 * Math.atan2(yd, xd)) / PI)
+  end
+  
+end

data/samples/peasy_cam/data/java_args.txt

@@ -0,0 +1 @@
+-Xms256m -Xmx256m

data/samples/peasy_cam/hello_peasy.rb

@@ -0,0 +1,29 @@
+load_library 'PeasyCam'
+import 'peasy'
+
+attr_reader :cam
+
+def setup
+  size 200, 200, P3D
+  configure_camera
+end
+
+def configure_camera
+  @cam = PeasyCam.new(self, 100)
+  cam.set_minimum_distance 50
+  cam.set_maximum_distance 500
+end
+
+def draw
+  rotate_x -0.5
+  rotate_y -0.5
+  background 0
+  fill 255, 0, 0
+  box 30
+  push_matrix
+  translate 0, 0, 20
+  fill 0, 0, 255
+  box 5
+  pop_matrix
+end
+

data/samples/peasy_cam/hilbert_fractal.rb

@@ -0,0 +1,40 @@
+########################################################
+# A 3D Hilbert fractal implemented using a
+# Lindenmayer System in ruby-processing by Martin Prout
+# Best if you've got opengl
+########################################################
+
+class Hilbert_Test < Processing::App
+  full_screen # NB: All distances are relative to screen height
+  load_libraries 'hilbert', 'PeasyCam', 'opengl'
+  import 'peasy'
+  import "processing.opengl" if library_loaded? "opengl"
+  attr_reader :hilbert, :cam
+
+  def setup
+    library_loaded?(:opengl) ? configure_opengl : render_mode(P3D)
+    configure_peasycam
+    @hilbert = Hilbert.new(height)
+    hilbert.create_grammar 3
+    no_stroke
+  end
+
+  def configure_peasycam
+    cam = PeasyCam.new self, height / 6.5
+    cam.set_minimum_distance height / 10
+    cam.set_maximum_distance height
+  end
+
+  def configure_opengl
+    render_mode OPENGL
+    hint ENABLE_OPENGL_4X_SMOOTH     # optional
+    hint DISABLE_OPENGL_ERROR_REPORT # optional
+  end
+
+  def draw
+    background 0
+    lights
+    hilbert.render
+  end
+end
+

data/samples/peasy_cam/library/hilbert/hilbert.rb

@@ -0,0 +1,99 @@
+############################
+# Non-stochastic grammar
+# with unique premise/rules
+############################
+class Grammar
+  attr_accessor :axiom, :rules
+
+  def initialize axiom
+    @axiom = axiom
+    @rules = Hash.new
+  end
+
+  def add_rule premise, rule
+    rules.store(premise, rule)
+  end
+
+  ##########################################
+  # replace each pre char with a unique rule
+  ##########################################
+  def new_production production
+    production.gsub!(/./) { |c| (r = @rules[c]) ? r : c }
+  end
+
+  ##########################################
+  # control the number of iterations
+  # default 0, returns the axiom
+  ##########################################
+  def generate repeat = 0
+    prod = axiom
+    repeat.times do
+      prod = new_production prod
+    end
+    return prod
+  end
+end
+
+############################
+# Hilbert Curves
+###########################
+class Hilbert
+  include Processing::Proxy
+
+  attr_reader :grammar, :axiom, :production, :premis, :rule,
+  :theta, :scale_factor, :distance, :phi, :len
+
+  def initialize(len)
+    @axiom = "X"
+    @grammar = Grammar.new(axiom)
+    @production = axiom
+    @premis = "X"
+    @rule = "^<XF^<XFX-F^>>XFX&F+>>XFX-F>X->"
+    @len = len
+    @distance = len/12      # distance value relative to screen height
+    @theta = Math::PI/180 * 90
+    @phi = Math::PI/180 * 90
+    grammar.add_rule(premis, rule)
+    no_stroke()
+  end
+
+  def render()
+    translate(-len/42, len/42, -len/42)  # use the "answer?" to center the Hilbert
+    fill(0, 75, 152)
+    light_specular(204, 204, 204)
+    specular(255, 255, 255)
+    shininess(1.0)
+    production.scan(/./) do |ch|
+      case(ch)
+      when "F"
+        translate(0, distance/-2, 0)
+        box(distance/9 , distance, distance/9)
+        translate(0, distance/-2, 0)
+      when "+"
+        rotateX(-theta)
+      when "-"
+        rotateX(theta)
+      when ">"
+        rotateY(theta)
+      when "<"
+        rotateY(-theta)
+      when "&"
+        rotateZ(-phi)
+      when "^"
+        rotateZ(phi)
+      when "X"
+      else
+        puts("character '#{ch}' not in grammar")
+      end
+    end
+  end
+  ##############################
+  # create grammar from axiom and
+  # rules (adjust scale)
+  ##############################
+
+  def create_grammar(gen)
+    @distance *= 0.5**gen
+    @production = @grammar.generate gen
+  end
+end

data/samples/processing_app/3D/form/brick_tower.rb

@@ -77,9 +77,9 @@ class Cubeish
   
   def create
     @vertices.each do |name, vectors|
-      begin_shape App::QUADS
-      vectors.each {|v| vertex(v.x, v.y, v.z) }
-      end_shape
+      shape(App::QUADS) do
+        vectors.each {|v| vertex(v.x, v.y, v.z) }
+      end
     end
   end
   

data/samples/processing_app/basics/data/characters_strings/characters_strings.rb

@@ -64,18 +64,16 @@ class CharactersStrings < Processing::App
   def key_pressed
   	# The variable "key" always contains the value of the most recent key pressed.
 	  # If the key is an upper or lowercase letter between 'A' and 'z'
-	  # the image is shifted to the corresponding value of that key
-	  
-	  if (key >= "A"[0]) and (key <= "z"[0])  # should become "A".ord and "z".ord in Ruby 1.9
-		
+	  # the image is shifted to the corresponding value of that key	  
+	  if ('A'..'z').include? key
+	    
 		  # Map the index of the key pressed from the range between 'A' and 'z',
 		  # into a position for the left edge of the image. The maximum xoffset
 		  # is the width of the drawing area minus the size of the image.
-		  
-		  @xoffset = map( key, "A"[0], "z"[0], 0, width - @frog.width ).to_i
+		  @xoffset = map( key[0], "A"[0], "z"[0], 0, width - @frog.width ).to_i
 		  
 		  # Update the letter shown to the screen
-		  @letter = key.chr
+		  @letter = key
 		  
 		  # Write the letter to the console
 		  puts key

data/samples/processing_app/basics/form/triangle_strip.rb

@@ -23,19 +23,19 @@ class TriangleStrip < Processing::App
     number_of_points = 36
     rotation = 360.0/number_of_points
     
-    begin_shape TRIANGLE_STRIP
-    number_of_points.times do |i|
-      px = x + cos(angle.radians)*outer_radius
-		  py = y + sin(angle.radians)*outer_radius
-		  angle += rotation
-		  vertex px, py
+    shape(TRIANGLE_STRIP) do
+      number_of_points.times do |i|
+        px = x + cos(angle.radians)*outer_radius
+  		  py = y + sin(angle.radians)*outer_radius
+  		  angle += rotation
+  		  vertex px, py
 		  
-		  px = x + cos(angle.radians)*inner_radius
-		  py = y + sin(angle.radians)*inner_radius
-		  angle += rotation
-		  vertex px, py
+  		  px = x + cos(angle.radians)*inner_radius
+  		  py = y + sin(angle.radians)*inner_radius
+  		  angle += rotation
+  		  vertex px, py
+      end
     end
-    end_shape
   end
   
 end

data/samples/processing_app/basics/input/keyboard.rb

@@ -17,17 +17,11 @@ class Keyboard < Processing::App
   end
   
   def draw
-  	if key_pressed?
-  		if key >= ("A"[0]) && key <= ("z"[0])
-  			if key <= ("Z"[0])
-  				@key_index = key - ("A"[0])
-  			else
-  				@key_index = key - ("a"[0])
-  			end
+  	if key_pressed? && ('A'..'z').include?(key)
+  	  @key_index = key.ord - (key <= 'Z' ? 'A'.ord : 'a'.ord)
 			fill millis % 255
 			begin_rect = @rect_width/2 + @key_index * @key_scale - @rect_width/2
 			rect begin_rect, 0, @rect_width, height
-  		end
   	end
   end
   

data/samples/processing_app/basics/input/keyboard_2.rb

@@ -17,11 +17,11 @@ class Keyboard2 < Processing::App
   
   def draw
   	if key_pressed?
-  		if key.chr && key.chr >= "A" && key.chr <= "z"  # added testing 'gainst Nil
-  			if key.chr <= "Z"
-  				@key_index = key - "A".ord
+  		if ('A'..'z').include? key
+  			if key <= "Z"
+  				@key_index = key.ord - "A".ord
   			else
-  				@key_index = key - "a".ord
+  				@key_index = key.ord - "a".ord
   			end
 			fill millis % 255
 			begin_rect = @rect_width/2 + @key_index * @key_scale - @rect_width/2

data/samples/processing_app/basics/input/keyboard_functions.rb

@@ -28,14 +28,14 @@ class KeyboardFunctions < Processing::App
   def draw
   	if new_letter?
   		if upcase?
-  			fill (key - "A".ord).abs % 255
+  			fill (key.ord - "A".ord).abs % 255
   			rect @x, @y, @letter_width, @letter_height*2
   		else
   			# clear with letter space with background color
   			fill @num_chars/2
   			rect @x, @y, 			    @letter_width, @letter_height
   			
-  			fill (key - "a".ord).abs % 255
+  			fill (key.ord - "a".ord).abs % 255
   			rect @x, @y+@letter_height, @letter_width, @letter_height
   		end
   		@new_letter = false
@@ -51,26 +51,17 @@ class KeyboardFunctions < Processing::App
   end
   
   def key_pressed
-  	# Try to get a String for int value in "key"
-  	key_char = nil
-  	key_char = key.chr rescue nil
-  	
-  	# if the key is between 'A'(65) and 'z'(122)
-  	if key_char && key_char >= "A" && key_char <= "z"
-  		if key_char <= "Z"
-  			@upcase = true
-  		else
-  			@upcase = false
-  		end
+  	if ('A'..'z').include? key
+  		@upcase = key <= "Z"
+  		@new_letter = true
+  		
+  		# Update the "letter" position and 
+    	# wrap horizontally and vertically
+    	@y += (@letter_height*2) if @x + @letter_width >= width
+    	@y = @y % height
+    	@x += @letter_width
+    	@x = @x % width
   	end
-  	@new_letter = true
-  	
-  	# Update the "letter" position and 
-  	# wrap horizontally and vertically
-  	@y += (@letter_height*2) if @x + @letter_width >= width
-  	@y = @y % height
-  	@x += @letter_width
-  	@x = @x % width
   end
   
 end