Oculus + OpenGL + SDL 2 minimal demo on (Visual Studio 9).

//----------------------------------------------
// Oculus + OpenGL + SDL 2 minimal demo.
//
// Author : Olivier Renault.
//----------------------------------------------
#include <windows.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <stdio.h>
#include <limits>
#include "sdl.h"
#include "OVR.h"

#pragma comment(lib, "Winmm.lib")
#pragma comment(lib, "opengl32.lib")
#pragma comment(lib, "glu32.lib")
#pragma comment(lib, "libovr.lib")
#pragma comment (lib, "sdl2.lib")
#pragma comment (lib, "sdl2main.lib")

void trace(const char* format, ...)
{
    char temp[1024];
    va_list args;
    va_start(args, format);
    vsprintf_s(temp, sizeof(temp), format, args);
    va_end(args);
    OutputDebugString(temp);
    OutputDebugString("\n");
}

void debug_break()
{
    __asm int 3;
}

#define TRACE(A, ...)  { trace("[TRACE] %s", A, __VA_ARGS__); }
#define WARN(A, ...)   { trace("[WARN]  %s", A, __VA_ARGS__); }
#define FATAL(A, ...)  { trace("[FATAL] %s", A, __VA_ARGS__); debug_break(); }
#define ASSERT(A)      { if(!(A)) { trace("[ASSERT] %s", #A); debug_break(); } }

class Oculus : public OVR::MessageHandler
{
public:
    Oculus()
    {}

    ~Oculus()
    {
        OVR::MessageHandler::RemoveHandlerFromDevices();
        m_sensor.Clear();
        m_HMD.Clear();
        m_device_manager.Clear();

        OVR::System::Destroy();
        OVR_DEBUG_STATEMENT(_CrtDumpMemoryLeaks());
    }

    void start()
    {
        OVR::System::Init(OVR::Log::ConfigureDefaultLog(OVR::LogMask_All));

        m_device_manager = *OVR::DeviceManager::Create();

        // We'll handle it's messages in this case.
        m_device_manager->SetMessageHandler(this);

        // Release Sensor/HMD in case this is a retry.
        m_sensor.Clear();
        m_HMD.Clear();

        m_HMD = *m_device_manager->EnumerateDevices<OVR::HMDDevice>().CreateDevice();
        if (m_HMD)
        {
            m_sensor = *m_HMD->GetSensor();

            // This will initialize HMDInfo with information about configured IPD,
            // screen size and other variables needed for correct projection.
            // We pass HMD DisplayDeviceName into the renderer to select the
            // correct monitor in full-screen mode.
            m_HMD->GetDeviceInfo(&m_HMD_info);

            m_stereo_config.SetHMDInfo(m_HMD_info);
            m_stereo_config.SetFullViewport(OVR::Util::Render::Viewport(0,0, m_HMD_info.HResolution, m_HMD_info.VResolution));
            m_stereo_config.SetStereoMode(OVR::Util::Render::Stereo_LeftRight_Multipass);
            if (m_HMD_info.HScreenSize > 0.140f) // 7"
                m_stereo_config.SetDistortionFitPointVP(-1.0f, 0.0f);
            else
                m_stereo_config.SetDistortionFitPointVP(0.0f, 1.0f);
        }
        else
        {
            // If we didn't detect an HMD, try to create the sensor directly.
            // This is useful for debugging sensor interaction; it is not needed in
            // a shipping app.
            m_sensor = m_device_manager->EnumerateDevices<OVR::SensorDevice>().CreateDevice();
        }

        const char* detectionMessage=0;
        if (!m_HMD && !m_sensor)
            detectionMessage = "Oculus Rift not detected.";
        else if (!m_HMD)
            detectionMessage = "Oculus Sensor detected; HMD Display not detected.";
        else if (!m_sensor)
            detectionMessage = "Oculus HMD Display detected; Sensor not detected.";
        else if (m_HMD_info.DisplayDeviceName[0] == '\0')
            detectionMessage = "Oculus Sensor detected; HMD display EDID not detected.";
        else
            detectionMessage = 0;

        if (detectionMessage)
        {
            ::MessageBoxA(0, detectionMessage, "Oculus Rift ERROR", MB_OK);
        }

        if (m_sensor)
        {
            // We need to attach sensor to SensorFusion object for it to receive
            // body frame messages and update orientation. SFusion.GetOrientation()
            // is used in OnIdle() to orient the view.
            m_sensor_fusion.AttachToSensor(m_sensor);
            m_sensor_fusion.SetPredictionEnabled(true);
            m_sensor_fusion.SetDelegateMessageHandler(this);
        }
    }

    bool get_sensor_position(float& x, float& y, float& z) const
    {
        x = 0.0f;
        y = 0.0f;
        z = 0.0f;
        return false;
    }

