Added BoneAttachment component

src/Engine/Rendering/AnimationSystem.cpp

@@ -41,7 +41,5 @@ void AnimationSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& a
         }
     }
 
-    
-
 }
 

src/Engine/Rendering/BoneAttachmentSystem.cpp

@@ -0,0 +1,71 @@
+#include "Rendering/BoneAttachmentSystem.h"
+
+void BoneAttachmentSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& BoneAttachmentComponent, double dt)
+{
+
+    if(!entity.HasComponent("Transform")) {
+        return;
+    }
+
+    auto parent = entity.FirstParentWithComponent("Animation");
+    if (!parent.HasComponent("Model")) {
+        return;
+    }
+    Model* model;
+    try {
+        model = ResourceManager::Load<::Model, true>(parent["Model"]["Resource"]);
+    } catch (const std::exception&) {
+        return;
+    }
+
+
+    Skeleton* skeleton = model->m_RawModel->m_Skeleton;
+    const Skeleton::Animation* animation = skeleton->GetAnimation(parent["Animation"]["Name"]);
+
+    if (!animation) {
+        return;
+    }
+
+    int id = skeleton->GetBoneID(entity["BoneAttachment"]["Name"]);
+
+    if(id == -1) {
+        return;
+    }
+
+    int currentKeyframeIndex = skeleton->GetKeyframe(*animation, parent["Animation"]["Time"]);
+
+    const Skeleton::Animation::Keyframe& currentFrame = animation->Keyframes[currentKeyframeIndex];
+    const Skeleton::Animation::Keyframe& nextFrame = animation->Keyframes[(currentKeyframeIndex + 1) % animation->Keyframes.size()];
+    float alpha = ((double)parent["Animation"]["Time"] - currentFrame.Time) / (nextFrame.Time - currentFrame.Time);
+
+    glm::mat4 boneTransform = skeleton->GetBoneTransform(skeleton->Bones[id], currentFrame, nextFrame, alpha, glm::mat4(1));
+
+
+
+    glm::vec3 scale;
+    glm::quat rotation;
+    glm::vec3 translation;
+    glm::vec3 skew;
+    glm::vec4 perspective;
+    glm::decompose(boneTransform, scale, rotation, translation, skew, perspective);
+
+    glm::vec3 angles;
+    angles.y = asin(-boneTransform[0][2]);
+    if (cos(angles.y) != 0) {
+        angles.x = atan2(boneTransform[1][2], boneTransform[2][2]);
+        angles.z = atan2(boneTransform[0][1], boneTransform[0][0]);
+    } else {
+        angles.x = atan2(-boneTransform[2][0], boneTransform[1][1]);
+        angles.z = 0;
+    }
+
+    if ((bool)entity["BoneAttachment"]["InheritPosition"]) {
+        (glm::vec3&)entity["Transform"]["Position"] = translation + (glm::vec3)entity["BoneAttachment"]["PositionOffset"];
+    }
+    if ((bool)entity["BoneAttachment"]["InheritOrientation"]) {
+        (glm::vec3&)entity["Transform"]["Orientation"] = angles  + (glm::vec3)entity["BoneAttachment"]["OrientationOffset"];
+    }
+    if ((bool)entity["BoneAttachment"]["InheritScale"]) {
+        (glm::vec3&)entity["Transform"]["Scale"] = scale  * (glm::vec3)entity["BoneAttachment"]["ScaleOffset"];
+    }
+}

src/Engine/Rendering/DrawFinalPass.cpp

@@ -94,11 +94,16 @@ void DrawFinalPass::Draw(RenderScene& scene)
             glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
             }*/
 
