ruby-processing 1.0.4 → 1.0.5

data/samples/learning_processing/chapter_14/15_rotating_many_things.rb

@@ -1,56 +0,0 @@
-require 'ruby-processing'
-
-# A Rotater class
-class Rotater
-
-  def initialize(x, y, speed, width)
-    @x, @y = x, y
-    # Angle is always initialized to 0
-    @theta = 0 
-    @speed = speed
-    @w = width
-  end
-
-  # Increment angle
-  def spin
-    @theta += @speed
-  end
-
-  # Display rectangle
-  def display
-    # push_matrix and pop_matrix are called inside the class' display method. 
-    # This way, every Rotater object is rendered with its own independent translation and rotation!
-    $app.push_matrix  
-    $app.translate @x, @y
-    $app.rotate @theta
-    $app.rect 0, 0, @w, @w
-    $app.pop_matrix 
-  end
-
-end
-
-class RotatingManyThingsSketch < Processing::App
-
-  def setup
-    rect_mode CENTER
-    stroke 0
-    fill 0, 100
-    @rotaters = Array.new(20) do
-      Rotater.new(rand(width), rand(height), random(-0.1, 0.1), rand(48))
-    end
-  end
-
-  def draw
-    background 255
-
-    # All Rotaters spin and are displayed
-    @rotaters.each do |r|
-      r.spin
-      r.display
-    end
-  end
-
-end
-
-RotatingManyThingsSketch.new :title => "Rotating Many Things", :width => 200, :height => 200
-

data/samples/learning_processing/chapter_14/16_simple_solar_system.rb

@@ -1,53 +0,0 @@
-require 'ruby-processing'
-
-class SimpleSolarSystemSketch < Processing::App
-
-  def setup
-    smooth
-    @theta = 0  # Angle of rotation around sun and planets
-  end
-
-  def draw
-    background 255
-    stroke 0
-
-    # Translate to center of window to draw the sun.
-    translate width/2, height/2
-    fill 255, 200, 50
-    ellipse 0, 0, 20, 20
-
-    # The earth rotates around the sun
-    push_matrix 
-    rotate @theta
-    translate 50, 0
-    fill 50, 200, 255
-    ellipse 0, 0, 10, 10
-
-    # Moon #1 rotates around the earth
-    # push_matrix is called to save the transformation state before drawing moon #1. 
-    # This way we can pop and return to earth before drawing moon #2. 
-    # Both moons rotate around the earth  which itself is rotating around the sun).
-    push_matrix  
-    rotate -@theta*4
-    translate 15, 0
-    fill 50, 255, 200
-    ellipse 0, 0, 6, 6
-    pop_matrix 
-
-    # Moon #2 also rotates around the earth
-    push_matrix 
-    rotate @theta*2
-    translate 25, 0
-    fill 50, 255, 200
-    ellipse 0, 0, 6, 6
-    pop_matrix 
-
-    pop_matrix 
-
-    @theta += 0.01;
-  end
-
-end
-
-SimpleSolarSystemSketch.new :title => "Simple Solar System", :width => 200, :height => 200
-

data/samples/learning_processing/chapter_14/17_nested_push_and_pop.rb

@@ -1,50 +0,0 @@
-require 'ruby-processing'
-
-class NestedPushAndPopSketch < Processing::App
-
-  def setup
-    smooth
-    @theta = 0  # angle for rotation
-  end
-
-  def draw
-    background 255
-    stroke 0
-
-    # Translate to center of window
-    translate width/2, height/2
-
-    # Loop from 0 to 360 degrees (2*PI radians)
-    0.step(TWO_PI, 0.2) do |i| 
-
-      # Push, rotate and draw a line!
-      # The transformation state is saved at the beginning of each cycle through the for loop and restored at the end. 
-      # Try commenting out these lines to see the difference!
-      push_matrix  
-      rotate @theta + i
-      line 0, 0, 100, 0
-
-      # Loop from 0 to 360 degrees (2*PI radians)
-      0.step(TWO_PI, 0.5) do |j| 
-        # Push, translate, rotate and draw a line!
-        push_matrix 
-        translate 100, 0
-        rotate -@theta - j
-        line 0, 0, 50, 0
-        # We're done with the inside loop,pop!
-        pop_matrix 
-      end
-
-      # We're done with the outside loop, pop!
-      pop_matrix 
-    end
-    end_shape 
-
-    # Increment @theta
-    @theta += 0.01
-  end
-
-end
-
-NestedPushAndPopSketch.new :title => "Nested Push and Pop", :width => 200, :height => 200
-

