Tag Archives: Oculus

Items related to the Oculus Rift virtual reality headset.

Oculus Rift Virtual Reality Initial Impressions

Here are my impressions after having the Oculus Development Kit (DK2) in-hand for a bit over two weeks now:

The Technology Behind Oculus

The hardware itself will be familiar to anyone who has developed software for a touch screen phone. Described generally, the head-mounted display is a cell phone screen placed in a headset mount. A gyroscope, magnetometer and accelerometer provide instrumentation, with an accompanying camera used to identify the position of the wearer’s head. In all, the DK2 seems a perfect example of innovation, where the device introduces no new technologies but is instead a recombination of existing parts to create something wholly new.


A remarkable innovation of existing technology

That doesn’t in any way diminish how much of a marvel the device is, but it does suggest that, as with cell phones, VR headsets are likely to drop in price when created in volume and may be expected to improve in quality at a rapid pace.

Oculus Immersion

The screen’s low resolution does produce a bit of a ‘screen door’ effect, with the LCD pixels very easy to see.  The sensation is a bit like sitting too close to an old CRT television set.  Since the DK2 is a prototype development kit (and not the final product) that lower image quality wasn’t surprising, and I found the immersive experience of the headset allowed me to very quickly dismiss quibbles about resolution.

The sense of presence is very effective. Even with the ‘seated at a desk’ test display, I found myself reaching out to confirm that what I saw on the desk before me wasn’t actually there . It’s clear that the environment one is looking at is a set of video game graphics, but one’s mind is easily convinced that what is being seen is actually real.


Feel like you’re swimming in the ocean while seated at your desk

Along with that immersion, an awareness of my actual surroundings disappeared almost entirely at times, and I sometimes found myself startled to feel my hands touch a desk or chair when my eyes saw open air around me. I’m not sure if I would trust myself walking with a VR headset, and it will be interesting to see how Steam VR overcomes that sense of displacement from reality with their own plans for a headset which encourages standing, mobile user operation.

In the virtual environment, I felt a sense of apprehension whenever deliberately putting myself in danger.  For one example, when swimming about in the Ocean Rift demo, I was reluctant to descend into the depths where the giant shark (which you’re warned about) was waiting to attack. Even though I was obviously not really swimming beneath the waves and diving deep into a dark ocean trench, it was a spookily genuine experience all the same.  Given my uneasiness with something so tame and G-rated, there is no way in hell I’d play a horror game like Alien Isolation in VR.

It will be interesting to see if that sense of dread diminishes once my brain becomes accustomed to the VR environment and learns about a new thing it can safely ignore. I remember telling my friends about the sense of total immersion I felt playing a pixelated 3D Quake, 640×480, on a 14 inch monitor, and I can’t help but wonder if my initial Oculus experiences will sound just as exaggeratedly real when looking back on this technology in the future.


So real! It’s like you’re there!  (It felt like that in 1995.  Honest!)

Surprisingly, the various roller coaster demos (which famously freak people out) did very little for me. I’m the type of heights-dreading person who feels apprehension just watching a parkour video and ends up with sweaty palms after playing a game like Mirror’s Edge on a regular monitor, but I found the Oculus roller coasters to be a bit underwhelming.  I suspect that will change once issues of judder and resolution are resolved.

Oculus Nausea

The nausea experienced when first using the DK2 was surprisingly intense.  Just a few minutes of wandering around the low-intensity Tuscany Villa demo had me feeling queasy, and about 10 seconds flying in the AirDrift demo almost made me vomit. Regardless of the settings or passiveness of the environment, for the first few days it was not possible for me to use the DK2 for more than a few minutes at a time.  An extended period of use would see me wearing the device for no more than 10 minutes, and only with tremendous effort.


Quiet, peaceful, and more nausea-inducing than an economy-class flight through a thunderstorm

