moving Unix folders to Core, implementing VFS base

Kbz-8 · Kbz-8 · commit 3e353f628a4e · 2025-04-05T12:34:57.000+02:00
diff --git a/Engine/Runtime/Includes/Core/ComponentStack.hpp b/Engine/Runtime/Includes/Core/ComponentStack.hpp
@@ -33,6 +33,7 @@ namespace Squid
 			template<typename T>
 			inline T GetComponentAs(std::size_t index);
 
+			// snake_case names to be able to use range based loops
 			inline iterator begin() { return m_components.begin(); }
 			inline iterator end() { return m_components.end(); }
 			inline reverse_iterator rbegin() { return m_components.rbegin(); }
diff --git a/Engine/Runtime/Includes/Core/File.hpp b/Engine/Runtime/Includes/Core/File.hpp
@@ -0,0 +1,36 @@
+#ifndef SQUID_CORE_FILE_HPP__
+#define SQUID_CORE_FILE_HPP__
+
+#include <Core/PreCompiled.hpp>
+#include <Core/Enums.hpp>
+
+namespace Squid
+{
+	class SQUID_CORE_API File
+	{
+		public:
+			File(const std::filesystem::path& filepaht);
+			File(const std::filesystem::path& filepath, std::uint32_t flags);
+
+			bool Open(std::uint32_t flags);
+			void Close();
+
+			template <typename T>
+			inline void operator<<(T&& t) { m_stream << std::forward<T>(t); }
+
+			inline bool IsOpen() const { return m_stream.is_open(); }
+			inline bool Exists() const { return std::filesystem::exists(m_filepath); }
+
+			inline std::size_t GetSize() const { return  std::filesystem::file_size(m_filepath); }
+			inline std::filesystem::path GetPath() const { return m_filepath; }
+			inline std::filesystem::path GetDirectory() const { return m_filepath.parent_path(); }
+
+			~File() = default;
+
+		private:
+			std::fstream m_stream;
+			std::filesystem::path m_filepath;
+	};
+}
+
+#endif
diff --git a/Engine/Runtime/Includes/Core/Unix/PreCompiled.hpp b/Engine/Runtime/Includes/Core/Unix/PreCompiled.hpp
@@ -2,8 +2,9 @@
 #define SQUID_DRIVERS_UNIX_PRE_COMPILED_HEADER_HPP__
 
 #include <Core/CompilationProfile.hpp>
-#include <Platform/Unix/Unix.hpp>
+#include <Core/Unix/Unix.hpp>
 #include <ctime>
+
 #ifdef SQUID_PLAT_UNIX
 	#include <unistd.h>
 	#include <signal.h>
diff --git a/Engine/Runtime/Includes/Core/Unix/Unix.hpp b/Engine/Runtime/Includes/Core/Unix/Unix.hpp
diff --git a/Engine/Runtime/Includes/Core/Unix/UnixInstance.hpp b/Engine/Runtime/Includes/Core/Unix/UnixInstance.hpp
@@ -1,7 +1,7 @@
 #ifndef SQUID_DRIVERS_UNIX_INSTANCE_HPP__
 #define SQUID_DRIVERS_UNIX_INSTANCE_HPP__
 
-#include <Platform/Unix/PreCompiled.hpp>
+#include <Core/Unix/PreCompiled.hpp>
 #include <Core/OS/OSInstance.hpp>
 
 namespace Squid
diff --git a/Engine/Runtime/Includes/Core/Unix/UnixLibLoader.hpp b/Engine/Runtime/Includes/Core/Unix/UnixLibLoader.hpp
@@ -1,7 +1,7 @@
 #ifndef SQUID_UNIX_LIB_LOADER_HPP__
 #define SQUID_UNIX_LIB_LOADER_HPP__
 
-#include <Platform/Unix/PreCompiled.hpp>
+#include <Core/Unix/PreCompiled.hpp>
 #include <Core/OS/LibLoader.hpp>
 
 namespace Squid