data/samples/learning_processing/chapter_14/18_object_oriented_solar_system.rb

@@ -1,69 +0,0 @@
-require 'ruby-processing'
-
-class Planet
-
-  # Each planet object keeps track of its own angle of rotation.
-  # @theta        Rotation around sun
-  # @diameter     Size of planet
-  # @distance     Distance from sun
-  # @orbit_speed  Orbit speed
-  def initialize(distance, diameter)
-    @distance = distance
-    @diameter = diameter
-    @theta = 0
-    @orbit_speed = rand * 0.02 + 0.01
-  end
-
-  def update
-    # Increment the angle to rotate
-    @theta += @orbit_speed
-  end
-
-  def display
-    # Before rotation and translation, the state of the matrix is saved with push_matrix.
-    $app.push_matrix 
-    # Rotate orbit
-    $app.rotate @theta 
-    # translate out @distance
-    $app.translate @distance, 0 
-    $app.stroke 0
-    $app.fill 175
-    $app.ellipse 0, 0, @diameter, @diameter
-    # Once the planet is drawn, the matrix is restored with pop_matrix so that the next planet is not affected.
-    $app.pop_matrix 
-  end
-
-end
-
-
-class ObjectOrientedSolarSystemSketch < Processing::App
-
-  def setup
-    smooth
-    @planets = Array.new(8) { |i| Planet.new(20+i*10, i+8) }
-  end
-
-  def draw
-    background 255
-
-    # Drawing the Sun
-    push_matrix
-    # Translate to center of window
-    translate width/2, height/2
-    stroke 0
-    fill 255
-    ellipse 0, 0, 20, 20
-
-    # Drawing all Planets
-    @planets.each do |p|
-      p.update
-      p.display
-    end
-
-    pop_matrix
-  end
-
-end
-
-  ObjectOrientedSolarSystemSketch.new :title => "Object Oriented Solar System", :width => 200, :height => 200
-

data/samples/learning_processing/chapter_15/01_hello_world_image.rb

@@ -1,20 +0,0 @@
-require 'ruby-processing'
-
-class HelloWorldImageSketch < Processing::App
-
-  def setup
-    # the image file must be in the data directory
-    @img = load_image("mysummervacation.jpg")
-  end
-
-  def draw
-    background 0
-
-    #The image function displays the image at a location-in this case the point (0,0).
-    image @img, 0, 0
-  end
-
-end
-
-HelloWorldImageSketch.new :title => "Hello World Image", :width => 320, :height => 240
-

data/samples/learning_processing/chapter_15/02_image_sprite.rb

@@ -1,29 +0,0 @@
-require 'ruby-processing'
-
-class ImageSpriteSketch < Processing::App
-
-  def setup
-    @head = load_image("face.jpg")  # variable for the image file
-    @x, @y = 0, width/2             # variables for image location
-    @rot = 0.0                      # variable for image rotation
-  end
-
-  def draw
-    background 255
-
-    translate @x, @y
-    rotate @rot
-
-    # Images can be animated just like regular shapes using variables, translate, rotate, and so on.
-    image @head, 0, 0
-    # Adjust variables for animation
-    @x += 1.0
-    @rot += 0.02
-    @x = -@head.width if @x > width + @head.width
-  end
-
-end
-
-ImageSpriteSketch.new :title => "Image Sprite", :width => 200, :height => 200
-
-

data/samples/learning_processing/chapter_15/03_swapping_images.rb

@@ -1,25 +0,0 @@
-require 'ruby-processing'
-
-class SwappingImagesSketch < Processing::App
-
-  def setup
-    @index = 0
-    @count = 7
-    # loading the images into the array
-    @images = (0...@count).map { |i| load_image("animal#{i}.jpg") }
-  end
-
-  def draw
-    # displaying one images
-    image @images[@index], 0, 0 
-  end
-
-  def mouse_pressed
-    # A new image is picked randomly when the mouse is clicked
-    @index = rand(@images.size)
-  end
-
-end
-
-SwappingImagesSketch.new :title => "Swapping Images", :width => 200, :height => 200
-

data/samples/learning_processing/chapter_15/04_image_sequence.rb

