void cleanUpRift() {
if(pSensor) pSensor.Clear();
if(pHMD) pHMD.Clear();
if(pManager) pManager.Clear();
if(pFusionResult) delete pFusionResult;
OVR::System::Destroy();
}
void cleanUpRift() {
pSensor.Clear();
pManager.Clear();
OVR::System::Destroy();
}
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);
}