The nausea was of a surprisingly intense and persistent sort. Whenever I’ve experienced motion sickness when playing games, the sensation tended to grow gradually and quickly diminished once I’d left the computer screen. However, VR sickness seemed to onset immediately and persisted for a bit over two hours after I’d left the device behind. A sense of dizziness and unsteadiness remained after taking off the DK2, and I’d recommend anyone looking to try a VR headset ensure they’re not needing to operate machinery or a vehicle for a few hours after their first attempt — I’d never have trusted myself in a car or on a bike at that point.

The nausea and dizziness was so intense at first that I was concerned I would not be able to use VR at all. Fortunately, this has turned out not to be the case.

One quickly learns not to change position too quickly while wearing the VR headset. The sensation when swiftly turning my virtual body’s view about was as if blood were being pressed to the side of my brain to cushion it from a sudden shock. Whether that was an illusion or an actual reaction from my nervous system is something I’ll leave to the biologists and physicians, but the unpleasantness of the experience was very real.

I gained my ‘VR legs’ rather quickly and the discomfort was considerably reduced after a week of occasional use. Nausea diminished with each session using the DK2, and use of it for extended periods (30+ minutes) after about 10 days barely registered any sense of discomfort at all. It then became possible to skip through the various Oculus demonstration apps with ease and play games for an hour or so at a time without any difficulty. Flying in AirDrift became a breeze. Use of the device soon began to feel so natural that I would have likely misremembered my earlier nausea as being considerably less intense if I’d not made notes about it at the time.


Give it a few days, and even flying through the air starts to feel natural

It’s unclear to me whether my diminishing nausea was due to my senses growing accustomed to the VR environment, or my having optimized my computer’s drivers and configuration to ensure the DK2 was being used in the best possible fashion. Others who have tried the DK2 device on my computer after I had finished its configuration and video driver optimization experienced no nausea issue whatsoever. So, either I should have spent more time configuring my system’s drivers and DK2 configuration before starting to use the device, or I was just an unlucky outlier who was particularly susceptible to VR motion sickness.

Gaming With Oculus

The Direct to Rift mode for the DK2 worked flawlessly, with all games and tech demos suited for that mode running without issue. However, setting up Extend Desktop mode on my own computer to use Steam was a difficult experience which reminded me of the ‘DLL hell’ presented when installing a video card on Windows 3.1. That difficulty is no fault of Oculus or any other hardware/software vendor: The DK2 is beta development hardware, and my difficulties could have come from a variety of sources, from video card drivers to my monitor setup under Windows. I only mention these issues as a reminder that the DK2 is not consumer hardware:  Everything might work for you right out of the box at this point, but anyone who purchases a DK2 should be prepared to spend a good amount of time configuring their system to ensure it works correctly.


It turns out these guys are actually kinda big

Once Extend Desktop mode was enabled for my DK2, I tried out Half-Life 2 using Steam’s beta VR client and found the game a new experience entirely. The screen door effect is still there, with pixels visible when you’re looking for them, but the sensation of actually feeling ‘inside’ the game allowed me to quickly set that roughness aside. Even though the game was familiar to me, the VR immersion allowed me to pick out scenery details I’d not seen before, and I gained a sense of scale of my surroundings which had previously been missing — I had no idea head crabs were so big!

Video With Oculus

Virtual movie theaters and home entertainment setups seem to be one of the most popular initial applications of VR displays, and I believe video will end up becoming the most popular use of the Oculus and similar devices in the future. Even early in my use of the device, I did not feel nausea when using the DK2 to passively view video and that use seems likely to be the gateway through which wider adoption of VR headsets will occur.

A personal, isolated virtual movie theatre

The ability to set whatever environment one would like for movie viewing (whether in a living room, your choice of theater and row, or just a floating screen), combined with the full sense of immersion and lack of interruption from the outside world delivered by the headset provides the possibility of a perfect movie experience. A VR display delivers the option of viewing regular two-dimensional or fully 3D video in whatever format one would like, whether an IMAX-sized screen, a fully surrounding 3D environment, or a small corner television set, all while remaining seated or reclined in a favourite chair, couch or bed. The low resolution of the DK2 still delivers the feeling of sitting a bit too close to an old CRT television, but the higher resolution to be expected from the consumer Oculus device will likely resolve that distraction entirely in time.

