bulldog_physics 0.1.1 → 0.2.0

data/lib/Particles/particle_contact.rb

@@ -29,18 +29,18 @@ module BulldogPhysics
         end
     
         def calculate_separating_velocity
-          relative_velocity = @particle1.velocity
+          relative_velocity = @particle1.velocity.dup
           unless @particle2.nil?
             relative_velocity -= @particle2.velocity
           end
-          return relative_velocity.scalarProduct(@contact_normal)
+          return relative_velocity * @contact_normal
         end
       
       
         private
       
         def resolve_velocity(duration)
-        
+
           #Find the velocity in the direction of the contact.
           separating_velocity = calculate_separating_velocity()
         
@@ -49,19 +49,32 @@ module BulldogPhysics
             # The contact is either separating, or stationary; there’s no impulse required.
             return
           end
+
           new_sep_velocity = -separating_velocity * @restitution
+
+
+          acc_caused_velocity = @particle1.acceleration.dup
+
+          unless @particle2.nil?
+            acc_caused_velocity -= @particle2.acceleration
+          end
+
+          acc_caused_velocity = acc_caused_velocity * @contact_normal * duration;
+
+          if acc_caused_velocity < 0
+            new_sep_velocity += @restitution * acc_caused_velocity
+            new_sep_velocity = 0 if new_sep_velocity < 0
+          end
+
           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
+          return if( total_inverse_mass <= 0)
         
           impulse = delta_velocity / total_inverse_mass
         
@@ -76,9 +89,9 @@ module BulldogPhysics
         end
     
         def resolve_interpenetration(duration)
-          if(@penetration <= 0)
-            return
-          end
+          
+          return if(@penetration <= 0)
+            
         
           total_inverse_mass = @particle1.inverse_mass
           unless( @particle2.nil? )

data/lib/Particles/particle_contact_resolver.rb

@@ -24,15 +24,15 @@ module BulldogPhysics
           
             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) )
+              if( sep_vel < max && ( sep_vel < 0 || contact.penetration > 0) )
                 max = sep_vel
                 max_index = i
               end
             end
         
-            if( max_index.eql? num_contacts)
-              break
-            end
+
+            break if( max_index.eql? num_contacts)
+
         
             contact_array[max_index].resolve(duration)
         

data/lib/Particles/particle_drag.rb

@@ -13,7 +13,7 @@ module BulldogPhysics
         end
 
         def update_force(particle, duration)
-          force = particle.velocity
+          force = particle.velocity.dup
 
           dragCoeff = force.magnitude
 

data/lib/Particles/particle_rod.rb

@@ -1,4 +1,4 @@
-module BulldogPhysics
+  module BulldogPhysics
   module Particles
     module Collisions
     
@@ -19,8 +19,8 @@ module BulldogPhysics
       
         # * 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
-          
+          current_len = current_length
+
           if( current_len == @length)
             return 0
           end
@@ -28,18 +28,19 @@ module BulldogPhysics
           
           contact = ParticleContact.new(@particle1, @particle2)
   
-                    
+          normal = @particle2.position - @particle1.position
+          normal.normalize
           # The contact normal depends on whether we’re extending or compressing.
           
+          contact.contact_normal = normal
+
           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
           

data/lib/Particles/particle_world.rb

@@ -29,6 +29,7 @@ module BulldogPhysics
         # give a number of contact-resolution iterations to use. If you * don’t give a number of iterations, then twice the number of
         # contacts will be used.
         def initialize(max_contacts = 100, iterations = 1)
+          puts "INIT WORLD"
           @max_contacts = max_contacts
           @calculate_iterations = iterations
           @particles = Array.new

data/lib/RigidBodies/Gravity.rb

@@ -0,0 +1,18 @@
+module BulldogPhysics
+	class Gravity < ForceGenerator
+
+		attr :gravity # vector3 accel do to gravity
+
+		def initialize(grav)
+			@gravity = grav
+		end
+
+		def update_force(body, duration)
+			#return if body.hasFiniteMass
+
+			body.add_force(gravity * body.mass)
+		end
+
+
+	end
+end

data/lib/RigidBodies/buoyancy.rb

@@ -0,0 +1,32 @@
+module BulldogPhysics
+	class Buoyancy < ForceGenerator
+
+		attr_accessor :max_depth, :volume, :water_height, :liquid_density, :center_of_buoyancy
+
+		def initialize(c_of_b, max_depth, volume, water_height, liquid_density = 1000.0)
+			@center_of_buoyancy, @max_depth, @volume, @water_height, @liquid_density =
+				c_of_b, max_depth, volume, water_height, liquid_density
+		end
+
+		def update_force(body, duration)
+			point_in_world = body.get_point_in_world_space(@center_of_buoyancy)
+			depth = point_in_world.y
+
+			if(depth >= @water_height + @max_depth)
+				return
+			end
+
+			force = Vector3.new
+
+			if depth <= @water_height - @max_depth
+				force.y = @liquid_density * @volume
+				body.add_force_at_point(force, @center_of_buoyancy)
+				return
+			end
+
+			force.y = @liquid_density * @volume * (depth - @max_depth - @water_height) / (2 * @max_depth)
+			body.add_force_at_point(force, @center_of_buoyancy)
+
+		end
+	end
+end

data/lib/RigidBodies/collision_shapes.rb

@@ -0,0 +1,256 @@
+module BulldogPhysics
+	
+	class CollisionPrimitive
+
+		attr_accessor :body, :offset
+		
+		
+		def initialize()
+			#puts "INIT"
+			@body = RigidBody.new
+			@offset = Matrix4.new
+			@transform = Matrix4.new
+		end
+
+		attr :transform
+
+		def calculate_internals()
+			#puts "OFFSET #{@offset}"
+			@transform = @body.transform_matrix * @offset
+		end
+
+		def get_axis(index)
+			@transform.getAxisVector(index)
+		end
+
+		def get_transform
+			@transform
+		end
+	end
+
+
+	class CollisionSphere < CollisionPrimitive
+		attr_accessor :radius
+
+		def initialize()
+			super()
+			@radius = 1
+		end
+	end
+
+
+	class CollisionPlane
+		attr_accessor :direction, :offset
+
+		def initialize(direction = Vector3.new, offset = 0.0)
+			@direction = direction
+			@offset = offset
+		end
+	end
+
+	class CollisionBox < CollisionPrimitive
+
+		attr_accessor :half_size
+
+		def initialize(half_size = Vector3.new)
+			super()
+			@half_size = half_size
+		end
+	end
+
+
+	class CollisionData
+		attr_accessor :contacts, :current_contact, :contacts_count, :friction, :restitution, :tolerance, :contacts_left
+
+		def initialize()
+			@contacts = Array.new
+			@current_contact = @contacts_count = @contacts_left = 0
+			@friction = @restitution = @tolerance = 0.0
+		end
+
+		def has_more_contacts()
+			@contacts_left > 0
+		end
+
+		def reset(max_contacts)
+			@contacts_left = max_contacts
+			@contacts_count = 0
+			@current_contact = 0
+		end
+
+		def add_contacts(count)
+			@contacts_left -= count
+			@contacts_count += count
+
+			@current_contact += count
+		end
+
+	end
+
+	def transform_to_axis(box, axis)
+		return box.half_size.x * (axis * box.get_axis(0)).abs + \
+		box.half_size.y * (axis * box.get_axis(1)).abs + \
+		box.half_size.z * (axis * box.get_axis(2)).abs
+	end
+
+	def overlap_on_axis(one, two, axis, to_centre)
+		one_project = transform_to_axis(one, axis)
+		two_project = transform_to_axis(two, axis)
+
+		distance = (to_centre * axis).abs
+
+		distance < one_project + two_project	
+	end
+
+	class IntersectionTests
+
+		def self.sphere_and_half_space(sphere, plane)
+
+			ball_distance = plane.direction * sphere.get_axis(3) - sphere.radius
+
+			ball_distance <= plane.offset
+		end
+
+		def self.sphere_and_sphere(one, two)
+
+			mid_line = one.get_axis(3) - two.get_axis(3)
+
+			return mid_line.sqaureMagnitude < (one.radius + two.radius) * (one.radius + two.radius)
+		end
+
+		def self.box_and_box(one, two)
+
+			to_center = two.get_axis(3) - one.get_axis(3)
+
+			return 	overlap_on_axis(one,two,one.getAxis(0), to_center) && \
+        			overlap_on_axis(one,two,one.getAxis(1), to_center) && \
+        			overlap_on_axis(one,two,one.getAxis(2), to_center) && \
+        			overlap_on_axis(one,two,two.getAxis(0), to_center) && \
+        			overlap_on_axis(one,two,two.getAxis(1), to_center) && \
+        			overlap_on_axis(one,two,two.getAxis(2), to_center) && \
+        			overlap_on_axis(one,two,one.getAxis(0) % two.getAxis(0), to_center) && \
+			        overlap_on_axis(one,two,one.getAxis(0) % two.getAxis(1), to_center) && \
+			        overlap_on_axis(one,two,one.getAxis(0) % two.getAxis(2), to_center) && \
+			        overlap_on_axis(one,two,one.getAxis(1) % two.getAxis(0), to_center) && \
+			        overlap_on_axis(one,two,one.getAxis(1) % two.getAxis(1), to_center) && \
+			        overlap_on_axis(one,two,one.getAxis(1) % two.getAxis(2), to_center) && \
+			        overlap_on_axis(one,two,one.getAxis(2) % two.getAxis(0), to_center) && \
+			        overlap_on_axis(one,two,one.getAxis(2) % two.getAxis(1), to_center) && \
+			        overlap_on_axis(one,two,one.getAxis(2) % two.getAxis(2), to_center)
+		end
+
+		def self.box_and_half_space(box, plane)
+			projection_radius = transform_to_axis( box, plane.direction)
+			box_distance = plane.direction * box.get_axis(3) - projection_radius
+			box_distance < plane.offset 
+		end
+
+	end
+
+	class CollisionDetector
+
+		def self.sphere_and_half_space(sphere, plane, contacts)
+			#eturn 0 if(data.contacts_left <= 0)
+
+			position = sphere.get_axis(3)
+
+			ball_distance = plane.direction * position - sphere.radius - plane.offset
+
+			puts "ball distance"
+			return 0 if ball_distance >= 0
+
+			contact = Contact.new
+			contact.contact_normal = plane.direction
+			contact.penetration = -ball_distance
+			contact.contact_point = position - plane.direction * (ball_distance + sphere.radius)
+			contact.set_body_data(sphere.body, nil, 0.9, 0.6)
+			contacts << contact
+			return 1
+		end
+
+		def self.sphere_and_sphere(one, two, contatcs)
+
+			positionOne = one.get_axis(3)
+			positionTwo = two.get_axis(3)
+
+			midline = positionOne - positionTwo
+
+			size = midline.magnitude 
+
+			if size <= 0.0 || size >= one.radius + two.radius
+				return 0
+			end
+
+			normal = midline * (1.0/size)
+
+			contact = Contact.new
+			contact.normal = normal
+			contact.contact_point = positionOne + midline * 0.5
+			contact.penetration = one.radius + two.radius - size
+			contact.set_body_data( one.body, two.body, 0.9, 0.6)
+			contatcs << contact
+			return 1
+		end
+
+		def self.box_and_box(one, two, data)
+
+			to_center = two.get_axis(3) - one.get_axis(3)
+			puts "NOT DONE YET"
+			return 	overlap_on_axis(one,two,one.getAxis(0), to_center) && \
+        			overlap_on_axis(one,two,one.getAxis(1), to_center) && \
+        			overlap_on_axis(one,two,one.getAxis(2), to_center) && \
+        			overlap_on_axis(one,two,two.getAxis(0), to_center) && \
+        			overlap_on_axis(one,two,two.getAxis(1), to_center) && \
+        			overlap_on_axis(one,two,two.getAxis(2), to_center) && \
+        			overlap_on_axis(one,two,one.getAxis(0) % two.getAxis(0), to_center) && \
+			        overlap_on_axis(one,two,one.getAxis(0) % two.getAxis(1), to_center) && \
+			        overlap_on_axis(one,two,one.getAxis(0) % two.getAxis(2), to_center) && \
+			        overlap_on_axis(one,two,one.getAxis(1) % two.getAxis(0), to_center) && \
+			        overlap_on_axis(one,two,one.getAxis(1) % two.getAxis(1), to_center) && \
+			        overlap_on_axis(one,two,one.getAxis(1) % two.getAxis(2), to_center) && \
+			        overlap_on_axis(one,two,one.getAxis(2) % two.getAxis(0), to_center) && \
+			        overlap_on_axis(one,two,one.getAxis(2) % two.getAxis(1), to_center) && \
+			        overlap_on_axis(one,two,one.getAxis(2) % two.getAxis(2), to_center)
+		end
+
+		def self.box_and_half_space(box, plane, contacts)
+			#return 0 if data.contacts_left <= 0
+
+			#return 0 unless IntersectionTests.box_and_half_space(box,plane)
+
+			mults = [ [1,1,1] , [-1,1,1] , [1,-1,1] , [-1,-1,1] , \
+					   [1,1,-1] , [-1,1,-1], [1,-1,-1] , [-1,-1,-1]]
+
+			contacts_used = 0
+
+			#contact = contacts[contacts_used]
+
+			for i in 0..7
+				vertexPos = Vector3.new(mults[i][0], mults[i][1], mults[i][2]);
+        		vertexPos.componentProductUpdate(box.half_size);
+        		vertexPos = box.transform.transform(vertexPos);
+        		vertexDistance = vertexPos * plane.direction;
+	
+        		if(vertexDistance <= plane.offset)
+        					puts "test"
+        			contact = Contact.new
+        			contact.contact_point = plane.direction
+        			contact.contact_point *= (vertexDistance - plane.offset)
+        			contact.contact_point = vertexPos # ??????
+        			contact.contact_normal = plane.direction
+        			contact.penetration = plane.offset - vertexDistance
+
+        			contacts_used+=1
+        			contact.set_body_data(box.body, nil, 0.9, 0.6)
+        			contacts << contact
+        			#contact = data.contacts[contacts_used]
+        			#return contacts_used if contacts_used == data.contacts_left
+        		end
+        	end
+
+        	#data.add_contacts(contacts_used)
+        	return contacts_used
+		end
+
+	end
+end