bulldog_physics 0.1.0

data/lib/Particles/particle_contact_generator.rb

@@ -0,0 +1,28 @@
+module BulldogPhysics
+  module Particles
+    module Collisions
+    
+
+      
+      # Links connect two particles together, generating a contact if * they violate the constraints of their link. It is used as a
+      # base class for cables and rods, and could be used as a base
+      # class for springs with a limit to their extension.
+      
+      class ParticleContactGenerator
+      
+        # Fills the given contact structure with the generated
+        # contact. The contact pointer should point to the first
+        # available contact in a contact array, where limit is the
+        # maximum number of contacts in the array that can be written * to. The method returns the number of contacts that have
+        # been written.
+        #def add_contact(contact, limit)
+        #end
+
+      
+        
+      end
+      
+      
+    end
+  end
+end

data/lib/Particles/particle_contact_resolver.rb

@@ -0,0 +1,49 @@
+module BulldogPhysics
+  module Particles
+    module Collisions
+    
+      REAL_MAX = 10000000
+      # The contact resolution routine for particle contacts. 
+      # One resolver instance can be shared for the entire simulation.
+      class ParticleContactResolver
+      
+        attr_accessor :iterations
+        attr_accessor :iterations_used
+      
+        def initialize(iters = 2)
+          @iterations = iters
+          @iterations_used = 0  
+        end
+      
+        def resolve_contacts(contact_array, num_contacts, duration)
+        
+          max_index = num_contacts
+          max = REAL_MAX
+          @iterations_used = 0
+          while( @iterations_used < @iterations )
+          
+            contact_array.each_with_index do |contact, i|
+              sep_vel = contact.calculate_separating_velocity  
+              if( sep_vel < max and ( sep_vel < 0 or contact.penetration > 0) )
+                max = sep_vel
+                max_index = i
+              end
+            end
+        
+            if( max_index.eql? num_contacts)
+              break
+            end
+        
+            contact_array[max_index].resolve(duration)
+        
+            @iterations_used += 1
+          end # end while
+          contact_array
+        end # end resolve_contacts
+      
+      end
+      
+      
+    end
+  end
+end

data/lib/Particles/particle_drag.rb

@@ -0,0 +1,30 @@
+module BulldogPhysics
+  module Particles
+    module Generators
+
+      class ParticleDrag < ParticleForceGenerator
+        attr :kl # holds the velocity drag coefficient
+        attr :k2 # holds the velocity squared drag coefficient
+
+        def initialize(k1,k2)
+          super
+          @k1 = k1
+          @k2 = k2
+        end
+
+        def update_force(particle, duration)
+          force = particle.velocity
+
+          dragCoeff = force.magnitude
+
+          dragCoeff = k1 * dragCoeff + k2 * dragCoeff * dragCoeff
+
+          force.normalize
+          force *= -dragCoeff
+          particle.addForce(force)
+        end
+      end
+      
+    end
+  end
+end

data/lib/Particles/particle_force_generator.rb

@@ -0,0 +1,23 @@
+module BulldogPhysics
+  module Particles
+    module Generators
+
+      # A force generator can be asked to add a force to one or more particles.
+      class ParticleForceGenerator
+  
+        attr_accessor :registrations
+  
+        def initialize
+          @registrations = Array.new # array of ParticleForceRegistration(s)
+        end
+  
+        # Overload this in implementations of the interface to calculate 
+        # and update the force applied to the given particle.
+        def update_force(particle, duration)
+        end
+  
+      end
+      
+    end 
+  end
+end

data/lib/Particles/particle_force_registration.rb

@@ -0,0 +1,15 @@
+module BulldogPhysics
+  module Particles
+    
+    # Keeps track of one force generator and the particle it applies to.
+    class ParticleForceRegistration
+      attr_accessor :particle, :particle_force_generator
+  
+      def initialize()
+        @particle = Particle.new
+        @particle_force_generator = ParticleForceGenerator.new
+      end
+    end
+    
+  end
+end