There is also the possibility of interactive movies, or fully 360’ degree movie experiences which put you in the role of a character of your choice. The Birdy King Land Oculus demo gives a really good example of that – you’re a character IN the movie. However, as fun as interactivity and gaming is with the Oculus, easily delivered passive entertainment seems likely to become the ‘killer app’ for head-mounted VR displays. Often, people just want to lie back and relax, and a personal, isolated virtual movie theatre has the potential to perfectly deliver that experience on-demand.

Oculus Tips From Experience

If I could go back in time to the moment I started using the DK2, I’d give myself these bits of advice:

You should use the Rift configuration tools to set your Inter-Pupillary Distance (IPD) rather than using the value measured for your glasses. IPD for the Rift (and presumably other VR headsets) should match the value used when your eyes are focused to infinity (informally confirmed here by Oculus Founder Palmer Luckey), which is what the configuration tool provides. Using the IPD value set for your glasses will probably be incorrect.

Ensure your video drivers are up to date. If using an NVidia card, install and use the NVidia ‘GeForce Experience’ tool to simplify the upgrade of your video drivers. It saves a lot of hassle when identifying and applying the correct driver version.

Contact lenses are helpful but not necessary if you can see well without glasses. With natural eyesight, I would be incapable of reading a cell-phone held at Oculus distance from my eyes, but the corrective optics of the device’s lenses extend that distance to remove any difficulty with viewing. VR resolution isn’t sharp enough yet to justify concerns with fine visual detail, but that will probably change with consumer versions of the device.

Be sure to move slowly in the VR environment. If you’re used to flicking the mouse around for a quick change in orientation in first-person shooter games, using the same gesture to move about in VR will probably feel uncomfortable at first and lead to nausea.

If you’re taller than average, set the Player Height value in the Oculus settings to be lower. The people creating Oculus games and experience demos are likely to be of average height, and the environments will often feel uncomfortably cramped (as if you’re about to hit your head on the ceiling) if they are set to take into account player height. Just set your configuration height at 5’5” and you’re good.

Should I Buy An Oculus Rift DK2?

If you’re looking to develop VR software right now then, yes, you should buy an Oculus DK2. You should be prepared to fiddle with system settings, drivers, incomplete documentation and the other hassles which come with being on the ‘bleeding edge’ of a technology, but the device is good to go for development.

If you’re considering the development of VR software, are curious about the experience or just want to play games with the system, you should wait. The consumer versions of the Oculus Rift are going to be superior to the development kits in pretty much every way, and might even be less expensive at first.  It will be worth the anticipation to wait a few more months for those to arrive since, once consumer versions of VR headsets are available, the early implementations now available with the Oculus DK1 and DK2 are probably going to be set aside to gather dust.

“Hello World!” for Oculus Rift Development Kit 2 (DK2)

Update: This blog post discusses building a simple C++ app for the Oculus v0.5.0 beta SDK. An updated example which shows how to build a simple C++ console app for the production Oculus Rift CV1/DK2 v1.3.2 SDK can be found here.

This post walks through the basics of building a simple C++ app for the Oculus Rift Development Kit 2 (DK2).  Setup of the development environment is covered first, with the coding of a simple app which reads the device’s sensors and outputs their state following after.

We’re working with the Oculus Rift 0.5.0 SDK for this example and a DK2 device. Everything posted in here is subject to change as the Oculus API matures (that’s no fault of Oculus — we were all told we’re getting a work-in-progress developer kit, and that’s what’s been delivered), so please do let me know if these notes no longer reflect reality for a developer new to the device.

Oculus DK2 Dev Environment Setup

If you’ve not already installed the Oculus Rift SDK, you’ll want to do so now. It is also assumed for Oculus development that the DirectX SDK and Windows SDK are already installed on your computer. We won’t need those SDKs for the initial ‘Hello World!’ completed here but will definitely need them later, so best to fetch those before starting to code.

The DirectX SDK can be retrieved from here:


