TriangleMesh.hpp

#pragma once
 
#include <Core/Containers/VectorArray.hpp>
#include <Core/Geometry/AbstractGeometry.hpp>
#include <Core/Geometry/StandardAttribNames.hpp>
#include <Core/RaCore.hpp>
#include <Core/Types.hpp>
#include <Core/Utils/Attribs.hpp>
#include <Core/Utils/Color.hpp>
#include <Core/Utils/Observable.hpp>
 
namespace Ra {
namespace Core {
namespace Geometry {
 
class RA_CORE_API AttribArrayGeometry : public AbstractGeometry
{
  public:
    using Point  = Vector3;
    using Normal = Vector3;
 
    using PointAttribHandle  = Utils::AttribHandle<Point>;
    using NormalAttribHandle = Utils::AttribHandle<Normal>;
    using FloatAttribHandle  = Utils::AttribHandle<Scalar>;
    using Vec2AttribHandle   = Utils::AttribHandle<Vector2>;
    using Vec3AttribHandle   = Utils::AttribHandle<Vector3>;
    using Vec4AttribHandle   = Utils::AttribHandle<Vector4>;
 
    inline AttribArrayGeometry() : AbstractGeometry() { initDefaultAttribs(); }
 
    inline explicit AttribArrayGeometry( const AttribArrayGeometry& other );
 
    inline explicit AttribArrayGeometry( AttribArrayGeometry&& other );
 
    inline AttribArrayGeometry& operator=( const AttribArrayGeometry& other );
 
    inline AttribArrayGeometry& operator=( AttribArrayGeometry&& other );
 
    ~AttribArrayGeometry() = default;
 
    bool append( const AttribArrayGeometry& other );
 
    void clear() override;
 
    inline void setVertices( PointAttribHandle::Container&& vertices );
    inline void setVertices( const PointAttribHandle::Container& vertices );
 
    inline const PointAttribHandle::Container& vertices() const;
 
    inline void setNormals( PointAttribHandle::Container&& normals );
    inline void setNormals( const PointAttribHandle::Container& normals );
 
    inline const NormalAttribHandle::Container& normals() const;
 
    template <typename T>
    inline Utils::AttribHandle<T> getAttribHandle( const std::string& name ) const;
 
    template <typename T>
    inline bool isValid( const Utils::AttribHandle<T>& h ) const;
 
 
    template <typename T>
    inline Utils::Attrib<T>& getAttrib( const Utils::AttribHandle<T>& h );
    template <typename T>
    inline const Utils::Attrib<T>& getAttrib( const Utils::AttribHandle<T>& h ) const;
 
    template <typename T>
    inline Utils::Attrib<T>& getAttrib( const std::string& name );
    template <typename T>
    inline const Utils::Attrib<T>& getAttrib( const std::string& name ) const;
 
    template <typename T>
    inline Utils::Attrib<T>* getAttribPtr( const Utils::AttribHandle<T>& h );
    template <typename T>
    inline const Utils::Attrib<T>* getAttribPtr( const Utils::AttribHandle<T>& h ) const;
 
    inline Utils::AttribBase* getAttribBase( const std::string& name );
    inline const Utils::AttribBase* getAttribBase( const std::string& name ) const;
 
    inline bool hasAttrib( const std::string& name ) const;
 
    template <typename T>
    inline Utils::AttribHandle<T> addAttrib( const std::string& name );
 
    template <typename T>
    inline Utils::AttribHandle<T> addAttrib( const std::string& name,
                                             const typename Core::VectorArray<T>& data );
 
    template <typename T>
    inline Utils::AttribHandle<T> addAttrib( const std::string& name,
                                             const typename Utils::Attrib<T>::Container&& data );
 
    template <typename T>
    inline void removeAttrib( Utils::AttribHandle<T>& h );
 
    inline void clearAttributes();
 
    inline virtual void copyBaseGeometry( const AttribArrayGeometry& other );
 
    template <typename... Handles>
    bool copyAttributes( const AttribArrayGeometry& input, Handles... attribs );
 
    inline bool copyAllAttributes( const AttribArrayGeometry& input );
 
    inline Aabb computeAabb() const override;
 
    void colorize( const Utils::Color& c );
 
    inline Utils::AttribManager& vertexAttribs();
 
    inline const Utils::AttribManager& vertexAttribs() const;
 
    inline PointAttribHandle::Container& verticesWithLock();
 
    inline void verticesUnlock();
 
    inline NormalAttribHandle::Container& normalsWithLock();
 
    inline void normalsUnlock();
 
  private:
    inline void initDefaultAttribs();
 
    template <typename T>
    void append_attrib( Utils::AttribBase* attr );
 
