BVB Source Codes

CRYENGINE Show ProceduralClipAnimManipulation.cpp Source code

Return Download CRYENGINE: download ProceduralClipAnimManipulation.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. //
  4. ////////////////////////////////////////////////////////////////////////////
  5.  
  6. #include "StdAfx.h"
  7.  
  8. #include "ICryMannequin.h"
  9. #include <Mannequin/Serialization.h>
  10. #include <CryExtension/ClassWeaver.h>
  11. #include <CryExtension/CryCreateClassInstance.h>
  12.  
  13. struct SProceduralClipLayerWeightParams : public IProceduralParams
  14. {
  15.         SProceduralClipLayerWeightParams()
  16.                 : layer(0)
  17.                 , invert(false)
  18.         {
  19.         }
  20.  
  21.         virtual void Serialize(Serialization::IArchive& ar) override
  22.         {
  23.                 ar(paramName, "LayerWeightParam", "Layer Weight Param");
  24.                 ar(Serialization::Decorators::Range<uint32>(layer, 0, 15), "ScopeLayer", "Scope Layer");
  25.                 ar(invert, "Invert", "Invert");
  26.         }
  27.  
  28.         virtual void GetExtraDebugInfo(StringWrapper& extraInfoOut) const override
  29.         {
  30.                 extraInfoOut = paramName.c_str();
  31.         }
  32.  
  33.         TProcClipString paramName;
  34.         uint32          layer;
  35.         bool            invert;
  36. };
  37.  
  38. class CProceduralClipLayerWeight : public TProceduralClip<SProceduralClipLayerWeightParams>
  39. {
  40. public:
  41.         CProceduralClipLayerWeight()
  42.                 : m_dataStringCRC(0)
  43.                 , m_animLayer(0)
  44.                 , m_invert(false)
  45.         {
  46.         }
  47.  
  48.         virtual void OnEnter(float blendTime, float duration, const SProceduralClipLayerWeightParams& params)
  49.         {
  50.                 m_dataStringCRC = CCrc32::ComputeLowercase(params.paramName.c_str());
  51.                 m_invert = params.invert;
  52.                 uint32 layer = params.layer;
  53.  
  54.                 CRY_ASSERT_MESSAGE(layer >= 0 && layer < m_scope->GetTotalLayers(), string().Format("CProceduralClipLayerWeight::OnEnter -> Invalid layer passed in: '%d'", layer));
  55.  
  56.                 m_animLayer = m_scope->GetBaseLayer() + layer;
  57.  
  58.                 UpdateLayerWeight();
  59.         }
  60.  
  61.         virtual void OnExit(float blendTime)
  62.         {
  63.                 m_charInstance->GetISkeletonAnim()->SetLayerBlendWeight(m_animLayer, 1.f);
  64.         }
  65.  
  66.         virtual void Update(float timePassed)
  67.         {
  68.                 UpdateLayerWeight();
  69.         }
  70.  
  71. private:
  72.  
  73.         void UpdateLayerWeight()
  74.         {
  75.                 float paramValue = 0.f;
  76.  
  77.                 if (GetParam(m_dataStringCRC, paramValue))
  78.                 {
  79.                         paramValue = m_invert ? 1.0f - paramValue : paramValue;
  80.                         m_charInstance->GetISkeletonAnim()->SetLayerBlendWeight(m_animLayer, paramValue);
  81.                 }
  82.         }
  83.  
  84.         uint32 m_dataStringCRC;
  85.         uint8  m_animLayer;
  86.         bool   m_invert;
  87. };
  88.  
  89. REGISTER_PROCEDURAL_CLIP(CProceduralClipLayerWeight, "LayerWeight");
  90.  
  91. struct SProceduralClipIKControlledLayerWeightParams : public IProceduralParams
  92. {
  93.         SProceduralClipIKControlledLayerWeightParams()
  94.                 : layer(0)
  95.                 , invert(false)
  96.         {
  97.         }
  98.  
  99.         virtual void Serialize(Serialization::IArchive& ar) override
  100.         {
  101.                 ar(jointName, "JointName", "Joint Name");
  102.                 ar(Serialization::Decorators::Range<uint32>(layer, 0, 15), "ScopeLayer", "Scope Layer");
  103.                 ar(invert, "Invert", "Invert");
  104.         }
  105.  
  106.         virtual void GetExtraDebugInfo(StringWrapper& extraInfoOut) const override
  107.         {
  108.                 extraInfoOut = jointName.c_str();
  109.         }
  110.  
  111.         TProcClipString jointName;
  112.         uint32          layer;
  113.         bool            invert;
  114. };
  115.  
  116. class CProceduralClipIKControlledLayerWeight : public TProceduralClip<SProceduralClipIKControlledLayerWeightParams>
  117. {
  118. public:
  119.         CProceduralClipIKControlledLayerWeight()
  120.                 : m_jointID(-1)
  121.                 , m_animLayer(0)
  122.                 , m_invert(false)
  123.         {
  124.         }
  125.  
  126.         virtual void OnEnter(float blendTime, float duration, const SProceduralClipIKControlledLayerWeightParams& params)
  127.         {
  128.                 IDefaultSkeleton& defaultSkeleton = m_charInstance->GetIDefaultSkeleton();
  129.                 m_jointID = defaultSkeleton.GetJointIDByName(params.jointName.c_str());
  130.  
  131.                 m_invert = params.invert;
  132.                 uint32 layer = params.layer;
  133.  
  134.                 CRY_ASSERT_MESSAGE(layer >= 0 && layer < m_scope->GetTotalLayers(), string().Format("CProceduralClipIKControlledLayerWeight::OnEnter -> Invalid layer passed in: '%d'", layer));
  135.  
  136.                 m_animLayer = m_scope->GetBaseLayer() + layer;
  137.  
  138.                 UpdateLayerWeight();
  139.         }
  140.  
  141.         virtual void OnExit(float blendTime)
  142.         {
  143.                 m_charInstance->GetISkeletonAnim()->SetLayerBlendWeight(m_animLayer, 1.f);
  144.         }
  145.  
  146.         virtual void Update(float timePassed)
  147.         {
  148.                 UpdateLayerWeight();
  149.         }
  150.  
  151. private:
  152.  
  153.         void UpdateLayerWeight()
  154.         {
  155.                 if (m_jointID >= 0)
  156.                 {
  157.                         ISkeletonPose& skeletonPose = *m_charInstance->GetISkeletonPose();
  158.  
  159.                         QuatT joint = skeletonPose.GetRelJointByID(m_jointID);
  160.  
  161.                         float paramValue = clamp_tpl(joint.t.x, 0.f, 1.f);
  162.  
  163.                         if (m_invert)
  164.                         {
  165.                                 paramValue = 1.0f - paramValue;
  166.                         }
  167.  
  168.                         m_charInstance->GetISkeletonAnim()->SetLayerBlendWeight(m_animLayer, paramValue);
  169.  
  170.                 }
  171.         }
  172.  
  173.         int16 m_jointID;
  174.         uint8 m_animLayer;
  175.         bool  m_invert;
  176. };
  177.  
  178. REGISTER_PROCEDURAL_CLIP(CProceduralClipIKControlledLayerWeight, "IKLayerWeight");
  179.  
  180. struct SProceduralClipLayerManualUpdateParams
  181.         : public IProceduralParams
  182. {
  183.         SProceduralClipLayerManualUpdateParams()
  184.                 : layer(0)
  185.                 , invert(false)
  186.         {
  187.         }
  188.  
  189.         virtual void Serialize(Serialization::IArchive& ar) override
  190.         {
  191.                 ar(paramName, "ParamName", "Param Name");
  192.                 ar(Serialization::Decorators::Range<uint32>(layer, 0, 15), "ScopeLayer", "Scope Layer");
  193.                 ar(invert, "Invert", "Invert");
  194.         }
  195.  
  196.         virtual void GetExtraDebugInfo(StringWrapper& extraInfoOut) const override
  197.         {
  198.                 extraInfoOut = paramName.c_str();
  199.         }
  200.  
  201.         TProcClipString paramName;
  202.         uint32          layer;
  203.         bool            invert;
  204. };
  205.  
  206. class CProceduralClipLayerManualUpdate : public TProceduralClip<SProceduralClipLayerManualUpdateParams>
  207. {
  208. public:
  209.         CProceduralClipLayerManualUpdate()
  210.                 : m_dataStringCRC(0)
  211.         {
  212.         }
  213.  
  214.         virtual void OnEnter(float blendTime, float duration, const SProceduralClipLayerManualUpdateParams& params)
  215.         {
  216.                 m_dataStringCRC = CCrc32::ComputeLowercase(params.paramName.c_str());
  217.                 uint32 layer = params.layer;
  218.  
  219.                 CRY_ASSERT_MESSAGE(layer >= 0 && layer < m_scope->GetTotalLayers(), string().Format("CProceduralClipLayerManualUpdate::OnEnter -> Invalid layer passed in: '%d'", layer));
  220.  
  221.                 CAnimation* pAnimation = NULL;
  222.                 ISkeletonAnim* pSkeletonAnim = NULL;
  223.  
  224.                 if (GetSkeletonAndAnimation(pSkeletonAnim, pAnimation))
  225.                 {
  226.                         pAnimation->SetStaticFlag(CA_MANUAL_UPDATE);
  227.  
  228.                         float paramValue = 0.f;
  229.  
  230.                         if (GetParam(m_dataStringCRC, paramValue))
  231.                         {
  232.                                 pSkeletonAnim->SetAnimationNormalizedTime(pAnimation, paramValue);
  233.                         }
  234.                 }
  235.         }
  236.  
  237.         virtual void OnExit(float blendTime)
  238.         {
  239.                 CAnimation* pAnimation = NULL;
  240.                 ISkeletonAnim* pSkeletonAnim = NULL;
  241.  
  242.                 if (GetSkeletonAndAnimation(pSkeletonAnim, pAnimation))
  243.                 {
  244.                         pAnimation->ClearStaticFlag(CA_MANUAL_UPDATE);
  245.                 }
  246.         }
  247.  
  248.         virtual void Update(float timePassed)
  249.         {
  250.                 float paramValue = 0.f;
  251.  
  252.                 if (GetParam(m_dataStringCRC, paramValue))
  253.                 {
  254.                         CAnimation* pAnimation = NULL;
  255.                         ISkeletonAnim* pSkeletonAnim = NULL;
  256.  
  257.                         if (GetSkeletonAndAnimation(pSkeletonAnim, pAnimation))
  258.                         {
  259.                                 pSkeletonAnim->SetAnimationNormalizedTime(pAnimation, paramValue);
  260.                         }
  261.                 }
  262.         }
  263.  
  264. private:
  265.  
  266.         bool GetSkeletonAndAnimation(ISkeletonAnim*& pSkeletonAnim, CAnimation*& pAnimation)
  267.         {
  268.                 pSkeletonAnim = m_charInstance->GetISkeletonAnim();
  269.                 pAnimation = m_scope->GetTopAnim(GetParams().layer);
  270.  
  271.                 return (pAnimation != NULL);
  272.         }
  273.  
  274.         uint32 m_dataStringCRC;
  275. };
  276.  
  277. REGISTER_PROCEDURAL_CLIP(CProceduralClipLayerManualUpdate, "LayerManualUpdate");
  278.  
  279. struct SProceduralClipWeightedListParams : public IProceduralParams
  280. {
  281.         SProceduralClipWeightedListParams()
  282.                 : layer(0)
  283.                 , invert(false)
  284.         {
  285.         }
  286.  
  287.         virtual void Serialize(Serialization::IArchive& ar) override
  288.         {
  289.                 ar(paramName, "ParamName", "Param Name");
  290.                 ar(Serialization::Decorators::Range<uint32>(layer, 0, 15), "ScopeLayer", "Scope Layer");
  291.                 ar(invert, "Invert", "Invert");
  292.         }
  293.  
  294.         virtual void GetExtraDebugInfo(StringWrapper& extraInfoOut) const override
  295.         {
  296.                 extraInfoOut = paramName.c_str();
  297.         }
  298.  
  299.         SProcDataCRC paramName;
  300.         uint32       layer;
  301.         bool         invert;
  302. };
  303.  
  304. class CProceduralClipWeightedList : public TProceduralClip<SProceduralClipWeightedListParams>
  305. {
  306. public:
  307.         CProceduralClipWeightedList()
  308.                 : m_baseLayer(0)
  309.         {
  310.         }
  311.  
  312.         virtual void OnEnter(float blendTime, float duration, const SProceduralClipWeightedListParams& params)
  313.         {
  314.                 m_baseLayer = params.layer;
  315.                 UpdateLayerWeight();
  316.         }
  317.  
  318.         virtual void OnExit(float blendTime)
  319.         {
  320.         }
  321.  
  322.         virtual void Update(float timePassed)
  323.         {
  324.                 UpdateLayerWeight();
  325.         }
  326.  
  327. private:
  328.  
  329.         void UpdateLayerWeight()
  330.         {
  331.                 SWeightData data;
  332.                 if (GetParam(GetParams().paramName.crc, data))
  333.                 {
  334.                         const uint32 numLayers = min(m_scope->GetTotalLayers() - m_baseLayer, static_cast<uint32>(SWeightData::MAX_WEIGHTS));
  335.  
  336.                         uint32 layer = m_baseLayer;
  337.                         for (uint32 i = 0; i < numLayers; i++, layer++)
  338.                         {
  339.                                 float factor = clamp_tpl(data.weights[i], 0.f, 1.f);
  340.  
  341.                                 m_scope->ApplyAnimWeight(layer, factor);
  342.                         }
  343.                 }
  344.         }
  345.  
  346.         uint32 m_baseLayer;
  347. };
  348.  
  349. REGISTER_PROCEDURAL_CLIP(CProceduralClipWeightedList, "WeightedList");
  350.  
  351. struct SProceduralClipManualUpdateListParams : public IProceduralParams
  352. {
  353.         SProceduralClipManualUpdateListParams()
  354.                 : layer(0)
  355.                 , invert(false)
  356.         {
  357.         }
  358.  
  359.         virtual void Serialize(Serialization::IArchive& ar)
  360.         {
  361.                 ar(paramName, "ParamName", "Param Name");
  362.                 ar(Serialization::Decorators::Range<uint32>(layer, 0, 15), "ScopeLayer", "Scope Layer");
  363.                 ar(invert, "Invert", "Invert");
  364.         }
  365.  
  366.         SProcDataCRC paramName;
  367.         uint32       layer;
  368.         bool         invert;
  369. };
  370.  
  371. class CProceduralClipManualUpdateList : public TProceduralClip<SProceduralClipManualUpdateListParams>
  372. {
  373. public:
  374.         CProceduralClipManualUpdateList()
  375.                 : m_baseLayer(0)
  376.         {
  377.         }
  378.  
  379.         virtual void OnEnter(float blendTime, float duration, const SProceduralClipManualUpdateListParams& params)
  380.         {
  381.                 m_baseLayer = params.layer;
  382.                 UpdateLayerTimes();
  383.         }
  384.  
  385.         virtual void OnExit(float blendTime)
  386.         {
  387.         }
  388.  
  389.         virtual void Update(float timePassed)
  390.         {
  391.                 UpdateLayerTimes();
  392.         }
  393.  
  394. private:
  395.  
  396.         void UpdateLayerTimes()
  397.         {
  398.                 SWeightData data;
  399.                 if (GetParam(GetParams().paramName.crc, data))
  400.                 {
  401.                         const uint32 numLayers = min(m_scope->GetTotalLayers() - m_baseLayer, static_cast<uint32>(SWeightData::MAX_WEIGHTS) * 2);
  402.  
  403.                         uint32 layer = m_scope->GetBaseLayer() + m_baseLayer;
  404.                         for (uint32 i = 0; i < numLayers; i++, layer++)
  405.                         {
  406.                                 uint32 factorID = i >> 1;
  407.                                 float factor = data.weights[factorID];
  408.  
  409.                                 const bool bIsNegative = (i % 2) == 0;
  410.                                 if (bIsNegative)
  411.                                 {
  412.                                         factor = -factor;
  413.                                 }
  414.  
  415.                                 ISkeletonAnim& skeletonAnimation = *m_charInstance->GetISkeletonAnim();
  416.                                 int numAnims = skeletonAnimation.GetNumAnimsInFIFO(layer);
  417.                                 if (numAnims > 0)
  418.                                 {
  419.                                         CAnimation& animation = skeletonAnimation.GetAnimFromFIFO(layer, numAnims - 1);
  420.                                         animation.SetStaticFlag(CA_MANUAL_UPDATE);
  421.                                         animation.SetCurrentSegmentNormalizedTime(max(0.0f, factor));
  422.                                 }
  423.                         }
  424.                 }
  425.         }
  426.  
  427.         uint32 m_baseLayer;
  428. };
  429.  
  430. REGISTER_PROCEDURAL_CLIP(CProceduralClipManualUpdateList, "ManualUpdateList");
  431.  
  432. struct SJointAdjustParams : public IProceduralParams
  433. {
  434.         SProcDataCRC jointName;
  435.         uint32       layer;
  436.         bool         additive;
  437.         bool         relative;
  438.         Vec3         position;
  439.  
  440.         SJointAdjustParams()
  441.                 : layer(0)
  442.                 , additive(true)
  443.                 , relative(true)
  444.                 , position(ZERO)
  445.         {
  446.         }
  447.  
  448.         virtual void Serialize(Serialization::IArchive& ar)
  449.         {
  450.                 ar(Serialization::Decorators::JointName<SProcDataCRC>(jointName), "JointName", "Joint Name");
  451.                 ar(Serialization::Decorators::Range<uint32>(layer, 0, 15), "ScopeLayer", "Scope Layer");
  452.                 ar(additive, "Additive", "Additive");
  453.                 ar(relative, "Relative", "Relative To Parent");
  454.                 ar(position, "Position", "Position");
  455.         }
  456. };
  457.  
  458. class CProceduralClipPostProcessAdjust : public TProceduralClip<SJointAdjustParams>
  459. {
  460. public:
  461.         CProceduralClipPostProcessAdjust()
  462.                 : m_operation(IAnimationOperatorQueue::eOp_AdditiveRelative)
  463.                 , m_jointID(-1)
  464.                 , m_layer(0)
  465.                 , m_position(ZERO)
  466.         {
  467.         }
  468.  
  469.         virtual void OnEnter(float blendTime, float duration, const SJointAdjustParams& params)
  470.         {
  471.                 m_layer = params.layer;
  472.                 m_position = params.position;
  473.  
  474.                 if (params.additive)
  475.                 {
  476.                         m_operation = (params.relative) ? IAnimationOperatorQueue::eOp_OverrideRelative : IAnimationOperatorQueue::eOp_Override;
  477.                 }
  478.                 else
  479.                 {
  480.                         m_operation = (params.relative) ? IAnimationOperatorQueue::eOp_AdditiveRelative : IAnimationOperatorQueue::eOp_Additive;
  481.                 }
  482.  
  483.                 IDefaultSkeleton& defaultSkeleton = m_charInstance->GetIDefaultSkeleton();
  484.                 int16 jointID = defaultSkeleton.GetJointIDByCRC32(params.jointName.crc);
  485.  
  486.                 if (jointID >= 0)
  487.                 {
  488.                         m_jointID = jointID;
  489.                         CryCreateClassInstance("AnimationPoseModifier_OperatorQueue", m_pPoseModifier);
  490.                 }
  491.                 else
  492.                 {
  493.                         CryWarning(VALIDATOR_MODULE_ANIMATION, VALIDATOR_WARNING, "CProceduralClipPostProcessAdjust::OnEnter joint '%s' doesn't exist in skeleton '%s'", params.jointName.c_str(), m_charInstance->GetFilePath());
  494.                 }
  495.         }
  496.  
  497.         virtual void OnExit(float blendTime)
  498.         {
  499.         }
  500.  
  501.         virtual void Update(float timePassed)
  502.         {
  503.                 if (m_jointID >= 0)
  504.                 {
  505.                         if (ICharacterInstance* pCharacter = m_scope->GetCharInst())
  506.                         {
  507.                                 pCharacter->GetISkeletonAnim()->PushPoseModifier(m_scope->GetBaseLayer() + m_layer, m_pPoseModifier, "ProceduralClipPostProcessAdjust");
  508.  
  509.                                 m_pPoseModifier->Clear();
  510.                                 m_pPoseModifier->PushPosition(m_jointID, m_operation, m_position);
  511.                         }
  512.                 }
  513.         }
  514.  
  515. private:
  516.  
  517.         IAnimationOperatorQueue::EOp m_operation;
  518.         int16                        m_jointID;
  519.         uint32                       m_layer;
  520.         Vec3                         m_position;
  521.         IAnimationOperatorQueuePtr   m_pPoseModifier;
  522. };
  523.  
  524. REGISTER_PROCEDURAL_CLIP(CProceduralClipPostProcessAdjust, "JointAdjust");
  525.  
  526. struct SProceduralClipLayerAnimSpeedParams : public IProceduralParams
  527. {
  528.         SProceduralClipLayerAnimSpeedParams()
  529.                 : layer(0)
  530.                 , invert(false)
  531.         {
  532.         }
  533.  
  534.         virtual void Serialize(Serialization::IArchive& ar) override
  535.         {
  536.                 ar(paramName, "ParamName", "Param Name");
  537.                 ar(Serialization::Decorators::Range<uint32>(layer, 0, 15), "ScopeLayer", "Scope Layer");
  538.                 ar(invert, "Invert", "Invert");
  539.         }
  540.  
  541.         virtual void GetExtraDebugInfo(StringWrapper& extraInfoOut) const override
  542.         {
  543.                 extraInfoOut = paramName.c_str();
  544.         }
  545.  
  546.         SProcDataCRC paramName;
  547.         uint32       layer;
  548.         bool         invert;
  549. };
  550.  
  551. class CProceduralClipLayerAnimSpeed : public TProceduralClip<SProceduralClipLayerAnimSpeedParams>
  552. {
  553. public:
  554.         CProceduralClipLayerAnimSpeed()
  555.                 : m_dataStringCRC(0)
  556.                 , m_animLayer(0)
  557.                 , m_invert(false)
  558.         {
  559.         }
  560.  
  561.         virtual void OnEnter(float blendTime, float duration, const SProceduralClipLayerAnimSpeedParams& params)
  562.         {
  563.                 m_dataStringCRC = params.paramName.crc;
  564.                 m_invert = params.invert;
  565.  
  566.                 CRY_ASSERT_MESSAGE(params.layer >= 0 && params.layer < m_scope->GetTotalLayers(), string().Format("CProceduralClipLayerAnimSpeed::OnEnter -> Invalid layer passed in: '%d'", params.layer));
  567.  
  568.                 m_animLayer = m_scope->GetBaseLayer() + params.layer;
  569.  
  570.                 UpdateLayerAnimSpeed();
  571.         }
  572.  
  573.         virtual void OnExit(float blendTime)
  574.         {
  575.                 m_charInstance->GetISkeletonAnim()->SetLayerPlaybackScale(m_animLayer, 1.0f);
  576.         }
  577.  
  578.         virtual void Update(float timePassed)
  579.         {
  580.                 UpdateLayerAnimSpeed();
  581.         }
  582.  
  583. private:
  584.  
  585.         void UpdateLayerAnimSpeed()
  586.         {
  587.                 float paramValue = 0.f;
  588.  
  589.                 if (GetParam(m_dataStringCRC, paramValue))
  590.                 {
  591.                         paramValue = m_invert ? 1.0f - paramValue : paramValue;
  592.                         m_charInstance->GetISkeletonAnim()->SetLayerPlaybackScale(m_animLayer, paramValue);
  593.                 }
  594.         }
  595.  
  596.         uint32 m_dataStringCRC;
  597.         uint8  m_animLayer;
  598.         bool   m_invert;
  599. };
  600.  
  601. REGISTER_PROCEDURAL_CLIP(CProceduralClipLayerAnimSpeed, "LayerAnimSpeed");
  602.  
downloadProceduralClipAnimManipulation.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