MaterialShader.cpp

Go to the documentation of this file.

#include "Engine/Material/MaterialShader.h"
#include "Engine/Core/Settings.h"
#include "Engine/Files/Path.h"
#include "plog/Log.h"
 
namespace EngineCore
{
    MaterialShader::MaterialShader(
        const std::filesystem::path & meshShaderPath,
        const std::filesystem::path & fragmentShaderPath
    )
    {
        this->meshShaderPath = meshShaderPath;
        this->fragmentShaderPath = fragmentShaderPath;
    }
 
    std::filesystem::path MaterialShader::getMeshShaderPath() const
    {
        if ( meshShaderPath.empty() )
            return meshShaderPath;
        return meshShaderPath;
    }
 
    std::filesystem::path MaterialShader::getFragShaderPath() const
    {
        if ( fragmentShaderPath.empty() )
            return fragmentShaderPath;
        return fragmentShaderPath;
    }
 
    std::string MaterialShader::getPipelineNameFromString( const PipelineNames pipelineName )
    {
        return getMaterialNameMap().get_right().at( pipelineName );
    }
 
    GraphicsPipeline * MaterialShader::getPipeline() const
    {
        return pipeline;
    }
 
    void MaterialShader::setPipeline( GraphicsPipeline * pipeline )
    {
        if ( !pipeline )
        {
            PLOGF << "Trying to set null pipeline";
        }
        this->pipeline = pipeline;
    }
 
    PipelineMaterialPayload MaterialShader::getPipelineData() const
    {
        return pipelineData;
    }
 
    std::string MaterialShader::toString() const
    {
        std::stringstream ss;
        ss << " Mesh Shader: " << this->meshShaderPath.generic_string() << " Frag Shader: " << this->meshShaderPath.generic_string();
        return ss.str();
    }
 
    PipelineNames MaterialShader::getPipelineNameFromString( const std::string & pipelineName )
    {
        if ( getMaterialNameMap().get_left().contains( pipelineName ) )
        {
            return getMaterialNameMap().get_left().at( pipelineName );
        }
        return DEFAULT_MATERIAL_PIPELINE;  // default fallback
    }
 
    const BidirectionalMap<std::string, PipelineNames> & MaterialShader::getMaterialNameMap()
    {
        static const BidirectionalMap<std::string, PipelineNames> map = []()
        {
            BidirectionalMap<std::string, PipelineNames> m;
            m.insert( "diffuseFlatColor", PipelineNames::DIFFUSE_FLAT_COLOR );
            m.insert( "diffuseShader", PipelineNames::DIFFUSE_SHADER );
            m.insert( "movableDiffuseShader", PipelineNames::MOVABLE_DIFFUSE_SHADER );
            m.insert( "normalsShader", PipelineNames::NORMALS_SHADER );
            m.insert( "l0Shader", PipelineNames::L0_SHADER );
            m.insert( "l1Shader", PipelineNames::L1_SHADER );
            m.insert( "l2Shader", PipelineNames::L2_SHADER );
            m.insert( "dynamicTextures", PipelineNames::DYNAMIC_TEXTURES );
            m.insert( "staticLightmap", PipelineNames::STATIC_LIGHTMAP );
            return m;
        }();
        return map;
    }
 
}  // namespace EngineCore