glimr 0.1.0

data/lib/glimr/renderer.rb

@@ -0,0 +1,2 @@
+require 'glimr/renderer_core'
+require 'glimr/renderer/glutwindow' unless $glimr_no_glut

data/lib/glimr/renderer/camera.rb

@@ -0,0 +1,63 @@
+require 'glimr/renderer/transform'
+
+module GlimR
+
+  # Camera is a special Transform that applies to both the 
+  # OpenGL projection matrix and modelview matrix.
+  # 
+  class Camera < Transform
+    
+    touching_accessor :looking_at, :up
+    attr_accessor :perspective, :fov, :near, :far
+
+    def default_config
+      super.merge(
+        :position => [0,0,5000],
+        :looking_at => [0,0,0],
+        :up => [0,1,0],
+        :near => 1,
+        :far => 10000,
+        :fov => 60,
+        :perspective => false
+      )
+    end
+
+    def initialize(*a, &b)
+      super
+      @changed = true
+    end
+    
+    # Sets up the camera projection to the projection matrix
+    def apply
+      MatrixMode(PROJECTION)
+      LoadIdentity()
+      if perspective
+        top = Math.tan(fov*Math::PI/360) * near
+        bottom = -top
+        left = viewport.aspect * bottom
+        right = viewport.aspect * top
+        Frustum(left,right, bottom,top, near,far)
+      else
+        Ortho(viewport.x,viewport.width, viewport.y,viewport.height, near,far)
+        Scale(1,-1,1)
+        Translate(0,-viewport.height,0)
+      end
+      MatrixMode(MODELVIEW)
+      LoadIdentity()
+      super
+    end
+    
+    # Uses GLU.LookAt to position the camera.
+    def gl_transform
+      GLU.LookAt(*position+looking_at+up)
+    end
+    
+    def absolute_transform
+      collapse! unless @collapsed_matrix
+      @collapsed_matrix
+    end
+  
+  end
+
+end
+

data/lib/glimr/renderer/geometry.rb

