bool OcudumpDebug::ovrHmdCreateVersioned()
{
#if defined(OVRSDK5)
hmd = ovrHmd_CreateDebug(ovrHmd_DK2);
return hmd ? true : false;
#elif defined(OVRSDK6)
return (ovrHmd_CreateDebug(ovrHmd_DK2, &hmd)==ovrSuccess);
#endif
}
void OVRSDK06AppSkeleton::initHMD()
{
ovrInitParams initParams = { 0 };
if (ovrSuccess != ovr_Initialize(NULL))
{
LOG_INFO("Failed to initialize the Oculus SDK");
}
if (ovrSuccess != ovrHmd_Create(0, &m_Hmd))
{
LOG_INFO("Could not create HMD");
if (ovrSuccess != ovrHmd_CreateDebug(ovrHmd_DK2, &m_Hmd))
{
LOG_ERROR("Could not create Debug HMD");
}
m_usingDebugHmd = true;
}
const ovrBool ret = ovrHmd_ConfigureTracking(m_Hmd,
ovrTrackingCap_Orientation | ovrTrackingCap_MagYawCorrection | ovrTrackingCap_Position,
ovrTrackingCap_Orientation);
if (!OVR_SUCCESS(ret))
{
LOG_ERROR("Error calling ovrHmd_ConfigureTracking");
}
}
int OVRInitialize(int debug)
{
unsigned int supportedTrackingCaps =
ovrTrackingCap_Orientation|
ovrTrackingCap_MagYawCorrection|
ovrTrackingCap_Position;
ovrHmdType debugHMDType = ovrHmd_None;
if ( debug != 0 ) {
debugHMDType = (debug == 1 ? ovrHmd_DK1 : debug == 2 ? ovrHmd_DK2 : ovrHmd_Other);
}
if ( ! ovr_Initialize() ) {
return 0;
}
_OVRGlobals.HMD = ovrHmd_Create(0);
// no HMD? check for vr_debug and attempt to create a debug HMD
if ( ! _OVRGlobals.HMD && (
! ( debugHMDType != ovrHmd_None ) ||
! ( _OVRGlobals.HMD = ovrHmd_CreateDebug( debugHMDType ) ) ) ) {
return 0;
}
if ( ! ovrHmd_ConfigureTracking( _OVRGlobals.HMD, supportedTrackingCaps, ovrTrackingCap_Orientation ) ) {
return 0;
}
return 1;
}
void OculusInterface::initOculus(float _devicePixelAspect)
{
m_devicePixelAspect=_devicePixelAspect;
std::cout<<"setting device aspect "<<m_devicePixelAspect<<"\n";
m_hmd = ovrHmd_Create(0);
if (!m_hmd)
{
std::cerr<<"Unable to create HMD: "<< ovrHmd_GetLastError(NULL)<<std::endl;
std::cerr<<"Attempting to run without HMD\n";
// If we didn't detect an Hmd, create a simulated one for debugging.
m_hmd = ovrHmd_CreateDebug(ovrHmd_DK1);
if (!m_hmd)
{ // Failed Hmd creation.
exit(EXIT_FAILURE);
}
}
m_windowWidth=m_hmd->Resolution.w;
m_windowHeight=m_hmd->Resolution.h;
oculusDebug();
// Start the sensor which provides the Rift’s pose and motion.
ovrHmd_ConfigureTracking(m_hmd, ovrTrackingCap_Orientation | ovrTrackingCap_MagYawCorrection | ovrTrackingCap_Position, 0);
// let's fill in some info about oculus
m_eyeres[0] = ovrHmd_GetFovTextureSize(m_hmd, ovrEye_Left, m_hmd->DefaultEyeFov[0], 1.0);
m_eyeres[1] = ovrHmd_GetFovTextureSize(m_hmd, ovrEye_Right, m_hmd->DefaultEyeFov[1],1.0);
/* and create a single render target texture to encompass both eyes */
//m_fbWidth = m_eyeres[0].w + m_eyeres[1].w;
//m_fbHeight = m_eyeres[0].h > m_eyeres[1].h ? m_eyeres[0].h : m_eyeres[1].h;
ovrSizei recommenedTex0Size = ovrHmd_GetFovTextureSize(m_hmd, ovrEye_Left,m_hmd->DefaultEyeFov[0], m_devicePixelAspect);
ovrSizei recommenedTex1Size = ovrHmd_GetFovTextureSize(m_hmd, ovrEye_Right,m_hmd->DefaultEyeFov[1], m_devicePixelAspect);
// Determine dimensions to fit into a single render target.
ovrSizei renderTargetSize;
m_fbWidth = recommenedTex0Size.w + recommenedTex1Size.w;
m_fbHeight = std::max ( recommenedTex0Size.h, recommenedTex1Size.h );
createRenderTarget();
createOVRGLConfig();
createOVRTextureBuffers();
/* enable low-persistence display and dynamic prediction for lattency compensation */
ovrHmd_SetEnabledCaps(m_hmd, ovrHmdCap_LowPersistence | ovrHmdCap_DynamicPrediction);
/* configure SDK-rendering and enable chromatic abberation correction, vignetting, and
* timewrap, which shifts the image before drawing to counter any lattency between the call
* to ovrHmd_GetEyePose and ovrHmd_EndFrame.
*/
unsigned int dcaps = ovrDistortionCap_Chromatic | ovrDistortionCap_Vignette | ovrDistortionCap_TimeWarp |
ovrDistortionCap_Overdrive;
if(!ovrHmd_ConfigureRendering(m_hmd, &m_glcfg.Config, dcaps, m_hmd->DefaultEyeFov, m_eyeRdesc))
{
fprintf(stderr, "failed to configure distortion renderer\n");
}
}
void RiftSetup()
{
ovr_Initialize();
s_hmd = ovrHmd_Create(0);
if (!s_hmd)
{
s_hmd = ovrHmd_CreateDebug(ovrHmd_DK1);
}
ovrHmd_GetDesc(s_hmd, &s_hmdDesc);
DumpHMDInfo(s_hmdDesc);
uint32_t supportedSensorCaps = ovrSensorCap_Orientation;
uint32_t requiredSensorCaps = ovrSensorCap_Orientation;
ovrBool success = ovrHmd_StartSensor(s_hmd, supportedSensorCaps, requiredSensorCaps);
if (!success) {
fprintf(stderr, "ERROR: HMD does not have required capabilities!\n");
exit(2);
}
// Figure out dimensions of render target
ovrSizei recommenedTex0Size = ovrHmd_GetFovTextureSize(s_hmd, ovrEye_Left, s_hmdDesc.DefaultEyeFov[0], 1.0f);
ovrSizei recommenedTex1Size = ovrHmd_GetFovTextureSize(s_hmd, ovrEye_Right, s_hmdDesc.DefaultEyeFov[1], 1.0f);
s_renderTargetSize.w = recommenedTex0Size.w + recommenedTex1Size.w;
s_renderTargetSize.h = std::max(recommenedTex0Size.h, recommenedTex1Size.h);
CreateRenderTarget(s_renderTargetSize.w, s_renderTargetSize.h);
s_eyeTexture[0].Header.API = ovrRenderAPI_OpenGL;
s_eyeTexture[0].Header.TextureSize = s_renderTargetSize;
s_eyeTexture[0].Header.RenderViewport.Pos = {0, 0};
s_eyeTexture[0].Header.RenderViewport.Size = {s_renderTargetSize.w / 2, s_renderTargetSize.h};
((ovrGLTexture*)(&s_eyeTexture[0]))->OGL.TexId = s_fboTex;
s_eyeTexture[1].Header.API = ovrRenderAPI_OpenGL;
s_eyeTexture[1].Header.TextureSize = s_renderTargetSize;
s_eyeTexture[1].Header.RenderViewport.Pos = {s_renderTargetSize.w / 2, 0};
s_eyeTexture[1].Header.RenderViewport.Size = {s_renderTargetSize.w / 2, s_renderTargetSize.h};
((ovrGLTexture*)(&s_eyeTexture[1]))->OGL.TexId = s_fboTex;
// Configure ovr SDK Rendering
ovrGLConfig cfg;
memset(&cfg, 0, sizeof(ovrGLConfig));
cfg.OGL.Header.API = ovrRenderAPI_OpenGL;
cfg.OGL.Header.RTSize = {s_config->width, s_config->height};
cfg.OGL.Header.Multisample = 0;
// TODO: on windows need to set HWND, on Linux need to set other parameters
if (!ovrHmd_ConfigureRendering(s_hmd, &cfg.Config, s_hmdDesc.DistortionCaps, s_hmdDesc.DefaultEyeFov, s_eyeRenderDesc))
{
fprintf(stderr, "ERROR: HMD configure rendering failed!\n");
exit(3);
}
}
HelloRift() {
ovr_Initialize();
hmd = ovrHmd_Create(0);
if (nullptr == hmd) {
debugDevice = true;
hmd = ovrHmd_CreateDebug(ovrHmd_DK2);
}
ovrHmd_ConfigureTracking(hmd,
ovrTrackingCap_Orientation |
ovrTrackingCap_Position, 0);
resetPosition();
}
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);
}
///@brief Set this up early so we can get the HMD's display dimensions to create a window.
void RiftAppSkeleton::initHMD()
{
ovr_Initialize();
m_Hmd = ovrHmd_Create(0);
if (m_Hmd == NULL)
{
m_Hmd = ovrHmd_CreateDebug(ovrHmd_DK1);
}
m_ovrScene.SetHmdPointer(m_Hmd);
m_ovrScene.SetChassisPosPointer(&m_chassisPos);
m_ovrScene.SetChassisYawPointer(&m_chassisYaw);
// Both ovrVector3f and glm::vec3 are at heart a float[3], so this works fine.
m_fm.SetChassisPosPointer(reinterpret_cast<glm::vec3*>(&m_chassisPos));
m_fm.SetChassisYawPointer(&m_chassisYaw);
}
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;
}
bool OVR_SDL2_app::init_OVR()
{
ovr_Initialize();
// Use the first connected HMD.
hmd = ovrHmd_Create(0);
// Fall back on a DK1 debug configuration if no HMD is available.
if (hmd == 0)
hmd = ovrHmd_CreateDebug(ovrHmd_DK1);
// Enable all tracking capabilities on this HMD.
if (hmd)
ovrHmd_ConfigureTracking(hmd, ovrTrackingCap_Orientation |
ovrTrackingCap_MagYawCorrection |
ovrTrackingCap_Position, 0);
return (hmd != 0);
}
int OculusWorldDemoApp::OnStartup(int argc, const char** argv)
{
// *** Oculus HMD & Sensor Initialization
// Create DeviceManager and first available HMDDevice from it.
// Sensor object is created from the HMD, to ensure that it is on the
// correct device.
ovr_Initialize();
Hmd = ovrHmd_Create(0);
if (!Hmd)
{
// If we didn't detect an Hmd, create a simulated one for debugging.
Hmd = ovrHmd_CreateDebug(ovrHmd_DK1);
UsingDebugHmd = true;
if (!Hmd)
{ // Failed Hmd creation.
return 1;
}
}
// Get more details about the HMD.
ovrHmd_GetDesc(Hmd, &HmdDesc);
WindowSize = HmdDesc.Resolution;
// ***** Setup System Window & rendering.
if (!SetupWindowAndRendering(argc, argv))
return 1;
// Initialize FovSideTanMax, which allows us to change all Fov sides at once - Fov
// starts at default and is clamped to this value.
FovSideTanLimit = FovPort::Max(HmdDesc.MaxEyeFov[0], HmdDesc.MaxEyeFov[1]).GetMaxSideTan();
FovSideTanMax = FovPort::Max(HmdDesc.DefaultEyeFov[0], HmdDesc.DefaultEyeFov[1]).GetMaxSideTan();
PositionTrackingEnabled = (HmdDesc.SensorCaps & ovrSensorCap_Position) ? true : false;
// *** Configure HMD Stereo settings.
CalculateHmdValues();
// Query eye height.
ThePlayer.UserEyeHeight = ovrHmd_GetFloat(Hmd, OVR_KEY_EYE_HEIGHT, ThePlayer.UserEyeHeight);
ThePlayer.BodyPos.y = ThePlayer.UserEyeHeight;
// Center pupil for customization; real game shouldn't need to adjust this.
CenterPupilDepthMeters = ovrHmd_GetFloat(Hmd, "CenterPupilDepth", 0.0f);
ThePlayer.bMotionRelativeToBody = false; // Default to head-steering for DK1
if (UsingDebugHmd)
Menu.SetPopupMessage("NO HMD DETECTED");
else if (!(ovrHmd_GetSensorState(Hmd, 0.0f).StatusFlags & ovrStatus_OrientationTracked))
Menu.SetPopupMessage("NO SENSOR DETECTED");
else
Menu.SetPopupMessage("Press F9 for Full-Screen on Rift");
// Give first message 10 sec timeout, add border lines.
Menu.SetPopupTimeout(10.0f, true);
PopulateOptionMenu();
// *** Identify Scene File & Prepare for Loading
InitMainFilePath();
PopulatePreloadScene();
LastUpdate = ovr_GetTimeInSeconds();
return 0;
}
bool OVR::postReset(void* _nwh, ovrRenderAPIConfig* _config, bool _debug)
{
if (_debug)
{
switch (_config->Header.API)
{
#if BGFX_CONFIG_RENDERER_DIRECT3D11
case ovrRenderAPI_D3D11:
{
ovrD3D11ConfigData* data = (ovrD3D11ConfigData*)_config;
# if OVR_VERSION > OVR_VERSION_043
m_rtSize = data->Header.BackBufferSize;
# else
m_rtSize = data->Header.RTSize;
# endif // OVR_VERSION > OVR_VERSION_043
}
break;
#endif // BGFX_CONFIG_RENDERER_DIRECT3D11
#if BGFX_CONFIG_RENDERER_OPENGL
case ovrRenderAPI_OpenGL:
{
ovrGLConfigData* data = (ovrGLConfigData*)_config;
# if OVR_VERSION > OVR_VERSION_043
m_rtSize = data->Header.BackBufferSize;
# else
m_rtSize = data->Header.RTSize;
# endif // OVR_VERSION > OVR_VERSION_043
}
break;
#endif // BGFX_CONFIG_RENDERER_OPENGL
case ovrRenderAPI_None:
default:
BX_CHECK(false, "You should not be here!");
break;
}
m_debug = true;
return false;
}
if (!m_initialized)
{
return false;
}
if (!_debug)
{
m_hmd = ovrHmd_Create(0);
}
if (NULL == m_hmd)
{
m_hmd = ovrHmd_CreateDebug(ovrHmd_DK2);
BX_WARN(NULL != m_hmd, "Unable to initialize OVR.");
if (NULL == m_hmd)
{
return false;
}
}
BX_TRACE("HMD: %s, %s, firmware: %d.%d"
, m_hmd->ProductName
, m_hmd->Manufacturer
, m_hmd->FirmwareMajor
, m_hmd->FirmwareMinor
);
ovrBool result;
result = ovrHmd_AttachToWindow(m_hmd, _nwh, NULL, NULL);
if (!result) { goto ovrError; }
ovrFovPort eyeFov[2] = { m_hmd->DefaultEyeFov[0], m_hmd->DefaultEyeFov[1] };
result = ovrHmd_ConfigureRendering(m_hmd
, _config
, 0
#if OVR_VERSION < OVR_VERSION_050
| ovrDistortionCap_Chromatic // permanently enabled >= v5.0
#endif
| ovrDistortionCap_Vignette
| ovrDistortionCap_TimeWarp
| ovrDistortionCap_Overdrive
| ovrDistortionCap_NoRestore
| ovrDistortionCap_HqDistortion
, eyeFov
, m_erd
);
if (!result) { goto ovrError; }
ovrHmd_SetEnabledCaps(m_hmd
, 0
| ovrHmdCap_LowPersistence
| ovrHmdCap_DynamicPrediction
);
result = ovrHmd_ConfigureTracking(m_hmd
, 0
| ovrTrackingCap_Orientation
| ovrTrackingCap_MagYawCorrection
| ovrTrackingCap_Position
, 0
);
if (!result)
{
ovrError:
BX_TRACE("Failed to initialize OVR.");
ovrHmd_Destroy(m_hmd);
m_hmd = NULL;
return false;
}
ovrSizei sizeL = ovrHmd_GetFovTextureSize(m_hmd, ovrEye_Left, m_hmd->DefaultEyeFov[0], 1.0f);
ovrSizei sizeR = ovrHmd_GetFovTextureSize(m_hmd, ovrEye_Right, m_hmd->DefaultEyeFov[1], 1.0f);
m_rtSize.w = sizeL.w + sizeR.w;
m_rtSize.h = bx::uint32_max(sizeL.h, sizeR.h);
m_warning = true;
return true;
}
/** Initialize the Oculus HMD.
*
* @param pos The position that we want the Oculus HMD to start at.
*/
static void viewmat_init_hmd_oculus(const float pos[3])
{
#ifdef MISSING_OVR
msg(MSG_FATAL, "Oculus support is missing: You have not compiled this code against the LibOVR library.\n");
exit(EXIT_FAILURE);
#else
ovr_Initialize(NULL);
int useDebugMode = 0;
hmd = ovrHmd_Create(0);
if(!hmd)
{
msg(MSG_WARNING, "Failed to open Oculus HMD. Is ovrd running? Is libOVRRT*.so.* in /usr/lib, /usr/local/lib, or the current directory?\n");
msg(MSG_WARNING, "Press any key to proceed with Oculus debugging window.\n");
char c;
if(fscanf(stdin, "%c", &c) < 0)
{
msg(MSG_ERROR, "fscanf error.\n");
exit(EXIT_FAILURE);
}
hmd = ovrHmd_CreateDebug(ovrHmd_DK2);
useDebugMode = 1;
if(!hmd)
{
msg(MSG_ERROR, "Oculus: Failed to create virtual debugging HMD\n");
exit(EXIT_FAILURE);
}
}
msg(MSG_INFO, "Initialized HMD: %s - %s\n", hmd->Manufacturer, hmd->ProductName);
#if 0
printf("default fov tangents left eye:\n");
printf("up=%f\n", hmd->DefaultEyeFov[ovrEye_Left].UpTan);
printf("up=%f\n", hmd->DefaultEyeFov[ovrEye_Left].DownTan);
printf("up=%f\n", hmd->DefaultEyeFov[ovrEye_Left].LeftTan);
printf("up=%f\n", hmd->DefaultEyeFov[ovrEye_Left].RightTan);
#endif
/* pixelDensity can range between 0 to 1 (where 1 has the highest
* resolution). Using smaller values will result in smaller
* textures that each eye is rendered into. */
float pixelDensity = 1;
/* Number of multisample antialiasing while rendering the scene
* for each eye. */
GLint msaa_samples = 2;
recommendTexSizeL = ovrHmd_GetFovTextureSize(hmd, ovrEye_Left, hmd->DefaultEyeFov[ovrEye_Left], pixelDensity);
recommendTexSizeR = ovrHmd_GetFovTextureSize(hmd, ovrEye_Right, hmd->DefaultEyeFov[ovrEye_Right], pixelDensity);
GLuint leftTextureAA,rightTextureAA;
leftFramebufferAA = kuhl_gen_framebuffer_msaa(recommendTexSizeL.w, recommendTexSizeL.h, &leftTextureAA, NULL, msaa_samples);
rightFramebufferAA = kuhl_gen_framebuffer_msaa(recommendTexSizeR.w, recommendTexSizeR.h, &rightTextureAA, NULL, msaa_samples);
GLuint leftTexture,rightTexture;
leftFramebuffer = kuhl_gen_framebuffer(recommendTexSizeL.w, recommendTexSizeL.h, &leftTexture, NULL);
rightFramebuffer = kuhl_gen_framebuffer(recommendTexSizeR.w, recommendTexSizeR.h, &rightTexture, NULL);
//printf("Left recommended texture size: %d %d\n", recommendTexSizeL.w, recommendTexSizeL.h);
//printf("Right recommended texture size: %d %d\n", recommendTexSizeR.w, recommendTexSizeR.h);
EyeTexture[0].OGL.Header.API = ovrRenderAPI_OpenGL;
EyeTexture[0].OGL.Header.TextureSize.w = recommendTexSizeL.w;
EyeTexture[0].OGL.Header.TextureSize.h = recommendTexSizeL.h;
EyeTexture[0].OGL.Header.RenderViewport.Pos.x = 0;
EyeTexture[0].OGL.Header.RenderViewport.Pos.y = 0;
EyeTexture[0].OGL.Header.RenderViewport.Size.w = recommendTexSizeL.w;
EyeTexture[0].OGL.Header.RenderViewport.Size.h = recommendTexSizeL.h;
EyeTexture[1].OGL.Header.API = ovrRenderAPI_OpenGL;
EyeTexture[1].OGL.Header.TextureSize.w = recommendTexSizeR.w;
EyeTexture[1].OGL.Header.TextureSize.h = recommendTexSizeR.h;
EyeTexture[1].OGL.Header.RenderViewport.Pos.x = 0;
EyeTexture[1].OGL.Header.RenderViewport.Pos.y = 0;
EyeTexture[1].OGL.Header.RenderViewport.Size.w = recommendTexSizeR.w;
EyeTexture[1].OGL.Header.RenderViewport.Size.h = recommendTexSizeR.h;
EyeTexture[0].OGL.TexId = leftTexture;
EyeTexture[1].OGL.TexId = rightTexture;
union ovrGLConfig glcfg;
memset(&glcfg, 0, sizeof(glcfg));
glcfg.OGL.Header.API=ovrRenderAPI_OpenGL;
glcfg.OGL.Header.Multisample = 0;
glcfg.OGL.Disp = glXGetCurrentDisplay();
if(hmd->Type == ovrHmd_DK2 && useDebugMode == 0)
{
/* Since the DK2 monitor is rotated, we need to swap the width
* and height here so that the final image correctly fills the
* entire screen. */
glcfg.OGL.Header.BackBufferSize.h=hmd->Resolution.w;
glcfg.OGL.Header.BackBufferSize.w=hmd->Resolution.h;
} else
{
glcfg.OGL.Header.BackBufferSize.h=hmd->Resolution.h;
glcfg.OGL.Header.BackBufferSize.w=hmd->Resolution.w;
}
// interferes with PROJAT_FULLSCREEN
// glutReshapeWindow(glcfg.OGL.Header.BackBufferSize.w,
// glcfg.OGL.Header.BackBufferSize.h);
unsigned int trackingcap = 0;
trackingcap |= ovrTrackingCap_Orientation; // orientation tracking
trackingcap |= ovrTrackingCap_Position; // position tracking
trackingcap |= ovrTrackingCap_MagYawCorrection; // use magnetic compass
ovrHmd_ConfigureTracking(hmd, trackingcap, 0);
unsigned int hmd_caps = 0;
hmd_caps |= ovrHmdCap_DynamicPrediction; // enable internal latency feedback
/* disable vsync; allow frame rate higher than display refresh
rate, can cause tearing. On some windowing systems, you using
this setting reduces issues with overrunning the time budget
and tearing still does not occur. */
hmd_caps |= ovrHmdCap_NoVSync;
hmd_caps |= ovrHmdCap_LowPersistence; // Less blur during rotation; dimmer screen
ovrHmd_SetEnabledCaps(hmd, hmd_caps);
/* Distortion options
* See OVR_CAPI.h for additional options
*/
unsigned int distort_caps = 0;
distort_caps |= ovrDistortionCap_LinuxDevFullscreen; // Screen rotation for DK2
// distort_caps |= ovrDistortionCap_Chromatic; // Chromatic aberration correction - Necessary for 0.4.4, turned on permanently in 0.5.0.1
distort_caps |= ovrDistortionCap_Vignette; // Apply gradient to edge of image
// distort_caps |= ovrDistortionCap_OverDrive; // Overdrive brightness transitions to compensate for DK2 artifacts
/* Shift image based on time difference between
* ovrHmd_GetEyePose() and ovrHmd_EndFrame(). This option seems to
* reduce FPS on at least one machine. */
//distort_caps |= ovrDistortionCap_TimeWarp;
if(!ovrHmd_ConfigureRendering(hmd, &glcfg.Config, distort_caps, hmd->DefaultEyeFov, eye_rdesc)) {
msg(MSG_FATAL, "Failed to configure distortion renderer.\n");
exit(EXIT_FAILURE);
}
/* disable health and safety warning */
ovrHmd_DismissHSWDisplay(hmd);
vec3f_copy(oculus_initialPos, pos);
// Try to connect to VRPN
viewmat_init_vrpn();
// TODO: We are supposed to do these things when we are done:
//ovrHmd_Destroy(hmd);
//ovr_Shutdown();
#endif
}
int
setup_rift(struct weston_compositor *compositor)
{
struct oculus_rift *rift = compositor->rift;
rift->enabled = 1;
rift->screen_z = -5.0;
rift->screen_scale = 1.0;
weston_compositor_add_key_binding(compositor, KEY_5, MODIFIER_SUPER,
toggle_sbs, compositor);
weston_compositor_add_key_binding(compositor, KEY_6, MODIFIER_SUPER,
toggle_rotate, compositor);
weston_compositor_add_key_binding(compositor, KEY_7, MODIFIER_SUPER,
move_in, compositor);
weston_compositor_add_key_binding(compositor, KEY_8, MODIFIER_SUPER,
move_out, compositor);
weston_compositor_add_key_binding(compositor, KEY_9, MODIFIER_SUPER,
scale_up, compositor);
weston_compositor_add_key_binding(compositor, KEY_0, MODIFIER_SUPER,
scale_down, compositor);
/*// use this at some point in the future to detect and grab the rift display
struct weston_output *output;
wl_list_for_each(output, &compositor->output_list, link)
{
weston_log("Output (%i): %s\n\t%ix%i\n", output->id, output->name,
output->width, output->height);
}*/
rift->distortion_shader = calloc(1, sizeof *(rift->distortion_shader));
struct distortion_shader_ *d = rift->distortion_shader;
d->program = CreateProgram(distortion_vertex_shader, distortion_fragment_shader);
d->EyeToSourceUVScale = glGetUniformLocation(d->program, "EyeToSourceUVScale");
d->EyeToSourceUVOffset = glGetUniformLocation(d->program, "EyeToSourceUVOffset");
d->RightEye = glGetUniformLocation(d->program, "RightEye");
d->angle = glGetUniformLocation(d->program, "angle");
d->Position = glGetAttribLocation(d->program, "Position");
d->TexCoord0 = glGetAttribLocation(d->program, "TexCoord0");
d->TexCoordR = glGetAttribLocation(d->program, "TexCoordR");
d->TexCoordG = glGetAttribLocation(d->program, "TexCoordG");
d->TexCoordB = glGetAttribLocation(d->program, "TexCoordB");
d->eyeTexture = glGetAttribLocation(d->program, "Texture0");
rift->eye_shader = calloc(1, sizeof *(rift->eye_shader));
struct eye_shader_ *e = rift->eye_shader;
e->program = CreateProgram(eye_vertex_shader, eye_fragment_shader);
e->Position = glGetAttribLocation(d->program, "Position");
e->TexCoord0 = glGetAttribLocation(d->program, "TexCoord0");
e->Projection = glGetUniformLocation(e->program, "Projection");
e->ModelView = glGetUniformLocation(e->program, "ModelView");
e->virtualScreenTexture = glGetAttribLocation(d->program, "Texture0");
rift->scene = calloc(1, sizeof *(rift->scene));
glGenBuffers(1, &rift->scene->vertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, rift->scene->vertexBuffer);
static const GLfloat rectangle[] =
{-1.0f, -1.0f, -0.5f,
1.0f, -1.0f, -0.5f,
-1.0f, 1.0f, -0.5f,
1.0f, -1.0f, -0.5f,
1.0f, 1.0f, -0.5f,
-1.0f, 1.0f, -0.5f};
glBufferData(GL_ARRAY_BUFFER, sizeof(rectangle), rectangle, GL_STATIC_DRAW);
glGenBuffers(2, &rift->scene->SBSuvsBuffer[0]);
glGenBuffers(1, &rift->scene->uvsBuffer);
static const GLfloat uvs[3][12] =
{{ 0.0, 0.0,
0.5, 0.0,
0.0, 1.0,
0.5, 0.0,
0.5, 1.0,
0.0, 1.0},
{ 0.5, 0.0,
1.0, 0.0,
0.5, 1.0,
1.0, 0.0,
1.0, 1.0,
0.5, 1.0},
{ 0.0, 0.0,
1.0, 0.0,
0.0, 1.0,
1.0, 0.0,
1.0, 1.0,
0.0, 1.0}};
glBindBuffer(GL_ARRAY_BUFFER, rift->scene->SBSuvsBuffer[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(uvs[0]), uvs[0], GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, rift->scene->SBSuvsBuffer[1]);
glBufferData(GL_ARRAY_BUFFER, sizeof(uvs[1]), uvs[1], GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, rift->scene->uvsBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(uvs[2]), uvs[2], GL_STATIC_DRAW);
rift->width = 1920;
rift->height = 1080;
glGenTextures(1, &rift->fbTexture);
glBindTexture(GL_TEXTURE_2D, rift->fbTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, rift->width, rift->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glGenFramebuffers(1, &rift->redirectedFramebuffer);
glBindFramebuffer(GL_FRAMEBUFFER, rift->redirectedFramebuffer);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rift->fbTexture, 0); show_error();
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
switch(glCheckFramebufferStatus(GL_FRAMEBUFFER))
{
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: weston_log("incomplete attachment\n"); break;
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: weston_log("incomplete dimensions\n"); break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: weston_log("incomplete missing attachment\n"); break;
case GL_FRAMEBUFFER_UNSUPPORTED: weston_log("unsupported\n"); break;
}
weston_log("framebuffer not working\n");
show_error();
exit(1);
}
glClear(GL_COLOR_BUFFER_BIT);
/*EGLint pbufferAttributes[] = {
EGL_WIDTH, rift->width,
EGL_HEIGHT, rift->height,
EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGB,
EGL_TEXTURE_TARGET, EGL_TEXTURE_2D,
EGL_NONE
};
rift->pbuffer = eglCreatePbufferSurface(
rift->egl_display, rift->egl_config,
pbufferAttributes);
glGenTextures(1, &(rift->texture));
glBindTexture(GL_TEXTURE_2D, rift->texture);
//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, rift->width, rift->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
eglMakeCurrent(rift->egl_display, rift->pbuffer, rift->pbuffer, rift->egl_context);
eglBindTexImage(rift->egl_display, rift->pbuffer, EGL_BACK_BUFFER);
eglMakeCurrent(rift->egl_display, rift->orig_surface, rift->orig_surface, rift->egl_context);*/
ovr_Initialize(0);
rift->hmd = ovrHmd_Create(0);
if(rift->hmd == NULL)
{
rift->hmd = ovrHmd_CreateDebug(ovrHmd_DK2);
}
ovrHmd_ConfigureTracking(rift->hmd, ovrTrackingCap_Orientation |
ovrTrackingCap_Position | ovrTrackingCap_MagYawCorrection, 0);
ovrHmd_ResetFrameTiming(rift->hmd, 0);
int eye;
for(eye = 0; eye < 2; eye++)
{
ovrFovPort fov = rift->hmd->DefaultEyeFov[eye];
ovrEyeRenderDesc renderDesc = ovrHmd_GetRenderDesc(rift->hmd, eye, fov);
struct EyeArg *eyeArg = &rift->eyeArgs[eye];
eyeArg->projection = ovrMatrix4f_Projection(fov, 0.1, 100000, true);
/*int j, k;
for(k=0; k<4; k++)
{
for(j=0; j<4; j++)
{
printf("%f\t", eyeArg->projection.M[k][j]);
}
printf("\n");
}*/
rift->hmdToEyeOffsets[eye] = renderDesc.HmdToEyeViewOffset;
ovrRecti texRect;
texRect.Size = ovrHmd_GetFovTextureSize(rift->hmd, eye, rift->hmd->DefaultEyeFov[eye],
1.0f);
texRect.Pos.x = texRect.Pos.y = 0;
eyeArg->textureWidth = texRect.Size.w;
eyeArg->textureHeight = texRect.Size.h;
glGenTextures(1, &eyeArg->texture);
glBindTexture(GL_TEXTURE_2D, eyeArg->texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, eyeArg->textureWidth, eyeArg->textureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glGenFramebuffers(1, &eyeArg->framebuffer); show_error();
glBindFramebuffer(GL_FRAMEBUFFER, eyeArg->framebuffer); show_error();
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, eyeArg->texture, 0); show_error();
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
switch(glCheckFramebufferStatus(GL_FRAMEBUFFER))
{
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: weston_log("incomplete attachment\n"); break;
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: weston_log("incomplete dimensions\n"); break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: weston_log("incomplete missing attachment\n"); break;
case GL_FRAMEBUFFER_UNSUPPORTED: weston_log("unsupported\n"); break;
}
weston_log("framebuffer not working\n");
show_error();
exit(1);
}
if(eye)
{
glClearColor(1.0, 0.0, 0.0, 1.0); show_error();
}
else
{
glClearColor(0.0, 1.0, 0.0, 1.0); show_error();
}
glClear(GL_COLOR_BUFFER_BIT); show_error();
/*EGLint eyePbufferAttributes[] = {
EGL_WIDTH, texRect.Size.w,
EGL_HEIGHT, texRect.Size.h,
EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGB,
EGL_TEXTURE_TARGET, EGL_TEXTURE_2D,
EGL_NONE
};
eyeArg.surface = eglCreatePbufferSurface(
rift->egl_display, rift->egl_config,
eyePbufferAttributes);*/
ovrVector2f scaleAndOffset[2];
ovrHmd_GetRenderScaleAndOffset(fov, texRect.Size, texRect, scaleAndOffset);
eyeArg->scale = scaleAndOffset[0];
eyeArg->offset = scaleAndOffset[1];
ovrHmd_CreateDistortionMesh(rift->hmd, eye, fov, 0, &eyeArg->mesh);
glGenBuffers(1, &eyeArg->indexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, eyeArg->indexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, eyeArg->mesh.IndexCount * sizeof(unsigned short), eyeArg->mesh.pIndexData, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
float vertices_buffer[eyeArg->mesh.VertexCount*2];
float uvs_buffer[3][eyeArg->mesh.VertexCount*2];
uint i;
for(i=0; i<eyeArg->mesh.VertexCount; i++)
{
ovrDistortionVertex vertex = eyeArg->mesh.pVertexData[i];
vertices_buffer[i*2] = vertex.ScreenPosNDC.x;
vertices_buffer[(i*2)+1] = vertex.ScreenPosNDC.y;
uvs_buffer[0][i*2] = vertex.TanEyeAnglesR.x;
uvs_buffer[0][(i*2)+1] = vertex.TanEyeAnglesR.y;
uvs_buffer[1][i*2] = vertex.TanEyeAnglesG.x;
uvs_buffer[1][(i*2)+1] = vertex.TanEyeAnglesG.y;
uvs_buffer[2][i*2] = vertex.TanEyeAnglesB.x;
uvs_buffer[2][(i*2)+1] = vertex.TanEyeAnglesB.y;
}
glGenBuffers(1, &eyeArg->vertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, eyeArg->vertexBuffer);
glBufferData(GL_ARRAY_BUFFER, eyeArg->mesh.VertexCount * sizeof(GL_FLOAT) * 2, vertices_buffer, GL_STATIC_DRAW);
glGenBuffers(3, &eyeArg->uvsBuffer[0]);
for(i=0; i<3; i++)
{
glBindBuffer(GL_ARRAY_BUFFER, eyeArg->uvsBuffer[i]);
glBufferData(GL_ARRAY_BUFFER, eyeArg->mesh.VertexCount * sizeof(GL_FLOAT) * 2, uvs_buffer[i], GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
}
return 0;
}
void Renderer::initOVR()
{
ovr_Initialize();
Config& config = Core::get().config();
if(!config.getBool("Renderer.OVR", false))
{
return;
}
hmd_ = ovrHmd_Create(0);
if(!hmd_)
{
fprintf(stderr, "Failed to create OVR HMD, falling back to fake one\n");
hmd_ = ovrHmd_CreateDebug(ovrHmd_DK2);
}
ovrSizei leftEyeTexSize = ovrHmd_GetFovTextureSize(hmd_, ovrEye_Left, hmd_->DefaultEyeFov[ovrEye_Left], 1.0f);
ovrSizei rightEyeTexSize = ovrHmd_GetFovTextureSize(hmd_, ovrEye_Right, hmd_->DefaultEyeFov[ovrEye_Right], 1.0f);
renderTexSize_.w = leftEyeTexSize.w + rightEyeTexSize.w;
renderTexSize_.h = max(leftEyeTexSize.h, rightEyeTexSize.h);
glGenTextures(1, &renderTex_);
glBindTexture(GL_TEXTURE_2D, renderTex_);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, renderTexSize_.w, renderTexSize_.h, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &renderTexSize_.w);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &renderTexSize_.h);
glGenTextures(1, &depthTex_);
glBindTexture(GL_TEXTURE_2D, depthTex_);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, renderTexSize_.w, renderTexSize_.h, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, nullptr);
eyeViewport_[ovrEye_Left].Pos.x = 0;
eyeViewport_[ovrEye_Left].Pos.y = 0;
eyeViewport_[ovrEye_Left].Size.w = renderTexSize_.w / 2;
eyeViewport_[ovrEye_Left].Size.h = renderTexSize_.h;
eyeViewport_[ovrEye_Right].Pos.x = renderTexSize_.w / 2;
eyeViewport_[ovrEye_Right].Pos.y = 0;
eyeViewport_[ovrEye_Right].Size.w = renderTexSize_.w / 2;
eyeViewport_[ovrEye_Right].Size.h = renderTexSize_.h;
eyeTexture_[ovrEye_Left].OGL.Header.API = ovrRenderAPI_OpenGL;
eyeTexture_[ovrEye_Left].OGL.Header.TextureSize = renderTexSize_;
eyeTexture_[ovrEye_Left].OGL.Header.RenderViewport = eyeViewport_[ovrEye_Left];
eyeTexture_[ovrEye_Left].OGL.TexId = renderTex_;
eyeTexture_[ovrEye_Right].OGL.Header.API = ovrRenderAPI_OpenGL;
eyeTexture_[ovrEye_Right].OGL.Header.TextureSize = renderTexSize_;
eyeTexture_[ovrEye_Right].OGL.Header.RenderViewport = eyeViewport_[ovrEye_Right];
eyeTexture_[ovrEye_Right].OGL.TexId = renderTex_;
ovrSizei targetSize;
SDL_GetWindowSize(window_, &targetSize.w, &targetSize.h);
SDL_SysWMinfo wmInfo;
SDL_VERSION(&wmInfo.version);
if(!SDL_GetWindowWMInfo(window_, &wmInfo))
{
throw runtime_error("Failed to get window info");
}
ovrGLConfig cfg;
cfg.OGL.Header.API = ovrRenderAPI_OpenGL;
cfg.OGL.Header.RTSize = targetSize;
cfg.OGL.Header.Multisample = 1; // yes?
#if defined(OVR_OS_WIN32)
cfg.OGL.Window = wmInfo.info.win.window;
cfg.OGL.DC = GetDC(wmInfo.info.win.window);
#elif defined(OVR_OS_MAC)
// Mac does not have any fields
#else
#error Implement for this OS.
#endif
unsigned int distortionCaps = ovrDistortionCap_Chromatic|ovrDistortionCap_TimeWarp|ovrDistortionCap_Overdrive;
if(!ovrHmd_ConfigureRendering(hmd_, &cfg.Config, distortionCaps, hmd_->DefaultEyeFov, eyeRenderDesc_))
{
throw runtime_error("Failed to configure HMD rendering");
}
#ifdef OVR_OS_WIN32
if(!ovrHmd_AttachToWindow(hmd_, wmInfo.info.win.window, nullptr, nullptr))
{
throw runtime_error("Failed to attach HMD to window");
}
#endif
glGenFramebuffers(1, &framebuffer_);
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, renderTex_, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthTex_, 0);
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
throw runtime_error("Framebuffer not complete");
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
unsigned int trackingCaps = ovrTrackingCap_Orientation|ovrTrackingCap_Position;
if(!ovrHmd_ConfigureTracking(hmd_, trackingCaps, 0))
{
throw runtime_error("Failed to configure HMD tracking");
}
// warning will disappear as soon as the timeout expires
ovrHmd_DismissHSWDisplay(hmd_);
}
int32_t VR_OVR_Enable()
{
int32_t failure = 0;
unsigned int hmdCaps = 0;
qboolean isDebug = false;
unsigned int device = 0;
if (!vr_ovr_enable->value)
return 0;
if (!libovrInitialized)
{
libovrInitialized = ovr_Initialize();
if (!libovrInitialized)
{
Com_Printf("VR_OVR: Fatal error: could not initialize LibOVR!\n");
return 0;
} else {
Com_Printf("VR_OVR: %s initialized...\n",ovr_GetVersionString());
}
}
{
int numDevices = ovrHmd_Detect();
int i;
qboolean found = false;
memset(hmdnames,0,sizeof(ovrname_t) * 255);
Com_Printf("VR_OVR: Enumerating devices...\n");
Com_Printf("VR_OVR: Found %i devices\n", numDevices);
for (i = 0 ; i < numDevices ; i++)
{
ovrHmd tempHmd = ovrHmd_Create(i);
if (tempHmd)
{
Com_Printf("VR_OVR: Found device #%i '%s' s/n:%s\n",i,tempHmd->ProductName, tempHmd->SerialNumber);
sprintf(hmdnames[i].label,"%i: %s",i + 1, tempHmd->ProductName);
sprintf(hmdnames[i].serialnumber,"%s",tempHmd->SerialNumber);
if (!strncmp(vr_ovr_device->string,tempHmd->SerialNumber,strlen(tempHmd->SerialNumber)))
{
device = i;
found = true;
}
ovrHmd_Destroy(tempHmd);
}
}
}
Com_Printf("VR_OVR: Initializing HMD: ");
withinFrame = false;
hmd = ovrHmd_Create(device);
if (!hmd)
{
Com_Printf("no HMD detected!\n");
failure = 1;
}
else {
Com_Printf("ok!\n");
}
if (failure && vr_ovr_debug->value)
{
ovrHmdType temp = ovrHmd_None;
switch((int) vr_ovr_debug->value)
{
default:
temp = ovrHmd_DK1;
break;
case 2:
temp = ovrHmd_DKHD;
break;
case 3:
temp = ovrHmd_DK2;
break;
}
hmd = ovrHmd_CreateDebug(temp);
isDebug = true;
Com_Printf("VR_OVR: Creating debug HMD...\n");
}
if (!hmd)
return 0;
if (hmd->HmdCaps & ovrHmdCap_ExtendDesktop)
{
Com_Printf("...running in extended desktop mode\n");
} else if (!isDebug) {
Com_Printf("...running in Direct HMD mode\n");
Com_Printf("...Direct HMD mode is unsupported at this time\n");
VR_OVR_Disable();
VR_OVR_Shutdown();
return 0;
}
Com_Printf("...device positioned at (%i,%i)\n",hmd->WindowsPos.x,hmd->WindowsPos.y);
if (hmd->HmdCaps & ovrHmdCap_Available)
Com_Printf("...sensor is available\n");
if (hmd->HmdCaps & ovrHmdCap_LowPersistence)
Com_Printf("...supports low persistance\n");
if (hmd->HmdCaps & ovrHmdCap_DynamicPrediction)
Com_Printf("...supports dynamic motion prediction\n");
if (hmd->TrackingCaps & ovrTrackingCap_Position)
Com_Printf("...supports position tracking\n");
Com_Printf("...has type %s\n", hmd->ProductName);
Com_Printf("...has %ux%u native resolution\n", hmd->Resolution.w, hmd->Resolution.h);
if (!VR_OVR_InitSensor())
{
Com_Printf("VR_OVR: Sensor initialization failed!\n");
}
ovrHmd_ResetFrameTiming(hmd,0);
return 1;
}
void OcculusCameraComponent::init()
{
ovr_Initialize();
parent->getStage()->getGame()->getGraphicsHandle()->setAutoBufferSwap( false );
hmd = ovrHmd_Create(0);
if (hmd)
{
ovrSizei resolution = hmd->Resolution;
resolution;
}
else
{
hmd = ovrHmd_CreateDebug( ovrHmdType::ovrHmd_DK2 );
}
// Start the sensor which provides the Rift’s pose and motion.
//ovrHmd_SetEnabledCaps(hmd, ovrHmdCap_LowPersistence | ovrHmdCap_DynamicPrediction);
ovrHmd_ConfigureTracking(hmd, ovrTrackingCap_Orientation | ovrTrackingCap_MagYawCorrection | ovrTrackingCap_Position, 0);
ovrHmd_RecenterPose( hmd );
ovrFovPort eyeFov[2] = { hmd->DefaultEyeFov[0], hmd->DefaultEyeFov[1] } ;
ovrGLConfig oglConfig;
oglConfig.OGL.Header.API = ovrRenderAPI_OpenGL;
oglConfig.OGL.Header.RTSize = OVR::Sizei(hmd->Resolution.w, hmd->Resolution.h);
oglConfig.OGL.Header.Multisample = 1;
oglConfig.OGL.Window = parent->getStage()->getGame()->getGraphicsHandle()->getHandle();
oglConfig.OGL.DC = parent->getStage()->getGame()->getGraphicsHandle()->getHDC();
#pragma comment(lib,"libovrd.lib")
ovrBool result = ovrHmd_ConfigureRendering( hmd, &oglConfig.Config,
ovrDistortionCap_Chromatic | ovrDistortionCap_Vignette |
ovrDistortionCap_TimeWarp | ovrDistortionCap_Overdrive,
eyeFov, EyeRenderDesc);
result;
ovrHmd_AttachToWindow(hmd, oglConfig.OGL.Window, NULL, NULL);
//Sets up FBOS
// Configure Stereo settings.
OVR::Sizei recommenedTex0Size = ovrHmd_GetFovTextureSize(hmd, ovrEye_Left, hmd->DefaultEyeFov[0], 1.0f);
OVR::Sizei recommenedTex1Size = ovrHmd_GetFovTextureSize(hmd, ovrEye_Right, hmd->DefaultEyeFov[1], 1.0f);
OVR::Sizei renderTargetSize;
renderTargetSize.w = recommenedTex0Size.w + recommenedTex1Size.w;
renderTargetSize.h = max ( recommenedTex0Size.h, recommenedTex1Size.h );
renderTarget = FrameBufferObject::createFrameBuffer( renderTargetSize.w, renderTargetSize.h );
//Set up viewports
EyeRenderViewport[0].Pos = OVR::Vector2i(0,0);
EyeRenderViewport[0].Size = OVR::Sizei(renderTarget->width / 2, renderTarget->height);
EyeRenderViewport[1].Pos = OVR::Vector2i((renderTarget->width + 1) / 2, 0);
EyeRenderViewport[1].Size = EyeRenderViewport[0].Size;
EyeTexture[0].OGL.Header.API = ovrRenderAPI_OpenGL;
EyeTexture[0].OGL.Header.TextureSize = renderTargetSize;
EyeTexture[0].OGL.Header.RenderViewport = EyeRenderViewport[0];
EyeTexture[0].OGL.TexId = renderTarget->colorTexture->textureID;
EyeTexture[1].OGL.Header.API = ovrRenderAPI_OpenGL;
EyeTexture[1].OGL.Header.TextureSize = renderTargetSize;
EyeTexture[1].OGL.Header.RenderViewport = EyeRenderViewport[1];
EyeTexture[1].OGL.TexId = renderTarget->colorTexture->textureID;
}
OculusDevice::OculusDevice(float nearClip, float farClip, bool useTimewarp) : m_hmdDevice(0),
m_nearClip(nearClip), m_farClip(farClip),
m_useTimeWarp(useTimewarp),
m_position(osg::Vec3(0.0f, 0.0f, 0.0f)),
m_orientation(osg::Quat(0.0f, 0.0f, 0.0f, 1.0f))
{
ovr_Initialize();
// Enumerate HMD devices
int numberOfDevices = ovrHmd_Detect();
osg::notify(osg::DEBUG_INFO) << "Number of connected devices: " << numberOfDevices << std::endl;
// Get first available HMD
m_hmdDevice = ovrHmd_Create(0);
// If no HMD is found try an emulated device
if (!m_hmdDevice) {
osg::notify(osg::WARN) << "Warning: No device could be found. Creating emulated device " << std::endl;
m_hmdDevice = ovrHmd_CreateDebug(ovrHmd_DK1);
ovrHmd_ResetFrameTiming(m_hmdDevice, 0);
}
if (m_hmdDevice) {
// Print out some information about the HMD
osg::notify(osg::ALWAYS) << "Product: " << m_hmdDevice->ProductName << std::endl;
osg::notify(osg::ALWAYS) << "Manufacturer: " << m_hmdDevice->Manufacturer << std::endl;
osg::notify(osg::ALWAYS) << "VendorId: " << m_hmdDevice->VendorId << std::endl;
osg::notify(osg::ALWAYS) << "ProductId: " << m_hmdDevice->ProductId << std::endl;
osg::notify(osg::ALWAYS) << "SerialNumber: " << m_hmdDevice->SerialNumber << std::endl;
osg::notify(osg::ALWAYS) << "FirmwareVersion: " << m_hmdDevice->FirmwareMajor << "." << m_hmdDevice->FirmwareMinor << std::endl;
// Get more details about the HMD.
m_resolution = m_hmdDevice->Resolution;
// Compute recommended render texture size
float pixelsPerDisplayPixel = 1.0f; // Decrease this value to scale the size on render texture on lower performance hardware. Values above 1.0 is unnecessary.
ovrSizei recommenedLeftTextureSize = ovrHmd_GetFovTextureSize(m_hmdDevice, ovrEye_Left, m_hmdDevice->DefaultEyeFov[0], pixelsPerDisplayPixel);
ovrSizei recommenedRightTextureSize = ovrHmd_GetFovTextureSize(m_hmdDevice, ovrEye_Right, m_hmdDevice->DefaultEyeFov[1], pixelsPerDisplayPixel);
// Compute size of render target
m_renderTargetSize.w = recommenedLeftTextureSize.w + recommenedRightTextureSize.w;
m_renderTargetSize.h = osg::maximum(recommenedLeftTextureSize.h, recommenedRightTextureSize.h);
// Initialize ovrEyeRenderDesc struct.
m_eyeRenderDesc[0] = ovrHmd_GetRenderDesc(m_hmdDevice, ovrEye_Left, m_hmdDevice->DefaultEyeFov[0]);
m_eyeRenderDesc[1] = ovrHmd_GetRenderDesc(m_hmdDevice, ovrEye_Right, m_hmdDevice->DefaultEyeFov[1]);
ovrVector3f leftEyeAdjust = m_eyeRenderDesc[0].ViewAdjust;
m_leftEyeAdjust.set(leftEyeAdjust.x, leftEyeAdjust.y, leftEyeAdjust.z);
ovrVector3f rightEyeAdjust = m_eyeRenderDesc[1].ViewAdjust;
m_rightEyeAdjust.set(rightEyeAdjust.x, rightEyeAdjust.y, rightEyeAdjust.z);
bool isRightHanded = true;
ovrMatrix4f leftEyeProjectionMatrix = ovrMatrix4f_Projection(m_eyeRenderDesc[0].Fov, m_nearClip, m_farClip, isRightHanded);
// Transpose matrix
m_leftEyeProjectionMatrix.set(leftEyeProjectionMatrix.M[0][0], leftEyeProjectionMatrix.M[1][0], leftEyeProjectionMatrix.M[2][0], leftEyeProjectionMatrix.M[3][0],
leftEyeProjectionMatrix.M[0][1], leftEyeProjectionMatrix.M[1][1], leftEyeProjectionMatrix.M[2][1], leftEyeProjectionMatrix.M[3][1],
leftEyeProjectionMatrix.M[0][2], leftEyeProjectionMatrix.M[1][2], leftEyeProjectionMatrix.M[2][2], leftEyeProjectionMatrix.M[3][2],
leftEyeProjectionMatrix.M[0][3], leftEyeProjectionMatrix.M[1][3], leftEyeProjectionMatrix.M[2][3], leftEyeProjectionMatrix.M[3][3]);
ovrMatrix4f rightEyeProjectionMatrix = ovrMatrix4f_Projection(m_eyeRenderDesc[1].Fov, m_nearClip, m_farClip, isRightHanded);
// Transpose matrix
m_rightEyeProjectionMatrix.set(rightEyeProjectionMatrix.M[0][0], rightEyeProjectionMatrix.M[1][0], rightEyeProjectionMatrix.M[2][0], rightEyeProjectionMatrix.M[3][0],
rightEyeProjectionMatrix.M[0][1], rightEyeProjectionMatrix.M[1][1], rightEyeProjectionMatrix.M[2][1], rightEyeProjectionMatrix.M[3][1],
rightEyeProjectionMatrix.M[0][2], rightEyeProjectionMatrix.M[1][2], rightEyeProjectionMatrix.M[2][2], rightEyeProjectionMatrix.M[3][2],
rightEyeProjectionMatrix.M[0][3], rightEyeProjectionMatrix.M[1][3], rightEyeProjectionMatrix.M[2][3], rightEyeProjectionMatrix.M[3][3]);
// Start the sensor which provides the Rift’s pose and motion.
ovrHmd_ConfigureTracking(m_hmdDevice, ovrTrackingCap_Orientation |
ovrTrackingCap_MagYawCorrection |
ovrTrackingCap_Position, 0);
beginFrameTiming();
}
}
OculusManager& OculusManager::getOculusManager()
{
static OculusManager* oculusManager = NULL;
if (oculusManager == NULL)
{
oculusManager = new OculusManager();
if (!ovr_Initialize()) {
fprintf(stderr, "Failed to initialize the Oculus SDK");
}
//= *OculusManager::getHmd();
g_Hmd = ovrHmd_Create(0);
if (!g_Hmd)
{
printf("No Oculus Rift device attached, using virtual version...\n");
g_Hmd = ovrHmd_CreateDebug(ovrHmd_DK2);
}
printf("initialized HMD: %s - %s\n", g_Hmd->Manufacturer, g_Hmd->ProductName);
if (!glfwInit()) exit(EXIT_FAILURE);
if (l_MultiSampling) glfwWindowHint(GLFW_SAMPLES, 4); else glfwWindowHint(GLFW_SAMPLES, 0);
bool l_DirectMode = ((g_Hmd->HmdCaps & ovrHmdCap_ExtendDesktop) == 0);
GLFWmonitor* l_Monitor;
ovrSizei l_ClientSize;
if (l_DirectMode)
{
printf("Running in \"Direct\" mode...\n");
l_Monitor = NULL;
l_ClientSize.w = g_Hmd->Resolution.w / 2; // Something reasonable, smaller, but maintain aspect ratio...
l_ClientSize.h = g_Hmd->Resolution.h / 2; // Something reasonable, smaller, but maintain aspect ratio...
}
else // Extended Desktop mode...
{
printf("Running in \"Extended Desktop\" mode...\n");
int l_Count;
GLFWmonitor** l_Monitors = glfwGetMonitors(&l_Count);
switch (l_Count)
{
case 0:
printf("No monitors found, exiting...\n");
exit(EXIT_FAILURE);
break;
case 1:
printf("Two monitors expected, found only one, using primary...\n");
l_Monitor = glfwGetPrimaryMonitor();
break;
case 2:
printf("Two monitors found, using second monitor...\n");
l_Monitor = l_Monitors[1];
break;
default:
printf("More than two monitors found, using second monitor...\n");
l_Monitor = l_Monitors[1];
}
l_ClientSize.w = g_Hmd->Resolution.w; // 1920 for DK2...
l_ClientSize.h = g_Hmd->Resolution.h; // 1080 for DK2...
}
l_Window = glfwCreateWindow(l_ClientSize.w, l_ClientSize.h, "GLFW Oculus Rift Test", l_Monitor, NULL);
if (!l_Window)
{
glfwTerminate();
exit(EXIT_FAILURE);
}
#if defined(_WIN32)
if (l_DirectMode)
{
ovrBool l_AttachResult = ovrHmd_AttachToWindow(g_Hmd, glfwGetWin32Window(l_Window), NULL, NULL);
if (!l_AttachResult)
{
printf("Could not attach to window...");
exit(EXIT_FAILURE);
}
}
#endif
glfwMakeContextCurrent(l_Window);
glewExperimental = GL_TRUE;
GLenum l_GlewResult = glewInit();
if (l_GlewResult != GLEW_OK)
{
printf("glewInit() error.\n");
exit(EXIT_FAILURE);
}
int l_Major = glfwGetWindowAttrib(l_Window, GLFW_CONTEXT_VERSION_MAJOR);
int l_Minor = glfwGetWindowAttrib(l_Window, GLFW_CONTEXT_VERSION_MINOR);
int l_Profile = glfwGetWindowAttrib(l_Window, GLFW_OPENGL_PROFILE);
printf("OpenGL: %d.%d ", l_Major, l_Minor);
if (l_Major >= 3) // Profiles introduced in OpenGL 3.0...
{
if (l_Profile == GLFW_OPENGL_COMPAT_PROFILE) printf("GLFW_OPENGL_COMPAT_PROFILE\n"); else printf("GLFW_OPENGL_CORE_PROFILE\n");
}
printf("Vendor: %s\n", (char*)glGetString(GL_VENDOR));
printf("Renderer: %s\n", (char*)glGetString(GL_RENDERER));
ovrSizei l_EyeTextureSizes[2];
l_EyeTextureSizes[ovrEye_Left] = ovrHmd_GetFovTextureSize(g_Hmd, ovrEye_Left, g_Hmd->MaxEyeFov[ovrEye_Left], 1.0f);
l_EyeTextureSizes[ovrEye_Right] = ovrHmd_GetFovTextureSize(g_Hmd, ovrEye_Right, g_Hmd->MaxEyeFov[ovrEye_Right], 1.0f);
// Combine for one texture for both eyes...
g_RenderTargetSize.w = l_EyeTextureSizes[ovrEye_Left].w + l_EyeTextureSizes[ovrEye_Right].w;
g_RenderTargetSize.h = (l_EyeTextureSizes[ovrEye_Left].h > l_EyeTextureSizes[ovrEye_Right].h ? l_EyeTextureSizes[ovrEye_Left].h : l_EyeTextureSizes[ovrEye_Right].h);
// Create the FBO being a single one for both eyes (this is open for debate)...
glGenFramebuffers(1, &l_FBOId);
glBindFramebuffer(GL_FRAMEBUFFER, l_FBOId);
// The texture we're going to render to...
glGenTextures(1, &l_TextureId);
// "Bind" the newly created texture : all future texture functions will modify this texture...
glBindTexture(GL_TEXTURE_2D, l_TextureId);
// Give an empty image to OpenGL (the last "0")
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, g_RenderTargetSize.w, g_RenderTargetSize.h, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
// Linear filtering...
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// Create Depth Buffer...
glGenRenderbuffers(1, &l_DepthBufferId);
glBindRenderbuffer(GL_RENDERBUFFER, l_DepthBufferId);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, g_RenderTargetSize.w, g_RenderTargetSize.h);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, l_DepthBufferId);
// Set the texture as our colour attachment #0...
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, l_TextureId, 0);
// Set the list of draw buffers...
GLenum l_GLDrawBuffers[1] = { GL_COLOR_ATTACHMENT0 };
glDrawBuffers(1, l_GLDrawBuffers); // "1" is the size of DrawBuffers
// Check if everything is OK...
GLenum l_Check = glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
if (l_Check != GL_FRAMEBUFFER_COMPLETE)
{
printf("There is a problem with the FBO.\n");
exit(EXIT_FAILURE);
}
// Unbind...
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Setup textures for each eye...
// Left eye...
g_EyeTextures[ovrEye_Left].Header.API = ovrRenderAPI_OpenGL;
g_EyeTextures[ovrEye_Left].Header.TextureSize = g_RenderTargetSize;
g_EyeTextures[ovrEye_Left].Header.RenderViewport.Pos.x = 0;
g_EyeTextures[ovrEye_Left].Header.RenderViewport.Pos.y = 0;
g_EyeTextures[ovrEye_Left].Header.RenderViewport.Size = l_EyeTextureSizes[ovrEye_Left];
((ovrGLTexture&)(g_EyeTextures[ovrEye_Left])).OGL.TexId = l_TextureId;
// Right eye (mostly the same as left but with the viewport on the right side of the texture)...
g_EyeTextures[ovrEye_Right] = g_EyeTextures[ovrEye_Left];
g_EyeTextures[ovrEye_Right].Header.RenderViewport.Pos.x = (g_RenderTargetSize.w + 1) / 2;
g_EyeTextures[ovrEye_Right].Header.RenderViewport.Pos.y = 0;
// Oculus Rift eye configurations...
g_Cfg.OGL.Header.API = ovrRenderAPI_OpenGL;
g_Cfg.OGL.Header.RTSize.w = l_ClientSize.w;
g_Cfg.OGL.Header.RTSize.h = l_ClientSize.h;
g_Cfg.OGL.Header.Multisample = (l_MultiSampling ? 1 : 0);
#if defined(_WIN32)
g_Cfg.OGL.Window = glfwGetWin32Window(l_Window);
g_Cfg.OGL.DC = GetDC(g_Cfg.OGL.Window);
#elif defined(__linux__)
l_Cfg.OGL.Win = glfwGetX11Window(l_Window);
l_Cfg.OGL.Disp = glfwGetX11Display();
#endif
// Enable capabilities...
// ovrHmd_SetEnabledCaps(g_Hmd, ovrHmdCap_LowPersistence | ovrHmdCap_DynamicPrediction);
ovrBool l_ConfigureResult = ovrHmd_ConfigureRendering(g_Hmd, &g_Cfg.Config, g_DistortionCaps, g_Hmd->MaxEyeFov, g_EyeRenderDesc);
glUseProgram(0); // Avoid OpenGL state leak in ovrHmd_ConfigureRendering...
if (!l_ConfigureResult)
{
printf("Configure failed.\n");
exit(EXIT_FAILURE);
}
// Start the sensor which provides the Rift’s pose and motion...
uint32_t l_SupportedSensorCaps = ovrTrackingCap_Orientation | ovrTrackingCap_MagYawCorrection | ovrTrackingCap_Position;
uint32_t l_RequiredTrackingCaps = 0;
ovrBool l_TrackingResult = ovrHmd_ConfigureTracking(g_Hmd, l_SupportedSensorCaps, l_RequiredTrackingCaps);
if (!l_TrackingResult)
{
printf("Could not start tracking...");
exit(EXIT_FAILURE);
}
// Projection matrici for each eye will not change at runtime, we can set them here...
g_ProjectionMatrici[ovrEye_Left] = ovrMatrix4f_Projection(g_EyeRenderDesc[ovrEye_Left].Fov, 0.3f, 100.0f, true);
g_ProjectionMatrici[ovrEye_Right] = ovrMatrix4f_Projection(g_EyeRenderDesc[ovrEye_Right].Fov, 0.3f, 100.0f, true);
// IPD offset values will not change at runtime, we can set them here...
g_EyeOffsets[ovrEye_Left] = g_EyeRenderDesc[ovrEye_Left].HmdToEyeViewOffset;
g_EyeOffsets[ovrEye_Right] = g_EyeRenderDesc[ovrEye_Right].HmdToEyeViewOffset;
ovrHmd_RecenterPose(g_Hmd);
return *oculusManager;
}
}
bool HeadMountedDisplay::createDebug( ovrHmdType type )
{
return ( m_handler = ovrHmd_CreateDebug( type ) ) != NULL;
}
