HandleData.hpp

#pragma once
 
#include <Core/Asset/AssetData.hpp>
#include <Core/Containers/AlignedStdVector.hpp>
#include <Core/RaCore.hpp>
#include <Core/Types.hpp>
#include <Core/Utils/Log.hpp>
 
#include <map>
#include <set>
#include <string>
#include <vector>
 
namespace Ra {
namespace Core {
namespace Asset {
 
struct RA_CORE_API HandleComponentData {
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
    HandleComponentData();
 
    std::string m_name;
 
    Core::Transform m_frame { Core::Transform::Identity() };
 
    std::map<std::string, Core::Transform> m_bindMatrices;
 
    std::map<std::string, std::vector<std::pair<uint, Scalar>>> m_weights;
};
 
class RA_CORE_API HandleData : public AssetData
{
  public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
    enum HandleType { UNKNOWN = 1 << 0, POINT_CLOUD = 1 << 1, SKELETON = 1 << 2, CAGE = 1 << 3 };
 
    HandleData( const std::string& name = "", const HandleType& type = UNKNOWN );
 
    HandleData( const HandleData& data ) = default;
 
    ~HandleData();
 
 
    inline void setName( const std::string& name );
 
    inline HandleType getType() const;
 
    inline void setType( const HandleType& type );
 
    inline Core::Transform getFrame() const;
 
    inline void setFrame( const Core::Transform& frame );
 
    inline void addBindMesh( const std::string& name );
 
    inline const std::set<std::string>& getBindMeshes() const;
 
    inline uint getVertexSize() const;
 
    inline void setVertexSize( uint size );
 
    inline void setNameTable( const std::map<std::string, uint>& nameTable );
 
    inline void recomputeAllIndices();
 
 
    inline uint getComponentDataSize() const;
 
    inline const Core::AlignedStdVector<HandleComponentData>& getComponentData() const;
 
    inline Core::AlignedStdVector<HandleComponentData>& getComponentData();
 
    inline const HandleComponentData& getComponent( const uint i ) const;
 
    inline HandleComponentData& getComponent( const uint i );
 
    inline void setComponents( const Core::AlignedStdVector<HandleComponentData>& components );
 
    inline const Core::AlignedStdVector<Core::Vector2ui>& getEdgeData() const;
 
    inline Core::AlignedStdVector<Core::Vector2ui>& getEdgeData();
 
    inline void setEdges( const Core::AlignedStdVector<Core::Vector2ui>& edgeList );
 
    inline const Core::AlignedStdVector<Core::VectorNui>& getFaceData() const;
 
    inline Core::AlignedStdVector<Core::VectorNui>& getFaceData();
 
    inline void setFaces( const Core::AlignedStdVector<Core::VectorNui>& faceList );
 
    inline void needEndNodes( bool need );
 
 
    inline bool isPointCloud() const;
 
    inline bool isSkeleton() const;
 
    inline bool isCage() const;
 
    inline bool hasComponents() const;
 
    inline bool hasEdges() const;
 
    inline bool hasFaces() const;
 
    inline bool needsEndNodes() const;
 
    inline int getIndexOf( const std::string& name ) const;
 
    inline void displayInfo() const;
 
  private:
    HandleType m_type;
 
    Core::Transform m_frame { Core::Transform::Identity() };
 
    bool m_endNode { false };
 
    uint m_vertexSize { 0 };
 
    std::map<std::string, uint> m_nameTable;
 
    std::set<std::string> m_bindMeshes;
 
    Core::AlignedStdVector<HandleComponentData> m_component;
 
    Core::AlignedStdVector<Core::Vector2ui> m_edge;
 
