hate 0.1.0

data/README.md

@@ -0,0 +1,95 @@
+# Hate 3d
+
+A Ruby 3d OpenGL game library inspired by the Lua [Love](http://love2d.org/) project, a fun little 2d game engine.
+
+The project name `hate` is a parody of the inspiration.
+
+Other inspirational Ruby game projects worth checking out (and much, much more feature complete, albeit only 2d).
+
+* [Rubygame](http://rubygame.org/)
+* [Gosu](http://www.libgosu.org/)
+
+## Installation
+
+    gem install hate
+  
+## Usage
+
+Your game requires a `main.rb` file at the root of your game directory which `hate` will execute.  There is an example game located in the example folder which shows how the basic methods of the system work.  At the moment you must wrap all the methods in a module like so.
+
+    module Hate
+      module Game
+        # methods
+      end
+    end
+
+### Core Methods
+
+These are predefined and overridable methods which the engine implements.  Any logic you write within them will get execute by the engine.
+
+__self.load__
+
+Anything defined in here is initially loaded at system startup.
+
+__self.update__
+
+Anything in here gets called every second draw call.  In theory physics and non draw frame game updates would go in here.
+
+__self.draw__
+
+Draw logic for all of the objects in your scene.
+
+__self.keypressed(k)__
+
+Any keys which have been pressed by the user as a byte character.
+
+__self.mousepressed(x, y, button)__
+
+The x, y position and button pressed for the mouse.
+
+__self.mousemotion(x, y, xr, yr, state)__
+
+The x, y position, x, y position at click, and button state of the mouse.
+
+__self.quit__
+
+The quit callback.
+
+## Support
+
+Currently this has only been tested on OSX using MRI 1.8.7 and MRI 1.9.2.  Unfortunately ffi-opengl under Rubinius and jRuby doesn't seem to be operational.
+
+## Known Issues
+
+* Quit doesn't exit cleanly.
+* The framerate slows down when the mouse is moved.
+* The framerate isn't locked to a constant rate.
+* The full system isn't currently implemented, and the engine is a continual work in progress.
+
+## Authors
+
+Brian 'bojo' Jones <mojobojo@gmail.com>
+
+## License
+
+The MIT License
+ 
+Copyright (c) 2011 Brian Jones
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'rake'
+require 'jeweler'
+
+Jeweler::Tasks.new do |gem|
+  gem.name        = "hate"
+  gem.summary     = %Q{An OpenGL 3d Ruby Engine}
+  gem.email       = "mojobojo@gmail.com"
+  gem.homepage    = "http://github.com/boj/hate"
+  gem.authors     = ["Brian Jones"]
+  gem.version     = "0.1.0"
+
+  gem.add_dependency('ffi-opengl', '>= 0.2.1')
+  gem.add_dependency('ruby-sdl-ffi', '>= 0.4')
+end
+
+Jeweler::GemcutterTasks.new

data/bin/hate

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.dirname(__FILE__) + '/../lib') unless $:.include?(File.dirname(__FILE__) + '/../lib')
+
+require 'hate'
+
+Hate::Core.run

data/example/main.rb

@@ -0,0 +1,95 @@
+module Hate
+  module Game
+    def self.load
+      puts "Welcome!"
+      
+      @camera = Hate::Graphics::Manager.default_camera
+      
+      #@square = Hate::Graphics::Shapes::Square.new(5.0)
+      #@square.translate(0.0, 0.0, -15.0)
+      #@square.color(0.0, 0.0, 1.0)
+      #@square.build
+      #Hate::Graphics::Manager.add_object(@square)
+      
+      @cubes = []
+      base_cube = Hate::Graphics::Shapes::Cube.new(0.5)
+      100.times do |i|
+        cube = base_cube.clone
+        cube.translate(-rand(10) + 5.0, -rand(10) + 5.0, -rand(20).to_f + -5.0)
+        cube.rotate((rand(360) + 1).to_f, rand, rand, rand)
+        cube.color(rand, rand, rand)
+        Hate::Graphics::Manager.add_object(cube)
+        @cubes << cube
+      end
+      
+      ########################################
+      # Shader Lights
+      ########################################
+      v = Hate::Graphics::Shader::Vertex.new(File.dirname(__FILE__) + "/../lib/hate/graphics/shaders/lights/point.vertex")
+      f = Hate::Graphics::Shader::Fragment.new(File.dirname(__FILE__) + "/../lib/hate/graphics/shaders/lights/point.fragment")
+      @p = Hate::Graphics::Shader::Program.new
+      @p.attach(v.shader).attach(f.shader).compile
+      Hate::Graphics::Manager.add_shader(@p)
+      
+      ########################################
+      # Hardware Lights
+      ########################################
+      #@light1 = Hate::Graphics::Light.new
+      #Hate::Graphics::Manager.add_light(@light1)
+      
+      #@light2 = Hate::Graphics::Light.new([1.0, 0.0, 0.0, 1.0], [0.0, 1.0, 1.0, 1.0], [10.0, 10.0, 10.0, 0.0])
+      #Hate::Graphics::Manager.add_light(@light2)
+      
+      @speed = 1.0
+      @angle = 0.0
+    end
+    def self.update
+
+    end
+    def self.draw
+      @cubes.each_with_index do |cube, i|
+        if i % 2 == 0
+          cube.rotate(cube.ra + rand, 1.0, 0.0, 0.0)
+        elsif i % 3 == 0                            
+          cube.rotate(cube.ra + rand, 0.0, 1.0, 0.0)
+        else                                        
+          cube.rotate(cube.ra + rand, 0.0, 0.0, 1.0)
+        end
+      end
+    end
+    def self.keypressed(k)
+      puts "key: %i" % k
+      puts "camera: (%f, %f) - (%f, %f)" % [@camera.x, @camera.z, @camera.xl, @camera.zl]
+      case k
+        when 119
+          @camera.x += @camera.xl * @speed
+          @camera.z += @camera.zl * @speed
+        when 115
+          @camera.x -= @camera.xl * @speed
+          @camera.z -= @camera.zl * @speed
+        when 97
+          @angle -= 0.01
+          @camera.xl = Math.sin(@angle)
+          @camera.zl = -Math.cos(@angle)
+        when 100
+          @angle += 0.01
+          @camera.xl = Math.sin(@angle)
+          @camera.zl = -Math.cos(@angle)
+        when 27 # Escape
+          Hate::Game.quit
+      end
+    end
+    def self.mousepressed(x, y, button)
+      puts "%i - %i" % [x, y]
+    end
+    def self.mousemotion(x, y, xr, yr, state)
+      puts "(%i, %i) - (%i, %i), state: %i" % [x, y, xr, yr, state]
+    end
+    def self.quit
+      # Until I find a better solution (events), this is one of the rare times we call Core directly.
+      # This doesn't kill the process nicely at the moment.
+      Hate::Core.quit
+      puts "Game Over"
+    end
+  end
+end

data/lib/hate.rb

@@ -0,0 +1,16 @@
+$: << APP_PATH = File.dirname(File.expand_path(__FILE__))
+Dir["#{APP_PATH}/**/lib"].each { |p| $: << p }
+
+module Hate
+  VERSION = "0.0.1"
+  
+  # Files are loaded on demand.
+  autoload :Audio,    APP_PATH + '/hate/audio.rb'
+  autoload :Core,     APP_PATH + '/hate/core.rb'
+  autoload :Game,     APP_PATH + '/hate/game.rb'
+  autoload :Graphics, APP_PATH + '/hate/graphics.rb'
+  autoload :Input,    APP_PATH + '/hate/input.rb'
+  autoload :Network,  APP_PATH + '/hate/network.rb'
+  autoload :Physics,  APP_PATH + '/hate/physics.rb'
+  autoload :System,   APP_PATH + '/hate/system.rb'
+end

data/lib/hate/core.rb

@@ -0,0 +1,123 @@
+require 'rubygems'
+require 'util/trollop'
+require 'ffi-opengl'
+
+include FFI, GL, GLU, GLUT
+
+module Hate
+  module Core
+    
+    def self.trapcc
+      trap('INT') do
+        self.halt
+      end
+    end
+    
+    def self.halt
+      @window.quit
+      Hate::Core::Callbacks.quit
+      puts "Goodbye!"
+      exit
+    end
+    
+    def self.options
+      opts = Trollop::options do
+        version "Hate %s (c) 2011 Brian Jones" % Hate::VERSION
+        banner <<-EOS
+        Hate 3d - A Ruby 3d Game Engine
+
+        Usage:
+          hate [options] <game main.rb>
+
+        Options:
+        EOS
+      end
+      Trollop::die "No main.rb specified!" if ARGV[0].nil?
+    end
+    
+    def self.load
+      # Load main.rb
+      begin
+        require ARGV[0]
+      rescue LoadError
+        require "./" + ARGV[0]
+      end
+
+      # Call #load
+      Hate::Core::Callbacks.load
+    end
+
+    def self.run
+      trapcc  # Trap CTRL-C
+      options # Load cli options
+      @window = Hate::Graphics::Window.new
+      load    # Load user game
+      @window.start
+    end
+    
+    # Grab the default OpenGL window.
+    def self.window
+      @window
+    end
+    
+    # Get the current time in seconds according to GLUT_ELAPSED_TIME.
+    def self.time
+      @window.time
+    end
+    
+    def self.quit
+      halt
+    end
+    
+    # Callbacks are overridden by the user in Core::Game
+    module Callbacks
+      
+      # Initializes pre-game logic.
+      def self.load
+        Hate::Game.load if Hate::Game.respond_to?('load')
+      end
+      
+      # Called every other tick to update game logic.
+      def self.update
+        Hate::Game.update if Hate::Game.respond_to?('update')
+      end
+      
+      # Called each tick to update interface logic.
+      def self.draw
+        Hate::Game.draw if Hate::Game.respond_to?('draw')
+      end
+      
+      # Called when a mouse button is pressed down.
+      def self.mousepressed(x, y, button)
+        Hate::Game.mousepressed(x, y, button) if Hate::Game.respond_to?('mousepressed')
+      end
+      
+      # Called when a mouse button is let up.
+      def self.mousereleased(x, y, button)
+        Hate::Game.mousereleased(x, y, button) if Hate::Game.respond_to?('mousereleased')
+      end
+      
+      # Called when a mouse is moved.
+      def self.mousemotion(x, y, xr, xy, state)
+        Hate::Game.mousemotion(x, y, xr, xy, state) if Hate::Game.respond_to?('mousemotion')
+      end
+      
+      # Called when a key is pressed down.
+      def self.keypressed(key)
+        Hate::Game.keypressed(key) if Hate::Game.respond_to?('keypressed')
+      end
+      
+      # Called when a key is let up.
+      def self.keyreleased(key)
+        Hate::Game.keyreleased(key) if Hate::Game.respond_to?('keyreleased')
+      end
+      
+      # Called when the game is quit.
+      def self.quit
+        Hate::Game.quit if Hate::Game.respond_to?('quit')
+      end
+
+    end
+    
+  end
+end

data/lib/hate/game.rb

@@ -0,0 +1,6 @@
+module Hate
+  # This is an empty module where the user overrides Hate::Core::Callbacks
+  module Game
+  
+  end
+end

data/lib/hate/graphics.rb

@@ -0,0 +1,19 @@
+module Hate
+  module Graphics
+    require 'util/gl'
+    require "ruby-sdl-ffi/sdl"
+
+    include FFI, GL, GLU
+    
+    class SDLException < RuntimeError
+    end
+
+    autoload :Camera,    APP_PATH + '/hate/graphics/camera.rb'
+    autoload :Color,     APP_PATH + '/hate/graphics/color.rb'
+    autoload :Light,     APP_PATH + '/hate/graphics/light.rb'
+    autoload :Manager,   APP_PATH + '/hate/graphics/manager.rb'
+    autoload :Shader,    APP_PATH + '/hate/graphics/shader.rb'
+    autoload :Shapes,    APP_PATH + '/hate/graphics/shapes.rb'
+    autoload :Window,    APP_PATH + '/hate/graphics/window.rb'
+  end
+end

data/lib/hate/graphics/camera.rb

@@ -0,0 +1,39 @@
+module Hate
+  module Graphics
+    class Camera
+      
+      attr_accessor :x, :y, :z
+      attr_accessor :xl, :yl, :zl
+      attr_accessor :default
+
+      def initialize(angle=45.0, near=0.1, far=100.0)
+        @angle, @near, @far = angle, near, far
+        @x, @y, @z    = 0.0, 1.0, 0.0
+        @xl, @yl, @zl = 0.0, 1.0, -1.0
+        @default = true
+      end
+      
+      def is_default?
+        @default
+      end
+      
+      def reshape(x, y)
+        glMatrixMode(GL_PROJECTION)
+        glLoadIdentity
+        glViewport(0, 0, x, y)
+        gluPerspective(@angle, x / y, @near, @far)
+        glMatrixMode(GL_MODELVIEW)
+      end
+      
+      def run
+        glLoadIdentity
+        gluLookAt(
+          @x, @y, @z,
+          @x + @xl, 1.0, @z + @zl,
+          0.0, 1.0, 0.0
+        )
+      end
+      
+    end
+  end
+end

data/lib/hate/graphics/color.rb

@@ -0,0 +1,9 @@
+module Hate
+  module Graphics
+    module Color
+      RED = MemoryPointer.new(:float, 4).put_array_of_float(0, [0.8, 0.1, 0.0, 1.0]) 
+      GREEN = MemoryPointer.new(:float, 4).put_array_of_float(0, [0.0, 0.8, 0.2, 1.0])
+      BLUE = MemoryPointer.new(:float, 4).put_array_of_float(0, [0.2, 0.2, 1.0, 1.0])
+    end
+  end
+end

data/lib/hate/graphics/light.rb

@@ -0,0 +1,19 @@
+module Hate
+  module Graphics
+    class Light
+      
+      attr_accessor :ambient, :diffuse, :position
+
+      def initialize(a=[0.5, 0.5, 0.5, 1.0], d=[1.0, 1.0, 1.0, 1.0], p=[0.0, 10.0, 0.0, 1.0])
+        @ambient  = MemoryPointer.new(:float, 4).put_array_of_float(0, a)
+        @diffuse  = MemoryPointer.new(:float, 4).put_array_of_float(0, d)
+        @position = MemoryPointer.new(:float, 4).put_array_of_float(0, p)
+      end
+      
+      def run
+        
+      end
+      
+    end
+  end
+end