propane 0.3.0.pre-java

data/examples/regular/flight_patterns.rb

@@ -0,0 +1,63 @@
+# Description:
+# Flight Patterns is that ol' Euruko 2008 demo.
+# Reworked version for Propane
+# Usage:
+# Drag mouse to steer 'invisible' flock attractor, use 'f' key to toggle flee
+# Mouse 'click' to toggle 'sphere' or 'circle' display
+require 'propane'
+
+class FlightPatterns < Propane::App
+  load_library :boids
+  
+  attr_reader :flee, :radius
+  
+  def setup
+    size 1024, 768, P3D
+    sphere_detail 8
+    color_mode RGB, 1.0
+    no_stroke
+    shininess 1.0
+    specular 0.3, 0.1, 0.1
+    emissive 0.03, 0.03, 0.1
+    @radius = 0.02 * height
+    @click = false
+    @flee = false
+    @flocks = (0..3).map { Boids.flock(n: 20, x: 0, y: 0, w: width, h: height) }
+  end
+  
+  def mouse_pressed
+    @click = !@click
+  end
+  
+  def key_pressed
+    return unless key == 'f'
+    @flee = !@flee
+  end
+  
+  def draw
+    background 0.05
+    ambient_light 0.01, 0.01, 0.01
+    light_specular 0.4, 0.2, 0.2
+    point_light 1.0, 1.0, 1.0, mouse_x, mouse_y, 190
+    @flocks.each_with_index do |flock, i|
+      flock.goal(target: Vec3D.new(mouse_x, mouse_y, 0), flee: @flee)
+      flock.update(goal: 185, limit: 13.5)
+      flock.each do |boid|
+        r = (0.15 * boid.pos.z) + radius
+        case i
+        when 0 then fill 0.85, 0.65, 0.65
+        when 1 then fill 0.65, 0.85, 0.65
+        when 2 then fill 0.65, 0.65, 0.85
+        end
+        push_matrix
+        point_array = (boid.pos.to_a).map { |p| p - (r / 2.0) }
+        translate(*point_array)
+        @click ? sphere(r / 2) : ellipse(0, 0, r, r)
+        @click ? hint(ENABLE_DEPTH_TEST) : hint(DISABLE_DEPTH_TEST)
+        pop_matrix
+      end
+    end
+  end
+end
+
+FlightPatterns.new title: 'Flight Patterns'

data/examples/regular/grey_circles.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+# frozen_string_literal: true
+# grey circles : borrowed from https://github.com/quil/quil
+require 'propane'
+
+class GreyCircles < Propane::App
+
+  def setup
+    size(323, 200)
+    smooth
+    frame_rate(1)
+    background(200)    
+  end
+
+  def draw
+    stroke_setup
+    diameter = rand(100)
+    ellipse(rand(width), rand(height), diameter, diameter)
+  end
+
+  def stroke_setup
+    [:stroke, :stroke_weight, :fill].each do |method|
+      send(method, rand(255))
+    end
+  end
+end
+
+GreyCircles.new title: 'Oh so many circles'

