ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/topics/create_shapes/library/particle/particle_system.rb

@@ -0,0 +1,107 @@
+# The Particle System
+
+class ParticleSystem 
+  include Processing::Proxy
+
+  attr_reader :particles, :particle_shape#, :width, :height, :sprite
+
+  def initialize(width, height, sprite, n) 
+    #width, height, sprite = width, height, sprite
+    @particles = []
+    # The PShape is a group
+    @particle_shape = create_shape(GROUP)
+
+    # Make all the Particles
+    n.times do |i|       
+      particles << Particle.new(width, height, sprite)
+      # Each particle's PShape gets added to the System PShape
+      particle_shape.add_child(particles[i].s_shape)
+    end
+  end
+
+  def update
+    particles.each do |p|
+      p.update
+    end
+  end
+
+  def set_emitter(x, y) 
+    particles.each do |p|
+      # Each particle gets reborn at the emitter location     
+      p.rebirth(x, y) if (p.dead?) 
+    end
+  end
+
+  def display
+    shape(particle_shape)
+  end
+end
+
+# An individual Particle
+
+class Particle
+  include Processing::Proxy
+  
+  GRAVITY = PVector.new(0, 0.1) 
+  
+  attr_reader :center, :velocity, :lifespan, :s_shape, :part_size, 
+  :width, :height, :sprite
+ 
+
+  def initialize width, height, sprite
+    @width, @height, @sprite = width, height, sprite
+    part_size = rand(10 .. 60)
+    # The particle is a textured quad
+    @s_shape = create_shape
+    s_shape.begin_shape(QUAD)
+    s_shape.no_stroke
+    s_shape.texture(sprite)
+    s_shape.normal(0, 0, 1)
+    s_shape.vertex(-part_size/2, -part_size/2, 0, 0)
+    s_shape.vertex(+part_size/2, -part_size/2, sprite.width, 0)
+    s_shape.vertex(+part_size/2, +part_size/2, sprite.width, sprite.height)
+    s_shape.vertex(-part_size/2, +part_size/2, 0, sprite.height)
+    s_shape.end_shape
+
+    # Initialize center vector
+    @center = PVector.new 
+    
+    # Set the particle starting location
+    rebirth(width/2, height/2)
+  end
+
+  def rebirth(x, y)
+    theta = rand(-PI .. PI)
+    speed = rand(0.5 .. 4)
+    # A velocity with random angle and magnitude
+    @velocity = PVector.from_angle(theta)
+    @velocity.mult(speed)
+    # Set lifespan
+    @lifespan = 255
+    # Set location using translate
+    s_shape.reset_matrix
+    s_shape.translate(x, y) 
+    
+    # Update center vector
+    @center.set(x, y, 0)
+  end
+
+  # Is it off the screen, or its lifespan is over?
+  def dead?
+    (center.x > width  || center.x < 0 || 
+        center.y > height || center.y < 0 || lifespan < 0)
+  end
+
+  def update
+    # Decrease life
+    @lifespan = lifespan - 1
+    # Apply gravity
+    velocity.add(GRAVITY)
+    s_shape.setTint(color(255, lifespan))
+    # Move the particle according to its velocity
+    s_shape.translate(velocity.x, velocity.y)
+    # and also update the center
+    center.add(velocity)
+  end
+end
+

data/samples/processing_app/topics/create_shapes/library/polygon/polygon.rb

@@ -0,0 +1,35 @@
+# A class to describe a Polygon (with a PShape)
+
+class Polygon
+  include Processing::Proxy
+  # The PShape object
+  attr_reader :s, :x, :y, :speed, :height
+
+  def initialize(s_, width, height)
+    @x = rand(width)
+    @y = rand(-500 .. -100)
+    @s = s_
+    @speed = rand(2 .. 6)
+    @height = height
+  end
+  
+  # Simple motion
+  def move
+    @y +=speed
+    @y = -100 if (y > height + 100)
+  end
+  
+  # Draw the object
+  def display
+    push_matrix
+    translate(x, y)
+    shape(s)
+    pop_matrix
+  end
+  
+  def run
+    display
+    move
+  end
+end
+

data/samples/processing_app/topics/create_shapes/library/star/star.rb

@@ -0,0 +1,47 @@
+# A class to describe a Star shape
+
+class Star 
+  include Processing::Proxy
+  attr_reader :s, :x, :y, :speed, :width, :height
+  def initialize(width, height)
+    @width = width
+    @height = height
+    @x = rand(100 .. width-100)
+    @y = rand(100 .. height-100) 
+    @speed = rand(0.5 .. 3)
+    # First create the shape
+    @s = createShape
+    s.beginShape
+    # You can set fill and stroke
+    s.fill(255, 204)
+    s.noStroke
+    # Here, we are hardcoding a series of vertices
+    s.vertex(0, -50)
+    s.vertex(14, -20)
+    s.vertex(47, -15)
+    s.vertex(23, 7)
+    s.vertex(29, 40)
+    s.vertex(0, 25)
+    s.vertex(-29, 40)
+    s.vertex(-23, 7)
+    s.vertex(-47, -15)
+    s.vertex(-14, -20)
+    # The shape is complete
+    s.endShape(CLOSE)
+  end
+
+  def move
+    # Demonstrating some simple motion
+    @x += speed
+    @x = -100 if (x > width+100) 
+  end
+
+  def display
+    # Locating and drawing the shape
+    pushMatrix
+    translate(x, y)
+    shape(s)
+    popMatrix
+  end
+end
+

data/samples/processing_app/topics/create_shapes/library/wiggler/wiggler.rb

@@ -0,0 +1,57 @@
+# An object that wraps the PShape
+
+class Wiggler
+  include Processing::Proxy
+  attr_reader :original, :x, :y, :s, :yoff, :xoff
+
+  def initialize width, height
+    @x = width/2
+    @y = height/2 
+    @yoff = 0
+    # The "original" locations of the vertices make up a circle
+    @original = []
+    (0 ... TWO_PI).step(0.2) do |a|
+      v = PVector.from_angle(a)
+      v.mult(100)
+      original << v
+    end
+    
+    # Now make the PShape with those vertices
+    @s = create_shape
+    s.begin_shape
+    s.fill(127)
+    s.stroke(0)
+    s.stroke_weight(2)
+    original.each do |v|
+      s.vertex(v.x, v.y)
+    end
+    s.end_shape(CLOSE)
+  end
+
+  def wiggle
+    @xoff = 0
+    # Apply an offset to each vertex
+    (0 ... s.get_vertex_count).each do |i|
+      # Calculate a new vertex location based on noise around "original" location
+      pos = original[i]
+      a = TWO_PI*noise(xoff,yoff)
+      r = PVector.from_angle(a)
+      r.mult(4)
+      r.add(pos)
+      # Set the location of each vertex to the new one
+      s.set_vertex(i, r.x, r.y)
+      # increment perlin noise x value
+      @xoff += 0.5
+    end
+    # Increment perlin noise y value
+    @yoff += 0.02
+  end
+
+  def display
+    push_matrix
+    translate(x, y)
+    shape(s)
+    pop_matrix
+  end
+end
+

data/samples/processing_app/topics/create_shapes/particle_system_pshape.rb

@@ -0,0 +1,38 @@
+#
+# ParticleSystemPShape
+# A particle system optimized for drawing using PShape
+# For guts of implementation see 'particle' library
+#
+
+load_library 'particle'
+
+# Particle System object and image
+attr_reader :ps 
+
+def setup
+  size(640, 360, P2D)
+  # Load the image
+  sprite = loadImage("sprite.png")
+  # A new particle system with 10,000 particles
+  @ps = ParticleSystem.new(width, height, sprite, 10000)
+  # Writing to the depth buffer is disabled to avoid rendering
+  # artifacts due to the fact that the particles are semi-transparent
+  # but not z-sorted.
+  hint(DISABLE_DEPTH_MASK)
+end 
+
+def draw 
+  background(0)
+  # Update and display system
+  ps.update
+  ps.display
+  # Set the particle system's emitter location to the mouse
+  ps.set_emitter(mouse_x, mouse_y)
+  
+  # Display frame rate
+  fill(255, 0, 255)
+  text_size(16)
+  text("Frame rate: #{frame_rate.round(1)}", 10, 20)
+  
+end
+

data/samples/processing_app/topics/create_shapes/path_pshape.rb

