From caa9958e9e13bcbddf3f8a435a74669ecf3a0b56 Mon Sep 17 00:00:00 2001 From: Danilo Date: Wed, 8 May 2024 20:42:15 -0300 Subject: [PATCH] =?UTF-8?q?Implementa=C3=A7=C3=A3o=20em=20init-dx?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- framework/content/defaultreaders.hpp | 223 ++++++++++++++++++++++-- framework/content/manager.hpp | 33 +--- framework/content/typereadermanager.cpp | 1 + framework/content/typereadermanager.hpp | 33 +--- framework/csharp/stream.hpp | 4 +- framework/platform/init-dx.cpp | 64 +++++-- framework/platform/init-dx.hpp | 18 ++ framework/xna.cpp | 3 +- 8 files changed, 283 insertions(+), 96 deletions(-) diff --git a/framework/content/defaultreaders.hpp b/framework/content/defaultreaders.hpp index 7579941..376bb58 100644 --- a/framework/content/defaultreaders.hpp +++ b/framework/content/defaultreaders.hpp @@ -3,36 +3,221 @@ #include "reader.hpp" #include "../default.hpp" +#include "../common/color.hpp" +#include "../common/matrix.hpp" +#include "../common/point.hpp" +#include "../common/rectangle.hpp" +#include "../csharp/timespan.hpp" namespace xna { - template - class ArrayReader : public ContentTypeReaderT> { + class ObjectReader : public ContentTypeReaderT { public: - void Initialize(sptr const& manager) { - elementReader = manager->GetTypeReader(typeof()); + ObjectReader() : ContentTypeReaderT(typeof()) {} + + virtual Object Read(ContentReader& input, Object& existingInstance) override { + return Object(); } - - std::vector Read(ContentReader& input, std::vector& existingInstance) override { - const auto length = input.ReadInt32(); - std::vector objArray(length); - - for (size_t index = 0; index < length; ++index) - objArray[index] = input.ReadObject(elementReader); - - return objArray; - } - - private: - sptr elementReader = nullptr; }; class BooleanReader : public ContentTypeReaderT { + public: + BooleanReader() : ContentTypeReaderT(typeof()) {} + bool Read(ContentReader& input, bool& existingInstance) override { - auto value = input.ReadBoolean(); - auto b = New(value); + return input.ReadBoolean(); + } + }; + + class ByteReader : public ContentTypeReaderT { + public: + ByteReader() : ContentTypeReaderT(typeof()) {} + + Byte Read(ContentReader& input, Byte& existingInstance) override { + const auto b = input.ReadByte(); return b; } }; + + class CharReader : public ContentTypeReaderT { + public: + CharReader() : ContentTypeReaderT(typeof()) {} + + Char Read(ContentReader& input, Char& existingInstance) override { + const auto b = input.ReadChar(); + return b; + } + }; + + class ColorReader : public ContentTypeReaderT { + public: + ColorReader() : ContentTypeReaderT(typeof()) {} + + Color Read(ContentReader& input, Color& existingInstance) override { + const auto i = input.ReadUInt32(); + return { i }; + } + }; + + class DoubleReader : public ContentTypeReaderT { + public: + DoubleReader() : ContentTypeReaderT(typeof()) {} + + double Read(ContentReader& input, double& existingInstance) override { + return input.ReadDouble(); + } + }; + + class Int16Reader : public ContentTypeReaderT { + public: + Int16Reader() : ContentTypeReaderT(typeof()) {} + + Short Read(ContentReader& input, Short& existingInstance) override { + return input.ReadInt16(); + } + }; + + class Int32Reader : public ContentTypeReaderT { + public: + Int32Reader() : ContentTypeReaderT(typeof()) {} + + Int Read(ContentReader& input, Int& existingInstance) override { + return input.ReadInt32(); + } + }; + + class Int64Reader : public ContentTypeReaderT { + public: + Int64Reader() : ContentTypeReaderT(typeof()) {} + + Long Read(ContentReader& input, Long& existingInstance) override { + return input.ReadInt64(); + } + }; + + class MatrixReader : public ContentTypeReaderT { + public: + MatrixReader() : ContentTypeReaderT(typeof()) {} + + Matrix Read(ContentReader& input, Matrix& existingInstance) override { + return input.ReadMatrix(); + } + }; + + class PointReader : public ContentTypeReaderT { + public: + PointReader() : ContentTypeReaderT(typeof()) {} + + Point Read(ContentReader& input, Point& existingInstance) override { + Point point; + point.X = input.ReadInt32(); + point.Y = input.ReadInt32(); + return point; + } + }; + + class QuaternionReader : public ContentTypeReaderT { + public: + QuaternionReader() : ContentTypeReaderT(typeof()) {} + + Quaternion Read(ContentReader& input, Quaternion& existingInstance) override { + return input.ReadQuaternion(); + } + }; + + class RectangleReader : public ContentTypeReaderT { + public: + RectangleReader() : ContentTypeReaderT(typeof()) {} + + Rectangle Read(ContentReader& input, Rectangle& existingInstance) override { + Rectangle rectangle; + rectangle.X = input.ReadInt32(); + rectangle.Y = input.ReadInt32(); + rectangle.Width = input.ReadInt32(); + rectangle.Height = input.ReadInt32(); + return rectangle; + } + }; + + class SByteReader : public ContentTypeReaderT { + public: + SByteReader() : ContentTypeReaderT(typeof()) {} + + Sbyte Read(ContentReader& input, Sbyte& existingInstance) override { + return input.ReadSByte(); + } + }; + + class SingleReader : public ContentTypeReaderT { + public: + SingleReader() : ContentTypeReaderT(typeof()) {} + + float Read(ContentReader& input, float& existingInstance) override { + return input.ReadSingle(); + } + }; + + class TimeSpanReader : public ContentTypeReaderT { + public: + TimeSpanReader() : ContentTypeReaderT(typeof()) {} + + TimeSpan Read(ContentReader& input, TimeSpan& existingInstance) override { + return TimeSpan::FromTicks(input.ReadInt64()); + } + }; + + class UInt16Reader : public ContentTypeReaderT { + public: + UInt16Reader() : ContentTypeReaderT(typeof()) {} + + Ushort Read(ContentReader& input, Ushort& existingInstance) override { + return input.ReadUInt16(); + } + }; + + class UInt32Reader : public ContentTypeReaderT { + public: + UInt32Reader() : ContentTypeReaderT(typeof()) {} + + Uint Read(ContentReader& input, Uint& existingInstance) override { + return input.ReadUInt32(); + } + }; + + class UInt64Reader : public ContentTypeReaderT { + public: + UInt64Reader() : ContentTypeReaderT(typeof()) {} + + Ulong Read(ContentReader& input, Ulong& existingInstance) override { + return input.ReadUInt64(); + } + }; + + class Vector2Reader : public ContentTypeReaderT { + public: + Vector2Reader() : ContentTypeReaderT(typeof()) {} + + Vector2 Read(ContentReader& input, Vector2& existingInstance) override { + return input.ReadVector2(); + } + }; + + class Vector3Reader : public ContentTypeReaderT { + public: + Vector3Reader() : ContentTypeReaderT(typeof()) {} + + Vector3 Read(ContentReader& input, Vector3& existingInstance) override { + return input.ReadVector3(); + } + }; + + class Vector4Reader : public ContentTypeReaderT { + public: + Vector4Reader() : ContentTypeReaderT(typeof()) {} + + Vector4 Read(ContentReader& input, Vector4& existingInstance) override { + return input.ReadVector4(); + } + }; } #endif \ No newline at end of file diff --git a/framework/content/manager.hpp b/framework/content/manager.hpp index b70a927..fd88fc6 100644 --- a/framework/content/manager.hpp +++ b/framework/content/manager.hpp @@ -3,11 +3,11 @@ #include "../csharp/stream.hpp" #include "../default.hpp" +#include "../game/servicecontainer.hpp" #include "reader.hpp" #include #include #include -#include "../game/servicecontainer.hpp" namespace xna { class ContentManager { @@ -17,11 +17,7 @@ namespace xna { ContentManager(String const& rootDirectory, sptr const& services) : _rootDirectory(rootDirectory){ _services = services; - }; - - virtual ~ContentManager(){ - Unload(); - } + }; static sptr Services() { return _services; @@ -35,30 +31,14 @@ namespace xna { _rootDirectory = value; } - virtual void Unload() { - if (_loadedAssets.empty()) - return; - - _loadedAssets.clear(); - } - template T Load(String const& assetName) { - if (assetName.empty()) return T(); - - /*if (_loadedAssets.contains(assetName)) { - auto& ptr = _loadedAssets[assetName]; - auto obj1 = reinterpret_pointer_cast(ptr); - - return obj1; - }*/ + if (assetName.empty()) return T(); auto obj2 = ReadAsset(assetName); - //auto voidAsset = reinterpret_pointer_cast(obj2); - //_loadedAssets.insert({ assetName , obj2 }); return obj2; - } + } protected: template @@ -76,11 +56,10 @@ namespace xna { } private: - String _rootDirectory; - std::map> _loadedAssets; - inline const static String contentExtension = ".xnb"; + String _rootDirectory; std::vector byteBuffer; + inline const static String contentExtension = ".xnb"; inline static sptr _services = nullptr; }; } diff --git a/framework/content/typereadermanager.cpp b/framework/content/typereadermanager.cpp index 25be7dd..488f5da 100644 --- a/framework/content/typereadermanager.cpp +++ b/framework/content/typereadermanager.cpp @@ -1,5 +1,6 @@ #include "typereadermanager.hpp" #include "reader.hpp" +#include "defaultreaders.hpp" namespace xna { std::vector ContentTypeReaderManager::ReadTypeManifest(Int typeCount, sptr& contentReader, xna_error_ptr_arg) diff --git a/framework/content/typereadermanager.hpp b/framework/content/typereadermanager.hpp index fcf5553..3da2683 100644 --- a/framework/content/typereadermanager.hpp +++ b/framework/content/typereadermanager.hpp @@ -42,18 +42,7 @@ namespace xna { } virtual T Read(ContentReader& input, T& existingInstance) = 0; - }; - - //-------------------------------------------------------// - // TypeComparator // - //-------------------------------------------------------// - struct TypeComparator - { - bool operator()(sptr t1, sptr t2) const - { - return t1->GetHashCode() < t2->GetHashCode(); - } - }; + }; //-------------------------------------------------------// // ContentTypeReaderActivador // @@ -94,7 +83,6 @@ namespace xna { } private: - //inline static auto activators = std::map(); inline static auto activators = std::map(); ContentTypeReaderActivador(); @@ -155,30 +143,11 @@ namespace xna { sptr contentReader = nullptr; inline static auto nameToReader = std::map(); - //inline static auto targetTypeToReader = std::map(); - //inline static auto readerTypeToReader = std::map(); inline static auto targetTypeToReader = std::map(); inline static auto readerTypeToReader = std::map(); static void initMaps(); }; - - //-------------------------------------------------------// - // ObjectReader // - //-------------------------------------------------------// - class ObjectReader : public ContentTypeReaderT { - public: - ObjectReader() : ContentTypeReaderT(typeof()) { - ContentTypeReaderActivador::SetActivador(typeof(this), []() -> sptr { - auto obj = New (); - return reinterpret_pointer_cast(obj); - }); - } - - virtual Object Read(ContentReader& input, Object& existingInstance) override { - return Object(); - } - }; } #endif \ No newline at end of file diff --git a/framework/csharp/stream.hpp b/framework/csharp/stream.hpp index 865eb73..bdf28a9 100644 --- a/framework/csharp/stream.hpp +++ b/framework/csharp/stream.hpp @@ -118,8 +118,10 @@ namespace xna { virtual void WriteByte(Byte value, xna_error_nullarg) override; public: - std::streampos _filesize{ 0 }; std::fstream _fstream; + + private: + std::streampos _filesize{ 0 }; bool _closed{ false }; Int endOfFile() { diff --git a/framework/platform/init-dx.cpp b/framework/platform/init-dx.cpp index 1634626..077d162 100644 --- a/framework/platform/init-dx.cpp +++ b/framework/platform/init-dx.cpp @@ -3,28 +3,62 @@ #include "texture-dx.hpp" #include "content-readers/texture2Dreader-dx.hpp" #include "../content/typereadermanager.hpp" +#include "../content/defaultreaders.hpp" namespace xna { + + void InitPlatform::InitRegisteredTypes() { - Type::NameOfRegisteredTypes.insert({ "Texture2D", typeof() }); - - //Texture2DReader - const auto textureReader = typeof(); - Type::NameOfRegisteredTypes.insert({ "xna::Texture2DReader", textureReader }); - Type::NameOfRegisteredTypes.insert({ "Microsoft.Xna.Framework.Content.Texture2DReader", textureReader }); + insertRegisteredReader("ObjecReader"); + insertRegisteredReader("BooleanReader"); + insertRegisteredReader("ByteReader"); + insertRegisteredReader("CharReader"); + insertRegisteredReader("ColorReader"); + insertRegisteredReader("DoubleReader"); + insertRegisteredReader("Int16Reader"); + insertRegisteredReader("Int32Reader"); + insertRegisteredReader("Int64Reader"); + insertRegisteredReader("MatrixReader"); + insertRegisteredReader("PointReader"); + insertRegisteredReader("QuaternionReader"); + insertRegisteredReader("RectangleReader"); + insertRegisteredReader("SByteReader"); + insertRegisteredReader("SingleReader"); + insertRegisteredReader("TimeSpanReader"); + insertRegisteredReader("UInt16Reader"); + insertRegisteredReader("UInt32Reader"); + insertRegisteredReader("UInt64Reader"); + insertRegisteredReader("Vector2Reader"); + insertRegisteredReader("Vector3Reader"); + insertRegisteredReader("Vector4Reader"); + insertRegisteredReader("Texture2DReader"); } void InitPlatform::InitActivadors() { - ContentTypeReaderActivador::SetActivador(typeof(), []() -> sptr { - auto obj = New (); - return reinterpret_pointer_cast(obj); - }); - - ContentTypeReaderActivador::SetActivador(typeof(), []() -> sptr { - auto obj = New (); - return reinterpret_pointer_cast(obj); - }); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); + insertActivadorReader(); } } \ No newline at end of file diff --git a/framework/platform/init-dx.hpp b/framework/platform/init-dx.hpp index eab6abf..29cacb7 100644 --- a/framework/platform/init-dx.hpp +++ b/framework/platform/init-dx.hpp @@ -2,6 +2,8 @@ #define XNA_PLATFORM_INIT_HPP #include "../default.hpp" +#include "../csharp/type.hpp" +#include "../content/typereadermanager.hpp" namespace xna { struct InitPlatform { @@ -12,6 +14,22 @@ namespace xna { static void InitRegisteredTypes(); static void InitActivadors(); + + private: + template + static void insertRegisteredReader(String const& readerName) { + const auto reader = typeof(); + Type::NameOfRegisteredTypes.insert({ "xna::" + readerName, reader }); + Type::NameOfRegisteredTypes.insert({ "Microsoft.Xna.Framework.Content." + readerName, reader }); + } + + template + static void insertActivadorReader() { + ContentTypeReaderActivador::SetActivador(typeof(), []() -> sptr { + auto obj = New (); + return reinterpret_pointer_cast(obj); + }); + } }; } diff --git a/framework/xna.cpp b/framework/xna.cpp index 7f12728..f7e5296 100644 --- a/framework/xna.cpp +++ b/framework/xna.cpp @@ -28,8 +28,7 @@ namespace xna { void LoadContent() override { spriteBatch = New(*graphicsDevice); - texture = Content()->Load("idle"); - //Texture2D texture = Content()->Load("idle"); + texture = Content()->Load("idlse"); Game::LoadContent(); }