data/examples/regular/jwishy.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'propane'
+# Iconic ruby-processing example for Propane
+class JWishy < Propane::App
+  load_library :control_panel
+
+  attr_reader :alpha, :back_color, :bluish, :hide, :magnitude, :panel
+  attr_reader :x_wiggle, :y_wiggle
+
+  def setup
+    size 600, 600
+    control_panel do |c|
+      c.title = 'Control Panel'
+      c.look_feel 'Nimbus'
+      c.slider :bluish, 0.0..1.0, 0.5
+      c.slider :alpha,  0.0..1.0, 0.5
+      c.checkbox :go_big
+      c.button :reset
+      c.menu :shape, %w(oval square triangle)
+      @panel = c
+    end
+    @hide = false
+    @shape = 'oval'
+    @x_wiggle, @y_wiggle = 10.0, 0
+    @magnitude = 8.15
+    @back_color = [0.06, 0.03, 0.18]
+    color_mode RGB, 1
+    ellipse_mode CORNER
+    smooth
+  end
+
+  def draw_background
+    back_color[3] = alpha
+    fill(*back_color.to_java(:float))
+    rect 0, 0, width, height
+  end
+
+  def reset
+    @y_wiggle = 0
+  end
+
+  def draw
+    # only make control_panel visible once, or again when hide is false
+    unless hide
+      @hide = true
+      panel.set_visible(hide)
+    end
+    draw_background
+    # Seed the random numbers for consistent placement from frame to frame
+    srand(0)
+    horiz, vert, mag = x_wiggle, y_wiggle, magnitude
+    if @go_big
+      mag *= 2
+      vert /= 2
+    end
+    blu = bluish
+    x, y = (width / 2), -27
+    c = 0.0
+    64.times do
+      x += cos(horiz) * mag
+      y += log10(vert) * mag + sin(vert) * 2
+      fill(sin(y_wiggle + c), rand * 0.2, rand * blu, 0.5)
+      s = 42 + cos(vert) * 17
+      args = [@shape, x - s / 2, y - s / 2, s, s]
+      draw_shape(args)
+      vert += rand * 0.25
+      horiz += rand * 0.25
+      c += 0.1
+    end
+    @x_wiggle += 0.05
+    @y_wiggle += 0.1
+  end
+
+  def mouse_pressed
+    return unless hide
+    @hide = false
+  end
+
+  def draw_shape(args)
+    case args[0]
+    when 'triangle'
+      draw_triangle(args)
+    when 'square'
+      rect(args[1], args[2], args[3], args[4])
+    else
+      ellipse(args[1], args[2], args[3], args[4]) # oval for Shoes
+    end
+  end
+
+  def draw_triangle(args)
+    x2 = args[1] + (args[3] * 0.6)
+    y0 = args[2] + (args[4] * 0.396)
+    y1 = args[2] - (args[4] * 0.792)
+    y2 = args[2] + (args[4] * 0.396)
+    triangle(args[1] - (args[3] * 0.6), y0, args[1], y1, x2, y2)
+  end
+end
+
+JWishy.new title: 'Wishy Worm'

data/examples/regular/letters.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+# frozen_string_literal: true
+# Letters. 
+# 
+require 'propane'
+
+LETTERS = ('A'..'Z').to_a + ('0'..'9').to_a  + ('a'..'z').to_a
+
+# Draws letters to the screen. This requires loading a font, 
+# setting the font, and then drawing the letters.
+class Letters < Propane::App
+  def setup    
+    size 640, 360    
+    @font = create_font 'Georgia', 24 
+    text_font @font
+    text_align CENTER, CENTER    
+  end
+  
+  def draw    
+    background 0  	
+    translate 24, 32  	
+    x, y = 0.0, 0.0
+    gap = 30  
+    # ranges -> arrays -> joined!  	
+    LETTERS.each do |letter|  	    
+      fill 255
+      fill 204, 204, 0 if letter =~ /[AEIOU]/
+      fill 0, 204, 204 if letter =~ /[aeiou]/
+      fill 153 if letter =~ /[0-9]/
+      fill 255, 100, 0 if key_pressed? && (letter.downcase.eql? key) 
+      fill 0, 100, 255 if key_pressed? && (letter.upcase.eql? key)  	
+      text letter, x, y  		
+      x += gap  		
+      if x > width - 30
+        x = 0
+        y += gap
+      end
+    end
+  end
+end
+
+Letters.new title: 'Letters'

data/examples/regular/lib/boundary.rb

