(Emscripten) Working on emscripten support.

Author: Monika0000

inc/Utils/FileSystem/FileSystem.h

@@ -25,22 +25,16 @@ namespace SR_UTILS_NS {
         static bool WriteToFile(const std::string& path, const std::string_view& text);
         static std::string NormalizePath(const std::string& path);
         static void NormalizePathInPlace(std::string& path);
-
         static std::vector<std::string> ReadAllLines(const SR_UTILS_NS::Path& path);
 
         static uint64_t ReadHashFromFile(const SR_UTILS_NS::Path& path);
         static bool WriteHashToFile(const SR_UTILS_NS::Path& path, uint64_t hash);
 
-        static std::string ReadBinaryAsString(const Path& path, bool checkError = true);
-        static std::vector<char> ReadBinary(std::string_view path);
-        static std::vector<uint8_t> ReadFileAsVector(const std::string& path);
-        static std::shared_ptr<std::vector<uint8_t>> ReadFileAsBlob(const std::string& path);
+        static std::shared_ptr<std::string> ReadFileAsBlob(const std::string& path);
+        static bool ReadFile(const Path& path, std::string& buffer);
 
-        static std::string ReadAllText(const std::string& path);
         static std::vector<std::string_view> ReadAllTextAsStringViewVector(const Path& path, std::string& buffer);
 
-        static char* Load(std::string path);
-
         static void ForEachFileInFolder(const Path& path, bool recursive, const SR_HTYPES_NS::Function<void(const Path&)>& func);
 
         static uint64_t GetFileHash(const std::string& path);

inc/Utils/FileSystem/Path.h

@@ -134,4 +134,10 @@ template<> struct fmt::formatter<SR_UTILS_NS::Path>
     }
 };
 
+template<> struct std::hash<SR_UTILS_NS::Path> {
+    size_t operator()(const SR_UTILS_NS::Path& path) const noexcept {
+        return path.GetHash();
+    }
+};
+
 #endif //SR_ENGINE_PATH_H

inc/Utils/FileSystem/VirtualFS.h

@@ -0,0 +1,26 @@
+//
+// Created by Monika on 02.03.2026.
+//
+
+#ifndef SR_ENGINE_COMMON_VIRTUAL_FS_H
+#define SR_ENGINE_COMMON_VIRTUAL_FS_H
+
+#include <Utils/Common/Singleton.h>
+#include <Utils/FileSystem/Path.h>
+#include <Utils/Types/FlatHashMap.h>
+
+namespace SR_UTILS_NS {
+    class VirtualFS : public Singleton<VirtualFS> {
+        SR_REGISTER_SINGLETON(VirtualFS);
+    public:
+        SR_NODISCARD bool IsFileExist(const Path& path) const;
+        SR_NODISCARD bool TryReadFile(const Path& path, std::string& buffer) const;
+        SR_NODISCARD bool WriteFile(const Path& path, std::string_view data);
+
+    private:
+        SR_HTYPES_NS::FlatHashMap<Path, std::string> m_files;
+
+    };
+}
+
+#endif //SR_ENGINE_COMMON_VIRTUAL_FS_H

inc/Utils/Types/FlatHashMap.h

