SimpleMaterial.hpp

#pragma once
 
#include <Engine/RaEngine.hpp>
 
#include <map>
#include <string>
 
#include <Core/Utils/Color.hpp>
#include <Engine/Data/Material.hpp>
#include <Engine/Data/Texture.hpp>
 
namespace Ra {
namespace Engine {
namespace Data {
class RA_ENGINE_API SimpleMaterial : public Material, public ParameterSetEditingInterface
{
  public:
    enum class TextureSemantic { TEX_COLOR, TEX_MASK };
 
    explicit SimpleMaterial( const std::string& instanceName,
                             const std::string& materialName,
                             MaterialAspect aspect = MaterialAspect::MAT_OPAQUE );
 
    ~SimpleMaterial() override;
 
    void updateGL() override final;
 
    inline TextureParameters& addTexture( const TextureSemantic& semantic,
                                          const TextureParameters& texture );
 
    inline void addTexture( const TextureSemantic& semantic, Texture* texture );
 
    inline Texture* getTexture( const TextureSemantic& semantic ) const;
 
    inline void setColoredByVertexAttrib( bool state ) override;
 
    inline bool isColoredByVertexAttrib() const override;
 
  public:
    Core::Utils::Color m_color { 0.9, 0.9, 0.9, 1.0 };
    bool m_perVertexColor { false };
 
  private:
    void updateRenderingParameters();
 
    std::map<TextureSemantic, Texture*> m_textures;
    std::map<TextureSemantic, TextureParameters> m_pendingTextures;
 
  protected:
    static void loadMetaData( nlohmann::json& destination );
};
 
// Add a texture as material parameter from an already existing Radium Texture
inline void SimpleMaterial::addTexture( const TextureSemantic& semantic, Texture* texture ) {
    m_textures[semantic] = texture;
    // remove pendingTexture with same semantic, since the latter would
    // overwrite the former when updateGL will be called.
    m_pendingTextures.erase( semantic );
}
 
// Add a texture as material parameter with texture parameter set by the caller
inline TextureParameters& SimpleMaterial::addTexture( const TextureSemantic& semantic,
                                                      const TextureParameters& texture ) {
    m_pendingTextures[semantic] = texture;
    m_isDirty                   = true;
 
    return m_pendingTextures[semantic];
}
 
inline Texture* SimpleMaterial::getTexture( const TextureSemantic& semantic ) const {
    Texture* tex = nullptr;
 
    auto it = m_textures.find( semantic );
    if ( it != m_textures.end() ) { tex = it->second; }
 
    return tex;
}
 
inline void SimpleMaterial::setColoredByVertexAttrib( bool state ) {
    bool oldState    = m_perVertexColor;
    m_perVertexColor = state;
    if ( oldState != m_perVertexColor ) { needUpdate(); }
}
 
inline bool SimpleMaterial::isColoredByVertexAttrib() const {
    return m_perVertexColor;
}
 
} // namespace Data
} // namespace Engine
} // namespace Ra