mirror of
https://github.com/borgesdan/xn65
synced 2024-12-29 21:54:47 +01:00
Implementação em init-dx
This commit is contained in:
parent
77c6c40115
commit
caa9958e9e
@ -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
|
@ -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,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)
|
||||
|
@ -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
|
@ -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() {
|
||||
|
@ -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>();
|
||||
}
|
||||
}
|
@ -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);
|
||||
});
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -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();
|
||||
}
|
||||
|
Loading…
x
Reference in New Issue
Block a user