bulldog_physics 0.1.0

data/lib/matrix4.rb

@@ -0,0 +1,230 @@
+module BulldogPhysics
+	class Matrix4
+	
+			attr_accessor :data
+	
+	
+			def initialize()
+				@data = [ 1, 0, 0, 0, 
+					0, 1, 0, 0,
+					0, 0, 1, 0 ] 
+			end
+	
+			def *(vector)
+	
+	
+				if( @data.size < 8)
+					raise Exception.new("@data not big enough for vector math")
+				end
+	
+				if( vector.kind_of? Matrix4)
+					o = vector.dup
+	
+					result = Matrix4.new
+					result.data[0] = (o.data[0]*@data[0]) + (o.data[4]*@data[1]) + (o.data[8]*@data[2]);
+					result.data[4] = (o.data[0]*@data[4]) + (o.data[4]*@data[5]) + (o.data[8]*@data[6]);
+					result.data[8] = (o.data[0]*@data[8]) + (o.data[4]*@data[9]) + (o.data[8]*@data[10]);
+			
+					result.data[1] = (o.data[1]*@data[0]) + (o.data[5]*@data[1]) + (o.data[9]*@data[2]);
+					result.data[5] = (o.data[1]*@data[4]) + (o.data[5]*@data[5]) + (o.data[9]*@data[6]);
+					result.data[9] = (o.data[1]*@data[8]) + (o.data[5]*@data[9]) + (o.data[9]*@data[10]);
+			
+					result.data[2] = (o.data[2]*@data[0]) + (o.data[6]*@data[1]) + (o.data[10]*@data[2]);
+					result.data[6] = (o.data[2]*@data[4]) + (o.data[6]*@data[5]) + (o.data[10]*@data[6]);
+					result.data[10] = (o.data[2]*@data[8]) + (o.data[6]*data[9]) + (o.data[10]*@data[10]);
+			
+					result.data[3] = (o.data[3]*@data[0]) + (o.data[7]*@data[1]) + (o.data[11]*@data[2]) + @data[3];
+					result.data[7] = (o.data[3]*@data[4]) + (o.data[7]*@data[5]) + (o.data[11]*@data[6]) + @data[7];
+					result.data[11] = (o.data[3]*@data[8]) + (o.data[7]*@data[9]) + (o.data[11]*@data[10]) + @data[11];
+					return result;
+				else
+					return Vector3.new(
+							vector.x * @data[0] +  \
+							vector.y * @data[1] + \
+							vector.z * @data[2] + @data[3],\
+							vector.x * @data[4] + \
+							vector.y * @data[5] + \
+							vector.z * @data[6] + @data[7], \
+							vector.x * @data[8] + \
+							vector.y * @data[9] + \
+							vector.z * @data[10] + @data[11]\
+					)
+				end
+	
+	
+			end
+	
+	
+			# Sets the matrix to be the inverse of the given matrix.
+			# @param m The matrix to invert and use to set this.
+			def setInverse(m)
+				#Make sure the determinant is non-zero.
+				det = getDeterminant();
+				if (det == 0) 
+					return
+				end
+				
+				det = 1.0/det;
+				
+				@data[0] = (-m.data[9]*m.data[6]+m.data[5]*m.data[10])*det;
+				@data[4] = (m.data[8]*m.data[6]-m.data[4]*m.data[10])*det;
+				@data[8] = (-m.data[8]*m.data[5]+m.data[4]*m.data[9])*det;
+				
+				@data[1] = (m.data[9]*m.data[2]-m.data[1]*m.data[10])*det;
+				@data[5] = (-m.data[8]*m.data[2]+m.data[0]*m.data[10])*det;
+				@data[9] = (m.data[8]*m.data[1]-m.data[0]*m.data[9])*det;
+				
+				@data[2] = (-m.data[5]*m.data[2]+m.data[1]*m.data[6])*det;
+				@data[6] = (+m.data[4]*m.data[2]-m.data[0]*m.data[6])*det;
+				@data[10] = (-m.data[4]*m.data[1]+m.data[0]*m.data[5])*det;
+				
+				@data[3] = (m.data[9]*m.data[6]*m.data[3]
+									 -m.data[5]*m.data[10]*m.data[3]
+									 -m.data[9]*m.data[2]*m.data[7]
+									 +m.data[1]*m.data[10]*m.data[7]
+									 +m.data[5]*m.data[2]*m.data[11]
+									 -m.data[1]*m.data[6]*m.data[11])*det;
+				@data[7] = (-m.data[8]*m.data[6]*m.data[3]
+									 +m.data[4]*m.data[10]*m.data[3]
+									 +m.data[8]*m.data[2]*m.data[7]
+									 -m.data[0]*m.data[10]*m.data[7]
+									 -m.data[4]*m.data[2]*m.data[11]
+									 +m.data[0]*m.data[6]*m.data[11])*det;
+				@data[11] =(m.data[8]*m.data[5]*m.data[3]
+									 -m.data[4]*m.data[9]*m.data[3]
+									 -m.data[8]*m.data[1]*m.data[7]
+									 +m.data[0]*m.data[9]*m.data[7]
+									 +m.data[4]*m.data[1]*m.data[11]
+									 -m.data[0]*m.data[5]*m.data[11])*det;
+			end
+			# Returns a new matrix containing the inverse of this matrix. */
+			def inverse
+				result = Matrix3.new
+				result.setInverse(self);
+				return result
+			end
+	
+			def transformDirection(vector)
+				Vector3.new(
+						vector.x * @data[0] +
+						vector.y * @data[1] +
+						vector.z * @data[2],
+	
+						vector.x * @data[4] +
+						vector.y * @data[5] +
+						vector.z * @data[6],
+	
+						vector.x * @data[8] +
+						vector.y * @data[9] +
+						vector.z * @data[10]
+				);
+			end
+	
+			def transformInverseDirection(vector)
+					Vector3.new(
+							vector.x * @data[0] +
+							vector.y * @data[4] +
+							vector.z * @data[8],
+	
+							vector.x * @data[1] +
+							vector.y * @data[5] +
+							vector.z * @data[9],
+	
+							vector.x * @data[2] +
+							vector.y * @data[6] +
+							vector.z * @data[10]
+					);
+			end
+	
+	
+			def transformInverse(vector)
+					tmp = vector.dup;
+					tmp.x -= @data[3];
+					tmp.y -= @data[7];
+					tmp.z -= @data[11];
+					Vector3.new(
+							tmp.x * @data[0] +
+							tmp.y * @data[4] +
+							tmp.z * @data[8],
+	
+							tmp.x * @data[1] +
+							tmp.y * @data[5] +
+							tmp.z * @data[9],
+	
+							tmp.x * @data[2] +
+							tmp.y * @data[6] +
+							tmp.z * @data[10]
+					)
+			end
+	
+			# Fills the given array with this transform matrix, so it is
+			# usable as an open-gl transform matrix. OpenGL uses a column
+			# major format, so that the values are transposed as they are
+			# written.
+			def getGLArray()
+				array = Array.new
+				array[0] = @data[0];
+				array[1] = @data[4];
+				array[2] = @data[8];
+				array[3] = 0;
+	
+				array[4] = @data[1];
+				array[5] = @data[5];
+				array[6] = @data[9];
+				array[7] = 0;
+	
+				array[8] = @data[2];
+				array[9] = @data[6];
+				array[10] = @data[10];
+				array[11] = 0;
+	
+				array[12] = @data[3];
+				array[13] = @data[7];
+				array[14] = @data[11];
+				array[15] = 1;
+				return array
+			end
+			
+			def getAxisVector(i)
+				Vector3.new(@data[i], @data[i+4], @data[i+8]);
+			end
+			
+			def setOrientationAndPos(q, pos)
+				@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] = pos.x;
+				
+				@data[4] = 2*q.i*q.j - 2*q.k*q.r;
+				@data[5] = 1 - (2*q.i*q.i  + 2*q.k*q.k);
+				@data[6] = 2*q.j*q.k + 2*q.i*q.r;
+				@data[7] = pos.y;
+				
+				@data[8] = 2*q.i*q.k + 2*q.j*q.r;
+				@data[9] = 2*q.j*q.k - 2*q.i*q.r;
+				@data[10] = 1 - (2*q.i*q.i  + 2*q.j*q.j);
+				@data[11] = pos.z;
+			end
+	
+			# Inverts the matrix.
+			def invert()
+				setInverse(self)
+			end
+	
+	
+			def transform(vector)
+				self * vector
+			end
+			
+			def getDeterminant
+				return @data[8]*@data[5]*@data[2]+
+				@data[4]*@data[9]*@data[2]+
+				@data[8]*@data[1]*@data[6]-
+				@data[0]*@data[9]*@data[6]-
+				@data[4]*@data[1]*@data[10]+
+				@data[0]*@data[5]*@data[10];
+			end
+			
+		end
+end
+		

