ruby-processing 1.0.11 → 2.4.1

data/samples/contributed/re_sample.rb

@@ -0,0 +1,27 @@
+# Taken from processing discussion board, a little sketch by Amnon Owed
+# Illustrates use of offscreen image, texture sampling, mouse_pressed?,
+# load_pixels, displayWidth and displayHeight (do not snake case the last two)
+
+SCALE = 5  
+COLOR_RANGE = 16581375 # 255 * 255 * 255
+# full_screen # fill screen so no title bar
+
+attr_reader :grid
+ 
+def setup
+  size(displayWidth, displayHeight, P2D)
+  @grid = create_image(width/SCALE, height/SCALE, RGB)
+  g.texture_sampling(2)       # 2 = POINT mode sampling
+end
+ 
+def draw
+  unless mouse_pressed?
+    grid.load_pixels
+    grid.pixels.length.times do |i|
+      grid.pixels[i] = rand(COLOR_RANGE)
+    end
+    grid.update_pixels
+  end
+  image(grid, 0, 0, width, height)
+  frame.set_title("#{frame_rate.to_i}+ fps")
+end

data/samples/contributed/simple_buffer.rb

@@ -1,49 +1,44 @@
-require 'ruby-processing'
 
-class SimpleBuffer < Processing::App
-  def setup
-    
-    # With Processing, buffers allow you to draw off-screen to an image,
-    # and then use that image in your sketch. This can speed up rendering
-    # times quite a bit, as it's not only faster to draw off-screen, but
-    # it also allows you to redraw only portions of the screen.
-    
-    # Ruby-Processing provides a convenience method, "buffer", which
-    # sets up a buffer for you with the same width and height and 
-    # renderer as the current sketch, and yields it to you. It also
-    # takes care of calling begin_draw and end_draw at the start and 
-    # end of the block. Use it like so:
-    
-    @buffer = buffer do |b|
-      b.no_stroke
-      b.fill 255, 0, 0
-      b.rect 100, 200, 100, 100
-    end
-    
-    # Those lines are equivalent to the following lines:
-    
-    @buffer_2 = create_graphics(500, 500, P3D)
-    @buffer_2.begin_draw
-    @buffer_2.no_stroke
-    @buffer_2.fill(255, 0, 0)
-    @buffer_2.rect(100, 200, 100, 100)
-    @buffer_2.end_draw
-    
-    # If you'd like to set the size or renderer for the buffer block,
-    # just pass it in like normal:
-    
-    @buffer_3 = buffer(150, 150, P3D) do |b|
-      # b.whatever goes here.
-    end
-    
-    # And now we go ahead and grab the rendered image from the first buffer.
-    @img = @buffer.get(0, 0, @buffer.width, @buffer.height)
+def setup
+  
+  # With Processing, buffers allow you to draw off-screen to an image,
+  # and then use that image in your sketch. This can speed up rendering
+  # times quite a bit, as it's not only faster to draw off-screen, but
+  # it also allows you to redraw only portions of the screen.
+  
+  # Ruby-Processing provides a convenience method, "buffer", which
+  # sets up a buffer for you with the same width and height and 
+  # renderer as the current sketch, and yields it to you. It also
+  # takes care of calling begin_draw and end_draw at the start and 
+  # end of the block. Use it like so:
+  size 800, 800, P2D
+  @buffer = buffer do |b|
+    b.no_stroke
+    b.fill 255, 0, 0
+    b.rect 100, 200, 100, 100
   end
   
-  def draw
-    background 0
-    image @img, frame_count, 0
+  # Those lines are equivalent to the following lines:
+  
+  @buffer_2 = create_graphics(500, 500, P2D)
+  @buffer_2.begin_draw
+  @buffer_2.no_stroke
+  @buffer_2.fill(255, 0, 0)
+  @buffer_2.rect(100, 200, 100, 100)
+  @buffer_2.end_draw
+  
+  # If you'd like to set the size or renderer for the buffer block,
+  # just pass it in like normal:
+  
+  @buffer_3 = buffer(150, 150, P2D) do |b|
+    # b.whatever goes here.
   end
