dl_model_bone.h

浏览该文件的文档.

 
#pragma once
 
#include <vector>
 
#include "memory/dl_stream_output.h"
#include "memory/dl_stream_input.h"
#include "math/dl_matrix.h"
 
namespace dl
{
 
struct BoneKeyFrame
{
    BoneKeyFrame() :
        _t(-1.0f),//负数代表无效
        _translation{},
        _roationQuat{ 1.0f, 0.0f, 0.0f, 0.0f },
        _scaling{ 1.0f, 1.0f, 1.0f }
    {}
 
    FloatTime _t;
    Position3 _translation;
    Position4 _roationQuat;
    Position3 _scaling;
};
 
 
struct BoneKeyFrameMulti
{
    //关键帧插值
    void Interpolate(FloatTime t, Matrix4& mat)
    {
        //没有关键帧直接返回（保持不变）
        if (_allKeyFrame.empty())
            return;
        //变换顺序为SRT
        mat.Identity();
 
        if (t <= _allKeyFrame.front()._t)
        {
            BoneKeyFrame& key_frame = _allKeyFrame.front();
            Matrix4 mat_t = Mat::CreateTranslation(key_frame._translation);
            Matrix4 mat_r = Mat::CreateRotation(key_frame._roationQuat);
            Matrix4 mat_s = Mat::CreateScaling(key_frame._scaling);
            mat = mat_t * mat_r * mat_s;
        }
        else if (t >= _allKeyFrame.back()._t)
        {
            BoneKeyFrame& key_frame = _allKeyFrame.back();
            Matrix4 mat_t = Mat::CreateTranslation(key_frame._translation);
            Matrix4 mat_r = Mat::CreateRotation(key_frame._roationQuat);
            Matrix4 mat_s = Mat::CreateScaling(key_frame._scaling);
            mat = mat_t * mat_r * mat_s;
        }
        else
        {
            for (size_t i = 0; i < _allKeyFrame.size() - 1; ++i)
            {//[0, n-1)
                BoneKeyFrame& kf_0 = _allKeyFrame[i];
                BoneKeyFrame& kf_1 = _allKeyFrame[i + 1];
                //找到时间范围内
                if (t >= kf_0._t && t <= kf_1._t)
                {
                    FloatTime percent = (t - kf_0._t) / (kf_1._t - kf_0._t);
 
                    Position3 t = Each::Lerp(kf_0._translation, kf_1._translation, percent);
                    Position4 r = Math::Slerp(kf_0._roationQuat, kf_1._roationQuat, percent);
                    Position3 s = Each::Lerp(kf_0._scaling, kf_1._scaling, percent);
 
                    Matrix4 mat_t = Mat::CreateTranslation(t);
                    Matrix4 mat_r = Mat::CreateRotation(r);
                    Matrix4 mat_s = Mat::CreateScaling(s);
                    mat = mat_t * mat_r * mat_s;
                    break;
                }
            }
        }
    }
 
    std::vector<BoneKeyFrame> _allKeyFrame;
};
struct AnimationClip
{
    FloatTime _t0;
    FloatTime _t1;
    std::vector<BoneKeyFrameMulti> _allBoneKeyFrameMulti;
public:
    FloatTime GetClipEndTime()
    {
        return _t1;
    }
    //插值
    void Interpolate(FloatTime t, std::vector<Matrix4>& bone_trans)
    {
        for (size_t i = 0; i < _allBoneKeyFrameMulti.size(); ++i)
        {
            _allBoneKeyFrameMulti[i].Interpolate(t, bone_trans[i]);
        }
    }
};
 
class BoneData
{
    friend class ModelLoader;
    friend class FactoryImp;
    friend class BoneAnimation;
    friend class Actor;
public:
    //偏移矩阵先初始化
    size_t GetBoneSize() { return _allBoneOffset.size(); }
    FloatTime GetClipEndTime(std::string_view cilp_name)
    {
        auto clip = _allAnimation.find(std::string{ cilp_name });
        return clip->second.GetClipEndTime();
    }
    //返回偏移矩阵（单位矩阵才是静止状态）
    std::vector<Matrix4> GetBoneOffset()
    {
        return _allBoneOffset;
    }
 
