bulldog_physics 0.1.0

data/lib/Particles/particle_world.rb

@@ -0,0 +1,116 @@
+module BulldogPhysics
+  module Particles
+    module Collisions
+    
+
+      
+      # Keeps track of a set of particles, and provides the means to update them all.
+      class ParticleWorld
+      
+      
+        protected
+        
+
+        attr_accessor :resolver
+
+        attr_accessor :max_contacts
+        attr_accessor :calculate_iterations
+        
+        
+        public
+
+        attr_accessor :contact_generators
+        attr_accessor :contacts        
+        attr_accessor :particles
+        attr_accessor :registry
+
+        # Creates a new particle simulator that can handle up to the
+        # given number of contacts per frame. You can also optionally
+        # 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)
+          @max_contacts = max_contacts
+          @calculate_iterations = iterations
+          @particles = Array.new
+          @contacts = Array.new
+          @contact_generators = Array.new
+          @registry = ParticleForceRegistry.new
+          @resolver = ParticleContactResolver.new
+        end
+      
+        # Initializes the world for a simulation frame. This clears * the force accumulators for particles in the world. After
+        # calling this, the particles can have their forces for this * frame added.
+        def start_frame()
+          
+
+          @particles.each do |particle|
+            particle.clearAccumulator()
+          end
+        end
+        
+        # Calls each of the registered contact generators to report * their contacts. 
+        # Returns the number of generated contacts.
+        def generate_contacts()
+          limit = @max_contacts
+          
+          #if @contacts.size == 0
+          #  return 0
+          #end
+          
+          
+          for g in @contact_generators
+            used = g.add_contact(@contacts, limit)
+
+
+            limit -= used
+            # We’ve run out of contacts to fill. This means we’re missing // contacts.
+            if limit <= 0
+              break
+            end
+          end
+    
+          #return number of contacts used 
+          return @max_contacts - limit
+        end
+        
+        # Integrates all the particles in this world forward in time
+        # by the given duration.
+        def integrate(duration)
+          @particles.each{|p| p.integrate(duration)}
+        end
+        
+        def run_physics(duration)
+          
+          # check for colliding and hitting floor
+          
+          @contacts.clear
+
+          @registry.update_forces(duration)
+ 
+ 
+          integrate(duration)
+
+          used_contacts = generate_contacts()
+          
+          if(used_contacts > 0)
+            if(@calculate_iterations > 0)
+              @resolver.iterations = used_contacts * 2
+              @resolver.resolve_contacts(@contacts, used_contacts, duration)
+            end
+          end
+
+          #@resolver.resolve_contacts(@contacts, @contacts.size, duration)
+
+        end
+        
+        def add_gravity
+          gravity = ParticleGravity.new(Vector3.new(0, -0.5, 0))
+          @particles.each{|part| @registry.add(part, gravity)}
+        end
+        
+      end
+      
+      
+    end
+  end
+end

data/lib/Particles/projectile.rb

@@ -0,0 +1,15 @@
+module BulldogPhysics
+  module Particles
+    class Projectile
+  
+      attr_accessor :particle, :start_time
+
+      def initialize()
+        @particle = Particle.new
+        @start_time = 0
+      end
+  
+  
+    end
+  end
+end

data/lib/bulldog_physics.rb

@@ -0,0 +1,43 @@
+# make life easier by including all Physics files here
+require 'rubygems'
+require 'require_all'
+
+
+class VirtualMethodCalledError < RuntimeError
+	attr :name
+	def initialize(name)
+		super("Virtual function '#{name}' called")
+		@name = name
+	end
+end
+
+class Module
+	def virtual(*methods)
+		methods.each do |m|
+			define_method(m) {
+				raise VirtualMethodCalledError, m
+			}
+		end
+	end
+end
+
+require './vector3.rb'
+require './matrix3.rb'
+require './matrix4.rb'
+require './quaternion.rb'
+
+module BulldogPhysics
+	
+	def localToWorld(local, transform)
+		return tarnsform.transform(local)
+	end
+	
+	def worldToLocal(world, transform)
+		inverseTransform = Matrix4.new
+		inverseTransform.setInverse(transform)
+		return inverseTransform.transform(world)
+	end
+	
+end
+
+require_all 'Particles'

