VRManager : Immersive Virtual Reality Abstraction Framework
See our I3D 2005 poster
VRManager is an abstraction framework designed to simplify the process of integrating single or multiple tracking
systems and displays into virtual reality applications. It uses a simple and flexible XML configuration format
to define the relationships between tracking systems and the real world, and provides a very simple API for
accessing tracking information. VRManager allows the end programmer to draw objects in real world coordinates
without having to worry about the location of either user or viewport.
There is an abundance of custom-built virtual reality applications, with each reinventing the algorithms involved
in interpreting tracking information and displaying accurate projections. VR programming should be focused on the creation
and presentation of content, rather than the management of tracking and projection information. VRManager is designed to be
flexible enough to fit into any application and assume the task of integrating tracking information and configuring projection
matrices. It also greatly simplifies the process of configuring a VR system by automating input of coordinates and transformations
for VR elements. ...allows multiple users and applications to share common information such as screen locations and tracker systems, while
Download source code here
Debian-style linux binaries are available for i386 and amd64 by adding the following line to your /etc/apt/sources.list file:
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
- 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.
VRmanager's API is quite simple:
// Create a VRManager object given an XML configuration file
// 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 );
There are many other useful API calls, but these are the most important.
VRManager's XML configuration is easy and flexible:
<!-- 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 -->
<translate vector="2.7, 5.4, 1.3"/>
<scale vector="1, 1, 1"/>
<rotate angle="270" axis="0, 0, 1"/>
<!-- Currently only VRPN tracking systems are supported -->
<trackerSystem type="vrpn_tracker" name="Tracker0@hiball">
<!-- Each tracking system has its own coordinate system -->
<translate vector="0, 0, 0"/>
<!-- Multiple trackers are allowed, and any number of points relative to the tracker
can be defined and referenced by name -->
<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"/>
<!-- 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. -->
<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"/>