/// Tear-down logic.
void Shutdown()
{
// Do nothing if already shutdown.
if (g_session == nullptr)
return;
ovr_Destroy(g_session);
g_session = nullptr;
ovr_Shutdown();
}
OVR_SDL2_app::~OVR_SDL2_app()
{
if (buffer[1]) delete buffer[1];
if (buffer[0]) delete buffer[0];
if (context) SDL_GL_DeleteContext(context);
if (window) SDL_DestroyWindow(window);
if (hmd) ovrHmd_Destroy(hmd);
ovr_Shutdown();
}
/**
* Destructor.
***/
OculusTracker::~OculusTracker()
{
if (m_hSession)
{
// set performance hud to zero
ovr_SetInt(m_hSession, OVR_PERF_HUD_MODE, 0);
ovr_Destroy(m_hSession);
}
ovr_Shutdown();
if (m_hBitmapControl) CloseHandle(m_hBitmapControl);
if (m_hFont) CloseHandle(m_hFont);
}
void Renderer::cleanupOVR()
{
if(hmd_)
{
glDeleteFramebuffers(1, &framebuffer_);
glDeleteTextures(1, &renderTex_);
glDeleteTextures(1, &depthTex_);
ovrHmd_Destroy(hmd_);
}
ovr_Shutdown();
}
//-------------------------------------------------------------------------------------
int WINAPI WinMain(HINSTANCE hinst, HINSTANCE, LPSTR, int)
{
// Initializes LibOVR, and the Rift
ovrResult result = ovr_Initialize(nullptr);
VALIDATE(OVR_SUCCESS(result), "Failed to initialize libOVR.");
VALIDATE(DIRECTX.InitWindow(hinst, L"Oculus Room Tiny (DX12)"), "Failed to open window.");
DIRECTX.Run(MainLoop);
ovr_Shutdown();
return(0);
}
void releaseOculusSession() {
Q_ASSERT(refCount > 0 && session);
// HACK the Oculus runtime doesn't seem to play well with repeated shutdown / restart.
// So for now we'll just hold on to the session
#if 0
if (!--refCount) {
qCDebug(oculus) << "oculus: zero refcount, shutdown SDK and session";
ovr_Destroy(session);
ovr_Shutdown();
session = nullptr;
}
#endif
}
void VR::init()
{
#if defined(_OVR_)
ovrInitParams initParams = { ovrInit_RequestVersion, OVR_MINOR_VERSION, NULL, 0, 0 };
ovrResult result = ovr_Initialize(&initParams);
if (OVR_FAILURE(result)) {
ovrErrorInfo errorInfo;
ovr_GetLastErrorInfo(&errorInfo);
Log(L"ovr_Initialize failed: " << errorInfo.ErrorString << endl);
Error(L"ovr_Initialize failed");
return;
}
Log("LibOVR initialized ok!" << endl);
result = ovr_Create(&session, &luid);
if (OVR_FAILURE(result))
{
ovr_Shutdown();
Error(L"No Oculus Rift detected. Cannot run in OVR mode without Oculus Rift device.");
return;
}
desc = ovr_GetHmdDesc(session);
resolution = desc.Resolution;
// Start the sensor which provides the Rift’s pose and motion.
/* result = ovr_ConfigureTracking(session, ovrTrackingCap_Orientation |
ovrTrackingCap_MagYawCorrection |
ovrTrackingCap_Position, 0);
if (OVR_FAILURE(result)) Error(L"Could not enable Oculus Rift Tracking. Cannot run in OVR mode without Oculus Rift tracking.");
*/
// Setup VR components, filling out description
eyeRenderDesc[0] = ovr_GetRenderDesc(session, ovrEye_Left, desc.DefaultEyeFov[0]);
eyeRenderDesc[1] = ovr_GetRenderDesc(session, ovrEye_Right, desc.DefaultEyeFov[1]);
nextTracking();
// tracking setup complete, now init rendering:
// Configure Stereo settings.
Sizei recommenedTex0Size = ovr_GetFovTextureSize(session, ovrEye_Left, desc.DefaultEyeFov[0], 1.0f);
Sizei recommenedTex1Size = ovr_GetFovTextureSize(session, ovrEye_Right, desc.DefaultEyeFov[1], 1.0f);
buffersize_width = recommenedTex0Size.w + recommenedTex1Size.w;
buffersize_height = max(recommenedTex0Size.h, recommenedTex1Size.h);
result = ovr_RequestBoundaryVisible(session, ovrTrue);
if (OVR_FAILURE(result)) {
Log(L"Oculus Boundary system inactive.");
}
else {
Log(L"Oculus Boundary system activated!!");
}
#endif
}
void exitVR()
{
///@todo delete swap fbos
//_DestroySwapTextures();
for (int eye = 0; eye < 2; ++eye)
{
ovrTextureSwapChain& chain = g_textureSwapChain[eye];
ovr_DestroyTextureSwapChain(g_session, chain);
}
ovr_Destroy(g_session);
ovr_Shutdown();
}
void VR_Disable()
{
int i;
if( !vr_initialized )
return;
for( i = 0; i < 2; i++ ) {
DeleteFBO(eyes[i].fbo);
}
ovrHmd_DestroyMirrorTexture(hmd, (ovrTexture*)mirror_texture);
ovrHmd_Destroy(hmd);
ovr_Shutdown();
vr_initialized = false;
}
void OculusManager::destroyOculusManager()
{
glDeleteRenderbuffers(1, &l_DepthBufferId);
glDeleteTextures(1, &l_TextureId);
glDeleteFramebuffers(1, &l_FBOId);
// Clean up Oculus...
ovrHmd_Destroy(g_Hmd);
ovr_Shutdown();
// Clean up window...
glfwDestroyWindow(l_Window);
glfwTerminate();
}
OculusWorldDemoApp::~OculusWorldDemoApp()
{
CleanupDrawTextFont();
if (Hmd)
{
ovrHmd_Destroy(Hmd);
Hmd = 0;
}
CollisionModels.ClearAndRelease();
GroundCollisionModels.ClearAndRelease();
ovr_Shutdown();
}
VR::~VR() {
if (!this->xapp->ovrRendering) return;
#if defined(_OVR_)
int count;
ovr_GetTextureSwapChainLength(session, textureSwapChain, &count);
for (int i = 0; i < count; ++i)
{
texResource[i]->Release();
//texRtv[i]->Release();
}
ovr_DestroyTextureSwapChain(session, textureSwapChain);
ovr_Destroy(session);
ovr_Shutdown();
#endif
}
void vx_ovr_namespace_::OVRHMDHandleWithDevice::configureTracking()
{
sampleTime_ = ovr_GetTimeInSeconds();
ovrResult result = ovr_ConfigureTracking(session_, description_.AvailableTrackingCaps, description_.AvailableTrackingCaps);
if (OVR_FAILURE(result)) {
ovr_Shutdown();
throw new VX_OVR_RunTimeError("Failed to configure OVR tracking");
}
eyeRenderDesc_[0] = ovr_GetRenderDesc(session_, ovrEye_Left, description_.DefaultEyeFov[0]);
eyeRenderDesc_[1] = ovr_GetRenderDesc(session_, ovrEye_Right, description_.DefaultEyeFov[1]);
viewOffset_[0] = eyeRenderDesc_[0].HmdToEyeViewOffset;
viewOffset_[1] = eyeRenderDesc_[1].HmdToEyeViewOffset;
}
void GuardianSystemDemo::Start(HINSTANCE hinst)
{
ovrResult result;
result = ovr_Initialize(nullptr);
if (!OVR_SUCCESS(result)) {
printf("ovr_Initialize failed"); exit(-1);
}
ovrGraphicsLuid luid;
result = ovr_Create(&mSession, &luid);
if (!OVR_SUCCESS(result)) {
printf("ovr_Create failed"); exit(-1);
}
if (!DIRECTX.InitWindow(hinst, L"GuardianSystemDemo")) {
printf("DIRECTX.InitWindow failed"); exit(-1);
}
// Use HMD desc to initialize device
ovrHmdDesc hmdDesc = ovr_GetHmdDesc(mSession);
if (!DIRECTX.InitDevice(hmdDesc.Resolution.w / 2, hmdDesc.Resolution.h / 2, reinterpret_cast<LUID*>(&luid))) {
printf("DIRECTX.InitDevice failed"); exit(-1);
}
// Use FloorLevel tracking origin
ovr_SetTrackingOriginType(mSession, ovrTrackingOrigin_FloorLevel);
InitRenderTargets(hmdDesc);
InitSceneGraph();
mLastUpdateClock = std::chrono::high_resolution_clock::now();
// Main Loop
while (DIRECTX.HandleMessages() && !mShouldQuit)
{
ovrSessionStatus sessionStatus;
ovr_GetSessionStatus(mSession, &sessionStatus);
if (sessionStatus.ShouldQuit)
break;
float elapsedTimeSec = UpdateTimeWithBoundaryTest();
UpdateBoundaryLookAndFeel();
UpdateObjectsCollisionWithBoundary(elapsedTimeSec);
Render();
}
ovr_Shutdown();
}
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
static void
oculus_OculusRiftDK2_dealloc(oculus_OculusRiftDK2 *self)
{
/* Close oculus session */
if (self->device)
ovrHmd_Destroy(self->device);
/* If this instance was the last one, which used the initialised LibOVR */
if (!--CONTROLLER_COUNT)
{
IS_INITIALISED = false;
ovr_Shutdown();
}
/* Free self as a python object */
Py_TYPE(self)->tp_free((PyObject *)self);
}
void OculusInterface::init()
{
try
{
ovr_Initialize();
hmd = ovrHmd_Create(0);
if(hmd)
ovrHmd_GetDesc(hmd, &hmdDesc);
else
throw 0;
}
catch(int e)
{
cout << "Cannot get HMD" << endl;
//for now.
// initialized = false;
// return;
//TODO replace content of this exeption catch by creating a virtual debug HMD to run correctly
hmd = ovrHmd_CreateDebug(ovrHmd_DK2);
ovrHmd_GetDesc(hmd, &hmdDesc);
}
customReport();
try
{
if(!ovrHmd_StartSensor(hmd,ovrSensorCap_Orientation |ovrSensorCap_YawCorrection |ovrSensorCap_Position,ovrSensorCap_Orientation)) //minial required
throw string("Unable to start sensor! The detected device by OVR is not capable to get sensor state. We cannot do anything with that...");
}
catch (string const& e)
{
cerr << e << endl;
ovrHmd_Destroy(hmd);
ovr_Shutdown();
abort();
}
initialized = true;
}
virtual int run() {
SAY("Initializing SDK");
ovr_Initialize();
int hmdCount = ovrHmd_Detect();
SAY("Found %d connected Rift device(s)", hmdCount);
for (int i = 0; i < hmdCount; ++i) {
ovrHmd hmd = ovrHmd_Create(i);
SAY(hmd->ProductName);
ovrHmd_Destroy(hmd);
}
ovrHmd hmd = ovrHmd_CreateDebug(ovrHmd_DK2);
SAY(hmd->ProductName);
ovrHmd_Destroy(hmd);
ovr_Shutdown();
SAY("Exiting");
return 0;
}
//--------------------------------------------------------------------------------------
// 作成したオブジェクトを破棄する
//--------------------------------------------------------------------------------------
void CleanupDevice()
{
if( g_pTextureOculus ) g_pTextureOculus->Release();
if( g_pRenderTargetViewOculus ) g_pRenderTargetViewOculus->Release();
if( g_pShaderResViewOculus ) g_pShaderResViewOculus->Release();
if( g_pPixelShaderOculus ) g_pPixelShaderOculus->Release();
if( g_pVertexShaderOculus ) g_pVertexShaderOculus->Release();
if (g_pVertexBufferOculus[0]) g_pVertexBufferOculus[0]->Release();
if (g_pVertexBufferOculus[1]) g_pVertexBufferOculus[1]->Release();
if (g_pIndexBufferOculus[0]) g_pIndexBufferOculus[0]->Release();
if (g_pIndexBufferOculus[1]) g_pIndexBufferOculus[1]->Release();
if (g_pDepthStencilOculus) g_pDepthStencilOculus->Release();
if (g_pDepthStencilViewOculus) g_pDepthStencilViewOculus->Release();
if (g_pVertexLayoutOculus) g_pVertexLayoutOculus->Release();
if (g_pConstantBufferOculus) g_pConstantBufferOculus->Release();
if (g_pDepthStencil) g_pDepthStencil->Release();
if (g_pDepthStencilView) g_pDepthStencilView->Release();
if (g_pIndexBuffer) g_pIndexBuffer->Release();
if (g_pTextureRV) g_pTextureRV->Release();
if (g_pSamplerLinear) g_pSamplerLinear->Release();
if( g_pVertexBuffer ) g_pVertexBuffer->Release();
if( g_pVertexLayout ) g_pVertexLayout->Release();
if( g_pVertexShader ) g_pVertexShader->Release();
if( g_pPixelShader ) g_pPixelShader->Release();
if( g_pConstantBuffer ) g_pConstantBuffer->Release();
if( g_pRenderTargetView ) g_pRenderTargetView->Release();
if( g_pSwapChain ) g_pSwapChain->Release();
if( g_pImmediateContext ) g_pImmediateContext->Release();
if( g_pd3dDevice ) g_pd3dDevice->Release();
//Oculus Rift(libovr)用
ovrHmd_Destroy(HMD);
ovr_Shutdown();
}
virtual ~SensorFusionExample() {
ovr_Destroy(hmd);
ovr_Shutdown();
}
~ovr()
{
ovr_Shutdown();
}
DLL_EXPORT_API void xnOvrShutdown()
{
ovr_Shutdown();
}
void RiftShutdown()
{
ovrHmd_Destroy(s_hmd);
ovr_Shutdown();
}
OculusDevice::~OculusDevice()
{
ovrHmd_Destroy(m_hmdDevice);
ovr_Shutdown();
}
void OVR::shutdown()
{
BX_CHECK(NULL == m_hmd, "HMD not destroyed.");
ovr_Shutdown();
m_initialized = false;
}
int main(int argc, char **argv)
{
// Initialize SDL2's context
SDL_Init(SDL_INIT_VIDEO);
// Initialize Oculus' context
ovrResult result = ovr_Initialize(nullptr);
if (OVR_FAILURE(result))
{
std::cout << "ERROR: Failed to initialize libOVR" << std::endl;
SDL_Quit();
return -1;
}
ovrSession session;
ovrGraphicsLuid luid;
// Connect to the Oculus headset
result = ovr_Create(&session, &luid);
if (OVR_FAILURE(result))
{
std::cout << "ERROR: Oculus Rift not detected" << std::endl;
ovr_Shutdown();
SDL_Quit();
return -1;
}
int x = SDL_WINDOWPOS_CENTERED, y = SDL_WINDOWPOS_CENTERED;
int winWidth = 1280;
int winHeight = 720;
Uint32 flags = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN;
// Create SDL2 Window
SDL_Window* window = SDL_CreateWindow("OVR ZED App", x, y, winWidth, winHeight, flags);
// Create OpenGL context
SDL_GLContext glContext = SDL_GL_CreateContext(window);
// Initialize GLEW
glewInit();
// Turn off vsync to let the compositor do its magic
SDL_GL_SetSwapInterval(0);
// Initialize the ZED Camera
sl::zed::Camera* zed = 0;
zed = new sl::zed::Camera(sl::zed::HD720);
sl::zed::ERRCODE zederr = zed->init(sl::zed::MODE::PERFORMANCE, 0);
int zedWidth = zed->getImageSize().width;
int zedHeight = zed->getImageSize().height;
if (zederr != sl::zed::SUCCESS)
{
std::cout << "ERROR: " << sl::zed::errcode2str(zederr) << std::endl;
ovr_Destroy(session);
ovr_Shutdown();
SDL_GL_DeleteContext(glContext);
SDL_DestroyWindow(window);
SDL_Quit();
delete zed;
return -1;
}
GLuint zedTextureID_L, zedTextureID_R;
// Generate OpenGL texture for left images of the ZED camera
glGenTextures(1, &zedTextureID_L);
glBindTexture(GL_TEXTURE_2D, zedTextureID_L);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, zedWidth, zedHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// Generate OpenGL texture for right images of the ZED camera
glGenTextures(1, &zedTextureID_R);
glBindTexture(GL_TEXTURE_2D, zedTextureID_R);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, zedWidth, zedHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
#if OPENGL_GPU_INTEROP
cudaGraphicsResource* cimg_L;
cudaGraphicsResource* cimg_R;
cudaError_t errL, errR;
errL = cudaGraphicsGLRegisterImage(&cimg_L, zedTextureID_L, GL_TEXTURE_2D, cudaGraphicsMapFlagsNone);
errR = cudaGraphicsGLRegisterImage(&cimg_R, zedTextureID_R, GL_TEXTURE_2D, cudaGraphicsMapFlagsNone);
if (errL != cudaSuccess || errR != cudaSuccess)
{
std::cout << "ERROR: cannot create CUDA texture : " << errL << "|" << errR << std::endl;
}
#endif
ovrHmdDesc hmdDesc = ovr_GetHmdDesc(session);
// Get the texture sizes of Oculus eyes
ovrSizei textureSize0 = ovr_GetFovTextureSize(session, ovrEye_Left, hmdDesc.DefaultEyeFov[0], 1.0f);
ovrSizei textureSize1 = ovr_GetFovTextureSize(session, ovrEye_Right, hmdDesc.DefaultEyeFov[1], 1.0f);
// Compute the final size of the render buffer
ovrSizei bufferSize;
bufferSize.w = textureSize0.w + textureSize1.w;
bufferSize.h = std::max(textureSize0.h, textureSize1.h);
// Initialize OpenGL swap textures to render
ovrTextureSwapChain textureChain = nullptr;
// Description of the swap chain
ovrTextureSwapChainDesc descTextureSwap = {};
descTextureSwap.Type = ovrTexture_2D;
descTextureSwap.ArraySize = 1;
descTextureSwap.Width = bufferSize.w;
descTextureSwap.Height = bufferSize.h;
descTextureSwap.MipLevels = 1;
descTextureSwap.Format = OVR_FORMAT_R8G8B8A8_UNORM_SRGB;
descTextureSwap.SampleCount = 1;
descTextureSwap.StaticImage = ovrFalse;
// Create the OpenGL texture swap chain
result = ovr_CreateTextureSwapChainGL(session, &descTextureSwap, &textureChain);
int length = 0;
ovr_GetTextureSwapChainLength(session, textureChain, &length);
if (OVR_SUCCESS(result))
{
for (int i = 0; i < length; ++i)
{
GLuint chainTexId;
ovr_GetTextureSwapChainBufferGL(session, textureChain, i, &chainTexId);
glBindTexture(GL_TEXTURE_2D, chainTexId);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
}
else
{
std::cout << "ERROR: failed creating swap texture" << std::endl;
ovr_Destroy(session);
ovr_Shutdown();
SDL_GL_DeleteContext(glContext);
SDL_DestroyWindow(window);
SDL_Quit();
delete zed;
return -1;
}
// Generate frame buffer to render
GLuint fboID;
glGenFramebuffers(1, &fboID);
// Generate depth buffer of the frame buffer
GLuint depthBuffID;
glGenTextures(1, &depthBuffID);
glBindTexture(GL_TEXTURE_2D, depthBuffID);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
GLenum internalFormat = GL_DEPTH_COMPONENT24;
GLenum type = GL_UNSIGNED_INT;
glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, bufferSize.w, bufferSize.h, 0, GL_DEPTH_COMPONENT, type, NULL);
// Create a mirror texture to display the render result in the SDL2 window
ovrMirrorTextureDesc descMirrorTexture;
memset(&descMirrorTexture, 0, sizeof(descMirrorTexture));
descMirrorTexture.Width = winWidth;
descMirrorTexture.Height = winHeight;
descMirrorTexture.Format = OVR_FORMAT_R8G8B8A8_UNORM_SRGB;
ovrMirrorTexture mirrorTexture = nullptr;
result = ovr_CreateMirrorTextureGL(session, &descMirrorTexture, &mirrorTexture);
if (!OVR_SUCCESS(result))
{
std::cout << "ERROR: Failed to create mirror texture" << std::endl;
}
GLuint mirrorTextureId;
ovr_GetMirrorTextureBufferGL(session, mirrorTexture, &mirrorTextureId);
GLuint mirrorFBOID;
glGenFramebuffers(1, &mirrorFBOID);
glBindFramebuffer(GL_READ_FRAMEBUFFER, mirrorFBOID);
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mirrorTextureId, 0);
glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
// Frame index used by the compositor
// it needs to be updated each new frame
long long frameIndex = 0;
// FloorLevel will give tracking poses where the floor height is 0
ovr_SetTrackingOriginType(session, ovrTrackingOrigin_FloorLevel);
// Initialize a default Pose
ovrPosef eyeRenderPose[2];
// Get the render description of the left and right "eyes" of the Oculus headset
ovrEyeRenderDesc eyeRenderDesc[2];
eyeRenderDesc[0] = ovr_GetRenderDesc(session, ovrEye_Left, hmdDesc.DefaultEyeFov[0]);
eyeRenderDesc[1] = ovr_GetRenderDesc(session, ovrEye_Right, hmdDesc.DefaultEyeFov[1]);
// Get the Oculus view scale description
ovrVector3f hmdToEyeOffset[2];
double sensorSampleTime;
// Create and compile the shader's sources
Shader shader(OVR_ZED_VS, OVR_ZED_FS);
// Compute the ZED image field of view with the ZED parameters
float zedFovH = atanf(zed->getImageSize().width / (zed->getParameters()->LeftCam.fx *2.f)) * 2.f;
// Compute the Horizontal Oculus' field of view with its parameters
float ovrFovH = (atanf(hmdDesc.DefaultEyeFov[0].LeftTan) + atanf(hmdDesc.DefaultEyeFov[0].RightTan));
// Compute the useful part of the ZED image
unsigned int usefulWidth = zed->getImageSize().width * ovrFovH / zedFovH;
// Compute the size of the final image displayed in the headset with the ZED image's aspect-ratio kept
unsigned int widthFinal = bufferSize.w / 2;
float heightGL = 1.f;
float widthGL = 1.f;
if (usefulWidth > 0.f)
{
unsigned int heightFinal = zed->getImageSize().height * widthFinal / usefulWidth;
// Convert this size to OpenGL viewport's frame's coordinates
heightGL = (heightFinal) / (float)(bufferSize.h);
widthGL = ((zed->getImageSize().width * (heightFinal / (float)zed->getImageSize().height)) / (float)widthFinal);
}
else
{
std::cout << "WARNING: ZED parameters got wrong values."
"Default vertical and horizontal FOV are used.\n"
"Check your calibration file or check if your ZED is not too close to a surface or an object."
<< std::endl;
}
// Compute the Vertical Oculus' field of view with its parameters
float ovrFovV = (atanf(hmdDesc.DefaultEyeFov[0].UpTan) + atanf(hmdDesc.DefaultEyeFov[0].DownTan));
// Compute the center of the optical lenses of the headset
float offsetLensCenterX = ((atanf(hmdDesc.DefaultEyeFov[0].LeftTan)) / ovrFovH) * 2.f - 1.f;
float offsetLensCenterY = ((atanf(hmdDesc.DefaultEyeFov[0].UpTan)) / ovrFovV) * 2.f - 1.f;
// Create a rectangle with the computed coordinates and push it in GPU memory.
struct GLScreenCoordinates
{
float left, up, right, down;
} screenCoord;
screenCoord.up = heightGL + offsetLensCenterY;
screenCoord.down = heightGL - offsetLensCenterY;
screenCoord.right = widthGL + offsetLensCenterX;
screenCoord.left = widthGL - offsetLensCenterX;
float rectVertices[12] = { -screenCoord.left, -screenCoord.up, 0,
screenCoord.right, -screenCoord.up, 0,
screenCoord.right, screenCoord.down, 0,
-screenCoord.left, screenCoord.down, 0 };
GLuint rectVBO[3];
glGenBuffers(1, &rectVBO[0]);
glBindBuffer(GL_ARRAY_BUFFER, rectVBO[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(rectVertices), rectVertices, GL_STATIC_DRAW);
float rectTexCoord[8] = { 0, 1, 1, 1, 1, 0, 0, 0 };
glGenBuffers(1, &rectVBO[1]);
glBindBuffer(GL_ARRAY_BUFFER, rectVBO[1]);
glBufferData(GL_ARRAY_BUFFER, sizeof(rectTexCoord), rectTexCoord, GL_STATIC_DRAW);
unsigned int rectIndices[6] = { 0, 1, 2, 0, 2, 3 };
glGenBuffers(1, &rectVBO[2]);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rectVBO[2]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(rectIndices), rectIndices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Initialize hit value
float hit = 0.02f;
// Initialize a boolean that will be used to stop the application’s loop and another one to pause/unpause rendering
bool end = false;
bool refresh = true;
// SDL variable that will be used to store input events
SDL_Event events;
// Initialize time variables. They will be used to limit the number of frames rendered per second.
// Frame counter
unsigned int riftc = 0, zedc = 1;
// Chronometer
unsigned int rifttime = 0, zedtime = 0, zedFPS = 0;
int time1 = 0, timePerFrame = 0;
int frameRate = (int)(1000 / MAX_FPS);
// This boolean is used to test if the application is focused
bool isVisible = true;
// Enable the shader
glUseProgram(shader.getProgramId());
// Bind the Vertex Buffer Objects of the rectangle that displays ZED images
// vertices
glEnableVertexAttribArray(Shader::ATTRIB_VERTICES_POS);
glBindBuffer(GL_ARRAY_BUFFER, rectVBO[0]);
glVertexAttribPointer(Shader::ATTRIB_VERTICES_POS, 3, GL_FLOAT, GL_FALSE, 0, 0);
// indices
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rectVBO[2]);
// texture coordinates
glEnableVertexAttribArray(Shader::ATTRIB_TEXTURE2D_POS);
glBindBuffer(GL_ARRAY_BUFFER, rectVBO[1]);
glVertexAttribPointer(Shader::ATTRIB_TEXTURE2D_POS, 2, GL_FLOAT, GL_FALSE, 0, 0);
// Main loop
while (!end)
{
// Compute the time used to render the previous frame
timePerFrame = SDL_GetTicks() - time1;
// If the previous frame has been rendered too fast
if (timePerFrame < frameRate)
{
// Pause the loop to have a max FPS equal to MAX_FPS
SDL_Delay(frameRate - timePerFrame);
timePerFrame = frameRate;
}
// Increment the ZED chronometer
zedtime += timePerFrame;
// If ZED chronometer reached 1 second
if (zedtime > 1000)
{
zedFPS = zedc;
zedc = 0;
zedtime = 0;
}
// Increment the Rift chronometer and the Rift frame counter
rifttime += timePerFrame;
riftc++;
// If Rift chronometer reached 200 milliseconds
if (rifttime > 200)
{
// Display FPS
std::cout << "\rRIFT FPS: " << 1000 / (rifttime / riftc) << " | ZED FPS: " << zedFPS;
// Reset Rift chronometer
rifttime = 0;
// Reset Rift frame counter
riftc = 0;
}
// Start frame chronometer
time1 = SDL_GetTicks();
// While there is an event catched and not tested
while (SDL_PollEvent(&events))
{
// If a key is released
if (events.type == SDL_KEYUP)
{
// If Q quit the application
if (events.key.keysym.scancode == SDL_SCANCODE_Q)
end = true;
// If R reset the hit value
else if (events.key.keysym.scancode == SDL_SCANCODE_R)
hit = 0.0f;
// If C pause/unpause rendering
else if (events.key.keysym.scancode == SDL_SCANCODE_C)
refresh = !refresh;
}
// If the mouse wheel is used
if (events.type == SDL_MOUSEWHEEL)
{
// Increase or decrease hit value
float s;
events.wheel.y > 0 ? s = 1.0f : s = -1.0f;
hit += 0.005f * s;
}
}
// Get texture swap index where we must draw our frame
GLuint curTexId;
int curIndex;
ovr_GetTextureSwapChainCurrentIndex(session, textureChain, &curIndex);
ovr_GetTextureSwapChainBufferGL(session, textureChain, curIndex, &curTexId);
// Call ovr_GetRenderDesc each frame to get the ovrEyeRenderDesc, as the returned values (e.g. HmdToEyeOffset) may change at runtime.
eyeRenderDesc[0] = ovr_GetRenderDesc(session, ovrEye_Left, hmdDesc.DefaultEyeFov[0]);
eyeRenderDesc[1] = ovr_GetRenderDesc(session, ovrEye_Right, hmdDesc.DefaultEyeFov[1]);
hmdToEyeOffset[0] = eyeRenderDesc[0].HmdToEyeOffset;
hmdToEyeOffset[1] = eyeRenderDesc[1].HmdToEyeOffset;
// Get eye poses, feeding in correct IPD offset
ovr_GetEyePoses(session, frameIndex, ovrTrue, hmdToEyeOffset, eyeRenderPose, &sensorSampleTime);
// If the application is focused
if (isVisible)
{
// If successful grab a new ZED image
if (!zed->grab(sl::zed::SENSING_MODE::RAW, false, false))
{
// Update the ZED frame counter
zedc++;
if (refresh)
{
#if OPENGL_GPU_INTEROP
sl::zed::Mat m = zed->retrieveImage_gpu(sl::zed::SIDE::LEFT);
cudaArray_t arrIm;
cudaGraphicsMapResources(1, &cimg_L, 0);
cudaGraphicsSubResourceGetMappedArray(&arrIm, cimg_L, 0, 0);
cudaMemcpy2DToArray(arrIm, 0, 0, m.data, m.step, zedWidth * 4, zedHeight, cudaMemcpyDeviceToDevice);
cudaGraphicsUnmapResources(1, &cimg_L, 0);
m = zed->retrieveImage_gpu(sl::zed::SIDE::RIGHT);
cudaGraphicsMapResources(1, &cimg_R, 0);
cudaGraphicsSubResourceGetMappedArray(&arrIm, cimg_R, 0, 0);
cudaMemcpy2DToArray(arrIm, 0, 0, m.data, m.step, zedWidth * 4, zedHeight, cudaMemcpyDeviceToDevice); // *4 = 4 channels * 1 bytes (uint)
cudaGraphicsUnmapResources(1, &cimg_R, 0);
#endif
// Bind the frame buffer
glBindFramebuffer(GL_FRAMEBUFFER, fboID);
// Set its color layer 0 as the current swap texture
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, curTexId, 0);
// Set its depth layer as our depth buffer
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthBuffID, 0);
// Clear the frame buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClearColor(0, 0, 0, 1);
// Render for each Oculus eye the equivalent ZED image
for (int eye = 0; eye < 2; eye++)
{
// Set the left or right vertical half of the buffer as the viewport
glViewport(eye == ovrEye_Left ? 0 : bufferSize.w / 2, 0, bufferSize.w / 2, bufferSize.h);
// Bind the left or right ZED image
glBindTexture(GL_TEXTURE_2D, eye == ovrEye_Left ? zedTextureID_L : zedTextureID_R);
#if !OPENGL_GPU_INTEROP
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, zedWidth, zedHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, zed->retrieveImage(eye == ovrEye_Left ? sl::zed::SIDE::LEFT : sl::zed::SIDE::RIGHT).data);
#endif
// Bind the hit value
glUniform1f(glGetUniformLocation(shader.getProgramId(), "hit"), eye == ovrEye_Left ? hit : -hit);
// Bind the isLeft value
glUniform1ui(glGetUniformLocation(shader.getProgramId(), "isLeft"), eye == ovrEye_Left ? 1U : 0U);
// Draw the ZED image
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
}
// Avoids an error when calling SetAndClearRenderSurface during next iteration.
// Without this, during the next while loop iteration SetAndClearRenderSurface
// would bind a framebuffer with an invalid COLOR_ATTACHMENT0 because the texture ID
// associated with COLOR_ATTACHMENT0 had been unlocked by calling wglDXUnlockObjectsNV.
glBindFramebuffer(GL_FRAMEBUFFER, fboID);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
// Commit changes to the textures so they get picked up frame
ovr_CommitTextureSwapChain(session, textureChain);
}
// Do not forget to increment the frameIndex!
frameIndex++;
}
}
/*
Note: Even if we don't ask to refresh the framebuffer or if the Camera::grab()
doesn't catch a new frame, we have to submit an image to the Rift; it
needs 75Hz refresh. Else there will be jumbs, black frames and/or glitches
in the headset.
*/
ovrLayerEyeFov ld;
ld.Header.Type = ovrLayerType_EyeFov;
// Tell to the Oculus compositor that our texture origin is at the bottom left
ld.Header.Flags = ovrLayerFlag_TextureOriginAtBottomLeft; // Because OpenGL | Disable head tracking
// Set the Oculus layer eye field of view for each view
for (int eye = 0; eye < 2; ++eye)
{
// Set the color texture as the current swap texture
ld.ColorTexture[eye] = textureChain;
// Set the viewport as the right or left vertical half part of the color texture
ld.Viewport[eye] = OVR::Recti(eye == ovrEye_Left ? 0 : bufferSize.w / 2, 0, bufferSize.w / 2, bufferSize.h);
// Set the field of view
ld.Fov[eye] = hmdDesc.DefaultEyeFov[eye];
// Set the pose matrix
ld.RenderPose[eye] = eyeRenderPose[eye];
}
ld.SensorSampleTime = sensorSampleTime;
ovrLayerHeader* layers = &ld.Header;
// Submit the frame to the Oculus compositor
// which will display the frame in the Oculus headset
result = ovr_SubmitFrame(session, frameIndex, nullptr, &layers, 1);
if (!OVR_SUCCESS(result))
{
std::cout << "ERROR: failed to submit frame" << std::endl;
glDeleteBuffers(3, rectVBO);
ovr_DestroyTextureSwapChain(session, textureChain);
ovr_DestroyMirrorTexture(session, mirrorTexture);
ovr_Destroy(session);
ovr_Shutdown();
SDL_GL_DeleteContext(glContext);
SDL_DestroyWindow(window);
SDL_Quit();
delete zed;
return -1;
}
if (result == ovrSuccess && !isVisible)
{
std::cout << "The application is now shown in the headset." << std::endl;
}
isVisible = (result == ovrSuccess);
// This is not really needed for this application but it may be usefull for an more advanced application
ovrSessionStatus sessionStatus;
ovr_GetSessionStatus(session, &sessionStatus);
if (sessionStatus.ShouldRecenter)
{
std::cout << "Recenter Tracking asked by Session" << std::endl;
ovr_RecenterTrackingOrigin(session);
}
// Copy the frame to the mirror buffer
// which will be drawn in the SDL2 image
glBindFramebuffer(GL_READ_FRAMEBUFFER, mirrorFBOID);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
GLint w = winWidth;
GLint h = winHeight;
glBlitFramebuffer(0, h, w, 0,
0, 0, w, h,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
// Swap the SDL2 window
SDL_GL_SwapWindow(window);
}
// Disable all OpenGL buffer
glDisableVertexAttribArray(Shader::ATTRIB_TEXTURE2D_POS);
glDisableVertexAttribArray(Shader::ATTRIB_VERTICES_POS);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glUseProgram(0);
glBindVertexArray(0);
// Delete the Vertex Buffer Objects of the rectangle
glDeleteBuffers(3, rectVBO);
// Delete SDL, OpenGL, Oculus and ZED context
ovr_DestroyTextureSwapChain(session, textureChain);
ovr_DestroyMirrorTexture(session, mirrorTexture);
ovr_Destroy(session);
ovr_Shutdown();
SDL_GL_DeleteContext(glContext);
SDL_DestroyWindow(window);
SDL_Quit();
delete zed;
// quit
return 0;
}
OcudumpBase::~OcudumpBase()
{
ovrHmd_Destroy(hmd);
ovr_Shutdown();
}
void OcculusCameraComponent::destroy()
{
ovrHmd_Destroy(hmd);
ovr_Shutdown();
}
OculusVR::~OculusVR()
{
ovr_Destroy(m_hmdSession);
ovr_Shutdown();
m_hmdSession = nullptr;
}
void OculusInterface::releaseOculus()
{
ovrHmd_Destroy(m_hmd);
// shutdown OVR SDK
ovr_Shutdown();
}
void VR_OVR_Shutdown()
{
if (libovrInitialized)
ovr_Shutdown();
libovrInitialized = 0;
}
