自学教程：C++ GetRotation函数代码示例

void RoboCatServer::Update(){	RoboCat::Update();		Vector3 oldLocation = GetLocation();	Vector3 oldVelocity = GetVelocity();	float oldRotation = GetRotation();	ClientProxyPtr client = NetworkManagerServer::sInstance->GetClientProxy( GetPlayerId() );	if( client )	{		MoveList& moveList = client->GetUnprocessedMoveList();		for( const Move& unprocessedMove : moveList )		{			const InputState& currentState = unprocessedMove.GetInputState();			float deltaTime = unprocessedMove.GetDeltaTime();			ProcessInput( deltaTime, currentState );			SimulateMovement( deltaTime );		}		moveList.Clear();	}	HandleShooting();	if( !RoboMath::Is2DVectorEqual( oldLocation, GetLocation() ) ||		!RoboMath::Is2DVectorEqual( oldVelocity, GetVelocity() ) ||		oldRotation != GetRotation() )	{		NetworkManagerServer::sInstance->SetStateDirty( GetNetworkId(), ECRS_Pose );	}}

void CObject::Move ( const CVector& vecPosition, const CVector& vecRotation, unsigned long ulTime ){    // Are we already moving?    if ( IsMoving () )    {        // Stop our current movement        StopMoving ();    }    // If it's more than 0 milliseconds    if ( ulTime > 0 )    {        // Setup our move data        m_moveData.vecStartPosition = GetPosition ();        m_moveData.vecStopPosition = vecPosition;        GetRotation ( m_moveData.vecStartRotation );        m_moveData.vecStopRotation = vecRotation;        m_moveData.ulTime = ulTime;        m_moveData.ulTimeStart = GetTime ();        m_moveData.ulTimeStop = m_moveData.ulTimeStart + ulTime;        m_moveData.bActive = true;    }    // If we have a time of 0, move there now    else    {        SetPosition ( vecPosition );        CVector vecTemp;        GetRotation ( vecTemp );        SetRotation ( vecTemp + vecRotation );    }}

LineSegment OrientedBoxShape::GetEdge(int EdgeIdx)const{	sf::Vector2f P1 = GetHalfExtents();	sf::Vector2f P2 = GetHalfExtents();	switch(EdgeIdx % 4) 	{	case 0:/* top edge */		P1.x = -P1.x;		break;	case 1:/* right edge */		P2.y = -P2.y;		break;	case 2:/* bottom edge */		P1.y = -P1.y;		P2 = -P2;		break;	default:/* left edge */		P1 = -P1;		P2.x = -P2.x;		break;	}	P1 = MathUtils::RotateVector(P1, GetRotation());	P1 = P1 + GetCenter();	P2 = MathUtils::RotateVector(P1, GetRotation());	P2 = P2 + GetCenter();	return LineSegment(P1, P2);}

void Player::Move(){	//fprintf(stderr, "Move Forward/n");	Vector2 rotation = this->GetRotation();	Vector2 velocity = this->GetVelocity();	rotation = Vector2(GetRotation().GetX(), GetRotation().GetY());	velocity = velocity + rotation * 4 * pEngine->GetDeltaTime();	SetVelocity(velocity);}

void Wall::OnDestroy( bool bomb ){    if ( bomb )        return;    Vec2 d = _dir;    d.Rotate( M_PI / M_TWO );    Vec2 v = GetPosition() + d * M_TEN * 3;    if ( v._x >= 0 && v._x <= Lib::WIDTH && v._y >= 0 && v._y <= Lib::HEIGHT )        Spawn( new Square( v, GetRotation() ) );    v = GetPosition() - d * M_TEN * 3;    if ( v._x >= 0 && v._x <= Lib::WIDTH && v._y >= 0 && v._y <= Lib::HEIGHT )        Spawn( new Square( v, GetRotation() ) );}

void cEntity::TakeDamage(eDamageType a_DamageType, cEntity * a_Attacker, int a_RawDamage, int a_FinalDamage, double a_KnockbackAmount){	TakeDamageInfo TDI;	TDI.DamageType = a_DamageType;	TDI.Attacker = a_Attacker;	TDI.RawDamage = a_RawDamage;	TDI.FinalDamage = a_FinalDamage;	Vector3d Heading;	Heading.x = sin(GetRotation());	Heading.y = 0.4;  // TODO: adjust the amount of "up" knockback when testing	Heading.z = cos(GetRotation());	TDI.Knockback = Heading * a_KnockbackAmount;	DoTakeDamage(TDI);}

uint32_t TommyCoin::Write( OutgoingPacketBuffer& inPacket, uint32_t inDirtyState ) const {	uint32_t writtenState = 0;	uint32_t remainingBytes = inPacket.GetRemainingBytes();	if( remainingBytes >= 3 * sizeof( float ) + sizeof( XMVECTOR ) )	{		bool poseDirty = inDirtyState & ETCRS_Pose;		bool colorDirty = inDirtyState & ETCRS_Color;		inPacket.Write(poseDirty);		if (poseDirty) {			XMVECTORF32 location; location.v = GetLocation();			inPacket.Write(location.f[0]);			inPacket.Write(location.f[1]);			inPacket.Write(GetRotation());		}		inPacket.Write(colorDirty);		if (colorDirty) {			inPacket.Write(GetColor());		}		writtenState |= inDirtyState;	}	return writtenState;}

void MovingObstacle::Update(float dt){    if(this->IsDestroyed() || m_snake == NULL)    {        return;    }        Actor::Update(dt);    const float rotation = GetRotation();    SetRotation((rotation + 190 * dt));        Vector2 position = GetPosition();        position += m_direction * (m_speed * dt);        SetPosition(position);            if(++m_movementCount % m_maxMovements == 0)    {        m_direction *= -1;    }        if(!m_snake->isInvulnerable() && m_snake->collided(this))    {        m_snake->collide();    }    }

void Viewer3dParam::Print( FILE *fp ){    fprintf(fp, "%f %f %f ", eye[0], eye[1], eye[2]);    Quaternion q = GetRotation();    q.Print(fp);    fprintf(fp, "/n");}

void CClientVehicle::Serialize(CBitStream * pBitStream){	// Write the vehicle position	CVector3 vecPosition;	GetPosition(vecPosition);	pBitStream->Write(vecPosition);	// Write the vehicle rotation	CVector3 vecRotation;	GetRotation(vecRotation);	pBitStream->Write(vecRotation);	// Write the vehicle move speed	CVector3 vecMoveSpeed;	GetMoveSpeed(vecMoveSpeed);	pBitStream->Write(vecMoveSpeed);	// Write the vehicle turn speed	CVector3 vecTurnSpeed;	GetTurnSpeed(vecTurnSpeed);	pBitStream->Write(vecTurnSpeed);	// Write the vehicle health	pBitStream->Write(GetHealth());}

void CTextureNode::Render(){	// Check if the texture is loaded	if ( m_GLTexture.IsLoaded() && m_Visible )	{		glLoadIdentity();		glTranslatef( m_PositionAbsolute.x, m_PositionAbsolute.y, m_PositionAbsolute.z);		glRotatef( GetRotation() ,0.0f,0.0f,1.0f);		m_GLTexture.Bind();		m_VBO[m_FrameNum]->BindBuffer();		glTexCoordPointer(2,GL_FLOAT,5 * sizeof(GLfloat), ((GLubyte *) 0) );		glVertexPointer(3,GL_FLOAT,5 * sizeof(GLfloat), ((GLubyte *) 0 + (2*sizeof(GLfloat))) );		glEnableClientState(GL_TEXTURE_COORD_ARRAY);		glEnableClientState(GL_VERTEX_ARRAY);		glDrawArrays(GL_TRIANGLE_STRIP,0,4);		glDisableClientState(GL_COLOR_ARRAY);		glDisableClientState(GL_TEXTURE_COORD_ARRAY);		m_VBO[m_FrameNum]->UnBindBuffer();		m_GLTexture.UnBind();	}	CBaseNode::Render();}

bool cPlayer::SaveToDisk(){    cFile::CreateFolder(FILE_IO_PREFIX + AString("players"));    // create the JSON data    Json::Value JSON_PlayerPosition;    JSON_PlayerPosition.append(Json::Value(GetPosX()));    JSON_PlayerPosition.append(Json::Value(GetPosY()));    JSON_PlayerPosition.append(Json::Value(GetPosZ()));    Json::Value JSON_PlayerRotation;    JSON_PlayerRotation.append(Json::Value(GetRotation()));    JSON_PlayerRotation.append(Json::Value(GetPitch()));    JSON_PlayerRotation.append(Json::Value(GetRoll()));    Json::Value JSON_Inventory;    m_Inventory.SaveToJson(JSON_Inventory);    Json::Value root;    root["position"]       = JSON_PlayerPosition;    root["rotation"]       = JSON_PlayerRotation;    root["inventory"]      = JSON_Inventory;    root["health"]         = m_Health;    root["xpTotal"]        = m_LifetimeTotalXp;    root["xpCurrent"]      = m_CurrentXp;    root["air"]            = m_AirLevel;    root["food"]           = m_FoodLevel;    root["foodSaturation"] = m_FoodSaturationLevel;    root["foodTickTimer"]  = m_FoodTickTimer;    root["foodExhaustion"] = m_FoodExhaustionLevel;    root["world"] = GetWorld()->GetName();    if (m_GameMode == GetWorld()->GetGameMode())    {        root["gamemode"] = (int) eGameMode_NotSet;    }    else    {        root["gamemode"] = (int) m_GameMode;    }    Json::StyledWriter writer;    std::string JsonData = writer.write(root);    AString SourceFile;    Printf(SourceFile, "players/%s.json", m_PlayerName.c_str() );    cFile f;    if (!f.Open(SourceFile, cFile::fmWrite))    {        LOGERROR("ERROR WRITING PLAYER /"%s/" TO FILE /"%s/" - cannot open file", m_PlayerName.c_str(), SourceFile.c_str());        return false;    }    if (f.Write(JsonData.c_str(), JsonData.size()) != (int)JsonData.size())    {        LOGERROR("ERROR WRITING PLAYER JSON TO FILE /"%s/"", SourceFile.c_str());        return false;    }    return true;}

void CVehicle::GetMatrix( CMatrix& matrix ){    CVector vecRotation;    GetRotation( vecRotation );    matrix.SetRotation( vecRotation );    matrix.vPos = GetPosition();}

void CVehicleEntity::SetTargetRotation(const CVector3& vecRotation, unsigned long ulDelay){    // Are we spawned?    if(IsSpawned())	{        // Update our target rotation        UpdateTargetRotation();        // Get the current time        unsigned long ulTime = SharedUtility::GetTime();        // Get our local rotation        CVector3 vecLocalRotation;        GetRotation(vecLocalRotation);        // Set the target rotation        m_interp.rot.vecTarget = vecRotation;        // Get the error        m_interp.rot.vecError = Math::GetOffsetDegrees(vecLocalRotation, vecRotation);        // Get the interpolation interval        m_interp.rot.ulStartTime = ulTime;        m_interp.rot.ulFinishTime = (ulTime + ulDelay);        // Initialize the interpolation        m_interp.rot.fLastAlpha = 0.0f;    }    // Set our rotation straight    m_vecRotation = vecRotation;}

bool FTransform::DebugEqualMatrix(const FMatrix& Matrix) const{	FTransform TestResult(Matrix);	if (!Equals(TestResult))	{		// see now which one isn't equal				if (!Scale3DEquals(TestResult.Scale3D, ScalarRegister(0.01f)))		{			UE_LOG(LogTransform, Log, TEXT("Matrix(S)/t%s"), *TestResult.GetScale3D().ToString());			UE_LOG(LogTransform, Log, TEXT("VQS(S)/t%s"), *GetScale3D().ToString());		}		// see now which one isn't equal		if (!RotationEquals(TestResult.Rotation))		{			UE_LOG(LogTransform, Log, TEXT("Matrix(R)/t%s"), *TestResult.GetRotation().ToString());			UE_LOG(LogTransform, Log, TEXT("VQS(R)/t%s"), *GetRotation().ToString());		}		// see now which one isn't equal		if (!TranslationEquals(TestResult.Translation, ScalarRegister(0.01f)))		{			UE_LOG(LogTransform, Log, TEXT("Matrix(T)/t%s"), *TestResult.GetTranslation().ToString());			UE_LOG(LogTransform, Log, TEXT("VQS(T)/t%s"), *GetTranslation().ToString());		}		return false;	}	return true;}

void CWall::Advance(float dt){	(void)dt;	m_visual.SetPosition(GetPosition());	m_visual.SetRotation(GetRotation());}

void wxTransformMatrix::SetRotation(double rotation){    double x=GetValue(2,0);    double y=GetValue(2,1);    Rotate(-GetRotation(), x, y);    Rotate(rotation, x, y);}

	//! called during the update of the entity		void LaserSwiper::Update()	{		super::Update();		if(m_HitPoints < 0)		{			return;		}		LaserSwiperSettings* pSettings = static_cast<LaserSwiperSettings*>(m_Settings.Get());		// aim		Player* pPlayer = Player::Instance();		Vector3 vPosition = GetTransformationMatrix().GetTranslation();					Vector3 vPlayerMeshPos = pPlayer->GetMeshEntity()->GetTransformationMatrix().GetTranslation();		Vector3 vToPlayer = (vPlayerMeshPos-vPosition).Normalize();					f32 fDestAngle = Math::ATan2(vToPlayer.X, -vToPlayer.Y)*Math::RadToDegFactor;		f32 fRotation = Math::Damp(GetRotation().Z, 180.0f-fDestAngle, g_fDeltaTime, pSettings->m_fAimDuration);		m_fCurrentAngle = Math::Damp(m_fCurrentAngle, fDestAngle, g_fDeltaTime, pSettings->m_fAimDuration);		SetRotation(Vector3::Create(0.0f, 0.0f, fRotation));		f32 fDistSquared = (vPosition-vPlayerMeshPos).GetLengthSquared();		if(fDistSquared < m_fLaserLengthSquared)		{			// swipe			Vector3 vPosition = GetTransformationMatrix().GetTranslation();			Vector3 vOffset = Vector3::Create(0.0f, -pSettings->m_fLaserOffset, 0.0f);			Vector3 vRotatedOffset = Quaternion(Vector3::Create(0.0f, 0.0f, 1.0f), m_fCurrentAngle*Math::DegToRadFactor).Rotate(vOffset);			if(!m_pLaser || m_pLaser->fLife < 0.0f)			{				// shoot				Laser::Params params;									params.vStart = vPosition + vRotatedOffset;				params.vDir = vRotatedOffset.Normalize();				params.fSpeed = pSettings->m_fLaserSpeed;				params.fMaxLength = pSettings->m_fLaserLength;				params.fLife = 999.0f;				params.bStatic = true;				params.fThickness = pSettings->m_fLaserThickness;				m_pLaser = SFXManager::Instance()->GetEnemyLaserManager()->AddLaser(params);			}			else			{				// update laser				m_pLaser->vStart = vPosition + vRotatedOffset;				m_pLaser->vDir = vRotatedOffset.Normalize();			}		}		else		{			Translate(Vector3::Create(0.0f, -pSettings->m_fSpeed*g_fDeltaTime, 0.0f));			if(m_pLaser)			{				m_pLaser->fLife = 0.0f;				m_pLaser = NULL;			}		}	}

void CPed::GetMatrix( CMatrix& matrix ){    CVector vecRotation;    vecRotation.fZ = GetRotation();    matrix.SetRotation( vecRotation );    matrix.vPos = GetPosition();}

int         CasteroidIGC::Export(void* data) const{    if (data)    {        DataAsteroidIGC*  dataAsteroid = (DataAsteroidIGC*)data;        dataAsteroid->asteroidDef = m_asteroidDef;        dataAsteroid->position = GetPosition();        {            const Orientation&  o = GetOrientation();            dataAsteroid->forward = o.GetForward();            dataAsteroid->up      = o.GetUp();        }        dataAsteroid->rotation = GetRotation();        assert (GetCluster());        dataAsteroid->clusterID = GetCluster()->GetObjectID();        dataAsteroid->signature = GetSignature();        dataAsteroid->fraction = m_fraction;                const char* pszName = GetName();        if (*pszName == '/0')            memcpy(dataAsteroid->name, GetName(), sizeof(dataAsteroid->name));        else            UTL::putName(dataAsteroid->name, GetName());    }    return sizeof(DataAsteroidIGC);}

void World::InteractBetweenPlayerAndEnemy(Entity &subject, float time, bool &isBreak) {	float distance = GetDistance(subject.getRect(), player->getRect());	if (IntersectsRects(subject.getRect(), player->getRect())) {		EnemyDamagedPlayer(kickHit, subject, *player, time);	}	else {		subject.isMove = true;	}	if (distance <= ENEMY_VIEW_RANGE) {		if (subject.name == HARD_ENEMY) {			ActHardEnemy(*player, subject, distance, kickHit, time);		}		else if (subject.name == MEDIUM_ENEMY) {			FightRotateMediumEnemy(subject.sprite, GetRotation({ player->rect.left, player->rect.top }, { subject.rect.left, subject.rect.top }));			if (playerWeapon->shootEnemyTimer > DEFAULT_ENEMY_SHOOT_SPEED / GET_HALF) {				EnemyShootAtPlayer(lvl, subject, *player, entities, *playerWeapon, bulletImage);				isBreak = true;			}		}		else if (subject.name == EASY_ENEMY && IntersectsRects(subject.getEnemyView(), player->getRect())) {			subject.sprite.setColor(Color::Red);		}		else {			subject.sprite.setColor(Color::White);			subject.isFight = false;		}	}	else {		subject.sprite.setRotation(0);		subject.isFight = false;	}}

void CVehicleEntity::UpdateTargetRotation(){	// Do we have a target rotation?    if(HasTargetRotation())    {        // Get our current rotation        CVector3 vecCurrentRotation;        GetRotation(vecCurrentRotation);        // Get the factor of time spent from the interpolation start        // to the current time.        unsigned long ulCurrentTime = SharedUtility::GetTime();        float fAlpha = Math::Unlerp(m_interp.rot.ulStartTime, ulCurrentTime, m_interp.rot.ulFinishTime);        // Don't let it to overcompensate the error        fAlpha = Math::Clamp(0.0f, fAlpha, 1.0f);        // Get the current error portion to compensate        float fCurrentAlpha = (fAlpha - m_interp.rot.fLastAlpha);        m_interp.rot.fLastAlpha = fAlpha;        // Compensate the error        CVector3 vecCompensation = Math::Lerp(CVector3(), fCurrentAlpha, m_interp.rot.vecError);        // If we finished compensating the error, finish it for the next pulse        if(fAlpha == 1.0f)            m_interp.rot.ulFinishTime = 0;        // Set the new rotation        SetRotation((vecCurrentRotation + vecCompensation), false);    }}

boolHwcComposer2D::TryRender(Layer* aRoot,                         const gfxMatrix& aGLWorldTransform){    MOZ_ASSERT(Initialized());    if (mList) {        mList->numHwLayers = 0;    }    // XXX use GL world transform instead of GetRotation()    int rotation = GetRotation();    int fbHeight, fbWidth;    if (rotation == 0 || rotation == HWC_TRANSFORM_ROT_180) {        fbWidth = mScreenWidth;        fbHeight = mScreenHeight;    } else {        fbWidth = mScreenHeight;        fbHeight = mScreenWidth;    }    if (!PrepareLayerList(aRoot, nsIntRect(0, 0, fbWidth, fbHeight))) {        LOGD("Render aborted. Nothing was drawn to the screen");        return false;    }    if (mHwc->set(mHwc, mDpy, mSur, mList)) {        LOGE("Hardware device failed to render");        return false;    }    LOGD("Frame rendered");    return true;}

// creates a proper rectangle which can be drawn to the screensf::Shape WorldShape::CreateRectangle() {  sf::Shape s = sf::Shape::Rectangle(0, 0, w * WorldConfig::scale, h * WorldConfig::scale,                                     color, 1.0f, sf::Color::Black);  s.SetCenter(w * WorldConfig::scale / 2, h * WorldConfig::scale / 2);  s.SetRotation(GetRotation());  s.SetPosition(GetPosition());  return s;}

bool Spell::Render(float dt) {	UpdatePos(dt);	animation->RenderEx(xPos, yPos, GetRotation());	animation->Update(dt);	if (distance > range)		return true;	return false;}

 void SegmentShape2D::UpdateParameters() {     revision = GetSpatialRevision();     rotatedDirection = direction;     rotatedDirection.Rotate(GetRotation());     startPoint = GetPosition() + (rotatedDirection * GetBackLength()  * GetScale());     endPoint   = GetPosition() + (rotatedDirection * GetFrontLength() * GetScale()); }

void CObject::Rotate(const CVector3& vecRotation, unsigned int uiTime){	GetRotation(m_interp.rot.vecStart);	m_interp.rot.vecTarget = vecRotation;	unsigned int ulCurrentTime = SharedUtility::GetTime();	m_interp.rot.ulStartTime = ulCurrentTime;	m_interp.rot.ulFinishTime = (ulCurrentTime + uiTime);}

void CWall::SetVisual(){	m_visual.SetWidth(m_width);	m_visual.SetHeight(m_height);	m_visual.SetRotation(GetRotation());	m_visual.SetOrigin(GetOrigin());	m_visual.SetReferenceSystemOrigin(GetReferenceSystemOrigin());	m_visual.SetPosition(GetPosition());}

void Object::FillFullPacket( const PacketPtr& packet ) {	(*packet) << static_cast<sf::Uint16>( ServerToClient::SERVER_OBJECT ) << GetId() << static_cast<sf::Uint16>( ServerToClientObject::OBJECT_STATE )	          << GetType() << GetName()	          << GetResourceId()	          << GetSize().x << GetSize().y	          << GetPosition().x << GetPosition().y	          << GetVelocity().x << GetVelocity().y	          << GetRotation() << GetRotationalVelocity();}

void Entity::SetScale(Vector3 a_vScale){	float fRotation = GetRotation();	Vector3 vPosition = GetPosition();	m_oLocalTransform = Matrix3x3::setupTranslation(vPosition)		* Matrix3x3::setupRotation(fRotation)		* Matrix3x3::setupScale(a_vScale);}