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

Implementação em init-dx

Browse Source
This commit is contained in:
Danilo 2024-05-08 20:42:15 -03:00
parent 77c6c40115
commit caa9958e9e
8 changed files with 283 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

223
framework/content/defaultreaders.hpp
View File

@ -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 <typename T>
class ArrayReader : public ContentTypeReaderT<std::vector<T>> {
class ObjectReader : public ContentTypeReaderT<Object> {
public:
void Initialize(sptr<ContentTypeReaderManager> const& manager) {
elementReader = manager->GetTypeReader(typeof<T>());
ObjectReader() : ContentTypeReaderT(typeof<Object>()) {}
virtual Object Read(ContentReader& input, Object& existingInstance) override {
return Object();
}
std::vector<T> Read(ContentReader& input, std::vector<T>& existingInstance) override {
const auto length = input.ReadInt32();
std::vector<T> objArray(length);
for (size_t index = 0; index < length; ++index)
objArray[index] = input.ReadObject<T>(elementReader);
return objArray;
}
private:
sptr<ContentTypeReaderManager> elementReader = nullptr;
};
class BooleanReader : public ContentTypeReaderT<bool> {
public:
BooleanReader() : ContentTypeReaderT(typeof<bool>()) {}
bool Read(ContentReader& input, bool& existingInstance) override {
auto value = input.ReadBoolean();
auto b = New<bool>(value);
return input.ReadBoolean();
}
};
class ByteReader : public ContentTypeReaderT<Byte> {
public:
ByteReader() : ContentTypeReaderT(typeof<Byte>()) {}
Byte Read(ContentReader& input, Byte& existingInstance) override {
const auto b = input.ReadByte();
return b;
}
};
class CharReader : public ContentTypeReaderT<Char> {
public:
CharReader() : ContentTypeReaderT(typeof<Char>()) {}
Char Read(ContentReader& input, Char& existingInstance) override {
const auto b = input.ReadChar();
return b;
}
};
class ColorReader : public ContentTypeReaderT<Color> {
public:
ColorReader() : ContentTypeReaderT(typeof<Color>()) {}
Color Read(ContentReader& input, Color& existingInstance) override {
const auto i = input.ReadUInt32();
return { i };
}
};
class DoubleReader : public ContentTypeReaderT<double> {
public:
DoubleReader() : ContentTypeReaderT(typeof<double>()) {}
double Read(ContentReader& input, double& existingInstance) override {
return input.ReadDouble();
}
};
class Int16Reader : public ContentTypeReaderT<Short> {
public:
Int16Reader() : ContentTypeReaderT(typeof<Short>()) {}
Short Read(ContentReader& input, Short& existingInstance) override {
return input.ReadInt16();
}
};
class Int32Reader : public ContentTypeReaderT<Int> {
public:
Int32Reader() : ContentTypeReaderT(typeof<Int>()) {}
Int Read(ContentReader& input, Int& existingInstance) override {
return input.ReadInt32();
}
};
class Int64Reader : public ContentTypeReaderT<Long> {
public:
Int64Reader() : ContentTypeReaderT(typeof<Long>()) {}
Long Read(ContentReader& input, Long& existingInstance) override {
return input.ReadInt64();
}
};
class MatrixReader : public ContentTypeReaderT<Matrix> {
public:
MatrixReader() : ContentTypeReaderT(typeof<Matrix>()) {}
Matrix Read(ContentReader& input, Matrix& existingInstance) override {
return input.ReadMatrix();
}
};
class PointReader : public ContentTypeReaderT<Point> {
public:
PointReader() : ContentTypeReaderT(typeof<Point>()) {}
Point Read(ContentReader& input, Point& existingInstance) override {
Point point;
point.X = input.ReadInt32();
point.Y = input.ReadInt32();
return point;
}
};
class QuaternionReader : public ContentTypeReaderT<Quaternion> {
public:
QuaternionReader() : ContentTypeReaderT(typeof<Quaternion>()) {}
Quaternion Read(ContentReader& input, Quaternion& existingInstance) override {
return input.ReadQuaternion();
}
};
class RectangleReader : public ContentTypeReaderT<Rectangle> {
public:
RectangleReader() : ContentTypeReaderT(typeof<Rectangle>()) {}
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<Sbyte> {
public:
SByteReader() : ContentTypeReaderT(typeof<Sbyte>()) {}
Sbyte Read(ContentReader& input, Sbyte& existingInstance) override {
return input.ReadSByte();
}
};
class SingleReader : public ContentTypeReaderT<float> {
public:
SingleReader() : ContentTypeReaderT(typeof<float>()) {}
float Read(ContentReader& input, float& existingInstance) override {
return input.ReadSingle();
}
};
class TimeSpanReader : public ContentTypeReaderT<TimeSpan> {
public:
TimeSpanReader() : ContentTypeReaderT(typeof<TimeSpan>()) {}
TimeSpan Read(ContentReader& input, TimeSpan& existingInstance) override {
return TimeSpan::FromTicks(input.ReadInt64());
}
};
class UInt16Reader : public ContentTypeReaderT<Ushort> {
public:
UInt16Reader() : ContentTypeReaderT(typeof<Ushort>()) {}
Ushort Read(ContentReader& input, Ushort& existingInstance) override {
return input.ReadUInt16();
}
};
class UInt32Reader : public ContentTypeReaderT<Uint> {
public:
UInt32Reader() : ContentTypeReaderT(typeof<Uint>()) {}
Uint Read(ContentReader& input, Uint& existingInstance) override {
return input.ReadUInt32();
}
};
class UInt64Reader : public ContentTypeReaderT<Ulong> {
public:
UInt64Reader() : ContentTypeReaderT(typeof<Ulong>()) {}
Ulong Read(ContentReader& input, Ulong& existingInstance) override {
return input.ReadUInt64();
}
};
class Vector2Reader : public ContentTypeReaderT<Vector2> {
public:
Vector2Reader() : ContentTypeReaderT(typeof<Vector2>()) {}
Vector2 Read(ContentReader& input, Vector2& existingInstance) override {
return input.ReadVector2();
}
};
class Vector3Reader : public ContentTypeReaderT<Vector3> {
public:
Vector3Reader() : ContentTypeReaderT(typeof<Vector3>()) {}
Vector3 Read(ContentReader& input, Vector3& existingInstance) override {
return input.ReadVector3();
}
};
class Vector4Reader : public ContentTypeReaderT<Vector4> {
public:
Vector4Reader() : ContentTypeReaderT(typeof<Vector4>()) {}
Vector4 Read(ContentReader& input, Vector4& existingInstance) override {
return input.ReadVector4();
}
};
}
#endif

33
framework/content/manager.hpp
View File

@ -3,11 +3,11 @@
#include "../csharp/stream.hpp"
#include "../default.hpp"
#include "../game/servicecontainer.hpp"
#include "reader.hpp"
#include <algorithm>
#include <filesystem>
#include <map>
#include "../game/servicecontainer.hpp"
namespace xna {
class ContentManager {
@ -17,11 +17,7 @@ namespace xna {
ContentManager(String const& rootDirectory, sptr<GameServiceContainer> const& services) :
_rootDirectory(rootDirectory){
_services = services;
};
virtual ~ContentManager(){
Unload();
}
};
static sptr<GameServiceContainer> Services() {
return _services;
@ -35,30 +31,14 @@ namespace xna {
_rootDirectory = value;
}
virtual void Unload() {
if (_loadedAssets.empty())
return;
_loadedAssets.clear();
}
template <typename T>
T Load(String const& assetName) {
if (assetName.empty()) return T();
/*if (_loadedAssets.contains(assetName)) {
auto& ptr = _loadedAssets[assetName];
auto obj1 = reinterpret_pointer_cast<T>(ptr);
return obj1;
}*/
if (assetName.empty()) return T();
auto obj2 = ReadAsset<T>(assetName);
//auto voidAsset = reinterpret_pointer_cast<void>(obj2);
//_loadedAssets.insert({ assetName , obj2 });
return obj2;
}
}
protected:
template <typename T>
@ -76,11 +56,10 @@ namespace xna {
}
private:
String _rootDirectory;
std::map<String, sptr<void>> _loadedAssets;
inline const static String contentExtension = ".xnb";
String _rootDirectory;
std::vector<Byte> byteBuffer;
inline const static String contentExtension = ".xnb";
inline static sptr<GameServiceContainer> _services = nullptr;
};
}

1
framework/content/typereadermanager.cpp
View File

@ -1,5 +1,6 @@
#include "typereadermanager.hpp"
#include "reader.hpp"
#include "defaultreaders.hpp"
namespace xna {
std::vector<PContentTypeReader> ContentTypeReaderManager::ReadTypeManifest(Int typeCount, sptr<ContentReader>& contentReader, xna_error_ptr_arg)

33
framework/content/typereadermanager.hpp
View File

@ -42,18 +42,7 @@ namespace xna {
}
virtual T Read(ContentReader& input, T& existingInstance) = 0;
};
//-------------------------------------------------------//
// TypeComparator //
//-------------------------------------------------------//
struct TypeComparator
{
bool operator()(sptr<Type> t1, sptr<Type> t2) const
{
return t1->GetHashCode() < t2->GetHashCode();
}
};
};
//-------------------------------------------------------//
// ContentTypeReaderActivador //
@ -94,7 +83,6 @@ namespace xna {
}
private:
//inline static auto activators = std::map<size_t, Activador, TypeComparator>();
inline static auto activators = std::map<size_t, Activador>();
ContentTypeReaderActivador();
@ -155,30 +143,11 @@ namespace xna {
sptr<ContentReader> contentReader = nullptr;
inline static auto nameToReader = std::map<String, PContentTypeReader>();
//inline static auto targetTypeToReader = std::map<PType, PContentTypeReader, TypeComparator>();
//inline static auto readerTypeToReader = std::map<PType, PContentTypeReader, TypeComparator>();
inline static auto targetTypeToReader = std::map<PType, PContentTypeReader>();
inline static auto readerTypeToReader = std::map<PType, PContentTypeReader>();
static void initMaps();
};
//-------------------------------------------------------//
// ObjectReader //
//-------------------------------------------------------//
class ObjectReader : public ContentTypeReaderT<Object> {
public:
ObjectReader() : ContentTypeReaderT(typeof<Object>()) {
ContentTypeReaderActivador::SetActivador(typeof(this), []() -> sptr<ContentTypeReader> {
auto obj = New <ObjectReader>();
return reinterpret_pointer_cast<ContentTypeReader>(obj);
});
}
virtual Object Read(ContentReader& input, Object& existingInstance) override {
return Object();
}
};
}
#endif

