コード例 #1
0
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();
    }
}
コード例 #2
0
ファイル: EnemyController.cpp プロジェクト: utah2013zyd/Game
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);
	}
}
コード例 #3
0
ファイル: fps_view_controller.cpp プロジェクト: jkammerl/rviz
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() );
}
コード例 #4
0
ファイル: CameraManager.cpp プロジェクト: Target6/pairOculus
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);

}
コード例 #5
0
ファイル: GUIRadarLayout.cpp プロジェクト: beorc/flare_star
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);
}
コード例 #6
0
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 */ }
}
コード例 #7
0
ファイル: GUIRadarLayout.cpp プロジェクト: beorc/flare_star
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);
	}
	
}
コード例 #8
0
ファイル: Transform.cpp プロジェクト: jamessqr/Cing
/**
 * @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() );
}
コード例 #9
0
  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
       );
  }
コード例 #10
0
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;
}