C++ ISkeletonAnim::GetNumAnimsInFIFO方法代码示例

bool CBoidObject::PlayAnimation( const char *animation, bool bLooped, float fBlendTime )
{
	bool playing = false;

	if (m_object)
	{
		ISkeletonAnim* pSkeleton = m_object->GetISkeletonAnim();
		assert(pSkeleton);

		CryCharAnimationParams animParams;
		if (bLooped)
			animParams.m_nFlags |= CA_LOOP_ANIMATION;
		animParams.m_fTransTime = fBlendTime;

		const int amountAnimationsInFIFO = pSkeleton->GetNumAnimsInFIFO(0);
		const uint32 maxAnimationsAllowedInQueue = 2;
		if(amountAnimationsInFIFO >= maxAnimationsAllowedInQueue)
		{
			animParams.m_nFlags |= CA_REMOVE_FROM_FIFO;
		}

		playing = pSkeleton->StartAnimation( animation, animParams );
		assert(pSkeleton->GetNumAnimsInFIFO(0) <= maxAnimationsAllowedInQueue);
		m_object->SetPlaybackScale( 1.0f ); 
	}
	return playing;
}

bool CAnimationProxyDualCharacterUpper::RemoveAnimationInLayer(IEntity *entity, int32 nLayer, uint32 token)
{
    ICharacterInstance* pIShadowCharacter = m_firstPersonMode ? entity->GetCharacter(m_characterShadow) : NULL;
    ICharacterInstance* pICharacter = pIShadowCharacter ? pIShadowCharacter : entity->GetCharacter(m_characterMain);
    if (pICharacter)
        {
            ISkeletonAnim* pISkeletonAnim = pICharacter->GetISkeletonAnim();

            if (pIShadowCharacter)
                {
                    ISkeletonAnim* pIShadowSkeletonAnim = pIShadowCharacter->GetISkeletonAnim();
                    int nAnimsInFIFO = pIShadowSkeletonAnim->GetNumAnimsInFIFO(nLayer);
                    for (int i=0; i<nAnimsInFIFO; ++i)
                        {
                            const CAnimation& anim = pIShadowSkeletonAnim->GetAnimFromFIFO(nLayer, i);
                            if (anim.HasUserToken(token))
                                {
                                    pIShadowSkeletonAnim->RemoveAnimFromFIFO(nLayer, i);
                                }
                        }
                }

            int nAnimsInFIFO = pISkeletonAnim->GetNumAnimsInFIFO(nLayer);
            for (int i=0; i<nAnimsInFIFO; ++i)
                {
                    const CAnimation& anim = pISkeletonAnim->GetAnimFromFIFO(nLayer, i);
                    if (anim.HasUserToken(token))
                        {
                            return pISkeletonAnim->RemoveAnimFromFIFO(nLayer, i);
                        }
                }
        }

    return false;
}

//------------------------------------------------------------------------
void CItem::PlayAnimationEx(const char* animationName, int slot, int layer, bool loop, float blend, float speed, uint32 flags)
{
	bool start=true;

	ICharacterInstance *pCharacter = GetEntity()->GetCharacter(slot);

	if (!pCharacter && slot==eIGS_FirstPerson && ((m_stats.viewmode&eIVM_FirstPerson)==0))
	{
		start=false;

		int idx = 0;
		if (m_stats.hand == eIH_Right)
			idx = 1;
		else if (m_stats.hand == eIH_Left)
			idx = 2;
		if (m_fpgeometry[idx].name.empty())
			idx = 0;

		pCharacter = m_pItemSystem->GetCachedCharacter(m_fpgeometry[idx].name.c_str());
	}

	if (pCharacter && animationName)
	{
		ISkeletonAnim* pSkeletonAnim = pCharacter->GetISkeletonAnim();

		if (flags&eIPAF_CleanBlending)
		{
			while(pSkeletonAnim->GetNumAnimsInFIFO(layer)>1)
			{
				if (!pSkeletonAnim->RemoveAnimFromFIFO(layer, pSkeletonAnim->GetNumAnimsInFIFO(layer)-1))
					break;
			}
		}

		if (flags&eIPAF_NoBlend)
			blend = 0.0f;

		if (start)
		{
			CryCharAnimationParams params;
			params.m_fTransTime = blend;
			params.m_nLayerID = layer;
			params.m_nFlags = (loop?CA_LOOP_ANIMATION:0)|(flags&eIPAF_RestartAnimation?CA_ALLOW_ANIM_RESTART:0)|(flags&eIPAF_RepeatLastFrame?CA_REPEAT_LAST_KEY:0);
			pSkeletonAnim->StartAnimation(animationName,  params);
			pSkeletonAnim->SetLayerUpdateMultiplier(layer, speed);

			//pCharacter->GetISkeleton()->SetDebugging( true );
		}

		float duration=0.0f;
		int animationId = pCharacter->GetIAnimationSet()->GetAnimIDByName(animationName);
		if (animationId>=0)
			duration = pCharacter->GetIAnimationSet()->GetDuration_sec(animationId);
		
		m_animationTime[slot] = (uint32)(duration*1000.0f/speed);
		m_animationEnd[slot] = (uint32)(gEnv->pTimer->GetCurrTime()*1000.0f)+m_animationTime[slot];
		m_animationSpeed[slot] = speed;
	}
}

