BVB Source Codes

CRYENGINE Show AnimatedCharacter.cpp Source code

Return Download CRYENGINE: download AnimatedCharacter.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "AnimatedCharacter.h"
  5. #include "CryAction.h"
  6. #include "AnimationGraphCVars.h"
  7. #include "PersistantDebug.h"
  8. #include "GameObjects/MannequinObject.h"
  9. #include <CryAnimation/IFacialAnimation.h>
  10.  
  11. #include <CryExtension/CryCreateClassInstance.h>
  12.  
  13. #include "CryActionCVars.h"
  14. #include "Mannequin/MannequinAGState.h"
  15.  
  16. #include <IViewSystem.h>
  17.  
  18. char* g_szMCMString[eMCM_COUNT] = { "Undefined", "Entity", "Animation", "DecoupledCatchUp", "ClampedEntity", "SmoothedEntity", "AnimationHCollision" };
  19. char* g_szColliderModeString[eColliderMode_COUNT] = { "Undefined", "Disabled", "GroundedOnly", "Pushable", "NonPushable", "PushesPlayersOnly", "Spectator" };
  20. char* g_szColliderModeLayerString[eColliderModeLayer_COUNT] = { "AG", "Game", "Script", "FG", "Anim", "Sleep", "Debug" };
  21.  
  22. #define ANIMCHAR_MEM_DEBUG // Memory Allocation Tracking
  23. #undef  ANIMCHAR_MEM_DEBUG
  24.  
  25. #define ENABLE_NAN_CHECK
  26.  
  27. #ifndef _RELEASE
  28.         #define VALIDATE_CHARACTER_PTRS ValidateCharacterPtrs();
  29. #else //_RELEASE
  30.         #define VALIDATE_CHARACTER_PTRS
  31. #endif //_RELEASE
  32.  
  33. #undef CHECKQNAN_FLT
  34. #if defined(ENABLE_NAN_CHECK)
  35.         #define CHECKQNAN_FLT(x) \
  36.           assert(((*(unsigned*)&(x)) & 0xff000000) != 0xff000000u && (*(unsigned*)&(x) != 0x7fc00000))
  37. #else
  38.         #define CHECKQNAN_FLT(x) (void*)0
  39. #endif
  40.  
  41. #ifndef CHECKQNAN_VEC
  42.         #define CHECKQNAN_VEC(v) \
  43.           CHECKQNAN_FLT(v.x); CHECKQNAN_FLT(v.y); CHECKQNAN_FLT(v.z)
  44. #endif
  45.  
  46. static CAnimationPlayerProxy s_defaultAnimPlayerProxy;
  47. static CTimeValue lastTime;
  48.  
  49. namespace
  50. {
  51. struct CRY_ALIGN(8) SAnimRoot
  52. {
  53.         f32 m_NormalizedTimeAbs;
  54.         f32 m_KeyTimeAbs;
  55.         QuatT m_TransRot;
  56.  
  57.         SAnimRoot()
  58.         {
  59.                 m_NormalizedTimeAbs = 0;
  60.                 m_KeyTimeAbs = 0;
  61.                 m_TransRot.SetIdentity();
  62.         };
  63.  
  64. };
  65.  
  66. bool CheckNAN(const f32& f)
  67. {
  68.         return ((*(unsigned*)&(f)) & 0xff000000) != 0xff000000u && (*(unsigned*)&(f) != 0x7fc00000);
  69. }
  70.  
  71. bool CheckNANVec(Vec3& v, IEntity* pEntity)
  72. {
  73.         if (!CheckNAN(v.x) || !CheckNAN(v.y) || !CheckNAN(v.z))
  74.         {
  75.                 if (ICharacterInstance* pCharacter = pEntity->GetCharacter(0))
  76.                 {
  77.                         int numAnims = pCharacter->GetISkeletonAnim()->GetNumAnimsInFIFO(0);
  78.                         for (int i = 0; i < numAnims; ++i)
  79.                         {
  80.                                 const CAnimation& anim = pCharacter->GetISkeletonAnim()->GetAnimFromFIFO(0, i);
  81.                                 CryLogAlways("NAN on AnimationID:%d, model:%s, entity:%s", anim.GetAnimationId(), pCharacter->GetFilePath(), pEntity->GetName());
  82.                         }
  83.                 }
  84.  
  85.                 v.zero();
  86.                 return false;
  87.         }
  88.         return true;
  89. }
  90.  
  91. bool CheckNANVec(const Vec3& v, IEntity* pEntity)
  92. {
  93.         Vec3 v1(v);
  94.         return CheckNANVec(v1, pEntity);
  95. }
  96.  
  97. template<class T, class U> bool CloneBinary(T&& outInstance, U&& inInstance)
  98. {
  99.         return gEnv->pSystem->GetArchiveHost()->CloneBinary(Serialization::SStruct(std::forward<T>(outInstance)), Serialization::SStruct(std::forward<U>(inInstance)));
  100. }
  101.  
  102. struct SMannequinSettings
  103. {
  104.         string actionController;
  105.         string animDatabase1P;
  106.         string animDatabase3P;
  107.         string soundDatabase;
  108.         bool   useMannequinAGState;
  109. };
  110.  
  111. //! Initializes SMannequinSettings based on existing entity components.
  112. static SMannequinSettings RetrieveMannequinSettingsFromEntity(IEntity& entity)
  113. {
  114.         const auto pScriptComponent = entity.GetComponent<IEntityScriptComponent>();
  115.         if (pScriptComponent)
  116.         {
  117.                 const auto pScriptTable = pScriptComponent->GetScriptTable();
  118.                 if (pScriptTable)
  119.                 {
  120.                         if (pScriptTable->HaveValue("ActionController") || pScriptTable->HaveValue("fileActionController"))
  121.                         {
  122.                                 SMannequinSettings settings;
  123.  
  124.                                 if (!pScriptTable->GetValue("ActionController", settings.actionController))
  125.                                 {
  126.                                         pScriptTable->GetValue("fileActionController", settings.actionController);
  127.                                 }
  128.  
  129.                                 if (!pScriptTable->GetValue("AnimDatabase3P", settings.animDatabase3P))
  130.                                 {
  131.                                         pScriptTable->GetValue("fileAnimDatabase3P", settings.animDatabase3P);
  132.                                 }
  133.  
  134.                                 if (!pScriptTable->GetValue("AnimDatabase1P", settings.animDatabase1P))
  135.                                 {
  136.                                         pScriptTable->GetValue("fileAnimDatabase1P", settings.animDatabase1P);
  137.                                 }
  138.  
  139.                                 if (!pScriptTable->GetValue("SoundDatabase", settings.soundDatabase))
  140.                                 {
  141.                                         pScriptTable->GetValue("fileSoundDatabase", settings.soundDatabase);
  142.                                 }
  143.  
  144.                                 pScriptTable->GetValue("UseMannequinAGState", settings.useMannequinAGState);
  145.  
  146.                                 return settings;
  147.                         }
  148.                 }
  149.         }
  150.  
  151.         IEntityComponent* const pMannequinObject = entity.GetComponent<CMannequinObject>();
  152.         if (pMannequinObject)
  153.         {
  154.                 struct SEntityPropertyGroupSerialier
  155.                 {
  156.                         void Serialize(Serialization::IArchive& archive) { propertyGroup.SerializeProperties(archive); }
  157.  
  158.                         IEntityPropertyGroup& propertyGroup;
  159.                 };
  160.  
  161.                 struct SMannequinObjectPropertyGroupToMannequinSettingsSerializer
  162.                 {
  163.                         void Serialize(Serialization::IArchive& archive)
  164.                         {
  165.                                 archive(mannequinSettings.actionController, "actionController");
  166.                                 archive(mannequinSettings.animDatabase3P, "animationDatabase");
  167.  
  168.                                 if (archive.isInput())
  169.                                 {
  170.                                         mannequinSettings.animDatabase1P = "";
  171.                                         mannequinSettings.soundDatabase = "";
  172.                                         mannequinSettings.useMannequinAGState = false;
  173.                                 }
  174.                         }
  175.  
  176.                         SMannequinSettings& mannequinSettings;
  177.                 };
  178.  
  179.                 SMannequinSettings settings;
  180.                 CloneBinary(SMannequinObjectPropertyGroupToMannequinSettingsSerializer{ settings }, SEntityPropertyGroupSerialier{ *pMannequinObject->GetPropertyGroup() });
  181.                 return settings;
  182.         }
  183.  
  184.         return SMannequinSettings();
  185. }
  186.  
  187. } // anonymous namespace
  188.  
  189. namespace AC
  190. {
  191. void RegisterEvents(IGameObjectExtension& goExt, IGameObject& gameObject)
  192. {
  193.         const int eventToRegister[] =
  194.         {
  195.                 eGFE_QueueRagdollCreation,
  196.                 eGFE_OnCollision,
  197.                 eGFE_ResetAnimationGraphs,
  198.                 eGFE_QueueBlendFromRagdoll,
  199.                 eGFE_EnablePhysics,
  200.                 eGFE_DisablePhysics
  201.         };
  202.         gameObject.UnRegisterExtForEvents(&goExt, NULL, 0);
  203.         gameObject.RegisterExtForEvents(&goExt, eventToRegister, sizeof(eventToRegister) / sizeof(int));
  204. }
  205. }
  206.  
  207. CAnimatedCharacter::CAnimatedCharacter() : m_listeners(1)
  208. {
  209.         InitVars();
  210.  
  211.         m_debugHistoryManager = gEnv->pGameFramework->CreateDebugHistoryManager();
  212.  
  213.         CryCreateClassInstance("AnimationPoseAlignerC3", m_pPoseAligner);
  214. }
  215.  
  216. CAnimatedCharacter::~CAnimatedCharacter()
  217. {
  218.         SAFE_RELEASE(m_pMannequinAGState);
  219.  
  220.         if (m_debugHistoryManager)
  221.                 m_debugHistoryManager->Release();
  222.  
  223.         DisableRigidCollider();
  224.         DestroyExtraSolidCollider();
  225.  
  226.         CRY_ASSERT_MESSAGE(!m_pActionController, "ActionController should already be deleted. If not, the Exit of actions in the destructor could involve invalid objects.");
  227.         DeleteActionController();
  228. }
  229.  
  230. void CAnimatedCharacter::InitVars()
  231. {
  232.         m_fPrevInertia = 0.0f;
  233.         m_fPrevInertiaAccel = 0.0f;
  234.         m_fPrevTimeImpulseRecover = 0.0f;
  235.         m_facialAlertness = 0;
  236.         m_currentStance = -1;
  237.         m_requestedStance = -1;
  238.         m_stanceQuery = 0;
  239.         m_disallowLookIKFlags = 0;
  240.         m_allowAimIk = true;
  241.         m_curFrameID = -1;
  242.         m_lastResetFrameId = -1;
  243.         m_updateGrabbedInputFrameID = -1;
  244.         m_moveRequestFrameID = -1;
  245.         m_lastSerializeReadFrameID = 0;
  246.         m_lastPostProcessUpdateFrameID = 0;
  247.         m_lastAnimProcFrameID = 0;
  248.         m_shadowCharacterSlot = -1;
  249.         m_hasShadowCharacter = false;
  250.         m_bSimpleMovementSetOnce = false;
  251.         m_curWeaponRaisedPose = eWeaponRaisedPose_None;
  252.         m_isPlayer = false;
  253.         m_curFrameTime = 0.0f;
  254.         m_prevFrameTime = 0.0f;
  255.         m_curFrameTimeOriginal = 0.0f;
  256.         m_reqLocalEntAxxNextIndex = 0;
  257.         m_smoothedActualEntVelo = ZERO;
  258.         m_smoothedAmountAxx = 0.0f;
  259.         m_avgLocalEntAxx = ZERO;
  260.         m_requestedEntMoveDirLH4 = 0;
  261.         m_actualEntMoveDirLH4 = 0;
  262.         m_colliderMode = eColliderMode_Undefined;
  263.         m_simplifiedAGSpeedInputsRequested = false;
  264.         m_simplifiedAGSpeedInputsActual = false;
  265.         m_requestedEntityMovementType = RequestedEntMovementType_Undefined;
  266.         m_requestedIJump = 0;
  267.         m_bDisablePhysicalGravity = false;
  268.         m_simplifyMovement = false;
  269.         m_forceDisableSlidingContactEvents = false;
  270.         m_noMovementTimer = 0.0f;
  271.         m_actualEntSpeed = 0.0f;
  272.         m_actualEntSpeedHorizontal = 0.0f;
  273.         m_actualEntMovementDirHorizontal.zero();
  274.         m_actualEntVelocityHorizontal.zero();
  275.         m_actualEntAccelerationHorizontal.zero();
  276.         m_actualEntTangentialAcceleration = 0.0f;
  277.         m_actualEntMovement.SetIdentity();
  278.         m_entLocation.SetIdentity();
  279.         m_entTeleportMovement.SetIdentity();
  280.         m_pAnimTarget = NULL;
  281.         m_pCharacter = NULL;
  282.         m_pSkeletonAnim = NULL;
  283.         m_pSkeletonPose = NULL;
  284.         m_pShadowCharacter = NULL;
  285.         m_pShadowSkeletonAnim = NULL;
  286.         m_pShadowSkeletonPose = NULL;
  287.         m_wasInAir = false;
  288.         m_fallMaxHeight = 0.0f;
  289.         m_landBobTime = 0.0f;
  290.         m_totalLandBob = 0.0f;
  291.         m_noMovementOverrideExternal = false;
  292.         m_bAnimationGraphStatePaused = true;
  293.         m_fJumpSmooth = 1.0f;
  294.         m_fJumpSmoothRate = 1.0f;
  295.         m_fGroundSlopeMoveDirSmooth = 0.0f;
  296.         m_fGroundSlopeMoveDirRate = 0.0f;
  297.         m_fGroundSlope = 0.0f;
  298.         m_fGroundSlopeSmooth = 0.0f;
  299.         m_fGroundSlopeRate = 0.0f;
  300.         m_fRootHeightSmooth = 0.0f;
  301.         m_fRootHeightRate = 0.0f;
  302.         m_forcedRefreshColliderMode = false;
  303.         m_prevAnimPhaseHash = 0;
  304.         m_prevAnimEntOffsetHash = 0.0f;
  305.         m_prevMoveVeloHash = 0.0f;
  306.         m_prevMoveJump = 0;
  307.         m_collisionFrameID = -1;
  308.         m_collisionNormalCount = 0;
  309.         m_pFeetColliderPE = NULL;
  310.         m_debugHistoryManager = NULL;
  311.         m_pRigidColliderPE = NULL;
  312.         m_characterCollisionFlags = geom_colltype_player;
  313.         m_groundAlignmentParams.InitVars();
  314.         m_doMotionParams = true;
  315.         m_pAnimContext = NULL;
  316.         m_pActionController = NULL;
  317.         m_pAnimDatabase1P = NULL;
  318.         m_pAnimDatabase3P = NULL;
  319.         m_pSoundDatabase = NULL;
  320.         m_bPendingRagdoll = false;
  321.         m_pMannequinAGState = NULL;
  322.         m_proxiesInitialized = false;
  323.  
  324.         for (int layer = 0; layer < eAnimationGraphLayer_COUNT; ++layer)
  325.         {
  326.                 m_pAnimationPlayerProxies[layer] = &s_defaultAnimPlayerProxy;
  327.         }
  328.  
  329.         for (int slot = 0; slot < eMCMSlot_COUNT; ++slot)
  330.         {
  331.                 m_movementControlMethodTags[slot] = "InitVars";
  332.                 m_movementControlMethod[eMCMComponent_Horizontal][slot] = eMCM_Entity;
  333.                 m_movementControlMethod[eMCMComponent_Vertical][slot] = eMCM_Entity;
  334.         }
  335.         for (int slot = eMCMSlotStack_Begin; slot < eMCMSlotStack_End; ++slot)
  336.         {
  337.                 m_movementControlMethod[eMCMComponent_Horizontal][slot] = eMCM_Undefined;
  338.                 m_movementControlMethod[eMCMComponent_Vertical][slot] = eMCM_Undefined;
  339.         }
  340.         m_currentMovementControlMethodTags[eMCMComponent_Horizontal] = m_movementControlMethodTags[eMCMSlot_Cur];
  341.         m_currentMovementControlMethodTags[eMCMComponent_Vertical] = m_movementControlMethodTags[eMCMSlot_Cur];
  342.         m_elapsedTimeMCM[eMCMComponent_Horizontal] = 0.0f;
  343.         m_elapsedTimeMCM[eMCMComponent_Vertical] = 0.0f;
  344.  
  345.         for (int layer = 0; layer < eColliderModeLayer_COUNT; layer++)
  346.         {
  347.                 m_colliderModeLayersTag[layer] = "InitVars";
  348.                 m_colliderModeLayers[layer] = eColliderMode_Undefined;
  349.         }
  350.  
  351.         for (int i = 0; i < NumAxxSamples; i++)
  352.         {
  353.                 m_reqLocalEntAxx[i].zero();
  354.                 m_reqEntVelo[i].zero();
  355.                 m_reqEntTime[i].SetValue(0);
  356.         }
  357.  
  358.         m_fDesiredMoveSpeedSmoothQTX = 0;
  359.         m_fDesiredMoveSpeedSmoothRateQTX = 0;
  360.         m_fDesiredTurnSpeedSmoothQTX = 0;
  361.         m_fDesiredTurnSpeedSmoothRateQTX = 0;
  362.         m_fDesiredStrafeSmoothQTX = Vec2(0, 0);
  363.         m_fDesiredStrafeSmoothRateQTX = Vec2(0, 0);
  364.  
  365.         m_collisionNormal[0].zero();
  366.         m_collisionNormal[1].zero();
  367.         m_collisionNormal[2].zero();
  368.         m_collisionNormal[3].zero();
  369.  
  370.         m_lastAnimationUpdateFrameId = 0;
  371.         m_inGrabbedState = false;
  372.  
  373.         m_hasForcedMovement = false;
  374.         m_forcedMovementRelative.SetIdentity();
  375.  
  376.         m_hasForcedOverrideRotation = false;
  377.         m_forcedOverrideRotationWorld.SetIdentity();
  378.  
  379.         m_useMannequinAGState = false;
  380. }
  381.  
  382. bool CAnimatedCharacter::Init(IGameObject* pGameObject)
  383. {
  384. #ifdef ANIMCHAR_MEM_DEBUG
  385.         CCryAction::GetCryAction()->DumpMemInfo("CAnimatedCharacter::Init %p start", pGameObject);
  386. #endif
  387.  
  388.         SetGameObject(pGameObject);
  389.  
  390.         InitializeMannequin();
  391.  
  392. #ifdef ANIMCHAR_MEM_DEBUG
  393.         CCryAction::GetCryAction()->DumpMemInfo("CAnimatedCharacter::Init %p end", pGameObject);
  394. #endif
  395.  
  396.         return true;
  397. }
  398.  
  399. void CAnimatedCharacter::PostInit(IGameObject* pGameObject)
  400. {
  401.         AC::RegisterEvents(*this, *pGameObject);
  402.  
  403.         m_pComponentPrepareCharForUpdate = GetEntity()->GetOrCreateComponentClass<CAnimatedCharacterComponent_PrepareAnimatedCharacterForUpdate>();
  404.         m_pComponentPrepareCharForUpdate->SetAnimatedCharacter(this);
  405.        
  406.         auto componentMoveRequest = GetEntity()->GetOrCreateComponentClass<CAnimatedCharacterComponent_GenerateMoveRequest>();
  407.         componentMoveRequest->SetAnimatedCharacter(this);
  408.  
  409.         auto componentStartAnimProc = GetEntity()->GetOrCreateComponentClass<CAnimatedCharacterComponent_StartAnimProc>();
  410.         componentStartAnimProc->SetAnimatedCharacter(this);
  411.  
  412.         m_proxiesInitialized = true;
  413.  
  414.         pGameObject->EnableUpdateSlot(this, 0);
  415.         pGameObject->SetUpdateSlotEnableCondition(this, 0, eUEC_Visible);
  416.         pGameObject->EnablePhysicsEvent(true, eEPE_OnCollisionLogged);
  417. }
  418.  
  419. bool CAnimatedCharacter::ReloadExtension(IGameObject* pGameObject, const SEntitySpawnParams& params)
  420. {
  421. #ifdef ANIMCHAR_MEM_DEBUG
  422.         CCryAction::GetCryAction()->DumpMemInfo("CAnimatedCharacter::ReloadExtension %p start", pGameObject);
  423. #endif
  424.  
  425.         AC::RegisterEvents(*this, *pGameObject);
  426.         ResetGameObject();
  427.         ResetInertiaCache();
  428.  
  429.         SAFE_RELEASE(m_pMannequinAGState);
  430.  
  431.         for (int layer = 0; layer < eAnimationGraphLayer_COUNT; ++layer)
  432.         {
  433.                 m_pAnimationPlayerProxies[layer] = &s_defaultAnimPlayerProxy;
  434.         }
  435.  
  436.         InitializeMannequin();
  437.  
  438. #ifdef ANIMCHAR_MEM_DEBUG
  439.         CCryAction::GetCryAction()->DumpMemInfo("CAnimatedCharacter::ReloadExtension %p end", pGameObject);
  440. #endif
  441.  
  442.         m_pComponentPrepareCharForUpdate->ClearQueuedRotation();
  443.  
  444.         return true;
  445. }
  446.  
  447. bool CAnimatedCharacter::InitializeMannequin()
  448. {
  449.         SMannequinSettings mannequinSetup = RetrieveMannequinSettingsFromEntity(*GetEntity());
  450.         if (mannequinSetup.actionController.empty())
  451.         {
  452.                 return false;
  453.         }
  454.  
  455.         DeleteActionController();
  456.         SetActionController(mannequinSetup.actionController);
  457.         if (m_pActionController)
  458.         {
  459.                 IMannequin& mannequinSys = gEnv->pGameFramework->GetMannequinInterface();
  460.                 m_pAnimDatabase3P = mannequinSys.GetAnimationDatabaseManager().Load(mannequinSetup.animDatabase3P);
  461.                 m_pAnimDatabase1P = mannequinSys.GetAnimationDatabaseManager().Load(mannequinSetup.animDatabase1P);
  462.                 m_pSoundDatabase = mannequinSys.GetAnimationDatabaseManager().Load(mannequinSetup.soundDatabase);
  463.         }
  464.  
  465.         m_useMannequinAGState = mannequinSetup.useMannequinAGState;
  466.         if (m_useMannequinAGState)
  467.         {
  468.                 CRY_ASSERT(m_pActionController);
  469.  
  470.                 m_pMannequinAGState = new MannequinAG::CMannequinAGState();
  471.                 m_pMannequinAGState->SetAnimatedCharacter(this, 0, NULL);
  472.                 m_pMannequinAGState->AddListener("animchar", this);
  473.         }
  474.  
  475.         ResetVars();
  476.  
  477.         return true;
  478. }
  479.  
  480. void CAnimatedCharacter::Release()
  481. {
  482.         delete this;
  483. }
  484.  
  485. void CAnimatedCharacter::FullSerialize(TSerialize ser)
  486. {
  487.         MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "Animated character serialization");
  488.  
  489. #define SerializeMember(member)                    ser.Value( # member, member)
  490. #define SerializeMemberType(type, member)          { type temp = member; ser.Value( # member, temp); if (isReading) member = temp; }
  491. #define SerializeNamedType(type, name, type2, var) { type temp = var; ser.Value(name, temp); if (isReading) var = (type2)temp; }
  492.  
  493.         bool isReading = ser.IsReading();
  494.  
  495.         if (isReading)
  496.                 m_lastSerializeReadFrameID = m_curFrameID;
  497.         /*gEnv->pRenderer->GetFrameID()*/;
  498.  
  499.         // TODO: Find out what defines an inactive character and what can be safely omitted in that case.
  500.         // Is it safe to ignore inactive entities? Don't they have any active information?
  501.         bool bEntityActive = true; //GetEntity()->IsActive();
  502.         if (!ser.BeginOptionalGroup("AnimatedCharacter", bEntityActive))
  503.                 return;
  504.  
  505.         if (isReading)
  506.                 ResetVars();
  507.  
  508.         SerializeMember(m_shadowCharacterSlot);
  509.         SerializeMember(m_hasShadowCharacter);
  510.  
  511.         SerializeMember(m_prevEntLocation.t);
  512.         SerializeMember(m_prevEntLocation.q);
  513.  
  514.         SerializeMember(m_actualEntMovement.t);
  515.         SerializeMember(m_actualEntMovement.q);
  516.  
  517.         SerializeMember(m_actualEntSpeed);
  518.         SerializeMember(m_actualEntSpeedHorizontal);
  519.         if (isReading)
  520.         {
  521.                 m_actualEntMovementDirHorizontal = Vec2(m_actualEntMovement.t).GetNormalizedSafe(Vec2Constants<float>::fVec2_Zero);
  522.                 m_actualEntVelocityHorizontal = m_actualEntMovementDirHorizontal * m_actualEntSpeedHorizontal;
  523.         }
  524.         SerializeMember(m_actualEntAccelerationHorizontal);
  525.  
  526.         SerializeMember(m_requestedEntityMovement.t);
  527.         SerializeMember(m_requestedEntityMovement.q);
  528.  
  529.         if (m_pMannequinAGState)
  530.                 m_pMannequinAGState->Serialize(ser);
  531.  
  532.         if (isReading)
  533.                 ResetInertiaCache();
  534.  
  535.         SerializeMember(m_currentStance);
  536.  
  537.         SerializeMember(m_disallowLookIKFlags);
  538.         SerializeMemberType(bool, m_allowAimIk);
  539.  
  540.         RefreshAnimTarget();
  541.         bool bTemp = m_groundAlignmentParams.IsFlag(eGA_Enable);
  542.         ser.Value("m_enableGroundAlignment", bTemp);
  543.         m_groundAlignmentParams.SetFlag(eGA_Enable, bTemp);
  544.  
  545.         string cml("m_colliderModeLayer");
  546.         for (int layer = 0; layer < eColliderModeLayer_COUNT; layer++)
  547.         {
  548.                 uint32 tempVal = m_colliderModeLayers[layer];
  549.                 ser.Value(cml + g_szColliderModeLayerString[layer], tempVal);
  550.                 m_colliderModeLayers[layer] = EColliderMode(tempVal);
  551.         }
  552.  
  553.         char mcm[32] = "m_movementControlMethod";
  554.         static const int basicStringLength = 23;
  555.         assert(strlen(mcm) == basicStringLength);
  556.         for (int slot = 0; slot < eMCMSlot_COUNT; ++slot)
  557.         {
  558.                 mcm[basicStringLength] = 'H';
  559.                 itoa(slot, &mcm[basicStringLength + 1], 10);
  560.                 SerializeNamedType(uint8, mcm, EMovementControlMethod, m_movementControlMethod[eMCMComponent_Horizontal][slot]);
  561.  
  562.                 mcm[basicStringLength] = 'V';
  563.                 itoa(slot, &mcm[basicStringLength + 1], 10);
  564.                 SerializeNamedType(uint8, mcm, EMovementControlMethod, m_movementControlMethod[eMCMComponent_Vertical][slot]);
  565.         }
  566.         ser.Value("m_elapsedTimeMCM_Horizontal", m_elapsedTimeMCM[eMCMComponent_Horizontal]);
  567.         ser.Value("m_elapsedTimeMCM_Vertical", m_elapsedTimeMCM[eMCMComponent_Vertical]);
  568.  
  569.         ser.EndGroup(); //AnimatedCharacter
  570. }
  571.  
  572. void CAnimatedCharacter::PostSerialize()
  573. {
  574.         if (m_hasShadowCharacter)
  575.         {
  576.                 InitShadowCharacter();
  577.         }
  578. }
  579.  
  580. void CAnimatedCharacter::Update(SEntityUpdateContext& ctx, int slot)
  581. {
  582.         FUNCTION_PROFILER(GetISystem(), PROFILE_ACTION);
  583.  
  584.         //assert(!m_simplifyMovement); // If we have simplified movement, the this GameObject extension should not be updated here.
  585.  
  586.         assert(m_entLocation.IsValid());
  587.         //assert(m_colliderModeLayers[eColliderModeLayer_ForceSleep] == eColliderMode_Undefined);
  588.  
  589.         if (m_simplifyMovement)
  590.         {
  591.                 GetCurrentEntityLocation();
  592.         }
  593.  
  594.         float EntRotZ = RAD2DEG(m_entLocation.q.GetRotZ());
  595.  
  596.         assert(m_entLocation.IsValid());
  597.  
  598.         SetAnimationPostProcessParameters();
  599.  
  600.         assert(m_entLocation.IsValid());
  601.  
  602.         /*
  603.            This code which was around here is highly suspect; I suggest we fix 'standing on moving platforms' in a better way
  604.  
  605.            if (GetMCMV() == eMCM_SmoothedEntity)
  606.            {
  607.            static float elevationBlendDuration = 0.1f;
  608.            float elevationBlend = clamp_tpl((float)m_curFrameTime / elevationBlendDuration, 0.0f, 1.0f);
  609.  
  610.            // Blend out vertical lag when not moving (e.g. standing still on a vertically moving platform).
  611.            float velocityFractionH = clamp_tpl(m_actualEntSpeedHorizontal / 0.1f, 0.0f, 1.0f);
  612.            elevationBlend = LERP(1.0f, elevationBlend, velocityFractionH);
  613.  
  614.            // Blend out vertical lag when not moving (e.g. standing still on a vertically moving platform).
  615.            float prevFrameTimeInv = ((float)m_prevFrameTime > 0.0f) ? (1.0f / (float)m_prevFrameTime) : 0.0f;
  616.            float actualEntVelocityZ = m_actualEntMovement.t.z * prevFrameTimeInv;
  617.            float velocityFractionZ = clamp_tpl(actualEntVelocityZ / 1.0f, 0.0f, 1.0f);
  618.            elevationBlend = LERP(elevationBlend, 1.0f, velocityFractionZ);
  619.  
  620.            m_animLocation.q = animLocationClamped.q;
  621.            m_animLocation.t.x = animLocationClamped.t.x;
  622.            m_animLocation.t.y = animLocationClamped.t.y;
  623.            m_animLocation.t.z = LERP(m_animLocation.t.z, animLocationClamped.t.z, elevationBlend);
  624.            }
  625.          */
  626.  
  627.         assert(m_entLocation.IsValid());
  628.  
  629.         /*
  630.            CRYANIMATION2
  631.  
  632.            Broke procedural leaning. The animrenderlocation used to contain the procedural leaning factor:
  633.  
  634.            if (EnableProceduralLeaning()
  635.            && ((m_pAnimTarget == NULL) || (!m_pAnimTarget->activated))
  636.            && ((GetMCMH() == eMCM_DecoupledCatchUp) || CAnimationGraphCVars::Get().m_nonDecoupledLeaning)) // This was added to primarily prevent deviation while parachuting.
  637.            {
  638.            QuatT proceduralLeaning = CalculateProceduralLeaning();
  639.            animRenderLocation = animRenderLocation * proceduralLeaning;
  640.            }
  641.          */
  642.  
  643.         VALIDATE_CHARACTER_PTRS
  644.  
  645.           DebugRenderCurLocations();
  646.  
  647. #ifdef _DEBUG
  648.         DebugGraphQT(m_entLocation, "eDH_EntLocationPosX", "eDH_EntLocationPosY", "eDH_EntLocationOriZ");
  649.  
  650.         //DebugDisplayNewLocationsAndMovements(wantedEntLocationClamped, wantedEntMovement, wantedAnimLocationClamped, wantedAnimMovement, m_curFrameTime);
  651. #endif
  652. }
  653.  
  654. void CAnimatedCharacter::ForceRefreshPhysicalColliderMode()
  655. {
  656.         m_forcedRefreshColliderMode = true;
  657. }
  658.  
  659. void CAnimatedCharacter::RequestPhysicalColliderMode(EColliderMode mode, EColliderModeLayer layer, const char* tag /* = NULL */)
  660. {
  661.         bool update = (m_colliderModeLayers[layer] != mode);
  662.         if (update || m_forcedRefreshColliderMode)
  663.         {
  664.                 m_colliderModeLayersTag[layer] = tag;
  665.                 m_colliderModeLayers[layer] = mode;
  666.                 UpdatePhysicalColliderMode();
  667.         }
  668. }
  669.  
  670. void CAnimatedCharacter::HandleEvent(const SGameObjectEvent& event)
  671. {
  672.         switch (event.event)
  673.         {
  674.         case eGFE_QueueBlendFromRagdoll:
  675.                 SetBlendFromRagdollizeParams(event);
  676.                 break;
  677.         case eGFE_QueueRagdollCreation:
  678.                 SetRagdollizeParams(event);
  679.                 break;
  680.         case eGFE_OnCollision:
  681.                 {
  682.                         const EventPhysCollision* pCollision = static_cast<const EventPhysCollision*>(event.ptr);
  683.  
  684.                         // Ignore bullets and insignificant particles, etc.
  685.                         // TODO: This early-out condition should ideally be done on a higher level,
  686.                         // to avoid even touching this memory for all bullets and stuff.
  687.                         if (pCollision->pEntity[0]->GetType() == PE_PARTICLE)
  688.                                 break;
  689.  
  690.                         if (m_curFrameID > m_collisionFrameID)
  691.                         {
  692.                                 m_collisionNormalCount = 0;
  693.                                 m_collisionNormal[0].zero();
  694.                                 m_collisionNormal[1].zero();
  695.                                 m_collisionNormal[2].zero();
  696.                                 m_collisionNormal[3].zero();
  697.                         }
  698.  
  699.                         if ((m_curFrameID < m_collisionFrameID) || (m_collisionNormalCount >= 4) || (m_curFrameID <= 10))
  700.                                 break;
  701.  
  702.                         // Both entities in a collision recieve the same direction of the normal.
  703.                         // We need to flip the normal if this is the second entity.
  704.                         IPhysicalEntity* pPhysEnt = GetEntity()->GetPhysics();
  705.                         if (pPhysEnt == pCollision->pEntity[0])
  706.                                 m_collisionNormal[m_collisionNormalCount] = pCollision->n;
  707.                         else if (pPhysEnt == pCollision->pEntity[1])
  708.                                 m_collisionNormal[m_collisionNormalCount] = -pCollision->n;
  709.                         /*
  710.                               // This might happen for faked collisions, such as punches.
  711.                               else
  712.                                 assert(!"Entity recieved collision event without being part of collision!");
  713.                          */
  714.                         // We only care about the horizontal part, so we remove the vertical component for simplicity.
  715.                         m_collisionNormal[m_collisionNormalCount].z = 0.0f;
  716.                         if (!m_collisionNormal[m_collisionNormalCount].IsZero())
  717.                         {
  718.                                 m_collisionNormal[m_collisionNormalCount].Normalize();
  719.  
  720. #if _DEBUG && defined(USER_david)
  721.                                 CPersistantDebug* pPD = CCryAction::GetCryAction()->GetPersistantDebug();
  722.                                 if ((pPD != NULL) && true)
  723.                                 {
  724.                                         pPD->Begin(UNIQUE("AnimatedCharacter.HandleEvent.CollisionNormal"), false);
  725.                                         pPD->AddSphere(pCollision->pt, 0.02f, ColorF(1, 0.75f, 0.0f, 1), 0.1f);
  726.                                         pPD->AddLine(pCollision->pt, pCollision->pt + m_collisionNormal[m_collisionNormalCount] * 0.5f, ColorF(1, 0.75f, 0.0f, 1), 0.1f);
  727.                                 }
  728. #endif
  729.  
  730.                                 m_collisionFrameID = m_curFrameID;
  731.                                 m_collisionNormalCount++;
  732.  
  733.                         }
  734.                 }
  735.                 break;
  736.  
  737.         case eGFE_ResetAnimationGraphs:
  738.                 if (m_pMannequinAGState)
  739.                         m_pMannequinAGState->Reset();
  740.                 break;
  741.         case eGFE_EnablePhysics:
  742.                 RequestPhysicalColliderMode(eColliderMode_Undefined, eColliderModeLayer_ForceSleep, "eGFE_EnablePhysics");
  743.                 break;
  744.         case eGFE_DisablePhysics:
  745.                 RequestPhysicalColliderMode(eColliderMode_Disabled, eColliderModeLayer_ForceSleep, "eGFE_DisablePhysics");
  746.                 break;
  747.         }
  748.         // AnimationControlled/GameControlled: DEPRECATED in favor of MovementControlMethod controlled by AnimGraph.
  749. }
  750.  
  751. void CAnimatedCharacter::ResetInertiaCache()
  752. {
  753.         // Synch our cached inertia values with the living entity values
  754.         pe_player_dynamics dynParams;
  755.         IPhysicalEntity* pPhysEnt = GetEntity()->GetPhysics();
  756.         if (pPhysEnt && pPhysEnt->GetParams(&dynParams))
  757.         {
  758.                 m_fPrevInertia = dynParams.kInertia;
  759.                 m_fPrevInertiaAccel = dynParams.kInertiaAccel;
  760.                 m_fPrevTimeImpulseRecover = dynParams.timeImpulseRecover;
  761.         }
  762. }
  763.  
  764. void CAnimatedCharacter::ResetState()
  765. {
  766.         if (m_pMannequinAGState)
  767.                 m_pMannequinAGState->Reset();
  768.  
  769.         if (m_pActionController)
  770.                 m_pActionController->Reset();
  771.         ResetVars();
  772.         ResetInertiaCache();
  773. }
  774.  
  775. void CAnimatedCharacter::ResetVars()
  776. {
  777.         IEntity* pEntity = GetEntity();
  778.         assert(pEntity);
  779.  
  780.         m_params.Reset();
  781.  
  782.         m_facialAlertness = 0;
  783.  
  784.         m_currentStance = -1;
  785.         m_requestedStance = -1;
  786.         m_stanceQuery = 0;
  787.  
  788.         m_disallowLookIKFlags = 0;
  789.         m_allowAimIk = true;
  790.  
  791.         // Why -1, why not 0?
  792.         m_curFrameID = -1;
  793.         m_lastResetFrameId = gEnv->nMainFrameID;
  794.         m_updateGrabbedInputFrameID = -1;
  795.         m_moveRequestFrameID = -1;
  796.         m_lastSerializeReadFrameID = 0;
  797.         m_lastPostProcessUpdateFrameID = 0;
  798.         m_lastAnimProcFrameID = 0;
  799.  
  800.         m_shadowCharacterSlot = -1;
  801.         m_hasShadowCharacter = false;
  802.  
  803.         m_bSimpleMovementSetOnce = false;
  804.  
  805.         m_curWeaponRaisedPose = eWeaponRaisedPose_None;
  806.  
  807.         m_moveRequest.type = eCMT_None;
  808.         m_moveRequest.velocity.zero();
  809.         m_moveRequest.rotation.SetIdentity();
  810.         m_moveRequest.prediction.Reset();
  811.         m_moveRequest.jumping = false;
  812.         m_moveRequest.allowStrafe = false;
  813.         m_moveRequest.proceduralLeaning = false;
  814.  
  815.         m_inGrabbedState = false;
  816.  
  817.         m_groundAlignmentParams.InitVars();
  818.  
  819.         // Init IK Disable Distance to the CVar value if specified.
  820.         const float ikDisableDistance = CAnimationGraphCVars::Get().m_distanceForceNoIk;
  821.         m_groundAlignmentParams.ikDisableDistanceSqr = (float)__fsel(-ikDisableDistance, m_groundAlignmentParams.ikDisableDistanceSqr, sqr(ikDisableDistance));
  822.  
  823.         m_isPlayer = false;
  824.         if (pEntity)
  825.         {
  826.                 IActorSystem* pActorSystem = CCryAction::GetCryAction()->GetIActorSystem();
  827.                 assert(pActorSystem != NULL);
  828.                 IActor* pActor = pActorSystem->GetActor(pEntity->GetId());
  829.  
  830.                 //No longer asserting, as the animated character is no longer just used on actors
  831.                 if (pActor != NULL)
  832.                 {
  833.                         m_isPlayer = pActor->IsPlayer();
  834.  
  835.                         // Turn on by default for 3rd person in singleplayer.
  836.                         m_groundAlignmentParams.SetFlag(eGA_PoseAlignerUseRootOffset, pActor->IsThirdPerson() && !gEnv->bMultiplayer);
  837.                 }
  838.         }
  839.  
  840.         m_curFrameStartTime.SetValue(0);
  841.  
  842.         m_curFrameTime = 0.0f;
  843.         m_prevFrameTime = 0.0f;
  844.         m_curFrameTimeOriginal = 0.0f;
  845.  
  846.         if (pEntity)
  847.         {
  848.                 m_entLocation.t = pEntity->GetWorldPos();
  849.                 m_entLocation.q = pEntity->GetWorldRotation();
  850.  
  851.                 m_prevEntLocation = m_entLocation;
  852.         }
  853.         else
  854.         {
  855.                 m_entLocation.SetIdentity();
  856.                 m_prevEntLocation.SetIdentity();
  857.         }
  858.  
  859.         m_expectedEntMovement.zero();
  860.         m_actualEntMovement.SetIdentity();
  861.         m_entTeleportMovement.SetIdentity();
  862.  
  863.         for (int i = 0; i < NumAxxSamples; i++)
  864.         {
  865.                 m_reqLocalEntAxx[i].zero();
  866.                 m_reqEntVelo[i].zero();
  867.                 m_reqEntTime[i].SetValue(0);
  868.         }
  869.         m_reqLocalEntAxxNextIndex = 0;
  870.         m_smoothedActualEntVelo.zero();
  871.         m_smoothedAmountAxx = 0.0f;
  872.         m_avgLocalEntAxx.zero();
  873.  
  874.         m_requestedEntMoveDirLH4 = 0;
  875.         m_actualEntMoveDirLH4 = 0;
  876.  
  877.         for (int slot = 0; slot < eMCMSlot_COUNT; ++slot)
  878.         {
  879.                 m_movementControlMethodTags[slot] = "ResetVars";
  880.                 m_movementControlMethod[eMCMComponent_Horizontal][slot] = eMCM_Entity;
  881.                 m_movementControlMethod[eMCMComponent_Vertical][slot] = eMCM_Entity;
  882.         }
  883.         for (int slot = eMCMSlotStack_Begin; slot < eMCMSlotStack_End; ++slot)
  884.         {
  885.                 m_movementControlMethod[eMCMComponent_Horizontal][slot] = eMCM_Undefined;
  886.                 m_movementControlMethod[eMCMComponent_Vertical][slot] = eMCM_Undefined;
  887.         }
  888.         m_currentMovementControlMethodTags[eMCMComponent_Horizontal] = m_movementControlMethodTags[eMCMSlot_Cur];
  889.         m_currentMovementControlMethodTags[eMCMComponent_Vertical] = m_movementControlMethodTags[eMCMSlot_Cur];
  890.         m_elapsedTimeMCM[eMCMComponent_Horizontal] = 0.0f;
  891.         m_elapsedTimeMCM[eMCMComponent_Vertical] = 0.0f;
  892.  
  893.         for (int layer = 0; layer < eColliderModeLayer_COUNT; layer++)
  894.         {
  895.                 m_colliderModeLayersTag[layer] = "ResetVars";
  896.                 m_colliderModeLayers[layer] = eColliderMode_Undefined;
  897.         }
  898.         m_colliderMode = eColliderMode_Undefined;
  899.  
  900.         m_simplifiedAGSpeedInputsRequested = false;
  901.         m_simplifiedAGSpeedInputsActual = false;
  902.  
  903.         m_requestedEntityMovement.SetIdentity();
  904.         m_requestedEntityMovementType = RequestedEntMovementType_Undefined;
  905.         m_requestedIJump = 0;
  906.         m_bDisablePhysicalGravity = false;
  907.  
  908.         m_simplifyMovement = false;
  909.         m_forceDisableSlidingContactEvents = false;
  910.         m_noMovementTimer = 0.0f;
  911.  
  912.         m_actualEntSpeed = 0.0f;
  913.         m_actualEntSpeedHorizontal = 0.0f;
  914.         m_actualEntMovementDirHorizontal.zero();
  915.         m_actualEntVelocityHorizontal.zero();
  916.         m_actualEntAccelerationHorizontal.zero();
  917.         m_actualEntTangentialAcceleration = 0.0f;
  918.  
  919.         m_pAnimTarget = NULL;
  920.         m_pCharacter = NULL;
  921.         m_pSkeletonAnim = NULL;
  922.         m_pSkeletonPose = NULL;
  923.         m_pShadowCharacter = NULL;
  924.         m_pShadowSkeletonAnim = NULL;
  925.         m_pShadowSkeletonPose = NULL;
  926.  
  927.         m_wasInAir = false;
  928.         m_fallMaxHeight = 0.0f;
  929.         m_landBobTime = 0.0f;
  930.         m_totalLandBob = 0.0f;
  931.  
  932.         m_noMovementOverrideExternal = false;
  933.  
  934.         m_fJumpSmooth = 1.0f;
  935.         m_fJumpSmoothRate = 1.0f;
  936.         m_fGroundSlopeMoveDirSmooth = 0.0f;
  937.         m_fGroundSlopeMoveDirRate = 0.0f;
  938.         m_fGroundSlope = 0.0f;
  939.         m_fGroundSlopeSmooth = 0.0f;
  940.         m_fGroundSlopeRate = 0.0f;
  941.         m_fRootHeightSmooth = 0.0f;
  942.         m_fRootHeightRate = 0.0f;
  943.  
  944.         m_forcedRefreshColliderMode = false;
  945.         m_bPendingRagdoll = false;
  946.         m_ragdollParams = SRagdollizeParams();
  947.  
  948.         m_prevAnimPhaseHash = 0;
  949.         m_prevAnimEntOffsetHash = 0.0f;
  950.         m_prevMoveVeloHash = 0.0f;
  951.         m_prevMoveJump = 0;
  952.  
  953.         m_moveOverride_useAnimXY = false;
  954.         m_moveOverride_useAnimZ = false;
  955.         m_moveOverride_useAnimRot = false;
  956.  
  957.         m_collisionFrameID = -1;
  958.         m_collisionNormalCount = 0;
  959.         m_collisionNormal[0].zero();
  960.         m_collisionNormal[1].zero();
  961.         m_collisionNormal[2].zero();
  962.         m_collisionNormal[3].zero();
  963.  
  964.         if (m_pFeetColliderPE)
  965.         {
  966.                 gEnv->pPhysicalWorld->DestroyPhysicalEntity(m_pFeetColliderPE);
  967.                 m_pFeetColliderPE = NULL;
  968.         }
  969.  
  970.         DisableRigidCollider();
  971.  
  972.         if (m_debugHistoryManager)
  973.                 m_debugHistoryManager->Clear();
  974.  
  975.         if (pEntity)
  976.         {
  977.                 // Disable physics as default when reviving/resetting characters.
  978.                 // Only a few frames after reset will non-disabled collider be allowed in UpdatePhysicalColliderMode().
  979.                 IPhysicalEntity* pPhysEnt = pEntity->GetPhysics();
  980.                 if (pPhysEnt)
  981.                 {
  982.                         pe_player_dynamics pd;
  983.                         pe_params_part pp;
  984.                         pd.bActive = 0;
  985.                         pp.flagsAND = ~(m_characterCollisionFlags);
  986.                         pPhysEnt->SetParams(&pd);
  987.                         pPhysEnt->SetParams(&pp);
  988.                 }
  989.         }
  990.  
  991.         DestroyExtraSolidCollider();
  992.  
  993.         m_hasForcedMovement = false;
  994.         m_forcedMovementRelative.SetIdentity();
  995.         m_hasForcedOverrideRotation = false;
  996.         m_forcedOverrideRotationWorld.SetIdentity();
  997.  
  998.         if (m_proxiesInitialized)
  999.         {
  1000.                 m_pComponentPrepareCharForUpdate->ClearQueuedRotation();
  1001.         }
  1002. }
  1003.  
  1004. void CAnimatedCharacter::SetOutput(const char* output, const char* value)
  1005. {
  1006. }
  1007.  
  1008. void CAnimatedCharacter::QueryComplete(TAnimationGraphQueryID queryID, bool succeeded)
  1009. {
  1010.         if (queryID == m_stanceQuery)
  1011.         {
  1012.                 if (succeeded)
  1013.                         m_currentStance = m_requestedStance;
  1014.                 else
  1015.                         CryLog("CAnimatedCharacter::QueryComplete: failed setting stance %d on %s", m_requestedStance, GetEntity()->GetName());
  1016.                 m_requestedStance = -1;
  1017.                 m_stanceQuery = 0;
  1018.         }
  1019. }
  1020.  
  1021. void CAnimatedCharacter::AddMovement(const SCharacterMoveRequest& request)
  1022. {
  1023.         if (request.type != eCMT_None)
  1024.         {
  1025.                 assert(request.rotation.IsValid());
  1026.                 assert(request.velocity.IsValid());
  1027.  
  1028.                 CheckNANVec(Vec3(request.velocity), GetEntity());
  1029.  
  1030.                 // we should have processed a move request before adding a new one
  1031.                 m_moveRequest = request;
  1032.                 m_moveRequestFrameID = gEnv->nMainFrameID;
  1033.  
  1034.                 assert(m_moveRequest.rotation.IsValid());
  1035.                 assert(m_moveRequest.velocity.IsValid());
  1036.         }
  1037.         else
  1038.         {
  1039.                 m_moveRequest.type = eCMT_None;
  1040.                 m_moveRequest.velocity.zero();
  1041.                 m_moveRequest.rotation.SetIdentity();
  1042.                 m_moveRequest.prediction.Reset();
  1043.                 m_moveRequest.jumping = false;
  1044.                 m_moveRequest.allowStrafe = false;
  1045.                 m_moveRequest.proceduralLeaning = false;
  1046.         }
  1047. }
  1048.  
  1049. //////////////////////////////////////////////////////////////////////////
  1050. void CAnimatedCharacter::ValidateCharacterPtrs()
  1051. {
  1052.         ICharacterInstance* pCharacter = GetEntity()->GetCharacter(0);
  1053.         ICharacterInstance* pShadowCharacter = m_hasShadowCharacter ? GetEntity()->GetCharacter(m_shadowCharacterSlot) : NULL;
  1054.  
  1055.         const bool characterChanged = (pCharacter != m_pCharacter) || (m_pShadowCharacter != pShadowCharacter);
  1056.         CRY_ASSERT_TRACE(!characterChanged, ("CharacterPtrs out of date in %s. Ensure that updateCharacterPtrs is called on the animatedCharacter whenever new models are loaded", GetEntity()->GetName()));
  1057. }
  1058.  
  1059. //////////////////////////////////////////////////////////////////////////
  1060. void CAnimatedCharacter::UpdateCharacterPtrs()
  1061. {
  1062.         // TODO: OPT: These three will not change often (if ever), so they can be cached over many frames.
  1063.         // TODO: Though, make sure that they are refreshed if/when they actually DO change.
  1064.         ICharacterInstance* pCharacter = GetEntity()->GetCharacter(0);
  1065.         ICharacterInstance* pShadowCharacter = m_hasShadowCharacter ? GetEntity()->GetCharacter(m_shadowCharacterSlot) : NULL;
  1066.  
  1067.         const bool characterChanged = (pCharacter != m_pCharacter) || (m_pShadowCharacter != pShadowCharacter);
  1068.  
  1069.         m_pCharacter = pCharacter;
  1070.         m_pShadowCharacter = pShadowCharacter;
  1071.  
  1072.         if (characterChanged)
  1073.         {
  1074.                 m_pSkeletonAnim = (m_pCharacter != NULL) ? m_pCharacter->GetISkeletonAnim() : NULL;
  1075.                 m_pSkeletonPose = (m_pCharacter != NULL) ? m_pCharacter->GetISkeletonPose() : NULL;
  1076.  
  1077.                 m_pShadowSkeletonAnim = (m_pShadowCharacter != NULL) ? m_pShadowCharacter->GetISkeletonAnim() : NULL;
  1078.                 m_pShadowSkeletonPose = (m_pShadowCharacter != NULL) ? m_pShadowCharacter->GetISkeletonPose() : NULL;
  1079.  
  1080.                 DisableEntitySystemCharacterUpdate();
  1081.                 UpdateSkeletonSettings();
  1082.         }
  1083.  
  1084.         if (m_pActionController)
  1085.         {
  1086.                 IActor* pActor = CCryAction::GetCryAction()->GetIActorSystem()->GetActor(GetEntityId());
  1087.                 const bool isFirstPerson = pActor && (pActor->IsThirdPerson() == false);
  1088.  
  1089.                 if (characterChanged || (isFirstPerson != m_lastACFirstPerson))
  1090.                 {
  1091.                         m_lastACFirstPerson = isFirstPerson;
  1092.  
  1093.                         const int scopeContextSound = m_pActionController->GetContext().controllerDef.m_scopeContexts.Find("Audio");
  1094.                         const int scopeContext1P = m_pActionController->GetContext().controllerDef.m_scopeContexts.Find("Char1P");
  1095.                         const int scopeContext3P = m_pActionController->GetContext().controllerDef.m_scopeContexts.Find("Char3P");
  1096.  
  1097.                         if (scopeContextSound >= 0 && m_pSoundDatabase)
  1098.                         {
  1099.                                 m_pActionController->SetScopeContext(scopeContextSound, *GetEntity(), NULL, m_pSoundDatabase);
  1100.                         }
  1101.  
  1102.                         if (isFirstPerson)
  1103.                         {
  1104.                                 if ((scopeContext1P >= 0) && m_pAnimDatabase1P)
  1105.                                 {
  1106.                                         if (m_pCharacter)
  1107.                                         {
  1108.                                                 m_pActionController->SetScopeContext(scopeContext1P, *GetEntity(), m_pCharacter, m_pAnimDatabase1P);
  1109.                                         }
  1110.                                         else
  1111.                                         {
  1112.                                                 m_pActionController->ClearScopeContext(scopeContext1P);
  1113.                                         }
  1114.                                 }
  1115.                                 if ((scopeContext3P >= 0) && m_pAnimDatabase3P)
  1116.                                 {
  1117.                                         if (m_pShadowCharacter)
  1118.                                         {
  1119.                                                 m_pActionController->SetScopeContext(scopeContext3P, *GetEntity(), m_pShadowCharacter, m_pAnimDatabase3P);
  1120.                                         }
  1121.                                         else
  1122.                                         {
  1123.                                                 m_pActionController->ClearScopeContext(scopeContext3P);
  1124.                                         }
  1125.                                 }
  1126.                         }
  1127.                         else
  1128.                         {
  1129.                                 if (scopeContext1P >= 0)
  1130.                                 {
  1131.                                         m_pActionController->ClearScopeContext(scopeContext1P);
  1132.                                 }
  1133.                                 if ((scopeContext3P >= 0) && m_pAnimDatabase3P)
  1134.                                 {
  1135.                                         if (m_pCharacter)
  1136.                                         {
  1137.                                                 m_pActionController->SetScopeContext(scopeContext3P, *GetEntity(), m_pCharacter, m_pAnimDatabase3P);
  1138.                                         }
  1139.                                         else
  1140.                                         {
  1141.                                                 m_pActionController->ClearScopeContext(scopeContext3P);
  1142.                                         }
  1143.                                 }
  1144.                         }
  1145.  
  1146.                         for (TAnimCharListeners::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
  1147.                                 notifier->OnCharacterChange();
  1148.  
  1149.                 }
  1150.         }
  1151. }
  1152.  
  1153. //////////////////////////////////////////////////////////////////////////
  1154. void CAnimatedCharacter::ProcessEvent(SEntityEvent& event)
  1155. {
  1156.         FUNCTION_PROFILER(gEnv->pSystem, PROFILE_ACTION);
  1157.  
  1158.         switch (event.event)
  1159.         {
  1160.         case ENTITY_EVENT_PRE_SERIALIZE:
  1161.                 {
  1162.                         if (m_pActionController)
  1163.                                 m_pActionController->Reset();
  1164.                 }
  1165.                 break;
  1166.         case ENTITY_EVENT_ANIM_EVENT:
  1167.                 {
  1168.                         VALIDATE_CHARACTER_PTRS
  1169.  
  1170.                         if (m_pActionController)
  1171.                         {
  1172.                                 const AnimEventInstance* pAnimEvent = reinterpret_cast<const AnimEventInstance*>(event.nParam[0]);
  1173.                                 ICharacterInstance* pCharacter = reinterpret_cast<ICharacterInstance*>(event.nParam[1]);
  1174.                                 if (pAnimEvent && pCharacter)
  1175.                                 {
  1176.                                         m_pActionController->OnAnimationEvent(pCharacter, *pAnimEvent);
  1177.                                 }
  1178.                         }
  1179.                 }
  1180.                 break;
  1181.         case ENTITY_EVENT_XFORM:
  1182.                 {
  1183.                         int flags = (int)event.nParam[0];
  1184.  
  1185.                         if (!(flags & (ENTITY_XFORM_USER | ENTITY_XFORM_PHYSICS_STEP)))
  1186.                         {
  1187.                                 IEntity* pEntity = GetEntity();
  1188.                                 if (pEntity != NULL)
  1189.                                 {
  1190.                                         QuatT entLocationTeleported = m_entLocation; // maybe don't use this local variable, but instead just m_entLocation, and maybe call UpdateCurEntLocation() here as well, just in case.
  1191.  
  1192.                                         // TODO: Optimize by not doing the merge of full QuatT's twice (once for each component).
  1193.                                         if (flags & ENTITY_XFORM_ROT /*&& flags & (ENTITY_XFORM_TRACKVIEW|ENTITY_XFORM_EDITOR)*/)
  1194.                                         {
  1195.                                                 entLocationTeleported.q = pEntity->GetWorldRotation();
  1196.                                         }
  1197.                                         if (flags & ENTITY_XFORM_POS)
  1198.                                         {
  1199.                                                 entLocationTeleported.t = pEntity->GetWorldPos();
  1200.  
  1201.                                                 //if (pEntity->GetParent() == NULL && m_entLocation.t != entLocationTeleported.t)
  1202.                                                 //{
  1203.                                                 //      // forcing MCM's to eMCM_Entity only when teleported if not inside vehicle
  1204.                                                 //      // (inside vehicles entity can only move by teleporting)
  1205.                                                 //      EMovementControlMethod mcmh = GetMCMH();
  1206.                                                 //      EMovementControlMethod mcmv = GetMCMV();
  1207.                                                 //      bool forceEntity = false;
  1208.                                                 //      if (mcmh == eMCM_Animation || mcmh == eMCM_AnimationHCollision)
  1209.                                                 //      {
  1210.                                                 //              forceEntity = true;
  1211.                                                 //              mcmh = eMCM_Entity;
  1212.                                                 //      }
  1213.                                                 //      if (mcmv == eMCM_Animation)
  1214.                                                 //      {
  1215.                                                 //              forceEntity = true;
  1216.                                                 //              mcmv = eMCM_Entity;
  1217.                                                 //      }
  1218.                                                 //      if (forceEntity)
  1219.                                                 //              SetMovementControlMethods(mcmh, mcmv);
  1220.                                                 //}
  1221.                                         }
  1222.  
  1223.                                         if (!m_inGrabbedState)
  1224.                                         {
  1225.                                                 // This is only for debugging, not used for anything.
  1226.                                                 m_entTeleportMovement = ApplyWorldOffset(m_entTeleportMovement, GetWorldOffset(m_entLocation, entLocationTeleported));
  1227.  
  1228.                                                 m_expectedEntMovement.zero();
  1229.                                                 m_entLocation = entLocationTeleported;
  1230.                                         }
  1231.                                         else
  1232.                                         {
  1233.                                                 // [Benito] Note:
  1234.                                                 // When the player is grabbing an AI, the update of the character instance has to be delayed to this point
  1235.                                                 // The player instance will update, and the AI, being attached to the player's hand will get updated its final position
  1236.                                                 // at this point.
  1237.                                                 // Because this happens during SynchAllAnimations at the end of the frame, SetAnimationPostProcessParameters has true as 3rd parameter
  1238.                                                 // which means, it will immediatelly call FinishAnimations in the character (it's not ideal, but there is no other way to get the correct update order)
  1239.  
  1240.                                                 VALIDATE_CHARACTER_PTRS
  1241.  
  1242.                                                   m_entLocation = entLocationTeleported;
  1243.                                                 if (StartAnimationProcessing(m_entLocation))
  1244.                                                         SetAnimationPostProcessParameters(m_entLocation, true);
  1245.                                         }
  1246.  
  1247.                                         DestroyExtraSolidCollider();
  1248.  
  1249.                                         m_pComponentPrepareCharForUpdate->ClearQueuedRotation();
  1250.                                 }
  1251.                         }
  1252.                 }
  1253.                 break;
  1254.         case ENTITY_EVENT_SCRIPT_REQUEST_COLLIDERMODE:
  1255.                 {
  1256.                         VALIDATE_CHARACTER_PTRS
  1257.  
  1258.                         EColliderMode mode = (EColliderMode)event.nParam[0];
  1259.                         RequestPhysicalColliderMode(mode, eColliderModeLayer_Script);
  1260.                 }
  1261.                 break;
  1262.         case ENTITY_EVENT_DONE:
  1263.                 {
  1264.                         // Delete the ActionController before everything is deleted.
  1265.                         DeleteActionController();
  1266.                 }
  1267.                 break;
  1268.         case ENTITY_EVENT_INIT:
  1269.         case ENTITY_EVENT_RESET:
  1270.                 {
  1271.                         if (!m_pActionController)
  1272.                         {
  1273.                                 InitializeMannequin();
  1274.                         }
  1275.                 }
  1276.                 break;
  1277.         }
  1278. }
  1279.  
  1280. float CAnimatedCharacter::FilterView(SViewParams& viewParams) const
  1281. {
  1282.  
  1283.         ICharacterInstance* pCharacter = GetEntity()->GetCharacter(0);
  1284.         float animationControlledView = 0.0f;
  1285.  
  1286.         if (animationControlledView > 0.001f)
  1287.         {
  1288.                 viewParams.viewID = 1;
  1289.                 viewParams.nearplane = 0.1f;
  1290.  
  1291.                 ISkeletonPose* pISkeletonPose = pCharacter->GetISkeletonPose();
  1292.                 IDefaultSkeleton& rIDefaultSkeleton = pCharacter->GetIDefaultSkeleton();
  1293.  
  1294.                 //FIXME:keep IDs and such
  1295.  
  1296.                 //view position, get the character position from the eyes and blend it with the game desired position
  1297.                 int id_right = rIDefaultSkeleton.GetJointIDByName("eye_right_bone");
  1298.                 int id_left = rIDefaultSkeleton.GetJointIDByName("eye_left_bone");
  1299.                 if (id_right > -1 && id_left > -1)
  1300.                 {
  1301.                         Vec3 characterViewPos(pISkeletonPose->GetAbsJointByID(id_right).t);
  1302.                         characterViewPos += pISkeletonPose->GetAbsJointByID(id_left).t;
  1303.                         characterViewPos *= 0.5f;
  1304.  
  1305.                         characterViewPos = GetEntity()->GetSlotWorldTM(0) * characterViewPos;
  1306.  
  1307.                         viewParams.position = animationControlledView * characterViewPos + (1.0f - animationControlledView) * viewParams.position;
  1308.                 }
  1309.  
  1310.                 //and then, same with view rotation
  1311.                 int id_head = rIDefaultSkeleton.GetJointIDByName("Bip01 Head");
  1312.                 if (id_head > -1)
  1313.                 {
  1314.                         //      Quat characterViewQuat(Quat(GetEntity()->GetSlotWorldTM(0)) * Quat(pSkeleton->GetAbsJMatrixByID(id_head)) * Quat::CreateRotationY(gf_PI*0.5f));
  1315.                         Quat characterViewQuat(Quat(GetEntity()->GetSlotWorldTM(0)) * pISkeletonPose->GetAbsJointByID(id_head).q * Quat::CreateRotationY(gf_PI * 0.5f));
  1316.  
  1317.                         viewParams.rotation = Quat::CreateSlerp(viewParams.rotation, characterViewQuat, animationControlledView);
  1318.                 }
  1319.         }
  1320.  
  1321.         return animationControlledView;
  1322. }
  1323.  
  1324. void CAnimatedCharacter::SetParams(const SAnimatedCharacterParams& params)
  1325. {
  1326.         m_params = params;
  1327. }
  1328.  
  1329. void CAnimatedCharacter::RequestStance(int stanceID, const char* name)
  1330. {
  1331.         m_stanceQuery = 0;
  1332.         m_requestedStance = -1;
  1333.         m_currentStance = stanceID;
  1334. }
  1335.  
  1336. int CAnimatedCharacter::GetCurrentStance()
  1337. {
  1338.         return m_currentStance;
  1339. }
  1340.  
  1341. bool CAnimatedCharacter::InStanceTransition()
  1342. {
  1343.         return m_requestedStance >= 0;
  1344. }
  1345.  
  1346. void CAnimatedCharacter::DestroyedState(IAnimationGraphState*)
  1347. {
  1348.         m_pMannequinAGState = NULL;
  1349. }
  1350.  
  1351. uint32 CAnimatedCharacter::MakeFace(const char* pExpressionName, bool usePreviewChannel, float lifeTime)
  1352. {
  1353.         uint32 channelId(~0);
  1354.         return channelId;
  1355. }
  1356.  
  1357. void CAnimatedCharacter::AllowLookIk(bool allow, int layer /* = -1 */)
  1358. {
  1359.         unsigned int oneBasedLayerIndex = ((layer >= 0) && (layer < eAnimationGraphLayer_COUNT)) ? layer + 1 : 0;
  1360.  
  1361.         if (allow)
  1362.         {
  1363.                 m_disallowLookIKFlags &= ~(1 << oneBasedLayerIndex);
  1364.         }
  1365.         else
  1366.         {
  1367.                 m_disallowLookIKFlags |= (1 << oneBasedLayerIndex);
  1368.         }
  1369. }
  1370.  
  1371. void CAnimatedCharacter::AllowAimIk(bool allow)
  1372. {
  1373.         m_allowAimIk = allow;
  1374. }
  1375.  
  1376. void CAnimatedCharacter::TriggerRecoil(float duration, float kinematicImpact, float kickIn /*=0.8f*/, EAnimatedCharacterArms arms /*=eACA_BothArms*/)
  1377. {
  1378.         if (IActor* pActor = CCryAction::GetCryAction()->GetIActorSystem()->GetActor(GetEntityId()))
  1379.         {
  1380.                 //--- Ensure that our cached ptrs are up to date as this can be called from outside the update loop
  1381.                 VALIDATE_CHARACTER_PTRS
  1382.  
  1383.                 ISkeletonPose* pSkeletonPose = pActor->IsThirdPerson() ? m_pSkeletonPose : m_pShadowSkeletonPose; // in 1p apply recoil on shadow instead of the main skeletonpose
  1384.  
  1385.                 if (pSkeletonPose != NULL)
  1386.                         pSkeletonPose->ApplyRecoilAnimation(duration, kinematicImpact, kickIn, static_cast<uint32>(arms));
  1387.         }
  1388. }
  1389.  
  1390. void CAnimatedCharacter::SetWeaponRaisedPose(EWeaponRaisedPose pose)
  1391. {
  1392.         if (pose == m_curWeaponRaisedPose)
  1393.                 return;
  1394.  
  1395.         ICharacterInstance* pCharacter = GetEntity()->GetCharacter(0);
  1396.         if (pCharacter == NULL)
  1397.                 return;
  1398.  
  1399.         ISkeletonAnim* pSkeletonAnim = pCharacter->GetISkeletonAnim();
  1400.         if (pSkeletonAnim == NULL)
  1401.                 return;
  1402.  
  1403.         m_curWeaponRaisedPose = pose;
  1404.  
  1405.         if ((pose == eWeaponRaisedPose_None) || (pose == eWeaponRaisedPose_Fists))
  1406.         {
  1407.                 pSkeletonAnim->StopAnimationInLayer(2, 0.5f);  // Stop weapon raising animation in Layer 2.
  1408.                 return;
  1409.         }
  1410.  
  1411.         const char* anim = NULL;
  1412.         switch (pose)
  1413.         {
  1414.         case eWeaponRaisedPose_Pistol:
  1415.                 anim = "combat_idleAimBlockPoses_pistol_01";
  1416.                 break;
  1417.         case eWeaponRaisedPose_PistolLft:
  1418.                 anim = "combat_idleAimBlockPoses_dualpistol_left_01";
  1419.                 break;
  1420.         case eWeaponRaisedPose_PistolRgt:
  1421.                 anim = "combat_idleAimBlockPoses_dualpistol_right_01";
  1422.                 break;
  1423.         case eWeaponRaisedPose_PistolBoth:
  1424.                 anim = "combat_idleAimBlockPoses_dualpistol_01";
  1425.                 break;
  1426.         case eWeaponRaisedPose_Rifle:
  1427.                 anim = "combat_idleAimBlockPoses_rifle_01";
  1428.                 break;
  1429.         case eWeaponRaisedPose_Rocket:
  1430.                 anim = "combat_idleAimBlockPoses_rocket_01";
  1431.                 break;
  1432.         case eWeaponRaisedPose_MG:
  1433.                 anim = "combat_idleAimBlockPoses_mg_01";
  1434.                 break;
  1435.         }
  1436.  
  1437.         if (anim == NULL)
  1438.         {
  1439.                 m_curWeaponRaisedPose = eWeaponRaisedPose_None;
  1440.                 return;
  1441.         }
  1442.  
  1443.         // Start the weapon raising in Layer 2. This will automatically deactivate aim-poses.
  1444.         CryCharAnimationParams Params0(0);
  1445.         Params0.m_nLayerID = 2;
  1446.         Params0.m_fTransTime = 0.5f;
  1447.         Params0.m_nFlags |= CA_LOOP_ANIMATION;
  1448.         pSkeletonAnim->StartAnimation(anim, Params0);
  1449. }
  1450.  
  1451. SGroundAlignmentParams& CAnimatedCharacter::GetGroundAlignmentParams()
  1452. {
  1453.         return m_groundAlignmentParams;
  1454. }
  1455.  
  1456. void CAnimatedCharacter::GetMemoryUsage(ICrySizer* s) const
  1457. {
  1458.         s->Add(*this);
  1459.         {
  1460.                 SIZER_COMPONENT_NAME(s, "MannequinAGState");
  1461.                 s->AddObject(m_pMannequinAGState);
  1462.         }
  1463.  
  1464.         {
  1465.                 SIZER_COMPONENT_NAME(s, "DebugHistory");
  1466.                 s->AddObject(m_debugHistoryManager);
  1467.         }
  1468. }
  1469.  
  1470. void CAnimatedCharacter::DeleteActionController()
  1471. {
  1472.         SAFE_RELEASE(m_pActionController);
  1473.         SAFE_DELETE(m_pAnimContext);
  1474. }
  1475.  
  1476. void CAnimatedCharacter::SetActionController(const char* filename)
  1477. {
  1478.         IMannequin& mannequinSys = gEnv->pGameFramework->GetMannequinInterface();
  1479.         const SControllerDef* contDef = mannequinSys.GetAnimationDatabaseManager().LoadControllerDef(filename);
  1480.  
  1481.         DeleteActionController();
  1482.  
  1483.         if (contDef)
  1484.         {
  1485.                 m_pAnimContext = new SAnimationContext(*contDef);
  1486.                 m_pActionController = mannequinSys.CreateActionController(GetEntity(), *m_pAnimContext);
  1487.         }
  1488. }
  1489.  
  1490. void CAnimatedCharacter::SetShadowCharacterSlot(int id)
  1491. {
  1492.         m_shadowCharacterSlot = id;
  1493.         m_hasShadowCharacter = true;
  1494.  
  1495.         InitShadowCharacter();
  1496. }
  1497.  
  1498. void CAnimatedCharacter::InitShadowCharacter()
  1499. {
  1500.         //--- Ensure that the shadow skel is set to animDriven motion, don't wait until the occassional ticked update
  1501.         IEntity* pEntity = GetEntity();
  1502.         ICharacterInstance* pCharacterInstanceShadow = m_hasShadowCharacter ? pEntity->GetCharacter(m_shadowCharacterSlot) : NULL;
  1503.         ISkeletonAnim* pShadowSkeletonAnim = pCharacterInstanceShadow ? pCharacterInstanceShadow->GetISkeletonAnim() : NULL;
  1504.         if (pShadowSkeletonAnim)
  1505.         {
  1506.                 pShadowSkeletonAnim->SetAnimationDrivenMotion(1);
  1507.         }
  1508. }
  1509.  
  1510. void CAnimatedCharacter::SetAnimationPlayerProxy(CAnimationPlayerProxy* proxy, int layer)
  1511. {
  1512.         m_pAnimationPlayerProxies[layer] = proxy;
  1513. }
  1514.  
  1515. CAnimationPlayerProxy* CAnimatedCharacter::GetAnimationPlayerProxy(int layer)
  1516. {
  1517.         CRY_ASSERT(layer < eAnimationGraphLayer_COUNT);
  1518.         return m_pAnimationPlayerProxies[layer];
  1519. }
  1520.  
  1521. void CAnimatedCharacter::DisableEntitySystemCharacterUpdate()
  1522. {
  1523.         if (m_pCharacter)
  1524.         {
  1525.                 // Turn off auto updating on this character,
  1526.                 // AnimatedCharacter will be forcing Pre and Post update manually.
  1527.                 m_pCharacter->SetFlags(m_pCharacter->GetFlags() & (~CS_FLAG_UPDATE));
  1528.  
  1529.                 if (m_pShadowCharacter)
  1530.                 {
  1531.                         m_pShadowCharacter->SetFlags(m_pShadowCharacter->GetFlags() & (~CS_FLAG_UPDATE));
  1532.                 }
  1533.         }
  1534. }
  1535.  
  1536. void CAnimatedCharacter::EnableLandBob(const SLandBobParams& landBobParams)
  1537. {
  1538.         CRY_ASSERT(landBobParams.IsValid());
  1539.  
  1540.         m_landBobParams = landBobParams;
  1541. }
  1542.  
  1543. void CAnimatedCharacter::DisableLandBob()
  1544. {
  1545.         m_landBobParams.Invalidate();
  1546. }
  1547.  
  1548. void CAnimatedCharacter::UseAnimationMovementForEntity(bool xyMove, bool zMove, bool rotation)
  1549. {
  1550.         m_moveOverride_useAnimXY = xyMove;
  1551.         m_moveOverride_useAnimZ = zMove;
  1552.         m_moveOverride_useAnimRot = rotation;
  1553. }
  1554.  
  1555. void CAnimatedCharacter::SetInGrabbedState(bool bEnable)
  1556. {
  1557.         m_noMovementOverrideExternal = bEnable;
  1558.         m_inGrabbedState = bEnable;
  1559. }
  1560.  
  1561. void CAnimatedCharacter::SetBlendFromRagdollizeParams(const SGameObjectEvent& event)
  1562. {
  1563.         CRY_ASSERT(event.event == eGFE_QueueBlendFromRagdoll);
  1564.  
  1565.         m_blendFromRagollizeParams.m_bPendingBlend = event.paramAsBool;
  1566. }
  1567.  
  1568. void CAnimatedCharacter::SetRagdollizeParams(const SGameObjectEvent& event)
  1569. {
  1570.         CRY_ASSERT(event.event == eGFE_QueueRagdollCreation);
  1571.  
  1572.         m_ragdollParams = *static_cast<const SRagdollizeParams*>(event.ptr);
  1573.  
  1574.         m_bPendingRagdoll = true;
  1575. }
  1576.  
  1577. void CAnimatedCharacter::KickOffRagdoll()
  1578. {
  1579.         if (m_bPendingRagdoll)
  1580.         {
  1581.                 m_groundAlignmentParams.SetFlag(eGA_Enable, false);
  1582.  
  1583.                 SEntityPhysicalizeParams pp;
  1584.  
  1585.                 pp.type = PE_ARTICULATED;
  1586.                 pp.nSlot = 0;
  1587.                 pp.bCopyJointVelocities = true;
  1588.  
  1589.                 pp.mass = m_ragdollParams.mass;
  1590.  
  1591.                 //never ragdollize without mass [Anton]
  1592.                 pp.mass = (float)__fsel(-pp.mass, 80.0f, pp.mass);
  1593.  
  1594.                 pp.fStiffnessScale = m_ragdollParams.stiffness;
  1595.  
  1596.                 pe_player_dimensions playerDim;
  1597.                 pe_player_dynamics playerDyn;
  1598.  
  1599.                 playerDyn.gravity.z = 15.0f;
  1600.                 playerDyn.kInertia = 5.5f;
  1601.  
  1602.                 pp.pPlayerDimensions = &playerDim;
  1603.                 pp.pPlayerDynamics = &playerDyn;
  1604.  
  1605.                 IPhysicalEntity* pPhysicalEntity = GetEntity()->GetPhysics();
  1606.                 if (!pPhysicalEntity || pPhysicalEntity->GetType() != PE_LIVING)
  1607.                         pp.nLod = 1;
  1608.  
  1609.                 // Joints velocities are copied by default for now
  1610.                 pp.bCopyJointVelocities = !gEnv->pSystem->IsSerializingFile();
  1611.                 pp.nFlagsOR = pef_log_poststep;
  1612.                 GetEntity()->Physicalize(pp);
  1613.  
  1614.                 SGameObjectEvent triggeredRagdoll(eGFE_RagdollPhysicalized, eGOEF_ToExtensions);
  1615.                 triggeredRagdoll.ptr = &m_ragdollParams;
  1616.                 GetGameObject()->SendEvent(triggeredRagdoll);
  1617.         }
  1618.         m_bPendingRagdoll = false;
  1619.  
  1620.         if (m_blendFromRagollizeParams.m_bPendingBlend)
  1621.         {
  1622.                 m_groundAlignmentParams.SetFlag(eGA_Enable, true);
  1623.  
  1624.                 SGameObjectEvent event(eGFE_DisableBlendRagdoll, eGOEF_ToExtensions);
  1625.                 GetGameObject()->SendEvent(event);
  1626.  
  1627.                 /*              ICharacterInstance *pCharacter=GetEntity()->GetCharacter(0);
  1628.                     if (pCharacter && pCharacter->GetISkeletonAnim())
  1629.                     {
  1630.                       IPhysicalEntity *pPhysicalEntity=0;
  1631.                       Matrix34 delta(IDENTITY);
  1632.  
  1633.                       pCharacter->GetISkeletonPose()->StandUp( Matrix34(m_entLocation), false, pPhysicalEntity, delta);
  1634.  
  1635.                       if (pPhysicalEntity)
  1636.                       {
  1637.                         {
  1638.                           GetEntity()->SetWorldTM(delta);
  1639.                           m_entLocation = QuatT(delta);
  1640.                           GetEntity()->AssignPhysicalEntity(pPhysicalEntity);
  1641.  
  1642.                           GetGameObject()->SetAspectProfile(eEA_Physics, eAP_Alive);
  1643.                         }
  1644.                       }
  1645.                     }*/
  1646.         }
  1647.         m_blendFromRagollizeParams.m_bPendingBlend = false;
  1648. }
  1649.  
  1650. bool CAnimatedCharacter::StartAnimationProcessing(const QuatT& entityLocation) const
  1651. {
  1652.         const int currentFrameId = gEnv->nMainFrameID;
  1653.  
  1654.         if ((m_pCharacter != NULL) && (m_lastAnimationUpdateFrameId != currentFrameId))
  1655.         {
  1656.                 // calculate the approximate distance from camera
  1657.                 CCamera* pCamera = &GetISystem()->GetViewCamera();
  1658.                 const float fDistance = ((pCamera ? pCamera->GetPosition() : entityLocation.t) - entityLocation.t).GetLength();
  1659.                 const float fZoomFactor = 0.001f + 0.999f * (RAD2DEG((pCamera ? pCamera->GetFov() : 60.0f)) / 60.f);
  1660.  
  1661.                 SAnimationProcessParams params;
  1662.                 params.locationAnimation = entityLocation;
  1663.                 params.bOnRender = 0;
  1664.                 params.zoomAdjustedDistanceFromCamera = fDistance * fZoomFactor;
  1665.                 params.locationAnimation = QuatTS(entityLocation.q, entityLocation.t, m_pCharacter->GetUniformScale());
  1666.  
  1667.                 if (m_pShadowCharacter)
  1668.                         m_pShadowCharacter->StartAnimationProcessing(params);
  1669.  
  1670.                 m_pCharacter->StartAnimationProcessing(params);
  1671.  
  1672.                 m_lastAnimationUpdateFrameId = currentFrameId;
  1673.  
  1674.                 return true;
  1675.         }
  1676.  
  1677.         return false;
  1678. }
  1679.  
  1680. void CAnimatedCharacter::SetAnimationPostProcessParameters(const QuatT& entityLocation, const bool finishImmediate) const
  1681. {
  1682.         if (m_pCharacter != NULL)
  1683.         {
  1684.                 const CCamera& viewCamera = GetISystem()->GetViewCamera();
  1685.                 const float scale = GetEntity()->GetWorldTM().GetColumn(0).GetLength();
  1686.                 const float fDistance = (viewCamera.GetPosition() - entityLocation.t).GetLength();
  1687.                 const float fZoomFactor = 0.001f + 0.999f * (RAD2DEG((viewCamera.GetFov())) / 60.f);
  1688.  
  1689.                 m_pCharacter->SetAttachmentLocation_DEPRECATED(QuatTS(entityLocation.q, entityLocation.t, scale));
  1690.                 if (m_pShadowCharacter)
  1691.                 {
  1692.                         m_pShadowCharacter->SetAttachmentLocation_DEPRECATED(QuatTS(entityLocation.q, entityLocation.t, scale));
  1693.                 }
  1694.  
  1695.                 if (finishImmediate)
  1696.                 {
  1697.                         m_pCharacter->FinishAnimationComputations();
  1698.  
  1699.                         //This path won't trigger, but for consistency
  1700.                         if (m_pShadowCharacter)
  1701.                         {
  1702.                                 m_pShadowCharacter->FinishAnimationComputations();
  1703.                         }
  1704.                 }
  1705.         }
  1706. }
  1707.  
  1708. void CAnimatedCharacter::StartAnimationProcessing() const
  1709. {
  1710.         m_lastAnimProcFrameID = gEnv->nMainFrameID;
  1711.  
  1712.         if (UseNormalAnimationProcessing())
  1713.         {
  1714.                 StartAnimationProcessing(m_entLocation);
  1715.         }
  1716. }
  1717.  
  1718. void CAnimatedCharacter::SetAnimationPostProcessParameters() const
  1719. {
  1720.         if (UseNormalAnimationProcessing())
  1721.         {
  1722.                 SetAnimationPostProcessParameters(m_entLocation);
  1723.         }
  1724. }
  1725.  
  1726. void CAnimatedCharacter::PrepareAndStartAnimProc()
  1727. {
  1728.         if (m_curFrameTime <= 0.0f)
  1729.                 return;
  1730.  
  1731.         UpdateCharacterPtrs();
  1732.  
  1733.         KickOffRagdoll();
  1734.  
  1735.         UpdateGroundAlignment();
  1736.  
  1737.         StartAnimationProcessing();
  1738.  
  1739.         UpdatePhysicalColliderMode();
  1740.  
  1741.         UpdatePhysicsInertia();
  1742. }
  1743.  
  1744. void CAnimatedCharacter::ForceMovement(const QuatT& relativeMovement)
  1745. {
  1746.         if (!m_hasForcedMovement)
  1747.                 m_forcedMovementRelative = relativeMovement;
  1748.         else
  1749.                 m_forcedMovementRelative = ApplyWorldOffset(m_forcedMovementRelative, relativeMovement);
  1750.         m_hasForcedMovement = true;
  1751. }
  1752.  
  1753. void CAnimatedCharacter::ForceOverrideRotation(const Quat& qWorldRotation)
  1754. {
  1755.         m_forcedOverrideRotationWorld = qWorldRotation;
  1756.         m_hasForcedOverrideRotation = true;
  1757. }
  1758.  
  1759. void CAnimatedCharacter::UpdateGroundAlignment()
  1760. {
  1761.         //use ground alignment only when character is close to the camera
  1762.         if (m_pSkeletonPose)
  1763.         {
  1764.                 bool bNeedUpdate = true;
  1765.  
  1766.                 if (m_simplifyMovement)
  1767.                 {
  1768.                         bNeedUpdate = false;
  1769.                 }
  1770.                 else if (!m_groundAlignmentParams.IsFlag(eGA_Enable))
  1771.                 {
  1772.                         bNeedUpdate = false;
  1773.                 }
  1774.                 else
  1775.                 {
  1776.                         //check if player is close enough
  1777.                         CCamera& camera = gEnv->pSystem->GetViewCamera();
  1778.                         const float fDistanceSq = (camera.GetPosition() - m_entLocation.t).GetLengthSquared();
  1779.  
  1780.                         // check if the character is using an animAction
  1781.                         // because these should allow groundAlignment even in animation driven mode
  1782.                         const int currentStance = GetCurrentStance();
  1783.  
  1784.                         if (fDistanceSq > m_groundAlignmentParams.ikDisableDistanceSqr)
  1785.                         {
  1786.                                 bNeedUpdate = false;
  1787.                         }
  1788.                         else if (GetEntity()->GetParent() != NULL)
  1789.                         {
  1790.                                 bNeedUpdate = false;
  1791.                         }
  1792.                         else if ((currentStance == STANCE_SWIM) ||
  1793.                                  (currentStance == STANCE_ZEROG) ||
  1794.                                  (currentStance == STANCE_PRONE))
  1795.                         {
  1796.                                 bNeedUpdate = false;
  1797.                         }
  1798.                         else if (NoMovementOverride() && !m_groundAlignmentParams.IsFlag(eGA_AllowWithNoCollision))
  1799.                         {
  1800.                                 bNeedUpdate = false;
  1801.                         }
  1802.                         else if ((m_colliderMode == eColliderMode_Disabled) && !m_groundAlignmentParams.IsFlag(eGA_AllowWithNoCollision))
  1803.                         {
  1804.                                 bNeedUpdate = false;
  1805.                         }
  1806.                         else if (GetMCMV() == eMCM_Animation)
  1807.                         {
  1808.                                 bNeedUpdate = false;
  1809.                         }
  1810.                         else if (!m_groundAlignmentParams.IsFlag(eGA_AllowWhenHasGroundCollider))
  1811.                         {
  1812.                                 if (IPhysicalEntity* piPhysics = GetEntity()->GetPhysics())
  1813.                                 {
  1814.                                         // Can't get access to whether the actor has a ground collider here,
  1815.                                         // so querying physics directly. This is really a bug :(
  1816.                                         pe_status_living peLiv;
  1817.                                         piPhysics->GetStatus(&peLiv);
  1818.                                         if (peLiv.pGroundCollider)
  1819.                                         {
  1820.                                                 bNeedUpdate = false;
  1821.                                         }
  1822.                                 }
  1823.                         }
  1824.                 }
  1825.  
  1826.                 if (bNeedUpdate)
  1827.                 {
  1828.                         PostProcessingUpdate();
  1829.                 }
  1830.         }
  1831. }
  1832.  
  1833. void CAnimatedCharacter::PerformSimpleMovement()
  1834. {
  1835.         return;
  1836.         //this function doesn't make any sense here. We ALWAYS update entities in CryAnimation
  1837.         CryFatalError("no need to update entities here");
  1838.         /*      if (m_simplifyMovement && m_pCharacter)
  1839.            {
  1840.             //if a character is not visible on screen, we still have to update the world position of the attached entity
  1841.             QuatT EntLocation;
  1842.             EntLocation.q=GetEntity()->GetWorldRotation();
  1843.             EntLocation.t=GetEntity()->GetWorldPos();
  1844.             m_pCharacter->UpdateAttachedObjectsFast(EntLocation,0.0f);
  1845.            }*/
  1846. }
  1847.  
  1848. void CAnimatedCharacter::GenerateMovementRequest()
  1849. {
  1850.         // 21/09/2012: Workaround for cases in which ResetVars() is called after PrepareAnimatedCharacterForUpdate() but before GenerateMovementRequest()
  1851.         // This could turn into a proper 'cache' of useful variables like curFrameTime, velocity, ... which gets properly invalidated
  1852.         // whenever ResetVars() is called.
  1853.         IF_UNLIKELY (m_curFrameTime == 0.0f)
  1854.         {
  1855.                 UpdateTime();
  1856.         }
  1857.  
  1858.         UpdateCharacterPtrs();
  1859.  
  1860.         RefreshAnimTarget();
  1861.  
  1862.         UpdateSimpleMovementConditions();
  1863.  
  1864.         PreAnimationUpdate();
  1865.  
  1866.         // Update actioncontroller after the graph if we push fragments
  1867.         // (fragments started by the graph should start as soon as possible)
  1868.         if (m_pActionController)
  1869.         {
  1870.                 m_pActionController->Update((float) m_curFrameTime);
  1871.         }
  1872.  
  1873.         CalculateParamsForCurrentMotions();
  1874.  
  1875.         UpdateMCMs();
  1876.  
  1877.         CalculateAndRequestPhysicalEntityMovement();
  1878. }
  1879.  
  1880. void CAnimatedCharacter::PrepareAnimatedCharacterForUpdate()
  1881. {
  1882. #ifdef DEBUGHISTORY
  1883.         SetupDebugHistories();
  1884. #endif
  1885.  
  1886. #ifdef _DEBUG
  1887.         RunTests();
  1888. #endif
  1889.  
  1890.         UpdateTime();
  1891.         GetCurrentEntityLocation();
  1892.         RefreshAnimTarget();
  1893. }
  1894.  
  1895. namespace animatedcharacter
  1896. {
  1897.  
  1898. void Preload(struct IScriptTable* pEntityScript)
  1899. {
  1900.         // Cache Mannequin related files
  1901.         bool hasActionController = false;
  1902.         {
  1903.                 IMannequin& mannequinSystem = gEnv->pGameFramework->GetMannequinInterface();
  1904.                 IAnimationDatabaseManager& animationDatabaseManager = mannequinSystem.GetAnimationDatabaseManager();
  1905.  
  1906.                 const char* szAnimationDatabase1p = 0;
  1907.                 if (pEntityScript->GetValue("AnimDatabase1P", szAnimationDatabase1p) &&
  1908.                     szAnimationDatabase1p && szAnimationDatabase1p[0])
  1909.                 {
  1910.                         animationDatabaseManager.Load(szAnimationDatabase1p);
  1911.                 }
  1912.  
  1913.                 const char* szAnimationDatabase3p = 0;
  1914.                 if (pEntityScript->GetValue("AnimDatabase3P", szAnimationDatabase3p) &&
  1915.                     szAnimationDatabase3p && szAnimationDatabase3p[0])
  1916.                 {
  1917.                         animationDatabaseManager.Load(szAnimationDatabase3p);
  1918.                 }
  1919.  
  1920.                 const char* szSoundDatabase = 0;
  1921.                 if (pEntityScript->GetValue("SoundDatabase", szSoundDatabase) &&
  1922.                     szSoundDatabase && szSoundDatabase[0])
  1923.                 {
  1924.                         animationDatabaseManager.Load(szSoundDatabase);
  1925.                 }
  1926.  
  1927.                 const char* szControllerDef = 0;
  1928.                 if (pEntityScript->GetValue("ActionController", szControllerDef) &&
  1929.                     szControllerDef && szControllerDef[0])
  1930.                 {
  1931.                         const SControllerDef* pControllerDef = animationDatabaseManager.LoadControllerDef(szControllerDef);
  1932.                         hasActionController = (pControllerDef != NULL);
  1933.                 }
  1934.         }
  1935. }
  1936.  
  1937. } // namespace animatedcharacter
  1938.  
downloadAnimatedCharacter.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top