glm::mat4
psmove_pose_to_glm_mat4(const PSMovePose &pose)
{
return psmove_pose_to_glm_mat4(pose.Orientation, pose.Position);
}
void AppStage_ComputeTrackerPoses::render()
{
switch (m_menuState)
{
case eMenuState::inactive:
break;
case eMenuState::pendingControllerListRequest:
case eMenuState::pendingControllerStartRequest:
case eMenuState::pendingTrackerListRequest:
case eMenuState::pendingTrackerStartRequest:
break;
case eMenuState::failedControllerListRequest:
case eMenuState::failedControllerStartRequest:
case eMenuState::failedTrackerListRequest:
case eMenuState::failedTrackerStartRequest:
break;
case eMenuState::verifyTrackers:
{
render_tracker_video();
} break;
case eMenuState::calibrateWithMat:
m_pCalibrateWithMat->render();
break;
case eMenuState::testTracking:
{
// Draw the chaperone origin axes
drawTransformedAxes(glm::mat4(1.0f), 100.f);
// Draw the frustum for each tracking camera.
// The frustums are defined in PSMove tracking space.
// We need to transform them into chaperone space to display them along side the HMD.
for (t_tracker_state_map_iterator tracker_iter = m_trackerViews.begin(); tracker_iter != m_trackerViews.end(); ++tracker_iter)
{
const ClientTrackerView *trackerView = tracker_iter->second.trackerView;
const PSMovePose trackerPose = trackerView->getTrackerPose();
const glm::mat4 trackerMat4 = psmove_pose_to_glm_mat4(trackerPose);
PSMoveFrustum frustum = trackerView->getTrackerFrustum();
// use color depending on tracking status
glm::vec3 color= does_tracker_see_any_controller(trackerView) ? k_psmove_frustum_color : k_psmove_frustum_color_no_track;
drawTextAtWorldPosition(glm::mat4(1.f), psmove_position_to_glm_vec3(trackerPose.Position), "#%d", trackerView->getTrackerId());
drawTransformedFrustum(glm::mat4(1.f), &frustum, color);
drawTransformedAxes(trackerMat4, 20.f);
}
// Draw the psmove model
for (t_controller_state_map_iterator controller_iter = m_controllerViews.begin(); controller_iter != m_controllerViews.end(); ++controller_iter)
{
const ClientControllerView *controllerView = controller_iter->second.controllerView;
const PSMoveTrackingColorType trackingColorType= controller_iter->second.trackingColorType;
PSMovePose controllerPose = controllerView->GetPose();
glm::mat4 controllerMat4 = psmove_pose_to_glm_mat4(controllerPose);
if (m_controllerViews.size() > 1)
{
drawTextAtWorldPosition(glm::mat4(1.f), psmove_position_to_glm_vec3(controllerPose.Position), "#%d", controllerView->GetControllerID());
}
drawController(controllerView, controllerMat4, trackingColorType);
drawTransformedAxes(controllerMat4, 10.f);
// Draw the acceleration and velocity arrows
{
const PSMovePhysicsData &physicsData = controllerView->GetPhysicsData();
const glm::mat4 originMat4= glm::translate(glm::mat4(1.f), psmove_position_to_glm_vec3(controllerPose.Position));
const glm::vec3 vel_endpoint = psmove_float_vector3_to_glm_vec3(physicsData.VelocityCmPerSec);
const glm::vec3 acc_endpoint = psmove_float_vector3_to_glm_vec3(physicsData.AccelerationCmPerSecSqr)*k_centimeters_to_meters;
const float vel= glm::length(vel_endpoint);
if (vel > k_positional_epsilon)
{
drawArrow(originMat4, glm::vec3(0.f), vel_endpoint, 0.1f, glm::vec3(0.f, 1.f, 1.f));
//drawTextAtWorldPosition(originMat4, vel_endpoint, "v=%.2fcm/s", vel);
}
const float acc = glm::length(acc_endpoint);
if (acc > k_positional_epsilon)
{
drawArrow(originMat4, glm::vec3(0.f), acc_endpoint, 0.1f, glm::vec3(1.f, 1.f, 0.f));
//drawTextAtWorldPosition(originMat4, acc_endpoint, "a=%.2fm/s^2", acc);
}
}
}
} break;
case eMenuState::showTrackerVideo:
{
render_tracker_video();
} break;
case eMenuState::calibrateStepFailed:
break;
default:
assert(0 && "unreachable");
}
}
void AppStage_ComputeTrackerPoses::render()
{
switch (m_menuState)
{
case eMenuState::inactive:
break;
case eMenuState::pendingControllerListRequest:
case eMenuState::pendingControllerStartRequest:
case eMenuState::pendingTrackerListRequest:
case eMenuState::pendingTrackerStartRequest:
break;
case eMenuState::failedControllerListRequest:
case eMenuState::failedControllerStartRequest:
case eMenuState::failedTrackerListRequest:
case eMenuState::failedTrackerStartRequest:
break;
case eMenuState::verifyHMD:
{
if (m_hmdView != nullptr)
{
PSMovePose pose = m_hmdView->getDisplayHmdPose();
glm::quat orientation(pose.Orientation.w, pose.Orientation.x, pose.Orientation.y, pose.Orientation.z);
glm::vec3 position(pose.Position.x, pose.Position.y, pose.Position.z);
glm::mat4 rot = glm::mat4_cast(orientation);
glm::mat4 trans = glm::translate(glm::mat4(1.0f), position);
glm::mat4 transform = trans * rot;
drawDK2Model(transform);
drawTransformedAxes(transform, 10.f);
}
{
PSMoveVolume volume;
if (m_app->getOpenVRContext()->getHMDTrackingVolume(volume))
{
drawTransformedVolume(glm::mat4(1.f), &volume, glm::vec3(0.f, 1.f, 1.f));
}
}
} break;
case eMenuState::verifyTrackers:
{
render_tracker_video();
} break;
case eMenuState::selectCalibrationType:
break;
case eMenuState::calibrateWithHMD:
m_pCalibrateWithHMD->render();
break;
case eMenuState::calibrateWithMat:
m_pCalibrateWithMat->render();
break;
case eMenuState::testTracking:
{
// Draw the origin axes
drawTransformedAxes(glm::mat4(1.0f), 100.f);
// Draw the HMD and tracking volume
if (m_hmdView != nullptr)
{
// Compute a transform that goes from HMD tracking space to PSMove tracking space
PSMovePose hmd_pose_at_origin = m_app->getOpenVRContext()->getHMDPoseAtPSMoveTrackingSpaceOrigin();
glm::mat4 tracking_space_transform = psmove_pose_to_glm_mat4(hmd_pose_at_origin);
glm::mat4 tracking_space_inv_transform = glm::inverse(tracking_space_transform);
// Put the HMD transform in PSMove tracking space
PSMovePose hmd_pose = m_hmdView->getDisplayHmdPose();
glm::mat4 hmd_transform = tracking_space_inv_transform * psmove_pose_to_glm_mat4(hmd_pose);
drawDK2Model(hmd_transform);
drawTransformedAxes(hmd_transform, 10.f);
PSMoveVolume volume;
if (m_app->getOpenVRContext()->getHMDTrackingVolume(volume))
{
drawTransformedVolume(tracking_space_inv_transform, &volume, glm::vec3(0.f, 1.f, 1.f));
}
}
// Draw the frustum for each tracking camera
for (t_tracker_state_map_iterator iter = m_trackerViews.begin(); iter != m_trackerViews.end(); ++iter)
{
const ClientTrackerView *trackerView = iter->second.trackerView;
{
PSMoveFrustum frustum = trackerView->getTrackerFrustum();
drawFrustum(&frustum, k_psmove_frustum_color);
}
{
PSMovePose pose = trackerView->getTrackerPose();
glm::mat4 cameraTransform = psmove_pose_to_glm_mat4(pose);
drawTransformedAxes(cameraTransform, 20.f);
}
}
// Draw the psmove model
{
PSMovePose pose = m_controllerView->GetPSMoveView().GetPose();
glm::mat4 worldTransform = psmove_pose_to_glm_mat4(pose);
drawPSMoveModel(worldTransform, glm::vec3(1.f, 1.f, 1.f));
drawTransformedAxes(worldTransform, 10.f);
}
} break;
case eMenuState::calibrateStepFailed:
break;
default:
assert(0 && "unreachable");
}
}