void CActionScope::Pause()
{
    if (!m_scopeContext.charInst)
    {
        return;
    }

    ISkeletonAnim *pSkeletonAnim = m_scopeContext.charInst->GetISkeletonAnim();
    if (!pSkeletonAnim)
    {
        return;
    }

    for (int i = 0; i < m_numLayers; ++i)
    {
        SSequencer &sequencer = m_layerSequencers[i];

        const int animationLayer = m_layer + i;

        const int animationsInLayer = pSkeletonAnim->GetNumAnimsInFIFO(animationLayer);
        if (animationsInLayer == 0)
        {
            sequencer.savedAnimNormalisedTime = -1;
        }
        else
        {
            const int lastAnimationIndex = animationsInLayer - 1;
            const CAnimation &animation = pSkeletonAnim->GetAnimFromFIFO(animationLayer, lastAnimationIndex);
            sequencer.savedAnimNormalisedTime = pSkeletonAnim->GetAnimationNormalizedTime(&animation);
        }
    }
}

void CMountedGunController::ReplayUpdateThirdPersonAnimations( ICharacterInstance* pCharacter, float aimRad, float aimUp, float aimDown, bool firstPerson /*= false*/)
{
    if (pCharacter)
        {
            ISkeletonAnim *pSkeletonAnim = pCharacter->GetISkeletonAnim();
            assert(pSkeletonAnim);

            //Update manually animation time, to match current weapon orientation
            uint32 numAnimsLayer = pSkeletonAnim->GetNumAnimsInFIFO(REPLAY_PLAYER_ANIMATION_LAYER_BASE);
            for(uint32 i=0; i<numAnimsLayer; i++)
                {
                    CAnimation &animation = pSkeletonAnim->GetAnimFromFIFO(REPLAY_PLAYER_ANIMATION_LAYER_BASE, i);
                    if (animation.HasStaticFlag(CA_MANUAL_UPDATE))
                        {
                            float time = CalculateAnimationTime(aimRad);
                            pSkeletonAnim->SetAnimationNormalizedTime(&animation, time);
                            animation.ClearStaticFlag( CA_DISABLE_MULTILAYER );
                        }
                }

            if (firstPerson)
                return;

            //Update additive weights for aiming up/down
            pSkeletonAnim->SetLayerBlendWeight(REPLAY_PLAYER_ANIMATION_LAYER_AIM_UP, aimUp);
            pSkeletonAnim->SetLayerBlendWeight(REPLAY_PLAYER_ANIMATION_LAYER_AIM_DOWN, aimDown);
        }
}

CAnimation *CAnimationProxyDualCharacter::GetAnimation(IEntity *entity, int32 layer, uint32 token)
{
    ICharacterInstance* pIShadowCharacter = m_firstPersonMode ? entity->GetCharacter(m_characterShadow) : NULL;
    ICharacterInstance* pICharacter = pIShadowCharacter ? pIShadowCharacter : entity->GetCharacter(m_characterMain);
    if (pICharacter)
        {
            ISkeletonAnim* pISkeletonAnim = pICharacter->GetISkeletonAnim();

            int nAnimsInFIFO = pISkeletonAnim->GetNumAnimsInFIFO(layer);
            if (nAnimsInFIFO == 0)
                {
                    return NULL;
                }
            if (token == INVALID_ANIMATION_TOKEN)
                {
                    return &pISkeletonAnim->GetAnimFromFIFO(layer, 0);
                }
            else
                {
                    return pISkeletonAnim->FindAnimInFIFO(token, layer);
                }
        }

    return NULL;
}

