bool OVR::swap(HMD& _hmd) { if (NULL == m_hmd) { return false; } ovrHmd_EndFrame(m_hmd, m_pose, m_texture); if (m_warning) { m_warning = !ovrHmd_DismissHSWDisplay(m_hmd); } m_timing = ovrHmd_BeginFrame(m_hmd, 0); #if OVR_VERSION > OVR_VERSION_042 m_pose[0] = ovrHmd_GetHmdPosePerEye(m_hmd, ovrEye_Left); m_pose[1] = ovrHmd_GetHmdPosePerEye(m_hmd, ovrEye_Right); #else m_pose[0] = ovrHmd_GetEyePose(m_hmd, ovrEye_Left); m_pose[1] = ovrHmd_GetEyePose(m_hmd, ovrEye_Right); #endif // OVR_VERSION > OVR_VERSION_042 getEyePose(_hmd); return true; }
void OVR::postReset(const ovrTexture& _texture) { if (NULL != m_hmd) { m_texture[0] = _texture; m_texture[1] = _texture; ovrRecti rect; rect.Pos.x = 0; rect.Pos.y = 0; rect.Size.w = m_rtSize.w/2; rect.Size.h = m_rtSize.h; m_texture[0].Header.RenderViewport = rect; rect.Pos.x += rect.Size.w; m_texture[1].Header.RenderViewport = rect; m_timing = ovrHmd_BeginFrame(m_hmd, 0); #if OVR_VERSION > OVR_VERSION_042 m_pose[0] = ovrHmd_GetHmdPosePerEye(m_hmd, ovrEye_Left); m_pose[1] = ovrHmd_GetHmdPosePerEye(m_hmd, ovrEye_Right); #else m_pose[0] = ovrHmd_GetEyePose(m_hmd, ovrEye_Left); m_pose[1] = ovrHmd_GetEyePose(m_hmd, ovrEye_Right); #endif // OVR_VERSION > OVR_VERSION_042 } }
ovrPosef HeadMountedDisplay::posePerEye( ovrEyeType eye ) { ovrPosef ret; KVS_OVR_CALL( ret = ovrHmd_GetHmdPosePerEye( m_handler, eye ) ); return ret; }
/** Get view and projection matrices appropriate for the Oculus HMD */ static void viewmat_get_hmd_oculus(float viewmatrix[16], float projmatrix[16], int viewportID) { #ifndef MISSING_OVR /* Oculus recommends the order that we should render eyes. We * assume that smaller viewportIDs are rendered first. So, we need * to map the viewportIDs to the specific Oculus HMD eye. The * "eye" variable will be set to either ovrEye_Left (if we are * rendering the left eye) or ovrEye_Right (if we are rendering * the right eye). */ ovrEyeType eye = hmd->EyeRenderOrder[viewportID]; /* Oculus doesn't provide us with easy access to the view * frustum information. We get the projection matrix directly * from libovr. */ ovrMatrix4f ovrpersp = ovrMatrix4f_Projection(hmd->DefaultEyeFov[eye], 0.5, 500, 1); mat4f_setRow(projmatrix, &(ovrpersp.M[0][0]), 0); mat4f_setRow(projmatrix, &(ovrpersp.M[1][0]), 1); mat4f_setRow(projmatrix, &(ovrpersp.M[2][0]), 2); mat4f_setRow(projmatrix, &(ovrpersp.M[3][0]), 3); float offsetMat[16], rotMat[16], posMat[16], initPosMat[16]; mat4f_identity(offsetMat); // Viewpoint offset (IPD, etc); mat4f_identity(rotMat); // tracking system rotation mat4f_identity(posMat); // tracking system position mat4f_identity(initPosMat); // camera starting location /* Construct posMat and rotMat matrices which indicate the * position and orientation of the HMD. */ if(viewmat_vrpn_obj) // get position from VRPN { /* Get the offset for the left and right eyes from * Oculus. If you are using a separate tracking system, you * may also want to apply an offset here between the tracked * point and the eye location. */ mat4f_translate_new(offsetMat, eye_rdesc[eye].HmdToEyeViewOffset.x, // left & right IPD offset eye_rdesc[eye].HmdToEyeViewOffset.y, // vertical offset eye_rdesc[eye].HmdToEyeViewOffset.z); // forward/back offset float pos[3] = { 0,0,0 }; vrpn_get(viewmat_vrpn_obj, NULL, pos, rotMat); mat4f_translate_new(posMat, -pos[0], -pos[1], -pos[2]); // position viewmat_fix_rotation(rotMat); } else // get position from Oculus tracker { pose[eye] = ovrHmd_GetHmdPosePerEye(hmd, eye); mat4f_translate_new(posMat, // position (includes IPD offset) -pose[eye].Position.x, -pose[eye].Position.y, -pose[eye].Position.z); mat4f_rotateQuat_new(rotMat, // rotation pose[eye].Orientation.x, pose[eye].Orientation.y, pose[eye].Orientation.z, pose[eye].Orientation.w); // Starting point: // Translate the world based on the initial camera position // specified in viewmat_init(). You may choose to initialize the // camera position with y=1.5 meters to approximate a normal // standing eyeheight. float initPosVec[3]; vec3f_scalarMult_new(initPosVec, oculus_initialPos, -1.0f); mat4f_translateVec_new(initPosMat, initPosVec); // TODO: Could also get eyeheight via ovrHmd_GetFloat(hmd, OVR_KEY_EYE_HEIGHT, 1.65) } mat4f_transpose(rotMat); /* orientation sensor rotates camera, not world */ // viewmatrix = offsetMat * rotMat * posMat * initposmat mat4f_mult_mat4f_new(viewmatrix, offsetMat, rotMat); // offset is identity if we are using Oculus tracker mat4f_mult_mat4f_new(viewmatrix, viewmatrix, posMat); mat4f_mult_mat4f_new(viewmatrix, viewmatrix, initPosMat); if(0) { printf("ViewportID=%d; eye=%s\n", viewportID, eye == ovrEye_Left ? "left" : "right"); printf("Eye offset according to OVR (only used if VRPN is used): "); mat4f_print(offsetMat); printf("Rotation sensing (from OVR or VRPN): "); mat4f_print(rotMat); printf("Position tracking (from OVR or VRPN): "); mat4f_print(posMat); printf("Initial position (from set in viewmat_init()): "); mat4f_print(initPosMat); printf("Final view matrix: "); mat4f_print(viewmatrix); } #else /* We shouldn't ever get here, but we'll generate a generic view * and projection matrix just in case... */ mat4f_lookat_new(viewmatrix, 0,1.55,0, 0,1.55,-1, 0,1,0); mat4f_perspective_new(projmatrix, 50, 1, 0.5, 500); #endif }