GeometryData.hpp

#pragma once
 
#include <Core/Asset/AssetData.hpp>
#include <Core/Asset/MaterialData.hpp>
#include <Core/Containers/VectorArray.hpp>
#include <Core/Geometry/StandardAttribNames.hpp>
#include <Core/Geometry/TriangleMesh.hpp>
#include <Core/RaCore.hpp>
#include <Core/Types.hpp>
#include <Core/Utils/Attribs.hpp>
#include <Core/Utils/Index.hpp>
 
#include <memory>
#include <string>
#include <vector>
 
#include <algorithm> //std::transform
 
namespace Ra {
namespace Core {
namespace Asset {
 
class MaterialData;
 
class RA_CORE_API GeometryData : public AssetData
{
  public:
    using ColorArray = Vector4Array;
 
  public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
    enum GeometryType {
        UNKNOWN     = 1 << 0,
        POINT_CLOUD = 1 << 1,
        LINE_MESH   = 1 << 2,
        TRI_MESH    = 1 << 3,
        QUAD_MESH   = 1 << 4,
        POLY_MESH   = 1 << 5,
        TETRA_MESH  = 1 << 6,
        HEX_MESH    = 1 << 7
    };
 
    GeometryData( const std::string& name = "", const GeometryType& type = UNKNOWN );
 
    GeometryData( const GeometryData& data ) = delete;
 
    ~GeometryData();
 
 
    inline void setName( const std::string& name );
 
    inline GeometryType getType() const;
 
    inline void setType( const GeometryType& type );
 
    inline Transform getFrame() const;
 
    inline void setFrame( const Transform& frame );
 
    inline const MaterialData& getMaterial() const;
 
    inline void setMaterial( MaterialData* material );
 
    inline Geometry::MultiIndexedGeometry& getGeometry();
 
    inline const Geometry::MultiIndexedGeometry& getGeometry() const;
 
 
 
    inline bool isPointCloud() const;
 
    inline bool isLineMesh() const;
 
    inline bool isTriMesh() const;
 
    inline bool isQuadMesh() const;
 
    inline bool isPolyMesh() const;
 
    inline bool isTetraMesh() const;
 
    inline bool isHexMesh() const;
 
    inline bool hasEdges() const;
 
    inline bool hasFaces() const;
 
    inline bool hasPolyhedra() const;
 
    inline bool hasMaterial() const;
 
    inline void setPrimitiveCount( int n );
 
    inline int getPrimitiveCount() const;
 
 
    void displayInfo() const;
 
  protected:
    Transform m_frame;
 
    GeometryType m_type;
 
    Core::Geometry::MultiIndexedGeometry m_geometry;
 
    int m_primitiveCount { -1 };
 
    std::shared_ptr<MaterialData> m_material;
};
 
inline void GeometryData::setName( const std::string& name ) {
    m_name = name;
}
 
inline GeometryData::GeometryType GeometryData::getType() const {
    return m_type;
}
 
inline void GeometryData::setType( const GeometryType& type ) {
    m_type = type;
}
 
inline Transform GeometryData::getFrame() const {
    return m_frame;
}
 
inline void GeometryData::setFrame( const Transform& frame ) {
    m_frame = frame;
}
 
inline const MaterialData& GeometryData::getMaterial() const {
    return *( m_material.get() );
}
 
inline void GeometryData::setMaterial( MaterialData* material ) {
    m_material.reset( material );
}
 
inline bool GeometryData::isPointCloud() const {
    return ( m_type == POINT_CLOUD );
}
 
inline bool GeometryData::isLineMesh() const {
    return ( m_type == LINE_MESH );
}
 
inline bool GeometryData::isTriMesh() const {
    return ( m_type == TRI_MESH );
}
 
inline bool GeometryData::isQuadMesh() const {
    return ( m_type == QUAD_MESH );
}
 
inline bool GeometryData::isPolyMesh() const {
    return ( m_type == POLY_MESH );
}
 
inline bool GeometryData::isTetraMesh() const {
    return ( m_type == TETRA_MESH );
}
 
inline bool GeometryData::isHexMesh() const {
    return ( m_type == HEX_MESH );
}
 
inline bool GeometryData::hasEdges() const {
    return m_geometry.containsLayer( { Geometry::LineIndexLayer::staticSemanticName }, "indices" );
}
 
inline bool GeometryData::hasFaces() const {
    std::string layerSemanticName;
    switch ( m_type ) {
    case TRI_MESH:
        layerSemanticName = std::string( Geometry::TriangleIndexLayer::staticSemanticName );
        break;
    case QUAD_MESH:
        layerSemanticName = std::string( Geometry::QuadIndexLayer::staticSemanticName );
        break;
    case POLY_MESH:
        layerSemanticName = std::string( Geometry::PolyIndexLayer::staticSemanticName );
        break;
    default:
        return false;
    }
    return m_geometry.containsLayer( { layerSemanticName }, "indices" );
}
 
inline bool GeometryData::hasPolyhedra() const {
    return m_geometry.containsLayer( { Geometry::PolyIndexLayer::staticSemanticName }, "indices" );
}
 
inline bool GeometryData::hasMaterial() const {
    return m_material != nullptr;
}
 
const Geometry::MultiIndexedGeometry& GeometryData::getGeometry() const {
    return m_geometry;
}
 
Geometry::MultiIndexedGeometry& GeometryData::getGeometry() {
    return m_geometry;
}
 
inline void GeometryData::setPrimitiveCount( int n ) {
    m_primitiveCount = n;
}
inline int GeometryData::getPrimitiveCount() const {
    return m_primitiveCount;
}
 
} // namespace Asset
} // namespace Core
} // namespace Ra