void CScriptbind_Entity::PlayAnimation(IEntity *pEntity, mono::string animationName, int slot, int layer, float blend, float speed, EAnimationFlags flags)
{
	// Animation graph input
	/*if(IGameObject *pGameObject = static_cast<CScriptSystem *>(GetMonoScriptSystem())->GetIGameFramework()->GetGameObject(pEntity->GetId()))
	{
		if(IAnimatedCharacter *pAniamtedCharacter = static_cast<IAnimatedCharacter*>(pGameObject->AcquireExtension("AnimatedCharacter")))	
		{
			pAniamtedCharacter->GetAnimationGraphState()->SetInput("Action / "Signal"
		}
	}*/

	ICharacterInstance *pCharacter = pEntity->GetCharacter(slot);
	if(!pCharacter)
		return;

	ISkeletonAnim *pSkeletonAnim = pCharacter->GetISkeletonAnim();
	if(!pSkeletonAnim)
		return;

	if(flags & EAnimFlag_CleanBending)
	{
		while(pSkeletonAnim->GetNumAnimsInFIFO(layer)>1)
		{
			if (!pSkeletonAnim->RemoveAnimFromFIFO(layer, pSkeletonAnim->GetNumAnimsInFIFO(layer)-1))
				break;
		}
	}

	if (flags & EAnimFlag_NoBlend)
		blend = 0.0f;

	CryCharAnimationParams params;
	params.m_fTransTime = blend;
	params.m_nLayerID = layer;
	params.m_fPlaybackSpeed = speed;
	params.m_nFlags = (flags & EAnimFlag_Loop ? CA_LOOP_ANIMATION : 0) | (flags & EAnimFlag_RestartAnimation ? CA_ALLOW_ANIM_RESTART : 0) | (flags & EAnimFlag_RepeatLastFrame ? CA_REPEAT_LAST_KEY : 0);
	pSkeletonAnim->StartAnimation(ToCryString(animationName),  params);
}

CAnimation *CActionScope::GetTopAnim(int layer)
{
    CAnimation *anim = NULL;
    if (m_scopeContext.charInst)
    {
        ISkeletonAnim *pISkeletonAnim = m_scopeContext.charInst->GetISkeletonAnim();
        int nAnimsInFIFO = pISkeletonAnim->GetNumAnimsInFIFO(m_layer + layer);
        if (nAnimsInFIFO > 0)
        {
            anim = &pISkeletonAnim->GetAnimFromFIFO(m_layer + layer, nAnimsInFIFO-1);
        }
    }

    return anim;
}

//------------------------------------------------------------------------
int CVehiclePartAnimated::GetNextFreeLayer()
{
	if (ICharacterInstance* pCharInstance = GetEntity()->GetCharacter(m_slot))
	{
		ISkeletonAnim* pSkeletonAnim = pCharInstance->GetISkeletonAnim();
		CRY_ASSERT(pSkeletonAnim);

		for (int i = 1; i < ISkeletonAnim::LayerCount; i++)
		{
			if (pSkeletonAnim->GetNumAnimsInFIFO(i) == 0)
				return i;
		}
	}

	return -1;
}

//------------------------------------------------------------------------
void CVehicleSeatActionPassengerIK::Update(float frameTime)
{
	if (!m_passengerId)
		return;

	IActor* pActor = CCryAction::GetCryAction()->GetIActorSystem()->GetActor(m_passengerId);
	if (!pActor)
	{
		CRY_ASSERT(!"Invalid entity id for the actor id, Actor System didn't know it");
		return;
	}

	if (ICharacterInstance* pCharInstance = pActor->GetEntity()->GetCharacter(0))
	{
		ISkeletonAnim* pSkeletonAnim = pCharInstance->GetISkeletonAnim();
		CRY_ASSERT(pSkeletonAnim);

		if (pSkeletonAnim->GetNumAnimsInFIFO(0) >= 1)
		{
			const CAnimation& anim = pSkeletonAnim->GetAnimFromFIFO(0, 0);
			const uint16 loopCount = anim.GetLoop();
			const f32 animationTime = pSkeletonAnim->GetAnimationNormalizedTime( &anim );
			if (!m_waitShortlyBeforeStarting || (loopCount > 0 || animationTime > 0.9f))
			{
				for (TIKLimbVector::iterator ite = m_ikLimbs.begin(); ite != m_ikLimbs.end(); ++ite)
				{
					const SIKLimb& limb = *ite;

					Vec3 helperPos = limb.pHelper->GetWorldSpaceTranslation();
					pActor->SetIKPos(limb.limbName.c_str(), helperPos, 1);
				}
			}
		}
	}

}

