Material.hpp

#pragma once
 
#include <Engine/RaEngine.hpp>
 
#include <map>
#include <string>
 
// This include brings only the macro EIGEN_MAKE_ALIGNED_OPERATOR_NEW in the file scope.
// Need to be separated to reduce compilation time
#include <Core/Types.hpp>
 
#include <Engine/Data/RenderParameters.hpp>
 
namespace Ra {
namespace Engine {
namespace Data {
class RA_ENGINE_API Material : public Data::ShaderParameterProvider
{
  public:
    enum class MaterialAspect {
        MAT_OPAQUE,      
        MAT_TRANSPARENT, 
        MAT_DENSITY      
    };
 
  public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  protected:
    explicit Material( const std::string& instanceName,
                       const std::string& materialName,
                       MaterialAspect aspect = MaterialAspect::MAT_OPAQUE );
 
    inline void setMaterialName( std::string newName ) { m_materialName = std::move( newName ); }
 
  public:
    virtual ~Material() = default;
 
    inline const std::string& getInstanceName() const { return m_instanceName; }
 
    inline const std::string& getMaterialName() const { return m_materialName; }
 
    inline void setMaterialAspect( const MaterialAspect& aspect ) { m_aspect = aspect; }
 
    inline const MaterialAspect& getMaterialAspect() const { return m_aspect; }
 
    virtual bool isTransparent() const;
 
    std::list<std::string> getPropertyList() const override;
 
    virtual void setColoredByVertexAttrib( bool /* state */ ) {};
 
    virtual bool isColoredByVertexAttrib() const { return false; }
 
    inline void needUpdate() { m_isDirty = true; }
 
  protected:
    std::string m_instanceName {};
    MaterialAspect m_aspect { MaterialAspect::MAT_OPAQUE };
    bool m_isDirty { true };
 
  private:
    std::string m_materialName;
};
 
} // namespace Data
} // namespace Engine
} // namespace Ra