CSE::SMaterial Class Reference

Inheritance diagram for CSE::SMaterial:

Public Types
enum	SMaterialMode { NORMAL = 0 , DEFERRED = 1 , DEPTH_ONLY = 2 }

Public Member Functions
	SMaterial (const SMaterial *material)
void	Exterminate () override
void	AttachElement () const
void	InitElements (const ElementsMap &elements, SShaderGroup *shaders)
void	SetInt (const std::string &name, int value)
void	SetFloat (const std::string &name, float value)
void	SetVec3 (const std::string &name, const vec3 &value)
void	SetTexture (const std::string &name, SResource *texture)
short	GetOrderLayer () const
void	SetOrderLayer (int orderLayer)
SMaterialMode	GetMode () const
void	SetMode (SMaterialMode mode)
SShaderGroup *	GetShaders () const
int	GetTextureCount () const
std::string	PrintMaterial () 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

Static Public Member Functions
static SMaterial *	GenerateMaterial (SShaderGroup *shaders)
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 Member Functions
void	Init (const AssetMgr::AssetReference *asset) override

Additional Inherited Members
Protected Attributes inherited from CSE::SObject
std::string	m_hash

Detailed Description

Definition at line 16 of file SMaterial.h.

Member Enumeration Documentation

SMaterialMode

enum CSE::SMaterial::SMaterialMode

Definition at line 18 of file SMaterial.h.

{ NORMAL = 0, DEFERRED = 1, DEPTH_ONLY = 2 };

Constructor & Destructor Documentation

SMaterial() [1/2]

SMaterial::SMaterial

(

)

Definition at line 11 of file SMaterial.cpp.

                     {
    m_lightMgr = CORE->GetCore(LightMgr);
}

SMaterial() [2/2]

SMaterial::SMaterial ( const SMaterial *  material )

explicit

Definition at line 15 of file SMaterial.cpp.

                                              : SResource(material, false) {
 
    if (material == nullptr) throw -1;
 
    m_refHash = material->m_hash;
 
    for (const auto& element_pair : material->m_elements) {
        const auto& element_src = element_pair.second;
        auto element_copy = new Element;
        element_copy->count = element_src->count;
        element_copy->type = element_src->type;
        element_copy->valueStr = element_src->valueStr;
        m_elements.insert(std::pair<std::string, Element*>(element_pair.first, element_copy));
    }
    m_mode = material->m_mode;
    m_shaders = material->m_shaders;
    m_orderLayer = material->m_orderLayer;
    m_textureLayout = material->m_textureLayout;
 
    InitElements(m_elements, m_shaders);
    m_lightMgr = CORE->GetCore(LightMgr);
}

~SMaterial()

SMaterial::~SMaterial ( )

override

Definition at line 38 of file SMaterial.cpp.

                      {
    ReleaseElements();
}

Member Function Documentation

AttachElement()

void SMaterial::AttachElement

(

)

const

Definition at line 54 of file SMaterial.cpp.

                                    {
    m_textureLayout = m_lightMgr->GetShadowCount();
 
    for (const auto& element_pair : m_elements) {
        const auto& element = element_pair.second;
        if (element->id < 0) continue;
        element->attachFunc();
    }
}

Exterminate()

void SMaterial::Exterminate ( )

overridevirtual

Implements CSE::SObject.

Definition at line 42 of file SMaterial.cpp.

                            {
    ReleaseElements();
}

GenerateMaterial()

SMaterial * SMaterial::GenerateMaterial ( SShaderGroup *  shaders )

static

Definition at line 287 of file SMaterial.cpp.

                                                            {
    if (shaders == nullptr) return nullptr;
    const auto& handle = shaders->GetHandleByMode(SMaterialMode::NORMAL);
 
    const auto& uniformList = handle->GetUniformsList();
    auto material = new SMaterial();
    material->m_shaders = shaders;
 
    for (const auto& uniform_pair : uniformList) {
        const auto& name = uniform_pair.first;
        const auto& gl_element = uniform_pair.second;
 
        auto element = new Element;
        element->id = gl_element->id;
        element->type = XMLParser::GetType(gl_element->type);
 
        material->m_elements.insert(std::pair<std::string, Element*>(name, element));
    }
    material->InitElements(material->m_elements, shaders);
 
    return material;
}

GetMode()

SMaterial::SMaterialMode SMaterial::GetMode

(

)

const

Definition at line 275 of file SMaterial.cpp.

                                                {
    return m_mode;
}

GetOrderLayer()

short SMaterial::GetOrderLayer

(

)

const

Definition at line 263 of file SMaterial.cpp.

                                     {
    return m_orderLayer;
}

GetShaders()

SShaderGroup * SMaterial::GetShaders

(

)

const

Definition at line 271 of file SMaterial.cpp.

                                          {
    return m_shaders;
}

GetTextureCount()

int SMaterial::GetTextureCount

(

)

const

