ParaXBone.h

#pragma once
#include "animated.h"
#include "IAttributeFields.h"

namespace ParaEngine
{
    class CBVHSerializer;

    class Bone : public IAttributeFields
    {
    public:
        Bone();
        virtual ~Bone();

        ATTRIBUTE_DEFINE_CLASS(Bone);

        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);
        
        ATTRIBUTE_METHOD1(Bone, GetRotName_s, const char**)     { *p1 = cls->GetRotName().c_str(); return S_OK; }
        ATTRIBUTE_METHOD1(Bone, GetTransName_s, const char**)       { *p1 = cls->GetTransName().c_str(); return S_OK; }
        ATTRIBUTE_METHOD1(Bone, GetScaleName_s, const char**)       { *p1 = cls->GetScaleName().c_str(); return S_OK; }

        ATTRIBUTE_METHOD1(Bone, IsBillBoarded_s, bool*)     { *p1 = cls->IsBillBoarded(); return S_OK; }
        ATTRIBUTE_METHOD1(Bone, IsPivotBone_s, bool*)       { *p1 = cls->IsPivotBone(); return S_OK; }
        ATTRIBUTE_METHOD1(Bone, IsOffsetMatrixBone_s, bool*){ *p1 = cls->IsOffsetMatrixBone(); return S_OK; }
        ATTRIBUTE_METHOD1(Bone, IsTransformationNode_s, bool*)  { *p1 = cls->IsTransformationNode(); return S_OK; }
        ATTRIBUTE_METHOD1(Bone, IsStaticTransform_s, bool*) { *p1 = cls->IsStaticTransform(); return S_OK; }
        ATTRIBUTE_METHOD1(Bone, IsAnimated_s, bool*)        { *p1 = cls->IsAnimated(); return S_OK; }

        ATTRIBUTE_METHOD1(Bone, SetOffsetMatrix_s, const Matrix4&)      { cls->SetOffsetMatrix(p1); return S_OK; }
        ATTRIBUTE_METHOD1(Bone, SetStaticTransform_s, const Matrix4&)       { cls->SetStaticTransform(p1); return S_OK; }
        
        ATTRIBUTE_METHOD(Bone, RemoveRedundentKeys_s)       { cls->RemoveRedundentKeys(); return S_OK; }
        
        ATTRIBUTE_METHOD1(Bone, GetFinalMatrix_s, Matrix4*)     { *p1 = cls->GetFinalMatrix(); return S_OK; }
        ATTRIBUTE_METHOD1(Bone, GetFinalRotMatrix_s, Matrix4*)      { *p1 = cls->GetFinalRotMatrix(); return S_OK; }
        ATTRIBUTE_METHOD1(Bone, GetPivotRotMatrix_s, Matrix4*)      { *p1 = cls->GetPivotRotMatrix(); return S_OK; }
        
        ATTRIBUTE_METHOD1(Bone, GetPivotPoint_s, Vector3*)      { *p1 = cls->GetPivotPoint(); return S_OK; }
        ATTRIBUTE_METHOD1(Bone, GetAnimatedPivotPoint_s, Vector3*)      { *p1 = cls->GetAnimatedPivotPoint(); return S_OK; }

        ATTRIBUTE_METHOD1(Bone, SetFinalRot_s, Quaternion)      { cls->SetFinalRot(p1); return S_OK; }
        ATTRIBUTE_METHOD1(Bone, GetFinalRot_s, Quaternion*)     { *p1 = cls->GetFinalRot(); return S_OK; }

        ATTRIBUTE_METHOD1(Bone, SetFinalTrans_s, Vector3)       { cls->SetFinalTrans(p1); return S_OK; }
        ATTRIBUTE_METHOD1(Bone, GetFinalTrans_s, Vector3*)      { *p1 = cls->GetFinalTrans(); return S_OK; }

        ATTRIBUTE_METHOD1(Bone, SetFinalScaling_s, Vector3)     { cls->SetFinalScaling(p1); return S_OK; }
        ATTRIBUTE_METHOD1(Bone, GetFinalScaling_s, Vector3*)        { *p1 = cls->GetFinalScaling(); return S_OK; }

        ATTRIBUTE_METHOD1(Bone, GetParentIndex_s, int*)     { *p1 = cls->GetParentIndex(); return S_OK; }
        ATTRIBUTE_METHOD1(Bone, GetBoneIndex_s, int*)       { *p1 = cls->GetBoneIndex(); return S_OK; }
        
        ATTRIBUTE_METHOD1(Bone, GetBoneID_s, int*)      { *p1 = cls->GetBoneID(); return S_OK; }
        ATTRIBUTE_METHOD1(Bone, SetBoneID_s, int)       { cls->SetBoneID(p1); return S_OK; }
        
