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 FPSViewController::setPropertiesFromCamera( Ogre::Camera* source_camera )
{
Ogre::Quaternion quat = source_camera->getOrientation() * ROBOT_TO_CAMERA_ROTATION.Inverse();
float yaw = quat.getRoll( false ).valueRadians(); // OGRE camera frame looks along -Z, so they call rotation around Z "roll".
float pitch = quat.getYaw( false ).valueRadians(); // OGRE camera frame has +Y as "up", so they call rotation around Y "yaw".
Ogre::Vector3 direction = quat * Ogre::Vector3::NEGATIVE_UNIT_Z;
if ( direction.dotProduct( Ogre::Vector3::NEGATIVE_UNIT_Z ) < 0 )
{
if ( pitch > Ogre::Math::HALF_PI )
{
pitch -= Ogre::Math::PI;
}
else if ( pitch < -Ogre::Math::HALF_PI )
{
pitch += Ogre::Math::PI;
}
yaw = -yaw;
if ( direction.dotProduct( Ogre::Vector3::UNIT_X ) < 0 )
{
yaw -= Ogre::Math::PI;
}
else
{
yaw += Ogre::Math::PI;
}
}
pitch_property_->setFloat( pitch );
yaw_property_->setFloat( mapAngleTo0_2Pi( yaw ));
position_property_->setVector( source_camera->getPosition() );
}
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);
}
inline void GUIRadarLayout::DrawPos(unsigned num, Ogre::Vector3 dst_pos, Ogre::Quaternion players_orientation)
{
Ogre::Rectangle2D *row = Rows.Data[num];
Ogre::Rectangle2D *obj = Objects.Data[num];
//dst_pos -= CommonDeclarations::MaxDistForRadar/2;
Ogre::Quaternion orientation(Ogre::Degree(30), Ogre::Vector3::UNIT_X);
Ogre::Quaternion player_rotation(players_orientation.getYaw(), Ogre::Vector3::UNIT_Y);
player_rotation = Ogre::Quaternion(players_orientation.getRoll(), Ogre::Vector3::UNIT_Z) * player_rotation;
Ogre::Vector3 rel_pos = dst_pos, base_pos = rel_pos;
base_pos.y=0;
float scr_height = rel_pos.y*ScreenSize / CommonDeclarations::MaxDistForRadar;
base_pos = orientation * players_orientation * base_pos;
base_pos = (base_pos / CommonDeclarations::MaxDistForRadar)*ScreenSize;
base_pos.x += 0.75;
base_pos.y -= 0.75;
if (scr_height==0)
scr_height=0.01;
float left=base_pos.x-0.0035, top=base_pos.y, right=base_pos.x+0.0035, bottom=base_pos.y+scr_height;
//
obj->setCorners(base_pos.x-0.01, base_pos.y+0.005, base_pos.x+0.01, base_pos.y-0.005);
if (scr_height>0)
{
left=base_pos.x-0.0025;
top=base_pos.y+scr_height;
right=base_pos.x+0.0025;
bottom=base_pos.y;
obj->setMaterial("Radar/ObjMaterialUp");
} else
if (scr_height<0)
{
left=base_pos.x-0.0025;
top=base_pos.y;
right=base_pos.x+0.0025;
bottom=base_pos.y+scr_height;
obj->setMaterial("Radar/ObjMaterialDn");
}
row->setCorners(left, top, right, bottom);
row->setVisible(true);
obj->setVisible(true);
}
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 */ }
}
inline void GUIRadarLayout::DrawCompas(Ogre::Quaternion players_orientation)
{
//static clock_t last_update_time=0;
//if (clock()-last_update_time<100)
// return;
assert(CompasRect && CompasObj);
//if (NULL==CompasRect || NULL==CompasObj)
// return;
//last_update_time = clock();
//CompasTarget;
if (TargetID>0)
{
if (--WaitCompasTargetTimeout>=0)
{
CompasRect->setVisible(false);
CompasObj->setVisible(false);
return;
}
IAAObject *obj = CommonDeclarations::GetIDObject(TargetID);
//assert(obj);
if (NULL==obj)
{
RemoveCompasTarget();
return;
}
CompasTarget = obj->GetPosition();
}
Ogre::Rectangle2D *row = CompasRect;
Ogre::Rectangle2D *obj = CompasObj;
//dst_pos -= CommonDeclarations::MaxDistForRadar/2;
Ogre::Quaternion orientation(Ogre::Degree(30), Ogre::Vector3::UNIT_X);
Ogre::Quaternion player_rotation(players_orientation.getYaw(), Ogre::Vector3::UNIT_Y);
player_rotation = Ogre::Quaternion(players_orientation.getRoll(), Ogre::Vector3::UNIT_Z) * player_rotation;
Ogre::Vector3 pl_pos = CommonDeclarations::GetPlayer()->GetPosition();
Ogre::Vector3 rel_pos = CompasTarget-pl_pos, base_pos = rel_pos;
base_pos.y=0;
bool checkpoint_mode=false;
float scr_height = 0;
if (rel_pos.squaredLength()>CommonDeclarations::SqMaxDistForRadar)
{
Ogre::Vector3 dist=base_pos;
AAUtilities::Norm1(dist);
base_pos = dist*CommonDeclarations::MaxDistForRadar;
scr_height=0.01;
checkpoint_mode=true;
} else
{
scr_height =rel_pos.y*ScreenSize / CommonDeclarations::MaxDistForRadar;
}
base_pos = orientation * players_orientation * base_pos;
base_pos = (base_pos / CommonDeclarations::MaxDistForRadar)*ScreenSize;
base_pos.x += 0.75;
base_pos.y -= 0.75;
//
if (!checkpoint_mode)
{
if (scr_height==0)
scr_height=0.01;
float left=base_pos.x-0.005, top=base_pos.y, right=base_pos.x+0.005, bottom=base_pos.y+scr_height;
obj->setCorners(base_pos.x-0.01, base_pos.y+0.008, base_pos.x+0.01, base_pos.y-0.008);
if (scr_height>0)
{
left=base_pos.x-0.0025;
top=base_pos.y+scr_height;
right=base_pos.x+0.0025;
bottom=base_pos.y;
obj->setMaterial("Radar/CompasObjMaterialUp");
} else
if (scr_height<0)
{
left=base_pos.x-0.0025;
top=base_pos.y;
right=base_pos.x+0.0025;
bottom=base_pos.y+scr_height;
obj->setMaterial("Radar/CompasObjMaterialDn");
}
row->setCorners(left, top, right, bottom);
//
row->setVisible(true);
obj->setVisible(true);
} else
{
obj->setMaterial("Radar/CompasFarMaterial");
obj->setCorners(base_pos.x-0.015, base_pos.y+0.015, base_pos.x+0.015, base_pos.y-0.015);
obj->setVisible(true);
}
}
/**
* @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;
}