From 596de3cd2eeb32ca8d292c0409f46526acd31eaa Mon Sep 17 00:00:00 2001 From: Vladyslav Baranovskyi Date: Mon, 4 Nov 2024 17:04:19 +0200 Subject: [PATCH] YamlCppConverters for various pieces of math + tests --- .../Extensions/YamlCppConverters.hpp | 164 ++++++++++++++++- tests/Extensions/YamlCppConverters.cpp | 165 +++++++++++++----- 2 files changed, 287 insertions(+), 42 deletions(-) diff --git a/openVulkanoCpp/Extensions/YamlCppConverters.hpp b/openVulkanoCpp/Extensions/YamlCppConverters.hpp index 0286a12..58ffbd9 100644 --- a/openVulkanoCpp/Extensions/YamlCppConverters.hpp +++ b/openVulkanoCpp/Extensions/YamlCppConverters.hpp @@ -9,6 +9,13 @@ #include "Base/UUID.hpp" #include "Math/AABB.hpp" #include "Math/Pose.hpp" +#include "Math/DenseVector3i.hpp" +#include "Math/Int24.hpp" +#include "Math/Range.hpp" +#include "Math/RGB10A2.hpp" +#include "Math/RGB565.hpp" +#include "Math/RGBA5551.hpp" +#include "Math/Timestamp.hpp" #include #include #include @@ -246,4 +253,159 @@ namespace YAML return false; } }; -} + + template + struct convert> + { + static Node encode(const OpenVulkano::Math::DenseVector3i& v) + { + return Node(fmt::format("({},{},{})", v.X(), v.Y(), v.Z())); + } + + static bool decode(const Node& node, OpenVulkano::Math::DenseVector3i& v) + { + if (node.IsScalar()) + { + int x, y, z; + size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{},{})", x, y, z); + v = OpenVulkano::Math::DenseVector3i(x, y, z); + return ret != c4::csubstr::npos; + } + return false; + } + }; + + template<> + struct convert + { + static Node encode(const OpenVulkano::int24& v) + { + return Node(fmt::format("{}", static_cast(v))); + } + + static bool decode(const Node& node, OpenVulkano::int24& v) + { + if (node.IsScalar()) + { + int value; + size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "{}", value); + v = value; + return ret != c4::csubstr::npos; + } + return false; + } + }; + + template + struct convert> + { + static Node encode(const OpenVulkano::Math::Range& r) + { + return Node(fmt::format("[{},{}]", r.GetMin(), r.GetMax())); + } + + static bool decode(const Node& node, OpenVulkano::Math::Range& r) + { + if (node.IsScalar()) + { + T minVal, maxVal; + size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "[{},{}]", minVal, maxVal); + r = OpenVulkano::Math::Range(minVal, maxVal); + return ret != c4::csubstr::npos; + } + return false; + } + }; + + template + struct convert> + { + static Node encode(const OpenVulkano::Math::RGB10A2& c) + { + return Node(fmt::format("[{},{},{},{}]", c.r, c.g, c.b, c.a)); + } + + static bool decode(const Node& node, OpenVulkano::Math::RGB10A2& c) + { + if (node.IsScalar()) + { + T r, g, b, a; + size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "[{},{},{},{}]", r, g, b, a); + c.r = r; + c.g = g; + c.b = b; + c.a = a; + return ret != c4::csubstr::npos; + } + return false; + } + }; + + template<> + struct convert + { + static Node encode(const OpenVulkano::Math::RGB565& c) + { + return Node(fmt::format("[{},{},{}]", c.r, c.g, c.b)); + } + + static bool decode(const Node& node, OpenVulkano::Math::RGB565& c) + { + if (node.IsScalar()) + { + int r, g, b; + size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "[{},{},{}]", r, g, b); + c.r = r; + c.g = g; + c.b = b; + return ret != c4::csubstr::npos; + } + return false; + } + }; + + template<> + struct convert + { + static Node encode(const OpenVulkano::Math::RGBA5551& c) + { + return Node(fmt::format("[{},{},{},{}]", c.r, c.g, c.b, c.a)); + } + + static bool decode(const Node& node, OpenVulkano::Math::RGBA5551& c) + { + if (node.IsScalar()) + { + int r, g, b, a; + size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "[{},{},{},{}]", r, g, b, a); + c.r = r; + c.g = g; + c.b = b; + c.a = a; + return ret != c4::csubstr::npos; + } + return false; + } + }; + + template<> + struct convert + { + static Node encode(const OpenVulkano::Math::Timestamp& ts) + { + return Node(fmt::format("{}", ts.GetNanos())); + } + + static bool decode(const Node& node, OpenVulkano::Math::Timestamp& ts) + { + if (node.IsScalar()) + { + uint64_t nanos; + size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "{}", nanos); + ts = OpenVulkano::Math::Timestamp(nanos); + return ret != c4::csubstr::npos; + } + return false; + } + }; +} \ No newline at end of file diff --git a/tests/Extensions/YamlCppConverters.cpp b/tests/Extensions/YamlCppConverters.cpp index 5d0b257..dab631f 100644 --- a/tests/Extensions/YamlCppConverters.cpp +++ b/tests/Extensions/YamlCppConverters.cpp @@ -19,9 +19,9 @@ TEST_CASE("UUID encoding and decoding", "[YamlCppConverters]") REQUIRE(node.IsScalar()); REQUIRE(node.as() == uuid.string()); - UUID decoded_uuid; - REQUIRE(YAML::convert::decode(node, decoded_uuid)); - REQUIRE(decoded_uuid == uuid); + UUID decodedUuid; + REQUIRE(YAML::convert::decode(node, decodedUuid)); + REQUIRE(decodedUuid == uuid); } TEST_CASE("AABB encoding and decoding", "[YamlCppConverters]") @@ -30,10 +30,10 @@ TEST_CASE("AABB encoding and decoding", "[YamlCppConverters]") YAML::Node node = YAML::convert::encode(bbox); REQUIRE(node.IsScalar()); - Math::AABB decoded_bbox; - REQUIRE(YAML::convert::decode(node, decoded_bbox)); - REQUIRE(decoded_bbox.min == bbox.min); - REQUIRE(decoded_bbox.max == bbox.max); + Math::AABB decodedBbox; + REQUIRE(YAML::convert::decode(node, decodedBbox)); + REQUIRE(decodedBbox.min == bbox.min); + REQUIRE(decodedBbox.max == bbox.max); } TEST_CASE("PoseF encoding and decoding", "[YamlCppConverters]") @@ -44,10 +44,10 @@ TEST_CASE("PoseF encoding and decoding", "[YamlCppConverters]") YAML::Node node = YAML::convert::encode(pose); REQUIRE(node.IsScalar()); - Math::PoseF decoded_pose; - REQUIRE(YAML::convert::decode(node, decoded_pose)); - REQUIRE(decoded_pose.GetPosition() == pose.GetPosition()); - REQUIRE(decoded_pose.GetOrientation() == pose.GetOrientation()); + Math::PoseF decodedPose; + REQUIRE(YAML::convert::decode(node, decodedPose)); + REQUIRE(decodedPose.GetPosition() == pose.GetPosition()); + REQUIRE(decodedPose.GetOrientation() == pose.GetOrientation()); } TEST_CASE("Vector2 encoding and decoding", "[YamlCppConverters]") @@ -56,9 +56,9 @@ TEST_CASE("Vector2 encoding and decoding", "[YamlCppConverters]") YAML::Node node = YAML::convert>::encode(vec); REQUIRE(node.IsScalar()); - Math::Vector2 decoded_vec; - REQUIRE(YAML::convert>::decode(node, decoded_vec)); - REQUIRE(decoded_vec == vec); + Math::Vector2 decodedVec; + REQUIRE(YAML::convert>::decode(node, decodedVec)); + REQUIRE(decodedVec == vec); } TEST_CASE("Vector3 encoding and decoding", "[YamlCppConverters]") @@ -67,9 +67,9 @@ TEST_CASE("Vector3 encoding and decoding", "[YamlCppConverters]") YAML::Node node = YAML::convert>::encode(vec); REQUIRE(node.IsScalar()); - Math::Vector3 decoded_vec; - REQUIRE(YAML::convert>::decode(node, decoded_vec)); - REQUIRE(decoded_vec == vec); + Math::Vector3 decodedVec; + REQUIRE(YAML::convert>::decode(node, decodedVec)); + REQUIRE(decodedVec == vec); } TEST_CASE("Vector4 encoding and decoding", "[YamlCppConverters]") @@ -78,9 +78,9 @@ TEST_CASE("Vector4 encoding and decoding", "[YamlCppConverters]") YAML::Node node = YAML::convert>::encode(vec); REQUIRE(node.IsScalar()); - Math::Vector4 decoded_vec; - REQUIRE(YAML::convert>::decode(node, decoded_vec)); - REQUIRE(decoded_vec == vec); + Math::Vector4 decodedVec; + REQUIRE(YAML::convert>::decode(node, decodedVec)); + REQUIRE(decodedVec == vec); } TEST_CASE("Matrix3 encoding and decoding", "[YamlCppConverters]") @@ -89,9 +89,9 @@ TEST_CASE("Matrix3 encoding and decoding", "[YamlCppConverters]") YAML::Node node = YAML::convert>::encode(mat); REQUIRE(node.IsScalar()); - Math::Matrix3 decoded_mat; - REQUIRE(YAML::convert>::decode(node, decoded_mat)); - REQUIRE(decoded_mat == mat); + Math::Matrix3 decodedMat; + REQUIRE(YAML::convert>::decode(node, decodedMat)); + REQUIRE(decodedMat == mat); } TEST_CASE("Matrix4 encoding and decoding", "[YamlCppConverters]") @@ -103,9 +103,9 @@ TEST_CASE("Matrix4 encoding and decoding", "[YamlCppConverters]") YAML::Node node = YAML::convert>::encode(mat); REQUIRE(node.IsScalar()); - Math::Matrix4 decoded_mat; - REQUIRE(YAML::convert>::decode(node, decoded_mat)); - REQUIRE(decoded_mat == mat); + Math::Matrix4 decodedMat; + REQUIRE(YAML::convert>::decode(node, decodedMat)); + REQUIRE(decodedMat == mat); } TEST_CASE("Vector2_SIMD encoding and decoding", "[YamlCppConverters]") @@ -114,9 +114,9 @@ TEST_CASE("Vector2_SIMD encoding and decoding", "[YamlCppConverters]") YAML::Node node = YAML::convert>::encode(vec); REQUIRE(node.IsScalar()); - Math::Vector2_SIMD decoded_vec; - REQUIRE(YAML::convert>::decode(node, decoded_vec)); - REQUIRE(decoded_vec == vec); + Math::Vector2_SIMD decodedVec; + REQUIRE(YAML::convert>::decode(node, decodedVec)); + REQUIRE(decodedVec == vec); } TEST_CASE("Vector3_SIMD encoding and decoding", "[YamlCppConverters]") @@ -125,9 +125,9 @@ TEST_CASE("Vector3_SIMD encoding and decoding", "[YamlCppConverters]") YAML::Node node = YAML::convert>::encode(vec); REQUIRE(node.IsScalar()); - Math::Vector3_SIMD decoded_vec; - REQUIRE(YAML::convert>::decode(node, decoded_vec)); - REQUIRE(decoded_vec == vec); + Math::Vector3_SIMD decodedVec; + REQUIRE(YAML::convert>::decode(node, decodedVec)); + REQUIRE(decodedVec == vec); } TEST_CASE("Vector4_SIMD encoding and decoding", "[YamlCppConverters]") @@ -136,9 +136,9 @@ TEST_CASE("Vector4_SIMD encoding and decoding", "[YamlCppConverters]") YAML::Node node = YAML::convert>::encode(vec); REQUIRE(node.IsScalar()); - Math::Vector4_SIMD decoded_vec; - REQUIRE(YAML::convert>::decode(node, decoded_vec)); - REQUIRE(decoded_vec == vec); + Math::Vector4_SIMD decodedVec; + REQUIRE(YAML::convert>::decode(node, decodedVec)); + REQUIRE(decodedVec == vec); } TEST_CASE("Matrix3_SIMD encoding and decoding", "[YamlCppConverters]") @@ -147,9 +147,9 @@ TEST_CASE("Matrix3_SIMD encoding and decoding", "[YamlCppConverters]") YAML::Node node = YAML::convert>::encode(mat); REQUIRE(node.IsScalar()); - Math::Matrix3_SIMD decoded_mat; - REQUIRE(YAML::convert>::decode(node, decoded_mat)); - REQUIRE(decoded_mat == mat); + Math::Matrix3_SIMD decodedMat; + REQUIRE(YAML::convert>::decode(node, decodedMat)); + REQUIRE(decodedMat == mat); } TEST_CASE("Matrix4_SIMD encoding and decoding", "[YamlCppConverters]") @@ -161,7 +161,90 @@ TEST_CASE("Matrix4_SIMD encoding and decoding", "[YamlCppConverters]") YAML::Node node = YAML::convert>::encode(mat); REQUIRE(node.IsScalar()); - Math::Matrix4_SIMD decoded_mat; - REQUIRE(YAML::convert>::decode(node, decoded_mat)); - REQUIRE(decoded_mat == mat); + Math::Matrix4_SIMD decodedMat; + REQUIRE(YAML::convert>::decode(node, decodedMat)); + REQUIRE(decodedMat == mat); } + +TEST_CASE("DenseVector3i encoding and decoding", "[YamlCppConverters]") +{ + OpenVulkano::Math::DenseVector3i vec { 1, 2, 3 }; + YAML::Node node = YAML::convert>::encode(vec); + REQUIRE(node.IsScalar()); + + OpenVulkano::Math::DenseVector3i decodedVec(0, 0, 0); + REQUIRE(YAML::convert>::decode(node, decodedVec)); + REQUIRE(decodedVec == vec); +} + +TEST_CASE("int24 encoding and decoding", "[YamlCppConverters]") +{ + OpenVulkano::int24 value(42); + YAML::Node node = YAML::convert::encode(value); + REQUIRE(node.IsScalar()); + + OpenVulkano::int24 decodedValue; + REQUIRE(YAML::convert::decode(node, decodedValue)); + REQUIRE(decodedValue == value); +} + +TEST_CASE("Range encoding and decoding", "[YamlCppConverters]") +{ + OpenVulkano::Math::Range range(10, 20); + YAML::Node node = YAML::convert>::encode(range); + REQUIRE(node.IsScalar()); + + OpenVulkano::Math::Range decodedRange; + REQUIRE(YAML::convert>::decode(node, decodedRange)); + REQUIRE(decodedRange.GetMin() == range.GetMin()); + REQUIRE(decodedRange.GetMax() == range.GetMax()); +} + +TEST_CASE("RGB10A2 encoding and decoding", "[YamlCppConverters]") +{ + OpenVulkano::Math::RGB10A2 color; + color.Set(OpenVulkano::Math::Vector4i(1023, 512, 256, 3)); + + YAML::Node node = YAML::convert>::encode(color); + REQUIRE(node.IsScalar()); + + OpenVulkano::Math::RGB10A2 decodedColor; + REQUIRE(YAML::convert>::decode(node, decodedColor)); + REQUIRE(decodedColor == color); +} + +TEST_CASE("RGB565 encoding and decoding", "[YamlCppConverters]") +{ + OpenVulkano::Math::RGB565 color; + color.Set(OpenVulkano::Math::Vector3i(31, 63, 31)); + + YAML::Node node = YAML::convert::encode(color); + REQUIRE(node.IsScalar()); + + OpenVulkano::Math::RGB565 decodedColor; + REQUIRE(YAML::convert::decode(node, decodedColor)); + REQUIRE(decodedColor == color); +} + +TEST_CASE("RGBA5551 encoding and decoding", "[YamlCppConverters]") +{ + OpenVulkano::Math::RGBA5551 color(OpenVulkano::Math::Vector4i(31, 31, 31, 1)); + + YAML::Node node = YAML::convert::encode(color); + REQUIRE(node.IsScalar()); + + OpenVulkano::Math::RGBA5551 decodedColor; + REQUIRE(YAML::convert::decode(node, decodedColor)); + REQUIRE(decodedColor == color); +} + +TEST_CASE("Timestamp encoding and decoding", "[YamlCppConverters]") +{ + OpenVulkano::Math::Timestamp timestamp(uint64_t(1234567890)); + YAML::Node node = YAML::convert::encode(timestamp); + REQUIRE(node.IsScalar()); + + OpenVulkano::Math::Timestamp decodedTimestamp; + REQUIRE(YAML::convert::decode(node, decodedTimestamp)); + REQUIRE(decodedTimestamp == timestamp); +} \ No newline at end of file