ruby-processing 1.0.11 → 2.4.1

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

@@ -0,0 +1,154 @@
+# 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'
+  java_import 'pbox2d.PBox2D'
+  
+  
+  
+  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/pbox2d/liquidy.rb

@@ -0,0 +1,58 @@
+# The Nature of Code
+# <http:#www.shiffman.net/teaching/nature>
+# Spring 2011
+# PBox2D example
+
+# Box2D particle system example
+
+load_library :pbox2d
+load_library :particle_system
+
+# module PS is a wrapper for java imports, 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 = PBox2D.new(self)
+  box2d.create_world  
+  # We are setting a custom gravity
+  box2d.set_gravity(0, -20)  
+  # Create ArrayLists	
+  @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/pbox2d/polygons.rb

@@ -0,0 +1,58 @@
+# The Nature of Code
+# <http://www.shiffman.net/teaching/nature>
+# Spring 2011
+# PBox2D example
+
+# Basic example of falling rectangles
+load_library :pbox2d
+load_library :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 = PBox2D.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.each_with_index do |polygon, i|   
+    if polygon.done
+      polygons.delete_at(i)
+    end
+  end
+end
+
+def mouse_pressed  
+  polygons << CustomShape.new(box2d, mouse_x, mouse_y)
+end

data/samples/{peasy_cam → external_library/java_processing/peasy_cam}/hello_peasy.rb

@@ -1,5 +1,5 @@
-load_library 'PeasyCam'
-import 'peasy'
+load_library 'peasycam'
+include_package 'peasy'
 
 attr_reader :cam
 
@@ -15,8 +15,8 @@ def configure_camera
 end
 
 def draw
-  rotate_x -0.5
-  rotate_y -0.5
+  rotate_x(-0.5)
+  rotate_y(-0.5) 
   background 0
   fill 255, 0, 0
   box 30

data/samples/external_library/java_processing/peasy_cam/hilbert_fractal.rb

@@ -0,0 +1,34 @@
+########################################################
+# A 3D Hilbert fractal implemented using a
+# Lindenmayer System in ruby-processing by Martin Prout
+#
+# Use right mouse button drag or mousewheel for 
+# zoom even then needs a customised forked peasycam to work
+########################################################
+
+
+load_libraries :hilbert, :peasycam
+include_package 'peasy'
+attr_reader :hilbert, :cam
+
+def setup
+  size displayWidth, displayHeight, P3D
+  configure_peasycam
+  @hilbert = Hilbert.new(height/10)
+  hilbert.create_grammar 3
+  no_stroke
+end
+
+def configure_peasycam
+  @cam = PeasyCam.new self, height / 6.5
+  cam.set_minimum_distance height / 10
+  cam.set_maximum_distance height
+end
+
+def draw
+  background 0
+  lights
+  hilbert.render
+end
+
+

data/samples/{peasy_cam → external_library/java_processing/peasy_cam}/library/hilbert/hilbert.rb

@@ -7,7 +7,7 @@ class Grammar
 
   def initialize axiom
     @axiom = axiom
-    @rules = Hash.new
+    @rules = {}
   end
 
   def add_rule premise, rule

data/samples/external_library/java_processing/proscene/cad_camera.rb

@@ -0,0 +1,57 @@
+#
+# Cad Camera.
+# by Jean Pierre Charalambos.
+# 
+# This example illustrates how to add a CAD Camera type to your your scene.
+# 
+# Press 'h' to display the global shortcuts in the console.
+# Press 'H' to display the current camera profile keyboard shortcuts
+# and mouse bindings in the console.
+# Press 'u' to switch between right handed and left handed world frame.
+# Press the space bar to switch between camera profiles: CAD and CAD_CAM.
+# Press x, y or z to set the main rotation axis (defined in the world
+# coordinate system) used by the CAD Camera.
+#
+
+load_library :proscene
+
+include_package 'remixlab.proscene'
+
+attr_reader :scene
+
+def setup
+  size(640, 360, P3D)
+  #Scene instantiation
+  @scene = Scene.new(self)
+  #Register a CAD Camera profile and name it "CAD_CAM" NB Mode is a java enum
+  scene.register_camera_profile(CameraProfile.new(scene, "CAD_CAM", CameraProfile::Mode::CAD))
+  #Set the CAD_CAM as the current camera profile
+  scene.set_current_camera_profile("CAD_CAM")
+  #Unregister the  first-person camera profile (i.e., leave WHEELED_ARCBALL and CAD_CAM)
+  scene.unregister_camera_profile("FIRST_PERSON")
+  #Set right handed world frame (useful for architects...)
+  scene.set_right_handed
+  scene.camera.frame.setCADAxis(PVector.new(0, 1, 0))
+  scene.camera.frame.set_rotation_sensitivity(1.5)
+  scene.camera.frame.set_spinning_friction(0.5)
+  scene.camera.frame.set_tossing_friction(0.5)
+end
+
+def draw
+  background(0)
+  fill(204, 102, 0)
+  box(20, 30, 50)
+end
+
+def key_pressed
+  case(key)
+  when 'u', 'U'
+    ( scene.right_handed? )? scene.set_left_handed : scene.set_right_handed
+  when 'x', 'X'
+    scene.camera.frame.setCADAxis(PVector.new(1, 0, 0))
+  when 'y', 'Y'
+    scene.camera.frame.setCADAxis(PVector.new(0, 1, 0))
+  when 'z','Z'
+    scene.camera.frame.setCADAxis(PVector.new(0, 0, 1))
+  end
+end

