PathUtils.cpp

#include "components/PathUtils.hpp"
#include "components/ErrorUtils.hpp"
 
#ifdef _WIN32
#include <windows.h>
#elif defined(__APPLE__)
#include <mach-o/dyld.h>
#include <sys/param.h>
#else
#include <unistd.h>
#endif
 
namespace vex {
 
static std::string gAssetRootOverride = "";
static std::string gUserDataDir = "";
 
void SetAssetRoot(const std::string& projectPath) {
    gAssetRootOverride = projectPath;
}
 
void SetUserDataDir(const std::string& userDataDir) {
    if (!std::filesystem::exists(userDataDir)) {
        std::filesystem::create_directories(userDataDir);
    }
    gUserDataDir = userDataDir;
}
 
std::string GetAssetDir() {
    return gAssetRootOverride;
}
 
std::string GetUserDataDir() {
    return gUserDataDir;
}
 
std::filesystem::path GetExecutableDir() {
    std::filesystem::path exePath;
 
#ifdef _WIN32
    wchar_t wPath[MAX_PATH];
    DWORD len = GetModuleFileNameW(NULL, wPath, MAX_PATH);
    if (len == 0 || len == MAX_PATH) {
        vex::throw_error("Failed to get executable path on Windows");
    }
    int utf8Size = WideCharToMultiByte(CP_UTF8, 0, wPath, -1, nullptr, 0, nullptr, nullptr);
    if (utf8Size == 0) {
        vex::throw_error("Failed to convert executable path to UTF-8");
    }
    std::string utf8Path(utf8Size, '\0');
    WideCharToMultiByte(CP_UTF8, 0, wPath, -1, utf8Path.data(), utf8Size, nullptr, nullptr);
    exePath = std::filesystem::path(utf8Path);
#elif defined(__APPLE__)
    char pathBuf[MAXPATHLEN];
    uint32_t size = sizeof(pathBuf);
    if (_NSGetExecutablePath(pathBuf, &size) != 0) {
        vex::throw_error("Failed to get executable path on macOS");
    }
    exePath = std::filesystem::canonical(pathBuf);
#else
    char pathBuf[1024];
    ssize_t len = ::readlink("/proc/self/exe", pathBuf, sizeof(pathBuf) - 1);
    if (len == -1) {
        vex::throw_error("Failed to read /proc/self/exe on Linux");
    }
    pathBuf[len] = '\0';
    exePath = std::filesystem::path(pathBuf);
#endif
 
    return exePath.parent_path();
}
 
std::string GetAssetPath(const std::string& relativePath) {
 
    const std::string& overridePath = gAssetRootOverride;
    if (!overridePath.empty()) {
        if(relativePath.contains(overridePath)){
            return relativePath;
        }
        return (std::filesystem::path(overridePath) / relativePath).string();
    }
 
    #if DEBUG
        static std::filesystem::path exeDir = GetExecutableDir();
        return (exeDir / relativePath).string();
    #else
        return relativePath;
    #endif
}
 
std::string GetUserDataPath(const std::string& relativePath) {
    return (std::filesystem::path(gUserDataDir) / relativePath).string();
}
 
std::filesystem::path GetLogDir() {
    std::filesystem::path logDir;
    try {
        logDir = GetUserDataPath("logs");
        if (!std::filesystem::exists(logDir)) {
            std::filesystem::create_directories(logDir);
        }
        return logDir;
    } catch (...) {
        return std::filesystem::current_path();
    }
}
 
} // namespace vex