backup/xn65
1
0
Fork 0
mirror of https://github.com/borgesdan/xn65 synced 2024-12-29 21:54:47 +01:00
Code Issues Projects Releases Activity

Modificações em Content.Load

Browse Source
This commit is contained in:
Danilo 2024-05-08 10:51:49 -03:00
parent a7839de84f
commit 0c5d3af199
8 changed files with 51 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
framework/content/defaultreaders.hpp
View File

@ -12,7 +12,7 @@ namespace xna {
elementReader = manager->GetTypeReader(typeof<T>()); elementReader = manager->GetTypeReader(typeof<T>());
} }
sptr<std::vector<T>> Read(ContentReader& input, std::vector<T>& existingInstance) override { std::vector<T> Read(ContentReader& input, std::vector<T>& existingInstance) override {
const auto length = input.ReadInt32(); const auto length = input.ReadInt32();
std::vector<T> objArray(length); std::vector<T> objArray(length);
@ -27,7 +27,7 @@ namespace xna {
}; };
class BooleanReader : public ContentTypeReaderT<bool> { class BooleanReader : public ContentTypeReaderT<bool> {
sptr<bool> Read(ContentReader& input, bool& existingInstance) override { bool Read(ContentReader& input, bool& existingInstance) override {
auto value = input.ReadBoolean(); auto value = input.ReadBoolean();
auto b = New<bool>(value); auto b = New<bool>(value);
return b; return b;

12
framework/content/manager.hpp
View File

@ -43,26 +43,26 @@ namespace xna {
} }
template <typename T> template <typename T>
sptr<T> Load(String const& assetName) { T Load(String const& assetName) {
if (assetName.empty()) return nullptr; if (assetName.empty()) return T();
if (_loadedAssets.contains(assetName)) { /*if (_loadedAssets.contains(assetName)) {
auto& ptr = _loadedAssets[assetName]; auto& ptr = _loadedAssets[assetName];
auto obj1 = reinterpret_pointer_cast<T>(ptr); auto obj1 = reinterpret_pointer_cast<T>(ptr);
return obj1; return obj1;
} }*/
auto obj2 = ReadAsset<T>(assetName); auto obj2 = ReadAsset<T>(assetName);
//auto voidAsset = reinterpret_pointer_cast<void>(obj2); //auto voidAsset = reinterpret_pointer_cast<void>(obj2);
_loadedAssets.insert({ assetName , obj2 }); //_loadedAssets.insert({ assetName , obj2 });
return obj2; return obj2;
} }
protected: protected:
template <typename T> template <typename T>
sptr<T> ReadAsset(String const& assetName) { T ReadAsset(String const& assetName) {
auto input = OpenStream(assetName); auto input = OpenStream(assetName);
auto contentReader = ContentReader::Create(this, input, assetName); auto contentReader = ContentReader::Create(this, input, assetName);

45
framework/content/reader.hpp
View File

@ -17,19 +17,19 @@ namespace xna {
static sptr<ContentReader> Create(ContentManager* contentManager, sptr<Stream>& input, String const& assetName); static sptr<ContentReader> Create(ContentManager* contentManager, sptr<Stream>& input, String const& assetName);
template <typename T> template <typename T>
sptr<T> ReadAsset(); T ReadAsset();
template <typename T> template <typename T>
sptr<T> ReadObject(); T ReadObject();
template <typename T> template <typename T>
sptr<T> ReadObject(T existingInstance); T ReadObject(T existingInstance);
template <typename T> template <typename T>
sptr<T> ReadObject(ContentTypeReader& typeReader); T ReadObject(ContentTypeReader& typeReader);
template <typename T> template <typename T>
sptr<T> ReadObject(ContentTypeReader& typeReader, T existingInstance); T ReadObject(ContentTypeReader& typeReader, T existingInstance);
Vector2 ReadVector2(); Vector2 ReadVector2();
Vector3 ReadVector3(); Vector3 ReadVector3();
@ -51,13 +51,13 @@ namespace xna {
Int ReadHeader(); Int ReadHeader();
template <typename T> template <typename T>
sptr<T> ReadObjectInternal(std::any& existingInstance, xna_error_nullarg); T ReadObjectInternal(std::any& existingInstance, xna_error_nullarg);
template <typename T> template <typename T>
sptr<T> ReadObjectInternal(ContentTypeReader& typeReader, std::any& existingInstance, xna_error_nullarg); T ReadObjectInternal(ContentTypeReader& typeReader, std::any& existingInstance, xna_error_nullarg);
template <typename T> template <typename T>
sptr<T> InvokeReader(ContentTypeReader& reader, std::any& existingInstance, xna_error_nullarg); T InvokeReader(ContentTypeReader& reader, std::any& existingInstance, xna_error_nullarg);
private: private:
ContentManager* _contentManager = nullptr; ContentManager* _contentManager = nullptr;
@ -72,19 +72,20 @@ namespace xna {
}; };
template<typename T> template<typename T>
inline sptr<T> ContentReader::ReadObjectInternal(std::any& existingInstance, xna_error_ptr_arg) inline T ContentReader::ReadObjectInternal(std::any& existingInstance, xna_error_ptr_arg)
{ {
const auto num = Read7BitEncodedInt(); const auto num = Read7BitEncodedInt();
if (num == 0) { if (num == 0) {
return New<T>(); return T();
} }
const auto index = num - 1; const auto index = num - 1;
if (index >= typeReaders.size()) { if (index >= typeReaders.size()) {
xna_error_apply(err, XnaErrorCode::ARGUMENT_OUT_OF_RANGE); xna_error_apply(err, XnaErrorCode::ARGUMENT_OUT_OF_RANGE);
return New<T>();
return T();
} }
auto reader = typeReaders[index]; auto reader = typeReaders[index];
@ -92,22 +93,22 @@ namespace xna {
} }
template<typename T> template<typename T>
inline sptr<T> ContentReader::InvokeReader(ContentTypeReader& reader, std::any& existingInstance, xna_error_ptr_arg) inline T ContentReader::InvokeReader(ContentTypeReader& reader, std::any& existingInstance, xna_error_ptr_arg)
{ {
auto contentTypeReader = reinterpret_cast<ContentTypeReaderT<T>*>(&reader); auto contentTypeReader = reinterpret_cast<ContentTypeReaderT<T>*>(&reader);
sptr<T> objB = nullptr; T objB;
if (contentTypeReader) { if (contentTypeReader) {
auto existingInstance1 = existingInstance.has_value() ? std::any_cast<sptr<T>>(existingInstance) : nullptr; auto existingInstance1 = existingInstance.has_value() ? std::any_cast<T>(existingInstance) : T();
objB = contentTypeReader->Read(*this, *existingInstance1); objB = contentTypeReader->Read(*this, existingInstance1);
return objB; return objB;
} }
return New<T>(); return T();
} }
template<typename T> template<typename T>
inline sptr<T> ContentReader::ReadAsset() inline T ContentReader::ReadAsset()
{ {
const auto sharedResourceCount = ReadHeader(); const auto sharedResourceCount = ReadHeader();
auto obj = ReadObject<T>(); auto obj = ReadObject<T>();
@ -115,33 +116,33 @@ namespace xna {
} }
template<typename T> template<typename T>
inline sptr<T> ContentReader::ReadObject() inline T ContentReader::ReadObject()
{ {
auto a = std::any(); auto a = std::any();
return ReadObjectInternal<T>(a); return ReadObjectInternal<T>(a);
} }
template<typename T> template<typename T>
inline sptr<T> ContentReader::ReadObject(T existingInstance) inline T ContentReader::ReadObject(T existingInstance)
{ {
return ReadObjectInternal<T>(std::any(existingInstance)); return ReadObjectInternal<T>(std::any(existingInstance));
} }
template<typename T> template<typename T>
inline sptr<T> ContentReader::ReadObject(ContentTypeReader& typeReader) inline T ContentReader::ReadObject(ContentTypeReader& typeReader)
{ {
auto obj = std::any(); auto obj = std::any();
return ReadObjectInternal<T>(typeReader, obj); return ReadObjectInternal<T>(typeReader, obj);
} }
template<typename T> template<typename T>
inline sptr<T> ContentReader::ReadObject(ContentTypeReader& typeReader, T existingInstance) inline T ContentReader::ReadObject(ContentTypeReader& typeReader, T existingInstance)
{ {
return ReadObjectInternal<T>(typeReader, std::any(existingInstance)); return ReadObjectInternal<T>(typeReader, std::any(existingInstance));
} }
template<typename T> template<typename T>
inline sptr<T> ContentReader::ReadObjectInternal(ContentTypeReader& typeReader, std::any& existingInstance, xna_error_ptr_arg) inline T ContentReader::ReadObjectInternal(ContentTypeReader& typeReader, std::any& existingInstance, xna_error_ptr_arg)
{ {
return typeReader.TargetIsValueType return typeReader.TargetIsValueType
? InvokeReader<T>(typeReader, existingInstance, err) ? InvokeReader<T>(typeReader, existingInstance, err)

6
framework/content/typereadermanager.hpp
View File

@ -41,7 +41,7 @@ namespace xna {
return std::any(); return std::any();
} }
virtual sptr<T> Read(ContentReader& input, T& existingInstance) = 0; virtual T Read(ContentReader& input, T& existingInstance) = 0;
}; };
//-------------------------------------------------------// //-------------------------------------------------------//
@ -175,8 +175,8 @@ namespace xna {
}); });
} }
virtual sptr<Object> Read(ContentReader& input, Object& existingInstance) override { virtual Object Read(ContentReader& input, Object& existingInstance) override {
return nullptr; return Object();
} }
}; };
} }

