AssetIO Namespace Reference

Classes
struct	ComInit

Enumerations
enum class	AssetKind { Marker , Map }

Functions
const std::filesystem::path &	assetsDir (AssetKind kind)
std::string	slugify (const std::string &s)
std::filesystem::path	uniqueName (const std::filesystem::path &destDir, const std::string &baseFile)
std::optional< std::filesystem::path >	pickImageFileWin32 ()
bool	importFromPath (AssetKind kind, const std::filesystem::path &srcPath, std::filesystem::path *outDst=nullptr, std::string *outError=nullptr)
bool	importFromPicker (AssetKind kind, std::filesystem::path *outDst=nullptr, std::string *outError=nullptr)
std::vector< std::filesystem::path >	pickImageFilesWin32 ()
bool	importManyFromPicker (AssetKind kind, std::vector< std::filesystem::path > *outDsts=nullptr, std::string *outError=nullptr)
bool	importFromUrl (AssetKind kind, const std::wstring &urlW, std::filesystem::path *outDst=nullptr, std::string *outError=nullptr)
std::vector< std::filesystem::path >	listAssets (AssetKind kind)
bool	deleteAsset (AssetKind kind, const std::filesystem::path &file, std::string *outError=nullptr)
void	openDeleteAssetPopUp (std::weak_ptr< ImGuiToaster > toaster_)
void	openUrlAssetPopUp (std::weak_ptr< ImGuiToaster > toaster_)

Enumeration Type Documentation

AssetKind

enum class AssetIO::AssetKind

strong

Enumerator
Marker
Map

Definition at line 24 of file AssetIO.h.

    {
        Marker,
        Map
    };

Function Documentation

assetsDir()

const std::filesystem::path & AssetIO::assetsDir ( AssetKind kind )

inline

