1
0
mirror of https://github.com/borgesdan/xn65 synced 2024-12-29 21:54:47 +01:00

248 lines
6.3 KiB
C++

#ifndef XNA_CONTENT_READERS_DEFAULT_HPP
#define XNA_CONTENT_READERS_DEFAULT_HPP
#include "../../common/color.hpp"
#include "../../common/numerics.hpp"
#include "../../csharp/timespan.hpp"
#include "../../default.hpp"
#include "../reader.hpp"
namespace xna {
class ObjectReader : public ContentTypeReader {
public:
ObjectReader() : ContentTypeReader(typeof<Object>()) {}
virtual Object Read(ContentReader& input, Object& existingInstance) override {
Exception::Throw(Exception::NOT_IMPLEMENTED);
return Object();
}
};
class BooleanReader : public ContentTypeReaderT<bool> {
public:
BooleanReader() : ContentTypeReaderT(typeof<bool>()) {}
bool Read(ContentReader& input, bool& existingInstance) override {
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();
}
};
template <typename T>
class ListReader : public ContentTypeReaderT<std::vector<T>> {
public:
ListReader(){}
std::vector<T> Read(ContentReader& input, std::vector<T>& existingInstance) override {
auto num = input.ReadInt32();
auto& objList = existingInstance;
while (num-- > 0) {
auto obj = input.ReadObject<T>(*elementReader);
objList.push_back(obj);
}
return objList;
}
void Initialize(sptr<ContentTypeReaderManager> const& manager) override {
elementReader = manager->GetTypeReader(typeof<T>());
}
private:
PContentTypeReader elementReader = nullptr;
};
}
#endif