data/lib/quaternion.rb

@@ -0,0 +1,86 @@
+module BulldogPhysics
+	class Quaternion
+		
+		#attr :data
+		attr_accessor :r, :i, :j, :k
+		
+		def initialize(r = 1.0, i =0, j = 0, k = 0)
+			@r, @i, @j, @k = r, i, j, k
+		end
+		
+		def intialize(r, i, j, k)
+			@r = r
+			@i = i
+			@j = j
+			@k = k
+		end
+				
+		def data=(data)
+			@r = data[0]
+			@i = data[1]
+			@j = data[2]
+			@k = data[3]
+		end
+		
+		def data
+			[@r, @i, @j, @k]
+		end	
+	
+		def *(multiplier)
+			q = self
+			r = q.r*multiplier.r - q.i*multiplier.i -
+					q.j*multiplier.j - q.k*multiplier.k
+			i = q.r*multiplier.i + q.i*multiplier.r + 
+					q.j*multiplier.k - q.k*multiplier.j
+			j = q.r*multiplier.j + q.j*multiplier.r +
+					q.k*multiplier.i - q.i*multiplier.k;
+			k = q.r*multiplier.k + q.k*multiplier.r +
+					q.i*multiplier.j - q.j*multiplier.i;
+			Quaternion.new( r, i, j, k )
+		end
+		
+		def normalize()
+			d = (@r*@r) + (@i*@i) + (@j*@j) + (@k*@k)
+			
+			if( d == 0)
+				@r = 1
+				return
+			end
+			#return if d.nan?
+			begin
+			d = (1.0 / Math.sqrt(d))
+		rescue 
+			puts "FUCK D IS #{d}"
+		end
+			@r *= d
+			@i *= d
+			@j *= d
+			@k *= d
+		end
+		
+		def addScaledVector(vector, scale)
+	
+			q = Quaternion.new(0,
+					vector.x * scale,
+					vector.y * scale,
+					vector.z * scale)
+					
+			q *= self;
+			@r += q.r * 0.5
+			@i += q.i * 0.5
+			@j += q.j * 0.5
+			@k += q.k * 0.5
+		end
+		
+		def rotateByVector(vector)
+			q = Quaternion.new( 0, vector.x, vector.y, vector.z)
+			new_q = self * q
+			@r = q.r
+			@i = q.i
+			@j = q.j
+			@k = q.k
+		end
+		
+	end
+end
+		

