BTH/axyz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'master' into Weapons

Browse Source
This commit is contained in:
sippeangelo
2016-03-03 23:46:46 +01:00
parent 7e6d32aaec 9426942988
commit 4dd46e2e21
39 changed files with 3850 additions and 1236 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/Engine/Core/EntityWrapper.h
+1
View File
@@ -29,6 +29,7 @@ struct EntityWrapper
EntityWrapper Parent();
EntityWrapper FirstParentByName(const std::string& parentEntityName);
EntityWrapper FirstChildByName(const std::string& name);
EntityWrapper FirstLevelChildByName(const std::string& name);
EntityWrapper FirstParentWithComponent(const std::string& componentType);
EntityWrapper Clone(EntityWrapper parent = EntityWrapper::Invalid);
std::vector<EntityWrapper> ChildrenWithComponent(const std::string& componentType);
include/Engine/Rendering/AnimationSystem.h
+19 -13
View File
@@ -3,27 +3,33 @@
#include "GLM.h"
#include "Common.h"
#include "Core/System.h"
#include "Core/ResourceManager.h"
#include "../Common.h"
#include "../Core/System.h"
#include "../Core/ResourceManager.h"
#include "Rendering/Model.h"
#include "Rendering/EAnimationComplete.h"
#include "Rendering/Skeleton.h"
#include <imgui/imgui.h>
#include "Rendering/BlendTree.h"
#include "Rendering/EAutoAnimationBlend.h"
#include "../Core/EntityWrapper.h"
#include "Rendering/AutoBlendQueue.h"
class AnimationSystem : public PureSystem
#include "imgui/imgui.h"
class AnimationSystem : public ImpureSystem
{
public:
AnimationSystem(SystemParams params)
: System(params)
, PureSystem("Animation")
{
}
AnimationSystem(SystemParams params);
~AnimationSystem() { }
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& animationComponent, double dt) override;
virtual void Update(double dt) override;
private:
void CreateBlendTrees();
void UpdateAnimations(double dt);
void UpdateWeights(double dt);
EventRelay<AnimationSystem, Events::AutoAnimationBlend> m_EAutoAnimationBlend;
bool OnAutoAnimationBlend(Events::AutoAnimationBlend& e);
std::unordered_map<EntityWrapper, AutoBlendQueue> m_AutoBlendQueues;
};
#endif
include/Engine/Rendering/AutoBlendQueue.h
+46
View File
@@ -0,0 +1,46 @@
#ifndef AutoBlendQueue_h__
#define AutoBlendQueue_h__
#include "../Core/ResourceManager.h"
#include "Skeleton.h"
#include "Model.h"
#include "BlendTree.h"
#include "../Core/EntityWrapper.h"
class AutoBlendQueue
{
public:
struct AutoBlendJob
{
EntityWrapper RootNode = EntityWrapper::Invalid;
double Duration;
double CurrentTime = 0.0;
double Delay = 0.0;
EntityWrapper AnimationEntity = EntityWrapper::Invalid;
BlendTree::AutoBlendInfo BlendInfo;
};
struct AutoblendNode
{
AutoBlendJob BlendJob;
double StartTime;
double EndTime;
};
AutoBlendQueue() { };
void Insert(AutoBlendJob autoBlendJob);
void UpdateTime(double dt);
void PrintQueue();
bool HasActiveBlendJob();
std::shared_ptr<BlendTree> GetBlendTree();
AutoBlendQueue::AutoBlendJob& GetActiveBlendJob();
private:
std::list<AutoblendNode> m_BlendQueue;
};
#endif
include/Engine/Rendering/BlendTree.h
+100
View File
@@ -0,0 +1,100 @@
#ifndef BlendTree_h__
#define BlendTree_h__
#include "Common.h"
#include "../GLM.h"
#include "Skeleton.h"
#include "../Core/EntityWrapper.h"
#include "../Core/World.h"
#include <stack>
class BlendTree
{
public:
enum class NodeType
{
Additive,
Blend,
Override,
Animation,
};
struct Node
{
std::string Name;
EntityWrapper Entity;
Node* Parent = nullptr;
Node* Child[2] = { nullptr, nullptr };
NodeType Type;
std::map<int, Skeleton::PoseData> Pose;
bool SubTreeRoot = false;
double Weight = 0.0;
Node* Next() {
Node* next = this;
if (next->Child[1] == nullptr) {
// Node has no right child
next = this;
while (next->Parent != nullptr && next == next->Parent->Child[1]) {
next = next->Parent;
}
next = next->Parent;
} else {
// Find the leftmost node in the right subtree
next = next->Child[1];
while (next->Child[0] != nullptr) {
next = next->Child[0];
}
}
return next;
}
};
struct AutoBlendInfo
{
std::string NodeName;
double progress;
bool Start;
bool SingleBlend;
std::unordered_map<EntityWrapper, double> StartWeights;
};
BlendTree(EntityWrapper ModelEntity, Skeleton* skeleton);
~BlendTree();
std::vector<glm::mat4> GetFinalPose() { return m_FinalPose; }
glm::mat4 GetBoneTransform(int boneID);
bool IsValid() { return (m_Root == nullptr ? false : true); }
void PrintTree();
BlendTree::AutoBlendInfo AutoBlendStep(AutoBlendInfo blendInfo);
BlendTree::Node* GetCommonParent(std::string NodeName1, std::string NodeName2);
BlendTree::Node* FirstCommonParent(Node* node1, Node* node2);
EntityWrapper GetSubTreeRoot(std::string nodeName);
private:
Skeleton* m_Skeleton = nullptr;
Node* m_Root = nullptr;
std::vector<glm::mat4> m_FinalPose;
std::map<int, glm::mat4> m_FinalBoneTransforms;
std::vector<glm::mat4> AccumulateFinalPose();
BlendTree::Node* FillTreeByName(Node* parentNode, std::string name, EntityWrapper parentEntity);
std::vector<BlendTree::Node*> FindNodesByName(std::string name);
void Blend(std::map<int, Skeleton::PoseData>& pose);
};
#endif
include/Engine/Rendering/BoneAttachmentSystem.h
+1
View File
@@ -8,6 +8,7 @@
#include "Core/ResourceManager.h"
#include "Rendering/Model.h"
#include "Rendering/Skeleton.h"
#include "Rendering/BlendTree.h"
//Needs to be a higher orderlevel than AnimationSystem
class BoneAttachmentSystem : public PureSystem
include/Engine/Rendering/EAutoAnimationBlend.h
+27
View File
@@ -0,0 +1,27 @@
#ifndef Events_AutoAnimationBlend_h__
#define Events_AutoAnimationBlend_h__
#include "../Core/EventBroker.h"
#include "../Core/EntityWrapper.h"
namespace Events
{
struct AutoAnimationBlend : Event
{
EntityWrapper RootNode = EntityWrapper::Invalid;
std::string NodeName;
double Duration = 0.0;
double Delay = 0.0;
bool Start = false;
bool Reverse = false;
bool Restart = false;
bool SingleLevelBlend = false;
EntityWrapper AnimationEntity = EntityWrapper::Invalid;
};
}
#endif
include/Engine/Rendering/ModelJob.h
+6 -26
View File
@@ -15,6 +15,7 @@
#include "../Core/Transform.h"
#include "Skeleton.h"
#include "ShaderProgram.h"
#include "BlendTree.h"
struct ModelJob : RenderJob
{
@@ -123,32 +124,14 @@ struct ModelJob : RenderJob
Skeleton = Model->m_RawModel->m_Skeleton;
if (Skeleton != nullptr) {
if (world->HasComponent(Entity, "Animation")) {
auto animationComponent = world->GetComponent(Entity, "Animation");
EntityWrapper entityWrapper = EntityWrapper(world, modelComponent.EntityID);
for (int i = 1; i <= 3; i++) {
::Skeleton::AnimationData animationData;
animationData.animation = model->m_RawModel->m_Skeleton->GetAnimation(animationComponent["AnimationName" + std::to_string(i)]);
if (animationData.animation == nullptr) {
continue;
}
animationData.time = (double)animationComponent["Time" + std::to_string(i)];
animationData.weight = (double)animationComponent["Weight" + std::to_string(i)];
Animations.push_back(animationData);
}
}
if (world->HasComponent(Entity, "AnimationOffset")) {
auto animationOffsetComponent = world->GetComponent(Entity, "AnimationOffset");
AnimationOffset.animation = model->m_RawModel->m_Skeleton->GetAnimation(animationOffsetComponent["AnimationName"]);
AnimationOffset.time = (double)animationOffsetComponent["Time"];
} else {
AnimationOffset.animation = nullptr;
if(Skeleton->BlendTrees.find(entityWrapper) != Skeleton->BlendTrees.end()) {
BlendTree = Skeleton->BlendTrees.at(entityWrapper);
}
}
}
};
unsigned int TextureID;
@@ -167,10 +150,7 @@ struct ModelJob : RenderJob
glm::vec4 Color;
const ::Model* Model = nullptr;
::Skeleton* Skeleton = nullptr;
std::vector<::Skeleton::AnimationData> Animations;
::Skeleton::AnimationOffset AnimationOffset;
std::shared_ptr<::BlendTree> BlendTree = nullptr;
float GlowIntensity = 8.0;
glm::vec4 DiffuseColor;
glm::vec4 SpecularColor;
include/Engine/Rendering/Skeleton.h
+21 -57
View File
@@ -6,27 +6,9 @@
#include "../GLM.h"
#include <glm/gtx/matrix_decompose.hpp>
#include <imgui/imgui.h>
#include "../Core/EntityWrapper.h"
//struct Bone
//{
// Bone(std::string name, glm::mat4 offsetMatrix)
// : Name(name)
// , OffsetMatrix(offsetMatrix)
// { }
//
// ~Bone()
// {
// for (auto kv : Children) {
// delete kv.second;
// }
// }
//
// std::string Name;
// glm::mat4 OffsetMatrix;
// glm::mat4 LocalMatrix;
//
// std::map<std::string, Bone*> Children;
//};
class BlendTree;
class Skeleton
{
@@ -68,58 +50,40 @@ public:
std::map<int, std::vector<Keyframe>> JointAnimations;
};
struct AnimationData
{
const Animation* animation;
float time;
float weight;
};
struct JointFrameTransform {
glm::vec3 PositionInterp = glm::vec3(0);
glm::quat RotationInterp = glm::quat();
glm::vec3 ScaleInterp = glm::vec3(0);
float Weight;
};
struct AnimationOffset {
const Animation* animation;
float time;
struct PoseData {
glm::vec3 Translation;
glm::quat Orientation;
glm::vec3 Scale;
};
Skeleton() { }
~Skeleton();
Bone* RootBone;
std::map<int, Bone*> Bones;
std::unordered_map<EntityWrapper, std::shared_ptr<BlendTree>> BlendTrees;
// Attach a new bone to the skeleton
// Returns: New bone index
int CreateBone(int ID, int parentID, std::string name, glm::mat4 offsetMatrix);
int GetBoneID(std::string name);
std::vector<glm::mat4> GetFrameBones(std::vector<AnimationData> animations, AnimationOffset animationOffset, bool noRootMotion = false);
std::vector<glm::mat4> GetFrameBones(std::vector<AnimationData> animations, bool noRootMotion = false);
const Animation* GetAnimation(std::string name);
void AccumulateBoneTransforms(bool noRootMotion, std::vector<AnimationData> animations, std::map<int, glm::mat4>& frameBones, const Bone* bone, glm::mat4 parentMatrix);
void AccumulateBoneTransforms(bool noRootMotion, std::vector<AnimationData> animations, AnimationOffset animationOffset, std::map<int, glm::mat4>& frameBones, const Bone* bone, glm::mat4 parentMatrix);
void PrintSkeleton();
void PrintSkeleton(const Bone* parent, int depthCount);
std::map<std::string, Animation> Animations;
glm::mat4 GetBoneTransform(const Bone* bone, const Animation* animation, float time, glm::mat4 childMatrix);
glm::mat4 GetBoneTransform(bool noRootMotion, const Bone* bone, std::vector<AnimationData> animations, AnimationOffset animationOffset, glm::mat4 childMatrix);
glm::mat4 GetBoneTransform(bool noRootMotion, const Bone* bone, std::vector<AnimationData> animations, glm::mat4 childMatrix);
int GetKeyframe(const Animation& animation, double time);
std::map<int, Skeleton::PoseData> GetFrameBones(const Animation* animation, double time, bool additive, bool noRootMotion = false);
std::map<int, Skeleton::PoseData> BlendPoses(const std::map<int, PoseData>& pose1, const std::map<int, PoseData>& pose2, double weight);
std::map<int, Skeleton::PoseData> OverridePose(const std::map<int, PoseData>& overridePose, const std::map<int, PoseData>& targetPose);
std::map<int, Skeleton::PoseData> BlendPoseAdditive(const std::map<int, PoseData>& additivePose, const std::map<int, PoseData>& targetPose);
void GetFinalPose(std::map<int, Skeleton::PoseData>& boneMatrices, std::vector<glm::mat4>& finalPose, std::map<int, glm::mat4>& boneTransforms);
std::map<std::string, Animation> Animations;
private:
glm::mat4 GetOffsetTransform(const Bone* bone, AnimationOffset animationOffset);
Skeleton::PoseData GetAdditiveBonePose(const Bone* bone, const Animation* animation, double time);
void AccumulateFinalPose(std::map<int, glm::mat4>& boneMatrices, std::map<int, Skeleton::PoseData>& poseDatas, std::map<int, glm::mat4>& boneTransforms, const Bone* bone, glm::mat4 parentMatrix);
void AdditiveBoneTransforms(const Animation* animation, double time, std::map<int, PoseData>& boneMatrices, const Bone* bone);
void AccumulateBoneTransforms(bool noRootMotion, const Animation* animation, double time, std::map<int, PoseData>& boneMatrices, const Bone* bone);
std::map<std::string, Bone*> m_BonesByName;
include/Game/Systems/LifetimeSystem.h
+1 -1
View File
@@ -10,7 +10,7 @@ public:
: System(params)
, PureSystem("Lifetime")
{
LOG_INFO("ASDASDASSA");
}
virtual void Update(double dt) override;