3
framework/forward.hpp
View File

@ -88,6 +88,9 @@ namespace xna {
struct GamePadState; struct GamePadState;
struct KeyboardState; struct KeyboardState;
struct MouseState; struct MouseState;
//Pointer
using PTexture2D = std::shared_ptr<Texture2D>;
} }
#endif #endif

4
framework/platform/content-readers/texture2Dreader-dx.hpp
View File

@ -7,11 +7,11 @@
#include "../texture-dx.hpp" #include "../texture-dx.hpp"
namespace xna { namespace xna {
class Texture2DReader : public ContentTypeReaderT<Texture2D> { class Texture2DReader : public ContentTypeReaderT<PTexture2D> {
public: public:
Texture2DReader() : ContentTypeReaderT(typeof<Texture2D>()){} Texture2DReader() : ContentTypeReaderT(typeof<Texture2D>()){}
sptr<Texture2D> Read(ContentReader& input, Texture2D& existingInstance) override{ PTexture2D Read(ContentReader& input, PTexture2D& existingInstance) override{
const auto format = static_cast<SurfaceFormat>(input.ReadInt32()); const auto format = static_cast<SurfaceFormat>(input.ReadInt32());
const auto width = input.ReadInt32(); const auto width = input.ReadInt32();
const auto height = input.ReadInt32(); const auto height = input.ReadInt32();

8
framework/platform/init-dx.cpp
View File

@ -10,9 +10,9 @@ namespace xna {
Type::NameOfRegisteredTypes.insert({ "Texture2D", typeof<Texture2D>() }); Type::NameOfRegisteredTypes.insert({ "Texture2D", typeof<Texture2D>() });
//Texture2DReader //Texture2DReader
Type::NameOfRegisteredTypes.insert({ "Texture2DReader", typeof<Texture2DReader>() }); const auto textureReader = typeof<Texture2DReader>();
Type::NameOfRegisteredTypes.insert({ "xna::Texture2DReader", typeof<Texture2DReader>() }); Type::NameOfRegisteredTypes.insert({ "xna::Texture2DReader", textureReader });
Type::NameOfRegisteredTypes.insert({ "Microsoft.Xna.Framework.Content.Texture2DReader", typeof<Texture2DReader>() }); Type::NameOfRegisteredTypes.insert({ "Microsoft.Xna.Framework.Content.Texture2DReader", textureReader });
} }
void InitPlatform::InitActivadors() void InitPlatform::InitActivadors()
@ -25,6 +25,6 @@ namespace xna {
ContentTypeReaderActivador::SetActivador(typeof<Texture2DReader>(), []() -> sptr<ContentTypeReader> { ContentTypeReaderActivador::SetActivador(typeof<Texture2DReader>(), []() -> sptr<ContentTypeReader> {
auto obj = New <Texture2DReader>(); auto obj = New <Texture2DReader>();
return reinterpret_pointer_cast<ContentTypeReader>(obj); return reinterpret_pointer_cast<ContentTypeReader>(obj);
}); });
} }
} }

10
framework/xna.cpp
View File

@ -28,6 +28,9 @@ namespace xna {
void LoadContent() override { void LoadContent() override {
spriteBatch = New<SpriteBatch>(*graphicsDevice); spriteBatch = New<SpriteBatch>(*graphicsDevice);
texture = Content()->Load<PTexture2D>("idle");
//Texture2D texture = Content()->Load<Texture2D>("idle");
Game::LoadContent(); Game::LoadContent();
} }
@ -39,9 +42,11 @@ namespace xna {
} }
void Draw(GameTime const& gameTime) override { void Draw(GameTime const& gameTime) override {
graphicsDevice->Clear(Colors::CornflowerBlue); graphicsDevice->Clear(Colors::CornflowerBlue);
spriteBatch->Begin();
spriteBatch->Draw(*texture, Vector2(10, 10), Colors::White);
spriteBatch->End();
Game::Draw(gameTime); Game::Draw(gameTime);
} }
@ -49,6 +54,7 @@ namespace xna {
private: private:
sptr<GraphicsDeviceManager> graphics = nullptr; sptr<GraphicsDeviceManager> graphics = nullptr;
sptr<SpriteBatch> spriteBatch = nullptr; sptr<SpriteBatch> spriteBatch = nullptr;
PTexture2D texture = nullptr;
}; };
} }