Improved movement animaitons

Added a SetBlendWeight event that sets the weight for all nodes with a name.

src/Engine/Rendering/AnimationSystem.cpp

@@ -4,6 +4,8 @@ AnimationSystem::AnimationSystem(SystemParams params)
     : System(params)
 {
     EVENT_SUBSCRIBE_MEMBER(m_EAutoAnimationBlend, &AnimationSystem::OnAutoAnimationBlend);
+    EVENT_SUBSCRIBE_MEMBER(m_EEntityDeleted, &AnimationSystem::OnEntityDeleted);
+    EVENT_SUBSCRIBE_MEMBER(m_ESetBlendWeight, &AnimationSystem::OnSetBlendWeight);
 }
 
 void AnimationSystem::Update(double dt)
@@ -122,16 +124,13 @@ void AnimationSystem::UpdateAnimations(double dt)
     }
 }
 
-
 void AnimationSystem::UpdateWeights(double dt)
 {
-    for (auto& autoBlendQueue : m_AutoBlendQueues) {
-
-        if(autoBlendQueue.second.HasActiveBlendJob()) {
-            AutoBlendQueue::AutoBlendJob& blendJob = autoBlendQueue.second.GetActiveBlendJob();
-
-            std::shared_ptr<BlendTree> blendTree = autoBlendQueue.second.GetBlendTree();
+    for (auto it = m_AutoBlendQueues.begin(); it != m_AutoBlendQueues.end(); ) {
+        if(it->second.HasActiveBlendJob()) {
+            AutoBlendQueue::AutoBlendJob& blendJob = it->second.GetActiveBlendJob();
 
+            std::shared_ptr<BlendTree> blendTree = it->second.GetBlendTree();
             if (blendTree != nullptr) {
                 if (blendJob.Duration != 0.0) {
                     blendJob.BlendInfo.progress = glm::clamp(blendJob.CurrentTime / blendJob.Duration, 0.0, 1.0);
@@ -140,10 +139,17 @@ void AnimationSystem::UpdateWeights(double dt)
                 }
 
                 blendJob.BlendInfo = blendTree->AutoBlendStep(blendJob.BlendInfo);
+            } else {
+                it = m_AutoBlendQueues.erase(it);
+            }
+            it++;
+        } else {
+            if (it->second.Empty()) {
+                it = m_AutoBlendQueues.erase(it);
+            } else {
+                it++;
             }
-
         }
-
     }
 }
 
@@ -177,46 +183,163 @@ bool AnimationSystem::OnAutoAnimationBlend(Events::AutoAnimationBlend& e)
         return false;
     }
 
+    EntityWrapper subTreeRoot;
 
 
-    EntityWrapper subTreeRoot = blendTree->GetSubTreeRoot(e.NodeName);
+    if (e.SingleLevelBlend) {
+        subTreeRoot = blendTree->GetSubTreeRoot(e.NodeName);
 
-    if (!subTreeRoot.Valid()) {
-        return false;
-    }
+        if (!subTreeRoot.Valid()) {
+            return false;
+        }
 
-    AutoBlendQueue::AutoBlendJob abj;
-    abj.AnimationEntity = e.AnimationEntity;
-    abj.CurrentTime = 0.0;
-    abj.Delay = e.Delay;
-    abj.Duration = e.Duration;
-    abj.RootNode = e.RootNode;
+        AutoBlendQueue::AutoBlendJob abj;
+        abj.AnimationEntity = e.AnimationEntity;
+        abj.CurrentTime = 0.0;
+        abj.Delay = e.Delay;
+        abj.Duration = e.Duration;
+        abj.RootNode = e.RootNode;
 
-    abj.BlendInfo.NodeName = e.NodeName;
-    abj.BlendInfo.progress = 0.0;
-    abj.BlendInfo.Start = e.Start;
-    abj.BlendInfo.SingleBlend = e.SingleLevelBlend;
-    abj.BlendInfo.Weight = e.Weight;
+        abj.BlendInfo.NodeName = e.NodeName;
+        abj.BlendInfo.progress = 0.0;
+        abj.BlendInfo.Start = e.Start;
+        abj.BlendInfo.SingleBlend = e.SingleLevelBlend;
+        abj.BlendInfo.Weight = e.Weight;
 
-    EntityWrapper nodeEntity = subTreeRoot.FirstChildByName(e.NodeName); // more than one
-    if (nodeEntity.Valid()) {
-        if (nodeEntity.HasComponent("Animation")) {
-            const Skeleton::Animation* animation = skeleton->GetAnimation(nodeEntity["Animation"]["AnimationName"]);
-            (bool&)nodeEntity["Animation"]["Reverse"] = e.Reverse;
+        std::vector<EntityWrapper> animationEntities = blendTree->GetEntitesByName(e.NodeName); // more than one
+        for(auto entity : animationEntities)
+        if (entity.Valid()) {
+            if (entity.HasComponent("Animation")) {
+                const Skeleton::Animation* animation = skeleton->GetAnimation(entity["Animation"]["AnimationName"]);
+                (bool&)entity["Animation"]["Reverse"] = e.Reverse;
 
-            if (e.Restart) {
-                if (animation != nullptr) {
-                    if (e.Restart) {
-                        if (e.Reverse) {
-                            (double&)nodeEntity["Animation"]["Time"] = animation->Duration;
-                        } else {
-                            (double&)nodeEntity["Animation"]["Time"] = 0.0;
+                if (e.Restart) {
+                    if (animation != nullptr) {
+                        if (e.Restart) {
+                            if (e.Reverse) {
+                                (double&)entity["Animation"]["Time"] = animation->Duration;
+                            } else {
+                                (double&)entity["Animation"]["Time"] = 0.0;
+                            }
                         }
                     }
                 }
             }
         }
+        m_AutoBlendQueues[subTreeRoot].Insert(abj);
+    } else {
+        std::vector<EntityWrapper> subtreeroots = blendTree->GetSingleLevelRoots(e.NodeName);
+
+        for(auto entity : subtreeroots) {
+            subTreeRoot = entity;
+
+            if (!subTreeRoot.Valid()) {
+                return false;
+            }
+
+            AutoBlendQueue::AutoBlendJob abj;
+            abj.AnimationEntity = e.AnimationEntity;
+            abj.CurrentTime = 0.0;
+            abj.Delay = e.Delay;
+            abj.Duration = e.Duration;
+            abj.RootNode = e.RootNode;
+
+            abj.BlendInfo.NodeName = e.NodeName;
+            abj.BlendInfo.progress = 0.0;
+            abj.BlendInfo.Start = e.Start;
+            abj.BlendInfo.SingleBlend = e.SingleLevelBlend;
+            abj.BlendInfo.Weight = e.Weight;
+            m_AutoBlendQueues[subTreeRoot].Insert(abj);
+        }
+
+        std::vector<EntityWrapper> animationEntities = blendTree->GetEntitesByName(e.NodeName); // more than one
+        for (auto entity : animationEntities)
+            if (entity.Valid()) {
+                if (entity.HasComponent("Animation")) {
+                    const Skeleton::Animation* animation = skeleton->GetAnimation(entity["Animation"]["AnimationName"]);
+                    (bool&)entity["Animation"]["Reverse"] = e.Reverse;
+
+                    if (e.Restart) {
+                        if (animation != nullptr) {
+                            if (e.Restart) {
+                                if (e.Reverse) {
+                                    (double&)entity["Animation"]["Time"] = animation->Duration;
+                                } else {
+                                    (double&)entity["Animation"]["Time"] = 0.0;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
     }
-    m_AutoBlendQueues[subTreeRoot].Insert(abj);
+
+   
     return true;
 }
+
+bool AnimationSystem::OnEntityDeleted(Events::EntityDeleted& e)
+{
+    EntityWrapper entity = EntityWrapper(m_World, e.DeletedEntity);
+
+    if (entity.HasComponent("Model")) {
+        Model* model;
+        try {
+            model = ResourceManager::Load<::Model, true>(entity["Model"]["Resource"]);
+        } catch (const std::exception&) {
+            return false;
+        }
+
+        Skeleton* skeleton = model->m_RawModel->m_Skeleton;
+        if (skeleton == nullptr) {
+            return false;
+        }
+
+        if (skeleton->BlendTrees.find(entity) != skeleton->BlendTrees.end()) {
+            skeleton->BlendTrees.erase(entity);
+        }
+
+
+    }
+
+}
+
+bool AnimationSystem::OnSetBlendWeight(Events::SetBlendWeight& e)
+{
+    if (!e.RootNode.Valid()) {
+        return false;
+    }
+
+    if (!e.RootNode.HasComponent("Model")) {
+        return false;
+    }
+
+    Model* model;
+    try {
+        model = ResourceManager::Load<::Model, true>((std::string)e.RootNode["Model"]["Resource"]);
+    } catch (const std::exception&) {
+        return false;
+    }
+
+    Skeleton* skeleton = model->m_RawModel->m_Skeleton;
+    if (skeleton == nullptr) {
+        return false;
+    }
+
+    std::shared_ptr<BlendTree> blendTree;
+    if (skeleton->BlendTrees.find(e.RootNode) != skeleton->BlendTrees.end()) {
+        blendTree = skeleton->BlendTrees.at(e.RootNode);
+    } else {
+        return false;
+    }
+
+    if(e.Weight >= 0 && e.Weight <= 1) {
+
+        blendTree->SetWeightByName(e.NodeName, e.Weight);
+
+        return true;
+    } else {
+        return false;
+    }
+
+}

src/Engine/Rendering/AutoBlendQueue.cpp

@@ -75,7 +75,6 @@ void AutoBlendQueue::Insert(AutoBlendJob autoBlendJob)
         }
     }
 
-
     m_BlendQueue.clear();
     m_BlendQueue.push_back(blendNode);
 }
@@ -124,7 +123,7 @@ bool AutoBlendQueue::HasActiveBlendJob()
             try {
                 model = ResourceManager::Load<::Model, true>(blendJob.RootNode["Model"]["Resource"]);
             } catch (const std::exception&) {
-                m_BlendQueue.pop_front();
+                //m_BlendQueue.pop_front();
                 return HasActiveBlendJob();
             }
 

src/Engine/Rendering/BlendTree.cpp

@@ -2,11 +2,8 @@
 
 BlendTree::BlendTree(EntityWrapper ModelEntity, Skeleton* skeleton)
 {
-
     m_Skeleton = skeleton;
 
-
-
     if (ModelEntity.HasComponent("Animation")) {
         const Skeleton::Animation* animation = skeleton->GetAnimation(ModelEntity["Animation"]["AnimationName"]);
         if (animation == nullptr) {
@@ -270,7 +267,7 @@ BlendTree::AutoBlendInfo BlendTree::AutoBlendStep(AutoBlendInfo blendInfo)
             currentNode = currentNode->Parent;
 
             if (blendInfo.SingleBlend) {
-                break;
+                return blendInfo;;
             }
         }
     } else if(goalNodes.size() >= 2) {
@@ -331,6 +328,9 @@ BlendTree::AutoBlendInfo BlendTree::AutoBlendStep(AutoBlendInfo blendInfo)
 
                 lastNode = currentNode;
                 currentNode = currentNode->Parent;
+                if (blendInfo.SingleBlend) {
+                    return blendInfo;
+                }
             }
         }
 
@@ -427,6 +427,55 @@ EntityWrapper BlendTree::GetSubTreeRoot(std::string nodeName)
     return subTreeRoots.front()->Entity;
 }
 
+
+std::vector<EntityWrapper> BlendTree::GetSingleLevelRoots(std::string name)
+{
+    std::vector<Node*> nodes = FindNodesByName(name);
+    std::vector<EntityWrapper> entities;
+
+    for (auto it = nodes.begin(); it != nodes.end(); it++) {
+        Node* currentNode = (*it)->Parent;
+        
+        if(currentNode->Entity.Valid()) {
+            entities.push_back(currentNode->Entity);
+        }
+    }
+
+    return entities;
+}
+
+
+std::vector<EntityWrapper> BlendTree::GetEntitesByName(std::string name)
+{
+    std::vector<Node*> nodes = FindNodesByName(name);
+    std::vector<EntityWrapper> entities;
+
+    for (auto it = nodes.begin(); it != nodes.end(); it++) {
+        Node* currentNode = (*it);
+
+        if (currentNode->Entity.Valid()) {
+            entities.push_back(currentNode->Entity);
+        }
+    }
+
+    return entities;
+}
+
+
+void BlendTree::SetWeightByName(std::string name, double weight)
+{
+    std::vector<Node*> nodes = FindNodesByName(name);
+
+    for (auto node : nodes) {
+        EntityWrapper entity = node->Entity;
+
+        if(entity.HasComponent("Blend")) {
+            entity["Blend"]["Weight"] = weight;
+            node->Weight = weight;
+        }
+    }
+}
+
 void BlendTree::Blend(std::map<int, Skeleton::PoseData>& pose)
 {
     Node* currentNode;

src/Engine/Rendering/Skeleton.cpp

@@ -321,6 +321,8 @@ Skeleton::~Skeleton()
     for (auto &kv : Bones) {
         delete kv.second;
     }
+
+    BlendTrees.clear();
 }
 
 const Skeleton::Animation* Skeleton::GetAnimation(std::string name)