glimr 0.1.0 → 0.1.1

data/README

@@ -0,0 +1,222 @@
+GlimR 0.1
+Ruby OpenGL Widget Kit
+2006-07-14
+-----------
+http://glimr.rubyforge.org
+
+Under development. Watch your head.
+
+Funded as one of Ruby Central Inc.'s
+Google Summer of Code 2006 projects.
+
+http://code.google.com/soc/
+
+
+Installation:
+-------------
+
+Requirements:
+  * Ruby OpenGL bindings and GLUT
+  * Ruby/SDL with SDL::TTF support
+
+To install:
+  (sudo) ruby setup.rb
+
+Should install and run on Windows, Linux and OS X.
+
+
+
+How to use:
+-----------
+GlimR is an event-driven GUI toolkit.
+
+You write programs by creating widgets,
+attaching them to a parent widget and setting
+event listeners to respond to user input.
+
+GlimR can be used as either a stand-alone
+GUI toolkit or embedded as a part of an
+OpenGL application.
+
+Currently GlimR has simple low-level widgets
+and you need to build dialogs and such from
+smaller bits.
+
+Here's a small GlimR program:
+
+require 'glimr'
+include GlimR
+
+name_form = VLayout.new(
+  :expand_height => true, :expand_width => true,
+  :align => :center, :valign => :middle)
+
+label = Label.new(:text => "Enter your name:")
+name_input = TextInput.new(:text => "")
+submit = Button.new(:label => "OK"){|o,e|
+  name_form.attach Label.new(:text => "Hi, #{name_input.text}!")
+}
+name_form.attach label, name_input, submit
+
+window = GLUTWindow.new(400, 200, "My App")
+window.attach name_form
+window.run
+
+
+See tests/integration_tests/ for more sample code.
+
+
+
+Embedding:
+----------
+To embed GlimR in an OpenGL application, do this:
+1. Create a GlimR::Viewport as the root of your GlimR scene.
+2. Set the viewport's width and height to your window's width and height.
+3. Send user input events, window reshape events and a frame event to
+   the viewport. See an example on how to do this in
+   lib/glimr/renderer/glutwindow.rb.
+4. After drawing your OpenGL frame -- but before swapping buffers --
+   draw the viewport by calling viewport.render
+
+To avoid loading GLUT, set $glimr_no_glut = true before loading GlimR.
+
+To draw the GUI only when it has changed, render the viewport to a
+texture and poll viewport.changed? to figure out if anything
+redraw-worthy has taken place.
+
+E.g. hypothetical frame loop:
+
+  input_events.each{|ev| viewport.multicast_event(ev) }
+  if reshape_event
+    viewport.multicast_event(reshape_event)
+    reshape_event = false
+  end
+  viewport.multicast_event(frame_event)
+  if viewport.changed?
+    gui_texture.render_into(w,h){ viewport.render }
+  end
+
+  draw_frame
+
+  gui_texture.draw_on_screen
+
+Implementation of gui_texture left as an exercise for the reader.
+
+
+
+Code structure:
+---------------
+
+--- EVENTS
+
+  + lib/glimr/event.rb - GlimR::Event
+    - Events are glorified OpenStructs
+    - conforms to the DOM2 Event interface (but no subclasses)
+
+  + lib/glimr/eventlistener.rb - GlimR::EventListener
+    - EventListener mixin
+    - conforms to the DOM2 EventListener interface
+      (plus event multicasting)
+    - if you're ever used JavaScript, you should feel comfy
+
+--- UTILITIES
+
+  + lib/glimr/configurable.rb - Configurable
+    - Configurable mixin for Hash-based initialization that works
+      with inheritance
+
+  + lib/glimr/layoutable.rb - GlimR::Layoutable
+    - Layoutable mixin
+    - used to make objects get layouted
+    - Widgets and Layouts are Layoutable
+
+  + lib/glimr/util.rb
+    - utility classes and core class extensions
+      (metaprogramming helpers mostly)
+
+--- WIDGETS
+
+  + lib/glimr/widget.rb - GlimR::Widget
+    - base GlimR widget class
+    - inherits from GlimR::Model (see below)
+    - is Layoutable and EventListener
+
+  + lib/glimr/widgets.rb
+    - loads widgets from widgets/
+
+  + lib/glimr/default_theme/
+    - the theme dir contains the images and fonts used by the widgets
+
+  + lib/glimr/widgets/
+    - all different widgets
+
+    + lib/glimr/layout.rb - GlimR::Layout, GlimR::VLayout, GlimR::HLayout
+      - layout classes, inherit from GlimR::Widget
+
+    + button.rb - Button
+    + checkbox.rb - CheckBox
+    + radiogroup.rb - RadioGroup
+
+    + container.rb - Container
+      - viewport wrapper
+    + scrollable_container.rb - ScrollableContainer
+    + resizer.rb - Resizer
+      - resizing knob
+    + scrollbar.rb - VScrollBar, HScrollBar
+
+    + image.rb - Image
+    + stretchable_image.rb - StretchableImage
+
+    + label.rb - Label
+    + text_editor.rb - TextInput
+
+--- RENDERER
+
+  + lib/glimr/renderer.rb
+    - loads renderer core classes
+    - loads standalone renderer if $glimr_no_glut is nil or false
+
+  + lib/glimr/renderer_core.rb
+    - loads renderer core classes
+
+  + lib/glimr/renderer/
+    - rendering-related classes
+
+    + glutwindow.rb - Glimr::GLUTWindow
+      - stand-alone GLUT window
+      - creates GL context
+      - passes input events to the viewport
+      - ctrl-q quits
+
+    + sceneobject.rb - GlimR::SceneObject
+      - class that other rendering classes inherit from
+      - defines child-parent relationships and state collapsing defaults
+
+    + viewport.rb - GlimR::Viewport
+      - the root of the GlimR drawing hierarchy
+      - captures input events, munges them to fit its view of the world
+        and passes them to the scene below
+      - handles clearing screen, setting up camera, clipping to viewport,
+        turning mouse_down & mouse_up into click
+
+    + model.rb - GlimR::Model
+      - convenience class for managing a transform with attached
+        material, texture, shader and geometry
+
+    + geometry.rb - GlimR::Geometry
+      - drawable geometry
+      - uses vertex arrays
+
+    + transform.rb - GlimR::Transform, GlimR::AngleAxis, GlimR::Quaternion
+      - does OpenGL transforms: translation, scaling, rotation
+        (with angle-axis or quaternion), custom transform matrix
+
+    + texture.rb - GlimR::Texture
+      - manages OpenGL textures
+      - handles loading image files to textures
+
+
+
+Author:
+-------
+Ilmari Heikkinen <ilmari.heikkinen@gmail.com>

data/glimr-0.1.1.gemspec

@@ -0,0 +1,21 @@
+require 'rake'
+
+Gem::Specification.new do |s|
+  s.name = 'glimr'
+  s.version = '0.1.1'
+  s.date = '2006-07-22'
+  s.summary = 'Ruby OpenGL GUI Widget Kit'
+  s.email = 'ilmari.heikkinen@gmail.com'
+  s.homepage = 'glimr.rubyforge.org'
+  s.rubyforge_project = 'glimr'
+  s.authors = ['Ilmari Heikkinen']
+  s.files = FileList[
+    '*',
+    'lib/**/*.rb', 
+    'lib/**/*.png', 
+    'lib/**/*.ttf', 
+    'tests/**/*'
+  ].to_a
+  s.required_ruby_version = '>= 1.8.1'
+  s.requirements = ['Ruby-OpenGL >= 0.32g', 'Ruby/SDL >= 1.0.0']
+end

data/lib/glimr/renderer/glutwindow.rb

@@ -1,387 +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
+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
+      GC.enable
+      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
+      GC.disable
+      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(:window_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 window_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
+      @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?
+      @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