data/lib/examples/GlStuff/gl_utility.rb

@@ -0,0 +1,21 @@
+module GlStuff
+  class GlUtility
+
+    def self.draw_line(ax, ay, bx, by, width, r, g, b, a)
+      glDisable(GL_TEXTURE_2D);
+      #glEnable(GL_BLEND);
+      #glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+      glColor4ub( r, g, b, a);
+
+      glLineWidth(width);
+      glBegin(GL_LINES);
+      glVertex2i( ax, ay);
+      glVertex2i( bx, by);
+      glEnd();
+
+      #glDisable(GL_BLEND);
+      glEnable(GL_TEXTURE_2D);
+    end
+    
+  end
+end

data/lib/examples/GlStuff/lighting.rb

@@ -0,0 +1,35 @@
+module GlStuff
+  
+  class Lighting
+  
+    attr_accessor :ambient, :diffuse, :position, :lmodel_ambient, :no_mat, :mat_ambient, :mat_ambient_color, :mat_diffuse,
+                  :mat_specular, :no_shininess, :low_shininess, :high_shininess, :mat_emission, :local_view
+                
+
+    def initialize
+      @ambient = [ 0.0, 1.0, 0.0, 1.0 ]
+      @diffuse = [ 1.0, 1.0, 1.0, 1.0 ]
+      @position = [ 1.0, 5.0, 1.0, 0.0 ]
+      @lmodel_ambient = [ 0.4, 0.4, 0.4, 1.0 ]
+      @no_mat = [ 0.0, 0.0, 0.0, 1.0 ]
+      @mat_ambient = [ 0.7, 0.7, 0.7, 1.0 ]
+      @mat_ambient_color = [ 0.8, 0.8, 0.2, 1.0 ]
+      @mat_diffuse = [ 0.1, 0.5, 0.0, 1.0 ]
+      @mat_specular = [ 1.0, 1.0, 1.0, 1.0 ]
+      @no_shininess = [ 0.0 ]
+      @low_shininess = [ 5.0 ]
+      @high_shininess = [ 100.0 ]
+      @mat_emission = [0.3, 0.2, 0.2, 0.0]
+      @local_view = [ 0.0 ]
+    end
+  
+    def setup
+      glEnable(GL_LIGHTING)
+      glEnable(GL_LIGHT0)
+      glShadeModel(GL_SMOOTH);
+      glLightfv(GL_LIGHT0, GL_POSITION, @position)
+    end
+  
+  end
+  
+end

data/lib/examples/GlStuff/material.rb

@@ -0,0 +1,24 @@
+module GlStuff
+  class Material
+    
+    attr_accessor :ambient, :diffuse, :specular, :shininess, :emission
+    
+    def initialize()
+      @ambient = [ 0.7, 0.7, 0.7, 1.0 ]
+      @ambient_color = [ 0.8, 0.8, 0.2, 1.0 ]
+      @diffuse = [ 0.5, 0.5, 0.5, 1.0 ]
+      @specular = [ 1.0, 1.0, 1.0, 1.0 ]
+      @shininess = [ 0.0 ] # 0 is noe, 100 would be hide
+      @emission = [0.3, 0.2, 0.2, 0.0]
+    end
+    
+    def setup_material
+      glMaterial(GL_FRONT, GL_AMBIENT, @ambient)
+  	  glMaterial(GL_FRONT, GL_DIFFUSE, @diffuse)
+  	  glMaterial(GL_FRONT, GL_SPECULAR, @specular)
+  	  glMaterial(GL_FRONT, GL_SHININESS, @shininess)
+  	  glMaterial(GL_FRONT, GL_EMISSION, @emission)
+	  end
+  	
+	end
+end

data/lib/examples/GlStuff/terrain.rb

