Creating a VR application with **OpenGL** is a powerful approach that gives you flexibility and low-level control over the VR environment. To get started, we’ll use **OpenGL** for rendering and **OpenVR** (or **OpenXR**) for VR headset support. This example will focus on OpenVR since it’s compatible with multiple VR headsets (like HTC Vive, Oculus, etc.). OpenXR is another option if you need a more standardized solution, but OpenVR is still widely used for cross-platform VR.

Overview
The process of building a VR application in OpenGL involves:
1. Initializing the VR system.
2. Setting up the OpenGL context.
3. Rendering the scene separately for each eye.
4. Submitting the rendered textures to the VR compositor.
5. Handling VR head-tracking and controllers.

### Prerequisites
- **OpenVR SDK**: Download it from [Valve's GitHub page](https://github.com/ValveSoftware/openvr).
- **OpenGL and GLEW**: Set up OpenGL in your project. GLEW can help with managing OpenGL extensions.
- **GLM**: (Optional) for 3D math (matrices, vectors) needed in VR development.

### Setting Up the VR Application with OpenGL and OpenVR

### Step 1: Initialize OpenVR
First, initialize OpenVR to connect with the VR headset.

```cpp

#include <openvr.h>

#include <GL/glew.h>

#include <GLFW/glfw3.h>

#include <iostream>

vr::IVRSystem* vrSystem = nullptr;

bool initOpenVR() {

    vr::EVRInitError vrError = vr::VRInitError_None;

    vrSystem = vr::VR_Init(&vrError, vr::VRApplication_Scene);

    if (vrError != vr::VRInitError_None) {

        std::cerr << "Failed to initialize OpenVR: " << vr::VR_GetVRInitErrorAsSymbol(vrError) << std::endl;

        return false;

    }

    if (!vr::VRCompositor()) {

        std::cerr << "Failed to initialize VR Compositor." << std::endl;

        vr::VR_Shutdown();

        return false;

    }

    return true;

}

```

### Step 2: Set Up OpenGL Context and Framebuffer
You need to set up an OpenGL context using a library like **GLFW** or **SDL**. For VR, each eye will need its own framebuffer.

```cpp

GLFWwindow* window;

GLuint leftEyeFramebuffer, rightEyeFramebuffer;

GLuint leftEyeTexture, rightEyeTexture;

GLuint depthBuffer;

bool initOpenGL() {

    if (!glfwInit()) {

        std::cerr << "Failed to initialize GLFW." << std::endl;

        return false;

    }

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);

    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);

    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    window = glfwCreateWindow(800, 600, "OpenGL VR Application", nullptr, nullptr);

    if (!window) {

        std::cerr << "Failed to create GLFW window." << std::endl;

        return false;

    }

    glfwMakeContextCurrent(window);

    glewExperimental = GL_TRUE;

    glewInit();

    // Create framebuffers for each eye

    glGenFramebuffers(1, &leftEyeFramebuffer);

    glGenFramebuffers(1, &rightEyeFramebuffer);

    glGenTextures(1, &leftEyeTexture);

    glGenTextures(1, &rightEyeTexture);

    glGenRenderbuffers(1, &depthBuffer);

    // Configure texture and framebuffer for left and right eye

    glBindTexture(GL_TEXTURE_2D, leftEyeTexture);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 1024, 1024, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    glBindFramebuffer(GL_FRAMEBUFFER, leftEyeFramebuffer);

    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, leftEyeTexture, 0);

    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthBuffer);

    // Repeat for right eye

    glBindTexture(GL_TEXTURE_2D, rightEyeTexture);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 1024, 1024, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);

    glBindFramebuffer(GL_FRAMEBUFFER, rightEyeFramebuffer);

    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rightEyeTexture, 0);

    return true;

}

```

### Step 3: Set Up Projection Matrices for Each Eye
Each eye needs a different projection matrix to achieve a stereoscopic effect.

```cpp

glm::mat4 getEyeProjection(vr::Hmd_Eye eye) {

    vr::HmdMatrix44_t proj = vrSystem->GetProjectionMatrix(eye, 0.1f, 100.0f);

    glm::mat4 matrix = glm::mat4(

        proj.m[0][0], proj.m[1][0], proj.m[2][0], proj.m[3][0],

        proj.m[0][1], proj.m[1][1], proj.m[2][1], proj.m[3][1],

        proj.m[0][2], proj.m[1][2], proj.m[2][2], proj.m[3][2],

        proj.m[0][3], proj.m[1][3], proj.m[2][3], proj.m[3][3]

    );

    return matrix;

}

```

### Step 4: Render Scene for Each Eye
Render the scene once for each eye and submit the textures to the VR compositor.

```cpp

void renderScene(GLuint framebuffer, const glm::mat4& viewMatrix, const glm::mat4& projectionMatrix) {

    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // Set the shader view and projection matrix

    shader.setUniform("viewMatrix", viewMatrix);

    shader.setUniform("projectionMatrix", projectionMatrix);

    // Draw scene objects here...

    glBindFramebuffer(GL_FRAMEBUFFER, 0);

}

void renderVR() {

    vr::TrackedDevicePose_t poses[vr::k_unMaxTrackedDeviceCount];

    vr::VRCompositor()->WaitGetPoses(poses, vr::k_unMaxTrackedDeviceCount, nullptr, 0);

    glm::mat4 leftEyeView = getEyeViewMatrix(vr::Eye_Left, poses);

    glm::mat4 rightEyeView = getEyeViewMatrix(vr::Eye_Right, poses);

    renderScene(leftEyeFramebuffer, leftEyeView, getEyeProjection(vr::Eye_Left));

    renderScene(rightEyeFramebuffer, rightEyeView, getEyeProjection(vr::Eye_Right));

    // Submit textures to VR compositor

    vr::Texture_t leftEyeTextureData = {(void*)(uintptr_t)leftEyeTexture, vr::TextureType_OpenGL, vr::ColorSpace_Gamma};

    vr::Texture_t rightEyeTextureData = {(void*)(uintptr_t)rightEyeTexture, vr::TextureType_OpenGL, vr::ColorSpace_Gamma};

    vr::VRCompositor()->Submit(vr::Eye_Left, &leftEyeTextureData);

    vr::VRCompositor()->Submit(vr::Eye_Right, &rightEyeTextureData);

}

```

### Step 5: Handle Input and Head Tracking
Use the poses data to track the headset and controllers. You can use OpenVR’s `poses` to update the headset’s position and orientation in real-time.

### Step 6: Clean Up and Shutdown
Clean up resources and shut down OpenVR when the application closes.

```cpp

void cleanup() {

    vr::VR_Shutdown();

    glDeleteFramebuffers(1, &leftEyeFramebuffer);

    glDeleteFramebuffers(1, &rightEyeFramebuffer);

    glfwDestroyWindow(window);

    glfwTerminate();

}

```

### Final Notes
1. **Stereo Rendering**: This setup renders one image per eye, giving a stereo effect for VR.
2. **Controller Tracking**: You can add controller input by reading from OpenVR’s `TrackedDevicePose_t` and using it for interactions.
3. **Advanced Features**: Consider implementing shader programs to enhance visuals, handle head tracking, and add controller inputs.

### Limitations
- **Performance**: VR requires high frame rates for a smooth experience. Ensure optimized rendering to avoid motion sickness.
- **OpenGL VR Limitations**: While OpenGL is versatile, VR rendering is often handled better by engines like Unity or Unreal Engine, as they have native VR support. 

For complex VR projects, consider VR-native engines or frameworks that handle stereoscopic 3D rendering and input out of the box.