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");
}
}
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);
}
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
}
int main(int argc, char* argv[]) {
OVR::System::Init();
ovrManager = *OVR::DeviceManager::Create();
{
OVR::Ptr<OVR::HMDDevice> ovrHmd = *ovrManager->EnumerateDevices<OVR::HMDDevice>().CreateDevice();
if (ovrHmd) {
ovrHmd->GetDeviceInfo(&ovrHmdInfo);
ovrSensor = *ovrHmd->GetSensor();
} else {
ovrHmdInfo.HResolution = 1280;
ovrHmdInfo.VResolution = 800;
ovrHmdInfo.HScreenSize = 0.14976f;
ovrHmdInfo.VScreenSize = 0.09360f;
ovrHmdInfo.VScreenCenter = 0.04680f;
ovrHmdInfo.EyeToScreenDistance = 0.04100f;
ovrHmdInfo.LensSeparationDistance = 0.06350f;
ovrHmdInfo.InterpupillaryDistance = 0.06400f;
ovrHmdInfo.DistortionK[0] = 1;
ovrHmdInfo.DistortionK[1] = 0.22f;
ovrHmdInfo.DistortionK[2] = 0.24f;
ovrHmdInfo.DistortionK[3] = 0;
ovrHmdInfo.DesktopX = 100;
ovrHmdInfo.DesktopY = 100;
ovrHmdInfo.ChromaAbCorrection[0] = 0.99600f;
ovrHmdInfo.ChromaAbCorrection[1] = -0.00400f;
ovrHmdInfo.ChromaAbCorrection[2] = 1.01400f;
ovrHmdInfo.ChromaAbCorrection[3] = 0;
}
}
ovrStereoConfig.SetHMDInfo(ovrHmdInfo);
if (!ovrSensor) {
ovrSensor = *ovrManager->EnumerateDevices<OVR::SensorDevice>().CreateDevice();
}
ovrSensorFusion = new OVR::SensorFusion();
if (ovrSensor) {
ovrSensorFusion->AttachToSensor(ovrSensor);
}
setlocale(LC_ALL, "");
setlocale(LC_NUMERIC, "C");
fprintf(stdout, "\nDone\n", SDL_GetError());
// bindtextdomain(PACKAGE, LOCALEDIR);
// bind_textdomain_codeset(PACKAGE, "UTF-8");
// textdomain (PACKAGE);
CONFIG_DATA_DIR = getenv("CELESTIA_HOME");
if (Directory::chdir(CONFIG_DATA_DIR) == -1) {
cerr << "Cannot chdir to '" << CONFIG_DATA_DIR
<< "', probably due to improper installation\n";
}
// Not ready to render yet
ready = false;
char c;
int startfile = 0;
//while ((c = getopt(argc, argv, "v::f")) > -1) {
// if (c == '?') {
// cout << "Usage: celestia [-v] [-f <filename>]\n";
// exit(1);
// }
// else if (c == 'v') {
// if (optarg)
// SetDebugVerbosity(atoi(optarg));
// else
// SetDebugVerbosity(0);
// }
// else if (c == 'f') {
// startfile = 1;
// }
//}
appCore = new CelestiaCore();
if (appCore == NULL) {
cerr << "Out of memory.\n";
return 1;
}
static SimpleNotifier notifier;
if (!appCore->initSimulation(NULL, NULL, ¬ifier)) {
return 1;
}
appCore->getSimulation()->getActiveObserver()->setFOV(ovrStereoConfig.GetYFOVDegrees());
if (0 != SDL_Init(SDL_INIT_EVERYTHING)) {
cerr << endl << "Unable to initialize SDL: " << SDL_GetError()
<< endl;
return 1;
}
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
sdlWindow = SDL_CreateWindow(AppName,
ovrHmdInfo.DesktopX, ovrHmdInfo.DesktopY,
ovrHmdInfo.HResolution, ovrHmdInfo.VResolution,
SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_BORDERLESS);
// SDL_SetWindowPosition();
appCore->resize(ovrHmdInfo.HResolution, ovrHmdInfo.VResolution);
sdlGlContext = SDL_GL_CreateContext(sdlWindow);
SDL_GL_SetSwapInterval(1);
glewExperimental = GL_TRUE;
GLenum glewErr = glewInit();
// GL should be all set up, now initialize the renderer.
appCore->initRenderer();
// Set the simulation starting time to the current system time
time_t curtime = time(NULL);
appCore->start(
(double) curtime / 86400.0 + (double) astro::Date(1970, 1, 1));
localtime(&curtime); // Only doing this to set timezone as a side effect
appCore->setTimeZoneBias(-timezone);
appCore->setTimeZoneName(tzname[daylight ? 0 : 1]);
if (startfile == 1) {
if (argv[argc - 1][0] == '-') {
cout << "Missing Filename.\n";
return 1;
}
cout << "*** Using CEL File: " << argv[argc - 1] << endl;
appCore->runScript(argv[argc - 1]);
}
ready = true;
SDL_Event event;
while (!quit) {
if (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_WINDOWEVENT:
onWindowEvent(event.window);
break;
case SDL_KEYDOWN:
case SDL_KEYUP:
onKeyboardEvent(event.key);
break;
case SDL_MOUSEMOTION:
onMouseMotion(event.motion);
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
onMouseButton(event.button);
break;
case SDL_MOUSEWHEEL:
onMouseWheel(event.wheel);
break;
}
}
else {
appCore->tick();
if (ready) {
appCore->draw();
SDL_GL_SwapWindow(sdlWindow);
}
}
}
SDL_DestroyWindow(sdlWindow);
SDL_Quit();
delete appCore;
appCore = NULL;
delete ovrSensorFusion;
ovrManager.Clear();
OVR::System::Destroy();
return 0;
}
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);
}