@@ -0,0 +1,216 @@
+class Terrain
+
+	attr_accessor :height_map_image, :terrain_grid_width, :terrain_grid_length, :terrain_normals
+
+	def initialize(surface)
+		@height_map_image = surface
+		@terrain_normals = Array.new
+		load_from_surface()
+		#compute_normals()
+	end
+
+	def load_from_surface
+		mode = @height_map_image.depth
+		puts mode
+		@terrain_grid_width = @height_map_image.width
+		@terrain_grid_length = @height_map_image.height
+		@terrain_heights = Array.new( @terrain_grid_width * @terrain_grid_length)
+		pixels = @height_map_image.pixels()
+		#puts pixels
+		puts pixels.size
+		for i in 0..@terrain_grid_length-1
+			for j in 0..@terrain_grid_width-1
+				#aux = mode * (i * @terrain_grid_width + j)
+				#index = aux + (mode - 1)
+				#puts@height_map_image.get_at(i,j)[1]
+				#if index < pixels.size
+					point_height = @height_map_image.get_at(i,j)[0] / 255.0
+					#puts point_height
+				#end
+				@terrain_heights[i * @terrain_grid_width + j] = point_height
+			end
+		end
+
+		for i in 0..10
+			#puts @terrain_heights[i * 1000]
+		end
+	end
+
+	def terrain_cross_product(x1, z1, x2, z2, x3, z3)
+		v1 = v2 =  aux = Vector3.new
+
+		v1.x = (x2 - x1 )
+		v1.y = -@terrain_heights[z1 * @terrain_grid_width + x1] + 
+					@terrain_heights[z2 * @terrain_grid_width + x2]
+		v1.z = (z2 - z1)
+
+		v2.x = (x3 - x1)
+		v2.y = -@terrain_heights[z1 * @terrain_grid_width + x1] + 
+					@terrain_heights[z3 * @terrain_grid_width + x3]
+		v2.z = (z3 - z1)
+
+		v1 -= v1.crossProduct(v2)
+	end
+
+	def create_display_list(x_offset, y_offset, z_offset)
+		
+		start_w = (@terrain_grid_width / 2.0) - @terrain_grid_width
+		start_l = (-@terrain_grid_length / 2.0) + @terrain_grid_length
+
+		terrain_dl = glGenLists(1)
+		
+		glNewList(terrain_dl, GL_COMPILE)
+
+		for i in 0..(@terrain_grid_length - 2)
+			glBegin(GL_TRIANGLE_STRIP)
+			for j in 0..(@terrain_grid_width - 2)
+
+				unless @terrain_normals.empty?
+					glNormal3f(@terrain_normals[3*((i+1)*@terrain_grid_width)],
+							   @terrain_normals[3*((i+1)*@terrain_grid_width)+1],
+							   @terrain_normals[3*((i+1)*@terrain_grid_width)+2] )
+				end
+				glVertex3f(
+					start_w + j,
+					@terrain_heights[(i+1)*@terrain_grid_width + (j)],
+					start_l - (i+1)
+				)			
+
+				unless @terrain_normals.empty?
+					glNormal3f(@terrain_normals[3*(i+@terrain_grid_width + j)],
+							   @terrain_normals[3*(i+@terrain_grid_width + j)+1],
+							   @terrain_normals[3*(i+@terrain_grid_width + j)+2] )
+				end
+
+				aux = 3 * ((i+1) * @terrain_grid_length + j)
+				glVertex3f( (start_w + j),
+							@terrain_heights[(i * @terrain_grid_width) + j],
+							(start_l - i)
+							)
+			end
+			glEnd()
+		end
+
+		glEndList()
+
+		terrain_dl
+	end
+	
+
+	def terrain_scale(minnum, maxnum)
+		if minnum > maxnum
+			aux = minnum
+			minnum = maxnum
+			maxnum = aux
+		end
+
+		amp = maxnum - minnum
+
+		total = @terrain_grid_width * @terrain_grid_length
+
+		min_val = @terrain_heights.min
+		max_val = @terrain_heights.max
+		for i in 0..total-2
+			height = (@terrain_heights[i] - min_val) / (max_val -	 min_val)
+			if height == nil
+				next
+			end
+			@terrain_heights[i] = (height * amp) - minnum
+			#puts @terrain_heights[i]
+		end
+
+		compute_normals()
+	end
+
+	def compute_normals
+		 norm1,norm2 = Vector3.new, Vector3.new
+		 @terrain_normals = Array.new(@terrain_grid_width * @terrain_grid_length * 3)
+	
+		return if @terrain_normals.nil?
+		
+
+
+		for i in 0..@terrain_grid_length - 1
+			for j in 0..@terrain_grid_width - 1
+				norm1.clear
+				norm2.clear
+				if i == 0 && j == 0
+					norm1 = terrain_cross_product(0,0, 0,1, 1,0)
+					norm1.normalize()
+				elsif j == @terrain_grid_width-1 && i == @terrain_grid_length-1
+					norm1 = terrain_cross_product(j,i, j,i-1, j-1,i)
+					norm1.normalize()
+				elsif j == 0 && i == @terrain_grid_length-1
+					norm1 = terrain_cross_product(j,i, j,i-1, j+1, i)
+					norm1.normalize()
+				elsif j == @terrain_grid_width - 1 && i == 0
+					norm1 = terrain_cross_product(j,i, j,i+1, j-1,i)
+				elsif i == 0
+					norm1 = terrain_cross_product(j,0, j-1,0, j,1)
+					norm1.normalize
+					norm2 = terrain_cross_product(j,0, j,1, j+1,0)
+					norm2.normalize
+					norm1 += norm2
+				elsif j == 0
+					norm1 = terrain_cross_product(0,i, 1,i, 0,i-1)
+					norm1.normalize
+					norm2 = terrain_cross_product(j,0, j,1, j+1,0)
+					norm2.normalize
+					norm1 += norm2
+				elsif i == @terrain_grid_length-1
+					norm1 = terrain_cross_product(j,i, j,i-1, j+1,i);
+					norm1.normalize
+					norm2 = terrain_cross_product(j,i, j+1,i, j,i-1);
+					norm2.normalize
+					norm1 += norm2
+				elsif (j == @terrain_grid_width-1)
+					norm1 = terrain_cross_product(j,i, j,i-1, j-1,i);
+					norm1.normalize
+					norm2 = terrain_cross_product(j,i, j-1,i, j,i+1);
+					norm2.normalize
+					norm1 += norm2;
+				else
+					norm1 = terrain_cross_product(j,i, j-1,i, j-1,i+1).unit
+					norm2 = terrain_cross_product(j,i, j-1,i+1, j,i+1).unit
+					norm1 += norm2;
+
+					norm2 = terrain_cross_product(j,i, j,i+1, j+1,i+1).unit
+					norm1 += norm2;
+					
+					norm2 = terrain_cross_product(j,i, j+1,i+1, j+1,i).unit
+					norm1 += norm2
+
+					norm2 = terrain_cross_product(j,i, j+1,i, j+1,i-1).unit
+					norm1 += norm2
+
+					norm2 = terrain_cross_product(j,i, j+1,i-1, j,i-1).unit
+					norm1 += norm2
+
+					norm2 = terrain_cross_product(j,i, j,i-1, j-1,i-1).unit
+					norm1 += norm2
+
+					norm2 = terrain_cross_product(j,i, j-1,i-1, j-1,i).unit
+					norm1 += norm2
+				end
+				
+				norm1.normalize			
+				norm1.z = - norm1.z
+
+				component = 0
+				for k in 0..3 
+					case k
+					when 0
+						component = norm1.x
+					when 1
+						component = norm1.y
+					when 2
+						component = norm1.z
+					end
+					@terrain_normals[3*(i*@terrain_grid_width + j) + k] = component;
+				end
+			end
+		end
+	end
+
+
+end