Пример #1
0
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");
    }
  }
Пример #5
0
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);
  }