technohippy-Pongo 0.1.0

data/lib/pongo/circle_particle.rb

@@ -0,0 +1,36 @@
+require 'pongo/abstract_particle'
+
+module Pongo
+  # A circle shaped particle. 	 
+  class CircleParticle < AbstractParticle
+    attr_accessor :radius
+
+    def initialize(x, y, radius, options={})
+      options = {:fixed => false, :mass => 1, :elasticity => 0.3, :friction => 0}.update(options)
+      super(x, y, options[:fixed], options[:mass], options[:elasticity], options[:friction])
+      @radius = radius
+    end
+
+    def projection(axis)
+      c = @samp.dot(axis)
+      @interval.min = c - @radius
+      @interval.max = c + @radius
+      @interval
+    end
+    alias get_projection projection
+
+    def interval_x
+      @interval.min = @samp.x - @radius
+      @interval.max = @samp.x + @radius
+      @interval
+    end
+    alias get_interval_x interval_x
+
+    def interval_y
+      @interval.min = @samp.y - @radius
+      @interval.max = @samp.y + @radius
+      @interval
+    end
+    alias get_interval_y interval_y
+  end
+end

data/lib/pongo/collision.rb

@@ -0,0 +1,11 @@
+module Pongo
+  class Collision
+    attr_accessor :vn, :vt
+
+    def initialize(vn=Vector.new, vt=Vector.new)
+      @vn = vn
+      @vt = vt
+    end
+  end
+end
+

data/lib/pongo/collision_detector.rb

