Inheritance diagram for CSE::SMaterial:

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

Public Member Functions
	RESOURCE_DEFINE_CONSTRUCTOR (SMaterial)

	SMaterial (const SMaterial *material)

void	Exterminate () override

int	AttachElement (int textureLayout) const

SMaterial::Element *	GetElement (const std::string &key) const

const ElementsMap &	GetElements () 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)

void	SetRawData (const std::string &name, std::vector< std::string > raw)

short	GetOrderLayer () const

void	SetOrderLayer (int orderLayer)

SMaterialMode	GetMode () const

void	SetMode (SMaterialMode mode)

SShaderGroup *	GetShaders () const

int	GetTextureCount () const

std::string	PrintMaterial () const

void	SetValue (std::string name_str, Arguments value) override

std::string	PrintValue () const override

Public Member Functions inherited from CSE::SResource
	SResource (std::string classType)

	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 ()

std::string	GetHash () const

Public Member Functions inherited from CSE::VariableBinder
Public Member Functions inherited from CSE::ReflectionObject
	ReflectionObject (std::string type)

void	SetClassType (std::string type)

const char *	GetClassType () const

bool	IsSameClass (const char *classType) 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)

static SResource *	Create (const std::string &name, const std::string &classType)

template<class T >
static T *	Create (const AssetMgr::AssetReference *asset)

static SResource *	Create (const AssetMgr::AssetReference *asset, const std::string &classType)

template<class T >
static T *	Get (std::string name)

static SResource *	Get (std::string &name)

Static Public Member Functions inherited from CSE::ReflectionObject
static ReflectionObject *	NewObject (const std::string &name)

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

Protected Member Functions inherited from CSE::SResource
Protected Member Functions inherited from CSE::VariableBinder

Additional Inherited Members
Protected Types inherited from CSE::VariableBinder
typedef std::vector< std::string >	Arguments

Protected Attributes inherited from CSE::SObject
std::string	m_hash

Protected Attributes inherited from CSE::ReflectionObject
std::string	m_class

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.

18{ FORWARD = 0, DEFERRED = 1, DEPTH_ONLY = 2 };

Constructor & Destructor Documentation

◆ SMaterial()

SMaterial::SMaterial ( const SMaterial * material )

explicit

Definition at line 17 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 40 of file SMaterial.cpp.

                      {
    ReleaseElements();
}

Member Function Documentation

◆ AttachElement()

int SMaterial::AttachElement ( int textureLayout ) const

Definition at line 56 of file SMaterial.cpp.

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

◆ Exterminate()

void SMaterial::Exterminate ( )

overridevirtual

Implements CSE::SObject.

Definition at line 44 of file SMaterial.cpp.

                            {
    ReleaseElements();
}

◆ GenerateMaterial()

SMaterial * SMaterial::GenerateMaterial ( SShaderGroup * shaders )

static

Definition at line 303 of file SMaterial.cpp.

                                                            {
    if (shaders == nullptr) return nullptr;
    const auto& handle = shaders->GetHandleByMode(SMaterialMode::FORWARD);
 
    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;
}

◆ GetElement()

SMaterial::Element * SMaterial::GetElement ( const std::string & key ) const

Definition at line 67 of file SMaterial.cpp.

                                                                  {
    const auto& result = m_elements.find(key);
    if(result == m_elements.end()) return nullptr;
    return result->second;
}

◆ GetElements()

const ElementsMap & CSE::SMaterial::GetElements ( ) const

inline

Definition at line 44 of file SMaterial.h.

                                               {
            return m_elements;
        }

◆ GetMode()

SMaterial::SMaterialMode SMaterial::GetMode ( ) const

Definition at line 291 of file SMaterial.cpp.

                                                {
    return m_mode;
}

◆ GetOrderLayer()

short SMaterial::GetOrderLayer ( ) const

Definition at line 279 of file SMaterial.cpp.

                                     {
    return m_orderLayer;
}

◆ GetShaders()

SShaderGroup * SMaterial::GetShaders ( ) const

Definition at line 287 of file SMaterial.cpp.

                                          {
    return m_shaders;
}

◆ GetTextureCount()

int SMaterial::GetTextureCount ( ) const

Definition at line 299 of file SMaterial.cpp.

                                     {
    return m_textureLayout;
}

◆ Init()

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

overrideprotectedvirtual

Implements CSE::SResource.

Definition at line 122 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 73 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 326 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;
}

◆ PrintValue()

std::string SMaterial::PrintValue ( ) const

overridevirtual

Implements CSE::VariableBinder.

Definition at line 354 of file SMaterial.cpp.

                                      {
    return {};
}

◆ SetFloat()

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

Definition at line 97 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 91 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 295 of file SMaterial.cpp.

                                          {
    m_mode = mode;
}

◆ SetOrderLayer()

void SMaterial::SetOrderLayer ( int orderLayer )

Definition at line 283 of file SMaterial.cpp.

                                            {
    m_orderLayer = orderLayer;
}

◆ SetRawData()

void SMaterial::SetRawData	(	const std::string &	name,
		std::vector< std::string >	raw )

Definition at line 115 of file SMaterial.cpp.

                                                                          {
    auto find_iter = m_elements.find(name);
    if (find_iter == m_elements.end()) return;
    find_iter->second->valueStr = std::move(raw);
    SetBindFuncByType(find_iter->second);
}

◆ SetTexture()

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

Definition at line 109 of file SMaterial.cpp.

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

◆ SetValue()

void SMaterial::SetValue	(	std::string	name_str,
		Arguments	value )

overridevirtual

Used to get serialized values. All classes that inherit from VariableBinder will unconditionally call this function first during initialization.

Parameters

name_str	Name of values
value	Serialized values

Implements CSE::VariableBinder.

Definition at line 350 of file SMaterial.cpp.

                                                                          {
 
}

◆ SetVec3()

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

Definition at line 103 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

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ SMaterialMode

Constructor & Destructor Documentation

◆ SMaterial()

◆ ~SMaterial()

Member Function Documentation

◆ AttachElement()

◆ Exterminate()

◆ GenerateMaterial()

◆ GetElement()

◆ GetElements()

◆ GetMode()

◆ GetOrderLayer()

◆ GetShaders()

◆ GetTextureCount()

◆ Init()

◆ InitElements()

◆ PrintMaterial()

◆ PrintValue()

◆ SetFloat()

◆ SetInt()

◆ SetMode()

◆ SetOrderLayer()

◆ SetRawData()

◆ SetTexture()

◆ SetValue()

◆ SetVec3()