Definition at line 283 of file SMaterial.cpp.

                                     {
    return m_textureLayout;
}

Init()

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

overrideprotectedvirtual

Implements CSE::SResource.

Definition at line 106 of file SMaterial.cpp.

                                                        {
    const XNode* root;
 
    try {
        root = XFILE(asset->name_path.c_str()).getRoot();
    }
    catch (int e) {
        return;
    }
 
    XNode cse_mat = root->getChild("CSEMAT");
    XNode shader_node = cse_mat.getChild("shader");
 
    auto var_nodes = shader_node.children;
    auto shader_file_id = shader_node.getAttribute("id").value;
    auto shaderGroup = Create<SShaderGroup>(shader_file_id);
    if (shaderGroup == nullptr) return;
    m_shaders = shaderGroup;
 
    if (shader_node.hasAttribute("deferred")) {
        auto get_deferred = std::stoi(shader_node.getAttribute("deferred").value);
        if (get_deferred == 1) {
            m_mode = DEFERRED;
        }
    }
 
    for (const auto& node : var_nodes) {
 
        auto element_value = node.value.toStringVector();
        auto element_type = node.getAttribute("type").value;
        SType type = XMLParser::GetType(element_type);
        auto element_name = node.getAttribute("name").value;
        auto element_count = node.getAttribute("count").value;
 
        auto element = new Element;
        element->type = type;
        element->count = std::stoi(element_count);
        element->valueStr = element_value;
        m_elements.insert(std::pair<std::string, Element*>(element_name, element));
    }
    SAFE_DELETE(root);
}

InitElements()

void SMaterial::InitElements	(	const ElementsMap &	elements,
		SShaderGroup *	shaders
	)

Definition at line 64 of file SMaterial.cpp.

                                                                               {
    const auto& handle = shaders->GetHandleByMode(m_mode);
    for (const auto& element_pair : elements) {
        const auto& element_name = element_pair.first.c_str();
        const auto& element = element_pair.second;
        if (element->attachFunc != nullptr) continue;
 
        const auto& handleElement = handle->UniformLocation(element_name);
        if (handleElement == nullptr) continue;
 
        element->id = handleElement->id;
        SetBindFuncByType(element);
    }
//    std::string str = PrintMaterial();
//    std::string path = GetAssetReference(m_refHash)->path;
//    SaveTxtFile(path, str);
}

PrintMaterial()

std::string SMaterial::PrintMaterial

(

)

const

Definition at line 310 of file SMaterial.cpp.

                                         {
    std::string result = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
                         "<CSEMAT version=\"1.0.0\">\n";
 
    if(m_mode == DEFERRED) {
        result += "<shader id=\"" + m_shaders->GetHash() + "\" deferred=\"1\">\n";
    }
    else {
        result += "<shader id=\"" + m_shaders->GetHash() + "\">\n";
    }
 
    for (const auto& var : m_elements) {
        const auto& element = var.second;
        if(element->raw.empty()) continue;
 
        result += "<var name=\"" + var.first
                  + "\" type=\"" + XMLParser::ToString(element->type)
                  + "\" count=\"1\">"
                  + element->raw + "</var>\n";
    }
    result += "</shader>\n</CSEMAT>";
    return result;
}

SetFloat()

void SMaterial::SetFloat	(	const std::string &	name,
		float	value
	)

Definition at line 88 of file SMaterial.cpp.

                                                           {
    auto find_iter = m_elements.find(name);
    if (find_iter == m_elements.end()) return;
    SetFloatFunc(find_iter->second, value);
}

SetInt()

void SMaterial::SetInt	(	const std::string &	name,
		int	value
	)

Definition at line 82 of file SMaterial.cpp.

                                                       {
    auto find_iter = m_elements.find(name);
    if (find_iter == m_elements.end()) return;
    SetIntFunc(find_iter->second, value);
}

SetMode()

void SMaterial::SetMode

(

SMaterialMode

mode

)

Definition at line 279 of file SMaterial.cpp.

                                          {
    m_mode = mode;
}

SetOrderLayer()

void SMaterial::SetOrderLayer

(

int

orderLayer

)

Definition at line 267 of file SMaterial.cpp.

                                            {
    m_orderLayer = orderLayer;
}

SetTexture()

void SMaterial::SetTexture	(	const std::string &	name,
		SResource *	texture
	)

Definition at line 100 of file SMaterial.cpp.

                                                                    {
    auto find_iter = m_elements.find(name);
    if (find_iter == m_elements.end()) return;
    SetTextureFunc(find_iter->second, texture);
}

SetVec3()

void SMaterial::SetVec3	(	const std::string &	name,
		const vec3 &	value
	)

Definition at line 94 of file SMaterial.cpp.

                                                                {
    auto find_iter = m_elements.find(name);
    if (find_iter == m_elements.end()) return;
    SetVec3Func(find_iter->second, value);
}

---

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

• Util/Render/SMaterial.h
• Util/Render/SMaterial.cpp