コード例 #1
0
void XMLHelper::fillElementFromQuaternion(TiXmlElement& elem, const Ogre::Quaternion& quaternion) {
	//split the quaternion into an axis and a degree (our format allows us to store the angle element as a radian too, but I prefer degrees)
	Ogre::Degree degrees;
	Ogre::Vector3 axis;
	quaternion.ToAngleAxis(degrees, axis);
	fillElementFromVector3(elem, axis);
	elem.SetDoubleAttribute("degrees", degrees.valueDegrees());
}
コード例 #2
0
ファイル: World.cpp プロジェクト: EvilWar/prj-reboot
void fix_gta_coord(Ogre::Quaternion& quat)
{
    swap(quat.y, quat.z);
    Ogre::Radian angle;
    Ogre::Vector3 axis;
    quat.ToAngleAxis(angle, axis);
    //swap(axis.y, axis.z);
    axis = Ogre::Quaternion(Ogre::Degree(-90), Ogre::Vector3::UNIT_X) * axis;
    quat.FromAngleAxis(angle, axis);
}
コード例 #3
0
ファイル: Entity.cpp プロジェクト: DeejStar/q-gears
Ogre::Degree
Entity::GetRotation() const
{
    assert( m_model_root_node );
    Ogre::Quaternion q = m_model_root_node->getOrientation();
    Ogre::Degree temp;
    Ogre::Vector3 vec = Ogre::Vector3::UNIT_Z;
    q.ToAngleAxis( temp, vec );

    return temp;
}
コード例 #4
0
ファイル: gkSteering.cpp プロジェクト: Ali-il/gamekit
gkRadian gkSteering::getAngle(const gkVector3& from, const gkVector3& to)
{
	Ogre::Vector3 from1 = getProjectionOnPlane(from, m_steerAxis);

	Ogre::Vector3 to1 = getProjectionOnPlane(to, m_steerAxis);

	Ogre::Quaternion q = from1.getRotationTo(to1);

	Ogre::Radian angle;
	Ogre::Vector3 rAxis;

	q.ToAngleAxis(angle, rAxis);

	rAxis = angle.valueRadians() * (rAxis * m_steerAxis);

	angle = rAxis.x + rAxis.y + rAxis.z;

	return angle;
}
コード例 #5
0
ファイル: QuaternionAdapter.cpp プロジェクト: Chimangoo/ember
void QuaternionAdapter::updateGui(const Ogre::Quaternion& quaternion)
{
	mSelfUpdate = true;

	if (&quaternion) {
		Ogre::Vector3 axis;
		Ogre::Degree angle;
		quaternion.ToAngleAxis( angle, axis);
		mVectorAdapter.updateGui(axis);
		if (mDegreeWindow) {
			mDegreeWindow->setText(Ogre::StringConverter::toString(angle.valueDegrees()));
		}
	} else {
		mVectorAdapter.updateGui(Ogre::Vector3::ZERO);
		if (mDegreeWindow) {
			mDegreeWindow->setText("");
		}
	}
	mSelfUpdate = false;
}
コード例 #6
0
void DefaultDrone::show(){
	Parent::show();

	float f = timeAlive();
	Coordinator::Transform base;
	if (mTransformCoordinator){
		base = mTransformCoordinator->getValue(timeAlive());
	}else{
		base.mPos = Ogre::Vector3::ZERO;
		base.mRot = Ogre::Quaternion::IDENTITY;
		base.mScl = Ogre::Vector3::UNIT_SCALE;
	}
	getNode()->setPosition(base.mPos);
	getNode()->setOrientation(base.mRot);

	Ogre::TransformKeyFrame key(NULL, 0);
	key = dynamic_cast<DefaultDroneDBE*>(mDbe)->getKeyFrame(f);
	Ogre::Vector3 v = key.getTranslate();
	v=v*base.mScl;

	getNode()->translate(v);

	Ogre::Radian angle;
	Ogre::Vector3 axis;

	Ogre::Quaternion r = key.getRotation();

	if ( base.mScl.x == -1){
		r.ToAngleAxis(angle, axis);
		axis.x *= -1;
		angle = (Ogre::Radian)0-angle;
		r.FromAngleAxis(angle, axis);
	}
	mSceneNode->rotate(r);

	/*Ogre::Node* n = getNode();
	n->setPosition(mDelta+mTransformCoordinator->getValue(timeAlive()).mPos);*/
}
コード例 #7
0
    void PropertiesWindow::addPropertyQuaternion(const Property& prop,
        CEGUI::MultiColumnList* table, const CeGuiString& key)
    {
        // Check column count
        // if count = 3 | MainTable
        // if count = 2 | Array table
        int colCount = table->getColumnCount();
        int rowCount = table->getRowCount();

        Ogre::Quaternion quat = prop.toQuaternion();
        Ogre::Degree angle;
        Ogre::Vector3 axis;

        quat.ToAngleAxis( angle, axis );

        char buf_angle [50];
        sprintf(buf_angle, "%1.2f", angle.valueDegrees());
        char buf_v1 [50];
        sprintf(buf_v1, "%1.2f", axis.x);
        char buf_v2 [50];
        sprintf(buf_v2, "%1.2f", axis.y);
        char buf_v3 [50];
        sprintf(buf_v3, "%1.2f", axis.z);

        // Table has the three columns Key, Type, Value
        if ( colCount == 3 )
        {
            // Add row for the first IntTriple value
            table->addRow(rowCount);
            table->setItem(new ListboxTextItem(key + "  "), 0, rowCount);
            table->setItem(new ListboxTextItem("Quaternion  "), 1, rowCount);
            table->setItem(new ListboxTextItem("Axis:   ( " +
                CEGUI::String(buf_v1) + ", " +
                CEGUI::String(buf_v2) + ", " +
                CEGUI::String(buf_v3) + " )"),
                2,
                rowCount);

            // Add second for the second IntTriple value
            table->addRow(rowCount + 1);
            table->setItem(new ListboxTextItem("Degree: " +
                CEGUI::String(buf_angle)),
                2,
                rowCount + 1);
        }
        // Table has the two columns Type, Value
        else if ( colCount == 2 )
        {
            table->addRow(rowCount);
            table->setItem(new ListboxTextItem("Quaternion  "), 0, rowCount);
            table->setItem(new ListboxTextItem("Axis:   ( " +
                CEGUI::String(buf_v1) + ", " +
                CEGUI::String(buf_v2) + ", " +
                CEGUI::String(buf_v3) + " )"),
                2,
                rowCount);

            // Add second for the second IntTriple value
            table->addRow(rowCount + 1);
            table->setItem(new ListboxTextItem("Degree " +
                CEGUI::String(buf_angle)),
                2,
                rowCount + 1);
        }

    }
