ruby-processing 2.6.3 → 2.6.4

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

@@ -1,209 +0,0 @@
-module PS
-  include_package 'org.jbox2d.collision.shapes'
-  include_package 'org.jbox2d.common'
-  include_package 'org.jbox2d.dynamics'
-  include_package 'shiffman.box2d'
-
-  # Box2D Particle System
-  # <http://www.shiffman.net/teaching/nature>
-  # Spring 2010
-  # translated to ruby-processing Martin Prout
-  
-  # A class to describe a group of Particles
-  # An Array is used to manage the list of Particles 
-  
-  class ParticleSystem
-    
-    attr_reader :particles, :x, :y
-    
-    def initialize(bd, num, x, y)
-      @particles = []          # Initialize the Array
-      @x, @y = x, y            # Store the origin point  
-      num.times do
-        particles << PS::Particle.new(bd, x, y)
-      end
-    end
-    
-    def run
-      # Display all the 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}
-      
-    end
-    
-    def add_particles(bd, n)
-      n.times do
-        particles << PS::Particle.new(bd, x, y)
-      end
-    end
-    
-    # A method to test if the particle system still has particles
-    def dead  
-      particles.empty?
-    end
-    
-  end
-  
-  # The Nature of Code
-  # <http://www.shiffman.net/teaching/nature>
-  # Spring 2012
-  # PBox2D example
-  
-  # A Particle
-  
-  class Particle
-    TRAIL_SIZE = 6
-    # We need to keep track of a Body
-    
-    attr_reader :trail, :body, :box2d
-    
-    # Constructor
-    def initialize(b2d, x, y)
-      @box2d = b2d
-      @trail = Array.new(TRAIL_SIZE, [x, y])
-      
-      # Add the box to the box2d world
-      # Here's a little trick, let's make a tiny tiny radius
-      # This way we have collisions, but they don't overwhelm the system
-      make_body(PS::Vec2.new(x,y), 0.2)
-    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 + 20)
-        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)
-      
-      # Keep track of a history of screen positions in an array
-      (TRAIL_SIZE - 1).times do |i|
-        trail[i] = trail[i + 1]
-      end
-      trail[TRAIL_SIZE - 1] = [pos.x, pos.y]
-      
-      # Draw particle as a trail
-      begin_shape
-        noFill
-        stroke_weight(2)
-        stroke(0,150)
-        trail.each do |v|
-          vertex(v[0], v[1])
-        end
-      end_shape
-    end
-    
-    # This function adds the rectangle to the box2d world
-    def make_body(center, r)
-      # Define and create the body
-      bd = PS::BodyDef.new
-      bd.type = PS::BodyType::DYNAMIC
-      
-      bd.position.set(box2d.coord_pixels_to_world(center))
-      @body = box2d.create_body(bd)
-      
-      # Give it some initial random velocity
-      body.set_linear_velocity(PS::Vec2.new(rand(-1..1), rand(-1..1)))
-      
-      # Make the body's shape a circle
-      cs = PS::CircleShape.new
-      cs.m_radius = box2d.scalar_pixels_to_world(r)
-      
-      fd = PS::FixtureDef.new
-      fd.shape = cs
-      
-      fd.density = 1
-      fd.friction = 0  # Slippery when wet!
-      fd.restitution = 0.5
-      
-      # We could use this if we want to turn collisions off
-      #cd.filter.groupIndex = -10
-      
-      # Attach fixture to body
-      body.create_fixture(fd)
-      
-    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 = PS::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 = PS::BodyDef.new
-      bd.type = PS::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
-  
-  
-  
-  
-

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

