VolumeObject.hpp

#pragma once
 
#include <Core/Geometry/AbstractGeometry.hpp>
#include <Core/Types.hpp>
#include <Engine/Data/DisplayableObject.hpp>
#include <Engine/Data/Mesh.hpp>
#include <Engine/Data/Texture.hpp>
#include <Engine/RaEngine.hpp>
#include <memory>
#include <string>
 
namespace Ra {
namespace Engine {
namespace Data {
class ShaderProgram;
} // namespace Data
} // namespace Engine
 
namespace Core {
namespace Geometry {
class AbstractVolume;
} // namespace Geometry
} // namespace Core
namespace Engine {
namespace Data {
class RA_ENGINE_API VolumeObject : public Displayable
{
 
  public:
    explicit VolumeObject( const std::string& name );
    VolumeObject( const VolumeObject& rhs )   = delete;
    void operator=( const VolumeObject& rhs ) = delete;
 
    ~VolumeObject() override;
 
    using Displayable::getName;
 
    inline const Core::Geometry::AbstractGeometry& getAbstractGeometry() const override;
    inline Core::Geometry::AbstractGeometry& getAbstractGeometry() override;
 
    inline const Core::Geometry::AbstractVolume& getVolume() const;
    inline Core::Geometry::AbstractVolume& getVolume();
 
    void loadGeometry( Core::Geometry::AbstractVolume* volume );
 
    void loadGeometry( Core::Geometry::AbstractVolume* volume, const Core::Aabb& aabb );
 
    inline void setDirty() { m_isDirty = true; }
 
    const Texture& getDataTexture() { return m_tex; }
 
    void updateGL() override;
 
    void render( const ShaderProgram* prog ) override;
 
    size_t getNumFaces() const override { return 12; }
    inline size_t getNumVertices() const override { return 8; }
 
  private:
    std::unique_ptr<Core::Geometry::AbstractVolume> m_volume;
    Texture m_tex { {} };
    Mesh m_mesh;
 
    bool m_isDirty { false };
};
class RA_ENGINE_API VolumeObject : public Displayable {…};
 
const Core::Geometry::AbstractGeometry& VolumeObject::getAbstractGeometry() const {
    CORE_ASSERT( m_volume, "Volume is not initialized" );
    return *(Core::Geometry::AbstractGeometry*)( m_volume.get() );
}
const Core::Geometry::AbstractGeometry& VolumeObject::getAbstractGeometry() const  {…}
 
Core::Geometry::AbstractGeometry& VolumeObject::getAbstractGeometry() {
    CORE_ASSERT( m_volume, "Volume is not initialized" );
    return *(Core::Geometry::AbstractGeometry*)( m_volume.get() );
}
 
const Core::Geometry::AbstractVolume& VolumeObject::getVolume() const {
    CORE_ASSERT( m_volume, "Volume is not initialized" );
    return *m_volume.get();
}
const Core::Geometry::AbstractVolume& VolumeObject::getVolume() const  {…}
 
Core::Geometry::AbstractVolume& VolumeObject::getVolume() {
    CORE_ASSERT( m_volume, "Volume is not initialized" );
    return *m_volume.get();
}
 
} // namespace Data
} // namespace Engine
} // namespace Ra