+  
+  # And now we go ahead and grab the rendered image from the first buffer.
+  @img = @buffer.get(0, 0, @buffer.width, @buffer.height)
 end
 
-SimpleBuffer.new :title => "Simple Buffer", :width => 500, :height => 500
+def draw
+  background 0
+  image @img, frame_count, 0
+end

data/samples/contributed/tree.rb

@@ -1,83 +1,76 @@
 # http://processing.org/learning/topics/tree.html
 # by Joe Holt
 
-require 'ruby-processing'
+def setup
+  size 200, 200
+  color_mode RGB, 1
+  frame_rate 30
+  smooth
+  @x = 0.0
+  @dx = width / 100
+  @start_time = Time.now
+  @frame_time = nil
+end
 
-class Sketch < Processing::App
-  
-  def setup
-    color_mode RGB, 1
-    frameRate 30
-    smooth
-    @x = 0.0
-    @dx = width / 100
-    @start_time = Time.now
-    @frame_time = nil
-  end
+def radians(x)
+  return x * (Math::PI / 180)
+end
 
-  def radians(x)
-      return x * (Math::PI / 180)
+def draw
+  t = Time.now
+  if @frame_time
+    fps = 1.0 / (t - @frame_time)
+    # printf "%0.1f fps\n", fps    
   end
+  @frame_time = t
   
-  def draw
-    t = Time.now
-    if @frame_time
-      fps = 1.0 / (t - @frame_time)
-#     printf "%0.1ffps\n", fps
-    end
-    @frame_time = t
-
-    background 0
-    stroke 1, 1, 1
-    # Let's pick an angle 0 to 90 degrees based on the mouse position
-    a = (@x / width) * 90
-    # Convert it to radians
-    @theta = radians(a)
-    # Start the tree from the bottom of the screen
-    translate(width/2,height)
-    # Draw a line 60 pixels
-    h = height / 3
-    line(0,0,0,-h)
-    # Move to the end of that line
-    translate(0,-h)
-    # Start the recursive branching!
-    branch(h)
-
-    @x += @dx
-    if @x < 0
-        puts "Time after this iteration: " + (Time.now - @start_time).to_s
-    end
-    if @x > width || @x < 0
-        @dx = - @dx
-        @x += @dx * 2
-    end
+  background 0
+  stroke 1, 1, 1
+  # Let's pick an angle 0 to 90 degrees based on the mouse position
+  a = (@x / width) * 90
+  # Convert it to radians
+  @theta = radians(a)
+  # Start the tree from the bottom of the screen
+  translate(width / 2, height)
+  # Draw a line 60 pixels
+  h = height / 3
+  line(0, 0, 0,  -h)
+  # Move to the end of that line
+  translate(0,-h)
+  # Start the recursive branching!
+  branch(h)
+  
+  @x += @dx
+  if @x < 0
+    puts "Time after this iteration: " + (Time.now - @start_time).to_s
   end
-
-  def branch(h)
-    # Each branch will be 2/3rds the size of the previous one
-    h *= 0.66;
-
-    # All recursive functions must have an exit condition!!!!
-    # Here, ours is when the length of the branch is 2 pixels or less
-    if h > 2
-      pushMatrix       # Save the current state of transformation (i.e. where are we now)
-      rotate(@theta)   # Rotate by theta
-      line(0,0,0,-h)   # Draw the branch
-      translate(0,-h)  # Move to the end of the branch
-      branch(h)        # Ok, now call myself to draw two new branches!!
-      popMatrix        # Whenever we get back here, we "pop" in order to restore the previous matrix state
-
-      # Repeat the same thing, only branch off to the "left" this time!
-      pushMatrix
-      rotate(- @theta)
-      line(0,0,0,-h)
-      translate(0,-h)
-      branch(h)
-      popMatrix
-    end
+  if @x > width || @x < 0
+    @dx = - @dx
+    @x += @dx * 2
   end
+end
 
