void render()
{
// Clear
oRenderer->clear(Color::Black);
// Begin a batch
oSpriteBatch->begin();
drawController(0, Vector2(OScreenWf * .3f, OScreenHf * .3f));
drawController(1, Vector2(OScreenWf * .7f, OScreenHf * .3f));
drawController(2, Vector2(OScreenWf * .3f, OScreenHf * .7f));
drawController(3, Vector2(OScreenWf * .7f, OScreenHf * .7f));
// End and flush the batch
oSpriteBatch->end();
}
void AppStage_TestRumble::render()
{
const float modelScale = 18.f;
glm::mat4 scaleAndRotateModelX90 =
glm::rotate(
glm::scale(glm::mat4(1.f), glm::vec3(modelScale, modelScale, modelScale)),
90.f, glm::vec3(1.f, 0.f, 0.f));
switch (m_menuState)
{
case eMenuState::waitingForStreamStartResponse:
{
} break;
case eMenuState::failedStreamStart:
{
} break;
case eMenuState::idle:
{
float bigRumbleAmount = get_big_rumble_amount();
float smallRumbleAmount = get_small_rumble_amount();
// Draw the psmove model in the middle
const float red= fmaxf(bigRumbleAmount, smallRumbleAmount);
drawController(m_controllerView, scaleAndRotateModelX90, glm::vec3(red, 0.f, 0.f));
} 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::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_GyroscopeCalibration::render()
{
const float bigModelScale = 10.f;
glm::mat4 scaleAndRotateModelX90=
glm::rotate(
glm::scale(glm::mat4(1.f), glm::vec3(bigModelScale, bigModelScale, bigModelScale)),
90.f, glm::vec3(1.f, 0.f, 0.f));
switch (m_menuState)
{
case eCalibrationMenuState::pendingTrackingSpaceSettings:
case eCalibrationMenuState::waitingForStreamStartResponse:
case eCalibrationMenuState::failedStreamStart:
case eCalibrationMenuState::failedTrackingSpaceSettings:
{
} break;
case eCalibrationMenuState::waitForStable:
{
drawController(m_controllerView, scaleAndRotateModelX90);
// Draw the current direction of gravity
{
const float renderScale = 200.f;
glm::mat4 renderScaleMatrix =
glm::scale(glm::mat4(1.f), glm::vec3(renderScale, renderScale, renderScale));
glm::vec3 g= -psm_vector3f_to_glm_vec3(m_lastCalibratedAccelerometer);
drawArrow(
renderScaleMatrix,
glm::vec3(), g,
0.1f,
glm::vec3(0.f, 1.f, 0.f));
drawTextAtWorldPosition(renderScaleMatrix, g, "G");
}
} break;
case eCalibrationMenuState::measureBiasAndDrift:
{
drawController(m_controllerView, scaleAndRotateModelX90);
} break;
case eCalibrationMenuState::measureComplete:
{
drawController(m_controllerView, scaleAndRotateModelX90);
} break;
case eCalibrationMenuState::test:
{
// Get the orientation of the controller in world space (OpenGL Coordinate System)
PSMQuatf controllerQuat;
if (PSM_GetControllerOrientation(m_controllerView->ControllerID, &controllerQuat) == PSMResult_Success)
{
glm::quat q= psm_quatf_to_glm_quat(controllerQuat);
glm::mat4 worldSpaceOrientation= glm::mat4_cast(q);
glm::mat4 worldTransform = glm::scale(worldSpaceOrientation, glm::vec3(1.f));
drawController(m_controllerView, worldTransform);
drawTransformedAxes(worldSpaceOrientation, 200.f);
drawTransformedAxes(glm::mat4(1.f), 200.f);
}
} break;
default:
assert(0 && "unreachable");
}
}
