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);
        }
}
bool CAnimationProxyDualCharacter::StartAnimationById(IEntity *entity, int animId, const CryCharAnimationParams& Params, float speedMultiplier)
{
    ICharacterInstance* pICharacter = entity->GetCharacter(m_characterMain);
    if (pICharacter)
        {
            ISkeletonAnim* pISkeletonAnim = pICharacter->GetISkeletonAnim();
            ICharacterInstance* pIShadowCharacter = m_firstPersonMode ? entity->GetCharacter(m_characterShadow) : NULL;
            IAnimationSet* pAnimSet = pICharacter->GetIAnimationSet();

            SPlayParams playParams;
            GetPlayParams(animId, speedMultiplier, pAnimSet, playParams);

            bool shadowLocomotion = !(((Params.m_nFlags & CA_DISABLE_MULTILAYER) || (Params.m_nLayerID != 0)) || !m_killMixInFirst);
            bool bAnimStarted = false;
            bool bShouldPlayShadow = true;
            CryCharAnimationParams localParams = Params;
            if (!m_firstPersonMode || !shadowLocomotion)
                {
                    localParams.m_fPlaybackSpeed *= m_firstPersonMode ? playParams.speedFP : playParams.speedTP;
                    bAnimStarted = pISkeletonAnim->StartAnimationById(m_firstPersonMode ? playParams.animIDFP : playParams.animIDTP, localParams);
                    if (bAnimStarted)
                        {
                            pISkeletonAnim->SetLayerBlendWeight(Params.m_nLayerID, 1.0f);
                        }
                    else
                        bShouldPlayShadow = false;
                }

            if (bShouldPlayShadow && pIShadowCharacter != NULL)
                {
                    ISkeletonAnim* pIShadowSkeletonAnim = pIShadowCharacter->GetISkeletonAnim();
                    localParams.m_fPlaybackSpeed = Params.m_fPlaybackSpeed * playParams.speedTP;
                    if (pIShadowSkeletonAnim->StartAnimationById(playParams.animIDTP, localParams))
                        {
                            bAnimStarted = true;

                            pIShadowSkeletonAnim->SetLayerBlendWeight(Params.m_nLayerID, 1.0f);
                        }
                }

            if (bAnimStarted && (Params.m_nLayerID == 0))
                {
                    m_allowsMix = (Params.m_nFlags & CA_DISABLE_MULTILAYER) == 0;
                }

            return bAnimStarted;
        }

    return false;
}
bool CAnimationProxyDualCharacterUpper::StartAnimationById(IEntity *entity, int animId, const CryCharAnimationParams& Params, float speedMultiplier)
{
    ICharacterInstance* pICharacter = entity->GetCharacter(m_characterMain);
    if (pICharacter)
        {
            ISkeletonAnim* pISkeletonAnim = pICharacter->GetISkeletonAnim();
            ICharacterInstance* pIShadowCharacter = m_firstPersonMode ? entity->GetCharacter(m_characterShadow) : NULL;
            IAnimationSet* pAnimSet = pICharacter->GetIAnimationSet();

            SPlayParams playParams;
            GetPlayParams(animId, speedMultiplier, pAnimSet, playParams);

            CryCharAnimationParams localParams = Params;

            bool startedMain = false;
            if (m_firstPersonMode)
                {
                    localParams.m_fPlaybackSpeed *= playParams.speedFP;
                    startedMain = pISkeletonAnim->StartAnimationById(playParams.animIDFP, localParams);
                }
            else
                {
                    localParams.m_fPlaybackSpeed *= playParams.speedTP;
                    startedMain = pISkeletonAnim->StartAnimationById(playParams.animIDTP, localParams);
                }

            if (startedMain)
                {
                    pISkeletonAnim->SetLayerBlendWeight(Params.m_nLayerID, 1.0f);
                }

            if (pIShadowCharacter != NULL && (Params.m_nLayerID != 0))
                {
                    ISkeletonAnim* pIShadowSkeletonAnim = pIShadowCharacter->GetISkeletonAnim();

                    localParams.m_fPlaybackSpeed = Params.m_fPlaybackSpeed * playParams.speedTP;

                    if (pIShadowSkeletonAnim->StartAnimationById(playParams.animIDTP, localParams))
                        {
                            pIShadowSkeletonAnim->SetLayerBlendWeight(Params.m_nLayerID, 1.0f);
                        }
                }

            return startedMain;
        }

    return false;
}
Example #4
0
bool CActionScope::InstallAnimation(int animID, const CryCharAnimationParams &animParams)
{
    ISkeletonAnim *pSkelAnim = m_scopeContext.charInst->GetISkeletonAnim();
    const bool startAnimationSuccess = pSkelAnim->StartAnimationById(animID, animParams);
    pSkelAnim->SetLayerPlaybackScale(animParams.m_nLayerID, m_speedBias);
    pSkelAnim->SetLayerBlendWeight(animParams.m_nLayerID, m_animWeight);

    return startAnimationSuccess;
}
Example #5
0
void CActionScope::Update(float timePassed)
{
    IAction * const pPlayingAction = GetPlayingAction().get();
    if (pPlayingAction)
    {
        ISkeletonAnim *pSkelAnim = m_scopeContext.charInst ? m_scopeContext.charInst->GetISkeletonAnim() : NULL;

        const float newSpeedBias = pPlayingAction->GetSpeedBias();
        const float newAnimWeight = pPlayingAction->GetAnimWeight();

        if (m_speedBias != newSpeedBias)
        {
            m_speedBias = newSpeedBias;

            if(pSkelAnim)
            {
                for (uint32 layer=0; layer<m_numLayers; layer++)
                {
                    pSkelAnim->SetLayerPlaybackScale(m_layer+layer, newSpeedBias);
                }
            }
        }

        if(m_animWeight != newAnimWeight)
        {
            m_animWeight = newAnimWeight;

            if(pSkelAnim)
            {
                for (uint32 layer=0; layer<m_numLayers; layer++)
                {
                    pSkelAnim->SetLayerBlendWeight(m_layer+layer, newAnimWeight);
                }
            }
        }

        timePassed *= m_speedBias;

        m_fragmentTime += timePassed+m_timeIncrement;
    }

    UpdateSequencers(timePassed);
}