propane 0.8.0-java → 0.9.0-java

data/examples/regular/lib/particle.rb

@@ -1,77 +0,0 @@
-# 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

@@ -1,111 +0,0 @@
-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

data/examples/regular/lib/rain_drops.rb

@@ -1,54 +0,0 @@
-require 'forwardable'
-
-module Runnable
-  def run
-    reject!(&:dead?)
-    each(&:display)
-  end
-end
-
-class RainDrops
-  include Enumerable, Runnable
-  extend Forwardable
-  
-  def_delegators(:@drops, :<<, :each, :reject!,  :size)
-
-  attr_reader :drops, :width, :height #, :weight
-
-  def initialize(width, height)
-    @drops = []
-    @width = width
-    @height = height
-  end
-  
-  def fill_up(weight)
-    # @weight = weight
-    drops << Drop.new(rand(width), rand(height / 2) - height / 2, weight) 
-  end
-end
-
-class Drop
-  include Propane::Proxy
-  attr_reader :weight, :x, :y
-  
-  def initialize(x, y, weight = nil)
-    @weight = weight || 10
-    @x, @y = x, y
-  end
-  
-  def render
-    fill(100, 100, 200)
-    no_stroke
-    bezier(x, y,  x - (weight / 2), y + weight, x + (weight / 2), y + weight, x, y)
-  end
-  
-  def dead?
-    @y > height
-  end
-  
-  def display
-    @y = y + weight
-    @x = x - rand(-3..3)
-    render
-  end
-end

data/examples/regular/liquidy.rb

@@ -1,41 +0,0 @@
-#!/usr/bin/env jruby -v -W2
-require 'propane'
-require 'pbox2d'
-require_relative 'lib/particle_system'
-require_relative 'lib/boundary'
-
-Vect = Struct.new(:x, :y)
-
-class Liquidy < Propane::App
-  attr_reader :box2d, :boundaries, :systems
-
-  def setup
-    size(400, 300)
-    @box2d = WorldBuilder.build(app: self, gravity: [0, -20])
-    @systems = []
-    @boundaries = [
-    Boundary.new(box2d, Vect.new(50, 100), Vect.new(300, 5), -0.3),
-    Boundary.new(box2d, Vect.new(250, 175), Vect.new(300, 5), 0.5)
-    ]
-  end
-
-  def draw
-    background(255)
-    # 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(&:display)
-  end
-
-  def mouse_pressed
-    # Add a new Particle System whenever the mouse is clicked
-    systems << ParticleSystem.new(box2d, 0, mouse_x, mouse_y)
-  end
-end
-
-Liquidy.new title: 'Liquidy'

data/examples/regular/mouse_button_demo.rb

@@ -1,32 +0,0 @@
-#!/usr/bin/env jruby -v -W2
-# frozen_string_literal: true
-
-require_relative 'propane'
-# Demo of Mouse Button
-class MouseButtonDemo < Propane::App
-  # Click within the image and press
-  # the left and right mouse buttons to
-  # change the value of the rectangle
-  def setup
-    size 300, 200
-  end
-
-  def draw
-    rect(25, 25, 150, 80)
-  end
-
-  def mouse_pressed
-    case mouse_button
-    when LEFT
-      fill 0
-    when RIGHT
-      fill 255
-    when CENTER
-      fill 125
-    else
-      fill 200, 0, 0
-    end
-  end
-end
-
-MouseButtonDemo.new title: 'Mouse Button Demo'

data/examples/regular/polyhedrons.rb