@@ -0,0 +1,222 @@
+require 'pongo/util/numeric_ext'
+module Pongo
+  class CollisionDetector
+    class <<self
+      attr_accessor :cpa, :cpb, :coll_normal, :coll_depth
+
+      # Tests the collision between two objects. This initial test determines
+      # the multisampling state of the two particles.
+      def test(obj_a, obj_b)
+        return if obj_a == obj_b # TODO: added by ando
+        return if obj_a.fixed? and obj_b.fixed?
+
+        if obj_a.multisample == 0 and obj_b.multisample == 0
+          norm_vs_norm(obj_a, obj_b)
+        elsif obj_a.multisample > 0 and obj_b.multisample == 0
+          samp_vs_norm(obj_a, obj_b)
+        elsif obj_b.multisample > 0 and obj_a.multisample == 0
+          samp_vs_norm(obj_b, obj_a)
+        elsif obj_a.multisample == obj_b.multisample
+          samp_vs_samp(obj_a, obj_b)
+        else
+          norm_vs_norm(obj_a, obj_b)
+        end
+      end
+
+      # default test for two non-multisampled particles
+      def norm_vs_norm(obj_a, obj_b)
+        obj_a.samp.copy(obj_a.curr)
+
+        obj_b.samp.copy(obj_b.curr)
+        if test_types(obj_a, obj_b)
+          CollisionResolver.resolve(@cpa, @cpb, @coll_normal, @coll_depth)
+          true
+        else
+          false
+        end
+      end
+
+      # Tests two particles where one is multisampled and the other is not. Let objectA
+      # be the multisampled particle.
+      def samp_vs_norm(obj_a, obj_b)
+        return if norm_vs_norm(obj_a, obj_b)
+
+        s = 1 / (obj_a.multisample + 1)
+        t = s
+        obj_a.multisample.times do
+          obj_a.samp.set_to(
+            obj_a.prev.x + t * (obj_a.curr.x - obj_a.prev.x),
+            obj_a.prev.y + t * (obj_a.curr.y - obj_a.prev.y)
+          )
+          if test_types(obj_a, obj_b)
+            CollisionResolver.resolve(@cpa, @cpb, @coll_normal, @coll_depth)
+            return
+          end
+          t += s
+        end
+      end
+
+      # Tests two particles where both are of equal multisample rate
+      def samp_vs_samp(obj_a, obj_b)
+        return if norm_vs_norm(obj_a, obj_b)
+
+        s = 1 / (obj_a.multisample + 1)
+        t = s
+
+        obj_a.multisample.times do
+          obj_a.samp.set_to(
+            obj_a.prev.x + t * (obj_a.curr.x - obj_a.prev.x),
+            obj_a.prev.y + t * (obj_a.curr.y - obj_a.prev.y)
+          )
+          obj_b.samp.set_to(
+            obj_b.prev.x + t * (obj_b.curr.x - obj_b.prev.x),
+            obj_b.prev.y + t * (obj_b.curr.y - obj_b.prev.y)
+          )
+          if test_types(obj_a, obj_b)
+            CollisionResolver.resolve(@cpa, @cpb, @coll_normal, @coll_depth)
+            return
+          end
+          t += s
+        end
+      end
+
+      # Tests collision based on primitive type.
+      def test_types(obj_a, obj_b)
+        if obj_a.is_a?(RectangleParticle) and obj_b.is_a?(RectangleParticle)
+          test_obb_vs_obb(obj_a, obj_b)
+        elsif obj_a.is_a?(CircleParticle) and obj_b.is_a?(CircleParticle)
+          test_circle_vs_circle(obj_a, obj_b)
+        elsif obj_a.is_a?(RectangleParticle) and obj_b.is_a?(CircleParticle)
+          test_obb_vs_circle(obj_a, obj_b)
+        elsif obj_a.is_a?(CircleParticle) and obj_b.is_a?(RectangleParticle)
+          test_obb_vs_circle(obj_b, obj_a)
+        else
+          false
+        end
+      end
+
+      # Tests the collision between two RectangleParticles (aka OBBs). If there is a 
+      # collision it determines its axis and depth, and then passes it off to the 
+      # CollisionResolver for handling.
+      def test_obb_vs_obb(rect_a, rect_b)
+        @coll_depth = Numeric::POSITIVE_INFINITY
+        2.times do |i|
+          axis_a = rect_a.axes[i]
+          depth_a = test_intervals(rect_a.projection(axis_a), rect_b.projection(axis_a))
+          return false if depth_a == 0
+
+          axis_b = rect_b.axes[i]
+          depth_b = test_intervals(rect_a.projection(axis_b), rect_b.projection(axis_b))
+          return false if depth_b == 0
+
+          abs_a = depth_a.abs
+          abs_b = depth_b.abs
+
+          if abs_a < @coll_depth.abs or abs_b < @coll_depth.abs
+            altb = abs_a < abs_b
+            @coll_normal = altb ? axis_a : axis_b
+            @coll_depth = altb ? depth_a : depth_b
+          end
+        end
+
+        @cpa = rect_a
+        @cpb = rect_b
+        true
+      end
+
+      # Tests the collision between a RectangleParticle (aka an OBB) and a 
+      # CircleParticle. If there is a collision it determines its axis and depth, and 
+      # then passes it off to the CollisionResolver.
+      def test_obb_vs_circle(rect_a, cir_a)
+        @coll_depth = Numeric::POSITIVE_INFINITY
+        depths = []
+
+        # first go through the axes of the rectangle
+        2.times do |i|
+          box_axis = rect_a.axes[i]
+          depth = test_intervals(rect_a.projection(box_axis), cir_a.projection(box_axis))
+          return false if depth == 0
+
+          if depth.abs < @coll_depth.abs
+            @coll_normal = box_axis
+            @coll_depth = depth
+          end
+          depths[i] = depth
+        end
+
+        # determine if the circle's center is in a vertex region
+        r = cir_a.radius
+        if depths[0].abs < r and depths[1].abs < r
+          vertex = closest_vertex_on_obb(cir_a.samp, rect_a)
+
+          # get the distance from the closest vertex on rect to circle center
+          @coll_normal = vertex - cir_a.samp
+          mag = @coll_normal.magnitude
+          @coll_depth = r - mag
+
+          if @coll_depth > 0
+            # there is a collision in one of the vertex regions
+            @coll_normal.div!(mag)
+          else
+            # rect_a is in vertex region, but is not colliding
+            return false
+          end
+        end
+        @cpa = rect_a
+        @cpb = cir_a
+        true
+      end
+
+      # Tests the collision between two CircleParticles. If there is a collision it 
+      # determines its axis and depth, and then passes it off to the CollisionResolver
+      # for handling.
+      def test_circle_vs_circle(cir_a, cir_b)
+        depth_x = test_intervals(cir_a.interval_x, cir_b.interval_x)
+        return false if depth_x == 0
+
+        depth_y = test_intervals(cir_a.interval_y, cir_b.interval_y)
+        return false if depth_y == 0
+
+        @coll_normal = cir_a.samp - cir_b.samp
+        mag = @coll_normal.magnitude
+        @coll_depth = cir_a.radius + cir_b.radius - mag
+
+        if @coll_depth > 0
+          @coll_normal.div!(mag)
+          @cpa = cir_a
+          @cpb = cir_b
+          true
+        else
+          false
+        end
+      end
+
+      # Returns 0 if intervals do not overlap. Returns smallest depth if they do.
+      def test_intervals(interval_a, interval_b)
+        return 0 if interval_a.max < interval_b.min
+        return 0 if interval_b.max < interval_a.min
+
+        len_a = interval_b.max - interval_a.min
+        len_b = interval_b.min - interval_a.max
+
+        len_a.abs < len_b.abs ? len_a : len_b
+      end
+
+      # Returns the location of the closest vertex on rect to point
+      def closest_vertex_on_obb(point, rect)
+        d = point - rect.samp
+        q = rect.samp.dup
+
+        2.times do |i|
+          dist = d.dot(rect.axes[i])
+          if    dist >= 0; dist = rect.extents[i] 
+          elsif dist <  0; dist = -rect.extents[i]
+          end
+
+          q.plus!(rect.axes[i] * dist)
+        end
+        q
+      end
+    end
+  end
+end