@@ -1,22 +0,0 @@
-require 'ruby-processing'
-
-class ImageSequence < Processing::App
-
-  def setup
-    @index = 0
-    @count = 7
-    # loading the images into the array
-    @images = (0...@count).map { |i| load_image("animal#{i}.jpg") }
-    frame_rate 5
-  end
-
-  def draw
-    # displaying one images
-    image @images[@index], 0, 0 
-    @index = (@index + 1) % @images.size
-  end
-
-end
-
-ImageSequence.new :title => "Image Sequence", :width => 200, :height => 200
-

data/samples/learning_processing/chapter_15/05_setting_pixels.rb

@@ -1,19 +0,0 @@
-require 'ruby-processing'
-
-class SettingPixelsSketch < Processing::App
-
-  def setup
-    # load the pixels array
-    load_pixels
-    background 0
-    # loop through the pixels and set each one to a random greyscale color
-    pixels.size.times { |i| pixels[i] = color(rand 255) }
-    # update the pixels on screen
-    update_pixels
-  end
-
-
-end
-
-SettingPixelsSketch.new :title => "Setting Pixels", :width => 200, :height => 200
-

data/samples/learning_processing/chapter_15/06_pixels_2d.rb

@@ -1,29 +0,0 @@
-require 'ruby-processing'
-
-class Pixels2dSketch < Processing::App
-
-  def setup
-    # load the pixels array
-    load_pixels
-    # Two loops allow us to visit every column (x) and every row (y).
-    # Loop through every pixel column
-    width.times do |x|
-      # Loop through every pixel row
-      height.times do |y|
-        # Use the formula to find the 1D location
-        # The location in the pixel array is calculated via our formula: 1D pixel location = x + y * width
-        loc = x + y * width
-        # We use the even-or-odd-ness of the column number (x) to determine whether the color should be black or white.
-        pixels[loc] = (x % 2 == 0) ? color(255) : color(0)
-      end
-    end
-    # update the pixels on screen
-    update_pixels
-  end
-
-
-end
-
-Pixels2dSketch.new :title => "Pixels 2d", :width => 200, :height => 200
-
-

data/samples/learning_processing/chapter_15/07_image_pixels.rb

@@ -1,40 +0,0 @@
-require 'ruby-processing'
-
-class ImagePixelsSketch < Processing::App
-
-  def setup
-    @image = load_image 'sunflower.jpg'
-  end
-
-  def draw
-    # load the pixels array
-    load_pixels
-    # Two loops allow us to visit every column (x) and every row (y).
-    # Loop through every pixel column
-    width.times do |x|
-      # Loop through every pixel row
-      height.times do |y|
-        # Use the formula to find the 1D location
-        loc = x + y * width # The location in the pixel array is calculated via our formula: 1D pixel location = x + y * width
-
-        # The functions red, green, and blue pull out the three color components from a pixel.
-        r = red(@image.pixels[loc]) 
-        g = green(@image.pixels[loc])
-        b = blue(@image.pixels[loc])
-
-        # Image Processing would go here
-        # If we were to change the RGB values, we would do it here, before setting the pixel in the display window.
-
-        # Set the display pixel to the image pixel
-        pixels[loc] = color(r,g,b)
-      end
-    end
-    # update the pixels on screen
-    update_pixels
-  end
-
-end
-
-ImagePixelsSketch.new :title => "Image Pixels", :width => 200, :height => 200
-
-

data/samples/learning_processing/chapter_15/08_image_brightness.rb

@@ -1,29 +0,0 @@
-require 'ruby-processing'
-
-class ImageBrightnessSketch < Processing::App
-
-  def setup
-    @image = load_image 'sunflower.jpg'
-    # Let's grab the red, green and blue component of each pixel of the image to start with.
-    @image_pixels = @image.pixels.map {|p| [red(p), green(p), blue(p)]}
-  end
-
-  def draw
-    # We calculate a multiplier ranging from 0.0 to 8.0 based on mouseX position. 
-    # That multiplier changes the RGB value of each pixel.      
-    adjustment = (mouse_x.to_f / width) * 8.0 
-    load_pixels # load the pixels array
-    
-    # And here's a modified Ruby way to do the Java equivalent
-    pixels.size.times do |i|
-      pixels[i] = color(*@image_pixels[i].map {|rgb| rgb * adjustment })
-    end
-    
-    update_pixels
-  end
-
-end
-
-ImageBrightnessSketch.new :title => "Image Brightness", :width => 200, :height => 200
-
-