    Core::AlignedStdVector<Core::VectorNui> m_face;
};
 
inline void HandleData::setName( const std::string& name ) {
    m_name = name;
}
 
inline HandleData::HandleType HandleData::getType() const {
    return m_type;
}
 
inline void HandleData::setType( const HandleType& type ) {
    m_type = type;
}
 
inline Core::Transform HandleData::getFrame() const {
    return m_frame;
}
 
inline void HandleData::setFrame( const Core::Transform& frame ) {
    m_frame = frame;
}
 
inline uint HandleData::getVertexSize() const {
    return m_vertexSize;
}
inline void HandleData::setVertexSize( uint size ) {
    m_vertexSize = size;
}
 
inline void HandleData::setNameTable( const std::map<std::string, uint>& nameTable ) {
    m_nameTable = nameTable;
}
 
inline uint HandleData::getComponentDataSize() const {
    return m_component.size();
}
 
inline const Core::AlignedStdVector<HandleComponentData>& HandleData::getComponentData() const {
    return m_component;
}
 
inline Core::AlignedStdVector<HandleComponentData>& HandleData::getComponentData() {
    return m_component;
}
 
inline void
HandleData::setComponents( const Core::AlignedStdVector<HandleComponentData>& components ) {
    const uint size = components.size();
    m_component.resize( size );
#pragma omp parallel for
    for ( int i = 0; i < int( size ); ++i ) {
        m_component[i] = components[i];
    }
}
 
inline const HandleComponentData& HandleData::getComponent( const uint i ) const {
    CORE_ASSERT( ( i < m_component.size() ), "Index i out of bound" );
    return m_component[i];
}
 
inline HandleComponentData& HandleData::getComponent( const uint i ) {
    CORE_ASSERT( ( i < m_component.size() ), "Index i out of bound" );
    return m_component[i];
}
 
inline const Core::AlignedStdVector<Core::Vector2ui>& HandleData::getEdgeData() const {
    return m_edge;
}
 
inline Core::AlignedStdVector<Core::Vector2ui>& HandleData::getEdgeData() {
    return m_edge;
}
 
inline void HandleData::setEdges( const Core::AlignedStdVector<Core::Vector2ui>& edgeList ) {
    const uint size = edgeList.size();
    m_edge.resize( size );
#pragma omp parallel for
    for ( int i = 0; i < int( size ); ++i ) {
        m_edge[i] = edgeList[i];
    }
}
 
inline const Core::AlignedStdVector<Core::VectorNui>& HandleData::getFaceData() const {
    return m_face;
}
 
inline Core::AlignedStdVector<Core::VectorNui>& HandleData::getFaceData() {
    return m_face;
}
 
inline void HandleData::setFaces( const Core::AlignedStdVector<Core::VectorNui>& faceList ) {
    const uint size = faceList.size();
    m_face.resize( size );
#pragma omp parallel for
    for ( int i = 0; i < int( size ); ++i ) {
        m_face[i] = faceList[i];
    }
}
 
inline void HandleData::recomputeAllIndices() {
    m_nameTable.clear();
    for ( uint i = 0; i < getComponentDataSize(); ++i ) {
        m_nameTable[m_component[i].m_name] = i;
    }
}
 
inline bool HandleData::isPointCloud() const {
    return ( m_type == POINT_CLOUD );
}
 
inline bool HandleData::isSkeleton() const {
    return ( m_type == SKELETON );
}
 
inline bool HandleData::isCage() const {
    return ( m_type == CAGE );
}
 
inline bool HandleData::hasComponents() const {
    return !m_component.empty();
}
 
inline bool HandleData::hasEdges() const {
    return !m_edge.empty();
}
 
inline bool HandleData::hasFaces() const {
    return !m_face.empty();
}
 
inline bool HandleData::needsEndNodes() const {
    return m_endNode;
}
 
inline int HandleData::getIndexOf( const std::string& name ) const {
    auto it = m_nameTable.find( name );
    if ( it == m_nameTable.end() ) { return -1; }
    return it->second;
}
 
inline void HandleData::needEndNodes( bool need ) {
    m_endNode = need;
}
 
inline void HandleData::addBindMesh( const std::string& name ) {
    m_bindMeshes.insert( name );
}
 
inline const std::set<std::string>& HandleData::getBindMeshes() const {
    return m_bindMeshes;
}
 
inline void HandleData::displayInfo() const {
    using namespace Core::Utils; // log
    std::string type;
    switch ( m_type ) {
    case POINT_CLOUD:
        type = "POINT CLOUD";
        break;
    case SKELETON:
        type = "SKELETON";
        break;
    case CAGE:
        type = "CAGE";
        break;
    case UNKNOWN:
    default:
        type = "UNKNOWN";
        break;
    }
    LOG( logINFO ) << "======== HANDLE INFO ========";
    LOG( logINFO ) << " Name            : " << m_name;
    LOG( logINFO ) << " Type            : " << type;
    LOG( logINFO ) << " Element #       : " << m_component.size();
    LOG( logINFO ) << " Edge #          : " << m_edge.size();
    LOG( logINFO ) << " Face #          : " << m_face.size();
    LOG( logINFO ) << " Need EndNodes ? : " << ( ( m_endNode ) ? "YES" : "NO" );
}
 
} // namespace Asset
} // namespace Core
} // namespace Ra