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

void CMountedGunController::ReplayStopThirdPersonAnimations( ICharacterInstance* pCharacter )
{
    assert(pCharacter);
    ISkeletonAnim *pSkeletonAnim = pCharacter->GetISkeletonAnim();
    assert(pSkeletonAnim);

    pSkeletonAnim->StopAnimationInLayer(REPLAY_PLAYER_ANIMATION_LAYER_AIM_UP, 0.1f);
    pSkeletonAnim->StopAnimationInLayer(REPLAY_PLAYER_ANIMATION_LAYER_AIM_DOWN, 0.1f);
}

void CActionScope::StopAnimationOnLayer(uint32 layer, float blendTime)
{
    CRY_ASSERT_MESSAGE(layer < m_numLayers, "Overrunning scope!");

    ISkeletonAnim *pSkelAnim = m_scopeContext.charInst->GetISkeletonAnim();
    const uint32 actualLayer = layer + m_layer;
    pSkelAnim->StopAnimationInLayer(actualLayer, blendTime);
}

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

            if (pIShadowCharacter)
                {
                    ISkeletonAnim* pIShadowSkeletonAnim = pIShadowCharacter->GetISkeletonAnim();

                    pIShadowSkeletonAnim->StopAnimationInLayer(nLayer, BlendOutTime);
                }

            return pISkeletonAnim->StopAnimationInLayer(nLayer, BlendOutTime);
        }

    return false;
}

void CScriptbind_Entity::StopAnimationInLayer(IEntity *pEntity, int slot, int layer, float blendOutTime)
{
	ICharacterInstance *pCharacter = pEntity->GetCharacter(slot);
	if(!pCharacter)
		return;

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

	pSkeletonAnim->StopAnimationInLayer(layer, blendOutTime);
}

void CLipSyncProvider_TransitionQueue::StopLipSync(IEntityAudioProxy* pProxy, const AudioControlId audioTriggerId, const ELipSyncMethod lipSyncMethod)
{
	CRY_ASSERT(pProxy);
	CRY_ASSERT(audioTriggerId != INVALID_AUDIO_CONTROL_ID);
	CRY_ASSERT((m_state == eS_Started) || (m_state == eS_Requested) || (m_state == eS_Unpaused) || (m_state == eS_Paused));

	if (lipSyncMethod != eLSM_None)
	{
		if (m_state == eS_Requested)
		{
			CRY_ASSERT(m_soundId == INVALID_AUDIO_CONTROL_ID);
		}
		else
		{
			CRY_ASSERT(audioTriggerId == m_soundId);

			if (ICharacterInstance* pChar = GetCharacterInstance())
			{
				if (m_requestedAnimId >= 0)
				{
					ISkeletonAnim* skeletonAnimation = pChar->GetISkeletonAnim();

					// NOTE: there is no simple way to just stop the exact animation we started, but this should do too:
					bool success = skeletonAnimation->StopAnimationInLayer(m_nAnimLayer, LIPSYNC_STOP_TRANSITION_TIME);
					CRY_ASSERT(success);
				}
			}

			m_soundId        = INVALID_AUDIO_CONTROL_ID;
			m_isSynchronized = false;
		}

		m_cachedAnim = CAutoResourceCache_CAF();
	}
	m_state = eS_Stopped;
}

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);
                        }
                    }
                }
            }
        }
    }
}