diff --git a/Engine/Runtime/Includes/Core/VirtualDirectory.hpp b/Engine/Runtime/Includes/Core/VirtualDirectory.hpp
@@ -0,0 +1,57 @@
+#ifndef SQUID_CORE_VIRTUAL_DIRECTORY_HPP__
+#define SQUID_CORE_VIRTUAL_DIRECTORY_HPP__
+
+#include <Core/PreCompiled.hpp>
+#include <Utils/NonCopyable.hpp>
+#include <Core/VirtualPath.hpp>
+#include <Core/File.hpp>
+
+namespace Squid
+{
+	struct FileEntry
+	{
+		SharedPtr<File> file;
+	};
+
+	struct DirectoryEntry
+	{
+		SharedPtr<class VirtualDirectory> virtual_directory;
+	};
+
+	struct Entry
+	{
+		std::string name;
+		std::variant<FileEntry, DirectoryEntry> entry;
+
+		Entry(const std::string& n, std::variant<FileEntry, DirectoryEntry> e) : name(n), entry(e) {}
+	};
+
+	class SQUID_CORE_API VirtualDirectory : public NonCopyable, EnableSharedFromThis<VirtualDirectory>
+	{
+		public:
+			VirtualDirectory(const WeakPtr<VirtualDirectory>& parent, const std::string& name);
+
+			void MountRealDirectory(const std::filesystem::path& path);
+
+			template <typename F>
+			inline void ForEachEntries(F&& f);
+
+			FileEntry GetFileEntry(std::string_view path);
+			DirectoryEntry GetDirectoryEntry(std::string_view path);
+
+			~VirtualDirectory();
+
+		private:
+			void ReleaseFromParent() noexcept;
+
+		private:
+			std::string m_name;
+			std::vector<std::filesystem::path> m_mounted_directories;
+			std::vector<Entry> m_entries;
+			WeakPtr<VirtualDirectory> m_parent;
+	};
+}
+
+#include <Core/VirtualDirectory.inl>
+
+#endif
diff --git a/Engine/Runtime/Includes/Core/VirtualDirectory.inl b/Engine/Runtime/Includes/Core/VirtualDirectory.inl
@@ -0,0 +1,13 @@
+#pragma once
+#include <Core/VirtualDirectory.hpp>
+
+namespace Squid
+{
+	template <typename F>
+	void VirtualDirectory::ForEachEntries(F&& f)
+	{
+		static_assert(std::is_invocable_v<F(const Entry)>, "Squid::VirtualDirectory::ForEachEntries given callback is invalid");
+		for(auto&& entry : m_entries)
+			f(std::as_const(entry));
+	}
+}
diff --git a/Engine/Runtime/Includes/Core/VirtualFileSystem.hpp b/Engine/Runtime/Includes/Core/VirtualFileSystem.hpp
@@ -0,0 +1,28 @@
+#ifndef SQUID_CORE_VIRTUAL_FILE_SYSTEM_HPP__
+#define SQUID_CORE_VIRTUAL_FILE_SYSTEM_HPP__
+
+#include <Core/PreCompiled.hpp>
+#include <Core/File.hpp>
+#include <Core/VirtualPath.hpp>
+#include <Core/VirtualDirectory.hpp>
+
+namespace Squid
+{
+	class SQUID_CORE_API VirtualFileSystem
+	{
+		friend class CoreModule;
+
+		public:
+			bool CreateVirtualDirectory(std::string_view path, std::string_view directory_name);
+			bool MountVirtualDirectory(const std::filesystem::path& real_directory, const VirtualPath& virtual_directory);
+
+		private:
+			VirtualFileSystem();
+			~VirtualFileSystem() = default;
+
+		private:
+			VirtualDirectory m_root;
+	};
+}
+
+#endif
diff --git a/Engine/Runtime/Includes/Core/VirtualPath.hpp b/Engine/Runtime/Includes/Core/VirtualPath.hpp
@@ -0,0 +1,39 @@
+#ifndef SQUID_CORE_VIRTUAL_PATH_HPP__
+#define SQUID_CORE_VIRTUAL_PATH_HPP__
+
+#include <Core/PreCompiled.hpp>
+
+namespace Squid
+{
+	class SQUID_CORE_API VirtualPath
+	{
+		public:
+			VirtualPath() = default;
+			VirtualPath(std::string_view path);
+
+			std::string GetExtension() const;
+			std::string GetFilename() const;
+			std::string GetStem() const;
+
+			VirtualPath GetParentPath() const;
+
+			VirtualPath operator/(const VirtualPath& path);
+
+			std::string ToString() const;
+
+			inline bool IsEmpty() const noexcept { return m_path_steps.empty(); }
+			inline void Clear() { m_path_steps.clear(); m_is_absolute = false; }
+			inline std::size_t GetLength() const { return m_path_steps.size(); }
+			inline bool IsAbsolute() const noexcept { return m_is_absolute; }
+
+			friend std::ostream& operator<<(std::ostream& os, const VirtualPath& path);
+
+			~VirtualPath() = default;
+
+		private:
+			std::vector<std::string> m_path_steps;
+			bool m_is_absolute = false;
+	};
+}
+
+#endif
diff --git a/Engine/Runtime/Includes/Maths/Vec2.hpp b/Engine/Runtime/Includes/Maths/Vec2.hpp
@@ -108,4 +108,4 @@ namespace Squid
 
 #include <Maths/Vec2.inl>
 