@@ -1,154 +0,0 @@
-# The Nature of Code
-# <http://www.shiffman.net/teaching/nature>
-# Spring 2010
-# PBox2D example
-
-# An uneven surface boundary
-module SB
-  
-  include_package 'org.jbox2d.collision.shapes'
-  include_package 'org.jbox2d.common'  
-  include_package 'org.jbox2d.dynamics'
-  include_package 'shiffman.box2d'
-  
-  
-  
-  class Surface
-    # We'll keep track of all of the surface points
-    attr_reader :surface, :body, :box2d, :y, :width, :height
-    
-    
-    def initialize b2d
-      @box2d = b2d
-      @surface = []
-      @width, @height = $app.width, $app.height
-      # This is what box2d uses to put the surface in its world
-      chain = SB::ChainShape.new
-      
-      # Perlin noise argument
-      xoff = 0.0
-      
-      # This has to go backwards so that the objects  bounce off the top of the surface
-      # This "edgechain" will only work in one direction!
-      (width + 10).step(-10, -5) do |x| 
-        # Doing some stuff with perlin noise to calculate a surface that points down on one side
-        # and up on the other
-        
-        if (x > width/2)
-          @y = 100 + (width - x)*1.1 + map(noise(xoff),0,1,-80,80)
-        else
-          @y = 100 + x*1.1 + map(noise(xoff),0,1,-80,80)
-        end
-        
-        # Store the vertex in screen coordinates
-        surface << SB::Vec2.new(x, y)
-        
-        # Move through perlin noise
-        xoff += 0.1
-        
-      end
-      
-      # Build an array of vertices in Box2D coordinates
-      # from the ArrayList we made
-      vertices = []
-      surface.each do |surf|        
-        vertices << box2d.coord_pixels_to_world(surf)
-      end
-     # Create the chain!
-      chain.createChain(vertices, vertices.length)
-      # The edge chain is now attached to a body via a fixture
-      bd = SB::BodyDef.new
-      bd.position.set(0.0, 0.0)
-      @body = box2d.createBody(bd)
-      # Shortcut, we could define a fixture if we
-      # want to specify frictions, restitution, etc.
-      body.createFixture(chain, 1)      
-    end
-    
-    # A simple function to just draw the edge chain as a series of vertex points
-    def display
-      stroke_weight(2)
-      stroke(0)
-      fill(135, 206, 250)
-      beginShape
-        vertex(width, 0)      # extra vertices so we can fill sky
-        surface.each do |v|
-          vertex(v.x, v.y)    # the mountain range
-        end
-        vertex(0, 0)          # extra vertices so we can fill sky
-      endShape
-    end    
-  end
-  
-  class Particle
-    # We need to keep track of a Body
-    
-    attr_reader :body, :box2d, :x, :y, :r 
-    
-    # Constructor
-    def initialize(b2d, x, y, r)
-      @box2d, @x, @y, @r = b2d, x, y, r
-      # This function puts the particle in the Box2d world
-      make_body(x, y, r)
-    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
-      pos = box2d.get_body_pixel_coord(body)
-      # Is it off the bottom of the screen?
-      if (pos.y > $app.height + r * 2)
-        kill_body
-        return true
-      end
-        return false
-    end
-    
-    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
-      push_matrix
-      translate(pos.x,  pos.y)
-      rotate(-a)
-      fill(175)
-      stroke(0)
-      stroke_weight(1)
-      ellipse(0,0,r*2,r*2)
-      # Let's add a line so we can see the rotation
-      line(0,0,r,0)
-      pop_matrix
-    end
-    
-    # This function adds the rectangle to the box2d world
-    def make_body(x, y, r)
-      # Define and create the body
-      bd = SB::BodyDef.new      
-      bd.position = box2d.coord_pixels_to_world(x,y) 
-      bd.type = SB::BodyType::DYNAMIC
-      @body = box2d.world.create_body(bd)
-      # Make the body's shape a circle
-      cs = SB::CircleShape.new
-      cs.m_radius = box2d.scalar_pixels_to_world(r)      
-      fd = SB::FixtureDef.new      
-      fd.shape = cs
-      # Parameters that affect physics
-      fd.density = 1
-      fd.friction = 0.01
-      fd.restitution = 0.3      
-      # Attach fixture to body
-      body.create_fixture(fd)      
-      # Give it a random initial velocity (and angular velocity)
-      body.set_linear_velocity(SB::Vec2.new(rand(-10..10), rand(5..10)))
-      body.set_angular_velocity(rand(-10..10))      
-    end      
-  end    
-end  
-  
-  
-

