// return true to retry later (e.g. after display lost)
static bool MainLoop(bool retryCreate)
{
// Initialize these to nullptr here to handle device lost failures cleanly
ovrMirrorTexture mirrorTexture = nullptr;
OculusEyeTexture* pEyeRenderTexture[2] = { nullptr, nullptr };
Scene* roomScene = nullptr;
Camera* mainCam = nullptr;
ovrMirrorTextureDesc mirrorDesc = {};
ovrSession session;
ovrGraphicsLuid luid;
ovrResult result = ovr_Create(&session, &luid);
if (!OVR_SUCCESS(result))
return retryCreate;
ovrHmdDesc hmdDesc = ovr_GetHmdDesc(session);
// Setup Device and Graphics
// Note: the mirror window can be any size, for this sample we use 1/2 the HMD resolution
if (!DIRECTX.InitDevice(hmdDesc.Resolution.w / 2, hmdDesc.Resolution.h / 2, reinterpret_cast<LUID*>(&luid)))
goto Done;
// Make the eye render buffers (caution if actual size < requested due to HW limits).
ovrRecti eyeRenderViewport[2];
for (int eye = 0; eye < 2; ++eye)
{
ovrSizei idealSize = ovr_GetFovTextureSize(session, (ovrEyeType)eye, hmdDesc.DefaultEyeFov[eye], 1.0f);
pEyeRenderTexture[eye] = new OculusEyeTexture();
if (!pEyeRenderTexture[eye]->Init(session, idealSize.w, idealSize.h, true))
{
if (retryCreate) goto Done;
FATALERROR("Failed to create eye texture.");
}
eyeRenderViewport[eye].Pos.x = 0;
eyeRenderViewport[eye].Pos.y = 0;
eyeRenderViewport[eye].Size = idealSize;
if (!pEyeRenderTexture[eye]->TextureChain)
{
if (retryCreate) goto Done;
FATALERROR("Failed to create texture.");
}
}
// Create a mirror to see on the monitor.
mirrorDesc.Format = OVR_FORMAT_R8G8B8A8_UNORM_SRGB;
mirrorDesc.Width = DIRECTX.WinSizeW;
mirrorDesc.Height = DIRECTX.WinSizeH;
result = ovr_CreateMirrorTextureDX(session, DIRECTX.CommandQueue, &mirrorDesc, &mirrorTexture);
if (!OVR_SUCCESS(result))
{
if (retryCreate) goto Done;
FATALERROR("Failed to create mirror texture.");
}
// Create the room model
roomScene = new Scene(false);
// Create camera
mainCam = new Camera(XMVectorSet(0.0f, 1.6f, 5.0f, 0), XMQuaternionIdentity());
// Setup VR components, filling out description
ovrEyeRenderDesc eyeRenderDesc[2];
eyeRenderDesc[0] = ovr_GetRenderDesc(session, ovrEye_Left, hmdDesc.DefaultEyeFov[0]);
eyeRenderDesc[1] = ovr_GetRenderDesc(session, ovrEye_Right, hmdDesc.DefaultEyeFov[1]);
long long frameIndex = 0;
bool drawMirror = true;
DIRECTX.InitFrame(drawMirror);
// Main loop
while (DIRECTX.HandleMessages())
{
ovrSessionStatus sessionStatus;
ovr_GetSessionStatus(session, &sessionStatus);
if (sessionStatus.ShouldQuit)
{
// Because the application is requested to quit, should not request retry
retryCreate = false;
break;
}
if (sessionStatus.ShouldRecenter)
ovr_RecenterTrackingOrigin(session);
if (sessionStatus.IsVisible)
{
XMVECTOR forward = XMVector3Rotate(XMVectorSet(0, 0, -0.05f, 0), mainCam->GetRotVec());
XMVECTOR right = XMVector3Rotate(XMVectorSet(0.05f, 0, 0, 0), mainCam->GetRotVec());
XMVECTOR mainCamPos = mainCam->GetPosVec();
XMVECTOR mainCamRot = mainCam->GetRotVec();
if (DIRECTX.Key['W'] || DIRECTX.Key[VK_UP]) mainCamPos = XMVectorAdd( mainCamPos, forward);
if (DIRECTX.Key['S'] || DIRECTX.Key[VK_DOWN]) mainCamPos = XMVectorSubtract(mainCamPos, forward);
if (DIRECTX.Key['D']) mainCamPos = XMVectorAdd( mainCamPos, right);
if (DIRECTX.Key['A']) mainCamPos = XMVectorSubtract(mainCamPos, right);
static float Yaw = 0;
if (DIRECTX.Key[VK_LEFT]) mainCamRot = XMQuaternionRotationRollPitchYaw(0, Yaw += 0.02f, 0);
if (DIRECTX.Key[VK_RIGHT]) mainCamRot = XMQuaternionRotationRollPitchYaw(0, Yaw -= 0.02f, 0);
mainCam->SetPosVec(mainCamPos);
mainCam->SetRotVec(mainCamRot);
// Animate the cube
static float cubeClock = 0;
roomScene->Models[0]->Pos = XMFLOAT3(9 * sin(cubeClock), 3, 9 * cos(cubeClock += 0.015f));
// Get both eye poses simultaneously, with IPD offset already included.
ovrPosef EyeRenderPose[2];
ovrVector3f HmdToEyeOffset[2] = { eyeRenderDesc[0].HmdToEyeOffset,
eyeRenderDesc[1].HmdToEyeOffset };
double sensorSampleTime; // sensorSampleTime is fed into the layer later
ovr_GetEyePoses(session, frameIndex, ovrTrue, HmdToEyeOffset, EyeRenderPose, &sensorSampleTime);
// Render Scene to Eye Buffers
for (int eye = 0; eye < 2; ++eye)
{
DIRECTX.SetActiveContext(eye == 0 ? DrawContext_EyeRenderLeft : DrawContext_EyeRenderRight);
DIRECTX.SetActiveEye(eye);
CD3DX12_RESOURCE_BARRIER resBar = CD3DX12_RESOURCE_BARRIER::Transition(pEyeRenderTexture[eye]->GetD3DResource(),
D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE,
D3D12_RESOURCE_STATE_RENDER_TARGET);
DIRECTX.CurrentFrameResources().CommandLists[DIRECTX.ActiveContext]->ResourceBarrier(1, &resBar);
DIRECTX.SetAndClearRenderTarget(pEyeRenderTexture[eye]->GetRtv(), pEyeRenderTexture[eye]->GetDsv());
DIRECTX.SetViewport((float)eyeRenderViewport[eye].Pos.x, (float)eyeRenderViewport[eye].Pos.y,
(float)eyeRenderViewport[eye].Size.w, (float)eyeRenderViewport[eye].Size.h);
//Get the pose information in XM format
XMVECTOR eyeQuat = XMVectorSet(EyeRenderPose[eye].Orientation.x, EyeRenderPose[eye].Orientation.y,
EyeRenderPose[eye].Orientation.z, EyeRenderPose[eye].Orientation.w);
XMVECTOR eyePos = XMVectorSet(EyeRenderPose[eye].Position.x, EyeRenderPose[eye].Position.y, EyeRenderPose[eye].Position.z, 0);
// Get view and projection matrices for the Rift camera
Camera finalCam(XMVectorAdd(mainCamPos, XMVector3Rotate(eyePos, mainCamRot)), XMQuaternionMultiply(eyeQuat, mainCamRot));
XMMATRIX view = finalCam.GetViewMatrix();
ovrMatrix4f p = ovrMatrix4f_Projection(eyeRenderDesc[eye].Fov, 0.2f, 1000.0f, ovrProjection_None);
XMMATRIX proj = XMMatrixSet(p.M[0][0], p.M[1][0], p.M[2][0], p.M[3][0],
p.M[0][1], p.M[1][1], p.M[2][1], p.M[3][1],
p.M[0][2], p.M[1][2], p.M[2][2], p.M[3][2],
p.M[0][3], p.M[1][3], p.M[2][3], p.M[3][3]);
XMMATRIX prod = XMMatrixMultiply(view, proj);
roomScene->Render(&prod, 1, 1, 1, 1, true);
resBar = CD3DX12_RESOURCE_BARRIER::Transition(pEyeRenderTexture[eye]->GetD3DResource(),
D3D12_RESOURCE_STATE_RENDER_TARGET,
D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
DIRECTX.CurrentFrameResources().CommandLists[DIRECTX.ActiveContext]->ResourceBarrier(1, &resBar);
// Commit rendering to the swap chain
pEyeRenderTexture[eye]->Commit();
// kick off eye render command lists before ovr_SubmitFrame()
DIRECTX.SubmitCommandList(DIRECTX.ActiveContext);
}
// Initialize our single full screen Fov layer.
ovrLayerEyeFov ld = {};
ld.Header.Type = ovrLayerType_EyeFov;
ld.Header.Flags = 0;
for (int eye = 0; eye < 2; ++eye)
{
ld.ColorTexture[eye] = pEyeRenderTexture[eye]->TextureChain;
ld.Viewport[eye] = eyeRenderViewport[eye];
ld.Fov[eye] = hmdDesc.DefaultEyeFov[eye];
ld.RenderPose[eye] = EyeRenderPose[eye];
ld.SensorSampleTime = sensorSampleTime;
}
ovrLayerHeader* layers = &ld.Header;
result = ovr_SubmitFrame(session, frameIndex, nullptr, &layers, 1);
// exit the rendering loop if submit returns an error, will retry on ovrError_DisplayLost
if (!OVR_SUCCESS(result))
goto Done;
frameIndex++;
}
if (drawMirror)
{
DIRECTX.SetActiveContext(DrawContext_Final);
DIRECTX.SetViewport(0.0f, 0.0f, (float)hmdDesc.Resolution.w / 2, (float)hmdDesc.Resolution.h / 2);
// Render mirror
ID3D12Resource* mirrorTexRes = nullptr;
ovr_GetMirrorTextureBufferDX(session, mirrorTexture, IID_PPV_ARGS(&mirrorTexRes));
//DIRECTX.SetAndClearRenderTarget(DIRECTX.CurrentFrameResources().SwapChainRtvHandle, nullptr, 1.0f, 0.5f, 0.0f, 1.0f);
CD3DX12_RESOURCE_BARRIER preMirrorBlitBar[] =
{
CD3DX12_RESOURCE_BARRIER::Transition(DIRECTX.CurrentFrameResources().SwapChainBuffer, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_DEST),
CD3DX12_RESOURCE_BARRIER::Transition(mirrorTexRes, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE)
};
// Indicate that the back buffer will now be copied into
DIRECTX.CurrentFrameResources().CommandLists[DIRECTX.ActiveContext]->ResourceBarrier(ARRAYSIZE(preMirrorBlitBar), preMirrorBlitBar);
DIRECTX.CurrentFrameResources().CommandLists[DIRECTX.ActiveContext]->CopyResource(DIRECTX.CurrentFrameResources().SwapChainBuffer, mirrorTexRes);
CD3DX12_RESOURCE_BARRIER resBar = CD3DX12_RESOURCE_BARRIER::Transition(mirrorTexRes,
D3D12_RESOURCE_STATE_COPY_SOURCE,
D3D12_RESOURCE_STATE_RENDER_TARGET);
DIRECTX.CurrentFrameResources().CommandLists[DIRECTX.ActiveContext]->ResourceBarrier(1, &resBar);
}
DIRECTX.SubmitCommandListAndPresent(drawMirror);
}
// Release resources
Done:
delete mainCam;
delete roomScene;
if (mirrorTexture)
ovr_DestroyMirrorTexture(session, mirrorTexture);
for (int eye = 0; eye < 2; ++eye)
{
delete pEyeRenderTexture[eye];
}
DIRECTX.ReleaseDevice();
ovr_Destroy(session);
// Retry on ovrError_DisplayLost
return retryCreate || (result == ovrError_DisplayLost);
}
DLL_EXPORT_API npBool xnOvrCreateTexturesDx(xnOvrSession* session, void* dxDevice, int* outTextureCount, float pixelPerDisplayPixel, int mirrorBufferWidth, int mirrorBufferHeight)
{
session->HmdDesc = ovr_GetHmdDesc(session->Session);
ovrSizei sizel = ovr_GetFovTextureSize(session->Session, ovrEye_Left, session->HmdDesc.DefaultEyeFov[0], pixelPerDisplayPixel);
ovrSizei sizer = ovr_GetFovTextureSize(session->Session, ovrEye_Right, session->HmdDesc.DefaultEyeFov[1], pixelPerDisplayPixel);
ovrSizei bufferSize;
bufferSize.w = sizel.w + sizer.w;
bufferSize.h = fmax(sizel.h, sizer.h);
ovrTextureSwapChainDesc texDesc = {};
texDesc.Type = ovrTexture_2D;
texDesc.Format = OVR_FORMAT_R8G8B8A8_UNORM_SRGB;
texDesc.ArraySize = 1;
texDesc.Width = bufferSize.w;
texDesc.Height = bufferSize.h;
texDesc.MipLevels = 1;
texDesc.SampleCount = 1;
texDesc.StaticImage = ovrFalse;
texDesc.MiscFlags = ovrTextureMisc_None;
texDesc.BindFlags = ovrTextureBind_DX_RenderTarget;
if(!OVR_SUCCESS(ovr_CreateTextureSwapChainDX(session->Session, dxDevice, &texDesc, &session->SwapChain)))
{
return false;
}
auto count = 0;
ovr_GetTextureSwapChainLength(session->Session, session->SwapChain, &count);
*outTextureCount = count;
//init structures
session->EyeRenderDesc[0] = ovr_GetRenderDesc(session->Session, ovrEye_Left, session->HmdDesc.DefaultEyeFov[0]);
session->EyeRenderDesc[1] = ovr_GetRenderDesc(session->Session, ovrEye_Right, session->HmdDesc.DefaultEyeFov[1]);
session->HmdToEyeViewOffset[0] = session->EyeRenderDesc[0].HmdToEyeOffset;
session->HmdToEyeViewOffset[1] = session->EyeRenderDesc[1].HmdToEyeOffset;
session->Layer.Header.Type = ovrLayerType_EyeFov;
session->Layer.Header.Flags = 0;
session->Layer.ColorTexture[0] = session->SwapChain;
session->Layer.ColorTexture[1] = session->SwapChain;
session->Layer.Fov[0] = session->EyeRenderDesc[0].Fov;
session->Layer.Fov[1] = session->EyeRenderDesc[1].Fov;
session->Layer.Viewport[0].Pos.x = 0;
session->Layer.Viewport[0].Pos.y = 0;
session->Layer.Viewport[0].Size.w = bufferSize.w / 2;
session->Layer.Viewport[0].Size.h = bufferSize.h;
session->Layer.Viewport[1].Pos.x = bufferSize.w / 2;
session->Layer.Viewport[1].Pos.y = 0;
session->Layer.Viewport[1].Size.w = bufferSize.w / 2;
session->Layer.Viewport[1].Size.h = bufferSize.h;
//create mirror as well
if (mirrorBufferHeight != 0 && mirrorBufferWidth != 0)
{
ovrMirrorTextureDesc mirrorDesc = {};
mirrorDesc.Format = OVR_FORMAT_R8G8B8A8_UNORM_SRGB;
mirrorDesc.Width = mirrorBufferWidth;
mirrorDesc.Height = mirrorBufferHeight;
if (!OVR_SUCCESS(ovr_CreateMirrorTextureDX(session->Session, dxDevice, &mirrorDesc, &session->Mirror)))
{
return false;
}
}
return true;
}
// return true to retry later (e.g. after display lost)
static bool MainLoop(bool retryCreate)
{
// Initialize these to nullptr here to handle device lost failures cleanly
ovrMirrorTexture mirrorTexture = nullptr;
OculusTexture * pEyeRenderTexture = nullptr;
DepthBuffer * pEyeDepthBuffer = nullptr;
Scene * roomScene = nullptr;
Camera * mainCam = nullptr;
ovrMirrorTextureDesc desc = {};
bool isVisible = true;
long long frameIndex = 0;
bool useInstancing = false;
const int repeatDrawing = 1;
ovrSession session;
ovrGraphicsLuid luid;
ovrResult result = ovr_Create(&session, &luid);
if (!OVR_SUCCESS(result))
return retryCreate;
ovrHmdDesc hmdDesc = ovr_GetHmdDesc(session);
// Setup Device and Graphics
// Note: the mirror window can be any size, for this sample we use 1/2 the HMD resolution
if (!DIRECTX.InitDevice(hmdDesc.Resolution.w / 2, hmdDesc.Resolution.h / 2, reinterpret_cast<LUID*>(&luid)))
goto Done;
ovrRecti eyeRenderViewport[2];
// Make a single eye texture
{
ovrSizei eyeTexSizeL = ovr_GetFovTextureSize(session, ovrEye_Left, hmdDesc.DefaultEyeFov[0], 1.0f);
ovrSizei eyeTexSizeR = ovr_GetFovTextureSize(session, ovrEye_Right, hmdDesc.DefaultEyeFov[1], 1.0f);
ovrSizei textureSize;
textureSize.w = eyeTexSizeL.w + eyeTexSizeR.w;
textureSize.h = max(eyeTexSizeL.h, eyeTexSizeR.h);
pEyeRenderTexture = new OculusTexture();
if (!pEyeRenderTexture->Init(session, textureSize.w, textureSize.h))
{
if (retryCreate) goto Done;
VALIDATE(OVR_SUCCESS(result), "Failed to create eye texture.");
}
pEyeDepthBuffer = new DepthBuffer(DIRECTX.Device, textureSize.w, textureSize.h);
// set viewports
eyeRenderViewport[0].Pos.x = 0;
eyeRenderViewport[0].Pos.y = 0;
eyeRenderViewport[0].Size = eyeTexSizeL;
eyeRenderViewport[1].Pos.x = eyeTexSizeL.w;
eyeRenderViewport[1].Pos.y = 0;
eyeRenderViewport[1].Size = eyeTexSizeR;
}
if (!pEyeRenderTexture->TextureChain)
{
if (retryCreate) goto Done;
VALIDATE(false, "Failed to create texture.");
}
// Create a mirror to see on the monitor.
desc.Format = OVR_FORMAT_R8G8B8A8_UNORM_SRGB;
desc.Width = DIRECTX.WinSizeW;
desc.Height = DIRECTX.WinSizeH;
result = ovr_CreateMirrorTextureDX(session, DIRECTX.Device, &desc, &mirrorTexture);
if (!OVR_SUCCESS(result))
{
if (retryCreate) goto Done;
VALIDATE(false, "Failed to create mirror texture.");
}
// Create the room model
roomScene = new Scene(false);
// Create camera
mainCam = new Camera(&XMVectorSet(0.0f, 1.6f, 5.0f, 0), &XMQuaternionIdentity());
// Setup VR components, filling out description
ovrEyeRenderDesc eyeRenderDesc[2];
eyeRenderDesc[0] = ovr_GetRenderDesc(session, ovrEye_Left, hmdDesc.DefaultEyeFov[0]);
eyeRenderDesc[1] = ovr_GetRenderDesc(session, ovrEye_Right, hmdDesc.DefaultEyeFov[1]);
// Main loop
while (DIRECTX.HandleMessages())
{
XMVECTOR forward = XMVector3Rotate(XMVectorSet(0, 0, -0.05f, 0), mainCam->Rot);
XMVECTOR right = XMVector3Rotate(XMVectorSet(0.05f, 0, 0, 0), mainCam->Rot);
XMVECTOR up = XMVector3Rotate(XMVectorSet(0, 0.05f, 0, 0), mainCam->Rot);
if (DIRECTX.Key['W'] || DIRECTX.Key[VK_UP]) mainCam->Pos = XMVectorAdd(mainCam->Pos, forward);
if (DIRECTX.Key['S'] || DIRECTX.Key[VK_DOWN]) mainCam->Pos = XMVectorSubtract(mainCam->Pos, forward);
if (DIRECTX.Key['D']) mainCam->Pos = XMVectorAdd(mainCam->Pos, right);
if (DIRECTX.Key['A']) mainCam->Pos = XMVectorSubtract(mainCam->Pos, right);
if (DIRECTX.Key['Q']) mainCam->Pos = XMVectorAdd(mainCam->Pos, up);
if (DIRECTX.Key['E']) mainCam->Pos = XMVectorSubtract(mainCam->Pos, up);
static float Yaw = 0;
if (DIRECTX.Key[VK_LEFT]) mainCam->Rot = XMQuaternionRotationRollPitchYaw(0, Yaw += 0.02f, 0);
if (DIRECTX.Key[VK_RIGHT]) mainCam->Rot = XMQuaternionRotationRollPitchYaw(0, Yaw -= 0.02f, 0);
if (DIRECTX.Key['P'])
ovr_SetInt(session, OVR_PERF_HUD_MODE, int(ovrPerfHud_AppRenderTiming));
else
ovr_SetInt(session, OVR_PERF_HUD_MODE, int(ovrPerfHud_Off));
useInstancing = DIRECTX.Key['I'];
// Animate the cube
static float cubeClock = 0;
roomScene->Models[0]->Pos = XMFLOAT3(9 * sin(cubeClock), 3, 9 * cos(cubeClock += 0.015f));
// Get both eye poses simultaneously, with IPD offset already included.
ovrPosef EyeRenderPose[2];
ovrVector3f HmdToEyeOffset[2] = { eyeRenderDesc[0].HmdToEyeOffset,
eyeRenderDesc[1].HmdToEyeOffset };
double sensorSampleTime; // sensorSampleTime is fed into the layer later
ovr_GetEyePoses(session, frameIndex, ovrTrue, HmdToEyeOffset, EyeRenderPose, &sensorSampleTime);
// Render scene to eye texture
if (isVisible)
{
DIRECTX.SetAndClearRenderTarget(pEyeRenderTexture->GetRTV(), pEyeDepthBuffer);
// calculate eye transforms
XMMATRIX viewProjMatrix[2];
for (int eye = 0; eye < 2; ++eye)
{
//Get the pose information in XM format
XMVECTOR eyeQuat = XMLoadFloat4((XMFLOAT4 *)&EyeRenderPose[eye].Orientation.x);
XMVECTOR eyePos = XMVectorSet(EyeRenderPose[eye].Position.x, EyeRenderPose[eye].Position.y, EyeRenderPose[eye].Position.z, 0);
// Get view and projection matrices for the Rift camera
XMVECTOR CombinedPos = XMVectorAdd(mainCam->Pos, XMVector3Rotate(eyePos, mainCam->Rot));
Camera finalCam(&CombinedPos, &(XMQuaternionMultiply(eyeQuat, mainCam->Rot)));
XMMATRIX view = finalCam.GetViewMatrix();
ovrMatrix4f p = ovrMatrix4f_Projection(eyeRenderDesc[eye].Fov, 0.1f, 100.0f, ovrProjection_None);
XMMATRIX proj = XMMatrixSet(p.M[0][0], p.M[1][0], p.M[2][0], p.M[3][0],
p.M[0][1], p.M[1][1], p.M[2][1], p.M[3][1],
p.M[0][2], p.M[1][2], p.M[2][2], p.M[3][2],
p.M[0][3], p.M[1][3], p.M[2][3], p.M[3][3]);
if (useInstancing)
{
// scale and offset projection matrix to shift image to correct part of texture for each eye
XMMATRIX scale = XMMatrixScaling(0.5f, 1.0f, 1.0f);
XMMATRIX translate = XMMatrixTranslation((eye==0) ? -0.5f : 0.5f, 0.0f, 0.0f);
proj = XMMatrixMultiply(proj, scale);
proj = XMMatrixMultiply(proj, translate);
}
viewProjMatrix[eye] = XMMatrixMultiply(view, proj);
}
if (useInstancing)
{
// use instancing for stereo
DIRECTX.SetViewport(0.0f, 0.0f, (float)eyeRenderViewport[0].Size.w + eyeRenderViewport[1].Size.w, (float)eyeRenderViewport[0].Size.h);
// render scene
for (int i = 0; i < repeatDrawing; i++)
roomScene->RenderInstanced(&viewProjMatrix[0], 1, 1, 1, 1, true);
}
else
{
// non-instanced path
for (int eye = 0; eye < 2; ++eye)
{
// set viewport
DIRECTX.SetViewport((float)eyeRenderViewport[eye].Pos.x, (float)eyeRenderViewport[eye].Pos.y,
(float)eyeRenderViewport[eye].Size.w, (float)eyeRenderViewport[eye].Size.h);
// render scene
for (int i = 0; i < repeatDrawing; i++)
roomScene->Render(&viewProjMatrix[eye], 1, 1, 1, 1, true);
}
}
// Commit rendering to the swap chain
pEyeRenderTexture->Commit();
}
// Initialize our single full screen Fov layer.
ovrLayerEyeFov ld = {};
ld.Header.Type = ovrLayerType_EyeFov;
ld.Header.Flags = 0;
ld.SensorSampleTime = sensorSampleTime;
for (int eye = 0; eye < 2; ++eye)
{
ld.ColorTexture[eye] = pEyeRenderTexture->TextureChain;
ld.Viewport[eye] = eyeRenderViewport[eye];
ld.Fov[eye] = hmdDesc.DefaultEyeFov[eye];
ld.RenderPose[eye] = EyeRenderPose[eye];
}
ovrLayerHeader* layers = &ld.Header;
result = ovr_SubmitFrame(session, frameIndex, nullptr, &layers, 1);
// exit the rendering loop if submit returns an error, will retry on ovrError_DisplayLost
if (!OVR_SUCCESS(result))
goto Done;
isVisible = (result == ovrSuccess);
// Render mirror
ID3D11Texture2D* tex = nullptr;
ovr_GetMirrorTextureBufferDX(session, mirrorTexture, IID_PPV_ARGS(&tex));
DIRECTX.Context->CopyResource(DIRECTX.BackBuffer, tex);
tex->Release();
DIRECTX.SwapChain->Present(0, 0);
frameIndex++;
}
// Release resources
Done:
delete mainCam;
delete roomScene;
if (mirrorTexture) ovr_DestroyMirrorTexture(session, mirrorTexture);
delete pEyeRenderTexture;
delete pEyeDepthBuffer;
DIRECTX.ReleaseDevice();
ovr_Destroy(session);
// Retry on ovrError_DisplayLost
return retryCreate || OVR_SUCCESS(result) || (result == ovrError_DisplayLost);
}
