bool OSVRHMDDescription::OSVRViewerFitsUnrealModel(OSVR_DisplayConfig displayConfig)
{
// if the display config hasn't started up, we can't tell yet
if (osvrClientCheckDisplayStartup(displayConfig) == OSVR_RETURN_FAILURE)
{
UE_LOG(OSVRHMDDescriptionLog, Warning, TEXT("osvrClientCheckDisplayStartup call failed. Perhaps the HMD isn't connected?"));
return false;
}
OSVR_ReturnCode returnCode;
// must be only one display input
OSVR_DisplayInputCount numDisplayInputs;
returnCode = osvrClientGetNumDisplayInputs(displayConfig, &numDisplayInputs);
if (returnCode == OSVR_RETURN_FAILURE || numDisplayInputs != 1)
{
UE_LOG(OSVRHMDDescriptionLog, Warning, TEXT("osvrClientGetNumDisplayInputs call failed or number of display inputs not equal to 1"));
return false;
}
// must be only one viewer
OSVR_ViewerCount numViewers;
returnCode = osvrClientGetNumViewers(displayConfig, &numViewers);
if (returnCode == OSVR_RETURN_FAILURE || numViewers != 1)
{
UE_LOG(OSVRHMDDescriptionLog, Warning, TEXT("osvrClientGetNumViewers call failed or number of viewers not equal to 1"));
return false;
}
// the one viewer must have two eyes
OSVR_EyeCount numEyes;
returnCode = osvrClientGetNumEyesForViewer(displayConfig, 0, &numEyes);
if (returnCode == OSVR_RETURN_FAILURE || numEyes != 2)
{
UE_LOG(OSVRHMDDescriptionLog, Warning, TEXT("osvrClientGetNumEyesForViewer call failed or number of eyes not equal to 2"));
return false;
}
// each eye must have only one surface
// left eye
OSVR_ViewerCount numLeftEyeSurfaces, numRightEyeSurfaces;
returnCode = osvrClientGetNumSurfacesForViewerEye(displayConfig, 0, 0, &numLeftEyeSurfaces);
if (returnCode == OSVR_RETURN_FAILURE || numLeftEyeSurfaces != 1)
{
UE_LOG(OSVRHMDDescriptionLog, Warning, TEXT("osvrClientGetNumSurfacesForViewerEye call failed for the left eye, or number of surfaces not equal to 1"));
return false;
}
// right eye
returnCode = osvrClientGetNumSurfacesForViewerEye(displayConfig, 0, 1, &numRightEyeSurfaces);
if (returnCode == OSVR_RETURN_FAILURE || numRightEyeSurfaces != 1)
{
UE_LOG(OSVRHMDDescriptionLog, Warning, TEXT("osvrClientGetNumSurfacesForViewerEye call failed for the right eye, or number of surfaces not equal to 1"));
return false;
}
// I think we're good.
return true;
}
void QVRRenderContext::setOutputConf(QVROutputMode om)
{
_outputMode = om;
switch (om) {
case QVR_Output_Center:
_viewPasses = 1;
_eye[0] = QVR_Eye_Center;
break;
case QVR_Output_Left:
_viewPasses = 1;
_eye[0] = QVR_Eye_Left;
break;
case QVR_Output_Right:
_viewPasses = 1;
_eye[0] = QVR_Eye_Right;
break;
case QVR_Output_OSVR:
_viewPasses = 2;
_eye[0] = QVR_Eye_Left;
_eye[1] = QVR_Eye_Right;
#ifdef HAVE_OSVR
{
Q_ASSERT(QVROsvrDisplayConfig);
OSVR_EyeCount eyes;
osvrClientGetNumEyesForViewer(QVROsvrDisplayConfig, 0, &eyes);
if (eyes == 1) {
_viewPasses = 1;
_eye[0] = QVR_Eye_Center;
}
}
#endif
break;
case QVR_Output_Stereo_GL:
case QVR_Output_Stereo_Red_Cyan:
case QVR_Output_Stereo_Green_Magenta:
case QVR_Output_Stereo_Amber_Blue:
case QVR_Output_Stereo_Oculus:
case QVR_Output_Stereo_OpenVR:
case QVR_Output_Stereo_Custom:
_viewPasses = 2;
_eye[0] = QVR_Eye_Left;
_eye[1] = QVR_Eye_Right;
break;
}
}
void QVRDevice::update()
{
if (config().processIndex() == QVRManager::processIndex()) {
#ifdef HAVE_VRPN
if (_internals->vrpnTrackerRemote)
_internals->vrpnTrackerRemote->mainloop();
if (_internals->vrpnButtonRemote)
_internals->vrpnButtonRemote->mainloop();
if (_internals->vrpnAnalogRemote)
_internals->vrpnAnalogRemote->mainloop();
#endif
#ifdef HAVE_OCULUS
if (_internals->oculusTrackedEye >= 0) {
const ovrPosef* p;
if (_internals->oculusTrackedEye == 1)
p = &(QVROculusRenderPoses[0]);
else if (_internals->oculusTrackedEye == 2)
p = &(QVROculusRenderPoses[1]);
else
p = &(QVROculusTrackingState.HeadPose.ThePose);
// Note the position Y offset that moves the sitting user's eyes to a default standing height in
// the virtual world.
_position = QVector3D(p->Position.x, p->Position.y + QVRObserverConfig::defaultEyeHeight, p->Position.z);
_orientation = QQuaternion(p->Orientation.w, p->Orientation.x, p->Orientation.y, p->Orientation.z);
}
#endif
#ifdef HAVE_OPENVR
if (_internals->openVrTrackedEntity >= 0) {
_orientation = QVROpenVRTrackedOrientations[_internals->openVrTrackedEntity];
_position = QVROpenVRTrackedPositions[_internals->openVrTrackedEntity];
}
if (_internals->openVrButtonsEntity >= 0) {
_buttons[0] = QVROpenVRControllerStates[_internals->openVrButtonsEntity].rAxis[0].y > +0.5f;
_buttons[1] = QVROpenVRControllerStates[_internals->openVrButtonsEntity].rAxis[0].y < -0.5f;
_buttons[2] = QVROpenVRControllerStates[_internals->openVrButtonsEntity].rAxis[0].x < -0.5f;
_buttons[3] = QVROpenVRControllerStates[_internals->openVrButtonsEntity].rAxis[0].x > +0.5f;
unsigned long buttonPressed = QVROpenVRControllerStates[_internals->openVrButtonsEntity].ulButtonPressed;
_buttons[4] = buttonPressed & vr::ButtonMaskFromId(vr::k_EButton_ApplicationMenu);
_buttons[5] = buttonPressed & vr::ButtonMaskFromId(vr::k_EButton_Grip);
}
if (_internals->openVrAnalogsEntity >= 0) {
_analogs[0] = QVROpenVRControllerStates[_internals->openVrAnalogsEntity].rAxis[0].y;
_analogs[1] = QVROpenVRControllerStates[_internals->openVrAnalogsEntity].rAxis[0].x;
_analogs[2] = QVROpenVRControllerStates[_internals->openVrAnalogsEntity].rAxis[1].x;
}
#endif
#ifdef HAVE_OSVR
if (_internals->osvrTrackedEye != -1 || _internals->osvrTrackingInterface) {
OSVR_Pose3 pose;
bool ok;
if (_internals->osvrTrackedEye == 0) { // center eye
ok = (osvrClientGetViewerPose(QVROsvrDisplayConfig, 0, &pose) == OSVR_RETURN_SUCCESS);
} else if (_internals->osvrTrackedEye == 1) { // left eye
ok = (osvrClientGetViewerEyePose(QVROsvrDisplayConfig, 0, 0, &pose) == OSVR_RETURN_SUCCESS);
} else if (_internals->osvrTrackedEye == 2) { // right eye
OSVR_EyeCount eyes;
osvrClientGetNumEyesForViewer(QVROsvrDisplayConfig, 0, &eyes);
int e = (eyes == 2 ? 1 : 0);
ok = (osvrClientGetViewerEyePose(QVROsvrDisplayConfig, 0, e, &pose) == OSVR_RETURN_SUCCESS);
} else { // _internals->osvrTrackingInterface
struct OSVR_TimeValue timestamp;
ok = (osvrGetPoseState(_internals->osvrTrackingInterface, ×tamp, &pose) == OSVR_RETURN_SUCCESS);
}
if (ok) {
if (_internals->osvrTrackedEye >= 0 && pose.translation.data[1] < 1.1f) {
// Assume the user wears a HMD and sits (i.e. no room-scale VR).
// In this case, we apply an offset to a default standing observer,
// just as we do for Oculus Rift.
pose.translation.data[1] += QVRObserverConfig::defaultEyeHeight;
}
_position = QVector3D(pose.translation.data[0], pose.translation.data[1],
pose.translation.data[2]);
_orientation = QQuaternion(pose.rotation.data[0], pose.rotation.data[1],
pose.rotation.data[2], pose.rotation.data[3]);
}
}
if (_internals->osvrButtonsInterfaces.length() > 0) {
OSVR_ButtonState state;
struct OSVR_TimeValue timestamp;
for (int i = 0; i < _buttons.length(); i++) {
if (_internals->osvrButtonsInterfaces[i]
&& osvrGetButtonState(_internals->osvrButtonsInterfaces[i],
×tamp, &state) == OSVR_RETURN_SUCCESS) {
_buttons[i] = state;
}
}
}
if (_internals->osvrAnalogsInterfaces.length() > 0) {
OSVR_AnalogState state;
struct OSVR_TimeValue timestamp;
for (int i = 0; i < _analogs.length(); i++) {
if (_internals->osvrAnalogsInterfaces[i]
&& osvrGetAnalogState(_internals->osvrAnalogsInterfaces[i],
×tamp, &state) == OSVR_RETURN_SUCCESS) {
_analogs[i] = state;
}
}
}
#endif
}
}