@@ -31,6 +31,7 @@ namespace SR_HTYPES_NS {
         SR_NODISCARD uint64_t size() const { return m_map.size(); }
         SR_NODISCARD uint64_t count(const Key& key) const { return m_map.count(key); }
         SR_NODISCARD bool empty() const { return m_map.empty(); }
+        SR_NODISCARD bool contains(const Key& key) const { return m_map.count(key) > 0; }
         bool erase(const Key& key) { return m_map.erase(key) > 0; }
         Iterator erase(ConstIterator pos) { return m_map.erase(pos); }
         Iterator erase(ConstIterator first, ConstIterator last) { return m_map.erase(first, last); }

src/Utils/Common/Features.cpp

@@ -15,6 +15,7 @@ namespace SR_UTILS_NS {
     static const StringAtom SR_FEATURE_VARIANT_RELEASE_ID = "Release";
     static const StringAtom SR_FEATURE_VARIANT_VALIDATION_ID = "Validation";
     static const StringAtom SR_FEATURE_VARIANT_EMSCRIPTEN_ID = "Emscripten";
+    static const StringAtom SR_FEATURE_VARIANT_WINDOWS_ID = "Windows";
 
     bool FeatureGroup::Register(StringAtom name, bool value) {
         if (m_values.count(name)) {
@@ -81,13 +82,16 @@ namespace SR_UTILS_NS {
         std::vector<StringAtom> groups = { SR_FEATURE_COMMON_GROUP_ID };
         std::vector<StringAtom> variants = {
         #ifdef SR_DEBUG
-            SR_FEATURE_VARIANT_DEBUG_ID
+            SR_FEATURE_VARIANT_DEBUG_ID,
         #endif
         #ifdef SR_RELEASE
-            SR_FEATURE_VARIANT_RELEASE_ID
+            SR_FEATURE_VARIANT_RELEASE_ID,
         #endif
         #if defined(SR_EMSCRIPTEN)
-            SR_FEATURE_VARIANT_EMSCRIPTEN_ID
+            SR_FEATURE_VARIANT_EMSCRIPTEN_ID,
+        #endif
+        #if defined(SR_WIN32)
+            SR_FEATURE_VARIANT_WINDOWS_ID,
         #endif
         };
 

src/Utils/Debug.cpp

@@ -101,12 +101,16 @@ namespace SR_UTILS_NS {
 
         InitColorTheme();
 
-    #ifndef SR_ANDROID
+    #if !defined(SR_ANDROID) && !defined(SR_EMSCRIPTEN)
         auto&& successfulPath = SR_PLATFORM_NS::GetApplicationPath().GetFolder().Concat("/successful");
         if (successfulPath.Exists(Path::Type::File))
             Platform::Delete(successfulPath);
     #endif
 
+        m_isInit = true;
+        m_showUseMemory = ShowUsedMemory;
+
+    #ifndef SR_EMSCRIPTEN
         m_logPath = Path(log_path);
 
         if (!m_logPath.GetFolder().CreateIfNotExists()) {
@@ -122,10 +126,8 @@ namespace SR_UTILS_NS {
             SR_PLATFORM_NS::WriteConsoleError("Debug::Init() : failed to open log file!\n\tLog path: " + m_logPath.ToString());
         }
 
-        m_isInit = true;
-        m_showUseMemory = ShowUsedMemory;
-
         Print("Debugger has been initialized. \n\tLog path: " + m_logPath.ToString(), DebugLogType::Debug);
+    #endif
 
     #ifdef SR_COMMON_GIT_METADATA
         std::string gitMetadata;

src/Utils/FileSystem/FileSystem.cpp

@@ -3,9 +3,8 @@
 //
 
 #include <Utils/FileSystem/FileSystem.h>
-#include <Utils/Debug.h>
+#include <Utils/FileSystem/VirtualFS.h>
 #include <Utils/Platform/Platform.h>
-#include <Utils/FileSystem/Path.h>
 #include <Utils/Common/Hashes.h>
 #include <Utils/Common/StringUtils.h>
 #include <Utils/Profile/TracyContext.h>
@@ -21,33 +20,11 @@ namespace SR_UTILS_NS {
         return data;
     }
 
-    SR_COMMON_DLL_API char* FileSystem::Load(std::string path) {
-        /// open file
-        std::ifstream infile(path);
-        if (!infile.is_open()) {
-            SR_ERROR("FileSystem::Load() : failed open file!\n\tPath: "+path);
-            return nullptr;
-        }
-
-
-        /// get length of file
-        infile.seekg(0, std::ios::end);
-        size_t length = infile.tellg();
-        infile.seekg(0, std::ios::beg);
-
-        char* buffer = new char[length];
-
-        /// read file
-        infile.read(buffer, length);
-
-        return buffer;
-    }
-
     SR_COMMON_DLL_API std::vector<std::string_view> FileSystem::ReadAllTextAsStringViewVector(const Path& path, std::string& buffer) {
         SR_TRACY_ZONE;
         std::vector<std::string_view> result;
 
-        if (!SR_PLATFORM_NS::ReadFile(path, buffer)) {
+        if (!SR_UTILS_NS::FileSystem::ReadFile(path, buffer)) {
             return result;
         }
 
@@ -78,88 +55,6 @@ namespace SR_UTILS_NS {
         return result;
     }
 
-    SR_COMMON_DLL_API std::string FileSystem::ReadAllText(const std::string& path) {
-        SR_TRACY_ZONE;
-
-        std::string data = std::string();
-        std::ifstream stream(path, std::ios::in);
-        if (!stream) {
-            SR_ERROR("FileSystem::ReadAllText() : failed to open \"" + path + "\" file!");
-            return data;
-        }
-
-        stream.seekg(0, std::ios::end);
-        std::streampos bytes = stream.tellg();
-        stream.seekg(0, std::ios::beg);
-        data.reserve(bytes);
-
-        if (stream.is_open()) {
-            std::string line;
-            bool first = false;
-            while (getline(stream, line)) {
-                if (!first) {
-                    first = true;
-                    data += line;
-                }
-                else {
-                    data += "\n";
-                    data += line;
-                }
-            }
-            stream.close();
-        }
-        return data;
-    }
-
-    SR_COMMON_DLL_API std::vector<uint8_t> FileSystem::ReadFileAsVector(const std::string &path) {
-        std::ifstream file(path, std::ifstream::binary | std::ios::in);
-
-        if (file.fail()) {
-            return std::vector<uint8_t>();
-        }
-
-        file.seekg(0, std::ios::end);
-        std::streampos end = file.tellg();
-        file.seekg(0, std::ios::beg);
-        std::streampos start = file.tellg();
-        size_t size = static_cast<size_t>(end - start);
-
-        std::vector<uint8_t> result(size);
-
-        file.read(reinterpret_cast<char*>(result.data()), size);
-
-        return result;
-    }
-
-    SR_COMMON_DLL_API std::vector<char> FileSystem::ReadBinary(const std::string_view path) {
-        /*std::ifstream ifd(path,  std::ios::binary |  std::ios::ate);
-        int size = ifd.tellg();
-        ifd.seekg(0,  std::ios::beg);
-        std::vector<char> buffer;
-        buffer.resize(size); // << resize not reserve
-        ifd.read(buffer.data(), size);*/
-
-        //std::ifstream input(path, std::ios::binary);
-        //std::vector<uint32_t> buffer(std::istreambuf_iterator<char>(input), {});
-
-        std::ifstream file(path.data(), std::ios::ate | std::ios::binary);
-
-        if (!file.is_open()) {
-            SR_ERROR("FileSystem::ReadBinary() : failed to open \"{}\"file!", path);
-            return std::vector<char>();
-        }
-
-        size_t fileSize = (size_t) file.tellg();
-        std::vector<char> buffer(fileSize);
-
-        file.seekg(0);
-        file.read(buffer.data(), fileSize);
-
-        file.close();
-
-        return buffer;
-    }
-
     SR_COMMON_DLL_API bool FileSystem::CreatePath(std::string path, uint32_t offset) {
         if (path.empty()) {
             return false;
@@ -187,15 +82,11 @@ namespace SR_UTILS_NS {
     #endif
     }
 
-    //std::string FileSystem::GetFullPath(const std::string& path) {
-    //#ifdef SR_WIN32
-    //    char fullFilename[MAX_PATH];
-    //    GetFullPathName(path.c_str(), MAX_PATH, fullFilename, nullptr);
-    //    return std::string(fullFilename);
-    //#else
-    //    return std::string();
-    //#endif
-    //}
+    SR_COMMON_DLL_API bool FileSystem::ReadFile(const Path& path, std::string& buffer) {
+        SR_TRACY_ZONE;
+
+        return SR_PLATFORM_NS::ReadFile(path, buffer);
+    }
 
     SR_COMMON_DLL_API std::string FileSystem::NormalizePath(const std::string &path) {
         SR_TRACY_ZONE;
@@ -228,29 +119,6 @@ namespace SR_UTILS_NS {
         return true;
     }
 
-    SR_COMMON_DLL_API std::string FileSystem::ReadBinaryAsString(const Path& path, bool checkError) {
-        SR_TRACY_ZONE;
-
-        std::ifstream file(path.ToStringRef(), std::ios::ate | std::ios::binary);
-
-        if (!file.is_open()) {
-            SR_UNUSED_VARIABLE(checkError);
-            SRAssert2(!checkError, "FileSystem::ReadBinaryAsString() : failed to open \"" + path.ToStringRef() + "\" file!");
-            return std::string();
-        }
-
-        size_t fileSize = (size_t) file.tellg();
-        std::string buffer;
-        buffer.resize(fileSize);
-
-        file.seekg(0);
-        file.read(buffer.data(), fileSize);
-
-        file.close();
-
-        return buffer;
-    }
-
     SR_COMMON_DLL_API uint64_t FileSystem::GetFileHash(const std::string& path) {
         SR_TRACY_ZONE;
         SR_TRACY_ZONE_TEXT(path);
@@ -259,7 +127,7 @@ namespace SR_UTILS_NS {
 
         {
             SR_TRACY_ZONE_N("Read file");
-            if (!SR_PLATFORM_NS::ReadFile(path, buffer)) {
+            if (!SR_UTILS_NS::FileSystem::ReadFile(path, buffer)) {
                 SR_WARN("FileSystem::GetFileHash() : failed to read file!\n\tPath: " + path);
                 return SR_UINT64_MAX;
             }
@@ -297,8 +165,16 @@ namespace SR_UTILS_NS {
         return hash;
     }
 
-    SR_COMMON_DLL_API std::shared_ptr<std::vector<uint8_t>> FileSystem::ReadFileAsBlob(const std::string &path) {
-        return std::make_shared<std::vector<uint8_t>>(std::move(ReadFileAsVector(path)));
+    SR_COMMON_DLL_API std::shared_ptr<std::string> FileSystem::ReadFileAsBlob(const std::string& path) {
+        SR_TRACY_ZONE;
+
+        std::shared_ptr<std::string> pBuffer = std::make_shared<std::string>();
+        if (!SR_UTILS_NS::FileSystem::ReadFile(path, *pBuffer)) {
+            SR_ERROR("FileSystem::ReadFileAsBlob() : failed to read file!\n\tPath: " + path);
+            return nullptr;
+        }
+
+        return pBuffer;
     }
 
     SR_COMMON_DLL_API uint64_t FileSystem::ReadHashFromFile(const Path& path) {

src/Utils/FileSystem/VirtualFS.cpp

@@ -0,0 +1,29 @@
+//
+// Created by Monika on 02.03.2026.
+//
+
+#include <Utils/FileSystem/VirtualFS.h>
+#include <Utils/Types/LockGuard.h>
+
+namespace SR_UTILS_NS {
+    bool VirtualFS::IsFileExist(const Path& path) const {
+        SR_LOCK_GUARD;
+        return m_files.contains(path);
+    }
+
+    bool VirtualFS::TryReadFile(const Path& path, std::string& buffer) const {
+        SR_LOCK_GUARD;
+        auto it = m_files.find(path);
+        if (it != m_files.end()) {
+            buffer = it->second;
+            return true;
+        }
+        return false;
+    }
+
+    bool VirtualFS::WriteFile(const Path& path, std::string_view data) {
+        SR_LOCK_GUARD;
+        m_files[path] = data;
+        return true;
+    }
+}