void initGl() {
RiftGlfwApp::initGl();
Resource * sceneImages = SCENE_IMAGES_DK2;
if (hmd->Type == ovrHmd_DK1) {
sceneImages = SCENE_IMAGES_DK1;
}
for_each_eye([&](ovrEyeType eye){
glm::uvec2 textureSize;
GlUtils::getImageAsTexture(sceneTextures[eye],
sceneImages[eye], textureSize);
memset(eyeTextures + eye, 0,
sizeof(eyeTextures[eye]));
ovrTextureHeader & eyeTextureHeader =
eyeTextures[eye].Header;
eyeTextureHeader.TextureSize = Rift::toOvr(textureSize);
eyeTextureHeader.RenderViewport.Size =
eyeTextureHeader.TextureSize;
eyeTextureHeader.API = ovrRenderAPI_OpenGL;
((ovrGLTextureData&)eyeTextures[eye]).TexId =
sceneTextures[eye]->texture;
});
ovrRenderAPIConfig config;
memset(&config, 0, sizeof(config));
config.Header.API = ovrRenderAPI_OpenGL;
config.Header.RTSize = Rift::toOvr(windowSize);
config.Header.Multisample = 1;
#if defined(OVR_OS_WIN32)
((ovrGLConfigData&)config).Window = 0;
#elif defined(OVR_OS_LINUX)
((ovrGLConfigData&)config).Win = 0;
((ovrGLConfigData&)config).Disp = 0;
#endif
int distortionCaps =
ovrDistortionCap_Vignette
| ovrDistortionCap_Chromatic;
ovrEyeRenderDesc eyeRenderDescs[2];
int configResult = ovrHmd_ConfigureRendering(hmd, &config,
distortionCaps, hmd->DefaultEyeFov, eyeRenderDescs);
if (0 == configResult) {
FAIL("Unable to configure rendering");
}
ovrhmd_EnableHSWDisplaySDKRender(hmd, false);
}
VR::VR(Game &game)
{
// create HMD
if (!(m_hmd = ovrHmd_Create(0)))
{
std::cerr << "couldn't create Oculus HMD, falling back to debug HMD"
<< std::endl;
if (!(m_hmd = ovrHmd_CreateDebug(ovrHmd_DK2)))
throw Error("couldn't create debug HMD");
}
orient_window(game);
// enable position, rotation tracking
ovrHmd_ConfigureTracking(m_hmd, ovrTrackingCap_Orientation
| ovrTrackingCap_MagYawCorrection
| ovrTrackingCap_Position, 0);
// calculate framebuffer resolution and create framebuffer
ovrSizei eye_res[2];
eye_res[0] = ovrHmd_GetFovTextureSize(m_hmd, ovrEye_Left,
m_hmd->DefaultEyeFov[0], 1.0);
eye_res[1] = ovrHmd_GetFovTextureSize(m_hmd, ovrEye_Right,
m_hmd->DefaultEyeFov[1], 1.0);
m_fb_width = eye_res[0].w + eye_res[1].w;
m_fb_height = eye_res[0].h > eye_res[1].h ? eye_res[0].h : eye_res[1].h;
update_fb();
// fill in ovrGLConfig
ovrGLConfig glcfg;
memset(&glcfg, 0, sizeof glcfg);
glcfg.OGL.Header.API = ovrRenderAPI_OpenGL;
glcfg.OGL.Header.RTSize = m_hmd->Resolution;
glcfg.OGL.Header.Multisample = 1;
glcfg.OGL.Window = GetActiveWindow();
glcfg.OGL.DC = wglGetCurrentDC();
if (!(m_hmd->HmdCaps & ovrHmdCap_ExtendDesktop))
ovrHmd_AttachToWindow(m_hmd, glcfg.OGL.Window, 0, 0);
// enable HMD, distortion capabilities and enable SDK rendering
ovrHmd_SetEnabledCaps(m_hmd, ovrHmdCap_LowPersistence
| ovrHmdCap_DynamicPrediction);
if (!ovrHmd_ConfigureRendering(m_hmd, &glcfg.Config,
ovrDistortionCap_Chromatic | ovrDistortionCap_Vignette
| ovrDistortionCap_TimeWarp | ovrDistortionCap_Overdrive,
m_hmd->DefaultEyeFov, m_eye_rdesc))
throw Error("failed to configure distortion rendering");
// disable health/safety warning
ovrhmd_EnableHSWDisplaySDKRender(m_hmd, 0);
}
void initGl() {
RiftGlfwApp::initGl();
ovrGLConfig cfg;
memset(&cfg, 0, sizeof(cfg));
cfg.OGL.Header.API = ovrRenderAPI_OpenGL;
cfg.OGL.Header.RTSize = Rift::toOvr(windowSize);
cfg.OGL.Header.Multisample = 1;
int distortionCaps = 0
| ovrDistortionCap_Vignette
| ovrDistortionCap_Chromatic
| ovrDistortionCap_TimeWarp
;
int configResult = ovrHmd_ConfigureRendering(hmd, &cfg.Config,
distortionCaps, hmd->MaxEyeFov, eyeRenderDescs);
#ifdef _DEBUG
ovrhmd_EnableHSWDisplaySDKRender(hmd, false);
#endif
for_each_eye([&](ovrEyeType eye){
const ovrEyeRenderDesc & erd = eyeRenderDescs[eye];
ovrMatrix4f ovrPerspectiveProjection = ovrMatrix4f_Projection(erd.Fov, 0.01f, 100000.0f, true);
projections[eye] = Rift::fromOvr(ovrPerspectiveProjection);
});
///////////////////////////////////////////////////////////////////////////
// Initialize OpenGL settings and variables
glEnable(GL_BLEND);
ovrLock.lock();
renderWindow = glfwCreateWindow(100, 100, "Ofscreen", nullptr, window);
threadPtr = std::unique_ptr<std::thread>(new std::thread(&SimpleScene::runOvrThread, this));
glfwMakeContextCurrent(window);
}
int OVRConfigureRenderer(int width, int height, float znear, float zfar, float ipd, float multisample, int lowpersistence, int dynamicprediction, int vsync, int chromatic, int timewarp, int vignette, int state, int flip, int srgb, int overdrive, int profile)
{
unsigned hmdCaps;
unsigned int distortionCaps;
ovrFovPort eyeFov[EYE_ALL] = { _OVRGlobals.HMD->DefaultEyeFov[EYE_LEFT], _OVRGlobals.HMD->DefaultEyeFov[EYE_RIGHT] };
float FovSideTanMax = OVR::FovPort::Max(_OVRGlobals.HMD->DefaultEyeFov[EYE_LEFT], _OVRGlobals.HMD->DefaultEyeFov[EYE_RIGHT]).GetMaxSideTan();
//float FovSideTanLimit = OVR::FovPort::Max(_OVRGlobals.HMD->MaxEyeFov[EYE_LEFT], _OVRGlobals.HMD->MaxEyeFov[EYE_RIGHT]).GetMaxSideTan();
ovrBool didSetIPD = 0;
// generate the HMD and distortion caps
hmdCaps = (lowpersistence ? ovrHmdCap_LowPersistence : 0) |
(dynamicprediction ? ovrHmdCap_DynamicPrediction : 0) |
(vsync ? 0 : ovrHmdCap_NoVSync);
distortionCaps = (chromatic ? ovrDistortionCap_Chromatic : 0) |
(timewarp ? ovrDistortionCap_TimeWarp : 0) |
(vignette ? ovrDistortionCap_Vignette : 0) |
(state ? 0 : ovrDistortionCap_NoRestore) |
(flip ? ovrDistortionCap_FlipInput : 0) |
(srgb ? ovrDistortionCap_SRGB : 0) |
(overdrive ? ovrDistortionCap_Overdrive : 0) |
(profile ? ovrDistortionCap_ProfileNoTimewarpSpinWaits : 0);
didSetIPD = ovrHmd_SetFloat( _OVRGlobals.HMD, OVR_KEY_IPD, ipd * 0.001 );
ovrHmd_SetEnabledCaps( _OVRGlobals.HMD, hmdCaps );
ovrRenderAPIConfig config = ovrRenderAPIConfig();
config.Header.API = ovrRenderAPI_OpenGL;
config.Header.RTSize.w = width;
config.Header.RTSize.h = height;
config.Header.Multisample = multisample > 1 ? 1 : 0;
// clamp fov
eyeFov[EYE_LEFT] = OVR::FovPort::Min(eyeFov[EYE_LEFT], OVR::FovPort(FovSideTanMax));
eyeFov[EYE_RIGHT] = OVR::FovPort::Min(eyeFov[EYE_RIGHT], OVR::FovPort(FovSideTanMax));
if ( !ovrHmd_ConfigureRendering( _OVRGlobals.HMD, &config, distortionCaps, eyeFov, _OVRGlobals.EyeRenderDesc ) ) {
return 0;
}
#ifdef DEBUG
ovrhmd_EnableHSWDisplaySDKRender( _OVRGlobals.HMD, false );
#else
ovrHmd_DismissHSWDisplay( _OVRGlobals.HMD );
#endif
_OVRGlobals.IPD = ovrHmd_GetFloat( _OVRGlobals.HMD, OVR_KEY_IPD, ipd * 0.001 );
// create the projection
_OVRGlobals.Eye[EYE_LEFT].Projection =
ovrMatrix4f_Projection( _OVRGlobals.EyeRenderDesc[EYE_LEFT].Fov, znear, zfar, true );
_OVRGlobals.Eye[EYE_RIGHT].Projection =
ovrMatrix4f_Projection( _OVRGlobals.EyeRenderDesc[EYE_RIGHT].Fov, znear, zfar, true );
// transpose the projection
OVR::Matrix4 <float>transposeLeft = _OVRGlobals.Eye[EYE_LEFT].Projection;
OVR::Matrix4 <float>transposeRight = _OVRGlobals.Eye[EYE_RIGHT].Projection;
_OVRGlobals.Eye[EYE_LEFT].Projection = transposeLeft.Transposed();
_OVRGlobals.Eye[EYE_RIGHT].Projection = transposeRight.Transposed();
// TODO: ortho
{
float orthoDistance = 0.8f; // 2D is 0.8 meter from camera
OVR::Vector2f orthoScale0 = OVR::Vector2f(1.0f) / OVR::Vector2f(_OVRGlobals.EyeRenderDesc[EYE_LEFT].PixelsPerTanAngleAtCenter);
OVR::Vector2f orthoScale1 = OVR::Vector2f(1.0f) / OVR::Vector2f(_OVRGlobals.EyeRenderDesc[EYE_RIGHT].PixelsPerTanAngleAtCenter);
_OVRGlobals.Eye[EYE_LEFT].OrthoProjection =
ovrMatrix4f_OrthoSubProjection(_OVRGlobals.Eye[EYE_LEFT].Projection, orthoScale0, orthoDistance, _OVRGlobals.EyeRenderDesc[EYE_LEFT].ViewAdjust.x);
_OVRGlobals.Eye[EYE_RIGHT].OrthoProjection =
ovrMatrix4f_OrthoSubProjection(_OVRGlobals.Eye[EYE_RIGHT].Projection, orthoScale1, orthoDistance, _OVRGlobals.EyeRenderDesc[EYE_RIGHT].ViewAdjust.x);
OVR::Matrix4 <float>transposeLeftOrtho = _OVRGlobals.Eye[EYE_LEFT].OrthoProjection;
OVR::Matrix4 <float>transposeRightOrtho = _OVRGlobals.Eye[EYE_RIGHT].OrthoProjection;
_OVRGlobals.Eye[EYE_LEFT].OrthoProjection = transposeLeftOrtho.Transposed();
_OVRGlobals.Eye[EYE_RIGHT].OrthoProjection = transposeRightOrtho.Transposed();
}
return 1;
}