data/lib/vector3.rb

@@ -0,0 +1,155 @@
+module BulldogPhysics
+  
+  class Vector3
+     
+     attr_accessor :x, :y, :z
+     attr_reader :pad #padding to ensure four world alignment
+   
+     ## create Vertex, defaults all to zero
+     def initialize(x = 0,y = 0,z = 0)
+       @x = x
+       @y = y
+       @z = z
+     end
+   
+     ## flip the components
+     def invert
+       @x = -@x
+       @y = -@y
+       @z = -@z
+     end  
+   
+     ## Gets the magnitude of this vector.
+     def magnitude
+      num = (@x*@x) + (@y * @y) + (@z * @z)
+      return 0 if num.nan?
+       Math.sqrt((@x*@x)+(@y*@y)+(@z*@z))
+     end
+   
+     def squareMagnitude
+       return (@x*@x)+(@y*@y)+(@z*@z)
+     end
+   
+     ## Turns a non-zero vector into a vector of unit length.
+     def normalize
+       length = self.magnitude
+       if length > 0
+         @x /= length
+         @y /= length
+         @z /= length
+       end
+     end
+   
+     def unit
+       length = self.magnitude
+       if length > 0
+         x = @x * (1.0 / length)
+         #x = @x / length
+         y = @y * (1.0 / length)
+         #y = @y / length
+         #z = @z / length
+         z = @z * (1.0 / length) 
+         return Vector3.new(x,y,z)
+       else
+         return Vector3.new
+       end
+     end
+   
+     def addScaledVector(v, scalar)
+       @x += (v.x * scalar)
+       @y += (v.y * scalar)
+       @z += (v.z * scalar)
+     end
+   
+     def componentProduct(v)
+       Vector3.new(@x * v.x, @y * v.y, @z * v.z)
+     end
+   
+     def componentProductUpdate(v)
+       @x *= v.x
+       @y *= v.y
+       @z *= v.z
+       self
+     end
+   
+     def scalarProduct(v)
+       (@x * v.x) + (@y * v.y) + (@z * v.z)
+     end 
+   
+     def crossProduct(v)
+       Vector3.new( (@y * v.z) - (@z * v.y),
+                    (@z * v.x) - (@x * v.z),
+                    (@x * v.y) - (@y * v.x))
+     end
+   
+     def crossProductUpdate(v)
+       new_v = vectorProduct(v)
+       @x = new_v.x
+       @y = new_v.y
+       @z = new_v.z
+     end
+   
+     def *(scalar)
+       if scalar.kind_of? Float
+        Vector3.new(@x*scalar, @y*scalar, @z*scalar)
+       elsif scalar.kind_of? Vector3
+        return @x * scalar.x + @y * scalar.y + @z * scalar.z
+       end 
+     end
+   
+     def +(v)
+       Vector3.new(@x + v.x, @y + v.y, @z + v.z)
+     end
+   
+     def vector_product(vector)
+        Vector3.new(@y*vector.z - @z*vector.y,
+                @z*vector.x - @x*vector.z,
+                @x*vector.y - @y*vector.x)
+
+     end
+
+      #Updates this vector to be the vector product of its current
+      # => value and the given vector.
+     def %(vector)
+        vector_product(vector)
+     end
+     def addVector(v)
+       @x += v.x
+       @y += v.y
+       @z += v.z
+       self
+     end
+     
+     def multiplyByScalar(scalar)
+       @x *= scalar
+       @y *= scalar
+       @z *= scalar
+     end
+   
+     def subtractVector(v)
+       @x -= v.x
+       @y -= v.y
+       @z -= v.z
+     end
+     
+     def divideByScalar(scalar)
+       @x *= scalar
+       @y *= scalar
+       @z *= scalar
+     end
+     
+     def -(v)
+       Vector3.new(@x - v.x, @y - v.y, @z - v.z)
+     end
+   
+     def clear
+       @x, @y, @z = 0,0,0
+     end
+
+     def to_s
+       "(#{@x},#{@y},#{@z})"
+     end
+   
+   end
+ 
+ end