    public:
        virtual const std::string& GetIdentifier();
        virtual void SetIdentifier(const std::string& sID);

        bool IsBillBoarded() const { return (flags & BONE_BILLBOARDED) != 0; };
        bool IsPivotBone() const { return (flags & BONE_OFFSET_MATRIX) == 0; };
        bool IsOffsetMatrixBone() const { return (flags & BONE_OFFSET_MATRIX) != 0; };
        bool IsStaticTransform() const { return (flags & BONE_STATIC_TRANSFORM) != 0; };
        bool IsTransformationNode() const { return (flags & BONE_TRANSFORMATION_NODE) != 0; };

        void SetOffsetMatrix(const Matrix4& mat);
        
        void SetStaticTransform(const Matrix4& mat);

        bool CheckHasAnimation();

        const std::string& GetName() const;
        void SetName(const std::string& val);

        void AutoSetBoneInfoFromName();

        bool IsAnimated();
        bool calcMatrix(Bone* allbones, const AnimIndex & CurrentAnim, const AnimIndex & BlendingAnim, float blendingFactor, IAttributeFields* pAnimInstance = NULL);
        void calcMatrix(Bone* allbones);

        bool GetExternalRot(IAttributeFields* pAnimInstance, Quaternion& outQuat);
        bool GetExternalTranslation(IAttributeFields* pAnimInstance, Vector3& outTrans);
        bool GetExternalScaling(IAttributeFields* pAnimInstance, Vector3& outScaling);

        void RemoveRedundentKeys();

        /* rotation and offset matrix are processed */
        void PostCalculateBoneMatrix();
        
        const ParaEngine::Matrix4& GetFinalMatrix();
        const Vector3& GetPivotPoint();

        Vector3 GetAnimatedPivotPoint();

        int GetParentIndex() const { return parent; }
        int GetBoneIndex() const { return nIndex; }
        int GetBoneID() const { return nBoneID; }
        int IsAttachment() const;
        int GetAttachmentId() const;
        void SetBoneID(int val) { nBoneID = val; }

        const ParaEngine::Quaternion& GetFinalRot() const;
        void SetFinalRot(const ParaEngine::Quaternion& val);

        const Vector3 & GetFinalTrans() const;
        void SetFinalTrans(const Vector3 &val);

        const Vector3& GetFinalScaling() const;
        void SetFinalScaling(const Vector3& val);

        const ParaEngine::Matrix4& GetFinalRotMatrix() const;
        Matrix4 GetPivotRotMatrix();
        
        void MakeDirty(bool bForce = false);

        friend class CBVHSerializer;
    public:
        enum BONE_FLAGS
        {
            BONE_USE_PIVOT = 0,
            BONE_BILLBOARDED = (0x1 << 3),
            BONE_OFFSET_MATRIX = (0x1 << 4),
            BONE_STATIC_TRANSFORM = (0x1 << 5),
            /* the bone is the transformation node */
            BONE_TRANSFORMATION_NODE = (0x1 << 6),
        };
        std::string m_sIdentifer;
        std::string m_sRotName;
        std::string m_sTransName;
        std::string m_sScaleName;
        const std::string& GetRotName();
        const std::string& GetTransName();
        const std::string& GetScaleName();

        Animated<Vector3> trans;
        Animated<Quaternion> rot;
        Animated<Vector3> scale;

        // pivot point in binding pos
        Vector3 pivot;
        
        // offset matrix that transforms from mesh space to the current bone space. 
        Matrix4 matOffset;
        // the bone has no animation and a static transform is used to transform from current bone space to its parent bone space. 
        Matrix4 matTransform;

        // index of the parent bone
        int parent;
        
        // the predefined bone ID. it is 0 for unknown bones, positive for known bones. one of the KNOWN_BONE_NODES
        int nBoneID;

        // index of this bone
        int nIndex;
        
        // bitwise fields of bone attributes. BONE_BILLBOARDED for bill boarded. 
        DWORD flags;
    
        // temporary final matrix
        Matrix4 mat;
        
        // temporary final rotation matrix
        Matrix4 mrot;
        
        // temporary final m_finalRot used in composing the final mat
        Quaternion m_finalRot;

        // temporary final m_finalTrans used in composing the final mat
        Vector3 m_finalTrans;

        // temporary final m_finalScaling used in composing the final mat
        Vector3 m_finalScaling;
        
        bool calc;
        bool bUsePivot;

        const static int s_MaxBonesPerVertex = 4;
    };
}