    //或许可以缓存常用时刻的变换
    void GetFinalTrans(std::string_view clip_name, FloatTime t,
        std::vector<Matrix4>& final_trans)
    {
        //偏移矩阵数量（骨骼数量）
        size_t num_bone = _allBoneOffset.size();
        //变换到父骨骼的矩阵
        std::vector<Matrix4> trans_to_parent = _allNodeTrans2Parent;
 
        //对指定动画进行插值
        auto clip = _allAnimation.find(std::string{ clip_name });
        clip->second.Interpolate(t, trans_to_parent);
 
        //将骨骼变换到根空间
        std::vector<Matrix4> trans_to_root(num_bone);
 
        //计算trans_to_root
        for (size_t i = 0; i < num_bone; ++i)
        {
            //父骨骼下标
            int index_parent = _allNodeParent[i];
            if(index_parent == -1)//指向-1为根骨骼，无需计算
                trans_to_root[i] = trans_to_parent[i];
            else
            {
                //自己到父
                Matrix4& mat_to_parent = trans_to_parent[i];
                //父骨骼 到 根 的矩阵
                Matrix4& parent_to_root = trans_to_root[index_parent];
                //自己到根的矩阵 = 自己到父，再父到根
                trans_to_root[i] = parent_to_root * mat_to_parent;
            }
        }
 
        //计算最终矩阵
        for (size_t i = 0; i < num_bone; ++i)
        {
            Matrix4& mat_offset = _allBoneOffset[i];
            Matrix4& mat_to_root = trans_to_root[i];
            final_trans[i] = mat_to_root * mat_offset;
        }
    }
 
    void Save(StreamOutput& s)
    {
        s.Write(&_allNodeParent);
        s.Write(&_allNodeTrans2Parent);
        s.Write(&_allBoneOffset);
 
        size_t size = _allAnimation.size();
        s.Write(&size);
        for (auto& iter : _allAnimation)
        {
            const std::string& name = iter.first;
            const AnimationClip& clip = iter.second;
            s.Write(&name);
            s.Write(&clip._t0);
            s.Write(&clip._t1);
            size_t size1 = clip._allBoneKeyFrameMulti.size();
            s.Write(&size1);
            for (size_t i = 0; i < size1; ++i)
            {
                const BoneKeyFrameMulti& kf_mul = clip._allBoneKeyFrameMulti[i];
                size_t size2 = kf_mul._allKeyFrame.size();
                s.Write(&size2);
                for (size_t j = 0; j < size2; ++j)
                {
                    const BoneKeyFrame& kf = kf_mul._allKeyFrame[j];
                    s.Write(&kf);
                }
            }
        }
    }
    void Load(StreamInput& s)
    {
        s.Read(&_allNodeParent);
        s.Read(&_allNodeTrans2Parent);
        s.Read(&_allBoneOffset);
 
        size_t size;
        s.Read(&size);
        for (size_t k = 0; k < size; ++k)
        {
            std::string name;
            s.Read(&name);
            AnimationClip& clip = _allAnimation[name];
            s.Read(&clip._t0);
            s.Read(&clip._t1);
            size_t size1;
            s.Read(&size1);
            clip._allBoneKeyFrameMulti.resize(size1);
            for (size_t i = 0; i < size1; ++i)
            {
                BoneKeyFrameMulti& kf_mul = clip._allBoneKeyFrameMulti[i];
                size_t size2;
                s.Read(&size2);
                kf_mul._allKeyFrame.resize(size2);
                for (size_t j = 0; j < size2; ++j)
                {
                    s.Read(&kf_mul._allKeyFrame[j]);
                }
            }
        }
    }
private:
    std::vector<int> _allNodeParent;//Node的父Node，下标为node_id
    std::vector<Matrix4> _allNodeTrans2Parent;//Node到父Node的矩阵
    std::vector<Matrix4> _allBoneOffset;//偏移矩阵
    std::unordered_map<std::string, AnimationClip> _allAnimation;//动画片段
};
 
class BoneAnimation
{
public:
    BoneData* _skinndeData;//弱引用
    std::vector<Matrix4> _finalTrans;//某时间点的最终变换
    std::string _clipName;//当前动画名称
    FloatTime _t;//时间点
    size_t _id;//骨骼实例下标（不是ub下标）
 
    BoneAnimation() :
        _skinndeData{ nullptr },
        _t{},
        _id{(size_t)-1}
    {}
 
    //t为-1代表 设为起始
    void Set(std::string_view name, FloatTime t)
    {
        auto iter = _skinndeData->_allAnimation.find(std::string{ name });
        if (iter == _skinndeData->_allAnimation.end())
        {
            log_err("指定动画不存在：{}", name);
            return;
        }
        _clipName = std::string{ name };
        AnimationClip& clip = iter->second;
        if (t < 0)
            _t = clip._t0;
        else if (Math::IsOutRange(t, clip._t0, clip._t1))
        {
            log_err("设置动画时间越界：{}，{}->{}", t, clip._t0, clip._t1);
            _t = clip._t0;
        }
        else
            _t = t;
    }
 
    void Update(FloatTime dt)
    {
        _t += dt;
        if (_t > _skinndeData->GetClipEndTime(_clipName))
            _t = 0;
        if(true)
            _skinndeData->GetFinalTrans(_clipName, _t, _finalTrans);
        else
        {
            for (auto& iter : _finalTrans)
                iter.Identity();
        }
    }
};
 
}