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"); } }