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>());
}
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();
std::vector<T> objArray(length);
@ -27,7 +27,7 @@ namespace xna {
};
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 b = New<bool>(value);
return b;

12
framework/content/manager.hpp
View File

@ -43,26 +43,26 @@ namespace xna {
}
template <typename T>
sptr<T> Load(String const& assetName) {
if (assetName.empty()) return nullptr;
T Load(String const& assetName) {
if (assetName.empty()) return T();
if (_loadedAssets.contains(assetName)) {
/*if (_loadedAssets.contains(assetName)) {
auto& ptr = _loadedAssets[assetName];
auto obj1 = reinterpret_pointer_cast<T>(ptr);
return obj1;
}
}*/
auto obj2 = ReadAsset<T>(assetName);
//auto voidAsset = reinterpret_pointer_cast<void>(obj2);
_loadedAssets.insert({ assetName , obj2 });
//_loadedAssets.insert({ assetName , obj2 });
return obj2;
}
protected:
template <typename T>
sptr<T> ReadAsset(String const& assetName) {
T ReadAsset(String const& assetName) {
auto input = OpenStream(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);
template <typename T>
sptr<T> ReadAsset();
T ReadAsset();
template <typename T>
sptr<T> ReadObject();
T ReadObject();
template <typename T>
sptr<T> ReadObject(T existingInstance);
T ReadObject(T existingInstance);
template <typename T>
sptr<T> ReadObject(ContentTypeReader& typeReader);
T ReadObject(ContentTypeReader& typeReader);
template <typename T>
sptr<T> ReadObject(ContentTypeReader& typeReader, T existingInstance);
T ReadObject(ContentTypeReader& typeReader, T existingInstance);
Vector2 ReadVector2();
Vector3 ReadVector3();
@ -51,13 +51,13 @@ namespace xna {
Int ReadHeader();
template <typename T>
sptr<T> ReadObjectInternal(std::any& existingInstance, xna_error_nullarg);
T ReadObjectInternal(std::any& existingInstance, xna_error_nullarg);
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>
sptr<T> InvokeReader(ContentTypeReader& reader, std::any& existingInstance, xna_error_nullarg);
T InvokeReader(ContentTypeReader& reader, std::any& existingInstance, xna_error_nullarg);
private:
ContentManager* _contentManager = nullptr;
@ -72,19 +72,20 @@ namespace xna {
};
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();
if (num == 0) {
return New<T>();
return T();
}
const auto index = num - 1;
if (index >= typeReaders.size()) {
xna_error_apply(err, XnaErrorCode::ARGUMENT_OUT_OF_RANGE);
return New<T>();
return T();
}
auto reader = typeReaders[index];
@ -92,22 +93,22 @@ namespace xna {
}
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);
sptr<T> objB = nullptr;
T objB;
if (contentTypeReader) {
auto existingInstance1 = existingInstance.has_value() ? std::any_cast<sptr<T>>(existingInstance) : nullptr;
objB = contentTypeReader->Read(*this, *existingInstance1);
auto existingInstance1 = existingInstance.has_value() ? std::any_cast<T>(existingInstance) : T();
objB = contentTypeReader->Read(*this, existingInstance1);
return objB;
}
return New<T>();
return T();
}
template<typename T>
inline sptr<T> ContentReader::ReadAsset()
inline T ContentReader::ReadAsset()
{
const auto sharedResourceCount = ReadHeader();
auto obj = ReadObject<T>();
@ -115,33 +116,33 @@ namespace xna {
}
template<typename T>
inline sptr<T> ContentReader::ReadObject()
inline T ContentReader::ReadObject()
{
auto a = std::any();
return ReadObjectInternal<T>(a);
}
template<typename T>
inline sptr<T> ContentReader::ReadObject(T existingInstance)
inline T ContentReader::ReadObject(T existingInstance)
{
return ReadObjectInternal<T>(std::any(existingInstance));
}
template<typename T>
inline sptr<T> ContentReader::ReadObject(ContentTypeReader& typeReader)
inline T ContentReader::ReadObject(ContentTypeReader& typeReader)
{
auto obj = std::any();
return ReadObjectInternal<T>(typeReader, obj);
}
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));
}
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
? InvokeReader<T>(typeReader, existingInstance, err)

6
framework/content/typereadermanager.hpp
View File

@ -41,7 +41,7 @@ namespace xna {
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 {
return nullptr;
virtual Object Read(ContentReader& input, Object& existingInstance) override {
return Object();
}
};
}

3
framework/forward.hpp
View File

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

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

@ -7,11 +7,11 @@
#include "../texture-dx.hpp"
namespace xna {
class Texture2DReader : public ContentTypeReaderT<Texture2D> {
class Texture2DReader : public ContentTypeReaderT<PTexture2D> {
public:
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 width = 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>() });
//Texture2DReader
Type::NameOfRegisteredTypes.insert({ "Texture2DReader", typeof<Texture2DReader>() });
Type::NameOfRegisteredTypes.insert({ "xna::Texture2DReader", typeof<Texture2DReader>() });
Type::NameOfRegisteredTypes.insert({ "Microsoft.Xna.Framework.Content.Texture2DReader", typeof<Texture2DReader>() });
const auto textureReader = typeof<Texture2DReader>();
Type::NameOfRegisteredTypes.insert({ "xna::Texture2DReader", textureReader });
Type::NameOfRegisteredTypes.insert({ "Microsoft.Xna.Framework.Content.Texture2DReader", textureReader });
}
void InitPlatform::InitActivadors()
@ -25,6 +25,6 @@ namespace xna {
ContentTypeReaderActivador::SetActivador(typeof<Texture2DReader>(), []() -> sptr<ContentTypeReader> {
auto obj = New <Texture2DReader>();
return reinterpret_pointer_cast<ContentTypeReader>(obj);
});
});
}
}

10
framework/xna.cpp
View File

@ -28,6 +28,9 @@ namespace xna {
void LoadContent() override {
spriteBatch = New<SpriteBatch>(*graphicsDevice);
texture = Content()->Load<PTexture2D>("idle");
//Texture2D texture = Content()->Load<Texture2D>("idle");
Game::LoadContent();
}
@ -39,9 +42,11 @@ namespace xna {
}
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);
}
@ -49,6 +54,7 @@ namespace xna {
private:
sptr<GraphicsDeviceManager> graphics = nullptr;
sptr<SpriteBatch> spriteBatch = nullptr;
PTexture2D texture = nullptr;
};
}