Esempio n. 1
0
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, &notifier)) {
    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);
  }