ManagedMesh.hpp

Go to the documentation of this file.

/*
 *  Copyright (C) 2010 - 2016 Leonid Kostrykin
 *
 *  Chair of Medical Engineering (mediTEC)
 *  RWTH Aachen University
 *  Pauwelsstr. 20
 *  52074 Aachen
 *  Germany
 * 
 * 
 *  Copyright (C) 2021 - 2025 Leonid Kostrykin
 * 
 */
 
#ifndef MANAGEDMESH_H_6014714286
#define MANAGEDMESH_H_6014714286
 
#include <LibCarna/base/Mesh.hpp>
#include <LibCarna/base/GeometryFeature.hpp>
#include <LibCarna/base/ManagedMeshInterface.hpp>
#include <memory>
#include <vector>
 
namespace LibCarna
{
 
namespace base
{
 
 
 
// ----------------------------------------------------------------------------------
// ManagedMeshBase
// ----------------------------------------------------------------------------------
 
class LIBCARNA ManagedMeshBase : public GeometryFeature
{
 
    NON_COPYABLE
    
    struct Details;
    const std::unique_ptr< Details > pimpl;
 
protected:
 
    friend class GeometryFeature;
    friend class ManagedMeshInterface;
 
    ManagedMeshBase( unsigned int primitiveType, const VertexAttributes& va );
 
    virtual ~ManagedMeshBase();
    
    virtual VertexBufferBase* loadVertexBuffer() = 0;
    
    virtual IndexBufferBase* loadIndexBuffer() = 0;
    
    void acquireMesh();
    
    void releaseMesh();
    
    const MeshBase& mesh() const;
 
public:
 
    typedef ManagedMeshInterface ManagedInterface;
 
    virtual bool controlsSameVideoResource( const GeometryFeature& ) const override;
    
    const unsigned int primitiveType;
    
    const VertexAttributes vertexAttributes;
 
    virtual ManagedMeshInterface* acquireVideoResource() override;
 
}; // ManagedMeshBase
 
 
 
// ----------------------------------------------------------------------------------
// ManagedMesh
// ----------------------------------------------------------------------------------
 
template< typename VertexType, typename IndexType >
class ManagedMesh : public ManagedMeshBase
{
 
    const std::vector< VertexType > vertices;
    const std::vector<  IndexType > indices;
 
    ManagedMesh( unsigned int primitiveType
        , const VertexType* vertices
        , const std::size_t vertexCount
        , const IndexType* indices
        , const std::size_t indexCount );
    
protected:
    
    virtual VertexBufferBase* loadVertexBuffer() override;
    
    virtual IndexBufferBase* loadIndexBuffer() override;
 
public:
 
    typedef VertexType Vertex;  
    typedef  IndexType  Index;  
 
    static ManagedMesh< VertexType, IndexType >& create
        ( unsigned int primitiveType
        , const VertexType* vertices
        , const std::size_t vertexCount
        , const IndexType* indices
        , const std::size_t indexCount );
 
}; // ManagedMesh
 
 
template< typename VertexType, typename IndexType >
ManagedMesh< VertexType, IndexType >::ManagedMesh
        ( unsigned int primitiveType
        , const VertexType* vertices
        , const std::size_t vertexCount
        , const IndexType* indices
        , const std::size_t indexCount )
    : ManagedMeshBase( primitiveType, Vertex::attributes )
    , vertices( vertices, vertices + vertexCount )
    , indices (  indices,  indices +  indexCount )
{
}
 
 
template< typename VertexType, typename IndexType >
VertexBufferBase* ManagedMesh< VertexType, IndexType >::loadVertexBuffer()
{
    VertexBuffer< VertexType >* const vb = new VertexBuffer< VertexType >();
    vb->copy( &vertices.front(), vertices.size() );
    return vb;
}
 
 
template< typename VertexType, typename IndexType >
IndexBufferBase* ManagedMesh< VertexType, IndexType >::loadIndexBuffer()
{
    IndexBuffer< IndexType >* const ib = new IndexBuffer< IndexType >( primitiveType );
    ib->copy( &indices.front(), indices.size() );
    return ib;
}
 
 
template< typename VertexType, typename IndexType >
ManagedMesh< VertexType, IndexType >& ManagedMesh< VertexType, IndexType >::create
    ( unsigned int primitiveType
    , const VertexType* vertices
    , const std::size_t vertexCount
    , const IndexType* indices
    , const std::size_t indexCount )
{
    return *new ManagedMesh< Vertex, Index >( primitiveType, vertices, vertexCount, indices, indexCount );
}
 
 
 
}  // namespace LibCarna :: base
 
}  // namespace LibCarna
 
#endif // MANAGEDMESH_H_6014714286