hate 0.1.0

data/lib/hate/graphics/manager.rb

@@ -0,0 +1,73 @@
+module Hate
+  module Graphics
+    module Manager
+      
+      @objects = []
+      @shaders = []
+      @lights  = []
+      @cameras = []
+      
+      def self.lights
+        @lights
+      end
+      
+      def self.run
+        @cameras.each do |obj|
+          obj.run
+        end
+
+        @objects.each do |obj|
+          obj.run
+        end
+        
+        @shaders.each do |obj|
+          obj.run
+        end
+        
+        @lights.each do |obj|
+          obj.run
+        end
+      end
+      
+      def self.add_object(obj)
+        @objects << obj
+      end
+      
+      def self.remove_object(obj)
+        @objects.delete obj
+      end
+      
+      def self.add_shader(obj)
+        @shaders << obj
+      end
+      
+      def self.remove_shader(obj)
+        @shaders.delete obj
+      end
+      
+      def self.add_light(obj)
+        @lights << obj
+      end
+      
+      def self.remove_light(obj)
+        @lights.delete obj
+      end
+      
+      def self.add_camera(obj)
+        @cameras << obj
+      end
+      
+      def self.remove_camera(obj)
+        @cameras.delete obj
+      end
+      
+      def self.default_camera
+        add_camera Hate::Graphics::Camera.new if @cameras.empty?
+        @cameras.each do |obj|
+          return obj if obj.is_default?
+        end
+      end
+      
+    end
+  end
+end

data/lib/hate/graphics/shader.rb

@@ -0,0 +1,61 @@
+module Hate
+  module Graphics
+    module Shader
+      
+      class Program
+        
+        def initialize
+          @program = glCreateProgram
+        end
+        
+        def attach(shader)
+          glAttachShader(@program, shader)
+          self
+        end
+        
+        def compile
+          glLinkProgram(@program)
+          self
+        end
+        
+        def run
+          glUseProgram(@program)
+        end
+        
+      end
+      
+      class Base
+        
+        attr_reader :shader
+        
+        def initialize(file)
+          source = []
+          source << MemoryPointer.from_string(File.open(file).read)
+          arg = MemoryPointer.new(:pointer, source.length)
+          source.each_with_index do |p, i|
+            arg[i].put_pointer(0, p)
+          end
+
+          if self.class == Hate::Graphics::Shader::Vertex
+            @shader = glCreateShader(GL_VERTEX_SHADER)
+          elsif self.class == Hate::Graphics::Shader::Fragment
+            @shader = glCreateShader(GL_FRAGMENT_SHADER)
+          end  
+          
+          glShaderSource(@shader, source.size, arg, nil)
+          glCompileShader(@shader)
+        end
+        
+      end
+      
+      class Vertex < Base
+        
+      end
+      
+      class Fragment < Base
+
+      end
+      
+    end
+  end
+end

data/lib/hate/graphics/shaders/lights/point.fragment

@@ -0,0 +1,31 @@
+varying vec4 diffuse,ambientGlobal, ambient;
+varying vec3 normal,lightDir,halfVector;
+varying float dist;
+
+void main()
+{
+	vec3 n,halfV,viewV,ldir;
+	float NdotL,NdotHV;
+	vec4 color = ambientGlobal;
+	float att;
+	/* a fragment shader can't write a varying variable, hence we need
+
+	a new variable to store the normalized interpolated normal */
+	n = normalize(normal);
+	/* compute the dot product between normal and normalized lightdir */
+
+	NdotL = max(dot(n,normalize(lightDir)),0.0);
+	if (NdotL > 0.0) {
+
+		att = 1.0 / (gl_LightSource[0].constantAttenuation +
+				gl_LightSource[0].linearAttenuation * dist +
+				gl_LightSource[0].quadraticAttenuation * dist * dist);
+		color += att * (diffuse * NdotL + ambient);
+		halfV = normalize(halfVector);
+
+		NdotHV = max(dot(n,halfV),0.0);
+		color += att * gl_FrontMaterial.specular * gl_LightSource[0].specular *
+						pow(NdotHV,gl_FrontMaterial.shininess);
+	}
+	gl_FragColor = color;
+}

data/lib/hate/graphics/shaders/lights/point.vertex

