ruby-processing 2.6.3 → 2.6.4

data/samples/contributed/mandelbrot.rb

@@ -1,79 +0,0 @@
-# Mandelbrot Set example
-# by Jordan Scales (http://jordanscales.com)
-# Modified to use map1d (instead of map), and somewhat 
-# optimized (update_pixels instead of set, and hypot for abs)
-# default size 900x600
-# no need to loop
-
-def setup
-  size 900, 600
-  load_pixels
-  no_loop
-end
-
-# main drawing method
-def draw
-  (0...900).each do |x|
-    (0...600).each do |y|
-      c = Complex.new(map1d(x, (0...900), (-3..1.5)), map1d(y, (0...600), (-1.5..1.5)))  
-      # mandel will return 0 to 20 (20 is strong)
-      #   map this to 0, 255 (and flip it)
-      pixels[x + y * 900] = color(255 - map1d(mandel(c, 20), (0..20), (0..255)).to_i)
-    end
-  end
-  update_pixels
-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
-    hypot(real, imag)
-  end
-
-  def to_s
-    "#{real} + #{imag}i"
-  end
-end

data/samples/contributed/orbit.rb

@@ -1,41 +0,0 @@
-# Ported from http://nodebox.net/code/index.php/Graphics_State
-
-# 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
-  @d_font = create_font('Helvetica', 40)
-end
-
-def draw
-  background 255
-  translate 225, 225
-
-  text_font d_font
-  ellipse 0, 0, 10, 10
-  text 'sun', 10, 0
-
-  3.times do |i|
-    push_matrix
-
-    rotate frame_count / -180.0 * PI + i * PI / -1.5
-    line 0, 0, 120, 0
-
-    translate 120, 0
-    ellipse 0, 0, 10, 10
-    text_font d_font, 22
-    text 'planet', 10, 0
-
-    rotate frame_count / -30.0 * PI 
-    line 0, 0, 30, 0
-    text_font d_font, 15
-    text 'moon', 32, 0
-
-    pop_matrix
-  end
-end

data/samples/contributed/quadraticvertex.rb

