VRManager : Immersive Virtual Reality Abstraction Framework
[Under Construction]

deb http://thunderlab.mines.edu/packages current main

• OpenTracker (http://studierstube.org/opentracker/) is also an XML based framework for integrating multiple tracking systems (and is much more ambitious at that), but has no notion of the display half of the VR system. Integration of tracking data is only a small part of VRManager's scope.
• FreeVR (www.freevr.org) is a similar framework for developing VR applications, with some subtle differences. VRManager is designed to operate independently of the realm of VR and has a less invasive programming model.

• Allows objects to be drawn and interacted with in real world coordinates VRManager handles transformations between all of the various coordinate systems (tracker, application, world) and also automatically generates the correct projection matrix for any combination of viewport and viewpoint.
• VR hardware calibration such as tracker and screen locations are kept in global XML configuration files so the end programmer does not have to worry when the hardware calibration has changed.
• Low-profile implementation makes porting easy
  Since VRManager handles all of its operations in its own threaded environment, there is no need to hand program control over to it. This means that VRManager integrates easily into existing graphics programming environments (such as GLUT or SDL); the only code that needs to change is the code which sets the projection matrix.
• Open source C++ framework is easy to extend
  VRManager is written in object-oriented C++, making it easy to add new types of trackers and viewports. Currently only VRPN tracking systems are supported, and all displays must be rectangular.
• Automatic projector distortion and blending VRManager automatically corrects for non-rectangular displays (such as off-angle projections) and will soon have the ability to blend between overlapping projections to make seamless projector tiling as painless as possible.
• Handles multiple distributed viewports, allowing for immersive VR
  VRManager can create projection matrices for any number of viewports, allowing distributed rendering over large areas
• Dynamic viewports--this means you can track the location of a screen (such as a tablet or projector) and render accordingly
  Viewports are defined by the points at their corners, and since all points can be defined as relative to a tracker, viewports can also be defined this way. This allows the application to treat a tracked display as a dynamic "window" into the virtual world.
• Configuration is dynamic at runtime
  VRManager polls its configuration files for changes at runtime, allowing easy tuning of the configuration. For example, you can change the location and orientation of a running program just by altering its configuration; no extra programming is needed.
• Graphical configuration utility allowing easy manipulation of configuration files
  VRManager includes a GLUT based configuration utility designed to simplify the process of locating points in space such as the corners of a screen or a user's eyes relative to their tracker.
• XML configuration format; easy to read and write
  VRManager uses a distributed XML format, meaning a single application can make use of configuration information from many different XML files. The configuration format also allows VRManager to dynamically select different configurations based on location, user, and application.
• Uses intuitive vector/matrix math library, simplifying common application tasks
  The included vector math library supports most common vector/matrix operations, which is crucial to any interactive VR
• 3D user interface library in progress
  Our experimental UI library is designed to mimic real-world controls, such as moving an object from one place to another, turning a knob, or pushing a button.

      // Create a VRManager object given an XML configuration file
    VRManager("config_file.xml") vrm;
    
      // Request the location of a pointer by name
    Vector pointerPosition = vrm.getPointerLocation("pointerName");
    
      // Or, request the transformation matrix of the pointer instead
    Matrix pointerTransform = vrm.getPointerTransform("pointerName");

      // Head-tracked rendering is simple too
      // all you need to do is set up your projection matrix and begin drawing
    glLoadMatrixf( vrm.getGlProjectionMatrix( "eyeName", "viewportName", nearClipPlane, farClipPlane );
    

    <vrmanager>

      <!-- All programs tend to use a different coordinate system,
           this feature allows you to define the reationship between
           the program's coordinate system and the real world -->
   
      <coordSystem>
        <translate vector="2.7, 5.4, 1.3"/>
        <scale vector="1, 1, 1"/>
        <rotate angle="270" axis="0, 0, 1"/>
      </coordSystem>

      <!-- Currently only VRPN tracking systems are supported -->
      <trackerSystem type="vrpn_tracker" name="Tracker0@hiball">
        
          <!-- Each tracking system has its own coordinate system -->
        
        <coordSystem>
          <translate vector="0, 0, 0"/>
        </coordSystem>
        
          <!-- Multiple trackers are allowed, and any number of points relative to the tracker
               can be defined and referenced by name -->        
        
        <tracker id="0">
          <pointer name="eye_left" vector="-0.020, 0.08, -0.17"/>
          <pointer name="eye_right" vector=" 0.047, 0.08, -0.17"/>
          <pointer name="eye_center" vector="    0, 0.08, -0.17"/>
        </tracker>
      </trackerSystem>  
      

        <!-- Static points can also be defined, such as the corners of a screen -->
            
        <!-- Screens are defined by a set of four points and a reference name. -->
        
      <viewport name="rumble_screen0">
        <pointer name="ul" vector="1.2250, 1.1076, 1.2293"/>
        <pointer name="ur" vector="1.5765, 1.2521, 1.2369"/>
        <pointer name="bl" vector="1.2344, 1.1050, 0.9278"/>
        <pointer name="br" vector="1.5791, 1.2588, 0.9342"/>
      </viewport>
      
    </vrmanager>