@@ -0,0 +1,27 @@
+varying vec4 diffuse,ambientGlobal,ambient;
+varying vec3 normal,lightDir,halfVector;
+varying float dist;
+
+void main()
+{
+	vec4 ecPos;
+	vec3 aux;
+	normal = normalize(gl_NormalMatrix * gl_Normal);
+
+        /* these are the new lines of code to compute the light's direction */
+	ecPos = gl_ModelViewMatrix * gl_Vertex;
+	aux = vec3(gl_LightSource[0].position-ecPos);
+	lightDir = normalize(aux);
+	dist = length(aux);
+	halfVector = normalize(gl_LightSource[0].halfVector.xyz);
+
+        /* Compute the diffuse, ambient and globalAmbient terms */
+	diffuse = gl_FrontMaterial.diffuse * gl_LightSource[0].diffuse;
+	/* The ambient terms have been separated since one of them */
+
+	/* suffers attenuation */
+	ambient = gl_FrontMaterial.ambient * gl_LightSource[0].ambient;
+	ambientGlobal = gl_LightModel.ambient * gl_FrontMaterial.ambient;
+	gl_Position = ftransform();
+
+}

data/lib/hate/graphics/shapes.rb

@@ -0,0 +1,118 @@
+module Hate
+  module Graphics
+    module Shapes
+      
+      class Base
+        
+        attr_accessor :memory, :size
+        attr_reader :x, :y, :z
+        attr_reader :ra, :rx, :ry, :rz
+        attr_reader :c
+        
+        def initialize(s=1.0)
+          @size = s
+          
+          @memory = nil
+          compile
+          
+          translate
+          rotate
+          color
+        end
+        
+        def translate(x=0.0, y=0.0, z=0.0)
+          @x, @y, @z = x, y, z
+          self
+        end
+        
+        def rotate(a=0.0, x=0.0, y=0.0, z=0.0)
+          @ra, @rx, @ry, @rz = a, x, y, z
+          self
+        end
+        
+        def color(r=0.0, g=0.0, b=0.0)
+          @c = [r, g, b]
+          self
+        end
+        
+        def compile
+          @memory = glGenLists(1) if @memory.nil?
+          glNewList(@memory, GL_COMPILE)
+          build
+          glEndList
+        end
+
+        def run
+          glLoadIdentity
+          glPushMatrix
+          glColor3f(@c[0], @c[1], @c[2])
+          glTranslatef(@x, @y, @z)
+          glRotatef(@ra, @rx, @ry, @rz)
+          @memory.nil? ? build : glCallList(@memory)
+          glPopMatrix
+        end
+        
+        def destroy
+          glDeleteLists(@memory)
+          @memory = nil
+        end
+        
+      end
+      
+      class Square < Base
+
+        def build
+          glutSolidCube(@size)
+        end
+
+      end
+      
+      class Cube < Base
+        
+        def build
+          glBegin(GL_QUADS)
+          
+          glNormal3f(0.0, 0.0, 1.0)
+          glVertex3f( @size, @size,-@size)
+          glVertex3f(-@size, @size,-@size)
+          glVertex3f(-@size, @size, @size)
+          glVertex3f( @size, @size, @size)
+          
+          glNormal3f(0.0, 0.0, -1.0)
+      		glVertex3f( @size,-@size, @size)
+      		glVertex3f(-@size,-@size, @size)
+      		glVertex3f(-@size,-@size,-@size)
+      		glVertex3f( @size,-@size,-@size)
+      		
+      		glNormal3f(0.0, 1.0, 0.0)
+      		glVertex3f( @size, @size, @size)
+      		glVertex3f(-@size, @size, @size)
+      		glVertex3f(-@size,-@size, @size)
+      		glVertex3f( @size,-@size, @size)
+          
+          glNormal3f(0.0, -1.0, 0.0)
+      		glVertex3f( @size,-@size,-@size)
+      		glVertex3f(-@size,-@size,-@size)
+      		glVertex3f(-@size, @size,-@size)
+      		glVertex3f( @size, @size,-@size)
+      		
+      		glNormal3f(1.0, 0.0, 0.0)
+      		glVertex3f(-@size, @size, @size)
+      		glVertex3f(-@size, @size,-@size)
+      		glVertex3f(-@size,-@size,-@size)
+      		glVertex3f(-@size,-@size, @size)
+      		
+      		glNormal3f(-1.0, 0.0, 0.0)
+      		glVertex3f(@size, @size,-@size)
+      		glVertex3f(@size, @size, @size)
+      		glVertex3f(@size,-@size, @size)
+      		glVertex3f(@size,-@size,-@size)
+          
+          glEnd
+        end
+
+      end
+      
+    end
+  end
+end

data/lib/hate/graphics/window.rb