    bool get_sensor_orientation(float& yaw, float& pitch, float& roll) const
    {
        yaw = 0.0f;
        pitch = 0.0f;
        roll = 0.0f;

        if(!m_sensor_fusion.IsAttachedToSensor())
            return false;

        OVR::Quatf hmdOrient = m_sensor_fusion.GetOrientation();
        hmdOrient.GetEulerAngles<OVR::Axis_Y, OVR::Axis_X, OVR::Axis_Z>(&yaw, &pitch, &roll);
        return true;
    }

    const OVR::HMDInfo& get_HMD_info() const
    {
        return m_HMD_info;
    }

    OVR::Util::Render::StereoConfig get_stereo_config() const
    {
        return m_stereo_config;
    }

    virtual void OnMessage(const OVR::Message& msg)
    {
        if(msg.pDevice == m_sensor)
        {
            if (msg.Type == OVR::Message_BodyFrame)
            {
            }
        }
        else if(msg.pDevice == m_device_manager)
        {
            if (msg.Type == OVR::Message_DeviceAdded)
            {
                trace("DeviceManager reported device added.");
            }
            else if (msg.Type == OVR::Message_DeviceRemoved)
            {
                trace("DeviceManager reported device removed.");
            }
            else if (msg.Type == OVR::Message_DeviceAdded)
            {
                trace("Sensor reported device added.");
            }
            else if (msg.Type == OVR::Message_DeviceRemoved)
            {
                trace("Sensor reported device removed.");
            }
        }
    }

private:
    OVR::Ptr<OVR::DeviceManager>            m_device_manager;
    OVR::Ptr<OVR::SensorDevice>             m_sensor;
    OVR::Ptr<OVR::HMDDevice>                m_HMD;
    OVR::HMDInfo                            m_HMD_info;
    OVR::SensorFusion                       m_sensor_fusion;
    OVR::Util::Render::StereoConfig         m_stereo_config;
};

class Avatar
{
public:
    Avatar()
    {
        m_oculus = NULL;
    }

    void start(const Oculus* oculus)
    {
        m_oculus = oculus;
        m_speed = 10.0f;
    }

    void on_key_down(int key)
    {
        switch(key)
        {
        case SDLK_UP:
            {
                m_velocity.z = -m_speed;
                break;
            }
        case SDLK_DOWN:
            {
                m_velocity.z = m_speed;
                break;
            }
        case SDLK_LEFT:
            {
                m_velocity.x = -m_speed;
                break;
            }
        case SDLK_RIGHT:
            {
                m_velocity.x = m_speed;
                break;
            }
        }
    }

    void on_key_up(int key)
    {
        switch(key)
        {
        case SDLK_UP:
            {
                m_velocity.z = 0.0f;
                break;
            }
        case SDLK_DOWN:
            {
                m_velocity.z = 0.0f;
                break;
            }
        case SDLK_LEFT:
            {
                m_velocity.x = 0.0f;
                break;
            }
        case SDLK_RIGHT:
            {
                m_velocity.x = 0.0f;
                break;
            }
        }
    }

    const OVR::Vector3f& get_position() const
    {
        return m_position;
    }

    void set_position(const OVR::Vector3f& position)
    {
        m_position = position;
    }

    void update(float dt)
    {
        m_position += m_velocity * dt;
    }

    void apply_gl_matrix(const OVR::Matrix4f& matrix)
    {
        glMultMatrixf(&(matrix.Transposed().M[0][0]));
    }

    void begin_render(OVR::Util::Render::StereoEye eye)
    {
        const OVR::Util::Render::StereoEyeParams& params = m_oculus->get_stereo_config().GetEyeRenderParams(eye);
        glViewport(params.VP.x, params.VP.y, params.VP.w, params.VP.h);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        apply_gl_matrix(params.ViewAdjust);
        apply_gl_matrix(params.Projection);

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();

        OVR::Matrix4f eye_view = get_eye_view(eye);
        apply_gl_matrix(eye_view);
    }

    OVR::Matrix4f get_eye_view(OVR::Util::Render::StereoEye eye)
    {
        static const OVR::Vector3f UpVector(0.0f, 1.0f, 0.0f);
        static const OVR::Vector3f ForwardVector(0.0f, 0.0f, -1.0f);
        static const OVR::Vector3f RightVector(1.0f, 0.0f, 0.0f);

        float yaw, pitch, roll;
        m_oculus->get_sensor_orientation(yaw, pitch, roll);
        OVR::Matrix4f eye_rpy = OVR::Matrix4f::RotationY(yaw) * OVR::Matrix4f::RotationX(pitch) * OVR::Matrix4f::RotationZ(roll);

        OVR::Vector3f eye_pos = m_position;
        OVR::Vector3f eye_forward = eye_rpy.Transform(ForwardVector);
        OVR::Vector3f eye_up = eye_rpy.Transform(UpVector);
        OVR::Vector3f eye_right = eye_rpy.Transform(RightVector);
        OVR::Matrix4f eye_view = OVR::Matrix4f::LookAtRH(eye_pos, eye_pos + eye_forward, eye_up);
        return eye_view;
    }