data/lib/pongo/collision_event.rb

@@ -0,0 +1,23 @@
+require 'pongo/spring_constraint_particle'
+
+module Pongo
+  class CollisionEvent
+    COLLIDE = :collide
+    FIRST_COLLIDE = :first_collide
+
+    attr_accessor :type, :colliding_item
+
+    def initialize(type, colliding_item=nil)
+      @type = type
+      @colliding_item = colliding_item
+    end
+
+    def colliding_item
+      if @colliding_item.is_a?(SpringConstraintParticle)
+        @colliding_item.parent
+      else
+        @colliding_item
+      end
+    end
+  end
+end

data/lib/pongo/collision_resolver.rb

@@ -0,0 +1,39 @@
+require 'pongo/util/math_util'
+
+module Pongo
+  class CollisionResolver
+    def self.resolve(pa, pb, normal, depth)
+      mtd = normal * depth
+      te = pa.elasticity + pb.elasticity
+      sum_inv_mass = pa.inv_mass + pb.inv_mass
+
+      # the total friction in a collision is combined but clamped to [0,1]
+      tf = MathUtil.clamp(1 - (pa.friction + pb.friction), 0, 1)
+
+      # get the collision components, vn and vt
+      ca = pa.components(normal)
+      cb = pb.components(normal)
+
+      # calculate the coefficient of restitution as the normal component
+      vn_a = (cb.vn * ((te + 1) * pa.inv_mass) + 
+        (ca.vn * (pb.inv_mass - te * pa.inv_mass))) / sum_inv_mass
+      vn_b = (ca.vn * ((te + 1) * pb.inv_mass) + 
+        (cb.vn * (pa.inv_mass - te * pb.inv_mass))) / sum_inv_mass
+
+      # apply friction to the tangental component
+      ca.vt.mult!(tf)
+      cb.vt.mult!(tf)
+
+      # scale the mtd by the ratio of the masses. heavier particles move less 
+      mtd_a = mtd * ( pa.inv_mass / sum_inv_mass)
+      mtd_b = mtd * (-pb.inv_mass / sum_inv_mass)
+
+      # add the tangental component to the normal component for the new velocity 
+      vn_a.plus!(ca.vt)
+      vn_b.plus!(cb.vt)
+
+      pa.resolve_collision(mtd_a, vn_a, normal, depth, -1, pb)
+      pb.resolve_collision(mtd_b, vn_b, normal, depth,  1, pa)
+    end
+  end
+end

data/lib/pongo/composite.rb

@@ -0,0 +1,52 @@
+require 'pongo/abstract_collection'
+require 'pongo/util/numeric_ext'
+
+module Pongo
+  # The Composite class can contain Particles, and Constraints. Composites can be added
+  # to a parent Group, along with Particles and Constraints.  Members of a Composite
+  # are not checked for collision with one another, internally.
+  class Composite < AbstractCollection
+    attr_accessor :delta
+
+    def initialize
+      super
+      @delta = Vector.new
+    end
+
+    # Rotates the Composite to an angle specified in radians, around a given center
+    def rotate_by_radian(angle_radians, center)
+      particles.each do |p|
+        radius = p.center.distance(center)
+        angle = relative_angle(center, p.center) + angle_radians
+        p.px = (Math.cos(angle) * radius) + center.x
+        p.py = (Math.sin(angle) * radius) + center.y
+      end
+    end
+
+    # Rotates the Composite to an angle specified in degrees, around a given center
+    def rotate_by_angle(angle_degrees, center)
+      rotate_by_radian(angle_degrees * Numeric::PI_OVER_ONE_EIGHTY, center)
+    end
+
+    # The fixed state of the Composite. Setting this value to true or false will
+    # set all of this Composite's component particles to that value. Getting this 
+    # value will return false if any of the component particles are not fixed.
+    def fixed?
+      particles.each do |p|
+        return false unless p.fixed?
+      end
+      true
+    end
+    alias fixed fixed?
+
+    def fixed=(b)
+      particles.each {|p| p.fixed = b}
+    end
+
+    def relative_angle(center, p)
+      @delta.set_to(p.x - center.x, p.y - center.y)
+      Math.atan2(@delta.y, @delta.x)
+    end
+    alias get_relative_angle relative_angle
+  end
+end

data/lib/pongo/container/container.rb

@@ -0,0 +1,7 @@
+module Pongo
+  module Container
+    class Container
+      attr_accessor :renderer, :logger
+    end
+  end
+end