data/lib/Particles/particle_force_registry.rb

@@ -0,0 +1,50 @@
+module BulldogPhysics
+  module Particles
+
+    class ParticleForceRegistry
+      attr_accessor :registrations
+  
+      def initialize()
+        @registrations = Array.new # array of ParticleForceRegistration(s)
+      end
+  
+      # Registers the given force generator to apply to the 
+      # given particle.
+      def add(particle, force_generator)
+        particle_registration = ParticleForceRegistration.new
+        particle_registration.particle = particle
+        particle_registration.particle_force_generator = force_generator
+        @registrations << particle_registration
+        puts "Registration count #{@registrations.count}"
+      end
+  
+  
+      # Removes the given registered pair from the registry.
+      # If the pair is not registered, this method will have
+      # no effect.
+      def remove(particle,force_generator)
+        @registrations.remove_if do |registry|
+          registry.particle.eql? particle and registry.force_generator.eql? force_generator
+        end
+      end
+  
+      ### Clears all registrations from the registry. This will
+      ### not delete the particles or the force generators
+      ### themselves, just the records of their connection.
+      def clear
+        @registrations = Array.new
+      end
+  
+  
+      #Calls all the force generators to update the forces of
+      #their corresponding particles.
+      def update_forces(duration)
+        for registry in @registrations
+          registry.particle_force_generator.update_force(registry.particle,duration)
+        end
+      end
+
+    end
+    
+  end
+end

data/lib/Particles/particle_gravity.rb

@@ -0,0 +1,31 @@
+module BulldogPhysics
+  module Particles
+    module Generators
+      
+      # A force generator that applies a gravitational force. One instance * can be used for multiple particles.
+      class ParticleGravity < ParticleForceGenerator
+        attr_accessor :gravity
+
+        def initialize(gravityForce = Vector3.new(0,-9.8,0))
+          #super if defined?(super)
+          @gravity = gravityForce # vector3
+          super()
+        end
+  
+        #override
+        def update_force(particle, duration)
+          unless particle.has_infinite_mass
+            #puts "update_force"
+            #puts particle.mass
+            force_to_add = @gravity * particle.mass
+            particle.addForce(@gravity * particle.mass)
+            #puts particle.object_id
+          end
+          particle
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/Particles/particle_ground_contacts.rb

@@ -0,0 +1,43 @@
+module BulldogPhysics
+	module Particles
+  		module Collisions
+  			
+			class ParticleGroundContacts < ParticleContactGenerator 
+				
+				attr :particles
+				
+				def initialize(particles)
+					@particles = particles
+				end
+				
+				def add_contact(contactArray, limit)
+					
+					count = 0
+					@particles.each do |p|
+						
+						y = p.position.y
+						
+						if y < 0.0
+							contact = ParticleContact.new(p, nil)
+							contact.penetration = (p.position - Vector3.new(p.position.x, 0, p.position.z)).magnitude.abs - p.radius
+							contact.restitution = 0.2
+							contactArray << contact
+							count+=1
+						end
+						
+						
+						if( count >= limit)
+							return count
+						end
+						
+					end
+					
+					return count
+
+				end
+				
+				
+			end
+		end
+	end
+end

data/lib/Particles/particle_link.rb

@@ -0,0 +1,41 @@
+module BulldogPhysics
+  module Particles
+    module Collisions
+    
+      
+      # Links connect two particles together, generating a contact if * they violate the constraints of their link. It is used as a
+      # base class for cables and rods, and could be used as a base
+      # class for springs with a limit to their extension.
+      
+      class ParticleLink < ParticleContactGenerator
+      
+        attr_accessor :particle1
+        attr_accessor :particle2
+      
+        def initialize(particle1, particle2)
+          @particle1 = particle1
+          @particle2 = particle2
+        end
+        
+        # Generates the contacts to keep this link from being
+        # violated. This class can only ever generate a single
+        # contact, so the pointer can be a pointer to a single
+        # element, the limit parameter is assumed to be at least 1
+        # (0 isn’t valid), and the return value is 0 if the
+        # cable wasn’t overextended, or 1 if a contact was needed. *
+        # NB: This method is declared in the same way (as pure
+        # virtual) in the parent class, but is replicated here for
+        # documentation purposes.
+        
+        virtual :add_contact
+        
+        protected
+        
+        virtual :current_length
+        
+      end
+      
+      
+    end
+  end
+end