void CActionScope::UpdateSequencers(float timePassed)
{
    ISkeletonAnim *pSkelAnim = m_scopeContext.charInst ? m_scopeContext.charInst->GetISkeletonAnim() : NULL;

    const bool hasIncrement = (m_timeIncrement != 0.0f);
    timePassed += m_timeIncrement;
    m_timeIncrement = 0.0f;

    const int k_MAX_INCREMENTS = 5;
    float queuedIncrements[k_MAX_INCREMENTS];
    int   numQueued = 0;

    if(pSkelAnim)
    {
        const CAnimation *pRootAnim = GetTopAnim(0);
        if (pRootAnim)
        {
            m_lastNormalisedTime = m_normalisedTime;
            m_normalisedTime = pRootAnim->GetCurrentSegmentNormalizedTime();
        }

        for (uint32 i=0; i<m_numLayers; i++)
        {
            SSequencer &sequencer = m_layerSequencers[i];
            float timeLeft = timePassed;
            while ((sequencer.flags & eSF_Queued) != 0)
            {
                const float timeTillInstall = sequencer.installTime;
                if (timeLeft >= timeTillInstall)
                {
                    if (PlayPendingAnim(i, timeLeft - timeTillInstall))
                    {
                        timeLeft -= timeTillInstall;

                        if (numQueued < k_MAX_INCREMENTS)
                        {
                            queuedIncrements[numQueued++] = timeLeft;
                        }

                        if (sequencer.pos >= sequencer.sequence.size())
                            break;
                    }
                }
                else
                {
                    sequencer.installTime -= timeLeft;
                    break;
                }
            }

            if (hasIncrement)
            {
                uint32 layer = m_layer + i;
                uint32 numAnims = pSkelAnim->GetNumAnimsInFIFO(layer);
                if (numAnims > 0)
                {
                    for (uint32 anm=0; anm<numAnims; anm++)
                    {
                        int timeIncID = (anm + numQueued) - numAnims;
                        float timeIncrement = (timeIncID >= 0) ? queuedIncrements[timeIncID] : timePassed;

                        if (timeIncrement > 0.0f)
                        {
                            CAnimation &anim = pSkelAnim->GetAnimFromFIFO(layer, anm);
                            float segDuration = m_scopeContext.charInst->GetIAnimationSet()->GetDuration_sec(anim.GetAnimationId());
                            if (segDuration > 0.0f)
                            {
                                const float segNormTime = anim.GetCurrentSegmentNormalizedTime();
                                const float newTime			= (segNormTime * segDuration) + (timeIncrement * anim.GetPlaybackScale());
                                float newSegNormTime = newTime / segDuration;
                                if (!anim.HasStaticFlag(CA_LOOP_ANIMATION))
                                {
                                    newSegNormTime = min(newSegNormTime, 1.0f);
                                }
                                else
                                {
                                    newSegNormTime = newSegNormTime - (float)((int)(newSegNormTime));
                                }
                                anim.SetCurrentSegmentNormalizedTime(newSegNormTime);
                            }

                            float transitionPriority = 0.0f;
                            const float transitionTime = anim.GetTransitionTime();
                            if ((transitionTime == 0.0f) || (anm < numAnims-1))
                            {
                                transitionPriority = 1.0f;
                            }
                            else
                            {
                                transitionPriority = min(anim.GetTransitionPriority() + (timeIncrement / transitionTime), 1.0f);
                            }
                            anim.SetTransitionPriority(transitionPriority);
                        }
                    }
                }
            }
        }
    }

    const uint32 numProcSequencers = m_procSequencers.size();
//.........这里部分代码省略.........

void CActionScope::Resume(float forcedBlendTime, uint32 resumeFlags)
{
    if (!m_scopeContext.charInst)
    {
        return;
    }

    IAnimationSet *pAnimSet = m_scopeContext.charInst->GetIAnimationSet();
    if (!pAnimSet)
    {
        return;
    }

    ISkeletonAnim *pSkeletonAnim = m_scopeContext.charInst->GetISkeletonAnim();
    if (!pSkeletonAnim)
    {
        return;
    }

    const bool useDefaultBlendTime = (forcedBlendTime < 0);

    for (int i = 0; i < m_numLayers; ++i)
    {
        SSequencer &sequencer = m_layerSequencers[i];

        const int animationLayer = m_layer + i;
        const float blendTime = useDefaultBlendTime ? sequencer.blend.duration : forcedBlendTime;

        if (sequencer.savedAnimNormalisedTime < 0)
        {
            pSkeletonAnim->StopAnimationInLayer(animationLayer, blendTime);
        }
        else
        {
            const uint32 pos = sequencer.pos - 1;
            if (pos < sequencer.sequence.size())
            {
                SAnimClip& clip = sequencer.sequence[pos];
                const int animID = pAnimSet->GetAnimIDByCRC(clip.animation.animRef.crc);
                if (0 <= animID)
                {
                    CryCharAnimationParams params;
                    InitAnimationParams(clip.animation, i, clip.blend, params);
                    const bool installAnimationSuccess = InstallAnimation(animID, params);
                    if (installAnimationSuccess)
                    {
                        const int animationsInLayer = pSkeletonAnim->GetNumAnimsInFIFO(animationLayer);
                        CRY_ASSERT(1 <= animationsInLayer);

                        const bool loopingAnimation = ((clip.animation.flags & CA_LOOP_ANIMATION) != 0);
                        const uint32 restoreAnimationTimeFlagToCheck = loopingAnimation ? IActionController::ERF_RestoreLoopingAnimationTime : IActionController::ERF_RestoreNonLoopingAnimationTime;
                        const bool restoreAnimationTime = ((restoreAnimationTimeFlagToCheck & resumeFlags) != 0);
                        if (restoreAnimationTime)
                        {
                            const int lastAnimationIndex = animationsInLayer - 1;
                            CAnimation &animation = pSkeletonAnim->GetAnimFromFIFO(animationLayer, lastAnimationIndex);
                            pSkeletonAnim->SetAnimationNormalizedTime(&animation, sequencer.savedAnimNormalisedTime);
                        }
                    }
                }
            }
        }
    }
}

void CVehicleWeaponControlled::Update3PAnim(CPlayer *player, float goalTime, float frameTime, const Matrix34 &mat)
{
  if (player)
  {
    if (IEntity *entity = player->GetEntity())
    {
      const float ANIM_ANGLE_RANGE = gf_PI*0.25f;
      static float dir = 0.05f;
      static float pos = 0.5f;

      pos += dir;
      if (pos > 1.0f)
      {
        pos = 1.0f;
        dir = -dir;
      }
      else if (pos < 0.0f)
      {
        pos = 0.0f;
        dir = -dir;
      }

      m_CurrentTime = LERP(m_CurrentTime, goalTime, frameTime);
     
      if (ICharacterInstance *character = entity->GetCharacter(0))
      {
        ISkeletonAnim *pSkeletonAnim = character->GetISkeletonAnim();
        assert(pSkeletonAnim);

        //Update manually animation time, to match current weapon orientation
        uint32 numAnimsLayer = pSkeletonAnim->GetNumAnimsInFIFO(0);
        for(uint32 i=0; i<numAnimsLayer; i++)
        {
          CAnimation &animation = pSkeletonAnim->GetAnimFromFIFO(0, i);
          if (animation.HasStaticFlag( CA_MANUAL_UPDATE ))
          {
            float time = m_CurrentTime; //pos; //fmod_tpl(aimRad / ANIM_ANGLE_RANGE, 1.0f);
            time = (float)__fsel(time, time, 1.0f + time);
            pSkeletonAnim->SetAnimationNormalizedTime(&animation, time);
            animation.ClearStaticFlag( CA_DISABLE_MULTILAYER );
          }
        }
      }


      const SMountParams* pMountParams = GetMountedParams();
      SEntitySlotInfo info;
      if (GetEntity()->GetSlotInfo(eIGS_ThirdPerson, info))
      {
        if (info.pStatObj)
        {
          IStatObj *pStatsObj = info.pStatObj;

          const Vec3 &leftHandPos = pStatsObj->GetHelperPos(pMountParams->left_hand_helper.c_str()); 
          const Vec3 &rightHandPos = pStatsObj->GetHelperPos(pMountParams->right_hand_helper.c_str());
 
          const Vec3 leftIKPos = mat.TransformPoint(leftHandPos);
          const Vec3 rightIKPos = mat.TransformPoint(rightHandPos);

          player->SetIKPos("leftArm",		leftIKPos, 1);
          player->SetIKPos("rightArm",	rightIKPos, 1);
        }
      }
    }
  }
}

//------------------------------------------------------------------------
void CItem::UpdateMounted(float frameTime)
{
	IRenderAuxGeom* pAuxGeom = gEnv->pRenderer->GetIRenderAuxGeom();

	if (!m_ownerId || !m_stats.mounted)
		return;

	CActor *pActor = GetOwnerActor();
	if (!pActor)
		return;

	CheckViewChange();

  if (true)
  {  
	  if (IsClient())
	  {
		  ICharacterInstance *pCharacter = GetEntity()->GetCharacter(eIGS_FirstPerson);

		  if (pCharacter && !m_idleAnimation[eIGS_FirstPerson].empty() && pCharacter->GetISkeletonAnim()->GetNumAnimsInFIFO(0)<1)
			  PlayAction(m_idleAnimation[eIGS_FirstPerson], 0, true);
	  }

		// need to explicitly update characters at this point
		// cause the entity system update occered earlier, with the last position
		for (int i=0; i<eIGS_Last; i++)
		{
			if (GetEntity()->GetSlotFlags(i)&ENTITY_SLOT_RENDER)
			{
				ICharacterInstance *pCharacter = GetEntity()->GetCharacter(i);
				if (pCharacter)
				{
					Matrix34 mloc = GetEntity()->GetSlotLocalTM(i,false);
					Matrix34 m34 = GetEntity()->GetWorldTM()*mloc;
					QuatT renderLocation = QuatT(m34);
					pCharacter->GetISkeletonPose()->SetForceSkeletonUpdate(9);
					pCharacter->SkeletonPreProcess(renderLocation, renderLocation, GetISystem()->GetViewCamera(),0x55 );
					pCharacter->SetPostProcessParameter(renderLocation, renderLocation, 0, 0.0f, 0x55 );		
				}
			}
		}

	//	f32 fColor[4] = {1,1,0,1};
	//	f32 g_YLine=60.0f;
	//	gEnv->pRenderer->Draw2dLabel( 1,g_YLine, 1.3f, fColor, false, "Mounted Gun Code" ); 

		//adjust the orientation of the gun based on the aim-direction


		SMovementState info;
		IMovementController* pMC = pActor->GetMovementController();		
		pMC->GetMovementState(info);
		Vec3 dir = info.aimDirection.GetNormalized();
		Matrix34 tm = Matrix33::CreateRotationVDir(dir);
		Vec3 vGunXAxis=tm.GetColumn0();

		if (pActor->GetLinkedVehicle()==0)
		{
			if (pMC)
			{						
				if(!pActor->IsPlayer())
				{
					// prevent snapping direction
					Vec3 currentDir = GetEntity()->GetWorldRotation().GetColumn1();
					float dot = currentDir.Dot(dir);
					dot = CLAMP(dot,-1,1);
					float reqAngle = cry_acosf(dot);
					const float maxRotSpeed = 2.0f;
					float maxAngle = frameTime * maxRotSpeed;
					if(fabs(reqAngle) > maxAngle)
					{
						Vec3 axis = currentDir.Cross(dir);
						if(axis.GetLengthSquared()>0.001f) // current dir and new dir are enough different
							dir = currentDir.GetRotated(axis.GetNormalized(),sgn(reqAngle)*maxAngle);
					}
				}				
				//adjust the orientation of the gun based on the aim-direction
				tm = Matrix33::CreateRotationVDir(dir);
				Vec3 vWPos=GetEntity()->GetWorldPos();
				tm.SetTranslation(vWPos);
				GetEntity()->SetWorldTM(tm);  //set the new orientation of the mounted gun

				vGunXAxis=tm.GetColumn0();
				Vec3 vInitialAimDirection = m_stats.mount_dir;
				Matrix33 vInitialPlayerOrientation = Matrix33::CreateRotationVDir(vInitialAimDirection);
				assert( vInitialAimDirection.IsUnit() );

	  		Vec3 newp;

				if (pActor->IsThirdPerson())
				{
					//third person
					f32 dist = m_mountparams.body_distance*1.3f;
					Vec3 oldp = pActor->GetEntity()->GetWorldPos();
					newp = GetEntity()->GetWorldPos()-vInitialAimDirection*dist; //mounted gun
					newp.z = oldp.z;
				}
				else
				{
//.........这里部分代码省略.........