@@ -1,106 +0,0 @@
-# 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, :hide
-
-def setup
-  size 450, 320
-  @hide = false
-  control_panel do |c|
-    c.title = "controller"
-    c.menu(:detail, %w(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
-  if (!hide)
-    panel.set_visible true
-    @hide = true
-  end
-  background color('#BDF018')
-  translate width / 2, height / 2
-  @step_angle = TAU / (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 mouse_pressed
-  @hide = false
-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

data/samples/contributed/re_sample.rb

@@ -1,27 +0,0 @@
-# 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/reflection.rb

@@ -1,17 +0,0 @@
-# Taken from the Processing Examples.
-  
-def setup
-  size 200, 200, P3D
-  no_stroke
-  color_mode RGB, 1
-  fill 0.4
-end
-
-def draw
-  background          0
-  translate           width/2, height/2 
-  light_specular      1, 1, 1
-  directional_light   0.8, 0.8, 0.8, 0, 0, -1
-  specular            mouse_x.to_f / width.to_f
-  sphere              50
-end

data/samples/contributed/tree.rb

@@ -1,72 +0,0 @@
-# http://processing.org/learning/topics/tree.html
-# by Joe Holt
-
-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
-
-def draw
-  t = Time.now
-  if @frame_time
-    fps = 1.0 / (t - @frame_time)
-    # printf "%0.1f fps\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 = a.radians
-  # 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
-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
-
-

data/samples/external_library/java_processing/README

@@ -1,3 +0,0 @@
-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/box2d_processing/bumpy_surface_noise.rb

@@ -1,52 +0,0 @@
-# The Nature of Code
-# <http://www.shiffman.net/teaching/nature>
-# Spring 2010
-# PBox2D example
-
-# An uneven surface
-
-load_libraries :box2d_processing, :surface
-
-include SB
-
-attr_reader :surface, :box2d, :particles
-
-def setup
-  size(500,300)
-  smooth
-  
-  # Initialize box2d physics and create the world
-  @box2d = SB::Box2DProcessing.new(self)
-  box2d.create_world
-  # We are setting a custom gravity
-  box2d.set_gravity(0, -20)
-  
-  # Create the empty list
-  @particles = []
-  # Create the surface
-  @surface = Surface.new(box2d)
-end
-
-def draw
-  # If the mouse is pressed, we make new particles
-  
-  
-  # We must always step through time!
-  box2d.step
-  
-  background(138, 66, 54)  
-  # Draw the surface
-  surface.display
-  # NB question mark is reqd to call mouse_pressed value, else method gets called.
-  particles << Particle.new(box2d, mouse_x, mouse_y, rand(2.0..6)) if mouse_pressed?    
-  # Draw all particles
-  particles.each do |p|
-    p.display
-  end  
-  # Particles that leave the screen, we delete them
-  # (note they have to be deleted from both the box2d world and our list
-  particles.reject! {|p| p.done}
-  # Just drawing the framerate to see how many particles it can handle
-  fill(0)
-  text("framerate: #{frame_rate.to_i}", 12, 16)
-end

data/samples/external_library/java_processing/box2d_processing/data/java_args.txt

@@ -1,2 +0,0 @@
--XX:CompileCommand=dontinline,org.jruby.runtime.invokedynamic.InvokeDynamicSupport::invocationFallback 
-

data/samples/external_library/java_processing/box2d_processing/library/custom_shape/custom_shape.rb

@@ -1,158 +0,0 @@
-module B2D
-  include_package 'pbox2d'
-  include_package 'org.jbox2d.collision.shapes'
-  include_package 'org.jbox2d.common'
-  include_package 'org.jbox2d.dynamics'
-  include_package 'shiffman.box2d'
-  
-  
-  # The Nature of Code
-  # <http://www.shiffman.net/teaching/nature>
-  # Spring 2011
-  # PBox2D example
-  # A rectangular box
-  
-  class CustomShape
-
-    # We need to keep track of a Body and a width and height
-    attr_reader :body, :box2d
-    
-    # Constructor
-    def initialize(b2d, x, y)
-      # Add the box to the box2d world
-      @box2d = b2d  
-      make_body(B2D::Vec2.new(x, y))          
-    end
-    
-    # This function removes the particle from the box2d world
-    def kill_body!
-      box2d.destroy_body(body)
-    end
-    
-    # Is the particle ready for deletion?
-    def done
-      # Let's find the screen position of the particle
-      pos = box2d.get_body_pixel_coord(body)
-      # Is it off the bottom of the screen?
-      if (pos.y > $app.height)
-        kill_body!
-        return true
-      end
-      return false
-    end
-    
-    # Drawing the box
-    def display
-      # We look at each body and get its screen position
-      pos = box2d.get_body_pixel_coord(body)
-      # Get its angle of rotation
-      a = body.get_angle
-      
-      f = body.get_fixture_list
-      ps = f.get_shape
-      
-      
-      rect_mode(CENTER)
-      push_matrix
-      translate(pos.x, pos.y)
-      rotate(-a)
-      fill(175)
-      stroke(0)
-      begin_shape
-        # For every vertex, convert to pixel vector
-        ps.get_vertex_count.times do |i|
-          v = box2d.vector_world_to_pixels(ps.get_vertex(i))
-          vertex(v.x, v.y)
-        end
-      end_shape(CLOSE)
-      pop_matrix
-    end
-    
-    # This function adds the rectangle to the box2d world
-    def make_body(center)
-      
-      # Define a polygon (this is what we use for a rectangle)
-      sd = B2D::PolygonShape.new
-      
-      vertices = []
-      vertices << box2d.vector_pixels_to_world(B2D::Vec2.new(-15, 25))
-      vertices << box2d.vector_pixels_to_world(B2D::Vec2.new(15, 0))
-      vertices << box2d.vector_pixels_to_world(B2D::Vec2.new(20, -15))
-      vertices << box2d.vector_pixels_to_world(B2D::Vec2.new(-10, -10))
-      sd.set(vertices.to_java(Java::OrgJbox2dCommon::Vec2), vertices.length)
-      
-      # Define the body and make it from the shape
-      bd = B2D::BodyDef.new
-      bd.type = B2D::BodyType::DYNAMIC
-      bd.position.set(box2d.coord_pixels_to_world(center))
-      @body = box2d.create_body(bd)
-      
-      body.create_fixture(sd, 1.0)
-      
-      
-      # Give it some initial random velocity
-      body.set_linear_velocity(Vec2.new(rand(-5..5), rand(2..5)))
-      body.set_angular_velocity(rand(-5..5))
-    end
-  end
-  
-  # The Nature of Code
-  # <http://www.shiffman.net/teaching/nature>
-  # Spring 2012
-  # PBox2D example
-  
-  # A fixed boundary class (now incorporates angle)
-  
-  
-  
-  class Boundary
-    
-    attr_reader :box2d, :b, :x, :y, :w, :h #, :a
-    
-    def initialize(b2d, x, y, w, h, a)
-      @box2d = b2d
-      @x = x
-      @y = y
-      @w = w
-      @h = h
-
-      # Define the polygon
-      sd = B2D::PolygonShape.new
-
-      # Figure out the box2d coordinates
-      box2dW = box2d.scalar_pixels_to_world(w/2)
-      box2dH = box2d.scalar_pixels_to_world(h/2)
-      # We're just a box
-      sd.set_as_box(box2dW, box2dH)
-      
-      
-      # Create the body
-      bd = B2D::BodyDef.new
-      bd.type = B2D::BodyType::STATIC
-      bd.angle = a
-      bd.position.set(box2d.coord_pixels_to_world(x,y))
-      @b = box2d.create_body(bd)
-      
-      # Attached the shape to the body using a Fixture
-      b.create_fixture(sd,1)
-    end
-    
-    # Draw the boundary, it doesn't move so we don't have to ask the Body for location
-    def display
-      fill(0)
-      stroke(0)
-      stroke_weight(1)
-      rect_mode(CENTER)
-      a = b.get_angle
-      push_matrix
-      translate(x,y)
-      rotate(-a)
-      rect(0,0,w,h)
-      pop_matrix
-    end
-    
-  end
-end
-  
-  
-