Remove bytestream from Asset interface and derived assets (#15)

* Remove bytestream from Asset interface and derived assets

* Fix formatting

* Fix asset loading

* update text asset

* Update TextAsset.hpp

* Update engine.cpp

* Change return type of Load to bool

* return true;

* Split TextAsset::Load into a source file

* Make paths static

* formating

* Asset loader fix

Author: TymianekPL

lib/include/tkge/Assets/IAsset.hpp

@@ -135,40 +135,6 @@ namespace tkge::Assets
 	{
 	  public:
 		virtual ~IAsset() = default;
-
-	  protected:
-		[[nodiscard]] virtual ReadonlyByteStream& byteStream() noexcept = 0;
-		[[nodiscard]] virtual const ReadonlyByteStream& byteStream() const noexcept = 0;
-	};
-
-	template <typename T>
-	class IMoveableAsset : public virtual IAsset
-	{
-	  public:
-		explicit IMoveableAsset(std::string filename) : _byteStream(std::move(filename)) {}
-		//		static_assert(!std::is_base_of_v<ICopyableAsset<T>, T>, "Cannot derive from both move and copy assets!");
-		~IMoveableAsset() override = default;
-		[[nodiscard]] ReadonlyByteStream& byteStream() noexcept override { return this->_byteStream; }
-		[[nodiscard]] const ReadonlyByteStream& byteStream() const noexcept override { return this->_byteStream; }
-
-	  private:
-		ReadonlyByteStream _byteStream;
-
-		friend T;
-	};
-	template <typename T>
-	class ICopyableAsset : public virtual IAsset
-	{
-	  public:
-		explicit ICopyableAsset(std::string filename) : _byteStream(std::make_shared<ReadonlyByteStream>(std::move(filename))) {}
-		//		static_assert(!std::is_base_of_v<IMoveableAsset<T>, T>, "Cannot derive from both move and copy assets!");
-		~ICopyableAsset() override = default;
-		[[nodiscard]] ReadonlyByteStream& byteStream() noexcept override { return *this->_byteStream; }
-		[[nodiscard]] const ReadonlyByteStream& byteStream() const noexcept override { return *this->_byteStream; }
-
-	  private:
-		std::shared_ptr<ReadonlyByteStream> _byteStream;
-
-		friend T;
+		virtual bool Load(ReadonlyByteStream) = 0;
 	};
 } // namespace tkge::Assets

lib/include/tkge/Assets/TextAsset.hpp

@@ -4,11 +4,15 @@
 
 namespace tkge::Assets
 {
-	class TextAsset final : public ICopyableAsset<TextAsset>
+	class TextAsset final : public IAsset
 	{
 	  public:
-		explicit TextAsset(std::string filename) : ICopyableAsset(std::move(filename)) {}
-		[[nodiscard]] std::string ReadAllText() const;
-		[[nodiscard]] std::string ReadAt(std::size_t position, std::size_t size) const;
+		explicit TextAsset() = default;
+		bool Load(ReadonlyByteStream byteStream) override;
+
+		[[nodiscard]] const std::string& Text() const noexcept { return this->_text; }
+
+	  private:
+		std::string _text;
 	};
 } // namespace tkge::Assets

lib/include/tkge/assetLoader.hpp

@@ -10,20 +10,33 @@ namespace tkge
 	class AssetLoader
 	{
 	  public:
+		explicit AssetLoader() : _paths(this->GetSearchPaths()) {}
+		AssetLoader(const AssetLoader&) = delete;
+		AssetLoader(AssetLoader&&) = default;
+		AssetLoader& operator=(const AssetLoader&) = delete;
+		AssetLoader& operator=(AssetLoader&&) = default;
+		~AssetLoader() = default;
+
 		template <typename T>
 			requires std::is_base_of_v<Assets::IAsset, T>
 		std::unique_ptr<T> LoadAsset(const std::string& fileName) const
 		{
-			const std::vector<std::filesystem::path> paths = this->GetSearchPaths();
-
-			for (const auto& path : paths)
+			for (const auto& path : this->_paths)
 			{
-				if (std::filesystem::exists(path / fileName)) { return std::make_unique<T>((path / fileName).string()); }
+				if (std::filesystem::exists(path / fileName))
+				{
+					auto asset = std::make_unique<T>();
+					asset->Load(Assets::ReadonlyByteStream{(path / fileName).string()});
+					return asset;
+				}
 			}
 
 			throw std::runtime_error("Asset not found: " + fileName);
 		}
 
 		[[nodiscard]] std::vector<std::filesystem::path> GetSearchPaths() const;
+
+	  private:
+		std::vector<std::filesystem::path> _paths;
 	};
 } // namespace tkge

lib/src/Assets/TextAsset.cpp

@@ -1,12 +1,8 @@
 #include <tkge/Assets/TextAsset.hpp>
-std::string tkge::Assets::TextAsset::ReadAllText() const
-{
-	const auto vData = this->byteStream().AsSpan<char>(0, this->byteStream().GetStreamSize());
-	return std::string{vData.begin(), vData.end()};
-}
 
-std::string tkge::Assets::TextAsset::ReadAt(std::size_t position, std::size_t size) const
+bool tkge::Assets::TextAsset::Load(ReadonlyByteStream byteStream)
 {
-	const auto vData = this->byteStream().AsSpan<char>(position, size);
-	return std::string{vData.begin(), vData.end()};
-}
+	const auto vData = byteStream.AsSpan<char>(0, byteStream.GetStreamSize());
+	this->_text = std::string{vData.begin(), vData.end()};
+	return true;
+}