bulldog_physics 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+gem 'require_all'
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,22 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2.2)
+    rcov (0.9.11)
+    require_all (1.2.1)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  rcov
+  require_all
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Conner Wingard
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,25 @@
+= bulldog_physics
+
+bulldog_physics started as a school project at Champlain College. It has been put together from
+code samples provided in the book "Game Physics Engine Development : How to Build a Robust Commercial-Grade Physics Engine for your game" by Ian Millington. As the code samples in the book were in C++, 
+all of it had to be converted. As such, a lot of it still looks C like. 
+
+There is an example showing some of the things that the engine can do, gravity, bouncing of planes, being connected via springs (of various types) . Many more effects can be added by merely by subclassing one of the ForceGenerators.
+
+Documentation will be created as soon as time allows for me to do so. 
+
+== Contributing to bulldog_physics
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Conner Wingard. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "bulldog_physics"
+  gem.homepage = "http://github.com/ConnerMan/bulldog_physics"
+  gem.license = "MIT"
+  gem.summary = %Q{A 3D Physics Engine in Ruby}
+  gem.description = %Q{3D Physics Engine written in pure ruby that can be used for creating 3d simulations or games}
+  gem.email = "conner.wingard@gmail.com"
+  gem.authors = ["Conner Wingard"]
+
+  gem.add_dependency 'require_all'
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "bulldog_physics #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bulldog_physics.gemspec