@@ -0,0 +1,105 @@
+module Hate
+  module Graphics
+
+    DEFAULT_WIDTH      = 800
+    DEFAULT_HEIGHT     = 600
+    DEFAULT_COLOR      = nil
+    DEFAULT_BACKGROUND = nil
+    
+    class Window
+      
+      attr_reader :width, :height
+      attr_reader :frames
+
+      def initialize(w=nil, h=nil, title='New Game')
+        @width  = w || Hate::Graphics::DEFAULT_WIDTH
+        @height = h || Hate::Graphics::DEFAULT_HEIGHT
+        
+        @frames = 0
+        
+        if SDL.Init(SDL::INIT_EVERYTHING) == 0
+           SDL.EnableUNICODE(1)
+        else
+           throw Main::Graphics::SDLException, "SDL Exception: #{SDL.GetError()}"
+        end
+        SDL.SetVideoMode(@width, @height, 24, SDL::OPENGL)
+        SDL.Init(SDL::INIT_VIDEO)
+
+        glEnable(GL_DEPTH_TEST)
+        glEnable(GL_CULL_FACE)
+        glEnable(GL_COLOR_MATERIAL)
+        
+        glShadeModel(GL_SMOOTH)
+        glClearColor(1.0, 1.0, 1.0, 0.0)
+        glClearDepth(1.0)
+        glDepthFunc(GL_LEQUAL)
+        glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST) # Small performance hit
+        
+        # Hardware lights
+        Hate::Graphics::Manager.lights.each_with_index do |light, i|
+          glLightfv(eval("GL_LIGHT%i" % (i + 1)), GL_AMBIENT, light.ambient)
+          glLightfv(eval("GL_LIGHT%i" % (i + 1)), GL_DIFFUSE, light.diffuse)
+          glLightfv(eval("GL_LIGHT%i" % (i + 1)), GL_POSITION, light.position)
+          glEnable(eval("GL_LIGHT%i" % (i + 1)))
+        end
+        glEnable(GL_LIGHTING) if Hate::Graphics::Manager.lights.size > 0
+        
+        reshape(@width, @height)
+      end
+
+      def draw
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+        Hate::Core::Callbacks.draw
+        Hate::Graphics::Manager.run
+        SDL.GL_SwapBuffers()
+        @frames += 1
+      end
+
+      def reshape(x, y)
+        Hate::Graphics::Manager.default_camera.reshape(x, y)
+      end
+
+      def update
+        until (event = SDL::PollEvent()).nil?
+          events(event)
+        end
+        Hate::Core::Callbacks.update if @frames % 2 == 0 # Only call update every second cycle
+      end
+      
+      def events(event)
+        case event.type
+        when SDL::KEYDOWN
+          Hate::Input::Keyboard.pressed(event.keysym.sym)
+        when SDL::KEYUP
+          Hate::Input::Keyboard.released(event.keysym.sym)
+        when SDL::MOUSEBUTTONDOWN
+          Hate::Input::Mouse.pressed(event.x, event.y, event.button)
+        when SDL::MOUSEBUTTONUP
+          Hate::Input::Mouse.released(event.x, event.y, event.button)
+        when SDL::MOUSEMOTION
+          Hate::Input::Mouse.motion(event.x, event.y, event.xrel, event.yrel, event.state)
+        when SDL::VIDEORESIZE
+          reshape(event.w, event.h)
+        end
+      end
+      
+      def time
+        
+      end
+
+      def start
+        loop do
+          update
+          draw
+        end
+      end
+      
+      def quit
+        SDL.QuitSubSystem(SDL::INIT_VIDEO)
+        SDL.Quit
+      end
+
+    end
+
+  end
+end

data/lib/hate/input.rb

@@ -0,0 +1,35 @@
+module Hate
+  module Input
+    module Keyboard
+      
+      @key_states = Array.new(256)
+      
+      def self.pressed(k)
+        @key_states[k] = true
+        Hate::Core::Callbacks.keypressed(k)
+      end
+      
+      def self.released(k)
+        @key_states[k] = false
+        Hate::Core::Callbacks.keyreleased(k)
+      end
+      
+    end
+    
+    module Mouse
+      
+      def self.pressed(x, y, button)
+        Hate::Core::Callbacks.mousepressed(x, y, button)
+      end
+      
+      def self.released(x, y, button)
+        Hate::Core::Callbacks.mousereleased(x, y, button)
+      end
+      
+      def self.motion(x, y, xr, yr, state)
+        Hate::Core::Callbacks.mousemotion(x, y, xr, yr, state)
+      end
+      
+    end
+  end
+end