-            //TODO: Fixa så att modelsJobs kan spela upp olika animationer och så att den kan få in en tid istället för 1.0f - Hälsningar Johan och Andreas :)
-            if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
-               
+            if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {           
                 if (modelJob->Animation != nullptr) {
-                    std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones( *modelJob->Animation, modelJob->AnimationTime);
+                    std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
+//                     std::vector<glm::mat4> frameBones2 = modelJob->Skeleton->GetFrameBones(*modelJob->Skeleton->GetAnimation("Walk"), modelJob->AnimationTime);
+// 
+// 
+//                     for (int i = 0; i < frameBones.size(); i++) {
+//                         frameBones[i] = frameBones[i] * glm::mat4(glm::quat(glm::vec3(0.f, 0.f, 0.f)));//* frameBones2[i];
+//                     }
+
                     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
                 }
             }

src/Engine/Rendering/Skeleton.cpp

@@ -66,6 +66,8 @@ std::vector<glm::mat4> Skeleton::GetFrameBones(const Animation& animation, doubl
 	return finalMatrices;
 }
 
+
+
 void Skeleton::AccumulateBoneTransforms(bool noRootMotion, const Animation::Keyframe &currentFrame, const Animation::Keyframe &nextFrame, float progress, std::map<int, glm::mat4> &boneMatrices, const Bone* bone, glm::mat4 parentMatrix)
 {
     glm::mat4 boneMatrix;
@@ -101,6 +103,34 @@ void Skeleton::AccumulateBoneTransforms(bool noRootMotion, const Animation::Keyf
 
 }
 
+glm::mat4 Skeleton::GetBoneTransform(const Bone* bone, const Animation::Keyframe& currentFrame, const Animation::Keyframe& nextFrame, float progress, glm::mat4 parentMatrix)
+{
+    glm::mat4 boneMatrix;
+
+    if (currentFrame.BoneProperties.find(bone->ID) != currentFrame.BoneProperties.end() || nextFrame.BoneProperties.find(bone->ID) != nextFrame.BoneProperties.end()) {
+        Animation::Keyframe::BoneProperty currentBoneProperty = currentFrame.BoneProperties.at(bone->ID);
+        Animation::Keyframe::BoneProperty nextBoneProperty = nextFrame.BoneProperties.at(bone->ID);
+
+        glm::vec3 positionInterp = currentBoneProperty.Position * (1.f - progress) + nextBoneProperty.Position * progress;
+        glm::quat rotationInterp = glm::slerp(currentBoneProperty.Rotation, nextBoneProperty.Rotation, progress);
+        glm::vec3 scaleInterp = currentBoneProperty.Scale * (1.f - progress) + nextBoneProperty.Scale * progress;
+
+
+        boneMatrix = (glm::translate(positionInterp) * glm::toMat4(rotationInterp) * glm::scale(scaleInterp)) * parentMatrix;
+    } else {
+        if (bone->Parent) {
+            boneMatrix = parentMatrix;
+        }
+    }
+
+    if(bone->Parent) {
+        return  GetBoneTransform(bone->Parent, currentFrame, nextFrame, progress, boneMatrix);
+    } else {
+        return boneMatrix;
+    }
+
+}
+
 int Skeleton::GetBoneID(std::string name)
 {
 	if (m_BonesByName.find(name) == m_BonesByName.end()) {

src/Game/Game.cpp

@@ -10,7 +10,8 @@
 #include "Core/EntityFileWriter.h"
 #include "Game/Systems/CapturePointSystem.h"
 #include "Game/Systems/WeaponSystem.h"
-#include "../Engine/Rendering/AnimationSystem.h"
+#include "Rendering/AnimationSystem.h"
+#include "Rendering/BoneAttachmentSystem.h"
 
 Game::Game(int argc, char* argv[])
 {
@@ -90,6 +91,7 @@ Game::Game(int argc, char* argv[])
     m_SystemPipeline->AddSystem<AnimationSystem>(updateOrderLevel);
     // Collision and TriggerSystem should update after player.
     ++updateOrderLevel;
+    m_SystemPipeline->AddSystem<BoneAttachmentSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<CollisionSystem>(updateOrderLevel, m_OctreeCollision);
     m_SystemPipeline->AddSystem<TriggerSystem>(updateOrderLevel, m_OctreeCollision);
     ++updateOrderLevel;