From 6b37ede7200ba603257aa2e16f0acdf9c4b0098f Mon Sep 17 00:00:00 2001 From: Danilo Date: Tue, 7 May 2024 17:27:04 -0300 Subject: [PATCH] Implementa Vetores --- framework/common/matrix.hpp | 41 +++ framework/common/quaternion.hpp | 49 +++ framework/common/rectangle.hpp | 99 +++++- framework/common/vectors.cpp | 291 +++++++++++++++-- framework/common/vectors.hpp | 298 +++++++++++++++++- framework/content/defaultreaders.hpp | 38 +++ framework/content/reader.hpp | 31 +- framework/content/typereadermanager.hpp | 2 +- .../content-readers/texture2Dreader-dx.hpp | 11 +- 9 files changed, 813 insertions(+), 47 deletions(-) create mode 100644 framework/content/defaultreaders.hpp diff --git a/framework/common/matrix.hpp b/framework/common/matrix.hpp index 3a2959c..3da4588 100644 --- a/framework/common/matrix.hpp +++ b/framework/common/matrix.hpp @@ -623,6 +623,47 @@ namespace xna { vector3.Z = num3; return vector3; } + + constexpr Vector4 Vector4::Transform(Vector2 const& position, Matrix const& matrix) + { + const auto num1 = (position.X * matrix.M11 + position.Y * matrix.M21) + matrix.M41; + const auto num2 = (position.X * matrix.M12 + position.Y * matrix.M22) + matrix.M42; + const auto num3 = (position.X * matrix.M13 + position.Y * matrix.M23) + matrix.M43; + const auto num4 = (position.X * matrix.M14 + position.Y * matrix.M24) + matrix.M44; + Vector4 vector4; + vector4.X = num1; + vector4.Y = num2; + vector4.Z = num3; + vector4.W = num4; + return vector4; + } + + constexpr Vector4 Vector4::Transform(Vector3 const& position, Matrix const& matrix) + { + const auto num1 = (position.X * matrix.M11 + position.Y * matrix.M21 + position.Z * matrix.M31) + matrix.M41; + const auto num2 = (position.X * matrix.M12 + position.Y * matrix.M22 + position.Z * matrix.M32) + matrix.M42; + const auto num3 = (position.X * matrix.M13 + position.Y * matrix.M23 + position.Z * matrix.M33) + matrix.M43; + const auto num4 = (position.X * matrix.M14 + position.Y * matrix.M24 + position.Z * matrix.M34) + matrix.M44; + Vector4 vector4; + vector4.X = num1; + vector4.Y = num2; + vector4.Z = num3; + vector4.W = num4; + return vector4; + } + + constexpr Vector4 Vector4::Transform(Vector4 const& vector, Matrix const& matrix) { + const auto num1 = (vector.X * matrix.M11 + vector.Y * matrix.M21 + vector.Z * matrix.M31 + vector.W * matrix.M41); + const auto num2 = (vector.X * matrix.M12 + vector.Y * matrix.M22 + vector.Z * matrix.M32 + vector.W * matrix.M42); + const auto num3 = (vector.X * matrix.M13 + vector.Y * matrix.M23 + vector.Z * matrix.M33 + vector.W * matrix.M43); + const auto num4 = (vector.X * matrix.M14 + vector.Y * matrix.M24 + vector.Z * matrix.M34 + vector.W * matrix.M44); + Vector4 vector4; + vector4.X = num1; + vector4.Y = num2; + vector4.Z = num3; + vector4.W = num4; + return vector4; + } } #endif \ No newline at end of file diff --git a/framework/common/quaternion.hpp b/framework/common/quaternion.hpp index 87372d7..d7adeba 100644 --- a/framework/common/quaternion.hpp +++ b/framework/common/quaternion.hpp @@ -57,6 +57,55 @@ namespace xna { vector3.Z = num15; return vector3; } + + constexpr Vector4 Vector4::Transform(Vector2 const& value, Quaternion const& rotation) + { + const auto num1 = rotation.X + rotation.X; + const auto num2 = rotation.Y + rotation.Y; + const auto num3 = rotation.Z + rotation.Z; + const auto num4 = rotation.W * num1; + const auto num5 = rotation.W * num2; + const auto num6 = rotation.W * num3; + const auto num7 = rotation.X * num1; + const auto num8 = rotation.X * num2; + const auto num9 = rotation.X * num3; + const auto num10 = rotation.Y * num2; + const auto num11 = rotation.Y * num3; + const auto num12 = rotation.Z * num3; + const auto num13 = (value.X * (1.0F - num10 - num12) + value.Y * (num8 - num6)); + const auto num14 = (value.X * (num8 + num6) + value.Y * (1.0F - num7 - num12)); + const auto num15 = (value.X * (num9 - num5) + value.Y * (num11 + num4)); + Vector4 vector4; + vector4.X = num13; + vector4.Y = num14; + vector4.Z = num15; + vector4.W = 1.0f; + return vector4; + } + + constexpr Vector4 Vector4::Transform(Vector3 const& value, Quaternion const& rotation) { + const auto num1 = rotation.X + rotation.X; + const auto num2 = rotation.Y + rotation.Y; + const auto num3 = rotation.Z + rotation.Z; + const auto num4 = rotation.W * num1; + const auto num5 = rotation.W * num2; + const auto num6 = rotation.W * num3; + const auto num7 = rotation.X * num1; + const auto num8 = rotation.X * num2; + const auto num9 = rotation.X * num3; + const auto num10 = rotation.Y * num2; + const auto num11 = rotation.Y * num3; + const auto num12 = rotation.Z * num3; + const auto num13 = (value.X * (1.0F - num10 - num12) + value.Y * (num8 - num6) + value.Z * (num9 + num5)); + const auto num14 = (value.X * (num8 + num6) + value.Y * (1.0F - num7 - num12) + value.Z * (num11 - num4)); + const auto num15 = (value.X * (num9 - num5) + value.Y * (num11 + num4) + value.Z * (1.0F - num7 - num10)); + Vector4 vector4; + vector4.X = num13; + vector4.Y = num14; + vector4.Z = num15; + vector4.W = 1.0f; + return vector4; + } } #endif \ No newline at end of file diff --git a/framework/common/rectangle.hpp b/framework/common/rectangle.hpp index c454bc8..ed14fdc 100644 --- a/framework/common/rectangle.hpp +++ b/framework/common/rectangle.hpp @@ -2,18 +2,113 @@ #define XNA_COMMON_RECTANGLE_HPP #include "../types.hpp" +#include "point.hpp" namespace xna { struct Rectangle { - Int Height{ 0 }; - Int Width{ 0 }; Int X{ 0 }; Int Y{ 0 }; + Int Width{ 0 }; + Int Height{ 0 }; constexpr Rectangle() = default; constexpr Rectangle(const Int& X, const Int& Y, const Int& Width, const Int& Height): X(X), Y(Y), Width(Width), Height(Height) {} + + constexpr bool operator==(const Rectangle& other) const { + return Height == other.Height && Width == other.Width && X == other.X && Y == other.Y; + } + + constexpr Int Left() const { return X; } + constexpr Int Right() const { return X + Width; } + constexpr Int Top() const { return Y; } + constexpr Int Bottom() const { return Y + Height; } + + constexpr Point Location() const { return { X, Y }; } + constexpr void Location(Point const& p) { + X = p.X; + Y = p.Y; + } + + constexpr Point Center() const { return { X + Width / 2, Y + Height / 2 }; } + + constexpr static Rectangle Empty() { return {}; } + + constexpr bool IsEmpty() const { return Width == 0 && Height == 0 && X == 0 && Y == 0; } + + constexpr void Offset(Point const& amount) { + X += amount.X; + Y += amount.Y; + } + + constexpr void Offset(Int x, Int y) { + X += x; + Y += y; + } + + constexpr void Inflate(Int horizontalAmount, Int verticalAmount) { + X -= horizontalAmount; + Y -= verticalAmount; + Width += horizontalAmount * 2; + Height += verticalAmount * 2; + } + + constexpr bool Contains(Int x, Int y) const { + return X <= x && x < X + Width && Y <= y && y < Y + Height; + } + + constexpr bool Contains(Point const& value) const { + return X <= value.X && value.X < X + Width && Y <= value.Y && value.Y < Y + Height; + } + + constexpr bool Contains(Rectangle const& value) const { + return X <= value.X && value.X + value.Width <= X + Width && Y <= value.Y && value.Y + value.Height <= Y + Height; + } + + constexpr bool Intersects(Rectangle const& value) const { + return value.X < X + Width && X < value.X + value.Width && value.Y < Y + Height && Y < value.Y + value.Height; + } + + constexpr static Rectangle Intersect(Rectangle const& value1, Rectangle const& value2) { + const auto left1 = value1.Left(); + const auto left2 = value2.Left(); + const auto bottom1 = value1.Bottom(); + const auto bottom2 = value2.Bottom(); + const auto maxX = value1.X > value2.X ? value1.X : value2.X; + const auto maxY = value1.Y > value2.Y ? value1.Y : value2.Y; + const auto maxl = left1 < left2 ? left1 : left2; + const auto maxb = bottom1 < bottom2 ? bottom1 : bottom2; + + Rectangle rectangle{}; + + if (maxl > maxX && maxb > maxY) { + rectangle.X = maxX; + rectangle.Y = maxY; + rectangle.Width = maxl - maxX; + rectangle.Height = maxb - maxY; + } + + return rectangle; + } + + constexpr static Rectangle Union(Rectangle const& value1, Rectangle const& value2) { + const auto left1 = value1.Left(); + const auto left2 = value2.Left(); + const auto bottom1 = value1.Bottom(); + const auto bottom2 = value2.Bottom(); + const auto minX = value1.X < value2.X ? value1.X : value2.X; + const auto miny = value1.Y < value2.Y ? value1.Y : value2.Y; + const auto maxl = left1 > left2 ? left1 : left2; + const auto maxb = bottom1 > bottom2 ? bottom1 : bottom2; + + Rectangle rectangle; + rectangle.X = minX; + rectangle.Y = miny; + rectangle.Width = maxl - minX; + rectangle.Height = maxb - miny; + return rectangle; + } }; } diff --git a/framework/common/vectors.cpp b/framework/common/vectors.cpp index eb7dc6c..67c4034 100644 --- a/framework/common/vectors.cpp +++ b/framework/common/vectors.cpp @@ -17,6 +17,14 @@ namespace xna { return true; } + bool Vector2::Transform(std::vector sourceArray, Matrix const& matrix, std::vector& destinationArray) + { + if (destinationArray.empty()) + destinationArray.resize(sourceArray.size()); + + return Transform(sourceArray.data(), sourceArray.size(), matrix, destinationArray.data(), destinationArray.size()); + } + bool Vector2::Transform(Vector2 const* sourceArray, size_t sourceArrayLength, size_t sourceIndex, Matrix const& matrix, Vector2* destinationArray, size_t destinationArrayLength, size_t destinationIndex, size_t length) { if (!sourceArray || !destinationArray || destinationArrayLength < sourceArrayLength @@ -32,6 +40,14 @@ namespace xna { return true; } + bool Vector2::Transform(std::vector const& sourceArray, size_t sourceIndex, Matrix const& matrix, std::vector& destinationArray, size_t destinationIndex, size_t length) + { + if (destinationArray.empty()) + destinationArray.resize(sourceArray.size()); + + return Transform(sourceArray.data(), sourceArray.size(), sourceIndex, matrix, destinationArray.data(), destinationArray.size(), destinationIndex, length); + } + bool Vector2::TransformNormal(Vector2 const* sourceArray, size_t sourceArrayLength, Matrix const& matrix, Vector2* destinationArray, size_t destinationArrayLength) { if (!sourceArray || !destinationArray || destinationArrayLength < sourceArrayLength) return false; @@ -44,6 +60,14 @@ namespace xna { return true; } + + bool Vector2::TransformNormal(std::vector const& sourceArray, Matrix const& matrix, std::vector& destinationArray) + { + if (destinationArray.empty()) + destinationArray.resize(sourceArray.size()); + + return TransformNormal(sourceArray.data(), sourceArray.size(), matrix, destinationArray.data(), destinationArray.size()); + } bool Vector2::TransformNormal(Vector2 const* sourceArray, size_t sourceArrayLength, size_t sourceIndex, Matrix const& matrix, Vector2* destinationArray, size_t destinationArrayLength, size_t destinationIndex, size_t length) { if (!sourceArray || !destinationArray || destinationArrayLength < sourceArrayLength @@ -60,6 +84,14 @@ namespace xna { return true; } + bool Vector2::TransformNormal(std::vector const& sourceArray, size_t sourceIndex, Matrix const& matrix, std::vector& destinationArray, size_t destinationIndex, size_t length) + { + if (destinationArray.empty()) + destinationArray.resize(sourceArray.size()); + + return TransformNormal(sourceArray.data(), sourceArray.size(), sourceIndex, matrix, destinationArray.data(), destinationArray.size(), destinationIndex, length); + } + bool Vector2::Transform(Vector2 const* sourceArray, size_t sourceArrayLength, Quaternion const& rotation, Vector2* destinationArray, size_t destinationArrayLength) { if (!sourceArray || !destinationArray || destinationArrayLength < sourceArrayLength) return false; @@ -86,6 +118,14 @@ namespace xna { return true; } + bool Vector2::Transform(std::vector const& sourceArray, Quaternion const& rotation, std::vector& destinationArray) + { + if (destinationArray.empty()) + destinationArray.resize(sourceArray.size()); + + return Transform(sourceArray.data(), sourceArray.size(), rotation, destinationArray.data(), destinationArray.size()); + } + bool Vector2::Transform(Vector2 const* sourceArray, size_t sourceArrayLength, size_t sourceIndex, Quaternion const& rotation, Vector2* destinationArray, size_t destinationArrayLength, size_t destinationIndex, size_t length) { if (!sourceArray || !destinationArray || destinationArrayLength < sourceArrayLength @@ -117,30 +157,20 @@ namespace xna { return true; } - void Vector3::Normalize() { - const auto num = 1.0f / std::sqrt(X * X + Y * Y + Z * Z); - X *= num; - Y *= num; - Z *= num; - } - - Vector3 Vector3::Normalize(Vector3 const& value) { - const auto num = 1.0f / std::sqrt(value.X * value.X + value.Y * value.Y + value.Z * value.Z); - - Vector3 vector3; - vector3.X = value.X * num; - vector3.Y = value.Y * num; - vector3.Z = value.Z * num; - - return vector3; - } - - bool xna::Vector3::Transform(std::vector const& sourceArray, Matrix const& matrix, std::vector& destinationArray) + bool Vector2::Transform(std::vector const& sourceArray, size_t sourceIndex, Quaternion const& rotation, std::vector& destinationArray, size_t destinationIndex, size_t length) { - if (destinationArray.size() < sourceArray.size()) + if (destinationArray.empty()) + destinationArray.resize(sourceArray.size()); + + return Transform(sourceArray.data(), sourceArray.size(), sourceIndex, rotation, destinationArray.data(), destinationArray.size(), destinationIndex, length); + } + + bool Vector3::Transform(Vector3 const* sourceArray, size_t sourceArrayLength, Matrix const& matrix, Vector3* destinationArray, size_t destinationLength) + { + if (!sourceArray || !destinationArray || destinationLength < sourceArrayLength) return false; - for (size_t index = 0; index < sourceArray.size(); ++index) + for (size_t index = 0; index < sourceArrayLength; ++index) { const auto& source = sourceArray[index]; destinationArray[index].X = (source.X * matrix.M11 + source.Y * matrix.M21 + source.Z * matrix.M31) + matrix.M41; @@ -151,9 +181,17 @@ namespace xna { return true; } - bool Vector3::Transform(std::vector const& sourceArray, size_t sourceIndex, Matrix const& matrix, std::vector& destinationArray, size_t destinationIndex, size_t length) + bool Vector3::Transform(std::vector const& sourceArray, Matrix const& matrix, std::vector& destinationArray) { - if (sourceArray.size() < sourceIndex + length || destinationArray.size() < destinationIndex + length) + if (destinationArray.empty()) + destinationArray.resize(sourceArray.size()); + + return Transform(sourceArray.data(), sourceArray.size(), matrix, destinationArray.data(), destinationArray.size()); + } + + bool Vector3::Transform(Vector3 const* sourceArray, size_t sourceArrayLength, size_t sourceIndex, Matrix const& matrix, Vector3* destinationArray, size_t destinationLength, size_t destinationIndex, size_t length) + { + if (!sourceArray || !destinationArray || sourceArrayLength < sourceIndex + length || destinationLength < destinationIndex + length) return false; for (size_t index = 0; index < length; ++index) @@ -161,18 +199,26 @@ namespace xna { const auto& source = sourceArray[sourceIndex + index]; destinationArray[destinationIndex + index].X = (source.X * matrix.M11 + source.Y * matrix.M21 + source.Z * matrix.M31) + matrix.M41; destinationArray[destinationIndex + index].Y = (source.X * matrix.M12 + source.Y * matrix.M22 + source.Z * matrix.M32) + matrix.M42; - destinationArray[destinationIndex + index].Z = (source.X * matrix.M13 + source.Y * matrix.M23 + source.Z * matrix.M33) + matrix.M43; + destinationArray[destinationIndex + index].Z = (source.X * matrix.M13 + source.Y * matrix.M23 + source.Z * matrix.M33) + matrix.M43; } return true; } - bool Vector3::TransformNormal(std::vector const& sourceArray, Matrix const& matrix, std::vector& destinationArray) + bool Vector3::Transform(std::vector const& sourceArray, size_t sourceIndex, Matrix const& matrix, std::vector& destinationArray, size_t destinationIndex, size_t length) { - if (destinationArray.size() < sourceArray.size()) + if (destinationArray.empty()) + destinationArray.resize(sourceArray.size()); + + return Transform(sourceArray.data(), sourceArray.size(), sourceIndex, matrix, destinationArray.data(), destinationArray.size(), destinationIndex, length); + } + + bool Vector3::TransformNormal(Vector3 const* sourceArray, size_t sourceArrayLength, Matrix const& matrix, Vector3* destinationArray, size_t destionationArrayLength) + { + if (!sourceArray || !destinationArray || sourceArrayLength < destionationArrayLength) return false; - for (size_t index = 0; index < sourceArray.size(); ++index) + for (size_t index = 0; index < sourceArrayLength; ++index) { const auto& source = sourceArray[index]; destinationArray[index].X = source.X * matrix.M11 + source.Y * matrix.M21 + source.Z * matrix.M31; @@ -183,9 +229,17 @@ namespace xna { return true; } - bool Vector3::TransformNormal(std::vector const& sourceArray, size_t sourceIndex, Matrix const& matrix, std::vector& destinationArray, size_t destinationIndex, size_t length) + bool Vector3::TransformNormal(std::vector const& sourceArray, Matrix const& matrix, std::vector& destinationArray) { - if (sourceArray.size() < sourceIndex + length || destinationArray.size() < destinationIndex + length) + if (destinationArray.empty()) + destinationArray.resize(sourceArray.size()); + + return TransformNormal(sourceArray.data(), sourceArray.size(), matrix, destinationArray.data(), destinationArray.size()); + } + + bool Vector3::TransformNormal(Vector3 const* sourceArray, size_t sourceArrayLength, size_t sourceIndex, Matrix const& matrix, Vector3* destinationArray, size_t destinationLength, size_t destinationIndex, size_t length) + { + if (!sourceArray || !destinationArray || sourceArrayLength < sourceIndex + length || destinationLength < destinationIndex + length) return false; for (size_t index = 0; index < length; ++index) { @@ -198,9 +252,17 @@ namespace xna { return true; } - bool Vector3::TransformNormal(std::vector const& sourceArray, Quaternion const& rotation, std::vector& destinationArray) + bool Vector3::TransformNormal(std::vector const& sourceArray, size_t sourceIndex, Matrix const& matrix, std::vector& destinationArray, size_t destinationIndex, size_t length) { - if (destinationArray.size() < sourceArray.size()) + if (destinationArray.empty()) + destinationArray.resize(sourceArray.size()); + + return TransformNormal(sourceArray.data(), sourceArray.size(), sourceIndex, matrix, destinationArray.data(), destinationArray.size(), destinationIndex, length); + } + + bool Vector3::TransformNormal(Vector3 const* sourceArray, size_t sourceArrayLength, Quaternion const& rotation, Vector3* destinationArray, size_t destinationLength) + { + if (!sourceArray || !destinationArray || destinationLength < sourceArrayLength) return false; const auto num1 = rotation.X + rotation.X; @@ -225,7 +287,7 @@ namespace xna { const auto num20 = num11 + num4; const auto num21 = 1.0f - num7 - num10; - for (size_t index = 0; index < sourceArray.size(); ++index) + for (size_t index = 0; index < sourceArrayLength; ++index) { const auto& source = sourceArray[index]; destinationArray[index].X = source.X * num13 + source.Y * num14 + source.Z * num15; @@ -236,11 +298,19 @@ namespace xna { return true; } - bool Vector3::TransformNormal(std::vector const& sourceArray, size_t sourceIndex, Quaternion const& rotation, std::vector& destinationArray, size_t destinationIndex, size_t length) + bool Vector3::TransformNormal(std::vector const& sourceArray, Quaternion const& rotation, std::vector& destinationArray) { - if (sourceArray.size() < sourceIndex + length || destinationArray.size() < destinationIndex + length) + if (destinationArray.empty()) + destinationArray.resize(sourceArray.size()); + + return TransformNormal(sourceArray.data(), sourceArray.size(), rotation, destinationArray.data(), destinationArray.size()); + } + + bool Vector3::TransformNormal(Vector3 const* sourceArray, size_t sourceArrayLength, size_t sourceIndex, Quaternion const& rotation, Vector3* destinationArray, size_t destinationLength, size_t destinationIndex, size_t length) + { + if (!sourceArray || !destinationArray || sourceArrayLength < sourceIndex + length || destinationLength < destinationIndex + length) return false; - + const auto num1 = rotation.X + rotation.X; const auto num2 = rotation.Y + rotation.Y; const auto num3 = rotation.Z + rotation.Z; @@ -273,4 +343,155 @@ namespace xna { return true; } + + bool Vector3::TransformNormal(std::vector const& sourceArray, size_t sourceIndex, Quaternion const& rotation, std::vector& destinationArray, size_t destinationIndex, size_t length) + { + if (destinationArray.empty()) + destinationArray.resize(sourceArray.size()); + + return TransformNormal(sourceArray.data(), sourceArray.size(), sourceIndex, rotation, destinationArray.data(), destinationArray.size(), destinationIndex, length); + } + + bool Vector4::Transform(Vector4 const* sourceArray, size_t sourceLength, Matrix const& matrix, Vector4* destinationArray, size_t destinationLength) + { + if (!sourceArray || !destinationArray || destinationLength < sourceLength) + return false; + + for (size_t index = 0; index < sourceLength; ++index) + { + const auto& source = sourceArray[index]; + destinationArray[index].X = source.X * matrix.M11 + source.Y * matrix.M21 + source.Z * matrix.M31 + source.W * matrix.M41; + destinationArray[index].Y = source.X * matrix.M12 + source.Y * matrix.M22 + source.Z * matrix.M32 + source.W * matrix.M42; + destinationArray[index].Z = source.X * matrix.M13 + source.Y * matrix.M23 + source.Z * matrix.M33 + source.W * matrix.M43; + destinationArray[index].W = source.X * matrix.M14 + source.Y * matrix.M24 + source.Z * matrix.M34 + source.W * matrix.M44; + } + + return true; + } + + bool Vector4::Transform(std::vector const& sourceArray, size_t sourceLength, Matrix const& matrix, std::vector& destinationArray) + { + if (destinationArray.empty()) + destinationArray.resize(sourceArray.size()); + + return Transform(sourceArray.data(), sourceArray.size(), matrix, destinationArray.data(), destinationArray.size()); + } + + bool Vector4::Transform(Vector4 const* sourceArray, size_t sourceLength, size_t sourceIndex, Matrix const& matrix, Vector4* destinationArray, size_t destinationLength, size_t destinationIndex, size_t length) + { + if (!sourceArray || !destinationArray || sourceLength < sourceIndex + length || destinationLength < destinationIndex + length) + return false; + + for (size_t i = 0; i < length; ++i) + { + const auto& source = sourceArray[sourceIndex + i]; + destinationArray[destinationIndex].X = source.X * matrix.M11 + source.Y * matrix.M21 + source.Z * matrix.M31 + source.W * matrix.M41; + destinationArray[destinationIndex].Y = source.X * matrix.M12 + source.Y * matrix.M22 + source.Z * matrix.M32 + source.W * matrix.M42; + destinationArray[destinationIndex].Z = source.X * matrix.M13 + source.Y * matrix.M23 + source.Z * matrix.M33 + source.W * matrix.M43; + destinationArray[destinationIndex].W = source.X * matrix.M14 + source.Y * matrix.M24 + source.Z * matrix.M34 + source.W * matrix.M44; + } + + return true; + } + + bool Vector4::Transform(std::vector const& sourceArray, size_t sourceIndex, Matrix const& matrix, std::vector& destinationArray, size_t destinationIndex, size_t length) + { + if (destinationArray.empty()) + destinationArray.resize(sourceArray.size()); + + return Transform(sourceArray.data(), sourceArray.size(), sourceIndex, matrix, destinationArray.data(), destinationArray.size(), destinationIndex, length); + } + + bool Vector4::Transform(Vector4 const* sourceArray, size_t sourceLength, Quaternion const& rotation, Vector4* destinationArray, size_t destinationLength) + { + if (!sourceArray || !destinationArray || destinationLength < sourceLength) + return false; + + const auto num1 = rotation.X + rotation.X; + const auto num2 = rotation.Y + rotation.Y; + const auto num3 = rotation.Z + rotation.Z; + const auto num4 = rotation.W * num1; + const auto num5 = rotation.W * num2; + const auto num6 = rotation.W * num3; + const auto num7 = rotation.X * num1; + const auto num8 = rotation.X * num2; + const auto num9 = rotation.X * num3; + const auto num10 = rotation.Y * num2; + const auto num11 = rotation.Y * num3; + const auto num12 = rotation.Z * num3; + const auto num13 = 1.0f - num10 - num12; + const auto num14 = num8 - num6; + const auto num15 = num9 + num5; + const auto num16 = num8 + num6; + const auto num17 = 1.0f - num7 - num12; + const auto num18 = num11 - num4; + const auto num19 = num9 - num5; + const auto num20 = num11 + num4; + const auto num21 = 1.0f - num7 - num10; + + for (size_t index = 0; index < sourceLength; ++index) + { + const auto& source = sourceArray[index]; + destinationArray[index].X = source.Z * num13 + source.Y * num14 + source.Z * num15; + destinationArray[index].Y = source.Z * num16 + source.Y * num17 + source.Z * num18; + destinationArray[index].Z = source.Z * num19 + source.Y * num20 + source.Z * num21; + destinationArray[index].W = sourceArray[index].W; + } + + return true; + } + + bool Vector4::Transform(std::vector const& sourceArray, Quaternion const& rotation, std::vector& destinationArray) + { + if (destinationArray.empty()) + destinationArray.resize(sourceArray.size()); + + return Transform(sourceArray.data(), sourceArray.size(), rotation, destinationArray.data(), destinationArray.size()); + } + + bool Vector4::Transform(Vector4 const* sourceArray, size_t sourceLength, size_t sourceIndex, Quaternion const& rotation, Vector4* destinationArray, size_t destinationLength, size_t destinationIndex, size_t length) + { + if (!sourceArray || !destinationArray || sourceLength < sourceIndex + length || destinationLength < destinationIndex + length) + return false; + + const auto num1 = rotation.X + rotation.X; + const auto num2 = rotation.Y + rotation.Y; + const auto num3 = rotation.Z + rotation.Z; + const auto num4 = rotation.W * num1; + const auto num5 = rotation.W * num2; + const auto num6 = rotation.W * num3; + const auto num7 = rotation.X * num1; + const auto num8 = rotation.X * num2; + const auto num9 = rotation.X * num3; + const auto num10 = rotation.Y * num2; + const auto num11 = rotation.Y * num3; + const auto num12 = rotation.Z * num3; + const auto num13 = 1.0f - num10 - num12; + const auto num14 = num8 - num6; + const auto num15 = num9 + num5; + const auto num16 = num8 + num6; + const auto num17 = 1.0f - num7 - num12; + const auto num18 = num11 - num4; + const auto num19 = num9 - num5; + const auto num20 = num11 + num4; + const auto num21 = 1.0f - num7 - num10; + + for (size_t i = 0; i < length; ++i) + { + const auto& source = sourceArray[sourceIndex + i]; + destinationArray[destinationIndex].X = source.X * num13 + source.Y * num14 + source.Z * num15; + destinationArray[destinationIndex].Y = source.X * num16 + source.Y * num17 + source.Z * num18; + destinationArray[destinationIndex].Z = source.X * num19 + source.Y * num20 + source.Z * num21; + destinationArray[destinationIndex].W = source.W; + } + + return true; + } + bool Vector4::Transform(std::vector const& sourceArray, size_t sourceIndex, Quaternion const& rotation, std::vector& destinationArray, size_t destinationIndex, size_t length) + { + if (destinationArray.empty()) + destinationArray.resize(sourceArray.size()); + + return Transform(sourceArray.data(), sourceArray.size(), sourceIndex, rotation, destinationArray.data(), destinationArray.size(), destinationIndex, length); + } } \ No newline at end of file diff --git a/framework/common/vectors.hpp b/framework/common/vectors.hpp index 5587285..20a3abb 100644 --- a/framework/common/vectors.hpp +++ b/framework/common/vectors.hpp @@ -53,8 +53,9 @@ namespace xna { } static inline Vector2 Normalize(Vector2 const& value) { - const auto normal = 1.0F / value.Length(); - return { value.X * normal, value.Y * normal }; + auto v = value; + v.Normalize(); + return v; } static constexpr Vector2 Reflect(Vector2 const& vector, Vector2 const& normal) { @@ -136,14 +137,20 @@ namespace xna { static constexpr Vector2 TransformNormal(Vector2 const& normal, Matrix const& matrix); static constexpr Vector2 Transform(Vector2 const& value, Quaternion const& rotation); static bool Transform(Vector2 const* sourceArray, size_t sourceArrayLength, Matrix const& matrix, Vector2* destinationArray, size_t destinationArrayLength); + static bool Transform(std::vector sourceArray, Matrix const& matrix, std::vector& destinationArray); static bool Transform(Vector2 const* sourceArray, size_t sourceArrayLength, size_t sourceIndex, Matrix const& matrix, Vector2* destinationArray, size_t destinationArrayLength, size_t destinationIndex, size_t length); + static bool Transform(std::vector const& sourceArray, size_t sourceIndex, Matrix const& matrix, std::vector& destinationArray, size_t destinationIndex, size_t length); static bool TransformNormal(Vector2 const* sourceArray, size_t sourceArrayLength, Matrix const& matrix, Vector2* destinationArray, size_t destinationArrayLength); + static bool TransformNormal(std::vector const& sourceArray, Matrix const& matrix, std::vector& destinationArray); static bool TransformNormal(Vector2 const* sourceArray, size_t sourceArrayLength, size_t sourceIndex, Matrix const& matrix, Vector2* destinationArray, size_t destinationArrayLength, size_t destinationIndex, size_t length); + static bool TransformNormal(std::vector const& sourceArray, size_t sourceIndex, Matrix const& matrix, std::vector& destinationArray, size_t destinationIndex, size_t length); static bool Transform(Vector2 const* sourceArray, size_t sourceArrayLength, Quaternion const& rotation, Vector2* destinationArray, size_t destinationArrayLength); + static bool Transform(std::vector const& sourceArray, Quaternion const& rotation, std::vector& destinationArray); static bool Transform(Vector2 const* sourceArray, size_t sourceArrayLength, size_t sourceIndex, Quaternion const& rotation, Vector2* destinationArray, size_t destinationArrayLength, size_t destinationIndex, size_t length); + static bool Transform(std::vector const& sourceArray, size_t sourceIndex, Quaternion const& rotation, std::vector& destinationArray, size_t destinationIndex, size_t length); static constexpr Vector2 Negate(Vector2 const& value) { return { -value.X, -value.Y }; @@ -260,8 +267,18 @@ namespace xna { return vector1.X * vector2.X + vector1.Y * vector2.Y + vector1.Z * vector2.Z; } - void Normalize(); - static Vector3 Normalize(Vector3 const& value); + inline void Normalize() { + const auto num = 1.0f / Length(); + X *= num; + Y *= num; + Z *= num; + } + + static Vector3 Normalize(Vector3 const& value) { + auto v = value; + v.Normalize(); + return v; + } static constexpr Vector3 Cross(Vector3 const& vector1, Vector3 const& vector2) { Vector3 vector3; @@ -364,11 +381,17 @@ namespace xna { static constexpr Vector3 Transform(Vector3 const& position, Matrix const& matrix); static constexpr Vector3 TransformNormal(Vector3 const& normal, Matrix const& matrix); static constexpr Vector3 Transform(Vector3 const& value, Quaternion const& rotation); + static bool Transform(Vector3 const* sourceArray, size_t sourceArrayLength, Matrix const& matrix, Vector3* destinationArray, size_t destinationLength); static bool Transform(std::vector const& sourceArray, Matrix const& matrix, std::vector& destinationArray); + static bool Transform(Vector3 const* sourceArray, size_t sourceArrayLength, size_t sourceIndex, Matrix const& matrix, Vector3* destinationArray, size_t destinationLength, size_t destinationIndex, size_t length); static bool Transform(std::vector const& sourceArray, size_t sourceIndex, Matrix const& matrix, std::vector& destinationArray, size_t destinationIndex, size_t length); + static bool TransformNormal(Vector3 const* sourceArray, size_t sourceArrayLength, Matrix const& matrix, Vector3* destinationArray, size_t destionationArrayLength); static bool TransformNormal(std::vector const& sourceArray, Matrix const& matrix, std::vector& destinationArray); + static bool TransformNormal(Vector3 const* sourceArray, size_t sourceArrayLength, size_t sourceIndex, Matrix const& matrix, Vector3* destinationArray, size_t destinationLength, size_t destinationIndex, size_t length); static bool TransformNormal(std::vector const& sourceArray, size_t sourceIndex, Matrix const& matrix, std::vector& destinationArray, size_t destinationIndex, size_t length); + static bool TransformNormal(Vector3 const* sourceArray, size_t sourceArrayLength, Quaternion const& rotation,Vector3* destinationArray, size_t destinationLength); static bool TransformNormal(std::vector const& sourceArray, Quaternion const& rotation, std::vector& destinationArray); + static bool TransformNormal(Vector3 const* sourceArray, size_t sourceArrayLength, size_t sourceIndex, Quaternion const& rotation, Vector3* destinationArray, size_t destinationLength, size_t destinationIndex, size_t length); static bool TransformNormal(std::vector const& sourceArray, size_t sourceIndex, Quaternion const& rotation, std::vector& destinationArray, size_t destinationIndex, size_t length); static constexpr Vector3 Negate(Vector3 const& value) @@ -474,12 +497,279 @@ namespace xna { constexpr Vector4() = default; + constexpr Vector4(float value): + X(value), Y(value), Z(value), W(value){} + constexpr Vector4(float X, float Y, float Z, float W) : X(X), Y(Y), Z(Z), W(W) { } + constexpr Vector4(Vector2 value, float Z, float W) + : X(value.X), Y(value.Y), Z(Z), W(W) { } + + constexpr Vector4(Vector3 value, float W) + : X(value.X), Y(value.Y), Z(value.Z), W(W) { } + constexpr bool operator==(const Vector4& other) const { return X == other.X && Y == other.Y && Z == other.Z && W == other.W; } + + static Vector4 Zero() { return {}; } + static Vector4 One() { return { 1 }; } + static Vector4 UnitX() { return { 1,0,0,0 }; } + static Vector4 UnitY() { return { 0,1,0,0 }; } + static Vector4 UnitZ() { return { 0,0,1,0 }; } + static Vector4 UnitW() { return { 0,0,0,1 }; } + + float Length() const { + return sqrt(LengthSquared()); + } + + constexpr float LengthSquared() const { + return (X * X + Y * Y + Z * Z + W * W); + } + + inline static float Distance(Vector4 const& value1, Vector4 const& value2) { + return sqrt(DistanceSquared(value1, value2)); + } + + static constexpr float DistanceSquared(Vector4 const& value1, Vector4 const& value2) { + const auto num1 = value1.X - value2.X; + const auto num2 = value1.Y - value2.Y; + const auto num3 = value1.Z - value2.Z; + const auto num4 = value1.W - value2.W; + return num1 * num1 + num2 * num2 + num3 * num3 + num4 * num4; + } + + static constexpr float Dot(Vector4 const& vector1, Vector4 const& vector2) { + return vector1.X * vector2.X + vector1.Y * vector2.Y + vector1.Z * vector2.Z + vector1.W * vector2.W; + } + + void Normalize() { + const auto num = 1.0f / Length(); + X *= num; + Y *= num; + Z *= num; + W *= num; + } + + inline static Vector4 Normalize(Vector4 const& vector) { + auto v = vector; + v.Normalize(); + return v; + } + + static constexpr Vector4 Min(Vector4 const& value1, Vector4 const& value2) { + Vector4 vector4; + vector4.X = value1.X < value2.X ? value1.X : value2.X; + vector4.Y = value1.Y < value2.Y ? value1.Y : value2.Y; + vector4.Z = value1.Z < value2.Z ? value1.Z : value2.Z; + vector4.W = value1.W < value2.W ? value1.W : value2.W; + return vector4; + } + + static constexpr Vector4 Max(Vector4 const& value1, Vector4 const& value2) { + Vector4 vector4; + vector4.X = value1.X > value2.X ? value1.X : value2.X; + vector4.Y = value1.Y > value2.Y ? value1.Y : value2.Y; + vector4.Z = value1.Z > value2.Z ? value1.Z : value2.Z; + vector4.W = value1.W > value2.W ? value1.W : value2.W; + return vector4; + } + + static Vector4 Clamp(Vector4 const& value1, Vector4 const& min, Vector4 const& max) { + const auto x = value1.X; + const auto num1 = x > max.X ? max.X : x; + const auto num2 = num1 < min.X ? min.X : num1; + const auto y = value1.Y; + const auto num3 = y > max.Y ? max.Y : y; + const auto num4 = num3 < min.Y ? min.Y : num3; + const auto z = value1.Z; + const auto num5 = z > max.Z ? max.Z : z; + const auto num6 = num5 < min.Z ? min.Z : num5; + const auto w = value1.W; + const auto num7 = w > max.W ? max.W : w; + const auto num8 = num7 < min.W ? min.W : num7; + Vector4 vector4; + vector4.X = num2; + vector4.Y = num4; + vector4.Z = num6; + vector4.W = num8; + return vector4; + } + + static Vector4 Lerp(Vector4 const& value1, Vector4 const& value2, float amount) { + Vector4 vector4; + vector4.X = value1.X + (value2.X - value1.X) * amount; + vector4.Y = value1.Y + (value2.Y - value1.Y) * amount; + vector4.Z = value1.Z + (value2.Z - value1.Z) * amount; + vector4.W = value1.W + (value2.W - value1.W) * amount; + return vector4; + } + + static Vector4 Barycentric(Vector4 const& value1, Vector4 const& value2, Vector4 const& value3, float amount1, float amount2) { + Vector4 vector4; + vector4.X = value1.X + amount1 * (value2.X - value1.X) + amount2 * (value3.X - value1.X); + vector4.Y = value1.Y + amount1 * (value2.Y - value1.Y) + amount2 * (value3.Y - value1.Y); + vector4.Z = value1.Z + amount1 * (value2.Z - value1.Z) + amount2 * (value3.Z - value1.Z); + vector4.W = value1.W + amount1 * (value2.W - value1.W) + amount2 * (value3.W - value1.W); + return vector4; + } + + static Vector4 SmoothStep(Vector4 const& value1, Vector4 const& value2, float amount) { + amount = amount > 1.0F ? 1.0f : (amount < 0.0F ? 0.0f : amount); + amount = (amount * amount * (3.0F - 2.0F * amount)); + Vector4 vector4; + vector4.X = value1.X + (value2.X - value1.X) * amount; + vector4.Y = value1.Y + (value2.Y - value1.Y) * amount; + vector4.Z = value1.Z + (value2.Z - value1.Z) * amount; + vector4.W = value1.W + (value2.W - value1.W) * amount; + return vector4; + } + + static Vector4 CatmullRom(Vector4 const& value1, Vector4 const& value2, Vector4 const& value3, Vector4 const& value4, float amount) { + const auto num1 = amount * amount; + const auto num2 = amount * num1; + Vector4 vector4; + vector4.X = 0.5F * (2.0f * value2.X + (-value1.X + value3.X) * amount + (2.0F * value1.X - 5.0f * value2.X + 4.0f * value3.X - value4.X) * num1 + (-value1.X + 3.0f * value2.X - 3.0f * value3.X + value4.X) * num2); + vector4.Y = 0.5F * (2.0f * value2.Y + (-value1.Y + value3.Y) * amount + (2.0F * value1.Y - 5.0f * value2.Y + 4.0f * value3.Y - value4.Y) * num1 + (-value1.Y + 3.0f * value2.Y - 3.0f * value3.Y + value4.Y) * num2); + vector4.Z = 0.5F * (2.0f * value2.Z + (-value1.Z + value3.Z) * amount + (2.0F * value1.Z - 5.0f * value2.Z + 4.0f * value3.Z - value4.Z) * num1 + (-value1.Z + 3.0f * value2.Z - 3.0f * value3.Z + value4.Z) * num2); + vector4.W = 0.5F * (2.0f * value2.W + (-value1.W + value3.W) * amount + (2.0F * value1.W - 5.0f * value2.W + 4.0f * value3.W - value4.W) * num1 + (-value1.W + 3.0f * value2.W - 3.0f * value3.W + value4.W) * num2); + return vector4; + } + + static Vector4 Hermite(Vector4 const& value1, Vector4 const& tangent1, Vector4 const& value2, Vector4 const& tangent2, float amount) { + const auto num1 = amount * amount; + const auto num2 = amount * num1; + const auto num3 = (2.0F * num2 - 3.0F * num1 + 1.0F); + const auto num4 = (-2.0F * num2 + 3.0F * num1); + const auto num5 = num2 - 2.0f * num1 + amount; + const auto num6 = num2 - num1; + Vector4 vector4; + vector4.X = (value1.X * num3 + value2.X * num4 + tangent1.X * num5 + tangent2.X * num6); + vector4.Y = (value1.Y * num3 + value2.Y * num4 + tangent1.Y * num5 + tangent2.Y * num6); + vector4.Z = (value1.Z * num3 + value2.Z * num4 + tangent1.Z * num5 + tangent2.Z * num6); + vector4.W = (value1.W * num3 + value2.W * num4 + tangent1.W * num5 + tangent2.W * num6); + return vector4; + } + + static constexpr Vector4 Transform(Vector2 const& position, Matrix const& matrix); + static constexpr Vector4 Transform(Vector3 const& position, Matrix const& matrix); + static constexpr Vector4 Transform(Vector4 const& vector, Matrix const& matrix); + static constexpr Vector4 Transform(Vector2 const& value, Quaternion const& rotation); + static constexpr Vector4 Transform(Vector3 const& value, Quaternion const& rotation); + static bool Transform(Vector4 const* sourceArray, size_t sourceLength, Matrix const& matrix, Vector4* destinationArray, size_t destinationLength); + static bool Transform(std::vector const& sourceArray, size_t sourceLength, Matrix const& matrix, std::vector& destinationArray); + static bool Transform(Vector4 const* sourceArray, size_t sourceLength, size_t sourceIndex, Matrix const& matrix, Vector4* destinationArray, size_t destinationLength, size_t destinationIndex, size_t length); + static bool Transform(std::vector const& sourceArray, size_t sourceIndex, Matrix const& matrix, std::vector& destinationArray, size_t destinationIndex, size_t length); + static bool Transform(Vector4 const* sourceArray, size_t sourceLength, Quaternion const& rotation, Vector4* destinationArray, size_t destinationLength); + static bool Transform(std::vector const& sourceArray, Quaternion const& rotation, std::vector& destinationArray); + static bool Transform(Vector4 const* sourceArray, size_t sourceLength, size_t sourceIndex, Quaternion const& rotation, Vector4* destinationArray, size_t destinationLength, size_t destinationIndex, size_t length); + static bool Transform(std::vector const& sourceArray, size_t sourceIndex, Quaternion const& rotation, std::vector& destinationArray, size_t destinationIndex, size_t length); + + static constexpr Vector4 Negate(Vector4 const& value) { + Vector4 vector4; + vector4.X = -value.X; + vector4.Y = -value.Y; + vector4.Z = -value.Z; + vector4.W = -value.W; + return vector4; + } + + static constexpr Vector4 Add(Vector4 const& value1, Vector4 const& value2) { + Vector4 vector4; + vector4.X = value1.X + value2.X; + vector4.Y = value1.Y + value2.Y; + vector4.Z = value1.Z + value2.Z; + vector4.W = value1.W + value2.W; + return vector4; + } + + static constexpr Vector4 Subtract(Vector4 const& value1, Vector4 const& value2) { + Vector4 vector4; + vector4.X = value1.X - value2.X; + vector4.Y = value1.Y - value2.Y; + vector4.Z = value1.Z - value2.Z; + vector4.W = value1.W - value2.W; + return vector4; + } + + static constexpr Vector4 Multiply(Vector4 const& value1, Vector4 const& value2) + { + Vector4 vector4; + vector4.X = value1.X * value2.X; + vector4.Y = value1.Y * value2.Y; + vector4.Z = value1.Z * value2.Z; + vector4.W = value1.W * value2.W; + return vector4; + } + + + static constexpr Vector4 Multiply(Vector4 const& value1, float scaleFactor) + { + Vector4 vector4; + vector4.X = value1.X * scaleFactor; + vector4.Y = value1.Y * scaleFactor; + vector4.Z = value1.Z * scaleFactor; + vector4.W = value1.W * scaleFactor; + return vector4; + } + + static constexpr Vector4 Divide(Vector4 const& value1, Vector4 const& value2) + { + Vector4 vector4; + vector4.X = value1.X / value2.X; + vector4.Y = value1.Y / value2.Y; + vector4.Z = value1.Z / value2.Z; + vector4.W = value1.W / value2.W; + return vector4; + } + + static constexpr Vector4 Divide(Vector4 const& value1, float divider) + { + float num = 1.0f / divider; + Vector4 vector4; + vector4.X = value1.X * num; + vector4.Y = value1.Y * num; + vector4.Z = value1.Z * num; + vector4.W = value1.W * num; + return vector4; + } + + constexpr Vector4 operator-() const { + return Vector4::Negate(*this); + } + + friend constexpr Vector4 operator+(Vector4 const& value1, Vector4 const& value2) { + return Vector4::Add(value1, value2); + } + + friend constexpr Vector4 operator-(Vector4 const& value1, Vector4 const& value2) { + return Vector4::Subtract(value1, value2); + } + + friend constexpr Vector4 operator*(Vector4 const& value1, Vector4 const& value2) { + return Vector4::Multiply(value1, value2); + } + + friend constexpr Vector4 operator*(Vector4 const& value, float factor) { + return Vector4::Multiply(value, factor); + } + + friend constexpr Vector4 operator*(float factor, Vector4 const& value) { + return Vector4::Multiply(value, factor); + } + + friend constexpr Vector4 operator/(Vector4 const& value1, Vector4 const& value2) { + return Vector4::Divide(value1, value2); + } + + friend constexpr Vector4 operator/(Vector4 const& value, float divider) { + return Vector4::Divide(value, divider); + } + + friend constexpr Vector4 operator/(float divider, Vector4 const& value) { + return Vector4::Divide(value, divider); + } }; } diff --git a/framework/content/defaultreaders.hpp b/framework/content/defaultreaders.hpp new file mode 100644 index 0000000..9684f5b --- /dev/null +++ b/framework/content/defaultreaders.hpp @@ -0,0 +1,38 @@ +#ifndef XNA_CONTENT_DEFAULTREADERS_ARRAY_HPP +#define XNA_CONTENT_DEFAULTREADERS_ARRAY_HPP + +#include "reader.hpp" +#include "../default.hpp" + +namespace xna { + template + class ArrayReader : public ContentTypeReaderT> { + public: + void Initialize(sptr const& manager) { + elementReader = manager->GetTypeReader(typeof()); + } + + sptr> Read(ContentReader& input, std::vector& existingInstance) override { + const auto length = input.ReadInt32(); + std::vector objArray(length); + + for (size_t index = 0; index < length; ++index) + objArray[index] = input.ReadObject(elementReader); + + return objArray; + } + + private: + sptr elementReader = nullptr; + }; + + class BooleanReader : public ContentTypeReaderT { + sptr Read(ContentReader& input, bool& existingInstance) override { + auto value = input.ReadBoolean(); + auto b = New(value); + return b; + } + }; +} + +#endif \ No newline at end of file diff --git a/framework/content/reader.hpp b/framework/content/reader.hpp index 8804308..5a8e402 100644 --- a/framework/content/reader.hpp +++ b/framework/content/reader.hpp @@ -25,6 +25,12 @@ namespace xna { template sptr ReadObject(T existingInstance); + template + sptr ReadObject(ContentTypeReader& typeReader); + + template + sptr ReadObject(ContentTypeReader& typeReader, T existingInstance); + Vector2 ReadVector2(); Vector3 ReadVector3(); Vector4 ReadVector4(); @@ -46,6 +52,9 @@ namespace xna { template sptr ReadObjectInternal(std::any& existingInstance, xna_error_nullarg); + + template + sptr ReadObjectInternal(ContentTypeReader& typeReader, std::any& existingInstance, xna_error_nullarg); template sptr InvokeReader(ContentTypeReader& reader, std::any& existingInstance, xna_error_nullarg); @@ -102,7 +111,6 @@ namespace xna { { const auto sharedResourceCount = ReadHeader(); auto obj = ReadObject(); - //this.ReadSharedResources(sharedResourceCount); return obj; } @@ -118,6 +126,27 @@ namespace xna { { return ReadObjectInternal(std::any(existingInstance)); } + + template + inline sptr ContentReader::ReadObject(ContentTypeReader& typeReader) + { + auto obj = std::any(); + return ReadObjectInternal(typeReader, obj); + } + + template + inline sptr ContentReader::ReadObject(ContentTypeReader& typeReader, T existingInstance) + { + return ReadObjectInternal(typeReader, std::any(existingInstance)); + } + + template + inline sptr ContentReader::ReadObjectInternal(ContentTypeReader& typeReader, std::any& existingInstance, xna_error_ptr_arg) + { + return typeReader.TargetIsValueType + ? InvokeReader(typeReader, existingInstance, err) + : ReadObjectInternal(existingInstance, err); + } } #endif \ No newline at end of file diff --git a/framework/content/typereadermanager.hpp b/framework/content/typereadermanager.hpp index 12342a9..d9f230a 100644 --- a/framework/content/typereadermanager.hpp +++ b/framework/content/typereadermanager.hpp @@ -15,7 +15,7 @@ namespace xna { public: virtual Int TypeVersion() { return 0; } virtual bool CanDeserializeIntoExistingObject() { return false; } - virtual void Initialize(sptr& manager) {} + virtual void Initialize(sptr const& manager) {} sptr TargetType() { return _targetType; } virtual std::any Read(ContentReader& input, std::any& existingInstance) = 0; diff --git a/framework/platform/content-readers/texture2Dreader-dx.hpp b/framework/platform/content-readers/texture2Dreader-dx.hpp index 02dbedf..7ad93f7 100644 --- a/framework/platform/content-readers/texture2Dreader-dx.hpp +++ b/framework/platform/content-readers/texture2Dreader-dx.hpp @@ -1,10 +1,10 @@ #ifndef XNA_PLATFORM_CONTENTREADERS_TEXTURE2D_HPP #define XNA_PLATFORM_CONTENTREADERS_TEXTURE2D_HPP -#include "../../content/reader.hpp" -#include "../texture-dx.hpp" #include "../../content/manager.hpp" +#include "../../content/reader.hpp" #include "../../csharp/type.hpp" +#include "../texture-dx.hpp" namespace xna { class Texture2DReader : public ContentTypeReaderT { @@ -18,7 +18,10 @@ namespace xna { const auto mipMaps = input.ReadInt32(); auto a_device = ContentManager::Services()->GetService(*typeof()); - auto device = std::any_cast>(a_device); + sptr device = nullptr; + + if(a_device.has_value()) + device = std::any_cast>(a_device); auto texture2D = New(device, width, height, mipMaps, format); @@ -26,7 +29,7 @@ namespace xna { auto elementCount = input.ReadInt32(); std::vector data = input.ReadByteBuffer(elementCount); - texture2D->SetData(level, nullptr, data, 0, elementCount); + texture2D->SetData(static_cast(level), nullptr, data, 0, elementCount); } return texture2D;