4
framework/csharp/stream.hpp
View File

@ -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() {

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

@ -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<Texture2D>() });
//Texture2DReader
const auto textureReader = typeof<Texture2DReader>();
Type::NameOfRegisteredTypes.insert({ "xna::Texture2DReader", textureReader });
Type::NameOfRegisteredTypes.insert({ "Microsoft.Xna.Framework.Content.Texture2DReader", textureReader });
insertRegisteredReader<ObjectReader>("ObjecReader");
insertRegisteredReader<BooleanReader>("BooleanReader");
insertRegisteredReader<ByteReader>("ByteReader");
insertRegisteredReader<CharReader>("CharReader");
insertRegisteredReader<ColorReader>("ColorReader");
insertRegisteredReader<DoubleReader>("DoubleReader");
insertRegisteredReader<Int16Reader>("Int16Reader");
insertRegisteredReader<Int32Reader>("Int32Reader");
insertRegisteredReader<Int64Reader>("Int64Reader");
insertRegisteredReader<MatrixReader>("MatrixReader");
insertRegisteredReader<PointReader>("PointReader");
insertRegisteredReader<QuaternionReader>("QuaternionReader");
insertRegisteredReader<RectangleReader>("RectangleReader");
insertRegisteredReader<SByteReader>("SByteReader");
insertRegisteredReader<SingleReader>("SingleReader");
insertRegisteredReader<TimeSpanReader>("TimeSpanReader");
insertRegisteredReader<UInt16Reader>("UInt16Reader");
insertRegisteredReader<UInt32Reader>("UInt32Reader");
insertRegisteredReader<UInt64Reader>("UInt64Reader");
insertRegisteredReader<Vector2Reader>("Vector2Reader");
insertRegisteredReader<Vector3Reader>("Vector3Reader");
insertRegisteredReader<Vector4Reader>("Vector4Reader");
insertRegisteredReader<Texture2DReader>("Texture2DReader");
}
void InitPlatform::InitActivadors()
{
ContentTypeReaderActivador::SetActivador(typeof<ObjectReader>(), []() -> sptr<ContentTypeReader> {
auto obj = New <ObjectReader>();
return reinterpret_pointer_cast<ContentTypeReader>(obj);
});
ContentTypeReaderActivador::SetActivador(typeof<Texture2DReader>(), []() -> sptr<ContentTypeReader> {
auto obj = New <Texture2DReader>();
return reinterpret_pointer_cast<ContentTypeReader>(obj);
});
insertActivadorReader<ObjectReader>();
insertActivadorReader<BooleanReader>();
insertActivadorReader<ByteReader>();
insertActivadorReader<CharReader>();
insertActivadorReader<ColorReader>();
insertActivadorReader<DoubleReader>();
insertActivadorReader<Int16Reader>();
insertActivadorReader<Int32Reader>();
insertActivadorReader<Int64Reader>();
insertActivadorReader<MatrixReader>();
insertActivadorReader<PointReader>();
insertActivadorReader<QuaternionReader>();
insertActivadorReader<RectangleReader>();
insertActivadorReader<SByteReader>();
insertActivadorReader<SingleReader>();
insertActivadorReader<TimeSpanReader>();
insertActivadorReader<UInt16Reader>();
insertActivadorReader<UInt32Reader>();
insertActivadorReader<UInt64Reader>();
insertActivadorReader<Vector2Reader>();
insertActivadorReader<Vector3Reader>();
insertActivadorReader<Vector4Reader>();
insertActivadorReader<Texture2DReader>();
}
}

18
framework/platform/init-dx.hpp
View File

@ -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 <typename T>
static void insertRegisteredReader(String const& readerName) {
const auto reader = typeof<T>();
Type::NameOfRegisteredTypes.insert({ "xna::" + readerName, reader });
Type::NameOfRegisteredTypes.insert({ "Microsoft.Xna.Framework.Content." + readerName, reader });
}
template <typename T>
static void insertActivadorReader() {
ContentTypeReaderActivador::SetActivador(typeof<T>(), []() -> sptr<ContentTypeReader> {
auto obj = New <T>();
return reinterpret_pointer_cast<ContentTypeReader>(obj);
});
}
};
}

3
framework/xna.cpp
View File

@ -28,8 +28,7 @@ namespace xna {
void LoadContent() override {
spriteBatch = New<SpriteBatch>(*graphicsDevice);
texture = Content()->Load<PTexture2D>("idle");
//Texture2D texture = Content()->Load<Texture2D>("idle");
texture = Content()->Load<PTexture2D>("idlse");
Game::LoadContent();
}