@@ -0,0 +1,38 @@
+#
+# PathPShape
+# 
+# A simple path using PShape
+#
+
+# A PShape object
+attr_reader :path
+
+def setup
+  size(640, 360, P2D)
+  smooth
+  # Create the shape
+  @path = create_shape
+  path.begin_shape
+  # Set fill and stroke
+  path.noFill
+  path.stroke(255)
+  path.stroke_weight(2)
+  
+  x = 0
+  # Calculate the path as a sine wave
+  (0 .. TWO_PI).step(0.1) do |theta|
+    path.vertex(x,sin(theta)*100)
+    x += 5
+  end
+  # The path is complete
+  path.end_shape  
+
+end
+
+def draw
+  background(51)
+  # Draw the path at the mouse location
+  translate(mouse_x, mouse_y)
+  shape(path)
+end
+

data/samples/processing_app/topics/create_shapes/polygon_pshape_oo3.rb

@@ -0,0 +1,56 @@
+#
+# PolygonPShapeOOP. 
+# 
+# Wrapping a PShape inside a custom class 
+# and demonstrating how we can have a multiple objects each
+# using the same PShape.
+#
+load_library :polygon
+
+# A list of objects
+attr_reader :polygons
+
+def setup
+  size(640, 360, P2D)
+  shapes = []
+  shape = create_shape(ELLIPSE, 0, 0, 100, 100) # circle
+  shape.set_fill(color(255, 127))
+  shape.set_stroke(false)
+  shapes << shape                               # square
+  shape = create_shape(RECT, 0, 0, 100, 100)
+  shape.set_fill(color(255, 127))
+  shape.set_stroke(false)
+  shapes << shape
+  shape = create_shape  
+  shape.begin_shape                             # star
+  shape.fill(0, 127)
+  shape.no_stroke()
+  shape.vertex(0, -50)
+  shape.vertex(14, -20)
+  shape.vertex(47, -15)
+  shape.vertex(23, 7)
+  shape.vertex(29, 40)
+  shape.vertex(0, 25)
+  shape.vertex(-29, 40)
+  shape.vertex(-23, 7)
+  shape.vertex(-47, -15)
+  shape.vertex(-14, -20)
+  shape.end_shape(CLOSE)
+  shapes << shape
+  # Create an Array of polygons see polygon library
+  @polygons = []
+  
+  25.times do
+    polygons << Polygon.new(shapes.sample, width, height)  
+  end
+end
+
+def draw
+  background(102)
+
+  # Display and move them all
+  polygons.each do |poly|
+    poly.run
+  end
+end
+

data/samples/processing_app/topics/create_shapes/polygon_pshape_oop.rb

@@ -0,0 +1,29 @@
+#
+# PolygonPShapeOOP. 
+# 
+# Wrapping a PShape inside a custom class 
+#/
+
+load_library 'star'
+# A Star object
+attr_reader :s1, :s2
+
+def setup
+  size(640, 360, P2D)
+  # Make a new Star
+  @s1 = Star.new width, height
+  @s2 = Star.new width, height
+end
+
+def draw
+  background(51)
+ 
+  s1.display # Display the first star
+  s1.move    # Move the first star
+  
+  s2.display # Display the second star
+  s2.move    # Move the second star
+
+end
+
+

data/samples/processing_app/topics/create_shapes/polygon_pshape_oop2.rb

@@ -0,0 +1,52 @@
+#
+# PolygonPShapeOOP. 
+# 
+# Wrapping a PShape inside a custom class 
+# and demonstrating how we can have a multiple objects each
+# using the same PShape.
+#
+load_library 'polygon'
+
+# A list of objects
+attr_reader :polygons
+
+def setup
+  size(640, 360, P2D)
+  smooth
+  # Make a PShape
+  star = createShape
+  star.beginShape
+  star.noStroke
+  star.fill(0, 127)
+  star.vertex(0, -50)
+  star.vertex(14, -20)
+  star.vertex(47, -15)
+  star.vertex(23, 7)
+  star.vertex(29, 40)
+  star.vertex(0, 25)
+  star.vertex(-29, 40)
+  star.vertex(-23, 7)
+  star.vertex(-47, -15)
+  star.vertex(-14, -20)
+  star.endShape(CLOSE)
+
+  @polygons = []
+  
+  # Add a bunch of objects to the ArrayList
+  # Pass in reference to the PShape
+  # We coud make polygons with different PShapes
+  25.times do
+    polygons << Polygon.new(star, width, height)
+  end
+end
+
+def draw
+  background(255)
+
+  # Display and move them all
+  polygons.each do |poly|
+    poly.display
+    poly.move
+  end
+end
+