+def branch(h)
+  # Each branch will be 2/3rds the size of the previous one
+  h *= 0.66  
+  # All recursive functions must have an exit condition!!!!
+  # Here, ours is when the length of the branch is 2 pixels or less
+  if h > 2
+    push_matrix       # Save the current state of transformation (i.e. where are we now)
+    rotate(@theta)   # Rotate by theta
+    line(0, 0, 0, -h)   # Draw the branch
+    translate(0, -h)  # Move to the end of the branch
+    branch(h)        # Ok, now call myself to draw two new branches!!
+    pop_matrix        # Whenever we get back here, we "pop" in order to restore the previous matrix state
+    
+    # Repeat the same thing, only branch off to the "left" this time!
+    push_matrix
+    rotate(- @theta)
+    line(0, 0, 0, -h)
+    translate(0, -h)
+    branch(h)
+    pop_matrix
+  end
 end
 
 
-Sketch.new(:width => 200, :height => 200, :title => "Auto Tree")

data/samples/external_library/java_processing/README

@@ -0,0 +1,3 @@
+Sketches in this folder demonstrate the use of contributed java libraries in ruby-processing the easiest thing is if the library is installed in your regular processing sketchbook/libraries folder.
+To run the generativedesign sketches, you should have installed the generativedesign library either download from the processing ide or direct from:- http://www.generative-gestaltung.de/codes/generativedesign/index.html A library by Hartmut Bohnacker, Benedikt Groß. A library by Hartmut Bohnacker, Benedikt Groß. Goes with the book "Generative Gestaltung" http://www.generative-gestaltung.de/
+To run the gray_scott examples you should install the toxiclibs collection by Karsten Schmidt aka toxi. For the other examples toxiclibscore volumeutils etc.  To run the hemesh library samples you need the hemesh library version 1.8.1 (downloable via processing ide, as is the geomerative library). 

data/samples/external_library/java_processing/fisica/README

@@ -0,0 +1 @@
+For some reason several methods in the fisica ar not recongized when ruby-processing is run using the included jruby-complete.  However at least on my linux box these examples run OK using an external jruby (version 1.7.3).

data/samples/external_library/java_processing/fisica/bubbles.rb

@@ -0,0 +1,80 @@
+#
+#  Buttons and bodies
+#  by Ricard Marxer
+#  This example shows how to create a blob.
+#
+#  set_fill and set_stroke methods are missing
+#  when run using builtin jruby-complete yet work
+#  OK when using an external jruby
+#
+load_library :fisica
+include_package 'fisica'
+
+CIRCLE_COUNT = 20
+HOLE = 50
+TOP_MARGIN = 50
+BOTTOM_MARGIN = 300
+SIDE_MARGIN = 100
+
+
+attr_reader :world, :x_pos
+
+def setup
+  size(400, 400)
+  smooth
+  @x_pos = 0
+  Fisica.init(self)  
+  @world = FWorld.new
+  world.setGravity(0, -300)
+  l = FPoly.new
+  l.vertex(width/2-HOLE/2, 0)
+  l.vertex(0, 0)
+  l.vertex(0, height)
+  l.vertex(0 + SIDE_MARGIN, height)
+  l.vertex(0 + SIDE_MARGIN, height-BOTTOM_MARGIN)
+  l.vertex(width/2-HOLE/2, TOP_MARGIN)
+  l.set_static(true)  
+  l.set_fill(0)
+  l.set_friction(0)
+  world.add(l)
+  
+  r = FPoly.new
+  r.vertex(width/2 + HOLE/2, 0)
+  r.vertex(width, 0)
+  r.vertex(width, height)
+  r.vertex(width-SIDE_MARGIN, height)
+  r.vertex(width-SIDE_MARGIN, height-BOTTOM_MARGIN)
+  r.vertex(width/2 + HOLE/2, TOP_MARGIN)
+  r.set_static(true)
+  r.set_fill(0)
+  r.set_friction(0)
+  world.add(r)
+end
+
+def draw
+  background(80, 120, 200)
+  fill(0)
+  if ((frame_count % 40) == 1)
+    b = FBlob.new
+    s = rand(30 .. 40)
+    space = (width - SIDE_MARGIN * 2-s)
+    @x_pos = (x_pos + rand(s .. space/2.0)) % space
+    b.set_as_circle(SIDE_MARGIN + x_pos + s / 2, height - rand(100), s, 20)
+    b.set_stroke(0)
+    b.set_stroke_weight(2)
+    b.set_fill(255)
+    b.set_friction(0)
+    world.add(b)
+  end
+  
+  world.step
+  world.draw
+end
+
+
+def key_pressed
+  save_frame("screenshot.png")
+end
+
+
+

