[linux] first version for resource paths handling on linux

Based on this file (GPLv3): https://github.com/KD-lab-Open-Source/Perimeter/blob/d131aa26dce1db187416718610baa09d53c65de8/Source/XTool/XUTIL/XUTIL.CPP

Author: q4a

src/apps/engine/src/file_service.cpp

@@ -32,6 +32,9 @@ FILE_SERVICE::FILE_SERVICE()
     Max_File_Index = 0;
     for (uint32_t n = 0; n < _MAX_OPEN_INI_FILES; n++)
         OpenFiles[n] = nullptr;
+    if (ResourcePathsFirstScan) {
+        ScanResourcePaths();
+    }
 }
 
 FILE_SERVICE::~FILE_SERVICE()
@@ -41,7 +44,7 @@ FILE_SERVICE::~FILE_SERVICE()
 
 std::fstream FILE_SERVICE::_CreateFile(const char *filename, std::ios::openmode mode)
 {
-    const auto path = filename ? std::filesystem::u8path(convert_path_sep(filename)) : std::filesystem::path();
+    const auto path = filename ? std::filesystem::u8path(ConvertPathResource(filename)) : std::filesystem::path();
     std::fstream fileS(path, mode);
     return fileS;
 }
@@ -58,7 +61,7 @@ void FILE_SERVICE::_SetFilePointer(std::fstream &fileS, std::streamoff off, std:
 
 bool FILE_SERVICE::_DeleteFile(const char *filename)
 {
-    std::filesystem::path path = std::filesystem::u8path(convert_path_sep(filename));
+    std::filesystem::path path = std::filesystem::u8path(ConvertPathResource(filename));
     return std::filesystem::remove(path);
 }
 
@@ -94,7 +97,7 @@ bool FILE_SERVICE::_ReadFile(std::fstream &fileS, void *s, std::streamsize count
 
 bool FILE_SERVICE::_FileOrDirectoryExists(const char *p)
 {
-    std::filesystem::path path = std::filesystem::u8path(convert_path_sep(p));
+    std::filesystem::path path = std::filesystem::u8path(ConvertPathResource(p));
     auto ec = std::error_code{};
     bool result = std::filesystem::exists(path, ec);
     if (ec)
@@ -133,7 +136,7 @@ std::vector<std::filesystem::path> FILE_SERVICE::_GetFsPathsByMask(const char *s
     }
     else
     {
-        srcPath = std::filesystem::u8path(convert_path_sep(sourcePath));
+        srcPath = std::filesystem::u8path(ConvertPathResource(sourcePath));
     }
 
     std::filesystem::path curPath;
@@ -179,7 +182,7 @@ std::time_t FILE_SERVICE::_ToTimeT(std::filesystem::file_time_type tp)
 
 std::filesystem::file_time_type FILE_SERVICE::_GetLastWriteTime(const char *filename)
 {
-    std::filesystem::path path = std::filesystem::u8path(convert_path_sep(filename));
+    std::filesystem::path path = std::filesystem::u8path(ConvertPathResource(filename));
     return std::filesystem::last_write_time(path);
 }
 
@@ -203,25 +206,25 @@ std::string FILE_SERVICE::_GetExecutableDirectory()
 
 std::uintmax_t FILE_SERVICE::_GetFileSize(const char *filename)
 {
-    std::filesystem::path path = std::filesystem::u8path(convert_path_sep(filename));
+    std::filesystem::path path = std::filesystem::u8path(ConvertPathResource(filename));
     return std::filesystem::file_size(path);
 }
 
 void FILE_SERVICE::_SetCurrentDirectory(const char *pathName)
 {
-    std::filesystem::path path = std::filesystem::u8path(convert_path_sep(pathName));
+    std::filesystem::path path = std::filesystem::u8path(ConvertPathResource(pathName));
     std::filesystem::current_path(path);
 }
 
 bool FILE_SERVICE::_CreateDirectory(const char *pathName)
 {
-    std::filesystem::path path = std::filesystem::u8path(convert_path_sep(pathName));
+    std::filesystem::path path = std::filesystem::u8path(ConvertPathResource(pathName));
     return std::filesystem::create_directories(path);
 }
 
 std::uintmax_t FILE_SERVICE::_RemoveDirectory(const char *pathName)
 {
-    std::filesystem::path path = std::filesystem::u8path(convert_path_sep(pathName));
+    std::filesystem::path path = std::filesystem::u8path(ConvertPathResource(pathName));
     return std::filesystem::remove_all(path);
 }
 
@@ -358,6 +361,108 @@ bool FILE_SERVICE::LoadFile(const char *file_name, char **ppBuffer, uint32_t *dw
     return true;
 }
 
+//------------------------------------------------------------------------------------------------
+// Resource paths
+//
+
+static bool startsWith(const std::string& str, const std::string& prefix)
+{
+    return str.size() >= prefix.size() && 0 == str.compare(0, prefix.size(), prefix);
+}
+
+static bool endsWith(const std::string& str, const std::string& suffix)
+{
+    return str.size() >= suffix.size() && 0 == str.compare(str.size()-suffix.size(), suffix.size(), suffix);
+}
+
+void terminate_with_char(std::string& buffer, const char chr) {
+    //Check if already has
+    if (!buffer.empty() && buffer[buffer.length() - 1] != chr) {
+        //Append to end and store
+        buffer += chr;
+    }
+}
+
+std::string get_dir_iterator_path(const std::filesystem::path& path)
+{
+    std::string path_str = path.string();
+    size_t pos = path_str.find(std::string(".") + PATH_SEP);
+    if (pos != std::string::npos && pos == 0)
+    {
+        path_str.erase(0, 2);
+    }
+    return path_str;
+}
+
+void string_replace(std::string& input, const char* find, const char* paste)
+{
+    size_t pos = 0;
+    while (true) {
+        pos = input.find(find, pos);
+        if(pos >= input.size())
+            break;
+        input.replace(pos, strlen(find), paste);
+        pos += strlen(paste);
+    }
+}
+
+std::string convert_path(const char* path)
+{
+    std::string conv;
+    size_t size = strlen(path);
+    for (int i = 0; i < size; ++i)
+    {
+        conv.push_back(path[i] == WRONG_PATH_SEP ? PATH_SEP : path[i]);
+    }
+    return conv;
+}
+
+void FILE_SERVICE::ScanResourcePaths()
+{
+    if (ResourcePathsFirstScan)
+    {
+        //Seems like if static code calls us we need to do this manually to avoid any bugs
+        ResourcePaths = std::unordered_map<std::string, std::string>();
+    }
+    ResourcePaths.clear();
+    for (const auto & entry : std::filesystem::recursive_directory_iterator(".")) {
+        if (entry.is_regular_file() || entry.is_directory()) {
+            std::string path = get_dir_iterator_path(entry.path());
+            std::string path_lwr = convert_path(path.c_str());
+            tolwr(path_lwr.data());
+            if (startsWith(path_lwr, "program")
+             || startsWith(path_lwr, "resource")
+             || endsWith(path_lwr, ".ini")) {
+                ResourcePaths[path_lwr] = path;
+                if (entry.is_directory()) {
+                    terminate_with_char(path_lwr, PATH_SEP);
+                    ResourcePaths[path_lwr] = path;
+                }
+            }
+        }
+    }
+    ResourcePathsFirstScan = false;
+}
+
+std::string FILE_SERVICE::ConvertPathResource(const char* path)
+{
+    if (ResourcePathsFirstScan)
+    {
+        ScanResourcePaths();
+    }
+    std::string conv = convert_path(path);
+    tolwr(conv.data());
+    if (startsWith(conv, "./"))
+    {
+        string_replace(conv, "./", "");
+    }
+    std::string result = ResourcePaths[conv];
+    if (result.empty())
+        return conv;
+    else
+        return result;
+}
+
 //=================================================================================================
 
 INIFILE_T::~INIFILE_T()

src/apps/engine/src/file_service.h

@@ -3,6 +3,7 @@
 #include "ifs.h"
 #include "v_file_service.h"
 #include <memory>
+#include <unordered_map>
 
 #define _MAX_OPEN_INI_FILES 1024
 
@@ -85,6 +86,9 @@ class FILE_SERVICE : public VFILE_SERVICE
     IFS *OpenFiles[_MAX_OPEN_INI_FILES];
     uint32_t Files_Num;
     uint32_t Max_File_Index;
+    // Resource paths
+    bool ResourcePathsFirstScan = true; // Since some code may call this statically, we use a flag to know if this is the first time
+    std::unordered_map<std::string, std::string> ResourcePaths;
 
   public:
     FILE_SERVICE();
@@ -116,4 +120,8 @@ class FILE_SERVICE : public VFILE_SERVICE
     std::unique_ptr<INIFILE> OpenIniFile(const char *file_name) override;
     void RefDec(INIFILE *ini_obj);
     void FlushIniFiles();
+
+    // Resource paths
+    void ScanResourcePaths() override;
+    std::string ConvertPathResource(const char* path) override;
 };

src/libs/common/include/storm_platform.h

@@ -1,10 +1,14 @@
 #pragma once
 #ifdef _WIN32
+
+#define PATH_SEP '\\'
+#define WRONG_PATH_SEP '/'
 inline const char *convert_path_sep(const char *cPath)
 {
     return cPath;
 }
-#else
+
+#else // NOT _WIN32
 
 #include <limits.h>
 
@@ -17,6 +21,8 @@ inline const char *convert_path_sep(const char *cPath)
 #define _MAX_FNAME NAME_MAX
 #define MAKELONG(low, high) ((int32_t)(((uint16_t)(low)) | (((uint32_t)((uint16_t)(high))) << 16)))
 
+#define PATH_SEP '/'
+#define WRONG_PATH_SEP '\\'
 inline char *convert_path_sep(const char *cPath)
 {
     const auto len = strlen(cPath) + 1;

src/libs/common/include/v_file_service.h

@@ -43,6 +43,10 @@ class VFILE_SERVICE
     // ini files section
     virtual std::unique_ptr<INIFILE> CreateIniFile(const char *file_name, bool fail_if_exist) = 0;
     virtual std::unique_ptr<INIFILE> OpenIniFile(const char *file_name) = 0;
+
+    // Resource paths
+    virtual void ScanResourcePaths() = 0;
+    virtual std::string ConvertPathResource(const char* path) = 0;
 };
 
 //------------------------------------------------------------------------------------------------

src/libs/renderer/src/s_device.cpp

@@ -1376,7 +1376,7 @@ int32_t DX9RENDER::TextureCreate(const char *fname)
         return -1L;
     }
 
-    std::filesystem::path path = convert_path_sep(fname);
+    std::filesystem::path path = fio->ConvertPathResource(fname);
     std::string pathStr = path.extension().string();
     if (storm::iEquals(pathStr, ".tx"))
         path.replace_extension();