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");
}
}
SimpleScene() : eyes({ { PerEyeArg(LEFT), PerEyeArg(RIGHT) } }) {
eyeHeight = 1.0f;
applyProjectionOffset = true;
applyModelviewOffset = true;
{
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();
glm::mat4 modelviewOffset = glm::translate(glm::mat4(),
glm::vec3(ipd / 2.0f, 0, 0));
eyes[LEFT].modelviewOffset = modelviewOffset;
eyes[RIGHT].modelviewOffset = glm::inverse(modelviewOffset);
}
if (ovrManager) {
ovrSensor =
*ovrManager->EnumerateDevices<OVR::SensorDevice>().CreateDevice();
if (ovrSensor) {
sensorFusion.AttachToSensor(ovrSensor);
}
}
if (sensorFusion.IsAttachedToSensor()) {
SAY("Attached");
} else {
SAY("Attach failed");
}
{
OVR::HMDInfo hmdInfo;
Rift::getHmdInfo(ovrManager, hmdInfo);
OVR::Util::Render::StereoConfig config;
config.SetHMDInfo(hmdInfo);
gl::Stacks::projection().top() =
glm::perspective(config.GetYFOVRadians(), eyeAspect, 0.01f, 1000.0f);
glm::mat4 projectionOffset = glm::translate(glm::mat4(),
glm::vec3(config.GetProjectionCenterOffset(), 0, 0));
eyes[LEFT].projectionOffset = projectionOffset;
eyes[RIGHT].projectionOffset = glm::inverse(projectionOffset);
}
glm::vec3 playerPosition(0, eyeHeight, ipd * 4.0f);
player = glm::inverse(glm::lookAt(playerPosition, glm::vec3(0, eyeHeight, 0), GlUtils::Y_AXIS));
CameraControl::instance().enableHydra(true);
}
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);
}