Material.hpp

#pragma once
 
#include <Engine/RaEngine.hpp>
 
#include <map>
#include <string>
 
#include <Engine/Data/MaterialTextureSet.hpp>
#include <Engine/Data/RenderParameters.hpp>
#include <Engine/Data/Texture.hpp>
#include <Engine/Data/TextureManager.hpp>
#include <Engine/RadiumEngine.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      
    };
 
    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 { return m_aspect == MaterialAspect::MAT_TRANSPARENT; }
 
    std::list<std::string> getPropertyList() const override {
        return ShaderParameterProvider::getPropertyList();
    }
 
    virtual void setColoredByVertexAttrib( [[maybe_unused]] bool state ) {};
 
    virtual bool isColoredByVertexAttrib() const { return false; }
 
    inline void needUpdate() { setDirty(); }
 
  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 ); }
 
    bool isDirty() { return m_isDirty; }
 
    void setDirty() { m_isDirty = true; }
 
    void setClean() { m_isDirty = false; }
 
  private:
    std::string m_instanceName {};
    MaterialAspect m_aspect { MaterialAspect::MAT_OPAQUE };
    bool m_isDirty { true };
    std::string m_materialName;
};
 
} // namespace Data
} // namespace Engine
} // namespace Ra