SkinningComponent.hpp

#pragma once
 
#include <Core/Animation/HandleWeight.hpp>
#include <Core/Animation/Pose.hpp>
#include <Core/Animation/SkinningData.hpp>
#include <Core/Asset/HandleData.hpp>
#include <Core/Geometry/TopologicalMesh.hpp>
#include <Core/Geometry/TriangleMesh.hpp>
#include <Core/Math/DualQuaternion.hpp>
#include <Core/Utils/Index.hpp>
 
#include <Engine/Data/Material.hpp>
#include <Engine/Scene/Component.hpp>
#include <Engine/Scene/ComponentMessenger.hpp>
 
namespace Ra {
namespace Engine {
namespace Scene {
 
class RA_ENGINE_API SkinningComponent : public Component
{
  public:
    enum SkinningType {
        LBS = 0, 
        DQS,     
        COR,     
    };
 
    enum NormalSkinning {
        APPROX = 0, 
        GEOMETRIC   
    };
 
    enum WeightType {
        STANDARD = 0 
    };
 
    SkinningComponent( const std::string& name, SkinningType type, Entity* entity ) :
        Component( name, entity ),
        m_skinningType( type ),
        m_normalSkinning( APPROX ),
        m_isReady( false ),
        m_forceUpdate( false ),
        m_weightBone( 0 ),
        m_weightType( STANDARD ),
        m_showingWeights( false ) {}
 
    ~SkinningComponent() override {}
 
 
    virtual void initialize() override;
 
 
    void handleSkinDataLoading( const Core::Asset::HandleData* data, const std::string& meshName );
 
 
    void skin();
 
    void endSkinning();
 
    void setSkinningType( SkinningType type );
 
    inline SkinningType getSkinningType() const { return m_skinningType; }
 
    void setNormalSkinning( NormalSkinning normalSkinning );
 
    inline NormalSkinning getNormalSkinning() const { return m_normalSkinning; }
 
 
    const std::string& getMeshName() const;
 
    void setMeshName( const std::string& name ) { m_meshName = name; }
 
    const std::string& getSkeletonName() const;
 
    const Core::Animation::SkinningRefData* getSkinningRefData() const { return &m_refData; }
 
    const Core::Animation::SkinningFrameData* getSkinningFrameData() const { return &m_frameData; }
 
 
    void showWeights( bool on );
 
    bool isShowingWeights();
 
    void showWeightsType( WeightType type );
 
    WeightType getWeightsType();
 
    void setWeightBone( uint bone );
 
    void setPerBoneWeight( std::map<std::string, std::vector<std::pair<uint, Scalar>>>&& w ) {
        m_loadedWeights = w;
    }
 
    void setPerBoneMatrix( std::map<std::string, Core::Transform>&& m ) {
        m_loadedBindMatrices = m;
    }
 
  private:
    void setupIO( const std::string& id );
 
    void createWeightMatrix();
 
  private:
    template <typename T>
    using Getter = typename ComponentMessenger::CallbackTypes<T>::Getter;
 
    template <typename T>
    using ReadWrite = typename ComponentMessenger::CallbackTypes<T>::ReadWrite;
 
    std::string m_meshName;
 
    std::string m_skelName;
 
    Core::Animation::SkinningRefData m_refData;
 
    Core::Animation::SkinningFrameData m_frameData;
 
    Getter<Core::Animation::Skeleton> m_skeletonGetter;
 
    SkinningType m_skinningType;
 
    NormalSkinning m_normalSkinning;
 
    bool m_isReady;
 
    bool m_forceUpdate;
 
    Getter<Core::Utils::Index> m_renderObjectReader;
 
    bool m_meshIsPoly { false };
 
    bool m_meshIsQuad { false };
 
    ReadWrite<Core::Geometry::TriangleMesh> m_triMeshWriter;
 
    ReadWrite<Core::Geometry::PolyMesh> m_polyMeshWriter;
 
    ReadWrite<Core::Geometry::QuadMesh> m_quadMeshWriter;
 
    Core::Geometry::TopologicalMesh m_topoMesh;
 
    std::map<std::string, std::vector<std::pair<uint, Scalar>>> m_loadedWeights;
 
    std::map<std::string, Core::Transform> m_loadedBindMatrices;
 
    std::shared_ptr<Data::Material> m_baseMaterial;
 
    std::shared_ptr<Data::Material> m_weightMaterial;
 
    Core::Vector3Array m_baseUV;
 
    Core::Vector3Array m_weightsUV;
 
    uint m_weightBone;
 
    WeightType m_weightType;
 
    bool m_showingWeights;
};
 
} // namespace Scene
} // namespace Engine
} // namespace Ra