RawShaderMaterial.hpp

#pragma once
 
#include <Engine/RaEngine.hpp>
 
#include <Core/Asset/MaterialData.hpp>
#include <Engine/Data/Material.hpp>
 
namespace Ra {
namespace Engine {
namespace Data {
// Predeclare the External/Internal material representation converter
class RawShaderMaterialConverter;
} // namespace Data
} // namespace Engine
 
namespace Core {
namespace Asset {
 
class RA_ENGINE_API RawShaderMaterialData : public MaterialData
{
    friend class Ra::Engine::Data::RawShaderMaterialConverter;
 
  public:
    RawShaderMaterialData(
        const std::string& instanceName,
        const std::vector<std::pair<Ra::Engine::Data::ShaderType, std::string>>& shaders,
        std::shared_ptr<Ra::Engine::Data::ShaderParameterProvider> paramProvider ) :
        MaterialData( instanceName, "Ra::Engine::Data::RawShaderMaterial" ),
        m_shaders { shaders },
        m_paramProvider { std::move( paramProvider ) } {}
    RawShaderMaterialData()                               = delete;
    RawShaderMaterialData( const RawShaderMaterialData& ) = delete;
    ~RawShaderMaterialData()                              = default;
 
  private:
    std::vector<std::pair<Ra::Engine::Data::ShaderType, std::string>> m_shaders;
    std::shared_ptr<Ra::Engine::Data::ShaderParameterProvider> m_paramProvider;
};
 
} // namespace Asset
} // namespace Core
 
namespace Engine {
namespace Data {
class RA_ENGINE_API RawShaderMaterialConverter final
{
  public:
    RawShaderMaterialConverter()  = default;
    ~RawShaderMaterialConverter() = default;
    inline Material* operator()( const Ra::Core::Asset::MaterialData* toconvert );
};
 
class RA_ENGINE_API RawShaderMaterial : public Material
{
  public:
    explicit RawShaderMaterial(
        const std::string& instanceName,
        const std::vector<std::pair<Data::ShaderType, std::string>>& shaders,
        std::shared_ptr<Data::ShaderParameterProvider> paramProvider );
 
    ~RawShaderMaterial() override;
 
    RawShaderMaterial( const RawShaderMaterial& ) = delete;
 
    inline Data::RenderParameters& getParameters() override;
 
    inline const Data::RenderParameters& getParameters() const override;
 
    void registerDefaultTechnique();
 
    void updateShaders( const std::vector<std::pair<Data::ShaderType, std::string>>& shaders,
                        std::shared_ptr<Data::ShaderParameterProvider> paramProvider = nullptr );
 
    void updateGL() override final;
 
    static void registerMaterial();
 
    static void unregisterMaterial();
 
  private:
    std::string computeKey();
 
    std::vector<std::pair<Data::ShaderType, std::string>> m_shaders;
    std::shared_ptr<Data::ShaderParameterProvider> m_paramProvider;
    std::string m_materialKey {};
};
 
inline Material*
RawShaderMaterialConverter::operator()( const Ra::Core::Asset::MaterialData* toconvert ) {
    auto mat = static_cast<const Core::Asset::RawShaderMaterialData*>( toconvert );
    return new RawShaderMaterial( mat->getName(), mat->m_shaders, mat->m_paramProvider );
}
 
inline Data::RenderParameters& RawShaderMaterial::getParameters() {
    return m_paramProvider->getParameters();
}
 
inline const Data::RenderParameters& RawShaderMaterial::getParameters() const {
    return m_paramProvider->getParameters();
}
 
} // namespace Data
} // namespace Engine
} // namespace Ra