data/samples/external_library/java_processing/box2d_processing/liquidy.rb

@@ -1,58 +0,0 @@
-# The Nature of Code
-# <http:#www.shiffman.net/teaching/nature>
-# Spring 2011
-# Updated to use the updated library
-# translated to ruby-processing 2 March 2014 by Martin Prout
-# Box2DProcessing example
-
-load_libraries :box2d_processing, :particle_system
-
-
-# module PS is a wrapper for java packages, and Boundary and Particle classes
-include PS     
-
-attr_reader :box2d, :boundaries, :systems
-
-def setup
-  size(400,300)
-  smooth  
-  # Initialize box2d physics and create the world
-  @box2d = PS::Box2DProcessing.new(self)
-  box2d.create_world  
-  # We are setting a custom gravity
-  box2d.set_gravity(0, -20)  
-  # Create Arrays	
-  @systems = []
-  @boundaries = []  
-  # Add a bunch of fixed boundaries
-  boundaries << Boundary.new(box2d, 50, 100, 300, 5, -0.3)
-  boundaries << Boundary.new(box2d, 250, 175, 300, 5, 0.5)  
-end
-
-def draw
-  background(255)  
-  # We must always step through time!
-  box2d.step  
-  # Run all the particle systems
-  if systems.size > 0
-    systems.each do |system|
-      system.run 
-      system.add_particles(box2d, rand(0..2)) 
-    end
-  end  
-  # Display all the boundaries
-  boundaries.each do |wall|
-    wall.display
-  end
-end
-
-
-def mouse_pressed
-  # Add a new Particle System whenever the mouse is clicked
-  systems << ParticleSystem.new(box2d, 0, mouse_x, mouse_y)
-end
-
-
-
-
-

data/samples/external_library/java_processing/box2d_processing/polygons.rb

@@ -1,53 +0,0 @@
-# The Nature of Code
-# <http://www.shiffman.net/teaching/nature>
-# Spring 2011
-# Box2DProcessing example
-
-# Basic example of falling rectangles
-load_libraries :box2d_processing, :custom_shape
-
-# module B2D is a wrapper for java imports, and Boundary and CustomShape classes
-include B2D     
-
-attr_reader :box2d, :boundaries, :polygons
-
-def setup
-  size(640,360)
-  smooth  
-  # Initialize box2d physics and create the world
-  @box2d = B2D::Box2DProcessing.new(self)
-  box2d.create_world
-  # We are setting a custom gravity
-  box2d.set_gravity(0, -20)  
-  # Create Arrays	
-  @polygons = []
-  @boundaries = []  
-  # Add a bunch of fixed boundaries
-  boundaries << Boundary.new(box2d, width / 4, height - 5, width/2 - 50, 10, 0)
-  boundaries << Boundary.new(box2d, 3*width / 4, height - 50, width/2 - 50, 10, 0)
-  boundaries << Boundary.new(box2d, width - 5,height / 2, 10, height, 0)
-  boundaries << Boundary.new(box2d, 5, height / 2, 10, height, 0)
-end
-
-def draw
-  background(255)  
-  # We must always step through time!
-  box2d.step  
-  # Display all the boundaries
-  boundaries.each do |wall|
-    wall.display
-  end
-  
-  # Display all the polygons
-  polygons.each do |cs|
-    cs.display
-  end
-  
-  # polygons that leave the screen, we delete them
-  # (note they have to be deleted from both the box2d world and our list
-  polygons.reject! { |p| p.done}
-end
-
-def mouse_pressed  
-  polygons << CustomShape.new(box2d, mouse_x, mouse_y)
-end