@@ -1,249 +0,0 @@
-#!/usr/bin/env jruby -v -W2
-###
-# Polyhedrons after sketch by Chinchbug on openprocessing.org
-###
-Vert = Struct.new(:x, :y, :z) do
-  def dist_sq(v)
-    (x - v.x) * (x - v.x) + (y - v.y) * (y - v.y) + (z - v.z) * (z - v.z)
-  end
-
-  def self.permutations(x, y, z)
-    [new(x, y, z), new(z, x, y), new(y, z, x)]
-  end
-end
-
-PHI = (1 + Math.sqrt(5)) / 2
-PHI_SQ = PHI * PHI
-PHI_CU = PHI * PHI * PHI
-ROOT2 = Math.sqrt(2)
-TYPE = "Type Archimedian\nFaces: "
-
-require 'propane'
-
-class Polyhedrons < Propane::App
-
-  attr_reader :verts, :curr_id, :scayl, :ang, :spd, :name, :notes, :off_x, :off_y
-  attr_reader :off_z, :len_edge
-
-  def setup
-    size(1020, 576, P3D)
-    smooth 4
-    text_size(14)
-    # some positional variables for translation
-    @off_y = height / 2
-    @off_x = width / 2 - 100
-    @off_z = -off_y / 8
-    # angle and speed for rotation
-    @ang = 0.0
-    @spd = 0.015
-    # set up initial polyhedron
-    @verts = []
-    @curr_id = 0
-    create_poly(curr_id)
-  end
-
-  def draw
-    # setup the view
-    background(200)
-    push_matrix
-    translate(off_x, off_y, off_z)
-    rotate_x(Math.sin(-ang * 0.3) * 0.5)
-    rotate_y(ang)
-    draw_axis
-    # draw the polyhedron
-    stroke_weight(0.75)
-    stroke(0)
-    (0...verts.size).each do |i|
-      (i...verts.size).each do |j|
-        draw_line(verts[i], verts[j]) if edge?(verts[i], verts[j])
-      end
-    end
-    pop_matrix
-    hint(DISABLE_DEPTH_TEST)
-    # show some notes
-    fill(80, 50, 20)
-    text(name, width - 360, 50)
-    text(notes, width - 340, 70)
-    text('Click to view next polyhedron...',  width - 360, height - 50)
-    hint(ENABLE_DEPTH_TEST)
-    # bump up the angle for the spin
-    @ang += spd
-  end
-
-  def mouse_released
-    # change the polyhedron
-    create_poly(@curr_id += 1)
-  end
-
-  def draw_line(v1, v2)
-    # Draws an edge line
-    line(v1.x * scayl, v1.y * scayl, v1.z * scayl, v2.x * scayl, v2.y * scayl, v2.z * scayl)
-  end
-
-  def edge?(v1, v2)
-    # had some rounding errors, now a bit more forgiving...
-    pres = 1000
-    d = v1.dist_sq(v2) + 0.00001
-    ((d *  pres).round == (len_edge * len_edge * pres).round)
-  end
-
-  def add_verts(x, y, z)
-    # adds the requested vert and all 'mirrored' verts
-    verts << Vert.new(x, y, z)
-    verts << Vert.new(x, y, -z) unless (z == 0.0)
-    verts << Vert.new(x, -y, z) unless (y == 0.0)
-    verts << Vert.new(x, -y, -z) unless (z == 0.0)
-    verts << Vert.new(-x, y, z) unless (x == 0.0)
-    verts << Vert.new(-x, y, -z) unless (z == 0.0)
-    verts << Vert.new(-x, -y, z) unless (y == 0.0)
-    verts << Vert.new(-x, -y, -z) unless (z == 0.0)
-  end
-
-  def permutations(x, y, z)
-    # adds vertices for all three permutations of x, y, and z
-    Vert.permutations(x, y, z).each { |v| add_verts(v.x, v.y, v.z) }
-  end
-
-  def draw_axis
-    # based off how Sketchup handles their axis
-    stroke_weight(0.5)
-    stroke(0, 128, 0)
-    line(-300, 0, 0, 0, 0, 0)
-    stroke(0, 0, 128)
-    line(0, -300, 0, 0, 0, 0)
-    stroke(128, 0, 0)
-    line(0, 0, -300, 0, 0, 0)
-    stroke_weight(0.25)
-    stroke(0, 128, 0)
-    line(300, 0, 0, 0, 0, 0)
-    stroke(0, 0, 128)
-    line(0, 300, 0, 0, 0, 0)
-    stroke(128, 0, 0)
-    line(0, 0, 300, 0, 0, 0)
-  end
-
-  def create_poly(id)
-    # This is where the actual defining of the polyhedrons takes place
-    verts.clear # clear out whatever verts are currently defined
-    case (id)
-    when 0
-      @name = 'Cube:'
-      @notes = "Type platonic\nFaces: 6 squares\nVertices 8\nEdges 12"
-      add_verts(1, 1, 1)
-      @len_edge = 2
-      @scayl = 140
-    when 1
-      @name = 'Octohedron:'
-      @notes = "Type platonic\nFaces: 8 triangles\nVertices 6\nEdges 12"
-      permutations(1, 0, 0)
-      @len_edge = ROOT2
-      @scayl = 220
-    when 2
-      @name = 'Dodecahedron:'
-      @notes = "Type platonic\nFaces: 12 pentagons\nVertices 20\nEdges 30"
-      add_verts(1, 1, 1)
-      permutations(0, 1 / PHI, PHI)
-      @len_edge = 2 / PHI
-      @scayl = 130
-    when 3
-      @name = 'Icosahedron:'
-      @notes = "Type platonic\nFaces: 20 triangles\nVertices 12\nEdges 30"
-      permutations(0, 1, PHI)
-      @len_edge = 2.0
-      @scayl = 120
-    when 4
-      @name = 'Rhombic Dodecahedron:'
-      @notes = "Type Catalan\nFaces: 12 rhombuses\nVertices 14\nEdges 24"
-      add_verts(1, 1, 1)
-      permutations(0, 0, 2)
-      @len_edge = Math.sqrt(3)
-      @scayl = 110
-    when 5
-      @name = 'Rhombic Triacontahedron:'
-      @notes = "Type Catalan\nFaces: 30 rhombuses\nVertices 32\nEdges 60"
-      add_verts(PHI_SQ, PHI_SQ, PHI_SQ)
-      permutations(PHI_SQ, 0, PHI_CU)
-      permutations(0, PHI, PHI_CU)
-      @len_edge = PHI * Math.sqrt(PHI + 2)
-      @scayl = 46
-    when 6
-      @name = 'Cuboctahedron:'
-      @notes = format("%s %d triangles, 6 squares\nVertices 12\nEdges 24", TYPE, 8)
-      permutations(1, 0, 1)
-      @len_edge = ROOT2
-      @scayl = 170
-    when 7
-      @name = 'Truncated Cube:'
-      @notes = format("%s %d triangles, 6 octogons\nVertices 24\nEdges 36", TYPE, 8)
-      permutations(ROOT2 - 1, 1, 1)
-      @len_edge = 2 * (ROOT2 - 1)
-      @scayl = 155
-    when 8
-      @name = 'Truncated Octahedron:'
-      @notes = format("%s %d squares, 8 hexagons\nVertices 24\nEdges 36", TYPE, 6)
-      permutations(0, 1, 2)
-      permutations(2, 1, 0)
-      @len_edge = ROOT2
-      @scayl = 100
-    when 9
-      @name = 'Rhombicuboctahedron:'
-      @notes = format("%s %d triangles, 18 squares\nVertices 24\nEdges 48", TYPE, 8)
-      permutations(ROOT2 + 1, 1, 1)
-      @len_edge = 2
-      @scayl = 80
-    when 10
-      @name = 'Truncated Cuboctahedron:'
-      @notes = format("%s %d squares, 8 hexagons, 6 octogons\nVertices 48\nEdges 72", TYPE, 12)
-      permutations(ROOT2 + 1, 2 * ROOT2 + 1, 1)
-      permutations(ROOT2 + 1, 1, 2 * ROOT2 + 1)
-      @len_edge = 2
-      @scayl = 50
-    when 11
-      @name = 'Icosidodecahedron:'
-      @notes = format("%s %d triangles, 12 pentagons\nVertices 30\nEdges 60", TYPE, 20)
-      permutations(0, 0, 2 * PHI)
-      permutations(1, PHI, PHI_SQ)
-      @len_edge = 2
-      @scayl = 70
-    when 12
-      @name = 'Truncated Dodecahedron:'
-      @notes = format("%s %d triangles, 12 decagons\nVertices 60\nEdges 90", TYPE, 20)
-      permutations(0, 1 / PHI, PHI + 2)
-      permutations(1 / PHI, PHI, 2 * PHI)
-      permutations(PHI, 2, PHI_SQ)
-      @len_edge = 2 * (PHI - 1)
-      @scayl = 60
-    when 13
-      @name = 'Truncated Icosahedron:'
-      @notes = format("%s %d pentagons, 20 hexagons\nVertices 60\nEdges 90", TYPE, 12)
-      permutations(0, 1, 3 * PHI)
-      permutations(2, 2 * PHI + 1, PHI)
-      permutations(1, PHI + 2, 2 * PHI)
-      @len_edge = 2
-      @scayl = 45
-    when 14
-      @name = 'Small Rhombicosidodecahedron:'
-      @notes = format("%s %d triangles, 30 squares, 12 pentagons\nVertices 60\nEdges 120", TYPE, 20)
-      permutations(1, 1, PHI_CU)
-      permutations(PHI_SQ, PHI, 2 * PHI)
-      permutations(PHI + 2, 0, PHI_SQ)
-      @len_edge = 2
-      @scayl = 50
-    when 15
-      @name = 'Great Rhombicosidodecahedron:'
-      @notes = format("%s %d squares, 20 hexagons, 12 decagons\nVertices 120\nEdges 180", TYPE, 30)
-      permutations(1 / PHI, 1 / PHI, PHI + 3)
-      permutations(2 / PHI, PHI, 2 * PHI + 1)
-      permutations(1 / PHI, PHI_SQ, 3 * PHI - 1)
-      permutations(2 * PHI - 1, 2, PHI + 2)
-      permutations(PHI, 3, 2 * PHI)
-      @len_edge = 2 * PHI - 2
-      @scayl = 48
-    else    # start again
-      @curr_id = 0
-      create_poly(curr_id)
-    end
-  end
-end
-
-Polyhedrons.new title: 'Polyhedrons'