    float m_speed;
    OVR::Vector3f m_position;
    OVR::Vector3f m_velocity;
    const Oculus* m_oculus;
};

struct Scene
{
    int spherelist;

    Scene()
    {
        spherelist = -1;
    }
    ~Scene()
    {
        if(glIsList(spherelist))
        {
            glDeleteLists(spherelist, 1);
        }
    }

    void draw_sphere()
    {
        if(!glIsList(spherelist))
        {
            spherelist = glGenLists(1);
            glNewList(spherelist,GL_COMPILE);
            GLUquadricObj* sphere=gluNewQuadric();
            gluQuadricNormals(sphere, GLU_SMOOTH);
            gluQuadricTexture(sphere, GL_TRUE);
            gluSphere(sphere,0.5,20,20);
            gluDeleteQuadric(sphere);
            glEndList();
        }

        if(glIsList(spherelist))
        {
            glCallList(spherelist);
        }
    }

    // draw a bunch of spheres
    void draw(const OVR::Vector3f position)
    {
        float scale = 10.0f;
        float step = scale * 2.0f;
        int nx = 10;
        int ny = 1;
        int nz = 10;

        float cx = (int)(position.x / step) * step;
        float cy = (int)(position.y / step) * step;
        float cz = (int)(position.z / step) * step;

        for(int ix = 0; ix < nx; ix++)
        {
            for(int iz = 0; iz < nz; iz++)
            {
                for(int iy = 0; iy < ny; iy++)
                {
                    glPushMatrix();
                    float x = cx + (ix - nx * 0.5f)* (step);
                    float y = cy + (iy - ny * 0.5f)* (step);
                    float z = cz + (iz - nz * 0.5f)* (step);
                    glTranslatef(x, y, z);
                    glScalef(scale, scale, scale);
                    draw_sphere();
                    glPopMatrix();
                }
            }
        }
    }
};

// SDL stuff
bool sdl_debug = false;
bool sdl_quit = false;
SDL_Window *sdl_window=NULL;
SDL_GLContext sdl_opengl_context;
unsigned int sdl_frame_timestamp = 0;
unsigned int sdl_frame_timestep = 16;

// object encapsulation.
Avatar m_avatar;
Oculus m_oculus;
Scene m_scene;

void update_render(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    m_avatar.begin_render(OVR::Util::Render::StereoEye_Left);
    m_scene.draw(m_avatar.get_position());

    m_avatar.begin_render(OVR::Util::Render::StereoEye_Right);
    m_scene.draw(m_avatar.get_position());

    SDL_GL_SwapWindow(sdl_window);
}

void update_tick()
{
    unsigned int sdl_frame_time = SDL_GetTicks() - sdl_frame_timestamp;
    if(sdl_frame_time < sdl_frame_timestep) SDL_Delay(sdl_frame_timestep - sdl_frame_time);
    sdl_frame_timestamp = SDL_GetTicks();
}

void update_sdl_events()
{
    SDL_Event event;
    while( SDL_PollEvent( &event ) )
    {
        if( event.type == SDL_KEYDOWN )
        {
            if(event.key.keysym.sym == SDLK_ESCAPE)
            {
                sdl_quit = true;
            }
            else
            {
                m_avatar.on_key_down(event.key.keysym.sym);
            }
        }
        else if( event.type == SDL_KEYUP )
        {
            m_avatar.on_key_up(event.key.keysym.sym);
        }
        else if( event.type == SDL_QUIT )
        {
            sdl_quit = true;
        }
    }
}

void setup_oculus()
{
    m_oculus.start();
    m_avatar.start(&m_oculus);
}

void setup_sdl()
{
    if(SDL_Init(SDL_INIT_EVERYTHING) < 0)
        return;

    const OVR::HMDInfo& hmd_info = m_oculus.get_HMD_info();
    sdl_window = SDL_CreateWindow("Oculus!", 100, 100, hmd_info.HResolution, hmd_info.VResolution, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_BORDERLESS | SDL_WINDOW_MAXIMIZED);
    sdl_opengl_context = SDL_GL_CreateContext(sdl_window);

    if(!sdl_debug)
    {
        // set window bounds into oculus display.
        SDL_SetWindowPosition(sdl_window, hmd_info.DesktopX, hmd_info.DesktopY);
        SDL_SetWindowSize(sdl_window, hmd_info.HResolution, hmd_info.VResolution);
        //SDL_SetWindowFullscreen(sdl_window, SDL_WINDOW_FULLSCREEN);
    }
}