-#endif // __AK_VEC2__
+#endif // __SQUID_VEC2__
diff --git a/Engine/Runtime/Includes/Maths/Vec3.hpp b/Engine/Runtime/Includes/Maths/Vec3.hpp
@@ -125,4 +125,4 @@ namespace Squid
 
 #include <Maths/Vec3.inl>
 
-#endif // __AK_VEC3__
+#endif // __SQUID_VEC3__
diff --git a/Engine/Runtime/Includes/Maths/Vec4.hpp b/Engine/Runtime/Includes/Maths/Vec4.hpp
@@ -106,5 +106,5 @@ namespace Squid
 
 #include <Maths/Vec4.inl>
 
-#endif // __AK_VEC4__
+#endif // __SQUID_VEC4__
 
diff --git a/Engine/Runtime/Includes/SquidEntryPoint.hpp b/Engine/Runtime/Includes/SquidEntryPoint.hpp
@@ -5,7 +5,7 @@
 #include <Core/Application.hpp>
 #include <Core/CLI.hpp>
 #include <Core/EngineConfig.hpp>
-#include <Platform/Unix/UnixInstance.hpp>
+#include <Core/Unix/UnixInstance.hpp>
 
 // Setup functions defined by the user
 extern void SquidSetupApplication(Squid::Application& app);
diff --git a/Engine/Runtime/Includes/Utils/BitsArray.inl b/Engine/Runtime/Includes/Utils/BitsArray.inl
@@ -25,7 +25,7 @@ namespace Squid
 			Error("Bits Array set : index out of range");
 			return;
 		}
-		#ifdef AK_64BITS
+		#ifdef SQUID_64BITS
 			const uintsys_t mask = 1ULL << (index % nbits);
 		#else
 			const uintsys_t mask = 1U << (index % nbits);
@@ -41,7 +41,7 @@ namespace Squid
 			Error("Bits Array get : index out of range");
 			return false;
 		}
-		#ifdef AK_64BITS
+		#ifdef SQUID_64BITS
 			return m_pool[i] & (1ULL << (index % nbits));
 		#else
 			return m_pool[i] & (1U << (index % nbits));
diff --git a/Engine/Runtime/Sources/Core/File.cpp b/Engine/Runtime/Sources/Core/File.cpp
@@ -0,0 +1,28 @@
+#include <Core/File.hpp>
+#include <Core/Logs.hpp>
+
+namespace Squid
+{
+	File::File(const std::filesystem::path& filepath) : m_filepath(filepath) {}
+
+	File::File(const std::filesystem::path& filepath, std::uint32_t flags) : m_filepath(filepath)
+	{
+		Open(flags);
+	}
+
+	bool File::Open(std::uint32_t flags)
+	{
+		std::ios_base::openmode mode;
+		mode = (flags & FileModeAppend ? mode | std::ios::app : mode);
+		mode = (flags & FileModeBinary ? mode | std::ios::binary : mode);
+		mode = (flags & FileModeOverride ? mode | std::ios::trunc : mode);
+		m_stream.open(m_filepath, mode);
+		return m_stream.is_open();
+	}
+
+	void File::Close()
+	{
+		m_stream.close();
+		m_filepath.clear();
+	}
+}
diff --git a/Engine/Runtime/Sources/Core/Unix/UnixInstance.cpp b/Engine/Runtime/Sources/Core/Unix/UnixInstance.cpp
@@ -1,7 +1,7 @@
 #include <Core/CLI.hpp>
-#include <Platform/Unix/UnixLibLoader.hpp>
+#include <Core/Unix/UnixLibLoader.hpp>
 #include <Core/Application.hpp>