Definition at line 30 of file AssetIO.h.

    {
        static std::filesystem::path markers = PathManager::getMarkersPath();
        static std::filesystem::path maps = PathManager::getMapsPath();
        return (kind == AssetKind::Marker) ? markers : maps;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

deleteAsset()

bool AssetIO::deleteAsset ( AssetKind kind, const std::filesystem::path & file, std::string * outError = nullptr )

inline

Definition at line 343 of file AssetIO.h.

    {
        std::error_code ec;
 
        // Resolve and validate root
        auto root = std::filesystem::weakly_canonical(assetsDir(kind), ec);
        if (ec || root.empty() || !std::filesystem::exists(root) || !std::filesystem::is_directory(root))
        {
            if (outError)
                *outError = "Invalid assets root";
            return false;
        }
 
        // Resolve the target (weakly_canonical lets non-existing leaf still resolve)
        auto target = std::filesystem::weakly_canonical(file, ec);
        if (ec || target.empty())
        {
            if (outError)
                *outError = "Path canonicalization failed";
            return false;
        }
 
        // Safety: target must be under root (and on same root/drive)
        // lexically_relative returns a path that does not start with ".." if target is inside root.
        auto rel = target.lexically_relative(root);
        if (rel.empty() || rel.native().starts_with(L"..") || rel.is_absolute())
        {
            if (outError)
                *outError = "Refusing to delete outside assets dir";
            return false;
        }
 
        // Validate file
        if (!std::filesystem::exists(target))
        {
            if (outError)
                *outError = "File not found";
            return false;
        }
        if (!std::filesystem::is_regular_file(target))
        {
            if (outError)
                *outError = "Not a file";
            return false;
        }
 
        // Delete
        std::filesystem::remove(target, ec);
        if (ec)
        {
            if (outError)
                *outError = "Delete failed: " + ec.message();
            return false;
        }
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

importFromPath()

bool AssetIO::importFromPath ( AssetKind kind, const std::filesystem::path & srcPath, std::filesystem::path * outDst = nullptr, std::string * outError = nullptr )

inline

Definition at line 140 of file AssetIO.h.

    {
        std::error_code ec;
        if (!std::filesystem::exists(srcPath))
        {
            if (outError)
                *outError = "Source does not exist";
            return false;
        }
        auto destRoot = assetsDir(kind);
        std::filesystem::create_directories(destRoot, ec);
        ec.clear();
 
        // Build a nice destination name
        auto filename = srcPath.filename().string();
        auto ext = std::filesystem::path(filename).extension().string();
        auto stem = std::filesystem::path(filename).stem().string();
        std::string base = slugify(stem) + ext;
        auto dst = uniqueName(destRoot, base);
 
        std::filesystem::copy_file(srcPath, dst,
                                   std::filesystem::copy_options::overwrite_existing, ec);
        if (ec)
        {
            if (outError)
                *outError = "Copy failed: " + ec.message();
            return false;
        }
        if (outDst)
            *outDst = dst;
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

importFromPicker()

bool AssetIO::importFromPicker ( AssetKind kind, std::filesystem::path * outDst = nullptr, std::string * outError = nullptr )

inline

Definition at line 176 of file AssetIO.h.

    {
        auto p = pickImageFileWin32();
        if (!p)
        {
            if (outError)
                *outError = "User cancelled";
            return false;
        }
        return importFromPath(kind, *p, outDst, outError);
    }

Here is the call graph for this function:

importFromUrl()

bool AssetIO::importFromUrl ( AssetKind kind, const std::wstring & urlW, std::filesystem::path * outDst = nullptr, std::string * outError = nullptr )

inline

Definition at line 285 of file AssetIO.h.

    {
        // Guess filename from URL path
        std::wstring fnameW = L"asset";
        auto slash = urlW.find_last_of(L"/\\");
        if (slash != std::wstring::npos && slash + 1 < urlW.size())
        {
            fnameW = urlW.substr(slash + 1);
            if (fnameW.empty())
                fnameW = L"asset";
        }
        // sanitize/slugify
        std::string fnameUtf8(fnameW.begin(), fnameW.end());
        auto ext = std::filesystem::path(fnameUtf8).extension().string();
        auto stem = std::filesystem::path(fnameUtf8).stem().string();
        std::string base = slugify(stem) + ext;
 
        auto destRoot = assetsDir(kind);
        std::error_code ec;
        std::filesystem::create_directories(destRoot, ec);
        ec.clear();
 
        auto dst = uniqueName(destRoot, base);
        std::wstring dstW = dst.wstring();
 
        HRESULT hr = URLDownloadToFileW(nullptr, urlW.c_str(), dstW.c_str(), 0, nullptr);
        if (FAILED(hr))
        {
            if (outError)
                *outError = "Download failed (HRESULT " + std::to_string(hr) + ")";
            return false;
        }
        if (outDst)
            *outDst = dst;
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

importManyFromPicker()

bool AssetIO::importManyFromPicker ( AssetKind kind, std::vector< std::filesystem::path > * outDsts = nullptr, std::string * outError = nullptr )

inline

Definition at line 240 of file AssetIO.h.

    {
        auto files = pickImageFilesWin32();
        if (files.empty())
        {
            if (outError)
                *outError = "User cancelled";
            return false;
        }
 
        size_t ok = 0, fail = 0;
        std::vector<std::filesystem::path> dsts_local;
        for (auto& f : files)
        {
            std::filesystem::path dst;
            std::string err;
            if (importFromPath(kind, f, &dst, &err))
            {
                ++ok;
                if (outDsts)
                    outDsts->push_back(dst);
                else
                    dsts_local.push_back(dst);
            }
            else
            {
                ++fail;
            }
        }
 
        if (ok == 0)
        {
            if (outError)
                *outError = "All imports failed";
            return false;
        }
        if (fail > 0 && outError)
        {
            *outError = "Imported " + std::to_string(ok) + " file(s), " + std::to_string(fail) + " failed";
        }
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

listAssets()

std::vector< std::filesystem::path > AssetIO::listAssets ( AssetKind kind )

inline

Definition at line 325 of file AssetIO.h.

    {
        std::vector<std::filesystem::path> v;
        auto root = assetsDir(kind);
        std::error_code ec;
        if (!std::filesystem::exists(root))
            return v;
        for (auto& e : std::filesystem::directory_iterator(root, ec))
        {
            if (ec)
                break;
            if (e.is_regular_file())
                v.push_back(e.path());
        }
        std::sort(v.begin(), v.end());
        return v;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

openDeleteAssetPopUp()

void AssetIO::openDeleteAssetPopUp ( std::weak_ptr< ImGuiToaster > toaster_ )

inline

Definition at line 401 of file AssetIO.h.

    {
        ImGui::SetNextWindowSize(ImVec2(640, 480), ImGuiCond_Appearing);
        ImGui::SetNextWindowSizeConstraints(ImVec2(400, 300), ImVec2(FLT_MAX, FLT_MAX));
        if (ImGui::BeginPopupModal("DeleteAssets", nullptr))
        {
            static int tab = 0;
            ImGui::RadioButton("Markers", &tab, 0);
            ImGui::SameLine();
            ImGui::RadioButton("Maps", &tab, 1);
            auto kind = (tab == 0) ? AssetKind::Marker : AssetKind::Map;
 
            auto assets = listAssets(kind);
            ImGui::Separator();
            ImGui::BeginChild("assets_scroll", ImVec2(500, 300), true);
            bool deletedThisFrame = false;
            for (auto& p : assets)
            {
                auto fname = p.filename().string();
                ImGui::TextUnformatted(fname.c_str());
                ImGui::SameLine();
                ImGui::PushID(fname.c_str());
                if (ImGui::SmallButton(("Delete##" + fname).c_str()))
                {
                    std::string err;
                    if (!AssetIO::deleteAsset(kind, p, &err))
                    {
                        std::cerr << "Delete failed: " << err << "\n";
                        if (auto t = toaster_.lock(); t)
                            t->Push(ImGuiToaster::Level::Error, "Delete failed: " + err);
                    }
                    else
                    {
                        deletedThisFrame = true;
                        if (auto t = toaster_.lock(); t)
                            t->Push(ImGuiToaster::Level::Good, "Image Deleted Successfully!!");
                    }
                }
                ImGui::PopID();
                if (deletedThisFrame)
                    break;
            }
            ImGui::EndChild();
            ImGui::Separator();
            if (ImGui::Button("Close"))
                ImGui::CloseCurrentPopup();
            ImGui::EndPopup();
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

openUrlAssetPopUp()

void AssetIO::openUrlAssetPopUp ( std::weak_ptr< ImGuiToaster > toaster_ )

inline

Definition at line 451 of file AssetIO.h.

    {
 
        if (ImGui::BeginPopupModal("UrlAssets", nullptr, ImGuiWindowFlags_AlwaysAutoResize))
        {
            static int tab = 0;
            ImGui::RadioButton("Markers", &tab, 0);
            ImGui::SameLine();
            ImGui::RadioButton("Maps", &tab, 1);
            auto kind = (tab == 0) ? AssetKind::Marker : AssetKind::Map;
            ImGui::Separator();
            auto url_color = (kind == AssetKind::Marker) ? ImVec4(0.60f, 0.80f, 1.00f, 1.0f) /*BLUE*/ : ImVec4(0.45f, 0.95f, 0.55f, 1.0f) /*GREEN*/;
            std::wstring url = L"https://example.com/some.png";
            std::filesystem::path dst = assetsDir(kind);
            std::string err;
            ImGui::PushStyleColor(ImGuiCol_Text, url_color);
            //ImGui::InputText("",url_color, url);
            ImGui::PopStyleColor();
            if (!AssetIO::importFromUrl(kind, url, &dst, &err))
            {
                std::cerr << "Import URL failed: " << err << "\n";
                if (auto t = toaster_.lock(); t)
                    t->Push(ImGuiToaster::Level::Error, "Import URL failed: " + err);
            }
            else
            {
                if (auto t = toaster_.lock(); t)
                    t->Push(ImGuiToaster::Level::Good, "Image Imported from URL");
            }
 
            ImGui::Separator();
            if (ImGui::Button("Close"))
                ImGui::CloseCurrentPopup();
            ImGui::EndPopup();
        }
    }

Here is the call graph for this function:

pickImageFilesWin32()

std::vector< std::filesystem::path > AssetIO::pickImageFilesWin32 ( )

inline

Definition at line 191 of file AssetIO.h.

    {
        std::vector<std::filesystem::path> out;
        ComInit com;
        if (!com.ok())
            return out;
 
        IFileOpenDialog* pDlg = nullptr;
        if (FAILED(CoCreateInstance(CLSID_FileOpenDialog, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pDlg))) || !pDlg)
            return out;
 
        COMDLG_FILTERSPEC filters[] = {
            {L"Images (*.png;*.jpg;*.jpeg;*.bmp;*.gif;*.webp;*.tga)", L"*.png;*.jpg;*.jpeg;*.bmp;*.gif;*.webp;*.tga"},
            {L"All files (*.*)", L"*.*"}};
        pDlg->SetFileTypes(2, filters);
        pDlg->SetFileTypeIndex(1);
 
        DWORD opts = FOS_PATHMUSTEXIST | FOS_FILEMUSTEXIST | FOS_ALLOWMULTISELECT; // <- key change
        pDlg->SetOptions(opts);
 
        if (SUCCEEDED(pDlg->Show(nullptr)))
        {
            IShellItemArray* pArray = nullptr;
            if (SUCCEEDED(pDlg->GetResults(&pArray)) && pArray)
            {
                DWORD count = 0;
                pArray->GetCount(&count);
                for (DWORD i = 0; i < count; ++i)
                {
                    IShellItem* pItem = nullptr;
                    if (SUCCEEDED(pArray->GetItemAt(i, &pItem)) && pItem)
                    {
                        PWSTR psz = nullptr;
                        if (SUCCEEDED(pItem->GetDisplayName(SIGDN_FILESYSPATH, &psz)) && psz)
                        {
                            out.emplace_back(psz);
                            CoTaskMemFree(psz);
                        }
                        pItem->Release();
                    }
                }
                pArray->Release();
            }
        }
        pDlg->Release();
        return out;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

pickImageFileWin32()

std::optional< std::filesystem::path > AssetIO::pickImageFileWin32 ( )

inline

Definition at line 98 of file AssetIO.h.

    {
        ComInit com;
        if (!com.ok())
            return std::nullopt;
 
        IFileOpenDialog* pDlg = nullptr;
        HRESULT hr = CoCreateInstance(CLSID_FileOpenDialog, nullptr, CLSCTX_INPROC_SERVER,
                                      IID_PPV_ARGS(&pDlg));
        if (FAILED(hr) || !pDlg)
            return std::nullopt;
 
        // Filter for common image types; stb_image supports png/jpg/bmp/tga/gif/psd/pic/hdr
        COMDLG_FILTERSPEC filters[] = {
            {L"Images (*.png;*.jpg;*.jpeg;*.bmp;*.gif;*.webp;*.tga)", L"*.png;*.jpg;*.jpeg;*.bmp;*.gif;*.webp;*.tga"},
            {L"All files (*.*)", L"*.*"}};
        pDlg->SetFileTypes(2, filters);
        pDlg->SetFileTypeIndex(1);
        pDlg->SetOptions(FOS_PATHMUSTEXIST | FOS_FILEMUSTEXIST);
 
        std::optional<std::filesystem::path> result;
 
        hr = pDlg->Show(nullptr);
        if (SUCCEEDED(hr))
        {
            IShellItem* pItem = nullptr;
            if (SUCCEEDED(pDlg->GetResult(&pItem)) && pItem)
            {
                PWSTR pszFilePath = nullptr;
                if (SUCCEEDED(pItem->GetDisplayName(SIGDN_FILESYSPATH, &pszFilePath)) && pszFilePath)
                {
                    result = std::filesystem::path(pszFilePath);
                    CoTaskMemFree(pszFilePath);
                }
                pItem->Release();
            }
        }
        pDlg->Release();
        return result;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

slugify()

std::string AssetIO::slugify ( const std::string & s )

inline

Definition at line 56 of file AssetIO.h.

    {
        std::string out;
        out.reserve(s.size());
        for (unsigned char ch : s)
        {
            char c = static_cast<char>(std::tolower(ch));
            if (std::isalnum(static_cast<unsigned char>(c)) || c == '.' || c == '_' || c == '-')
            {
                out.push_back(c);
            }
            else if (std::isspace(static_cast<unsigned char>(c)))
            {
                out.push_back('_');
            } // else drop
        }
        if (out.empty())
            out = "asset";
        return out;
    }

Here is the caller graph for this function:

uniqueName()

std::filesystem::path AssetIO::uniqueName ( const std::filesystem::path & destDir, const std::string & baseFile )

inline

Definition at line 78 of file AssetIO.h.

    {
        std::filesystem::path name = destDir / baseFile;
        if (!std::filesystem::exists(name))
            return name;
 
        auto stem = std::filesystem::path(baseFile).stem().string();
        auto ext = std::filesystem::path(baseFile).extension().string();
        for (int i = 1; i < 100000; ++i)
        {
            auto trial = destDir / (stem + " (" + std::to_string(i) + ")" + ext);
            if (!std::filesystem::exists(trial))
                return trial;
        }
        // fallback improbable
        return destDir / (stem + "_dup" + ext);
    }

Here is the caller graph for this function: