bulldog_physics 0.1.0

data/lib/examples/simple_game.rb

@@ -0,0 +1,289 @@
+require 'rubygems'
+require 'rubygame'
+begin
+  require 'opengl'
+  include Gl,Glu,Glut
+rescue LoadError
+  puts "ATTENTION: This demo requires the opengl extension for ruby."
+  raise
+end
+
+require 'bulldog_physics'
+
+require_all 'GlStuff'
+
+include BulldogPhysics
+include BulldogPhysics::Particles
+include BulldogPhysics::Particles::Generators
+include BulldogPhysics::Particles::Collisions
+include Rubygame
+include GlStuff
+
+ROD_SPECULAR = [1.0, 0.0, 0.0, 0.5]
+BALL_SPECULAR = [1.0, 0.0, 1.0, 0.5]
+SPRING_SPECULAR = [0.0, 1.0, 0.0, 0.5]
+ANCHORED_SPECULAR = [0.0, 0.0, 1.0, 0.5]
+ANCHOR_SPECULAR = [ 0.0, 0.5, 1.0, 0.5]
+PARTICLE_DIFFUSE = [1.0, 0.0, 0.0, 0.5]
+SCALE = 500.0
+BULLET_LIFE = 20000.0
+class Game
+  
+
+  GRAVITATIONAL_CONST = 6.673 * (10 ** -4)
+
+  START_POSITION = Vector3.new(0.75,15,0)
+
+  SMOOTH = true
+  def initialize(width,height)
+    
+    @width = width
+    @height = height
+    @queue = EventQueue.new
+    @queue.enable_new_style_events
+    @clock = Clock.new
+    @lighting = Lighting.new
+    @x_trans = 0; @y_trans = -5; @z_trans = -25
+    @font = TTF.new "/Library/Fonts/Times New Roman.ttf",point_size
+    
+    @world = ParticleWorld.new(20, 1)
+    
+
+
+    @anchor = Particle.new
+    @anchor.mass = 1
+    @anchor.position = Vector3.new(-5,0,0)
+    @anchor.damping = 1
+    @anchor.velocity = Vector3.new(0,0.0,0)
+    @anchor.material.specular = ANCHOR_SPECULAR
+    @anchor.material.diffuse = PARTICLE_DIFFUSE
+    
+    #@world.add_gravity()  
+    
+    
+    @ball = Particle.new
+    @ball.mass = 1
+    @ball.position = START_POSITION.dup
+    @ball.damping = 1
+    @ball.material.specular = BALL_SPECULAR
+    @ball.material.diffuse = PARTICLE_DIFFUSE
+		@ball.frozen = true
+    		
+    
+    @current_ball = Particle.new
+    @current_ball.position = @ball.position
+    @current_ball.velocity = @ball.velocity
+    @current_ball.mass = @ball.mass
+    @current_ball.damping = @ball.damping
+    @current_ball.frozen = true
+    @world.registry.add( @current_ball, ParticleGravity.new())
+    @world.particles << @current_ball
+   
+   	 
+   particle1 = Particle.new
+   particle1.mass = 1
+   particle1.position = Vector3.new(5,2,0)
+   particle1.damping = 1
+   particle1.velocity = Vector3.new(0,2.0,0)
+   particle1.material.specular = ANCHOR_SPECULAR
+   particle1.material.diffuse = PARTICLE_DIFFUSE
+   
+   particle2 = Particle.new
+   particle2.mass = 1
+   particle2.position = Vector3.new(0,2,0)
+   particle2.damping = 1
+   particle2.velocity = Vector3.new(0,0.0,0)
+   particle2.material.specular = ANCHOR_SPECULAR
+   particle2.material.diffuse = PARTICLE_DIFFUSE
+   
+   prod = ParticleRod.new(particle1, particle2, 2.0)
+   
+   #@world.particles << particle1 
+   #@world.particles << particle2
+		#@world.contact_generators << prod
+   
+   	@world.contact_generators << ParticleGroundContacts.new(@world.particles)
+   	@world.contact_generators << ParticleParticleContacts.new(@world.particles)
+   
+    for i in 1..5
+	    for j in 1..5
+		    part = Particle.new
+		    part.mass = 0
+		    offset = j % 2 == 0 ? 1 : 0
+		    part.position = Vector3.new( -5 + i * 2 + offset, j * 2, 0)
+		    part.material.specular = SPRING_SPECULAR
+		    part.material.diffuse = PARTICLE_DIFFUSE
+		    @world.particles << part
+		  end
+		end
+		
+
+    puts "PARTICLE COUNT [ #{@world.particles.size} ] "
+    puts "Contact Generators count: #{@world.contact_generators.size}"
+    
+    
+    @w_down, @a_down, @s_down, @d_down = false, false, false, false
+    
+  end
+
+  def init_game()
+    Rubygame.init
+
+    Rubygame::GL.set_attrib(Rubygame::GL::RED_SIZE, 5)
+    Rubygame::GL.set_attrib(Rubygame::GL::GREEN_SIZE, 5)
+    Rubygame::GL.set_attrib(Rubygame::GL::BLUE_SIZE, 5)
+    Rubygame::GL.set_attrib(Rubygame::GL::DEPTH_SIZE, 16)
+    Rubygame::GL.set_attrib(Rubygame::GL::DOUBLEBUFFER, 1)
+		
+	@maximum_resolution = Screen.get_resolution
+    @screen = Screen.new([@width,@height], 16, [OPENGL])
+    @clock.target_framerate = 30
+    @clock.calibrate
+    @clock.enable_tick_events
+    ObjectSpace.garbage_collect
+      
+    glViewport( 0, 0, WIDE, HIGH )
+    glMatrixMode( GL::PROJECTION )
+    glLoadIdentity( )
+    #GLU::Perspective( -35, WIDE/(HIGH.to_f), 0.5, 30.0)
+    GLU::Perspective( 45, WIDE/(HIGH.to_f), 0.5, 100.0)
+    glMatrixMode( GL::MODELVIEW )
+    glLoadIdentity( )
+    
+
+    
+    @lighting.setup
+    
+    glShadeModel (GL_SMOOTH);
+    glEnable(GL::DEPTH_TEST)
+    glEnable(GL_LIGHTING)
+    glEnable(GL_LIGHT0)
+    glDepthFunc(GL::LESS)
+    
+
+      
+  end
+
+  
+  def run()
+    catch(:rubygame_quit) do
+    	loop do
+    		@queue.each do |event|
+    			case event
+    			when Rubygame::Events::KeyPressed
+#            puts event.key
+    				case event.key
+    				when :escape
+    					throw :rubygame_quit 
+    				when :q
+    					throw :rubygame_quit 
+    				when :w
+    				  @w_down = true
+    			  when :s
+    			    @s_down = true 
+    		    when :a
+    		      @a_down = true
+    	      when :d
+    	        @d_down = true
+		        when :l
+		          @world.particles.each do |part|
+		            puts part.position
+		            puts "NUM CONTACTS: #{@world.contacts.size}"
+	            end
+    	      when :space
+	    	      @current_ball.frozen = !@current_ball.frozen
+            when :r
+	            puts "RESET"
+	            @current_ball = Particle.new
+	            @current_ball.position = START_POSITION.dup
+	            @current_ball.velocity = @ball.velocity.dup
+	            @current_ball.mass = @ball.mass
+	            @current_ball.damping = @ball.damping
+	            @current_ball.frozen = true
+	            @world.registry.add( @current_ball, ParticleGravity.new())
+	            @world.particles << @current_ball
+            end
+          when Rubygame::Events::KeyReleased
+            case event.key
+            when :w
+              @w_down = false
+            when :a
+              @a_down = false
+            when :d
+              @d_down = false
+            when :s
+              @s_down = false
+            end
+          when Rubygame::Events::MouseMoved
+             puts "Mouse moved to #{event.rel.inspect} with #{event.buttons.inspect} pressed"
+             if( event.buttons.include? :mouse_right )
+               puts "mouse_right"
+               @current_ball.position.x += event.rel[0] / 100.0
+               @current_ball.position.y -= event.rel[1] / 100.0
+             end
+          when Rubygame::Events::QuitRequested
+            throw :rubygame_quit
+          end
+        end
+
+        if @w_down;@current_ball.position.y += 0.01; end;
+        if @s_down;@current_ball.position.y -= 0.01; end;
+        if @a_down;@current_ball.position.x -= 0.01; end;
+        if @d_down;@current_ball.position.x += 0.01; end;
+
+        @time_elapsed = @clock.tick()
+        @time_alive = @clock.lifetime
+        seconds_elapsed = @time_elapsed.milliseconds / 1000.0
+        @world.start_frame
+
+        glClearColor(0.0, 0.0, 0.0, -1.0)
+    	glClear(GL::COLOR_BUFFER_BIT|GL::DEPTH_BUFFER_BIT)
+        glLoadIdentity()
+        
+        glTranslatef(@x_trans,@y_trans,@z_trans)
+
+        glPushMatrix()
+           glBegin(GL_QUADS)
+           glVertex3f(-1000, -1 , 1000)
+           glVertex3f(-1000, -1, -1000)
+           glVertex3f(1000, -1, -1000)
+           glVertex3f(1000, -1, 1000)
+           glEnd
+        glPopMatrix()
+
+        
+        draw_skybox()
+
+        #glClear(GL::COLOR_BUFFER_BIT|GL::DEPTH_BUFFER_BIT)
+        @world.particles.each do |particle|
+          p = particle.position
+          glPushMatrix()
+          glTranslatef(p.x, p.y, p.z)
+          particle.material.setup_material()
+          glutSolidSphere(particle.radius, 16, 16)
+          glPopMatrix()
+        end
+
+        @world.run_physics(seconds_elapsed)
+
+    	Rubygame::GL.swap_buffers()
+		@screen.update
+        @screen.flip
+    	ObjectSpace.garbage_collect
+
+    	end
+    end
+  
+  end
+    
+end
+
+
+REAL_MAX = 10000000
+WIDE = 1280
+HIGH = 1024
+
+
+game = Game.new(WIDE, HIGH)
+game.init_game
+game.run