data/samples/external_library/java_processing/fisica/joints.rb

@@ -0,0 +1,112 @@
+#
+#  Joints#
+#  by Ricard Marxer#
+#  This example shows how to access all the joints of a given body.
+#
+# converted to ruby-processing by Martin Prout
+#
+
+load_library :fisica
+module Fis
+  java_import 'fisica.Fisica'
+  java_import 'fisica.FWorld'
+  java_import 'fisica.FCircle'
+  java_import 'fisica.FDistanceJoint'
+  java_import 'fisica.FJoint'
+end
+
+SPIDER_COUNT = 10
+MAIN_SIZE = 40
+LEG_COUNT = 10
+LEG_SIZE = 100
+
+attr_reader :world, :mains, :body_color, :hover_color
+
+def setup
+  size(400, 400)
+  @body_color = color('#6E0595')
+  @hover_color = color('#F5B502')
+  smooth
+  @mains = []
+  Fis::Fisica.init(self)  
+  @world = Fis::FWorld.new
+  world.set_edges
+  world.set_gravity(0, 0)
+  
+  SPIDER_COUNT.times do 
+    create_spider
+  end
+end
+
+def draw
+  background(255)
+  world.step
+  world.draw
+end
+
+def mouse_moved
+  hovered = world.get_body(mouse_x, mouse_y)  
+  mains.each do |other|    
+    if (hovered == other)
+      set_joints_drawable(other, true)
+      set_joints_color(other, hover_color)      
+    else
+      set_joints_drawable(other, false)
+      set_joints_color(other, body_color)
+    end
+  end
+end
+
+def key_pressed  
+  save_frame("screenshot.png")  
+end
+
+def create_spider
+  pos_x = rand(MAIN_SIZE/2 .. width-MAIN_SIZE/2)
+  pos_y = rand(MAIN_SIZE/2 .. height-MAIN_SIZE/2)  
+  main = Fis::FCircle.new(MAIN_SIZE)
+  main.set_position(pos_x, pos_y)
+  main.set_velocity(rand(-20 .. 20), rand(-20 .. 20))
+  main.set_fill_color(body_color)
+  main.set_no_stroke
+  main.set_group_index(2)
+  world.add(main)  
+  mains << main
+  
+  (0 ... LEG_COUNT).each do |i|
+    x = LEG_SIZE * cos(i * TAU/3) + pos_x
+    y = LEG_SIZE * sin(i * TAU/3) + pos_y    
+    leg = Fis::FCircle.new(MAIN_SIZE/2)
+    leg.set_position(pos_x, pos_y)
+    leg.set_velocity(rand(-20 .. 20), rand(-20 ..20))
+    leg.set_fill_color(body_color)
+    leg.set_no_stroke
+    world.add(leg)    
+    j = Fis::FDistanceJoint.new(main, leg)
+    j.set_length(LEG_SIZE)
+    j.set_no_stroke
+    j.set_stroke(0)
+    j.set_fill(0)
+    j.set_drawable(false)
+    j.set_frequency(0.1)
+    world.add(j)
+  end
+end
+
+def set_joints_color(b, c)
+  l = b.get_joints  
+  l.each do |j|
+    j.set_stroke_color(c)
+    j.set_fill_color(c)
+    j.get_body1.set_fill_color(c)
+    j.get_body2.set_fill_color(c)
+  end
+end
+
+def set_joints_drawable(b, c)
+  l = b.get_joints  
+  l.each do |j|
+    j.set_drawable(c)
+  end
+end
+