@@ -0,0 +1,194 @@
+require 'glimr/renderer/sceneobject'
+
+
+module GlimR
+
+
+  # A Geometry object abstracts vertex arrays.
+  # It may contain a normal array, texcoord array, color array and vertex array.
+  #
+  # The type of a Geometry is the corresponding GL VertexPointer type.
+  # 
+  # A Geometry is required to actually draw something to the screen.
+  #
+  class Geometry < SceneObject
+  
+    attr_accessor :normals, :texcoords, :colors, :vertices, :type, :vertice_count
+    
+    def default_config
+      super.merge(
+        :type => GL::QUADS
+      )
+    end
+    
+    # Returns the smallest x coordinate in the vertices.
+    def min_x
+      x_coords.min
+    end
+    
+    # Returns the largest x coordinate in the vertices.
+    def max_x
+      x_coords.max
+    end
+    
+    # Returns the smallest y coordinate in the vertices.
+    def min_y
+      y_coords.min
+    end
+    
+    # Returns the largest y coordinate in the vertices.
+    def max_y
+      y_coords.max
+    end
+      
+    # Returns the smallest z coordinate in the vertices.
+    def min_z
+      z_coords.min
+    end
+    
+    # Returns the largest z coordinate in the vertices.
+    def max_z
+      z_coords.max
+    end
+      
+    # Returns an array of the x coordinates in the vertices.
+    def x_coords
+      coords 0
+    end
+    
+    # Returns an array of the y coordinates in the vertices.
+    def y_coords
+      coords 1
+    end
+    
+    # Returns an array of the z coordinates in the vertices.
+    def z_coords
+      coords 2
+    end
+      
+    # Returns the coordinates that have coord index % 3 == d.
+    def coords(d)
+      if vertices
+        v = vertices.unpack("f*")
+        i = -1
+        v.find_all{|c|
+          i += 1
+          i%3 == d
+        }
+      else 
+        [0]
+      end
+    end
+
+    # Draws the vertex arrays.
+    def draw
+      DrawArrays type, 0, vertice_count
+    end
+
+    # Parses the given vertex array to a valid OpenGL vertex array
+    def parse_array(v)
+      case v
+      when Array
+        v.flatten.pack("f*")
+      when String,nil,false
+        v
+      else
+        raise ArgumentError, "Provide either an Array of coords or a String of packed floats"
+      end
+    end
+    
+    # A geometry is a drawable.
+    def drawables
+      @drawables + [self]
+    end
+    
+    def collapse(list=[])
+      if vertices # drawable geometry
+        list << self
+      end
+      super
+    end
+    
+    # The collapsed geometry of a Geometry is the Geometry itself.
+    def absolute_geometry
+      self
+    end
+    
+    # Merges self with the other.
+    def merge!(other)
+      @type = other.type if other.type
+      @normals = other.normals if other.normals
+      @texcoords = other.texcoords if other.texcoords
+      @colors = other.colors if other.colors
+      @vertices = other.vertices if other.vertices
+      @vertice_count = other.vertice_count if other.vertice_count
+      self
+    end
+    
+    # Replaces ivars with the other's.
+    def replace!(other)
+      @type = other.type 
+      @normals = other.normals 
+      @texcoords = other.texcoords 
+      @colors = other.colors 
+      @vertices = other.vertices 
+      @vertice_count = other.vertice_count 
+      self
+    end
+
+    def texcoords=(v)
+      v = parse_array(v)
+      @texcoords = v
+    end
+
+    def normals=(v)
+      v = parse_array(v)
+      @normals = v
+    end
+
+    def colors=(v)
+      v = parse_array(v)
+      @colors = v
+    end
+
+    def vertices=(v)
+      v = parse_array(v)
+      @vertices = v
+      @vertice_count = v.size / 12
+    end
+  
+    touching :touch!, :texcoords=, :normals=, :colors=, :vertices=, :vertice_count=, :replace!
+  
+    # Applies the different arrays and draws if vertices set.
+    def apply
+      NormalPointer FLOAT, 0, normals if normals
+      TexCoordPointer 2, FLOAT, 0, texcoords if texcoords
+      ColorPointer 4, FLOAT, 0, colors if colors
+      VertexPointer 3, FLOAT, 0, vertices if vertices
+      draw if vertices
+    end
+    
+    # Enables vertex arrays.
+    def push_state
+      EnableClientState NORMAL_ARRAY if normals
+      EnableClientState TEXTURE_COORD_ARRAY if texcoords
+      EnableClientState COLOR_ARRAY if colors
+      EnableClientState VERTEX_ARRAY if vertices
+    end
+    
+    # Disables vertex arrays.
+    def pop_state
+      DisableClientState NORMAL_ARRAY if normals
+      DisableClientState TEXTURE_COORD_ARRAY if texcoords
+      DisableClientState COLOR_ARRAY if colors
+      DisableClientState VERTEX_ARRAY if vertices
+    end
+    
+    def inspect
+      "#<#{self.class.name}:#{hash}:TYPE#@type:#@vertice_count vertices>"
+    end
+    
+  end
+
+
+end

data/lib/glimr/renderer/glutwindow.rb