data/samples/external_library/java_processing/proscene/camera_customization.rb

@@ -0,0 +1,114 @@
+#
+# Camera Customization.
+# by Jean Pierre Charalambos.
+# 
+# This example shows all the different aspects of proscene that
+# can be customized and how to do it.
+# 
+# Read the commented lines of the sketch code for details.
+#
+# Press 'h' to display the global shortcuts in the console.
+# Press 'H' to display the current camera profile keyboard shortcuts
+# and mouse bindings in the console.
+#
+
+load_library :proscene
+
+
+
+include_package 'remixlab.proscene'
+include_package 'remixlab.proscene.Scene'
+include_package 'remixlab.proscene.Scene.CameraKeyboardAction'
+
+
+class WeirdCameraProfile < CameraProfile
+  
+  def initialize(scn, name)
+    super(scn, name)
+    # 1. Perform some keyboard configuration (warning: camera profiles override those of the scene):
+    # 'u' = move camera up
+    setShortcut('u'.ord, Scene::CameraKeyboardAction::MOVE_CAMERA_UP)
+    # CTRL + SHIFT + 'l' = move camera to the left
+    setShortcut((Event::ALT || Event::SHIFT), 'l'.ord, Scene::CameraKeyboardAction::MOVE_CAMERA_LEFT)
+    # 'S' (note the caps) = move the camera to show all the scene
+    setShortcut('S'.ord, Scene::CameraKeyboardAction::SHOW_ALL)
+    # 2. Describe how to control the camera:
+    # mouse left button = translate camera
+    setCameraMouseBinding(LEFT.ord, Scene::MouseAction::TRANSLATE)
+    # SHIFT + mouse left button = rotate camera
+    setCameraMouseBinding(Event::SHIFT, LEFT.ord, Scene::MouseAction::ROTATE);   
+    # Right button = zoom on region
+    setCameraMouseBinding(RIGHT.ord, Scene::MouseAction::ZOOM_ON_REGION)
+    # 3. Describe how to control the interactive frame:
+    # Left button = rotate interactive frame
+    setFrameMouseBinding(LEFT.ord, Scene::MouseAction::ROTATE)
+    # Right button = translate interactive frame
+    setFrameMouseBinding(RIGHT.ord, Scene::MouseAction::TRANSLATE)
+    # Right button + SHIFT = screen translate interactive frame
+    setFrameMouseBinding(Event::SHIFT, RIGHT.ord, Scene::MouseAction::SCREEN_TRANSLATE)
+    # 4. Configure some click actions:
+    # double click + button left = align frame with world
+    setClickBinding(LEFT.ord, 2, Scene::ClickAction::ALIGN_FRAME)
+    # single click + middle button + SHIFT + ALT = interpolate to show all the scene
+    setClickBinding((Event::SHIFT | Event::ALT), CENTER.ord, 1, Scene::ClickAction::ZOOM_TO_FIT)
+    # double click + middle button = align camera with world
+    setClickBinding(CENTER.ord, 2, Scene::ClickAction::ALIGN_CAMERA)
+  end  
+  
+end
+
+
+attr_reader :scene, :wProfile
+
+def setup
+  size(640, 360, P3D)
+  @scene = Scene.new(self)
+  # A Scene has a single InteractiveFrame (null by default). We set it
+  # here.
+  scene.setInteractiveFrame(InteractiveFrame.new(scene))
+  scene.interactiveFrame.translate(PVector.new(30, 30, 0))
+  
+  # 1. Perform some keyboard configuration:
+  # Note that there are some defaults set (soon to be  documented ;)
+  # change interaction between camera an interactive frame:
+  scene.setShortcut('f'.ord, Scene::KeyboardAction::FOCUS_INTERACTIVE_FRAME)
+  # draw frame selection hint
+  scene.setShortcut(Event::ALT, 'i'.ord, Scene::KeyboardAction::DRAW_FRAME_SELECTION_HINT)
+  # change the camera projection
+  scene.setShortcut('z'.ord, Scene::KeyboardAction::CAMERA_TYPE)
+  
+  # 2. Customized camera profile:
+  @wProfile = WeirdCameraProfile.new(scene, "MY_PROFILE")
+  scene.registerCameraProfile(wProfile)
+  # Unregister the  first-person camera profile (i.e., leave WHEELED_ARCBALL
+  # and MY_PROFILE):
+  scene.unregisterCameraProfile("FIRST_PERSON")
+end
+
+def draw
+  background(0)
+  fill(204, 102, 0)
+  box(20, 20, 40)
+  # Save the current model view matrix
+  push_matrix
+  # Multiply matrix to get in the frame coordinate system.
+  # applyMatrix(scene.interactiveFrame.matrix) is handy but
+  # inefficient
+  scene.interactiveFrame.applyTransformation # optimum
+  # Draw an axis using the Scene static function
+  scene.drawAxis(20)
+  # Draw a second box attached to the interactive frame
+  if (scene.interactiveFrame.grabsMouse)
+    fill(255, 0, 0)
+    box(12, 17, 22)
+    
+  elsif (scene.interactiveFrameIsDrawn)
+    fill(0, 255, 255)
+    box(12, 17, 22)
+    
+  else
+    fill(0, 0, 255)
+    box(10, 15, 20)
+  end
+  pop_matrix
+end