data/lib/matrix3.rb

@@ -0,0 +1,242 @@
+module BulldogPhysics
+
+	class Matrix3
+		
+		
+		attr_accessor :data
+		
+		
+		def initialize(*args)
+		  @data = Array.new
+
+		  if(args.size == 0)
+		    @data = [ 0, 0, 0, \
+							    0, 0, 0, \
+							    0, 0, 0]
+			elsif( args[0].is_a? Float)			
+		    @data = [ args[0], args[1], args[2],\
+  							  args[3], args[4], args[5],\
+  								args[6], args[7], args[8]]
+		  elsif( args[0].is_a? Vector3)
+		      setComponents(args[0], args[1], args[2])
+		  end
+		end
+		
+
+		
+		def *(vector)
+			
+			if( @data.size < 8)
+				raise Exception.new("@data not big enough for vector math")
+			end
+
+			if( vector.is_a? Matrix3)
+				o = vector.dup
+				return Matrix3.new(@data[0]*o.data[0] + @data[1]*o.data[3] + @data[2]*o.data[6], @data[0]*o.data[1] + @data[1]*o.data[4] + @data[2]*o.data[7], @data[0]*o.data[2] + @data[1]*o.data[5] + @data[2]*o.data[8], \
+				                   @data[3]*o.data[0] + @data[4]*o.data[3] + @data[5]*o.data[6], @data[3]*o.data[1] + @data[4]*o.data[4] + @data[5]*o.data[7], @data[3]*o.data[2] + @data[4]*o.data[5] + @data[5]*o.data[8], \
+				                   @data[6]*o.data[0] + @data[7]*o.data[3] + @data[8]*o.data[6], @data[6]*o.data[1] + @data[7]*o.data[4] + @data[8]*o.data[7], @data[6]*o.data[2] + @data[7]*o.data[5] + @data[8]*o.data[8] )
+			elsif vector.is_a? Float
+				scalar = vector
+				return Matrix3.new(@data[0] * scalar, @data[1] * scalar, @data[2] * scalar, \
+								   @data[3] * scalar, @data[4] * scalar, @data[5] * scalar, \
+								   @data[6] * scalar, @data[7] * scalar, @data[8] * scalar)
+			else
+				
+			  return Vector3.new( (vector.x * @data[0]) + (vector.y * @data[1]) + (vector.z * @data[2]) , \
+											vector.x * @data[3] + vector.y * @data[4] + vector.z * @data[5] , \
+											vector.x * @data[6] + vector.y * @data[7] + vector.z * @data[8])
+			end
+
+		end
+		
+		def +(o)
+			Matrix3.new( 
+				@data[0] + o.data[0], @data[1] + o.data[1], @data[2] + o.data[2], \
+				@data[3] + o.data[3], @data[4] + o.data[4], @data[5] + o.data[5], \
+				@data[6] + o.data[6], @data[7] + o.data[7], @data[8] + o.data[8] \
+			  )
+		end
+		
+		def multiplyByMatrix(o)
+			o = o.dup
+			
+			t1 = @data[0]*o.data[0] + @data[1]*o.data[3] + @data[2]*o.data[6]; 
+			t2 = @data[0]*o.data[1] + @data[1]*o.data[4] + @data[2]*o.data[7]; 
+			t3 = @data[0]*o.data[2] + @data[1]*o.data[5] + @data[2]*o.data[8]; 
+			@data[0] = t1;
+			@data[1] = t2; 
+			@data[2] = t3;
+			t1 = @data[3]*o.data[0] + @data[4]*o.data[3] + @data[5]*o.data[6]; 
+			t2 = @data[3]*o.data[1] + @data[4]*o.data[4] + @data[5]*o.data[7]; 
+			t3 = @data[3]*o.data[2] + @data[4]*o.data[5] + @data[5]*o.data[8]; 
+			@data[3] = t1;
+			@data[4] = t2; 
+			@data[5] = t3;
+			t1 = @data[6]*o.data[0] + @data[7]*o.data[3] + @data[8]*o.data[6]; 
+			t2 = @data[6]*o.data[1] + @data[7]*o.data[4] + @data[8]*o.data[7];
+			t3 = @data[6]*o.data[2] + @data[7]*o.data[5] + @data[8]*o.data[8]; 
+			@data[6] = t1;
+			@data[7] = t2;
+			@data[8] = t3;
+		end
+		
+		def multiplyByScalar(scalar)
+			@data[0] *= scalar; @data[1] *= scalar; @data[2] *= scalar;
+			@data[3] *= scalar; @data[4] *= scalar; @data[5] *= scalar;
+			@data[6] *= scalar; @data[7] *= scalar; @data[8] *= scalar;
+		end
+		
+		def transform(vector)
+			self * vector
+		end
+		
+		def transformTranspose(vector)
+			Vector3.new(
+					vector.x * @data[0] + vector.y * @data[3] + vector.z * @data[6],
+					vector.x * @data[1] + vector.y * @data[4] + vector.z * @data[7],
+					vector.x * @data[2] + vector.y * @data[5] + vector.z * @data[8]
+			)
+		end
+		
+		def setOrientation(q)
+			@data[0] = 1 - (2*q.j*q.j + 2*q.k*q.k);
+			@data[1] = 2*q.i*q.j + 2*q.k*q.r;
+			@data[2] = 2*q.i*q.k - 2*q.j*q.r;
+			@data[3] = 2*q.i*q.j - 2*q.k*q.r;
+			@data[4] = 1 - (2*q.i*q.i  + 2*q.k*q.k);
+			@data[5] = 2*q.j*q.k + 2*q.i*q.r;
+			@data[6] = 2*q.i*q.k + 2*q.j*q.r;
+			@data[7] = 2*q.j*q.k - 2*q.i*q.r;
+			@data[8] = 1 - (2*q.i*q.i  + 2*q.j*q.j);
+		end
+		
+		def getAxisVector(i)
+			Vector3.new( @data[i], @data[i+3], @data[i+6])
+		end
+		
+		
+		def setInverse(m)
+			t4 = m.data[0]*m.data[4];
+			t6 = m.data[0]*m.data[5];
+			t8 = m.data[1]*m.data[3];
+			t10 = m.data[2]*m.data[3];
+			t12 = m.data[1]*m.data[6];
+			t14 = m.data[2]*m.data[6];
+			
+			# Calculate the determinant
+			t16 = (t4*m.data[8] - t6*m.data[7] - t8*m.data[8]+
+									t10*m.data[7] + t12*m.data[5] - t14*m.data[4]);
+			
+			# Make sure the determinant is non-zero.
+			if (t16 == 0.0) 
+				return
+			end
+			
+			t17 = 1/t16;
+			
+			@data[0] = (m.data[4]*m.data[8]-m.data[5]*m.data[7])*t17;
+			@data[1] = -(m.data[1]*m.data[8]-m.data[2]*m.data[7])*t17;
+			@data[2] = (m.data[1]*m.data[5]-m.data[2]*m.data[4])*t17;
+			@data[3] = -(m.data[3]*m.data[8]-m.data[5]*m.data[6])*t17;
+			@data[4] = (m.data[0]*m.data[8]-t14)*t17;
+			@data[5] = -(t6-t10)*t17;
+			@data[6] = (m.data[3]*m.data[7]-m.data[4]*m.data[6])*t17;
+			@data[7] = -(m.data[0]*m.data[7]-t12)*t17;
+			@data[8] = (t4-t8)*t17;
+		end
+		
+		def inverse()
+			result = Matrix3.new
+			result.setInverse(self)
+			return result
+		end
+		
+		def invert()
+			setInverse(self)
+		end
+		
+		def setTranspose(m)
+			@data[0] = m.data[0];
+			@data[1] = m.data[3];
+			@data[2] = m.data[6];
+			@data[3] = m.data[1];
+			@data[4] = m.data[4];
+			@data[5] = m.data[7];
+			@data[6] = m.data[2];
+			@data[7] = m.data[5];
+			@data[8] = m.data[8];
+		end
+
+
+		def transform_transpose(vector)
+			return Vector3.new(
+                vector.x * @data[0] + vector.y * @data[3] + vector.z * @data[6],
+                vector.x * @data[1] + vector.y * @data[4] + vector.z * @data[7],
+                vector.x * @data[2] + vector.y * @data[5] + vector.z * @data[8]
+            );
+        end
+		
+		def transpose()
+			result = Matrix3.new
+			result.setTranspose(self)
+			return result
+		end
+		
+		def setDiagonal(a, b, c)
+			setInertiaTensorCoeffs(a, b, c)
+		end
+		
+		def setInertiaTensorCoeffs(ix, iy, iz, ixy = 0, ixz = 0,iyz = 0)
+			@data[0] = ix;
+			@data[1] = @data[3] = -ixy;
+			@data[2] = @data[6] = -ixz;
+			@data[4] = iy;
+			@data[5] = @data[7] = -iyz;
+			@data[8] = iz;
+		end
+	
+	
+		def setBlockInertiaTensor(vHalfSizes, mass)
+			squares = vHalfSizes.componentProduct(vHalfSizes)
+			setInertiaTensorCoeffs(0.3 * mass * (squares.y + squares.z),
+														 0.3 * mass * (squares.x + squares.z),
+														 0.3 * mass * (squares.x + squares.y))
+		end
+		
+		def setSkewSymmetric(vector)
+			@data[0] = @data[4] = @data[8] = 0;
+			@data[1] = -vector.z;
+			@data[2] = vector.y;
+			@data[3] = vector.z;
+			@data[5] = -vector.x;
+			@data[6] = -vector.y;
+			@data[7] = vector.x;
+		end
+		
+		def setComponents(vCompOne, vCompTwo, vCompThree)
+			@data[0] = vCompOne.x
+			@data[1] = vCompTwo.x
+			@data[2] = vCompThree.x
+			@data[3] = vCompOne.y
+			@data[4] = vCompTwo.y
+			@data[5] = vCompThree.y
+			@data[6] = vCompOne.z
+			@data[7] = vCompTwo.z
+			@data[8] = vCompThree.z
+		end
+		
+		def self.linearInterpolate(a, b, prop)
+				result = Matrix3.new
+				for i in 0..9
+					result.data[i] = a.data * (1-prop) + b.data[i] * prop
+				end
+				return result
+		end
+		
+		def to_s
+			"[ #{@data[0]} #{@data[1]} #{@data[2]}\n \ #{@data[3]} #{@data[4]} #{@data[5]}\n \ #{@data[6]} #{@data[7]} #{@data[8]} ]"
+		end
+		
+	end
+	
+end