CSE::AssetMgr Class Reference

Classes
struct	AssetReference

Public Types
enum	TYPE {   NONE , TEX_2D , TEX_CUBEMAP , FRAMEBUFFER ,   MATERIAL , DAE , PREFAB , SCENE ,   SCRIPT , TXT , SHADER , SHADER_HANDLE ,   INI }

Public Member Functions
void	Exterminate ()
void	LoadAssets (bool isPacked)
AssetReference *	GetAsset (const std::string &name) const
std::list< AssetMgr::AssetReference * >	GetAssets (TYPE type) const

Static Public Member Functions
static std::string	LoadAssetFile (const std::string &path)
static std::string	GetAssetHash (const std::string &path)

Detailed Description

Definition at line 21 of file AssetMgr.h.

Member Enumeration Documentation

TYPE

enum CSE::AssetMgr::TYPE

Definition at line 23 of file AssetMgr.h.

                  {
            NONE, TEX_2D, TEX_CUBEMAP, FRAMEBUFFER, MATERIAL, DAE, PREFAB, SCENE, SCRIPT, TXT, SHADER, SHADER_HANDLE, INI
        };

Constructor & Destructor Documentation

~AssetMgr()

AssetMgr::~AssetMgr

(

)

Definition at line 38 of file AssetMgr.cpp.

                    {
    Exterminate();
}

Member Function Documentation

Exterminate()

void AssetMgr::Exterminate

(

)

Definition at line 43 of file AssetMgr.cpp.

                           {
    m_assets.clear();
 
    for (auto& asset: m_assetsList) {
        SAFE_DELETE(asset);
    }
 
#ifdef __ANDROID__
    SAFE_DELETE(m_assetManager);
#endif
 
    zip_close(m_zip);
    m_assetsList.clear();
}

GetAsset()

AssetMgr::AssetReference * AssetMgr::GetAsset

(

const std::string &

name

)

const

Definition at line 68 of file AssetMgr.cpp.

                                                                      {
    // Get an asset by hash
    if (m_assets.count(name) > 0) return m_assets.at(name);
 
    std::string lowerName = name;
    make_lower(lowerName);
    for (const auto& asset: m_assetsList) {
        if (make_lower_copy(asset->name) == lowerName) return asset;
        if (make_lower_copy(asset->id) == lowerName) return asset;
        if (make_lower_copy(asset->name_path) == lowerName) return asset;
        if (make_lower_copy(asset->name_full) == lowerName) return asset;
    }
    auto errorLog = "[Assets Warning] " + name + " does not exist.";
    SafeLog::Log(errorLog.c_str());
    return nullptr;
}

GetAssetHash()

std::string AssetMgr::GetAssetHash ( const std::string & path )

static

Definition at line 422 of file AssetMgr.cpp.

                                                      {
    std::string meta = LoadAssetFile(path + ".meta");
    std::string&& hash = "";
    if (!meta.empty()) {
        const XNode* root = XFILE().loadBuffer(std::move(meta));
        const auto& hashData = root->getNode("hash-data");
        hash = hashData.getAttribute("hash").value;
        SAFE_DELETE(root);
    } else {
        hash = GetRandomHash(16);
        std::string meta = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
                           "<CSEMETA version=\"1.0.0\">\n"
                           "<hash-data hash=\"" + hash + "\">\n"
                                                         "\n</hash-data>\n</CSEMETA>";
        if (!Settings::IsAssetsPacked())
            SaveTxtFile(path + ".meta", meta);
    }
    return hash;
}

GetAssets()

std::list< AssetMgr::AssetReference * > AssetMgr::GetAssets

(

TYPE

type

)

const

Definition at line 372 of file AssetMgr.cpp.

                                                                    {
    std::list<AssetReference*> result;
 
    for (const auto& asset: m_assetsList) {
        if (asset->type == type) {
            result.push_back(asset);
        }
    }
 
    return result;
}

LoadAssetFile()

std::string AssetMgr::LoadAssetFile ( const std::string & path )

static

Definition at line 384 of file AssetMgr.cpp.

                                                       {
    if (Settings::IsAssetsPacked() == false)
        return OpenNativeAssetsTxtFile(path);
 
    std::string result;
    std::string path_convert;
    const auto& zip = CORE->GetResMgrCore()->m_assetManager->m_zip;
    if (path.find("/../") != std::string::npos) {
        auto path_split = split(path, '/');
        std::stack<std::string> path_stack;
        for (const auto& part: path_split) {
            if (part == "..") {
                path_stack.pop();
                continue;
            }
            path_stack.push(part);
        }
        while (!path_stack.empty()) {
            path_convert = path_stack.top() + '/' + path_convert;
            path_stack.pop();
        }
        path_convert = path_convert.substr(0, path_convert.size() - 1);
    } else {
        path_convert = path;
    }
    zip_entry_open(zip, path_convert.c_str());
    {
        char* buf = nullptr;
        size_t bufsize = 0;
 
        zip_entry_read(zip, (void**) &buf, &bufsize);
        result = std::string(buf, bufsize);
        free(buf);
    }
    zip_entry_close(zip);
    return result;
}

LoadAssets()

void AssetMgr::LoadAssets

(

bool

isPacked

)

Definition at line 58 of file AssetMgr.cpp.

                                       {
 
    if (!isPacked) {
        ReadDirectory(CSE::NativeAssetsPath());
    } else {
        ReadPackage(CSE::NativeAssetsPath() + "Assets.zip");
    }
    SetType();
}

---

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

• Manager/AssetMgr.h
• Manager/AssetMgr.cpp