And the Windows 8.x SDK (which works fine for Windows 7) from here:


It turns out that the DirectX SDK installer can conflict with the Microsoft Visual C++ 2010 Redistributable, resulting in a cryptic “Error Code: S1023” installation failure. If that happens to you (as it did to me), this StackOverflow post will sort you out.

Microsoft Visual Studio (VS2013) is used as the development environment for the examples shown here. To test that environment after all SDKs are installed (and give us a VS2013 project into which we’ll put our example code) we’ll start out with a traditional ‘Hello World!’ program.

Using the VS2013 File > New > Project… wizard to create a new console app (being sure to turn off the “Precompiled header” checkbox option), we’ll pop into the editor:

#include <iostream>

int main()
{  std::cout << "Hello World!";
   return 0;

and then use the VS2013 Build > Build Solution menu option to create an executable.

With “Hello World!” output to the console when running that exe, we’ve confirmed our development environment is good to go.  Onwards to the DK2!

The Oculus developer documentation is a bit vague on the libraries needed for the basics, and the code examples included with the SDK cover a good amount of DirectX and other extra bits we’re not needing just yet.  Checking the Oculus developer forums, the latest news on libraries tells us that the only ones needed for the linker are:

libovr.lib (libovrd.lib in debug)

We’re just working with the Oculus SDK for now, so the libovr.lib and libovrd.lib alone will be sufficient.

Continuing with our simple ‘Hello World!’ project environment, we’ll add in the libovr.lib and libovrd.lib libraries through the VS2013 project’s properties (right-click the project for the Properties dialog selection) under Linker > Input > Additional Dependencies, adding in the file and path for those two .lib files. On my own system, those were under:


Your own path, of course, will depend upon the installation location of your Oculus SDK.

Next, we’ll include the Oculus SDK.

In VS2013 again, under the project’s properties, Configuration Properties > C/C++ > Additional Include Directories options, we’ll set the path to the SDK’s LibOVR Include, which could be found on my own system at:


Our development environment is now ready to create our basic Oculus program.

Starting Oculus DK2 Coding

To get a feel for how an Oculus program works, I opened up the Tiny Room sample code included with the SDK and…


It’s been a while since I last worked in C++ and that sample code felt more unfamiliar than I was comfortable with. Before going any further, it was back to school for me.

The full MIT Open Courseware introduction to C++ class is available online, and stepping away from things to read the full lecture notes and coding up the assignment basics provided just the refresher I needed. If it’s been a while since you’ve coded in C++, I’d recommend completing that course yourself to scrape the rust off your knowledge.

With that done, back to Oculus.

The Oculus Developers Guide provides an example initialization of the device through this snippet:

// Include the OculusVR SDK
#include <OVR_CAPI_0_5_0.h>
void Application()
   if (ovr_Initialize(NULL))
      ovrHmd hmd = ovrHmd_Create(0);
      if (hmd)
         // Get more details about the HMD.
         ovrSizei resolution = hmd->Resolution;
            // Do something with the HMD.

Let’s put that into working code.

Using the above example for reference, we’ll confirm we can connect to the DK2 by initializing the device and fetching its product name and firmware version.  That’s accomplished with this bit of code:

#include <iostream>
#include <OVR_CAPI_0_5_0.h>

using namespace std;

int main()
{  if (ovr_Initialize(NULL))
   {  ovrHmd hmd = ovrHmd_Create(0);

      if (hmd)
      {  // Output some attributes of the HMD.
         cout << "Connected to HMD with name " << hmd->ProductName
              << " and firmware version " << hmd->FirmwareMajor << "."
              << hmd->FirmwareMinor << endl;



   return 0;

With the DK2 turned on (look for the orange light on the headset), running the exe compiled from the above gives us the device’s attributes output to console:

Connected to HMD with name Oculus Rift DK2 and firmware version 2.12

So far so good. Now we’ll try reading some sensor data.

Referencing the Oculus Developer Guide again, under the Head Tracking and Sensors section we can see how to start up the DK2’s sensor and read in the tracking state. Putting all that into code with a loop to push out the results gives us:

#include <iostream>
#include <iomanip>
#include <OVR_CAPI_0_5_0.h>

#define COLW setw(15)

using namespace std;

int main()
{  if (ovr_Initialize(NULL))
   {  ovrHmd hmd = ovrHmd_Create(0);

      if (hmd)
      {  // Start the sensor which provides the Rift’s pose and motion.
         ovrHmd_ConfigureTracking(hmd, ovrTrackingCap_Orientation |
                                       ovrTrackingCap_MagYawCorrection |
                                       ovrTrackingCap_Position, 0);
         ovrTrackingState ts;
         ovrSensorData sensorData;
         ovrVector3f gyroData;
         ovrVector3f magData;

         while (true)
         {  // Query the HMD for the current tracking state.
            ts = ovrHmd_GetTrackingState(hmd, ovr_GetTimeInSeconds());
            // Fetch the sensor data.
            sensorData = ts.RawSensorData;
            // Retrieve the gyroscope and magnetometer numbers.
            gyroData = sensorData.Gyro;
            magData = sensorData.Magnetometer;
            // And output the lot to console.
            cout << "Gyro (x,y,z):  " << COLW << gyroData.x << "," << COLW
                 << gyroData.y << "," << COLW << gyroData.z
                 << "  Mag (x,y,z): " << COLW << magData.x << "," << COLW
                 << magData.y << "," << COLW << magData.z << endl;



   return 0;

With the output to console being:

Gyro (x,y,z):     -0.000476604,     0.00169012,    -0.00504548  Mag (x,y,z):       -0.347324,       -1.14652,       0.548826
Gyro (x,y,z):      0.000524145,   -0.000410698,     -0.0029435  Mag (x,y,z):       -0.347324,       -1.14652,       0.548826
Gyro (x,y,z):     -0.000476467,     -0.0026112,     0.00245846  Mag (x,y,z):       -0.347324,       -1.14652,       0.548826
Gyro (x,y,z):       0.00162392,    -0.00471226,     0.00245943  Mag (x,y,z):       -0.349417,       -1.13972,       0.558212
Gyro (x,y,z):      -0.00477799,   -0.000411771,    0.000259385  Mag (x,y,z):       -0.349417,       -1.13972,       0.558212
Gyro (x,y,z):      -0.00157782,     0.00278784,    0.000260718  Mag (x,y,z):       -0.339885,       -1.14628,       0.573855
Gyro (x,y,z):     -0.000477026,      0.0027865,    0.000261538  Mag (x,y,z):       -0.339885,       -1.14628,       0.573855
Gyro (x,y,z):       0.00052226,     0.00168425,    -0.00393636  Mag (x,y,z):       -0.339885,       -1.14628,       0.573855
Gyro (x,y,z):      0.000522759,    -0.00361625,    -0.00183387  Mag (x,y,z):       -0.339885,       -1.14628,       0.573855
Gyro (x,y,z):     -0.000478059,     0.00168509,    -0.00293224  Mag (x,y,z):       -0.340583,       -1.14769,       0.551232
Gyro (x,y,z):     -0.000479875,     0.00598387,    0.000268184  Mag (x,y,z):       -0.340583,       -1.14769,       0.551232
Gyro (x,y,z):       0.00591569,     0.00278188,    0.000269853  Mag (x,y,z):       -0.341512,       -1.15074,       0.550511
Gyro (x,y,z):       0.00161441,    0.000581309,    -0.00392838  Mag (x,y,z):       -0.341512,       -1.15074,       0.550511
Gyro (x,y,z):     -0.000486488,   -0.000418246,    0.000274017  Mag (x,y,z):       -0.341512,       -1.15074,       0.550511
Gyro (x,y,z):      0.000512119,     0.00168321,    -0.00292529  Mag (x,y,z):       -0.348022,       -1.14464,       0.555083

Success!  The DK2’s sensors are being read and updating to reflect the device’s orientation.  ‘Hello World!’ is accomplished.

Now, to get my head around the Tiny World sample code…