void OgreWidget::mouseReleaseEvent(QMouseEvent * e)
{
if (e->button() == Qt::MiddleButton || e->button() == Qt::LeftButton)
{
m_mouseButtonsPressed &= e->buttons();
m_oldPos = QPoint(InvalidMousePoint);
if (m_snapeToGrid)
{
Ogre::Vector3 pos = m_selectionManager.getPosition();
int gridSpace = DataManager::getSingleton()->getGridSpace();
pos.x = qFloor((pos.x + gridSpace / 2.f) / gridSpace) * gridSpace;
pos.y = qFloor((pos.y + gridSpace / 2.f) / gridSpace) * gridSpace;
pos.z = qFloor((pos.z + gridSpace / 2.f) / gridSpace) * gridSpace;
m_selectionManager.setPosition(pos.x, pos.y, pos.z);
emit itemMoved();
}
if (m_snapeToAngle)
{
Ogre::Quaternion orientation = m_selectionManager.getOrientation();
int snapAngle = DataManager::getSingleton()->getSnapAngle();
if (m_constraintedX)
{
m_selectionManager.pitch(-orientation.getPitch());
m_selectionManager.pitch(Ogre::Degree(qFloor((orientation.getPitch().valueDegrees() + snapAngle / 2.f) / snapAngle) * snapAngle));
}
else if (m_constraintedY)
{
m_selectionManager.yaw(-orientation.getYaw());
m_selectionManager.yaw(Ogre::Degree(qFloor((orientation.getYaw().valueDegrees() + snapAngle / 2.f) / snapAngle) * snapAngle));
}
else if (m_constraintedZ)
{
m_selectionManager.roll(-orientation.getRoll());
m_selectionManager.roll(Ogre::Degree(qFloor((orientation.getRoll().valueDegrees() + snapAngle / 2.f) / snapAngle) * snapAngle));
}
emit itemMoved();
}
update();
e->accept();
}
else
{
e->ignore();
}
}
void EnemyController::approach(void)
{
EnemyPlane* enemy = static_cast<EnemyPlane*>(IDManager::getPointer(_enemyName, ACTOR));
Ogre::Vector3 temp = FCKnowledge::getSingleton().getPlayerPosition() - enemy->getPosition();
Ogre::Vector3 direction = temp * enemy->getAxis();
//std::cout<<direction.x<<" "<<direction.y<<" "<<direction.z<<std::endl;
if(direction.angleBetween(Ogre::Vector3::NEGATIVE_UNIT_Z) >= Ogre::Radian(Ogre::Degree(1)))
{
Ogre::Quaternion test = direction.getRotationTo(Ogre::Vector3::NEGATIVE_UNIT_Z);
Ogre::Degree angle = enemy->getRotateLimit();
double yawNum = test.getYaw().valueDegrees()/(angle*WORLD_UPDATE_INTERVAL).valueDegrees();
yawNum = Ogre::Math::Clamp(yawNum, -1.0, 1.0);
enemy->yaw(yawNum);
double pitchNum = test.getPitch().valueDegrees()/(angle*WORLD_UPDATE_INTERVAL).valueDegrees();
pitchNum = Ogre::Math::Clamp(pitchNum, -1.0, 1.0);
enemy->pitch(pitchNum);
double rollNum = test.getRoll().valueDegrees()/(angle*WORLD_UPDATE_INTERVAL).valueDegrees();
rollNum = Ogre::Math::Clamp(rollNum, -1.0, 1.0);
enemy->roll(rollNum);
}
else
{
enemy->yaw(0);
enemy->pitch(0);
enemy->roll(0);
}
}
void PhysicsSystem::doPhysics(float dt, const std::vector<std::pair<std::string, Ogre::Vector3> >& actors)
{
//set the DebugRenderingMode. To disable it,set it to 0
//eng->setDebugRenderingMode(1);
//set the walkdirection to 0 (no movement) for every actor)
for(std::map<std::string,OEngine::Physic::PhysicActor*>::iterator it = mEngine->PhysicActorMap.begin(); it != mEngine->PhysicActorMap.end();it++)
{
OEngine::Physic::PhysicActor* act = it->second;
act->setWalkDirection(btVector3(0,0,0));
}
playerMove::playercmd& pm_ref = playerphysics->cmd;
pm_ref.rightmove = 0;
pm_ref.forwardmove = 0;
pm_ref.upmove = 0;
//playerphysics->ps.move_type = PM_NOCLIP;
for (std::vector<std::pair<std::string, Ogre::Vector3> >::const_iterator iter (actors.begin());
iter!=actors.end(); ++iter)
{
//dirty stuff to get the camera orientation. Must be changed!
Ogre::SceneNode *sceneNode = mRender.getScene()->getSceneNode (iter->first);
Ogre::Vector3 dir;
Ogre::Node* yawNode = sceneNode->getChildIterator().getNext();
Ogre::Node* pitchNode = yawNode->getChildIterator().getNext();
Ogre::Quaternion yawQuat = yawNode->getOrientation();
Ogre::Quaternion pitchQuat = pitchNode->getOrientation();
playerphysics->ps.viewangles.x = pitchQuat.getPitch().valueDegrees();
playerphysics->ps.viewangles.y = yawQuat.getYaw().valueDegrees() *-1 + 90;
Ogre::Quaternion quat = yawNode->getOrientation();
Ogre::Vector3 dir1(iter->second.x,iter->second.z,-iter->second.y);
pm_ref.rightmove = -iter->second.x;
pm_ref.forwardmove = -iter->second.y;
pm_ref.upmove = iter->second.z;
}
mEngine->stepSimulation(dt);
}
void Application::updateLogic( const float elapsedSeconds )
{
const float TURN_DEGREES_PER_SECOND = 360;
const float MOVEMENT_UNITS_PER_SECOND = 4;
m_movingDirection = 0;
if ( m_keyboard->isKeyDown( OIS::KC_LEFT ) )
{
m_sceneNode->yaw( Ogre::Degree( -TURN_DEGREES_PER_SECOND * elapsedSeconds ) );
Ogre::Quaternion nodeOri = m_sceneNode->getOrientation();
m_cameraController->addOrientation(nodeOri.getYaw().valueDegrees(), nodeOri.getPitch().valueDegrees());
}
if ( m_keyboard->isKeyDown( OIS::KC_RIGHT ) )
{
m_sceneNode->yaw( Ogre::Degree( -TURN_DEGREES_PER_SECOND * elapsedSeconds ) );
Ogre::Quaternion nodeOri = m_sceneNode->getOrientation();
m_cameraController->addOrientation(nodeOri.getYaw().valueDegrees(), nodeOri.getPitch().valueDegrees());
}
if ( m_keyboard->isKeyDown( OIS::KC_UP ) )
{
m_sceneNode->translate( Ogre::Vector3::UNIT_Z * MOVEMENT_UNITS_PER_SECOND * elapsedSeconds, Ogre::Node::TS_LOCAL );
m_movingDirection++;
Ogre::Vector3 nodePos = m_sceneNode->getPosition();
m_cameraController->setLookAtPosition(nodePos.x, nodePos.y, nodePos.z);
}
if ( m_keyboard->isKeyDown( OIS::KC_DOWN ) )
{
m_sceneNode->translate( Ogre::Vector3::NEGATIVE_UNIT_Z * MOVEMENT_UNITS_PER_SECOND * elapsedSeconds, Ogre::Node::TS_LOCAL );
m_movingDirection--;
Ogre::Vector3 nodePos = m_sceneNode->getPosition();
m_cameraController->setLookAtPosition(nodePos.x, nodePos.y, nodePos.z);
}
}
void CameraManager::setOrientation(Ogre::Quaternion ori){
mNodeYaw = ori.getYaw();
mNodePitch = ori.getPitch();
mNodeRoll = ori.getRoll();
if(mCameraMode == OCULUS)
mOculusCamera->setOrientation(ori);
else
mSimpleCamera->setOrientation(ori);
}
void Application::updateStats()
{
static Ogre::String currFps = "Current FPS: ";
static Ogre::String avgFps = "Average FPS: ";
static Ogre::String bestFps = "Best FPS: ";
static Ogre::String worstFps = "Worst FPS: ";
static Ogre::String tris = "Triangle Count: ";
static Ogre::String batches = "Batch Count: ";
// update stats when necessary
try {
Ogre::OverlayElement* guiAvg = Ogre::OverlayManager::getSingleton().getOverlayElement("Core/AverageFps");
Ogre::OverlayElement* guiCurr = Ogre::OverlayManager::getSingleton().getOverlayElement("Core/CurrFps");
Ogre::OverlayElement* guiBest = Ogre::OverlayManager::getSingleton().getOverlayElement("Core/BestFps");
Ogre::OverlayElement* guiWorst = Ogre::OverlayManager::getSingleton().getOverlayElement("Core/WorstFps");
const Ogre::RenderTarget::FrameStats& stats = m_window->getStatistics();
guiAvg->setCaption(avgFps + Ogre::StringConverter::toString(stats.avgFPS));
guiCurr->setCaption(currFps + Ogre::StringConverter::toString(stats.lastFPS));
guiBest->setCaption(bestFps + Ogre::StringConverter::toString(stats.bestFPS)
+" "+Ogre::StringConverter::toString(stats.bestFrameTime)+" ms");
guiWorst->setCaption(worstFps + Ogre::StringConverter::toString(stats.worstFPS)
+" "+Ogre::StringConverter::toString(stats.worstFrameTime)+" ms");
Ogre::OverlayElement* guiTris = Ogre::OverlayManager::getSingleton().getOverlayElement("Core/NumTris");
guiTris->setCaption(tris + Ogre::StringConverter::toString(stats.triangleCount));
Ogre::OverlayElement* guiBatches = Ogre::OverlayManager::getSingleton().getOverlayElement("Core/NumBatches");
guiBatches->setCaption(batches + Ogre::StringConverter::toString(stats.batchCount));
/////////////////////////
Ogre::Vector3 camPos = m_camera->getPosition();
Ogre::Quaternion camOri = m_camera->getOrientation();
Ogre::Vector3 freddyPos = m_sceneNode->getPosition();
Ogre::Quaternion freddyOri = m_sceneNode->getOrientation();
Ogre::OverlayElement* guiDbg = Ogre::OverlayManager::getSingleton().getOverlayElement("Core/DebugText");
guiDbg->setTop(0);
Ogre::String message =
"Camera Position: x: "+Ogre::StringConverter::toString(camPos.x)+", y: "+Ogre::StringConverter::toString(camPos.y)+", z:"+Ogre::StringConverter::toString(camPos.z) + "\n" +
"Camera orientation: yaw: "+Ogre::StringConverter::toString(camOri.getYaw())+", pitch: "+Ogre::StringConverter::toString(camOri.getPitch())+", roll:"+Ogre::StringConverter::toString(camOri.getRoll()) + "\n" +
"Freddy position: x: "+Ogre::StringConverter::toString(freddyPos.x)+", y: "+Ogre::StringConverter::toString(freddyPos.y)+", z:"+Ogre::StringConverter::toString(freddyPos.z) + "\n" +
"Freddy orientation: yaw: "+Ogre::StringConverter::toString(freddyOri.getYaw())+", pitch: "+Ogre::StringConverter::toString(freddyOri.getPitch())+", roll:"+Ogre::StringConverter::toString(freddyOri.getRoll());
guiDbg->setCaption(message);
debugWindow->setText("This is a demo!");
}
catch(...) { /* ignore */ }
}
/**
* @brief Returns the rotation Vector
*
* @param mode
*/
Vector Transform::getRotation ()
{
Ogre::Quaternion rot = m_4x4.extractQuaternion();
return Vector( rot.getYaw().valueRadians(), rot.getPitch().valueRadians(), rot.getRoll().valueRadians() );
}
void
CovarianceVisual::setMessage
(const geometry_msgs::PoseWithCovariance& msg)
{
// Construct pose position and orientation.
const geometry_msgs::Point& p = msg.pose.position;
Ogre::Vector3 position (p.x, p.y, p.z);
Ogre::Quaternion orientation
(msg.pose.orientation.w,
msg.pose.orientation.x,
msg.pose.orientation.y,
msg.pose.orientation.z);
// Set position and orientation for axes scene node.
if(!position.isNaN())
axes_->setPosition (position);
else
ROS_WARN_STREAM_THROTTLE(1, "position contains NaN: " << position);
if(!orientation.isNaN())
axes_->setOrientation (orientation);
else
ROS_WARN_STREAM_THROTTLE(1, "orientation contains NaN: " << orientation);
// check for NaN in covariance
for (unsigned i = 0; i < 3; ++i) {
if(isnan(msg.covariance[i])) {
ROS_WARN_THROTTLE(1, "covariance contains NaN");
return;
}
}
// Compute eigen values and vectors for both shapes.
std::pair<Eigen::Matrix3d, Eigen::Vector3d>
positionEigenVectorsAndValues
(computeEigenValuesAndVectors (msg, 0));
std::pair<Eigen::Matrix3d, Eigen::Vector3d>
orientationEigenVectorsAndValues
(computeEigenValuesAndVectors (msg, 3));
Ogre::Quaternion positionQuaternion
(computeRotation (msg, positionEigenVectorsAndValues));
Ogre::Quaternion orientationQuaternion
(computeRotation (msg, orientationEigenVectorsAndValues));
positionNode_->setOrientation (positionQuaternion);
orientationNode_->setOrientation (orientationQuaternion);
// Compute scaling.
Ogre::Vector3 positionScaling
(std::sqrt (positionEigenVectorsAndValues.second[0]),
std::sqrt (positionEigenVectorsAndValues.second[1]),
std::sqrt (positionEigenVectorsAndValues.second[2]));
positionScaling *= scaleFactor_;
Ogre::Vector3 orientationScaling
(std::sqrt (orientationEigenVectorsAndValues.second[0]),
std::sqrt (orientationEigenVectorsAndValues.second[1]),
std::sqrt (orientationEigenVectorsAndValues.second[2]));
orientationScaling *= scaleFactor_;
// Set the scaling.
if(!positionScaling.isNaN())
positionNode_->setScale (positionScaling);
else
ROS_WARN_STREAM("positionScaling contains NaN: " << positionScaling);
if(!orientationScaling.isNaN())
orientationNode_->setScale (orientationScaling);
else
ROS_WARN_STREAM("orientationScaling contains NaN: " << orientationScaling);
// Debugging.
ROS_DEBUG_STREAM_THROTTLE
(1.,
"Position:\n"
<< position << "\n"
<< "Positional part 3x3 eigen values:\n"
<< positionEigenVectorsAndValues.second << "\n"
<< "Positional part 3x3 eigen vectors:\n"
<< positionEigenVectorsAndValues.first << "\n"
<< "Sphere orientation:\n"
<< positionQuaternion << "\n"
<< positionQuaternion.getRoll () << " "
<< positionQuaternion.getPitch () << " "
<< positionQuaternion.getYaw () << "\n"
<< "Sphere scaling:\n"
<< positionScaling << "\n"
<< "Rotational part 3x3 eigen values:\n"
<< orientationEigenVectorsAndValues.second << "\n"
<< "Rotational part 3x3 eigen vectors:\n"
<< orientationEigenVectorsAndValues.first << "\n"
<< "Cone orientation:\n"
<< orientationQuaternion << "\n"
<< orientationQuaternion.getRoll () << " "
<< orientationQuaternion.getPitch () << " "
<< orientationQuaternion.getYaw () << "\n"
<< "Cone scaling:\n"
<< orientationScaling
);
}
bool LapTrainer::frameRenderingQueued(const Ogre::FrameEvent& evt)
{
//Static variables
static bool mMouseDown = false; // If a mouse button is depressed
static Ogre::Real mRotate = 0.13; // The rotate constant
static Ogre::Real mMove = 250; // The movement constant
bool currMouse = mMouse->getMouseState().buttonDown(OIS::MB_Left);
bool ret = OGREBase::frameRenderingQueued(evt);
//Declare variables
static int mYawL = 0;
static int mPitchL = 0;
static int mRotL = 0;
static int mInsL = 0;
//
static int mYawR = 0;
static int mPitchR = 0;
static int mRotR = 0;
static int mInsR = 0;
//
static int mYawC = 0;
static int mPitchC = 0;
static int mRotC = 0;
static int mInsC = 0;
if (!mNoSimballConnected) //Check if connected otherwise ignore
{
//--------------------------------Get Simballs values--------------------------------------------
//Load data symbols
simball_Left.ReadSimBallState(simball.handle[1]);
simball_Right.ReadSimBallState(simball.handle[2]);
simball_camera.ReadSimBallState(simball.handle[3]);
//-------------------Left Stick-----------------------------------------------------------------
//Yaw
int YawCurrentL = simball_Left.AYaw;
//Calculate yaw difference
if (YawCurrentL != mYawL){
mSceneMgr->getSceneNode("RightNode")->yaw(Ogre::Degree(YawCurrentL - mYawL));
mYawL = YawCurrentL;
}
//Pitch
int PitchCurrentL = simball_Left.APitch;
//Calculate pitch difference
if (PitchCurrentL != mPitchL){
mSceneMgr->getSceneNode("RightNode")->roll(Ogre::Degree(PitchCurrentL - mPitchL));
mPitchL = PitchCurrentL;
}
//Roll
int RotCurrentL = simball_Left.ARotation;
//Calculate rotation difference
if (RotCurrentL != mRotL){
mSceneMgr->getSceneNode("RightNode")->pitch(Ogre::Degree(RotCurrentL - mRotL));
mRotL = RotCurrentL;
}
//Insertion
Ogre::Vector3 transVectorSbL = Ogre::Vector3::ZERO;
int InsCurrentL = (simball_Left.AInsertion-228)*1;
//Calculate rotation difference
if (InsCurrentL != mInsL){
transVectorSbL.x = (InsCurrentL - mInsL);
mSceneMgr->getSceneNode("MoveNodeRight")->translate(transVectorSbL, Ogre::Node::TS_LOCAL);
mInsL = InsCurrentL;
}
//-------------------Right Stick-----------------------------------------------------------------
//Yaw
int YawCurrentR = simball_Right.AYaw;
//Calculate yaw difference
if (YawCurrentR != mYawR){
mSceneMgr->getSceneNode("LeftNode")->yaw(Ogre::Degree(YawCurrentR - mYawR));
mYawR = YawCurrentR;
}
//Pitch
int PitchCurrentR = simball_Right.APitch;
//Calculate pitch difference
if (PitchCurrentR != mPitchR){
mSceneMgr->getSceneNode("LeftNode")->roll(Ogre::Degree(PitchCurrentR - mPitchR));
mPitchR = PitchCurrentR;
}
//Roll
int RotCurrentR = (simball_Right.ARotation-228)*-2;
//Calculate rotation difference
if (RotCurrentR != mRotR){
mSceneMgr->getSceneNode("LeftNode")->pitch(Ogre::Degree(RotCurrentR - mRotR));
mRotR = RotCurrentR;
}
//Insertion
Ogre::Vector3 transVectorSbR = Ogre::Vector3::ZERO;
int InsCurrentR = (simball_Right.AInsertion-228)*1;
//Calculate rotation difference
if (InsCurrentR != mInsR){
transVectorSbR.x = (InsCurrentR - mInsR);
mSceneMgr->getSceneNode("MoveNodeLeft")->translate(transVectorSbR, Ogre::Node::TS_LOCAL);
mInsR = InsCurrentR;
}
//-------------------Camera Stick-----------------------------------------------------------------
//Fixed camera (comment next lines)
/*
//Must be uncommented if we want a moving camera
//Yaw
int YawCurrentC = simball_camera.AYaw;
if (YawCurrentC != mYawC){
mSceneMgr->getSceneNode("cameraNode")->yaw(Ogre::Degree((YawCurrentC - mYawC)));
mYawC = YawCurrentC;
}
//Pitch
int PitchCurrentC = simball_camera.APitch;
if (PitchCurrentC != mPitchC){
mSceneMgr->getSceneNode("cameraNode")->pitch(Ogre::Degree((PitchCurrentC - mPitchC)));
mPitchC = PitchCurrentC;
}
//Roll //It works but it moves like mirror sometimes. It doesn't work well
int RotCurrentC = (simball_camera.ARotation*-1)+179;
if (RotCurrentC != mRotC){
mSceneMgr->getSceneNode("cameraNode")->roll(Ogre::Degree((RotCurrentC - mRotC))*-1.00); //Changed to -1.0 instead of -0.09
mRotC = RotCurrentC;
}
//Insertion //It's not working, we don't know why
Ogre::Vector3 transVectorInsC = Ogre::Vector3::ZERO;
int InsCurrentC = (simball_camera.AInsertion-228)*-2;
if (InsCurrentC != mInsC){
transVectorInsC.z = (InsCurrentC - mInsC);
mSceneMgr->getSceneNode("cameraInsertion")->translate(transVectorInsC, Ogre::Node::TS_LOCAL);
mInsC = InsCurrentC;
}
*/
}
//-------------------Keyboard movements left node-----------------------------------------------------------------
//More information of the shorcuts of OIS: https://code.google.com/p/ezonas/source/browse/Ogrish/OIS-keycodes.txt?spec=svn92d08c346e48025efafc980557ee738ab0bd6ecd&r=92d08c346e48025efafc980557ee738ab0bd6ecd
Ogre::Vector3 transVectorLeft = Ogre::Vector3::ZERO;
Ogre::Vector3 transVectorInsertionLeft = Ogre::Vector3::ZERO;
if (mKeyboard->isKeyDown(OIS::KC_W)) // Forward
{
transVectorLeft.z -= mMove;
}
if (mKeyboard->isKeyDown(OIS::KC_S)) // Backward
{
if(mKeyboard->isKeyDown( OIS::KC_LSHIFT ))
{
// Pitch left
mSceneMgr->getSceneNode("LeftNode")->pitch(Ogre::Degree(mRotate * 5));
}
else if(mKeyboard->isKeyDown( OIS::KC_LMENU)) //Left alt
{
// Pitch right
mSceneMgr->getSceneNode("LeftNode")->pitch(Ogre::Degree(mRotate * -5));
}
else {
transVectorLeft.z += mMove;
}
}
if (mKeyboard->isKeyDown(OIS::KC_A)) // Left - or roll
{
if(mKeyboard->isKeyDown( OIS::KC_LSHIFT ))
{
// Roll left
mSceneMgr->getSceneNode("LeftNode")->roll(Ogre::Degree(mRotate * 5));
}
else if(mKeyboard->isKeyDown( OIS::KC_LMENU)) //Left alt
{
// Roll right
mSceneMgr->getSceneNode("LeftNode")->roll(Ogre::Degree(mRotate * -5));
}
else {
transVectorLeft.x -= mMove; // Strafe left
}
}
if (mKeyboard->isKeyDown(OIS::KC_D)) // Right - yaw or strafe
{
if(mKeyboard->isKeyDown( OIS::KC_LSHIFT ))
{
// Yaw left
mSceneMgr->getSceneNode("LeftNode")->yaw(Ogre::Degree(mRotate * 5));
}
else if(mKeyboard->isKeyDown( OIS::KC_LMENU)) //Left alt
{
// Yaw right
mSceneMgr->getSceneNode("LeftNode")->yaw(Ogre::Degree(mRotate * -5));
}
else {
transVectorLeft.x += mMove; // Strafe right
}
}
if (mKeyboard->isKeyDown(OIS::KC_Z)) // Up
{
transVectorLeft.y += mMove;
}
if (mKeyboard->isKeyDown(OIS::KC_X)) // Down
{
transVectorLeft.y -= mMove;
}
if (mKeyboard->isKeyDown(OIS::KC_Q)) // Change x point
{
transVectorInsertionLeft.x -= mMove;
}
if (mKeyboard->isKeyDown(OIS::KC_E)) // change x point
{
transVectorInsertionLeft.x += mMove;
}
// Translate the results to the scenenode
//Move node on x-axis for the insertion
mSceneMgr->getSceneNode("MoveNodeLeft")->translate(transVectorInsertionLeft * evt.timeSinceLastFrame, Ogre::Node::TS_LOCAL);
mSceneMgr->getSceneNode("LeftNode")->translate(transVectorLeft * evt.timeSinceLastFrame, Ogre::Node::TS_LOCAL);
//-------------------Keyboard movements right node-----------------------------------------------------------------
//Keyboard movements
Ogre::Vector3 transVectorRight = Ogre::Vector3::ZERO;
Ogre::Vector3 transVectorInsertionRight = Ogre::Vector3::ZERO;
if (mKeyboard->isKeyDown(OIS::KC_UP)) // Forward
{
transVectorRight.z -= mMove;
}
if (mKeyboard->isKeyDown(OIS::KC_DOWN)) // Backward
{
if(mKeyboard->isKeyDown( OIS::KC_LSHIFT ))
{
// Pitch left
mSceneMgr->getSceneNode("RightNode")->pitch(Ogre::Degree(mRotate * 5));
}
else if(mKeyboard->isKeyDown( OIS::KC_LMENU)) //Left alt
{
// Pitch right
mSceneMgr->getSceneNode("RightNode")->pitch(Ogre::Degree(mRotate * -5));
}
else {
transVectorRight.z += mMove;
}
}
if (mKeyboard->isKeyDown(OIS::KC_LEFT)) // Left - or roll
{
if(mKeyboard->isKeyDown( OIS::KC_LSHIFT ))
{
// Roll left
mSceneMgr->getSceneNode("RightNode")->roll(Ogre::Degree(mRotate * 5));
}
else if(mKeyboard->isKeyDown( OIS::KC_LMENU)) //Left alt
{
// Roll right
mSceneMgr->getSceneNode("RightNode")->roll(Ogre::Degree(mRotate * -5));
}
else {
transVectorRight.x -= mMove; // Strafe left
}
}
if (mKeyboard->isKeyDown(OIS::KC_RIGHT)) // Right - yaw or strafe
{
if(mKeyboard->isKeyDown( OIS::KC_LSHIFT ))
{
// Yaw left
mSceneMgr->getSceneNode("RightNode")->yaw(Ogre::Degree(mRotate * 5));
}
else if(mKeyboard->isKeyDown( OIS::KC_LMENU)) //Left alt
{
// Yaw right
mSceneMgr->getSceneNode("RightNode")->yaw(Ogre::Degree(mRotate * -5));
}
else {
transVectorRight.x += mMove; // Strafe right
}
}
if (mKeyboard->isKeyDown(OIS::KC_N)) // Up
{
transVectorRight.y += mMove;
}
if (mKeyboard->isKeyDown(OIS::KC_M)) // Down
{
transVectorRight.y -= mMove;
}
if (mKeyboard->isKeyDown(OIS::KC_K)) // Change x point
{
transVectorInsertionRight.x -= mMove;
}
if (mKeyboard->isKeyDown(OIS::KC_L)) // change x point
{
transVectorInsertionRight.x += mMove;
}
// Translate the results to the scenenode
//Move node on x-axis for the insertion
mSceneMgr->getSceneNode("MoveNodeRight")->translate(transVectorInsertionRight * evt.timeSinceLastFrame, Ogre::Node::TS_LOCAL);
mSceneMgr->getSceneNode("RightNode")->translate(transVectorRight * evt.timeSinceLastFrame, Ogre::Node::TS_LOCAL);
//-------------------Change sensibility -----------------------------------------------------------------
//Change sensibility of the keyboard
if (mKeyboard->isKeyDown(OIS::KC_1)) // Change speed
{
mMove = 50;
mRotate = 0.07;
}
if (mKeyboard->isKeyDown(OIS::KC_2)) // Change speed
{
mMove = 100;
mRotate = 0.10;
}
if (mKeyboard->isKeyDown(OIS::KC_3)) // Change speed
{
mMove = 250;
mRotate = 0.13;
}
//-------------------Move camera -----------------------------------------------------------------
Ogre::Vector3 transVectorInsertion = Ogre::Vector3::ZERO;
Ogre::Vector3 transVectorCamera = Ogre::Vector3::ZERO;
if (mKeyboard->isKeyDown(OIS::KC_Y)) // Pull back
{
transVectorInsertion.z -= mMove;
}
if (mKeyboard->isKeyDown(OIS::KC_U)) // Insert
{
transVectorInsertion.z += mMove;
}
if (mKeyboard->isKeyDown(OIS::KC_I)) // Roll
{
if (mKeyboard->isKeyDown(OIS::KC_LSHIFT))
{
mSceneMgr->getSceneNode("cameraNode")->roll(Ogre::Degree(mRotate * -5));
}
else
{
mSceneMgr->getSceneNode("cameraNode")->roll(Ogre::Degree(mRotate * 5));
}
}
if (mKeyboard->isKeyDown(OIS::KC_O)) // Pitch
{
if (mKeyboard->isKeyDown(OIS::KC_LSHIFT))
{
mSceneMgr->getSceneNode("cameraNode")->pitch(Ogre::Degree(mRotate * -5));
}
else
{
mSceneMgr->getSceneNode("cameraNode")->pitch(Ogre::Degree(mRotate * 5));
}
}
if (mKeyboard->isKeyDown(OIS::KC_P)) // Yaw
{
if (mKeyboard->isKeyDown(OIS::KC_LSHIFT))
{
mSceneMgr->getSceneNode("cameraNode")->yaw(Ogre::Degree(mRotate * -5));
}
else
{
mSceneMgr->getSceneNode("cameraNode")->yaw(Ogre::Degree(mRotate * 5));
}
}
if (mKeyboard->isKeyDown(OIS::KC_C)) // Left - or roll
{
if(mKeyboard->isKeyDown( OIS::KC_LSHIFT ))
{
transVectorCamera.x -= mMove;
}
else
{
transVectorCamera.x += mMove;
}
}
if (mKeyboard->isKeyDown(OIS::KC_V)) // Left - or roll
{
if(mKeyboard->isKeyDown( OIS::KC_LSHIFT ))
{
transVectorCamera.y -= mMove;
}
else
{
transVectorCamera.y += mMove;
}
}
if (mKeyboard->isKeyDown(OIS::KC_B)) // Left - or roll
{
if(mKeyboard->isKeyDown( OIS::KC_LSHIFT ))
{
transVectorCamera.z -= mMove;
}
else
{
transVectorCamera.z += mMove;
}
}
mSceneMgr->getSceneNode("cameraInsertion")->translate(transVectorInsertion * evt.timeSinceLastFrame, Ogre::Node::TS_LOCAL);
mSceneMgr->getSceneNode("cameraNode")->translate(transVectorCamera * evt.timeSinceLastFrame, Ogre::Node::TS_LOCAL);
//-------------------mTrayMgr -----------------------------------------------------------------
mTrayMgr->frameRenderingQueued(evt);
if (!mTrayMgr->isDialogVisible())
{
if (mDetailsPanel->isVisible())// If details panel is visible, then update its contents
{
if (mSelectedElement == 1)
{
Ogre::Quaternion Quat = mSceneMgr->getSceneNode("cameraNode")->getOrientation();
mDetailsPanel->setParamValue(0, "Camera");
mDetailsPanel->setParamValue(1, Ogre::StringConverter::toString(mSceneMgr->getSceneNode("cameraNode")->getPosition().x));
mDetailsPanel->setParamValue(2, Ogre::StringConverter::toString(mSceneMgr->getSceneNode("cameraNode")->getPosition().y));
mDetailsPanel->setParamValue(3, Ogre::StringConverter::toString(mSceneMgr->getSceneNode("cameraNode")->getPosition().z));
//Get scene node values
mDetailsPanel->setParamValue(6, Ogre::StringConverter::toString(Quat.getPitch()));
mDetailsPanel->setParamValue(9, Ogre::StringConverter::toString(Quat.getYaw()));
mDetailsPanel->setParamValue(12, Ogre::StringConverter::toString(Quat.getRoll()));
mDetailsPanel->setParamValue(15, Ogre::StringConverter::toString(mSceneMgr->getSceneNode("cameraInsertion")->getPosition().z));
//Get if possible symball values
if (!mNoSimballConnected)
{
mDetailsPanel->setParamValue(5, Ogre::StringConverter::toString(mPitchC));
mDetailsPanel->setParamValue(8, Ogre::StringConverter::toString(mRotC));
mDetailsPanel->setParamValue(11, Ogre::StringConverter::toString(mYawC));
mDetailsPanel->setParamValue(13, Ogre::StringConverter::toString(mInsC));;
}
}
if (mSelectedElement == 2)
{
Ogre::Quaternion Quat = mSceneMgr->getSceneNode("LeftNode")->getOrientation();
mDetailsPanel->setParamValue(0, "Stick left");
mDetailsPanel->setParamValue(1, Ogre::StringConverter::toString(mSceneMgr->getSceneNode("LeftNode")->getPosition().x));
mDetailsPanel->setParamValue(2, Ogre::StringConverter::toString(mSceneMgr->getSceneNode("LeftNode")->getPosition().y));
mDetailsPanel->setParamValue(3, Ogre::StringConverter::toString(mSceneMgr->getSceneNode("LeftNode")->getPosition().z));
//Get scene node values
mDetailsPanel->setParamValue(6, Ogre::StringConverter::toString(Quat.getPitch()));
mDetailsPanel->setParamValue(9, Ogre::StringConverter::toString(Quat.getYaw()));
mDetailsPanel->setParamValue(12, Ogre::StringConverter::toString(Quat.getRoll()));
mDetailsPanel->setParamValue(15, Ogre::StringConverter::toString(mSceneMgr->getSceneNode("MoveNodeLeft")->getPosition().x));
//Get if possible symball values
if (!mNoSimballConnected)
{
mDetailsPanel->setParamValue(5, Ogre::StringConverter::toString(mPitchR));
mDetailsPanel->setParamValue(8, Ogre::StringConverter::toString(mRotR));
mDetailsPanel->setParamValue(11, Ogre::StringConverter::toString(mYawR));
mDetailsPanel->setParamValue(13, Ogre::StringConverter::toString(mInsR));;
}
}
if (mSelectedElement == 3)
{
Ogre::Quaternion Quat = mSceneMgr->getSceneNode("RightNode")->getOrientation();
mDetailsPanel->setParamValue(0, "Stick right");
mDetailsPanel->setParamValue(1, Ogre::StringConverter::toString(mSceneMgr->getSceneNode("RightNode")->getPosition().x));
mDetailsPanel->setParamValue(2, Ogre::StringConverter::toString(mSceneMgr->getSceneNode("RightNode")->getPosition().y));
mDetailsPanel->setParamValue(3, Ogre::StringConverter::toString(mSceneMgr->getSceneNode("RightNode")->getPosition().z));
//Get scene node values
mDetailsPanel->setParamValue(6, Ogre::StringConverter::toString(Quat.getPitch()));
mDetailsPanel->setParamValue(9, Ogre::StringConverter::toString(Quat.getYaw()));
mDetailsPanel->setParamValue(12, Ogre::StringConverter::toString(Quat.getRoll()));
mDetailsPanel->setParamValue(15, Ogre::StringConverter::toString(mSceneMgr->getSceneNode("MoveNodeRight")->getPosition().x));
//Get if possible symball values
if (!mNoSimballConnected)
{
mDetailsPanel->setParamValue(5, Ogre::StringConverter::toString(mPitchL));
mDetailsPanel->setParamValue(8, Ogre::StringConverter::toString(mRotL));
mDetailsPanel->setParamValue(11, Ogre::StringConverter::toString(mYawL));
mDetailsPanel->setParamValue(13, Ogre::StringConverter::toString(mInsL));;
}
}
}
}
return ret;
}
void PhysicsSystem::doPhysics(float dt, const std::vector<std::pair<std::string, Ogre::Vector3> >& actors)
{
//set the DebugRenderingMode. To disable it,set it to 0
//eng->setDebugRenderingMode(1);
//set the walkdirection to 0 (no movement) for every actor)
for(std::map<std::string,OEngine::Physic::PhysicActor*>::iterator it = mEngine->PhysicActorMap.begin(); it != mEngine->PhysicActorMap.end();it++)
{
OEngine::Physic::PhysicActor* act = it->second;
act->setWalkDirection(btVector3(0,0,0));
}
playerMove::playercmd& pm_ref = playerphysics->cmd;
pm_ref.rightmove = 0;
pm_ref.forwardmove = 0;
pm_ref.upmove = 0;
//playerphysics->ps.move_type = PM_NOCLIP;
for (std::vector<std::pair<std::string, Ogre::Vector3> >::const_iterator iter (actors.begin());
iter!=actors.end(); ++iter)
{
OEngine::Physic::PhysicActor* act = mEngine->getCharacter(iter->first);
//if(iter->first == "player")
// std::cout << "This is player\n";
//dirty stuff to get the camera orientation. Must be changed!
Ogre::SceneNode *sceneNode = mRender.getScene()->getSceneNode (iter->first);
Ogre::Vector3 dir;
Ogre::Node* yawNode = sceneNode->getChildIterator().getNext();
Ogre::Node* pitchNode = yawNode->getChildIterator().getNext();
Ogre::Quaternion yawQuat = yawNode->getOrientation();
Ogre::Quaternion pitchQuat = pitchNode->getOrientation();
// unused
//Ogre::Quaternion both = yawQuat * pitchQuat;
playerphysics->ps.viewangles.x = pitchQuat.getPitch().valueDegrees();
playerphysics->ps.viewangles.z = 0;
playerphysics->ps.viewangles.y = yawQuat.getYaw().valueDegrees() *-1 + 90;
if(mFreeFly)
{
Ogre::Vector3 dir1(iter->second.x,iter->second.z,-iter->second.y);
pm_ref.rightmove = -dir1.x;
pm_ref.forwardmove = dir1.z;
pm_ref.upmove = dir1.y;
//std::cout << "Current angle" << yawQuat.getYaw().valueDegrees() - 90<< "\n";
//playerphysics->ps.viewangles.x = pitchQuat.getPitch().valueDegrees();
//std::cout << "Pitch: " << yawQuat.getPitch() << "Yaw:" << yawQuat.getYaw() << "Roll: " << yawQuat.getRoll() << "\n";
dir = 0.07*(yawQuat*pitchQuat*dir1);
}
else
{
Ogre::Quaternion quat = yawNode->getOrientation();
Ogre::Vector3 dir1(iter->second.x,iter->second.z,-iter->second.y);
pm_ref.rightmove = -dir1.x;
pm_ref.forwardmove = dir1.z;
pm_ref.upmove = dir1.y;
dir = 0.025*(quat*dir1);
}
//set the walk direction
act->setWalkDirection(btVector3(dir.x,-dir.z,dir.y));
}
mEngine->stepSimulation(dt);
}