void setup_material()
{
    float mat_specular[4]={1.0f,1.0f,1.0f,1.0f};
    float mat_diffuse[4] ={0.5f,0.0f,0.0f,1.0f};
    float mat_ambient[4] ={0.2f,0.1f,0.1f,1.0f};
    float mat_shininess=50.0;

    glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,mat_shininess);
    glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,mat_specular);
    glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,mat_diffuse);
    glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT,mat_ambient);
}

void setup_lighting()
{
    GLfloat global_ambient[]={.3f,.3f,.3f,1.0f};
    GLfloat ambient[]={1.0f,0.0f,0.0f,1.0f};
    glLightfv(GL_LIGHT0,GL_AMBIENT,ambient);
    glLightfv(GL_LIGHT0,GL_LIGHT_MODEL_AMBIENT,global_ambient);

    GLfloat diffuse[]= { 0.5,0.5,0.5,1.0 };
    glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuse);

    GLfloat specular[] = { 1.0,1.0,1.0,1.0 };
    glLightfv(GL_LIGHT0,GL_SPECULAR,specular);

    GLfloat light_position[]={ 100.0,1000.0,100.0,1.0};
    glLightfv(GL_LIGHT0,GL_POSITION,light_position);

    glEnable(GL_LIGHT0);
    glEnable(GL_LIGHTING);
}

void setup_opengl()
{
    // shading
    glClearColor    (0.1f, 0.1f, 0.1f, 1.0f);
    glShadeModel    (GL_SMOOTH);
    glEnable        (GL_NORMALIZE);

    // culling
    glPolygonMode   (GL_FRONT_AND_BACK,GL_FILL);
    glEnable        (GL_CULL_FACE);
    glFrontFace     (GL_CW);
    glCullFace      (GL_BACK);
    glEnable        (GL_DEPTH_TEST);
    glDepthMask     (GL_TRUE);
    glDepthFunc     (GL_LEQUAL);

    // blending
    glEnable        (GL_BLEND);
    glBlendFunc     (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    setup_lighting();
    setup_material();
}

void sdl_main_loop()
{
    while(!sdl_quit)
    {
        update_tick();
        update_sdl_events();
        m_avatar.update(sdl_frame_timestep / 1000.0f);
        update_render();
    }
}

void destroy_sdl()
{
    SDL_GL_DeleteContext(sdl_opengl_context);

    SDL_DestroyWindow(sdl_window);

    SDL_Quit();
}

int SDL_main(int argc, char * argv[])
{
    setup_oculus();
    setup_sdl();
    setup_opengl();
    sdl_main_loop();
    destroy_sdl();
    return 0;
}

/*
void set_oculus_display_mode()
{
    int num_displays = SDL_GetNumVideoDisplays();

    for(int display_index = 0; display_index < num_displays; display_index++)
    {
        int num_modes = SDL_GetNumDisplayModes(display_index);

        const char * display_name = SDL_GetDisplayName(display_index);

        SDL_Rect display_bounds;
        SDL_GetDisplayBounds(display_index, &display_bounds);

        trace("---- Display[%d] '%s'. %d modes, (%dx%d)", display_index, display_name, num_modes, display_bounds.w, display_bounds.h);

        for (int display_mode = 0; display_mode < num_modes; ++display_mode)
        {
            SDL_DisplayMode mode;
            SDL_GetDisplayMode(display_index, display_mode, &mode);
            trace("\t   Mode %d:  %dx%d %dHz %d bpp", display_mode, mode.w, mode.h, mode.refresh_rate, SDL_BITSPERPIXEL(mode.format));

            // find mode that matches the display.
            // [TODO] arbitrary display index.
            if(m_oculus.get_display_index() == display_index)
            {
                // [TODO] arbitrary refresh rate and BPP.
                const OVR::HMDInfo& hmd_info = m_oculus.get_HMD_info();
                if( mode.w == hmd_info.HResolution &&
                    mode.h == hmd_info.VResolution &&
                    mode.refresh_rate == 60 &&
                    SDL_BITSPERPIXEL(mode.format) == 24)
                {
                    SDL_SetWindowDisplayMode(sdl_window, &mode);
                    SDL_SetWindowPosition(sdl_window, display_bounds.x, display_bounds.y);
                    SDL_SetWindowSize(sdl_window, display_bounds.w, display_bounds.h);
                    //SDL_SetWindowFullscreen(sdl_window, SDL_WINDOW_FULLSCREEN);
                    trace("Window bound to Oculus display mode.");
                    break;
                }
            }
        }
    }
}
*/