    Utils::AttribManager m_vertexAttribs;
 
    PointAttribHandle m_verticesHandle;
 
    NormalAttribHandle m_normalsHandle;
};
 
class RA_CORE_API PointCloud : public AttribArrayGeometry
{};
 
class RA_CORE_API LineStrip : public AttribArrayGeometry
{};
 
inline AttribArrayGeometry ::AttribArrayGeometry( const AttribArrayGeometry& other ) :
    AbstractGeometry( other ) {
    m_vertexAttribs.copyAllAttributes( other.m_vertexAttribs );
    m_verticesHandle = other.m_verticesHandle;
    m_normalsHandle  = other.m_normalsHandle;
}
 
inline AttribArrayGeometry::AttribArrayGeometry( AttribArrayGeometry&& other ) :
    m_vertexAttribs( std::move( other.m_vertexAttribs ) ),
    m_verticesHandle( std::move( other.m_verticesHandle ) ),
    m_normalsHandle( std::move( other.m_normalsHandle ) ) {}
 
inline AttribArrayGeometry& AttribArrayGeometry::operator=( const AttribArrayGeometry& other ) {
    if ( this != &other ) {
        m_vertexAttribs.clear();
        m_vertexAttribs.copyAllAttributes( other.m_vertexAttribs );
        m_verticesHandle = other.m_verticesHandle;
        m_normalsHandle  = other.m_normalsHandle;
 
        invalidateAabb();
    }
    return *this;
}
 
inline AttribArrayGeometry& AttribArrayGeometry::operator=( AttribArrayGeometry&& other ) {
    if ( this != &other ) {
        m_vertexAttribs  = std::move( other.m_vertexAttribs );
        m_verticesHandle = std::move( other.m_verticesHandle );
        m_normalsHandle  = std::move( other.m_normalsHandle );
 
        invalidateAabb();
    }
    return *this;
}
 
inline void AttribArrayGeometry::clear() {
    m_vertexAttribs.clear();
    // restore the default attribs (empty though)
    initDefaultAttribs();
    invalidateAabb();
}
 
inline void AttribArrayGeometry::copyBaseGeometry( const AttribArrayGeometry& other ) {
    clear();
    m_vertexAttribs.copyAttributes(
        other.m_vertexAttribs, other.m_verticesHandle, other.m_normalsHandle );
    invalidateAabb();
}
 
template <typename... Handles>
inline bool AttribArrayGeometry::copyAttributes( const AttribArrayGeometry& input,
                                                 Handles... attribs ) {
    if ( vertices().size() != input.vertices().size() ) return false;
    // copy attribs
    m_vertexAttribs.copyAttributes( input.m_vertexAttribs, attribs... );
    invalidateAabb();
    return true;
}
 
inline bool AttribArrayGeometry::copyAllAttributes( const AttribArrayGeometry& input ) {
    if ( vertices().size() != input.vertices().size() ) return false;
    // copy attribs
    m_vertexAttribs.copyAllAttributes( input.m_vertexAttribs );
    invalidateAabb();
    return true;
}
 
inline Aabb AttribArrayGeometry::computeAabb() const {
    if ( !isAabbValid() ) {
        Aabb aabb;
        for ( const auto& v : vertices() ) {
            aabb.extend( v );
        }
        setAabb( aabb );
    }
 
    return getAabb();
}
 
inline void AttribArrayGeometry::setVertices( PointAttribHandle::Container&& vertices ) {
    m_vertexAttribs.setAttrib( m_verticesHandle, std::move( vertices ) );
    invalidateAabb();
}
 
inline void AttribArrayGeometry::setVertices( const PointAttribHandle::Container& vertices ) {
    m_vertexAttribs.setAttrib<PointAttribHandle::value_type>( m_verticesHandle, vertices );
    invalidateAabb();
}
 
inline const AttribArrayGeometry::PointAttribHandle::Container&
AttribArrayGeometry::vertices() const {
    return m_vertexAttribs.getAttrib( m_verticesHandle ).data();
}
 
inline void AttribArrayGeometry::setNormals( PointAttribHandle::Container&& normals ) {
    m_vertexAttribs.setAttrib( m_normalsHandle, std::move( normals ) );
}
inline void AttribArrayGeometry::setNormals( const PointAttribHandle::Container& normals ) {
    m_vertexAttribs.setAttrib( m_normalsHandle, normals );
}
 
inline const AttribArrayGeometry::NormalAttribHandle::Container&
AttribArrayGeometry::normals() const {
    return m_vertexAttribs.getAttrib( m_normalsHandle ).data();
}
 
template <typename T>
inline Utils::AttribHandle<T>
AttribArrayGeometry::getAttribHandle( const std::string& name ) const {
    return m_vertexAttribs.findAttrib<T>( name );
}
 
template <typename T>
inline bool AttribArrayGeometry::isValid( const Utils::AttribHandle<T>& h ) const {
    return m_vertexAttribs.isValid( h );
}
 
template <typename T>
inline Utils::Attrib<T>& AttribArrayGeometry::getAttrib( const Utils::AttribHandle<T>& h ) {
    return m_vertexAttribs.getAttrib( h );
}
 
template <typename T>
const Utils::Attrib<T>& AttribArrayGeometry::getAttrib( const Utils::AttribHandle<T>& h ) const {
    return m_vertexAttribs.getAttrib( h );
}
 
inline Utils::AttribBase* AttribArrayGeometry::getAttribBase( const std::string& name ) {
    return m_vertexAttribs.getAttribBase( name );
}
 
inline const Utils::AttribBase*
AttribArrayGeometry::getAttribBase( const std::string& name ) const {
    return m_vertexAttribs.getAttribBase( name );
}
 
template <typename T>
inline const Utils::Attrib<T>& AttribArrayGeometry::getAttrib( const std::string& name ) const {
    return m_vertexAttribs.getAttrib<T>( name );
}
 
template <typename T>
inline Utils::Attrib<T>& AttribArrayGeometry::getAttrib( const std::string& name ) {
    return m_vertexAttribs.getAttrib<T>( name );
}
 
inline bool AttribArrayGeometry::hasAttrib( const std::string& name ) const {
    return m_vertexAttribs.contains( name );
}
 
template <typename T>
inline Utils::AttribHandle<T> AttribArrayGeometry::addAttrib( const std::string& name ) {
    invalidateAabb();
    return m_vertexAttribs.addAttrib<T>( name );
}
 
template <typename T>
inline Utils::AttribHandle<T>
AttribArrayGeometry::addAttrib( const std::string& name,
                                const typename Core::VectorArray<T>& data ) {
    auto handle = addAttrib<T>( name );
    getAttrib( handle ).setData( data );
    invalidateAabb();
    return handle;
}
 
template <typename T>
inline Utils::AttribHandle<T>
AttribArrayGeometry::addAttrib( const std::string& name,
                                const typename Utils::Attrib<T>::Container&& data ) {
    auto handle = addAttrib<T>( name );
    getAttrib( handle ).setData( std::move( data ) );
    invalidateAabb();
    return handle;
}
 
template <typename T>
inline void AttribArrayGeometry::removeAttrib( Utils::AttribHandle<T>& h ) {
    m_vertexAttribs.removeAttrib( h );
    invalidateAabb();
}
 
inline Utils::AttribManager& AttribArrayGeometry::vertexAttribs() {
    return m_vertexAttribs;
}
 
inline const Utils::AttribManager& AttribArrayGeometry::vertexAttribs() const {
    return m_vertexAttribs;
}
 
inline AttribArrayGeometry::PointAttribHandle::Container& AttribArrayGeometry::verticesWithLock() {
    return m_vertexAttribs.getAttrib( m_verticesHandle ).getDataWithLock();
}
 
inline void AttribArrayGeometry::verticesUnlock() {
    return m_vertexAttribs.getAttrib( m_verticesHandle ).unlock();
}
 
inline AttribArrayGeometry::NormalAttribHandle::Container& AttribArrayGeometry::normalsWithLock() {
    return m_vertexAttribs.getAttrib( m_normalsHandle ).getDataWithLock();
}
 
inline void AttribArrayGeometry::normalsUnlock() {
    return m_vertexAttribs.getAttrib( m_normalsHandle ).unlock();
}
 
inline void AttribArrayGeometry::initDefaultAttribs() {
    m_verticesHandle = m_vertexAttribs.addAttrib<PointAttribHandle::value_type>(
        getAttribName( MeshAttrib::VERTEX_POSITION ) );
    m_normalsHandle = m_vertexAttribs.addAttrib<NormalAttribHandle::value_type>(
        getAttribName( MeshAttrib::VERTEX_NORMAL ) );
    invalidateAabb();
}
 
template <typename T>
inline void AttribArrayGeometry::append_attrib( Utils::AttribBase* attr ) {
    auto h         = m_vertexAttribs.findAttrib<T>( attr->getName() );
    auto& v0       = m_vertexAttribs.getAttrib( h ).getDataWithLock();
    const auto& v1 = attr->cast<T>().data();
    v0.insert( v0.end(), v1.cbegin(), v1.cend() );
    m_vertexAttribs.getAttrib( h ).unlock();
    invalidateAabb();
}
 
} // namespace Geometry
} // namespace Core
} // namespace Ra
 
#include "IndexedGeometry.hpp"