void toggleRenderScale() {
if(renderScale != 1) {
setRenderScale(1);
} else {
setRenderScale(stereo.GetDistortionScale());
}
}
ShaderLookupDistort() : lookupTextureSize(512, 512), chroma(true) {
OVR::Util::Render::StereoConfig stereoConfig;
stereoConfig.SetHMDInfo(ovrHmdInfo);
const OVR::Util::Render::DistortionConfig & distortion =
stereoConfig.GetDistortionConfig();
// The Rift examples use a post-distortion scale to resize the
// image upward after distorting it because their K values have
// been chosen such that they always result in a scale > 1.0, and
// thus shrink the image. However, we can correct for that by
// finding the distortion scale the same way the OVR examples do,
// and then pre-multiplying the constants by it.
double postDistortionScale = 1.0 / stereoConfig.GetDistortionScale();
for (int i = 0; i < 4; ++i) {
K[i] = (float)(distortion.K[i] * postDistortionScale);
}
// red channel correction
chromaK[0] = glm::vec2(
ovrHmdInfo.ChromaAbCorrection[0],
ovrHmdInfo.ChromaAbCorrection[1]);
// blue channel correction
chromaK[1] = glm::vec2(
ovrHmdInfo.ChromaAbCorrection[2],
ovrHmdInfo.ChromaAbCorrection[3]);
for (int i = 0; i < 2; ++i) {
chromaK[i][0] = ((1.0 - chromaK[i][0]) * postDistortionScale) + 1.0;
chromaK[i][1] *= postDistortionScale;
}
lensOffset = 1.0f - (2.0f * ovrHmdInfo.LensSeparationDistance / ovrHmdInfo.HScreenSize);
}
DistortionHelper(const OVR::HMDInfo & ovrHmdInfo) {
OVR::Util::Render::StereoConfig stereoConfig;
stereoConfig.SetHMDInfo(ovrHmdInfo);
const OVR::Util::Render::DistortionConfig & distortion =
stereoConfig.GetDistortionConfig();
double postDistortionScale = 1.0 / stereoConfig.GetDistortionScale();
for (int i = 0; i < 4; ++i) {
K[i] = distortion.K[i] * postDistortionScale;
}
lensOffset = distortion.XCenterOffset;
eyeAspect = ovrHmdInfo.HScreenSize / 2.0f / ovrHmdInfo.VScreenSize;
}
SimpleScene() {
OVR::Ptr<OVR::ProfileManager> profileManager =
*OVR::ProfileManager::Create();
OVR::Ptr<OVR::Profile> profile =
*(profileManager->GetDeviceDefaultProfile(
OVR::ProfileType::Profile_RiftDK1));
ipd = profile->GetIPD();
eyeHeight = profile->GetEyeHeight();
// setup the initial player location
player = glm::inverse(glm::lookAt(
glm::vec3(0, eyeHeight, ipd * 4.0f),
glm::vec3(0, eyeHeight, 0),
GlUtils::Y_AXIS));
OVR::Util::Render::StereoConfig ovrStereoConfig;
ovrStereoConfig.SetHMDInfo(ovrHmdInfo);
gl::Stacks::projection().top() =
glm::perspective(ovrStereoConfig.GetYFOVRadians(),
glm::aspect(eyeSize), 0.01f, 1000.0f);
eyes[LEFT].viewportPosition =
glm::uvec2(0, 0);
eyes[LEFT].modelviewOffset = glm::translate(glm::mat4(),
glm::vec3(ipd / 2.0f, 0, 0));
eyes[LEFT].projectionOffset = glm::translate(glm::mat4(),
glm::vec3(ovrStereoConfig.GetProjectionCenterOffset(), 0, 0));
eyes[RIGHT].viewportPosition =
glm::uvec2(hmdNativeResolution.x / 2, 0);
eyes[RIGHT].modelviewOffset = glm::translate(glm::mat4(),
glm::vec3(-ipd / 2.0f, 0, 0));
eyes[RIGHT].projectionOffset = glm::translate(glm::mat4(),
glm::vec3(-ovrStereoConfig.GetProjectionCenterOffset(), 0, 0));
distortionScale = ovrStereoConfig.GetDistortionScale();
ovrSensor =
*ovrManager->EnumerateDevices<OVR::SensorDevice>().
CreateDevice();
if (ovrSensor) {
sensorFusion.AttachToSensor(ovrSensor);
}
if (!sensorFusion.IsAttachedToSensor()) {
SAY_ERR("Could not attach to sensor device");
}
}
void initRift() {
OVR::System::Init(OVR::Log::ConfigureDefaultLog(OVR::LogMask_All));
pFusionResult = new OVR::SensorFusion();
pManager = *OVR::DeviceManager::Create();
//pManager->SetMessageHandler(this);
pHMD = *pManager->EnumerateDevices<OVR::HMDDevice>().CreateDevice();
stereo.Set2DAreaFov(OVR::DegreeToRad(50.0f));
stereo.SetFullViewport(OVR::Util::Render::Viewport(0,0, width, height));
stereo.SetStereoMode(OVR::Util::Render::Stereo_LeftRight_Multipass);
stereo.SetDistortionFitPointVP(-1.0f, 0.0f);
renderScale = stereo.GetDistortionScale();
if (pHMD)
{
pSensor = *pHMD->GetSensor();
InfoLoaded = pHMD->GetDeviceInfo(&Info);
strncpy(Info.DisplayDeviceName, RiftMonitorName, 32);
RiftDisplayId = Info.DisplayId;
EyeDistance = Info.InterpupillaryDistance;
for(int i = 0; i < 4; ++i) {
DistortionK[i] = Info.DistortionK[i];
DistortionChromaticAberration[i] = Info.ChromaAbCorrection[i];
}
stereo.SetHMDInfo(Info);
stereo.SetDistortionFitPointVP(-1.0f, 0.0f);
renderScale = stereo.GetDistortionScale();
}
else
{
pSensor = *pManager->EnumerateDevices<OVR::SensorDevice>().CreateDevice();
}
textureWidth = width * renderScale;
textureHeight = height * renderScale;
leftEye = stereo.GetEyeRenderParams(OVR::Util::Render::StereoEye_Left);
rightEye = stereo.GetEyeRenderParams(OVR::Util::Render::StereoEye_Right);
// Left eye rendering parameters
leftVP = leftEye.VP;
leftProjection = leftEye.Projection;
leftViewAdjust = leftEye.ViewAdjust;
// Right eye rendering parameters
rightVP = leftEye.VP;
rightProjection = leftEye.Projection;
rightViewAdjust = leftEye.ViewAdjust;
if (pSensor)
{
pFusionResult->AttachToSensor(pSensor);
pFusionResult->SetPredictionEnabled(true);
float motionPred = pFusionResult->GetPredictionDelta(); // adjust in 0.01 increments
if(motionPred < 0) motionPred = 0;
pFusionResult->SetPrediction(motionPred);
if(InfoLoaded) {
riftConnected = true;
riftX = Info.DesktopX;
riftY = Info.DesktopY;
riftResolutionX = Info.HResolution;
riftResolutionY = Info.VResolution;
}
}
#ifdef WIN32
getRiftDisplay();
#endif
}
HelloRift() : useTracker(false) {
ovrManager = *OVR::DeviceManager::Create();
if (!ovrManager) {
FAIL("Unable to initialize OVR Device Manager");
}
OVR::Ptr<OVR::HMDDevice> ovrHmd =
*ovrManager->EnumerateDevices<OVR::HMDDevice>().CreateDevice();
OVR::HMDInfo hmdInfo;
if (ovrHmd) {
ovrHmd->GetDeviceInfo(&hmdInfo);
ovrSensor = *ovrHmd->GetSensor();
} else {
Rift::getDk1HmdValues(hmdInfo);
}
ovrHmd.Clear();
if (!ovrSensor) {
ovrSensor =
*ovrManager->EnumerateDevices<OVR::SensorDevice>().CreateDevice();
}
if (ovrSensor) {
sensorFusion.AttachToSensor(ovrSensor);
useTracker = sensorFusion.IsAttachedToSensor();
}
ipd = hmdInfo.InterpupillaryDistance;
distortionCoefficients = glm::vec4(
hmdInfo.DistortionK[0], hmdInfo.DistortionK[1],
hmdInfo.DistortionK[2], hmdInfo.DistortionK[3]);
windowPosition = glm::ivec2(hmdInfo.DesktopX, hmdInfo.DesktopY);
// The HMDInfo gives us the position of the Rift in desktop
// coordinates as well as the native resolution of the Rift
// display panel, but NOT the current resolution of the signal
// being sent to the Rift.
GLFWmonitor * hmdMonitor =
GlfwApp::getMonitorAtPosition(windowPosition);
if (!hmdMonitor) {
FAIL("Unable to find Rift display");
}
// For the current resoltuion we must find the appropriate GLFW monitor
const GLFWvidmode * videoMode =
glfwGetVideoMode(hmdMonitor);
windowSize = glm::ivec2(videoMode->width, videoMode->height);
// The eyeSize is used to help us set the viewport when rendering to
// each eye. This should be based off the video mode that is / will
// be sent to the Rift
// We also use the eyeSize to set up the framebuffer which will be
// used to render the scene to a texture for distortion and display
// on the Rift. The Framebuffer resolution does not have to match
// the Physical display resolution in either aspect ratio or
// resolution, but using a resolution less than the native pixels can
// negatively impact image quality.
eyeSize = windowSize;
eyeSize.x /= 2;
eyeArgs[1].viewportLocation = glm::ivec2(eyeSize.x, 0);
eyeArgs[0].viewportLocation = glm::ivec2(0, 0);
// Notice that the eyeAspect we calculate is based on the physical
// display resolution, regardless of the current resolution being
// sent to the Rift. The Rift scales the image sent to it to fit
// the display panel, so a 1920x1080 image (with an aspect ratio of
// 16:9 will be displayed with the aspect ratio of the Rift display
// (16:10 for the DK1). This means that if you're cloning a
// 1920x1080 output to the rift and an conventional monitor of those
// dimensions the conventional monitor's image will appear a bit
// squished. This is expected and correct.
eyeAspect = (float)(hmdInfo.HResolution / 2) /
(float)hmdInfo.VResolution;
// Some of the values needed by the rendering or distortion need some
// calculation to find, but the OVR SDK includes a utility class to
// do them, so we use it here to get the ProjectionOffset and the
// post distortion scale.
OVR::Util::Render::StereoConfig stereoConfig;
stereoConfig.SetHMDInfo(hmdInfo);
// The overall distortion effect has a shrinking effect.
postDistortionScale = 1.0f / stereoConfig.GetDistortionScale();
// The projection offset and lens offset are both in normalized
// device coordinates, i.e. [-1, 1] on both the X and Y axis
glm::vec3 projectionOffsetVector =
glm::vec3(stereoConfig.GetProjectionCenterOffset() / 2.0f, 0, 0);
eyeArgs[0].projectionOffset =
glm::translate(glm::mat4(), projectionOffsetVector);
eyeArgs[1].projectionOffset =
glm::translate(glm::mat4(), -projectionOffsetVector);
eyeArgs[0].lensOffset =
1.0f - (2.0f * hmdInfo.LensSeparationDistance / hmdInfo.HScreenSize);
eyeArgs[1].lensOffset = -eyeArgs[0].lensOffset;
// The IPD and the modelview offset are in meters. If you wish to have a
// different unit for the scale of your world coordinates, you would need
// to apply the conversion factor here.
glm::vec3 modelviewOffsetVector =
glm::vec3(stereoConfig.GetIPD() / 2.0f, 0, 0);
eyeArgs[0].modelviewOffset =
glm::translate(glm::mat4(), modelviewOffsetVector);
eyeArgs[1].modelviewOffset =
glm::translate(glm::mat4(), -modelviewOffsetVector);
gl::Stacks::projection().top() = glm::perspective(
stereoConfig.GetYFOVDegrees() * DEGREES_TO_RADIANS,
eyeAspect,
Rift::ZNEAR, Rift::ZFAR);
}