@@ -0,0 +1,92 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "bulldog_physics"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Conner Wingard"]
+  s.date = "2012-04-24"
+  s.description = "3D Physics Engine written in pure ruby that can be used for creating 3d simulations or games"
+  s.email = "conner.wingard@gmail.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "bulldog_physics.gemspec",
+    "lib/Particles/particle.rb",
+    "lib/Particles/particle_anchored_spring.rb",
+    "lib/Particles/particle_cable.rb",
+    "lib/Particles/particle_contact.rb",
+    "lib/Particles/particle_contact_generator.rb",
+    "lib/Particles/particle_contact_resolver.rb",
+    "lib/Particles/particle_drag.rb",
+    "lib/Particles/particle_force_generator.rb",
+    "lib/Particles/particle_force_registration.rb",
+    "lib/Particles/particle_force_registry.rb",
+    "lib/Particles/particle_gravity.rb",
+    "lib/Particles/particle_ground_contacts.rb",
+    "lib/Particles/particle_link.rb",
+    "lib/Particles/particle_particle_contacts.rb",
+    "lib/Particles/particle_rod.rb",
+    "lib/Particles/particle_spring.rb",
+    "lib/Particles/particle_world.rb",
+    "lib/Particles/projectile.rb",
+    "lib/bulldog_physics.rb",
+    "lib/examples/GlStuff/gl_utility.rb",
+    "lib/examples/GlStuff/lighting.rb",
+    "lib/examples/GlStuff/material.rb",
+    "lib/examples/GlStuff/terrain.rb",
+    "lib/examples/simple_game.rb",
+    "lib/matrix3.rb",
+    "lib/matrix4.rb",
+    "lib/quaternion.rb",
+    "lib/vector3.rb",
+    "test/helper.rb",
+    "test/test_bulldog_physics.rb"
+  ]
+  s.homepage = "http://github.com/ConnerMan/bulldog_physics"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.13"
+  s.summary = "A 3D Physics Engine in Ruby"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<require_all>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_runtime_dependency(%q<require_all>, [">= 0"])
+    else
+      s.add_dependency(%q<require_all>, [">= 0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<require_all>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<require_all>, [">= 0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<require_all>, [">= 0"])
+  end
+end
+

data/lib/Particles/particle.rb

@@ -0,0 +1,75 @@
+module BulldogPhysics
+  module Particles
+    
+    class Particle
+  
+      attr_accessor :position, :velocity, :acceleration, :damping, :force_accum, :mass, :material, :radius, :frozen
+  
+  
+      def initialize()
+        @position = Vector3.new
+        @velocity = Vector3.new
+        @acceleration = Vector3.new
+        @force_accum = Vector3.new
+        @mass = 0
+        @damping = 0.0
+        @material = Material.new
+        @radius = 0.5
+        @frozen = false
+      end
+  
+      def inverse_mass
+        if @mass.eql? 0
+          return 0
+        else
+          return 1.0 / @mass
+        end
+      end
+      
+      
+      def integrate(duration)
+        
+        if @frozen
+          clearAccumulator
+          return
+        end
+        if(inverse_mass <= 0.0)
+          return
+        end
+    
+        if(duration < 0.0)
+          raise Exception.new
+        end
+    
+        @position.addScaledVector(@velocity, duration)
+    
+        resulting_acc = @acceleration.dup
+        resulting_acc.addScaledVector(@force_accum, inverse_mass)
+    
+        @velocity.addScaledVector(resulting_acc, duration)
+    
+        unless @damping == 0.0
+          modifier = @damping ** duration
+          @velocity.multiplyByScalar( modifier )
+        end
+        
+
+        clearAccumulator
+      end
+  
+      def addForce(forceVector3)
+        @force_accum.addVector( forceVector3 )
+      end
+  
+      def clearAccumulator
+        @force_accum.clear();
+      end
+  
+      def has_infinite_mass
+        @mass < 0
+      end
+    
+    end
+    
+  end
+end

data/lib/Particles/particle_anchored_spring.rb

@@ -0,0 +1,42 @@
+module BulldogPhysics
+  module Particles
+    module Generators
+    
+      class ParticleAnchoredSpring < ParticleForceGenerator
+      
+        attr_accessor :anchor # location of the anchored end of the spring
+        attr_accessor :spring_constant
+        attr_accessor :rest_length  # rest length of the string
+      
+      
+        def initialize(anchor, spring_const, rest_len)
+          @anchor = anchor
+          @spring_constant = spring_const
+          @rest_length = rest_len
+        end
+      
+        def update_force(particle, duration)
+        
+          #calculate vector of the spring
+          force = particle.position.dup
+          force = force.subtractVector(@anchor)
+          # calculate magnitude of the force
+          magnitude = force.magnitude
+          magnitude = (@rest_length - magnitude) * @spring_constant
+          magnitude *= @spring_constant
+          
+          #calculate final force and apply it
+          force = force.unit
+
+          force.multiplyByScalar(magnitude)
+          particle.addForce(force)
+        end
+      
+    
+    
+      end
+    
+    
+    end
+  end
+end

data/lib/Particles/particle_cable.rb

@@ -0,0 +1,52 @@
+module BulldogPhysics
+  module Particles
+    module Collisions
+    
+
+      
+      # Cables link a pair of particles, generating a contact if they stray too far apart.
+      class ParticleCable < ParticleLink
+      
+      
+        # Holds the maximum length of the cable.
+        attr_accessor :max_length
+        
+        # Holds the restitution (bounciness) of the cable.
+        attr_accessor :restitution
+        
+      
+        def initialize(particle1, particle2, max_length = 1.0, restitution = 1.0)
+          super(particle1, particle2)
+          @max_length = max_length
+          @restitution = restitution
+        end
+      
+        # see ParticleLink for description
+        def add_contact(contactArray, limit)
+          length = (@particle1.position - @particle2.position).magnitude
+          
+          
+          if( length < @max_length)
+            return 0
+          end
+          
+          contact = ParticleContact.new(@particle1, @particle2)
+          
+          contact.penetration = length - @max_length
+          contact.restitution = @restitution
+          
+          contactArray << contact
+          
+          return 1
+        end
+        
+        def current_length
+          (@particle1.position - @particle2.position).magnitude
+        end
+      
+      end
+      
+      
+    end
+  end
+end

data/lib/Particles/particle_contact.rb

@@ -0,0 +1,121 @@
+module BulldogPhysics
+  module Particles
+    module Collisions
+    
+      class ParticleContact
+      
+        attr_accessor :particle1
+        attr_accessor :particle2
+        attr_accessor :restitution
+        attr_accessor :contact_normal
+        attr_accessor :penetration
+        
+        def initialize(particle1, particle2 = nil, contact_normal = Vector3.new(0,1,0), penetration = 0)
+          @particle1 = particle1
+          @particle2 = particle2
+          @penetration = penetration
+          @contact_normal = contact_normal
+          unless @particle2.nil?
+            @contact_normal = (@particle1.position - @particle2.position).unit
+            #@penetration = (@particle1.position - @particle2.position).magnitude.abs - (@particle1.radius + @particle2.radius)
+            #puts "PENETRATION #{@penetration}"
+          end
+          @restitution = 0.0
+        end
+        
+        def resolve(duration)
+          resolve_velocity(duration)
+          resolve_interpenetration(duration)
+        end
+    
+        def calculate_separating_velocity
+          relative_velocity = @particle1.velocity
+          unless @particle2.nil?
+            relative_velocity -= @particle2.velocity
+          end
+          return relative_velocity.scalarProduct(@contact_normal)
+        end
+      
+      
+        private
+      
+        def resolve_velocity(duration)
+        
+          #Find the velocity in the direction of the contact.
+          separating_velocity = calculate_separating_velocity()
+        
+          # Check if it needs to be resolved.
+          if(separating_velocity > 0)
+            # The contact is either separating, or stationary; there’s no impulse required.
+            return
+          end
+          new_sep_velocity = -separating_velocity * @restitution
+          delta_velocity = new_sep_velocity -  separating_velocity
+        
+          total_inverse_mass = @particle1.inverse_mass
+        
+        
+          unless( @particle2.nil? )
+            total_inverse_mass += @particle2.inverse_mass
+          end
+        
+          if( total_inverse_mass <= 0)
+            return
+          end
+        
+          impulse = delta_velocity / total_inverse_mass
+        
+          impulse_per_i_mass = @contact_normal * impulse
+        
+          @particle1.velocity = @particle1.velocity + ( impulse_per_i_mass * @particle1.inverse_mass )
+        
+          unless( @particle2.nil? )
+            @particle2.velocity = @particle2.velocity + (impulse_per_i_mass * -@particle2.inverse_mass )
+          end
+        
+        end
+    
+        def resolve_interpenetration(duration)
+          if(@penetration <= 0)
+            return
+          end
+        
+          total_inverse_mass = @particle1.inverse_mass
+          unless( @particle2.nil? )
+            total_inverse_mass += @particle2.inverse_mass
+          end
+        
+          if(total_inverse_mass <= 0)
+            return
+          end
+        
+          # Calculate the movement amounts.
+          move_per_i_mass = @contact_normal * (@penetration / total_inverse_mass)
+        
+          particle_movement_1 = move_per_i_mass * @particle1.inverse_mass
+          particle_movement_2 = Vector3.new
+        
+          unless( @particle2.nil? )
+            particle_movement_2 = move_per_i_mass * -@particle2.inverse_mass
+          else
+            particle_movement_2.clear()
+          end
+        
+          @particle1.position = @particle1.position + particle_movement_1
+        
+          unless( @particle2.nil? )
+            @particle2.position = @particle2.position + particle_movement_2
+          end
+        
+        end
+      end
+      
+    end
+  end
+end
+  
+      
+    
+      
+      
+