data/lib/Particles/particle_particle_contacts.rb

@@ -0,0 +1,48 @@
+module BulldogPhysics
+	module Particles
+		module Collisions
+
+
+
+			class ParticleParticleContacts < ParticleContactGenerator 
+
+				attr :particles
+
+				def initialize(particles)
+					@particles = particles
+				end
+
+				def add_contact(contactArray, limit)
+
+					count = 0
+					@particles.each do |p|
+
+
+						other_particles = @particles.select{|x| x.object_id != p.object_id}
+						other_particles.each do |other|
+							
+							if (p.position - other.position).magnitude < (p.radius + other.radius)
+								contact = ParticleContact.new(p, other)
+								contact.penetration = (p.position - other.position).magnitude - (p.radius + other.radius)
+								contact.restitution = 0.5
+								contactArray << contact
+								count+=1
+							end
+						end
+
+
+						if( count >= limit)
+							return count
+						end
+
+					end
+
+					return count
+
+				end
+
+
+			end
+		end
+	end
+end

data/lib/Particles/particle_rod.rb

@@ -0,0 +1,58 @@
+module BulldogPhysics
+  module Particles
+    module Collisions
+    
+      
+      # Cables link a pair of particles, generating a contact if they stray too far apart.
+      class ParticleRod < ParticleLink
+      
+      
+        # Holds the length of the rod
+        attr_accessor :length
+        
+      
+        def initialize(particle1, particle2, length)
+          super(particle1, particle2)
+          @length = length
+          puts "CREATING ROD WITH LENGTH #{@length}"
+        end
+      
+        # * Fills the given contact structure with the contact needed to keep the rod from extending or compressing.
+        def add_contact(contactArray, limit)
+          current_len = (@particle1.position - @particle2.position).magnitude
+          
+          if( current_len == @length)
+            return 0
+          end
+          
+          
+          contact = ParticleContact.new(@particle1, @particle2)
+  
+                    
+          # The contact normal depends on whether we’re extending or compressing.
+          
+          if( current_len > @length)
+            contact.penetration = (current_len - @length)
+            #contact.penetration = -1
+          else
+            contact.contact_normal *= -1
+            contact.penetration = @length - current_len
+            #contact.penetration = 1
+          end
+          
+          contact.restitution = 0
+          contactArray << contact
+          
+          return 1
+        end
+        
+        def current_length
+          (@particle1.position - @particle2.position).magnitude
+        end
+      
+      end
+      
+      
+    end
+  end
+end

data/lib/Particles/particle_spring.rb

@@ -0,0 +1,44 @@
+module BulldogPhysics
+  module Particles
+    module Generators
+    
+      class ParticleSpring < ParticleForceGenerator
+      
+        attr_accessor :other_particle # particle at other end of the spring
+        attr_accessor :spring_constant
+        attr_accessor :rest_length  # rest length of the string
+      
+      
+        def initialize(other, spring_const, rest_len)
+          @other_particle = other
+          @spring_constant = spring_const
+          @rest_length = rest_len
+        end
+      
+        def update_force(particle, duration)
+        
+          #calculate vector of the spring
+          force = particle.position.dup
+
+          force.subtractVector(@other_particle.position)
+          # calculate magnitude of the force
+          magnitude = force.magnitude
+          magnitude = (magnitude - @rest_length).abs
+          magnitude *= @spring_constant
+          
+          #calculate final force and apply it
+          force.normalize
+
+          force.multiplyByScalar(-magnitude)
+          particle.addForce(force)
+          
+        end
+      
+    
+    
+      end
+    
+    
+    end
+  end
+end