-#include <Platform/Unix/UnixInstance.hpp>
+#include <Core/Unix/UnixInstance.hpp>
 
 namespace Squid
 {
diff --git a/Engine/Runtime/Sources/Core/Unix/UnixLibLoader.cpp b/Engine/Runtime/Sources/Core/Unix/UnixLibLoader.cpp
@@ -1,4 +1,4 @@
-#include <Platform/Unix/UnixLibLoader.hpp>
+#include <Core/Unix/UnixLibLoader.hpp>
 #include <Core/Logs.hpp>
 
 namespace Squid
diff --git a/Engine/Runtime/Sources/Core/VirtualDirectory.cpp b/Engine/Runtime/Sources/Core/VirtualDirectory.cpp
@@ -0,0 +1,67 @@
+#include <Core/VirtualDirectory.hpp>
+
+namespace Squid
+{
+	VirtualDirectory::VirtualDirectory(const WeakPtr<VirtualDirectory>& parent, const std::string& name) : m_name(name), m_parent(parent)
+	{
+	}
+
+	void VirtualDirectory::MountRealDirectory(const std::filesystem::path& path)
+	{
+		if(!std::filesystem::exists(path))
+		{
+			Error("Cannot mount '%' to virtual directory '%' as this path doesn't exists", path, m_name);
+			return;
+		}
+		if(!std::filesystem::is_directory(path))
+		{
+			Error("Cannot mount '%' to virtual directory '%' as this path is not a directory", path, m_name);
+			return;
+		}
+		if(std::find(m_mounted_directories.begin(), m_mounted_directories.end(), path) != m_mounted_directories.end())
+		{
+			Warning("'%' directory is already mounted into %", path, m_name);
+			return;
+		}
+		m_mounted_directories.push_back(path);
+
+		for(auto const& entry : std::filesystem::directory_iterator{ path })
+		{
+			if(entry.is_directory())
+				m_entries.emplace_back(entry.path().filename(), DirectoryEntry{ MakeShared<VirtualDirectory>(WeakFromThis(), entry.path().filename()) });
+			else if(entry.is_character_file() || entry.is_regular_file() || entry.is_other())
+				m_entries.emplace_back(entry.path().filename(), FileEntry{ MakeShared<File>(entry.path()) });
+		}
+	}
+
+	FileEntry VirtualDirectory::GetFileEntry(std::string_view path)
+	{
+		auto it = std::find_if(m_entries.begin(), m_entries.end(), [=](const Entry& entry)
+		{
+			return entry.name == path;
+		});
+		if(it != m_entries.end() && std::holds_alternative<FileEntry>(it->entry))
+			return std::get<FileEntry>(it->entry);
+		return FileEntry{ nullptr };
+	}
+
+	DirectoryEntry VirtualDirectory::GetDirectoryEntry(std::string_view path)
+	{
+		auto it = std::find_if(m_entries.begin(), m_entries.end(), [=](const Entry& entry)
+		{
+			return entry.name == path;
+		});
+		if(it != m_entries.end() && std::holds_alternative<DirectoryEntry>(it->entry))
+			return std::get<DirectoryEntry>(it->entry);
+		return DirectoryEntry{ nullptr };
+	}
+
+	void VirtualDirectory::ReleaseFromParent() noexcept
+	{
+		m_parent.Reset();
+	}
+
+	VirtualDirectory::~VirtualDirectory()
+	{
+	}
+}
diff --git a/Engine/Runtime/Sources/Core/VirtualFileSystem.cpp b/Engine/Runtime/Sources/Core/VirtualFileSystem.cpp
@@ -0,0 +1,17 @@
+#include <Core/VirtualFileSystem.hpp>
+
+namespace Squid
+{
+	VirtualFileSystem::VirtualFileSystem() : m_root({}, "/")
+	{
+		DebugLog("Virtual Filesystem is up");
+	}
+
+	bool VirtualFileSystem::CreateVirtualDirectory(std::string_view path, std::string_view directory_name)
+	{
+	}
+
+	bool VirtualFileSystem::MountVirtualDirectory(const std::filesystem::path& real_directory, const VirtualPath& virtual_directory)
+	{
+	}
+}
diff --git a/Engine/Runtime/Sources/Core/VirtualPath.cpp b/Engine/Runtime/Sources/Core/VirtualPath.cpp
diff --git a/Engine/Runtime/Sources/Renderer/RendererModule.cpp b/Engine/Runtime/Sources/Renderer/RendererModule.cpp
diff --git a/LICENSE b/LICENSE
diff --git a/xmake.lua b/xmake.lua