@@ -0,0 +1,387 @@
+require 'glimr/renderer/viewport'
+require 'glimr/renderer/camera'
+require 'glimr/util'
+GC.disable
+require 'glut'
+GLUT.Init
+
+
+module GlimR
+
+  # The GLUTWindow provides a stand-alone OpenGL context for GlimR.
+  #
+  # When rendering, a GLUTWindow first sends a frame event to its viewport,
+  # then clears the buffer and tells its viewport to draw itself.
+  #
+  # The GLUTWindow is also responsible for mapping GLUT events into GlimR
+  # events and sending them to the viewport.
+  #
+  class GLUTWindow
+
+    @frame_time = 0
+
+    # Index of the current window.
+    def self.window_index
+      @window_index ||= 0
+    end
+
+    # Array of windows created.
+    def self.windows
+      @windows ||= []
+    end
+
+    # Id of current GLUT window.
+    def self.current_window
+      windows[window_index]
+    end
+
+    # Sets the active GLUT window to the next window in order.
+    def self.next_window
+      if @window_index == 0
+        slp = 0.033 - (Time.now.to_f - @frame_time)
+        sleep(slp) if slp > 0
+        @frame_time = Time.now.to_f
+      end
+      @window_index = (window_index + 1)%windows.size
+      GLUT.SetWindow(current_window.window_id)
+      current_window.heartbeat
+    end
+
+    # Creates a GLUT window with the title and adds it to windows list.
+    def self.create_window(window)
+      GLUT.InitDisplayMode(window.display_mode)
+      GLUT.InitWindowSize(window.width, window.height)
+      GLUT.InitWindowPosition(window.x, window.y) if window.x and window.y
+      window.window_id = GLUT.CreateWindow window.title
+      windows << window
+      window.window_id
+    end
+
+    # Destroys the GLUT window w and deletes it from the windows list.
+    # Exits if the window in question was the last remaining window.
+    def self.destroy_window(w)
+      windows.delete w
+      GLUT.DestroyWindow w.window_id
+      exit if windows.empty?
+    end
+
+    # GLUT idle function is to show the next window.
+    GLUT.IdleFunc(lambda { next_window })
+
+    attr_accessor :viewport
+    attr_accessor :window_id
+    attr_reader :width, :height, :title, :frame, :frames_drawn, :x, :y, :display_mode
+
+    delegate :viewport, :<<, :attach, :detach, :camera=, :camera, :background, :background=
+
+    # Creates a window with width w and height h.
+    def initialize(w=400,h=300,title="GlimR - #{$0}",x=nil,y=nil)
+      @viewport = Viewport.new
+      @viewport.background = [1,1,1,1]
+      @viewport.clear_depth_buffer = true
+      @visible = true
+      @display_mode = GLUT::DOUBLE | GLUT::RGB | GLUT::DEPTH
+      @x = x
+      @y = y
+      @viewport.x = 0
+      @viewport.y = 0
+      @frame_event = Event.new(:frame)
+      @reshape_event = Event.new(:resize)
+      @frame_time = @last_frame_time = Time.now.to_f
+      @frame = @frames_drawn = 0
+      @title = title
+      @event_queue = {}
+      @mouse_buttons_down = {}
+      @mouse_properties = {}
+      @modifiers = {}
+      reshape(w,h)
+      init_glut
+    end
+
+    # Initialize GLUT state for the window, then ask GLUTWindow class to
+    # create the window.
+    def init_glut
+      self.class.create_window(self)
+      set_callback_funcs
+    end
+
+    # GLUT ReshapeFunc.
+    # Sets viewport width and height to w and h, respectively,
+    # and sends a resize event to the viewport.
+    def reshape(w,h)
+      @width = w
+      @height = h
+      @reshape_event.time = Time.now.to_f
+      @reshape_event.bubbles = false
+      @reshape_event.width = w
+      @reshape_event.height = h
+      viewport.multicast_event(@reshape_event)
+    end
+
+    # Enters GLUT.MainLoop.
+    def run
+      GLUT.MainLoop
+    end
+
+    def need_redraw?
+      @visible and (changed? or damaged?)
+    end
+
+    def damaged?
+      GLUT.LayerGet(GLUT::NORMAL_DAMAGED) == GL::TRUE
+    end
+
+    def changed?
+      viewport.changed?
+    end
+
+    def heartbeat
+      GC.disable
+      @frame_time = Time.now.to_f
+      @frame_event.time = @frame_time
+      @frame_event.bubbles = false
+      @event_queue.values.each{|evt|
+        viewport.dispatch_event(evt)
+      }
+      @event_queue.clear
+      viewport.multicast_event(@frame_event)
+      GLUT.PostRedisplay if need_redraw?
+      GC.enable
+      @frame += 1
+    end
+
+    def queue_event evt
+      if evt.type == :mouse_move and @event_queue[:mouse_move]
+        evt.dx += @event_queue[:mouse_move].dx
+        evt.dy += @event_queue[:mouse_move].dy
+        evt.params[:dx] = evt.dx
+        evt.params[:dy] = evt.dy
+        evt.params[:time] = evt.time = Time.now.to_f
+      end
+      @event_queue[evt.type] = evt
+    end
+
+    # GLUT DisplayFunc.
+    #
+    # Displays the GLUTWindow. Sleeps to maintain a maximum
+    # framerate of 33fps, then displays previously rendered frame.
+    # Then sends a frame event to the viewport.
+    #
+    # If the GLUTWindow is visible, clears the buffer and tells viewport to draw itself.
+    # Finally increments the frame counter.
+    #
+    def display
+      GC.disable
+      viewport.render
+      GLUT.SwapBuffers
+      @frames_drawn += 1
+    end
+
+    # Asks GLUTWindow class to destroy the window.
+    def close(*a)
+      self.class.destroy_window(self)
+    end
+
+    # Toggles fullscreen mode.
+    def fullscreen(*a)
+      if not @fullscreen
+        @fullscreen = %w(X Y WIDTH HEIGHT).map{|cn|
+          GLUT.Get(GLUT.const_get("WINDOW_#{cn}"))
+        }
+        GLUT.FullScreen
+      else
+        x,y,w,h = *@fullscreen
+        GLUT.ReshapeWindow(w,h)
+        GLUT.PositionWindow(x,y)
+        @fullscreen = nil
+      end
+    end
+
+    # Takes screenshot (not implemented.)
+    def take_screenshot(*a)
+      #screenshot
+    end
+
+    # Enters the profiler, lets run for 5 seconds, then
+    # exits.
+    def profiler(*a)
+      Thread.new{
+        puts "Entering profiler"
+        require 'profile'
+        sleep 5
+        exit
+      }
+    end
+
+    # Set GLUT callback functions to the object's methods that have
+    # the rubyized name of the corresponding callback function.
+    # That's not very clear, is it. Maybe this example sheds some light on it.
+    #
+    #   GLUT::ReshapeFunc is set to "reshape"-method
+    #   GLUT::SpaceballMotionFunc is set to "spaceball_motion"-method
+    #   GLUT::MouseFunc is set to "mouse"-method
+    #   ... and so on for every GLUT method that ends with Func.
+    #
+    # If there is no corresponding method (e.g. there's no "idle"-method), the
+    # callback won't be set.
+    #
+    # List of callback names (avoid these in non-callback method names):
+    #
+    #   ButtonBoxFunc       => button_box
+    #   DialsFunc           => dials
+    #   DisplayFunc         => display
+    #   EntryFunc           => entry
+    #   IdleFunc            => idle
+    #   KeyboardFunc        => keyboard
+    #   MotionFunc          => motion
+    #   MouseFunc           => mouse
+    #   OverlayDisplayFunc  => overlay_display
+    #   PassiveMotionFunc   => passive_motion
+    #   ReshapeFunc         => reshape
+    #   SpaceballButtonFunc => spaceball_button
+    #   SpaceballMotionFunc => spaceball_motion
+    #   SpaceballRotateFunc => spaceball_rotate
+    #   SpecialFunc         => special
+    #   TabletButtonFunc    => tablet_button
+    #   TabletMotionFunc    => tablet_motion
+    #   TimerFunc           => timer
+    #   VisibilityFunc      => visibility
+    #   WindowStatusFunc    => window_status
+    #
+    def set_callback_funcs
+      GLUT.methods.grep(/Func$/).sort.each{|callback_setter_name|
+        # Change FooBarFunc into foo_bar
+        callback_method_name = callback_setter_name[0,1].downcase +
+                               callback_setter_name[1..-5].
+                               gsub(/[A-Z]/){|cap| "_" + cap.downcase}
+        if respond_to?(callback_method_name.to_sym)
+          callback_method = method(callback_method_name).to_proc
+          GLUT.__send__(callback_setter_name, callback_method)
+        end
+      }
+      @mouse_over_window = true
+    end
+
+    MOUSE_BUTTONS = [:left, :middle, :right, :wheel_up, :wheel_down]
+
+    # GLUT EntryFunc.
+    def entry(enter)
+      @mouse_over_window = (enter == 1)
+      if @mouse_over_window
+        @mouse_x, @mouse_y = @prev_mouse_x, @prev_mouse_y
+      else
+        @mouse_x = @mouse_y = nil
+      end
+    end
+
+    # Updates current mouse coordinates.
+    def update_coords(x,y,update_modifier_keys=true)
+      props = {
+        :target => @target,
+        :x => x, :y => y,
+        :dx => (@prev_mouse_x ? x-@prev_mouse_x : 0),
+        :dy => (@prev_mouse_y ? y-@prev_mouse_y : 0),
+        :buttons => @mouse_buttons_down
+      }
+      @prev_mouse_x, @prev_mouse_y = x, y
+      @mouse_x, @mouse_y = x, y if @mouse_over_window
+      update_modifiers if update_modifier_keys
+      @mouse_properties = @mouse_properties.merge(props).merge(@modifiers)
+    end
+
+    # GLUT PassiveMotionFunc. Moving mouse without buttons depressed
+    def passive_motion(x,y)
+      event_properties = update_coords(x,y,false)
+      queue_event Event.new(:mouse_move, event_properties)
+    end
+
+    # GLUT MotionFunc. Moving mouse with mouse button depressed.
+    def motion(x,y)
+      event_properties = update_coords(x,y,false)
+      queue_event Event.new(:mouse_move, event_properties)
+    end
+
+    # GLUT ButtonBoxFunc.
+    def button_box(*a)
+    end
+
+    # GLUT VisibilityFunc. Toggles window visibility variable based on the argument.
+    def visibility(visible)
+      @visible = (visible == GLUT::VISIBLE)
+    end
+
+    # GLUT WindowStatusFunc.
+    def window_status(*a)
+    end
+
+    # GLUT MouseFunc. Fired when mouse button pressed or released.
+    def mouse(button, down, x, y)
+      down = (down == 0)
+      button = MOUSE_BUTTONS[button]
+      @mouse_buttons_down[button] = down
+      event_type = (down ? :mouse_down : :mouse_up)
+      event_properties = update_coords(x,y)
+      event_properties[:button] = button
+      queue_event Event.new(event_type, event_properties)
+    end
+
+    # Gets modifier key states and assigns them to
+    # @modifiers-Hash and returns the Hash.
+    def update_modifiers
+      modifier_bitfield = GLUT.GetModifiers
+      GLUT.constants.grep(/^ACTIVE_/).each{|cn|
+        @modifiers[cn[7..-1].downcase.to_sym] = (modifier_bitfield & GLUT.const_get(cn) > 0)
+      }
+      @modifiers
+    end
+
+    # GLUT KeyboardFunc. Fired when key pressed.
+    # Multicasts key_down and key_up.
+    #
+    # Note: there is no "Hold button down"-functionality in GLUT.
+    #
+    def keyboard(key, x, y)
+      event_properties = update_coords(x,y).merge(:key => key)
+      ev = Event.new(:key_down,  event_properties)
+      @viewport.multicast_event(ev)
+      ev = Event.new(:key_up, event_properties)
+      @viewport.multicast_event(ev)
+      handler = keyhandlers[key] if @modifiers[:ctrl] and not (@modifiers[:shift] or @modifiers[:alt])
+      if handler and not (ev.stopped or ev.cancelled)
+        if handler.respond_to? :call
+          handler.call(key, x, y)
+        else
+          __send__(handler, key, x, y)
+        end
+      end
+    end
+
+    # Handles special key presses.
+    #
+    # Converts the special key to a symbol by stripping KEY_
+    # off the front and downcasing the remains, e.g. :f1, :left, :right.
+    #
+    # Delegates the symbol to #keyboard.
+    #
+    def special(key, x, y)
+      cn = GLUT.constants.grep(/^KEY_/).find{|k| GLUT.const_get(k) == key}
+      key = cn.sub(/^KEY_/, '').downcase.to_sym
+      keyboard(key, x, y)
+    end
+
+    # Default key handlers.
+    #
+    # ESC closes window, f toggles fullscreen, p enters profiler, s takes screenshot.
+    #
+    def keyhandlers
+      @keyhandlers ||= {
+        17 => :close,
+        6 => :fullscreen,
+        16 => :profiler,
+        20 => :take_screenshot,
+      }
+    end
+
+  end
+
+end