コード例 #8
0
ファイル: game.cpp プロジェクト: Majki/es_core
void game_tick( unsigned int now, GameState & gs, SharedRenderState & rs ) {
  // get the latest mouse buttons state and orientation
  zstr_send( gs.zmq_input_req, "mouse_state" );
  char * mouse_state = zstr_recv( gs.zmq_input_req );
  Uint8 buttons;
  Ogre::Quaternion orientation;
  parse_mouse_state( mouse_state, orientation, buttons );
  free( mouse_state );

  // at 16 ms tick and the last 10 orientations buffered, that's 150ms worth of orientation history
  gs.orientation_history[ gs.orientation_index ].t = now;
  gs.orientation_history[ gs.orientation_index ].o = orientation;
  gs.orientation_index = ( gs.orientation_index + 1 ) % ORIENTATION_LOG;

  // oldest orientation
  unsigned int q1_index = gs.orientation_index;
  // NOTE: the problem with using the successive orientations to infer an angular speed,
  // is that if the orientation is changing fast enough, this code will 'flip' the speed around
  // e.g. this doesn't work, need to use the XY mouse data to track angular speed
  // NOTE: uncomment the following line to use the full history, notice the 'flip' happens at much lower speed
  q1_index = ( q1_index + ORIENTATION_LOG - 2 ) % ORIENTATION_LOG; 
  Ogre::Quaternion q1 = gs.orientation_history[ q1_index ].o;
  Uint32 q1_t = gs.orientation_history[ q1_index ].t;
  Ogre::Quaternion omega = 2.0f * ( orientation - q1 ) * q1.UnitInverse() * ( 1000.0f / (float)( now - q1_t ) );
  omega.ToAngleAxis( gs.smoothed_angular_velocity, gs.smoothed_angular );
  //  printf( "%f %f %f - %f\n", gs.smoothed_angular.x, gs.smoothed_angular.y, gs.smoothed_angular.z, gs.smoothed_angular_velocity.valueDegrees() );
  rs.smoothed_angular = gs.smoothed_angular;

  if ( ( buttons & SDL_BUTTON( 1 ) ) != 0 ) {
    if ( !gs.mouse_pressed ) {
      gs.mouse_pressed = true;
      // changing the control scheme: the player is now driving the orientation of the head directly with the mouse
      // tell the input logic to reset the orientation to match the current orientation of the head
      zstr_sendf( gs.zmq_input_req, "mouse_reset %f %f %f %f", rs.orientation.w, rs.orientation.x, rs.orientation.y, rs.orientation.z );
      zstr_recv( gs.zmq_input_req ); // wait for ack from input
      // IF RENDER TICK HAPPENS HERE: render will not know that it should grab the orientation directly from the mouse,
      // but the orientation coming from game should still be ok?
      zstr_sendf( gs.zmq_render_socket, "# %s", "1" );
      // IF RENDER TICK HAPPENS HERE (before a new gamestate):
      // the now reset input orientation will combine with the old game state, that's bad
    }
  } else {
    if ( gs.mouse_pressed ) {
      gs.mouse_pressed = false;
      // changing the control scheme: the head will free spin and slow down for a bit, then it will resume bouncing around
      // the player looses mouse control, the game grabs latest orientation and angular velocity
      // the input thread was authoritative on orientation until now, so accept that as our starting orientation
      rs.orientation = orientation;
      gs.rotation_speed = gs.smoothed_angular_velocity;
      gs.rotation = gs.smoothed_angular;
      zstr_sendf( gs.zmq_render_socket, "# %s", "0" );
      // IF RENDER TICK HAPPENS HERE (before a new gamestate): render will pull the head orientation from the game state rather than input, but game state won't have the fixed orientation yet
    }
  }

  if ( rs.position.x > gs.bounce || rs.position.x < -gs.bounce ) {
    gs.direction.x *= -1.0f;
  }
  if ( rs.position.y > gs.bounce || rs.position.y < -gs.bounce ) {
    gs.direction.y *= -1.0f;
  }
  Ogre::Vector2 delta = gs.speed * ( (float)GAME_DELAY / 1000.0f ) * gs.direction;
  if ( !gs.mouse_pressed ) {
    if ( gs.rotation_speed.valueDegrees() == 0.0f ) {
      rs.position.x += delta.x;
      rs.position.y += delta.y;
    }
    //    printf( "game tick position: %f %f\n", rs.position.x, rs.position.y );

    // update the orientation of the head on a free roll
    // gs.rotation is unit length
    // gs.rotation_speed is in degrees/seconds
    // NOTE: sinf/cosf really needed there?
    gs.rotation_speed *= 0.97f;
    if ( gs.rotation_speed.valueDegrees() < 20.f ) {
      gs.rotation_speed = 0.0f;
    }
    float factor = sinf( 0.5f * Ogre::Degree( gs.rotation_speed * GAME_TICK_FLOAT ).valueRadians() );
    Ogre::Quaternion rotation_tick(
      cosf( 0.5f * Ogre::Degree( gs.rotation_speed * GAME_TICK_FLOAT ).valueRadians() ),
      factor * gs.rotation.x,
      factor * gs.rotation.y,
      factor * gs.rotation.z );
    rs.orientation = rotation_tick * rs.orientation;
  } else {
    // keep updating the orientation in the render state, even while the render thread is ignoring it:
    // when the game thread resumes control of the head orientation, it will interpolate from one of these states,
    // so we keep updating the orientation to avoid a short glitch at the discontinuity
    rs.orientation = orientation;
  }
}
コード例 #9
0
void DefaultDrone::updateAlive(double timeDelta, double parentTime){
	float f = timeAlive();

	if (!mDbe->isStatic()){
		Coordinator::Transform base;
		if (mTransformCoordinator){
			base = mTransformCoordinator->getValue(timeAlive());
		}else{
			base = dynamic_cast<Coordinator::TransformCoordinator*>(Coordinator::CoordinatorFactory::getSingleton()->get("static_transform:0,0,0"))->getValue(0);
		}

		getNode()->setPosition(base.mPos);
		getNode()->setOrientation(base.mRot);
		Ogre::TransformKeyFrame key(NULL, 0);
		key = dynamic_cast<DefaultDroneDBE*>(mDbe)->getKeyFrame(f);
		Ogre::Vector3 v = key.getTranslate();
		v=v*base.mScl;

		getNode()->translate(v);
	
		Ogre::Radian angle;
		Ogre::Vector3 axis;
	
		Ogre::Quaternion r = key.getRotation();

		if ( base.mScl.x == -1){
			r.ToAngleAxis(angle, axis);
			axis.x *= -1;
			angle = (Ogre::Radian)0-angle;
			r.FromAngleAxis(angle, axis);
		}
		mSceneNode->rotate(r);


	}

	{
		list<GoAnim::GoAnim*>::iterator it, begin, end;
		
		begin = mGoAnim.begin();
		end = mGoAnim.end();
		for (it=begin;it!=end;it++){
			(*it)->update(timeDelta, parentTime);
		}
	}{
		list<FIRING_TIME>::iterator it, begin, end;
		
		begin = (dynamic_cast<DefaultDroneDBE*>(mDbe)->getFiringTime())->begin();
		end = (dynamic_cast<DefaultDroneDBE*>(mDbe)->getFiringTime())->end();
		for (it=begin;it!=end;it++){
			if (mLevelSegment->isTimeInFrame(getTimeOn()+(*it).time)){
				//Util::Log("IsTimeInFrame:"+ts(getTimeOn()+(*it).time));
				if ((*it).firingOption == FIRING_START){
					fire((*it).mount, (*it).inertia);
				}else{
					ceaseFire((*it).mount);
				}
			}
		}
	}{
		/*list<DRONE_TIMED_ANIM>::iterator it, begin, end;
		
		begin = (dynamic_cast<DefaultDroneDBE*>(mDbe)->getTimedAnim())->begin();
		end = (dynamic_cast<DefaultDroneDBE*>(mDbe)->getTimedAnim())->end();
		for (it=begin;it!=end;it++){
			if (mLevelSegment->isTimeInFrame(getTimeOn()+(*it).time)){
				Util::Log("IsTimeInFrame:"+ts(getTimeOn()+(*it).time));
				Ogre::AnimationState* as;
				as = mEntity->getAnimationState( (*it).label );
				as->setEnabled(true);
				as->setLoop((*it).loop);
				mAnim.push_back(as);
				
				//fire((*it).type);
			}
		}*/
	}{
		list<Ogre::AnimationState*>::iterator it, begin, end;
		
		begin = mAnim.begin();
		end = mAnim.end();
		for (it=begin;it!=end;it++){
			(*it)->addTime(timeDelta);//Level::getSingleton()->getTimeDelta());
		}
	}
}
コード例 #10
0
void OGRERendererRacer::update() {

    mpVehicle = mpApp->mRacer;

    const cml::vector3d& pos = mpVehicle->mPos;

    mVehicleNode->setPosition(pos[0], pos[1], pos[2]);

    Ogre::Quaternion q;

    const quat& orientation = mpVehicle->getOrientation();

    q.w = orientation.as_vector()[0];
    q.x = orientation.as_vector()[1];
    q.y = orientation.as_vector()[2];
    q.z = orientation.as_vector()[3];

    if (q != mOrientation) {

        Ogre::Quaternion transition = q * mOrientation.Inverse();

        Ogre::Radian a;
        Ogre::Vector3 v;

        transition.ToAngleAxis(a, v);

        if (a.valueDegrees() > 0.1) {

            Ogre::Quaternion t2;

            // TODO 3: Make rotation speed configurable
            t2.FromAngleAxis(a * 0.05, v);

            mOrientation = t2 * mOrientation;
        } else {
            mOrientation = q;
        }
    }

    //################# BEGIN Construct Sideward thrust roll quaternion ################

//	cml::vector3f velDirSidewardComponent = cml::dot(mpVehicle->mDirLeft, mpVehicle->mVelocity) * mpVehicle->mDirLeft;

    if (mpVehicle->mAddThrustLeft || mpVehicle->mAddThrustRight) {
        mRollAngle = -mpVehicle->mThrustSideward * 500;
    } else {
        mRollAngle *= 0.98;
    }

    float dot = cml::dot(mpVehicle->mDirLeft, mpVehicle->mVelocity);
    mRollAngle = -dot * 50;

    Ogre::Quaternion qSidewardThrustRoll(Ogre::Degree(mRollAngle), Ogre::Vector3(0, 0, -1));

    cml::vector3f g = mpVehicle->getGravity();

    cml::vector3f velDirGravityComponent = cml::dot(g, mpVehicle->mVelocity) * g;

    dot = cml::dot(velDirGravityComponent, g);

    if (velDirGravityComponent.length() > 0.000001) {
        mPitchAngle = -cml::sign(dot) * velDirGravityComponent.length() * 500000;
    } else {

        if (mpVehicle->mAddThrustForward && mPitchAngle > -7) {
            mPitchAngle -= 0.1;
        } else {
            mPitchAngle *= 0.95;
        }
    }

    Ogre::Quaternion qForwardThrustPitch(Ogre::Degree(mPitchAngle), Ogre::Vector3(1, 0, 0));

    //################# END Construct Sideward thrust roll quaternion ################

    bool mSidewardThrustRollCamera = false;

    if (mSidewardThrustRollCamera) {
        // Roll both vehicle and camera:
        mVehicleNode->setOrientation(q * qSidewardThrustRoll * qForwardThrustPitch);
    } else {
        // Roll only the vehicle, not the camera:
        mVehicleNode->setOrientation(mOrientation);
        mVehicleMeshNode->setOrientation(qSidewardThrustRoll * qForwardThrustPitch);
    }

    //############# BEGIN Update engine particle emitters ####################

    // TODO 1: Reimplement

    bool emit = (mpVehicle->mGameState == 0) && mpVehicle->mThrustForward > 0;

    mEngineFlameParticleSystem->setEmitting(emit);
    mEngineSmokeParticleSystem->setEmitting(emit);

    Ogre::ParticleEmitter* emitter = mEngineFlameParticleSystem->getEmitter(0);
    emitter->setParticleVelocity(mpVehicle->mThrustForward * 6000);
    emitter->setEmissionRate(mpVehicle->mThrustForward * 10000);

    emitter = mEngineSmokeParticleSystem->getEmitter(0);
    emitter->setEmissionRate(mpVehicle->mThrustForward * 7000);

    //############# END Update engine particle emitters ####################
}