data/lib/pongo/container/shoes_container.rb

@@ -0,0 +1,14 @@
+require 'pongo/container/container'
+require 'pongo/renderer/shoes_renderer'
+require 'pongo/logger/shoes_logger'
+
+module Pongo
+  module Container
+    class ShoesContainer < Container
+      def initialize(shoes)
+        @renderer = Renderer::ShoesRenderer.new(shoes)
+        @logger = Logger::ShoesLogger.new(shoes)
+      end
+    end
+  end
+end

data/lib/pongo/group.rb

@@ -0,0 +1,166 @@
+module Pongo
+  # The Group class can contain Particles, Constraints, and Composites. Groups can be 
+  # assigned to be checked for collision with other Groups or internally. 
+  class Group < AbstractCollection
+    attr_accessor :composites, :collision_list, :collide_internal
+
+    def initialize(collide_internal=false)
+      super()
+      @composites = []
+      @collision_list = []
+      self.collide_internal = collide_internal
+    end
+
+    def init
+      super
+      @composites.each {|c| c.init}
+    end
+
+    def collide_internal!
+      @collide_internal = true
+    end
+
+    def <<(item)
+      case item
+      when Composite
+        add_composite(item)
+      when Group
+        add_collidable(item)
+      when Array
+        add_collidable_list(item)
+      else
+        super
+      end
+    end
+
+    def add_composite(c)
+      @composites << c
+      c.is_parented = true
+      c.init if @is_parented
+    end
+
+    def remove_composite(c)
+      if @composites.delete(c)
+        c.is_parented = false
+        c.cleanup
+      end
+    end
+
+    def draw
+      super
+      @composites.each {|c| c.draw}
+    end
+
+    def add_collidable(g)
+      @collision_list << g
+    end
+
+    def remove_collidable(g)
+      @collision_list.delete(g)
+    end
+
+    def add_collidable_list(*list)
+      list = list.first if list.first.is_a?(Array)
+      list.each {|g| @collision_list << g}
+    end
+
+    def get_all
+      @particles + @constraints + @composites
+    end
+    alias all get_all
+
+    def clieanup
+      super
+      @composites.each {|c| c.cleanup}
+    end
+
+    def integrate(dt2)
+      super
+      @composites.each {|cmp| cmp.integrate(dt2)}
+    end
+
+    def satisfy_constraints
+      super
+      @composites.each {|cmp| cmp.satisfy_constraints}
+    end
+
+    def check_collisions
+      check_collision_group_internal if @collide_internal
+      @collision_list.each {|g| check_collision_vs_group(g) if g}
+    end
+
+    def check_collision_group_internal
+      # check collisions not in composites
+      check_internal_collisions
+
+      # for every composite in this Group..
+      valid_composites.each do |ca|
+        # .. vs non composite particles and constraints in this group
+        ca.check_collisions_vs_collection(self)
+
+        # ...vs every other composite in this Group
+        valid_composites.each do |cb|
+          ca.check_collisions_vs_collection(cb)
+        end
+      end
+    end
+
+    def check_collision_vs_group(g)
+      # check particles and constraints not in composites of either group
+      check_collisions_vs_collection(g)
+
+      # for every composite in this group..
+      valid_composites.each do |c|
+        # check vs the particles and constraints of g
+        c.check_collisions_vs_collection(g)
+
+        # check vs composites of g
+        g.valid_composites.each do |g|
+          c.check_collections_vs_collection(g)
+        end
+      end
+
+      # check particles and constraints of this group vs the composites of g
+      g.valid_composites.each do |gc|
+        check_collisions_vs_collection(gc)
+      end
+    end
+
+    def valid_composites
+      @composites.select{|c| not c.nil?}
+    end
+
+    def circle(x, y, radius, options={})
+      cir = CircleParticle.new(x, y, radius, options)
+      cir.always_redraw! if options[:always_redraw]
+      self << cir
+      cir
+    end
+
+    def rectangle(x, y, width, height, options={})
+      rect = RectangleParticle.new(x, y, width, height, options)
+      rect.always_redraw! if options[:always_redraw]
+      self << rect
+      rect
+    end
+
+    def wheel(x, y, radius, options={})
+      wh = WheelParticle.new(x, y, radius, options)
+      wh.always_redraw! if options[:always_redraw]
+      self << wh
+      wh
+    end
+
+    def connect(p1, p2, options={})
+      con = SpringConstraint.new(p1, p2, options)
+      self << con
+      con
+    end
+
+    def brace(p1, p2, p3, min_ang, max_ang, options={})
+      ang = AngularConstraint.new(p1, p2, p3, min_ang, max_ang, options)
+      self << ang
+      ang
+    end
+  end
+end