@@ -0,0 +1,38 @@
+# Re-usable Boundary class
+class Boundary
+  include Propane::Proxy
+  attr_reader :box2d, :b, :pos, :size, :a
+
+  def initialize(b2d, pos, sz, a = 0)
+    @box2d, @pos, @size, @a = b2d, pos, sz, a
+    # Define the polygon
+    sd = PolygonShape.new
+    # Figure out the box2d coordinates
+    box2d_w = box2d.scale_to_world(size.x / 2)
+    box2d_h = box2d.scale_to_world(size.y / 2)
+    # We're just a box
+    sd.set_as_box(box2d_w, box2d_h)
+    # Create the body
+    bd = BodyDef.new
+    bd.type = BodyType::STATIC
+    bd.angle = a
+    bd.position.set(box2d.processing_to_world(pos.x, pos.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 ask for location
+  def display
+    fill(0)
+    stroke(0)
+    stroke_weight(1)
+    rect_mode(PConstants::CENTER)
+    a = b.get_angle
+    push_matrix
+    translate(pos.x, pos.y)
+    rotate(-a)
+    rect(0, 0, size.x, size.y)
+    pop_matrix
+  end
+end

data/examples/regular/lib/particle.rb

@@ -0,0 +1,77 @@
+# Note the particle class change method is use to change color to red
+# when two particles collide (no change just hitting boundary)
+class Particle
+  extend Forwardable
+  def_delegators(:@app, :box2d, :begin_shape, :color, :end_shape, :line,
+                 :pop_matrix, :ellipse, :translate, :rotate, :stroke,
+                 :push_matrix, :fill, :no_fill, :stroke_weight)
+  attr_accessor :body
+  attr_reader :radius, :col
+
+  def initialize(app, x, y, r)
+    @app, @x, @y, @radius = app, x, y, r
+    # This function puts the particle in the Box2d world
+    make_body(x, y, radius)
+    @col = color('#c0c0c0') # silvergrey
+    body.setUserData(self)
+  end
+
+  # This function removes the particle from the box2d world
+  def kill_body
+    box2d.destroy_body(body)
+  end
+
+  # Change color when hit
+  def change
+    @col = color('#cc0000') # red
+  end
+
+  # Is the particle ready for deletion?
+  def done
+    # Let's find the screen position of the particle
+    pos = box2d.body_coord(body)
+    # Is it off the bottom of the screen?
+    return false unless pos.y > (box2d.height + radius * 2)
+    kill_body
+    true
+  end
+
+  def display
+    # We look at each body and get its screen position
+    pos = box2d.body_coord(body)
+    # Get its angle of rotation
+    a = body.get_angle
+    push_matrix
+    translate(pos.x, pos.y)
+    rotate(a)
+    fill(col)
+    stroke(0)
+    stroke_weight(1)
+    ellipse(0, 0, radius * 2, radius * 2)
+    # Let's add a line so we can see the rotation
+    line(0, 0, radius, 0)
+    pop_matrix
+  end
+
+  # Here's our function that adds the particle to the Box2D world
+  def make_body(x, y, r)
+    # Define a body
+    bd = BodyDef.new
+    # Set its position
+    bd.position = box2d.processing_to_world(x, y)
+    bd.type = BodyType::DYNAMIC
+    @body = box2d.create_body(bd)
+    # Make the body's shape a circle
+    cs = CircleShape.new
+    cs.m_radius = box2d.scale_to_world(r)
+    fd = 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)
+    body.set_angular_velocity(rand(-10.0..10))
+  end
+end

data/examples/regular/lib/particle_system.rb

@@ -0,0 +1,111 @@
+require 'forwardable'
+
+module Runnable
+  def run
+    reject!(&:done)
+    each(&:display)
+  end
+end
+
+# Not be confused with the jbox2d ParticleSystem
+class ParticleSystem
+  include Enumerable, Runnable
+  extend Forwardable
+  def_delegators(:@particles, :each, :reject!, :<<, :empty?)
+  def_delegator(:@particles, :empty?, :dead?)
+
+  attr_reader :x, :y
+
+  def initialize(bd, num, x, y)
+    @particles = []          # Initialize the Array
+    @x, @y = x, y            # Store the origin point
+    num.times do
+      self << Particle.new(bd, x, y)
+    end
+  end
+
+  def add_particles(bd, n)
+    n.times do
+      self << Particle.new(bd, x, y)
+    end
+  end
+end
+
+# A Particle
+require 'pbox2d'
+
+class Particle
+  include Propane::Proxy
+  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(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.body_coord(body)
+    # Is it off the bottom of the screen?
+    return false unless pos.y > box2d.height + 20
+    kill_body
+    true
+  end
+
+  # Drawing the box
+  def display
+    # We look at each body and get its screen position
+    pos = box2d.body_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
+    no_fill
+    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(x, y, r)
+    # Define and create the body
+    bd = BodyDef.new
+    bd.type = BodyType::DYNAMIC
+    bd.position.set(box2d.processing_to_world(x, y))
+    @body = box2d.create_body(bd)
+    # Give it some initial random velocity
+    body.set_linear_velocity(Vec2.new(rand(-1.0..1), rand(-1.0..1)))
+    # Make the body's shape a circle
+    cs = CircleShape.new
+    cs.m_radius = box2d.scale_to_world(r)
+    fd = 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