CSE::SShaderGroup Class Reference

Inheritance diagram for CSE::SShaderGroup:

Public Member Functions
void	Exterminate () override
const GLProgramHandle *	GetHandle (const std::string &pass) const
const GLProgramHandle *	GetHandleByMode (int mode) const
const GLProgramHandle *	GetGeometryHandle () const
const GLProgramHandle *	GetForwardHandle () const
const GLProgramHandle *	GetDepthOnlyHandle () const
Public Member Functions inherited from CSE::SResource
	SResource (bool isRegister)
	SResource (const SResource *resource, bool isRegister)
void	SetName (std::string name)
void	SetAbsoluteID (std::string id)
std::string	GetName () const
std::string	GetAbsoluteID () const
AssetMgr::AssetReference *	GetAssetReference (std::string hash="") const
void	LinkResource (AssetMgr::AssetReference *asset)
void	LinkResource (std::string name)
void	SetHash (std::string &hash) override
Public Member Functions inherited from CSE::SObject
	SObject (bool isRegister)
virtual void	SetUndestroyable (bool enable)
virtual void	Destroy ()
virtual void	__FORCE_DESTROY__ ()
virtual std::string	GenerateMeta ()
std::string	GetHash () const

Protected Member Functions
void	Init (const AssetMgr::AssetReference *asset) override

Additional Inherited Members
Static Public Member Functions inherited from CSE::SResource
template<class T >
static T *	Create (const std::string &name)
template<class T >
static T *	Create (const AssetMgr::AssetReference *asset)
template<class T >
static T *	Get (std::string name)
Protected Attributes inherited from CSE::SObject
std::string	m_hash

Detailed Description

Definition at line 10 of file SShaderGroup.h.

Constructor & Destructor Documentation

SShaderGroup()

SShaderGroup::SShaderGroup

(

)

Definition at line 12 of file SShaderGroup.cpp.

                           {
}

~SShaderGroup()

SShaderGroup::~SShaderGroup ( )

override

Definition at line 15 of file SShaderGroup.cpp.

                            {
}

Member Function Documentation

Exterminate()

void SShaderGroup::Exterminate ( )

overridevirtual

Implements CSE::SObject.

Definition at line 18 of file SShaderGroup.cpp.

                               {
}

GetDepthOnlyHandle()

const GLProgramHandle * CSE::SShaderGroup::GetDepthOnlyHandle ( ) const

inline

Definition at line 26 of file SShaderGroup.h.

                                                          {
            return m_depthOnlyHandle;
        }

GetForwardHandle()

const GLProgramHandle * CSE::SShaderGroup::GetForwardHandle ( ) const

inline

Definition at line 23 of file SShaderGroup.h.

                                                        {
            return m_forwardHandle;
        }

GetGeometryHandle()

const GLProgramHandle * CSE::SShaderGroup::GetGeometryHandle ( ) const

inline

Definition at line 20 of file SShaderGroup.h.

                                                         {
            return m_geometryHandle;
        }

GetHandle()

const GLProgramHandle * SShaderGroup::GetHandle

(

const std::string &

pass

)

const

Definition at line 84 of file SShaderGroup.cpp.

                                                                          {
    return m_handles.at(pass);
}

GetHandleByMode()

const GLProgramHandle * SShaderGroup::GetHandleByMode

(

int

mode

)

const

Definition at line 88 of file SShaderGroup.cpp.

                                                                   {
    const std::unordered_map<SMaterial::SMaterialMode, std::string> pass_map = {
            {SMaterial::NORMAL,     "forward"},
            {SMaterial::DEFERRED,   "geometry"},
            {SMaterial::DEPTH_ONLY, "depthOnly"}
    };
 
    return m_handles.at(pass_map.at(static_cast<SMaterial::SMaterialMode>(mode)));
}

Init()

void SShaderGroup::Init ( const AssetMgr::AssetReference *  asset )

overrideprotectedvirtual

Implements CSE::SResource.

Definition at line 21 of file SShaderGroup.cpp.

                                                           {
    const XNode* root;
 
    try {
        root = XFILE(asset->name_path.c_str()).getRoot();
    }
    catch (int e) {
//        SAFE_DELETE(root);
        return;
    }
 
    const auto& cse_mat = root->getChild("CSESHADER");
    const auto& cse_shaders = cse_mat.children;
    for (const auto& shader : cse_shaders) {
        const auto& pass = shader.getAttribute("pass").value;
        const auto& vert_path = shader.getAttribute("v").value;
        const auto& frag_path = shader.getAttribute("f").value;
 
        std::string&& vert = "";
        std::string&& frag = "";
 
        std::string hashes = "";
 
        if (shader.hasAttribute("localPath")
            && shader.getAttribute("localPath").value == "1") {
            const auto vert_asset_path = asset->path + vert_path;
            const auto frag_asset_path = asset->path + frag_path;
            vert = AssetMgr::LoadAssetFile(vert_asset_path);
            frag = AssetMgr::LoadAssetFile(frag_asset_path);
            hashes = GetShaderHash(vert_asset_path, frag_asset_path);
        } else {
            const auto& resMgr = CORE->GetCore(ResMgr);
            const auto& vert_asset = resMgr->GetAssetReference(vert_path);
            const auto& frag_asset = resMgr->GetAssetReference(frag_path);
 
            vert = AssetMgr::LoadAssetFile(vert_asset->name_path);
            frag = AssetMgr::LoadAssetFile(frag_asset->name_path);
            hashes = vert_asset->hash + frag_asset->hash;
        }
 
        if (vert.empty() || frag.empty() || hashes.empty()) continue;
 
        const auto& existHandle = SResource::Get<GLProgramHandle>(hashes);
        GLProgramHandle* handle = nullptr;
        if (existHandle == nullptr) {
            handle = ShaderUtil::CreateProgramHandle(vert.c_str(), frag.c_str());
            handle->SetName(hashes);
        } else {
            handle = existHandle;
        }
        m_handles.insert(std::pair<std::string, GLProgramHandle*>(pass, handle));
        if(pass == "geometry") m_geometryHandle = handle;
        if(pass == "forward") m_forwardHandle = handle;
        if(pass == "depthOnly") m_depthOnlyHandle = handle;
    }
 
    SAFE_DELETE(root);
}

---

The documentation for this class was generated from the following files:

• Util/Render/SShaderGroup.h
• Util/Render/SShaderGroup.cpp