From 34372619173100a7e384313e974d5d9158d62a6e Mon Sep 17 00:00:00 2001 From: Vladyslav Baranovskyi Date: Thu, 31 Oct 2024 19:01:48 +0200 Subject: [PATCH 1/2] RymlConverters update + tests --- openVulkanoCpp/Extensions/RymlConverters.hpp | 16 +- tests/Extensions/RymlConverters.cpp | 174 +++++++++++++++++++ 2 files changed, 188 insertions(+), 2 deletions(-) create mode 100644 tests/Extensions/RymlConverters.cpp diff --git a/openVulkanoCpp/Extensions/RymlConverters.hpp b/openVulkanoCpp/Extensions/RymlConverters.hpp index a22848e..268d9cc 100644 --- a/openVulkanoCpp/Extensions/RymlConverters.hpp +++ b/openVulkanoCpp/Extensions/RymlConverters.hpp @@ -6,6 +6,7 @@ #pragma once +#include "Base/UUID.hpp" #include "Math/Math.hpp" #include "Math/AABB.hpp" #include "Math/Pose.hpp" @@ -56,7 +57,7 @@ namespace c4 template size_t to_chars(ryml::substr buf, const OpenVulkano::Math::Pose& pose) - { return ryml::format(buf, "({},{},{}),({},{},{},{})", pose.m_position.x, pose.m_position.y, pose.m_position.z, pose.m_orientation.x, pose.m_orientation.y, pose.m_orientation.z, pose.m_orientation.w); } + { return ryml::format(buf, "({},{},{}),({},{},{},{})", pose.GetPosition().x, pose.GetPosition().y, pose.GetPosition().z, pose.GetOrientation().x, pose.GetOrientation().y, pose.GetOrientation().z, pose.GetOrientation().w); } template bool from_chars(ryml::csubstr buf, OpenVulkano::Math::Vector2* v) @@ -127,7 +128,18 @@ namespace c4 template bool from_chars(ryml::csubstr buf, OpenVulkano::Math::Pose* pose) { - size_t ret = ryml::unformat(buf, "({},{},{}),({},{},{},{})", pose->m_position.x, pose->m_position.y, pose->m_position.z, pose->m_orientation.x, pose->m_orientation.y, pose->m_orientation.z, pose->m_orientation.w); + size_t ret = ryml::unformat(buf, "({},{},{}),({},{},{},{})", pose->GetPosition().x, pose->GetPosition().y, pose->GetPosition().z, pose->GetOrientation().x, pose->GetOrientation().y, pose->GetOrientation().z, pose->GetOrientation().w); return ret != ryml::yml::npos; } + + inline size_t to_chars(ryml::substr buf, const OpenVulkano::UUID& uuid) + { + return ryml::format(buf, "{}", uuid.string()); + } + + inline bool from_chars(ryml::csubstr buf, OpenVulkano::UUID* uuid) + { + uuid->assign(buf.str); + return true; + } } \ No newline at end of file diff --git a/tests/Extensions/RymlConverters.cpp b/tests/Extensions/RymlConverters.cpp new file mode 100644 index 0000000..7d8ae03 --- /dev/null +++ b/tests/Extensions/RymlConverters.cpp @@ -0,0 +1,174 @@ +/* + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. + */ + +#include + +#include "Extensions/RymlConverters.hpp" + +using namespace OpenVulkano; +using namespace OpenVulkano::Math; +using namespace c4; + +TEST_CASE("Vector2 to_chars and from_chars", "[RymlConverters]") +{ + Vector2 vec2 { 1.1f, 2.2f }; + char buffer[20] = {}; + + size_t written = to_chars(ryml::substr(buffer), vec2); + REQUIRE(written != ryml::yml::npos); + REQUIRE(std::string(buffer) == "(1.1,2.2)"); + + Vector2 parsed_vec2; + REQUIRE(from_chars("(1.1,2.2)", &parsed_vec2)); + REQUIRE(parsed_vec2.x == 1.1f); + REQUIRE(parsed_vec2.y == 2.2f); +} + +TEST_CASE("Vector3 to_chars and from_chars", "[RymlConverters]") +{ + Vector3 vec3 { 1.1f, 2.2f, 3.3f }; + char buffer[30] = {}; + + size_t written = to_chars(ryml::substr(buffer), vec3); + REQUIRE(written != ryml::yml::npos); + REQUIRE(std::string(buffer) == "(1.1,2.2,3.3)"); + + Vector3 parsed_vec3; + REQUIRE(from_chars("(1.1,2.2,3.3)", &parsed_vec3)); + REQUIRE(parsed_vec3.x == 1.1f); + REQUIRE(parsed_vec3.y == 2.2f); + REQUIRE(parsed_vec3.z == 3.3f); +} + +TEST_CASE("Vector4 to_chars and from_chars", "[RymlConverters]") +{ + Vector4 vec4 { 1.1f, 2.2f, 3.3f, 4.4f }; + char buffer[30] = {}; + + size_t written = to_chars(ryml::substr(buffer), vec4); + REQUIRE(written != ryml::yml::npos); + REQUIRE(std::string(buffer) == "(1.1,2.2,3.3,4.4)"); + + Vector4 parsed_vec4; + REQUIRE(from_chars("(1.1,2.2,3.3,4.4)", &parsed_vec4)); + REQUIRE(parsed_vec4.x == 1.1f); + REQUIRE(parsed_vec4.y == 2.2f); + REQUIRE(parsed_vec4.z == 3.3f); + REQUIRE(parsed_vec4.w == 4.4f); +} + +TEST_CASE("Matrix3 to_chars and from_chars", "[RymlConverters]") +{ + Matrix3 mat3 { { 1.1f, 2.2f, 3.3f }, { 4.4f, 5.5f, 6.6f }, { 7.7f, 8.8f, 9.9f } }; + char buffer[100] = {}; + + size_t written = to_chars(ryml::substr(buffer), mat3); + REQUIRE(written != ryml::yml::npos); + REQUIRE(std::string(buffer) == "(1.1,4.4,7.7),(2.2,5.5,8.8),(3.3,6.6,9.9)"); + + Matrix3 parsed_mat3; + REQUIRE(from_chars("(1.1,4.4,7.7),(2.2,5.5,8.8),(3.3,6.6,9.9)", &parsed_mat3)); + REQUIRE(parsed_mat3[0][0] == 1.1f); + REQUIRE(parsed_mat3[0][1] == 2.2f); + REQUIRE(parsed_mat3[0][2] == 3.3f); + REQUIRE(parsed_mat3[1][0] == 4.4f); + REQUIRE(parsed_mat3[1][1] == 5.5f); + REQUIRE(parsed_mat3[1][2] == 6.6f); + REQUIRE(parsed_mat3[2][0] == 7.7f); + REQUIRE(parsed_mat3[2][1] == 8.8f); + REQUIRE(parsed_mat3[2][2] == 9.9f); +} + +TEST_CASE("Matrix4 to_chars and from_chars", "[RymlConverters]") +{ + Matrix4 mat4 { { 1.1f, 2.2f, 3.3f, 4.4f }, + { 5.5f, 6.6f, 7.7f, 8.8f }, + { 9.9f, 10.10f, 11.11f, 12.12f }, + { 13.13f, 14.14f, 15.15f, 16.16f } }; + char buffer[200] = {}; + + size_t written = to_chars(ryml::substr(buffer), mat4); + REQUIRE(written != ryml::yml::npos); + REQUIRE(std::string(buffer) == "(1.1,5.5,9.9,13.13),(2.2,6.6,10.1,14.14),(3.3,7.7,11.11,15.15),(4.4,8.8,12.12,16.16)"); + + Matrix4 parsed_mat4; + REQUIRE(from_chars("(1.1,5.5,9.9,13.13),(2.2,6.6,10.1,14.14),(3.3,7.7,11.11,15.15),(4.4,8.8,12.12,16.16)", &parsed_mat4)); + + REQUIRE(parsed_mat4[0][0] == 1.1f); + REQUIRE(parsed_mat4[0][1] == 2.2f); + REQUIRE(parsed_mat4[0][2] == 3.3f); + REQUIRE(parsed_mat4[0][3] == 4.4f); + + REQUIRE(parsed_mat4[1][0] == 5.5f); + REQUIRE(parsed_mat4[1][1] == 6.6f); + REQUIRE(parsed_mat4[1][2] == 7.7f); + REQUIRE(parsed_mat4[1][3] == 8.8f); + + REQUIRE(parsed_mat4[2][0] == 9.9f); + REQUIRE(parsed_mat4[2][1] == 10.10f); + REQUIRE(parsed_mat4[2][2] == 11.11f); + REQUIRE(parsed_mat4[2][3] == 12.12f); + + REQUIRE(parsed_mat4[3][0] == 13.13f); + REQUIRE(parsed_mat4[3][1] == 14.14f); + REQUIRE(parsed_mat4[3][2] == 15.15f); + REQUIRE(parsed_mat4[3][3] == 16.16f); +} + +TEST_CASE("AABB to_chars and from_chars", "[RymlConverters]") +{ + AABB bbox { Vector3 { 1.0f, 2.0f, 3.0f }, Vector3 { 4.0f, 5.0f, 6.0f } }; + char buffer[50] = {}; + + size_t written = to_chars(ryml::substr(buffer), bbox); + REQUIRE(written != ryml::yml::npos); + REQUIRE(std::string(buffer) == "(1,2,3),(4,5,6)"); + + AABB parsed_bbox; + REQUIRE(from_chars("(1,2,3),(4,5,6)", &parsed_bbox)); + REQUIRE(parsed_bbox.min.x == 1.0f); + REQUIRE(parsed_bbox.min.y == 2.0f); + REQUIRE(parsed_bbox.min.z == 3.0f); + REQUIRE(parsed_bbox.max.x == 4.0f); + REQUIRE(parsed_bbox.max.y == 5.0f); + REQUIRE(parsed_bbox.max.z == 6.0f); +} + +TEST_CASE("Pose to_chars and from_chars", "[RymlConverters]") +{ + Pose pose; + pose.SetPosition(Vector3 { 1.1f, 2.2f, 3.3f }); + pose.SetOrientation(QuaternionF(7.7f, 4.4f, 5.5f, 6.6f)); + char buffer[70] = {}; + + size_t written = to_chars(ryml::substr(buffer), pose); + REQUIRE(written != ryml::yml::npos); + REQUIRE(std::string(buffer) == "(1.1,2.2,3.3),(4.4,5.5,6.6,7.7)"); + + Pose parsed_pose; + REQUIRE(from_chars("(1.1,2.2,3.3),(4.4,5.5,6.6,7.7)", &parsed_pose)); + REQUIRE(parsed_pose.GetPosition().x == 1.1f); + REQUIRE(parsed_pose.GetPosition().y == 2.2f); + REQUIRE(parsed_pose.GetPosition().z == 3.3f); + REQUIRE(parsed_pose.GetOrientation().x == 4.4f); + REQUIRE(parsed_pose.GetOrientation().y == 5.5f); + REQUIRE(parsed_pose.GetOrientation().z == 6.6f); + REQUIRE(parsed_pose.GetOrientation().w == 7.7f); +} + +TEST_CASE("UUID to_chars and from_chars", "[RymlConverters]") +{ + UUID uuid("123e4567-e89b-12d3-a456-426655440000"); + char buffer[40] = {}; + + size_t written = to_chars(ryml::substr(buffer), uuid); + REQUIRE(written != ryml::yml::npos); + REQUIRE(std::string(buffer) == "123e4567-e89b-12d3-a456-426655440000"); + + UUID parsed_uuid; + REQUIRE(from_chars("123e4567-e89b-12d3-a456-426655440000", &parsed_uuid)); + REQUIRE(parsed_uuid.string() == uuid.string()); +} From 583cbaccfff28125f3e166130db5fb17b1ae4fea Mon Sep 17 00:00:00 2001 From: Vladyslav Baranovskyi Date: Thu, 31 Oct 2024 19:02:29 +0200 Subject: [PATCH 2/2] YamlCppConverters update + tests --- .../Extensions/YamlCppConverters.hpp | 175 ++++++++++++++++++ tests/Extensions/YamlCppConverters.cpp | 167 +++++++++++++++++ 2 files changed, 342 insertions(+) create mode 100644 tests/Extensions/YamlCppConverters.cpp diff --git a/openVulkanoCpp/Extensions/YamlCppConverters.hpp b/openVulkanoCpp/Extensions/YamlCppConverters.hpp index ce9e52b..0286a12 100644 --- a/openVulkanoCpp/Extensions/YamlCppConverters.hpp +++ b/openVulkanoCpp/Extensions/YamlCppConverters.hpp @@ -71,4 +71,179 @@ namespace YAML return false; } }; + + template + struct convert> + { + static Node encode(const OpenVulkano::Math::Vector2& v) + { + return Node(fmt::format("({},{})", v.x, v.y)); + } + + static bool decode(const Node& node, OpenVulkano::Math::Vector2& v) + { + if (node.IsScalar()) + { + size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{})", v.x, v.y); + return ret != c4::csubstr::npos; + } + return false; + } + }; + + template + struct convert> + { + static Node encode(const OpenVulkano::Math::Vector3& v) + { + return Node(fmt::format("({},{},{})", v.x, v.y, v.z)); + } + + static bool decode(const Node& node, OpenVulkano::Math::Vector3& v) + { + if (node.IsScalar()) + { + size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{},{})", v.x, v.y, v.z); + return ret != c4::csubstr::npos; + } + return false; + } + }; + + template + struct convert> + { + static Node encode(const OpenVulkano::Math::Vector4& v) + { + return Node(fmt::format("({},{},{},{})", v.x, v.y, v.z, v.w)); + } + + static bool decode(const Node& node, OpenVulkano::Math::Vector4& v) + { + if (node.IsScalar()) + { + size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{},{},{})", v.x, v.y, v.z, v.w); + return ret != c4::csubstr::npos; + } + return false; + } + }; + + template + struct convert> + { + static Node encode(const OpenVulkano::Math::Vector2_SIMD& v) + { + return Node(fmt::format("({},{})", v.x, v.y)); + } + + static bool decode(const Node& node, OpenVulkano::Math::Vector2_SIMD& v) + { + if (node.IsScalar()) + { + size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{})", v.x, v.y); + return ret != c4::csubstr::npos; + } + return false; + } + }; + + template + struct convert> + { + static Node encode(const OpenVulkano::Math::Vector3_SIMD& v) + { + return Node(fmt::format("({},{},{})", v.x, v.y, v.z)); + } + + static bool decode(const Node& node, OpenVulkano::Math::Vector3_SIMD& v) + { + if (node.IsScalar()) + { + size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{},{})", v.x, v.y, v.z); + return ret != c4::csubstr::npos; + } + return false; + } + }; + + template + struct convert> + { + static Node encode(const OpenVulkano::Math::Matrix3& mat) + { + return Node(fmt::format("(({},{},{}),({},{},{}),({},{},{}))", + mat[0][0], mat[0][1], mat[0][2], + mat[1][0], mat[1][1], mat[1][2], + mat[2][0], mat[2][1], mat[2][2])); + } + + static bool decode(const Node& node, OpenVulkano::Math::Matrix3& mat) + { + if (node.IsScalar()) + { + size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), + "(({},{},{}),({},{},{}),({},{},{}))", + mat[0][0], mat[0][1], mat[0][2], + mat[1][0], mat[1][1], mat[1][2], + mat[2][0], mat[2][1], mat[2][2]); + return ret != c4::csubstr::npos; + } + return false; + } + }; + + template + struct convert> + { + static Node encode(const OpenVulkano::Math::Matrix3_SIMD& mat) + { + return Node(fmt::format("(({},{},{}),({},{},{}),({},{},{}))", + mat[0][0], mat[0][1], mat[0][2], + mat[1][0], mat[1][1], mat[1][2], + mat[2][0], mat[2][1], mat[2][2])); + } + + static bool decode(const Node& node, OpenVulkano::Math::Matrix3_SIMD& mat) + { + if (node.IsScalar()) + { + size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), + "(({},{},{}),({},{},{}),({},{},{}))", + mat[0][0], mat[0][1], mat[0][2], + mat[1][0], mat[1][1], mat[1][2], + mat[2][0], mat[2][1], mat[2][2]); + return ret != c4::csubstr::npos; + } + return false; + } + }; + + template + struct convert> + { + static Node encode(const OpenVulkano::Math::Matrix4& mat) + { + return Node(fmt::format("(({},{},{},{}),({},{},{},{}),({},{},{},{}),({},{},{},{}))", + mat[0][0], mat[0][1], mat[0][2], mat[0][3], + mat[1][0], mat[1][1], mat[1][2], mat[1][3], + mat[2][0], mat[2][1], mat[2][2], mat[2][3], + mat[3][0], mat[3][1], mat[3][2], mat[3][3])); + } + + static bool decode(const Node& node, OpenVulkano::Math::Matrix4& mat) + { + if (node.IsScalar()) + { + size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), + "(({},{},{},{}),({},{},{},{}),({},{},{},{}),({},{},{},{}))", + mat[0][0], mat[0][1], mat[0][2], mat[0][3], + mat[1][0], mat[1][1], mat[1][2], mat[1][3], + mat[2][0], mat[2][1], mat[2][2], mat[2][3], + mat[3][0], mat[3][1], mat[3][2], mat[3][3]); + return ret != c4::csubstr::npos; + } + return false; + } + }; } diff --git a/tests/Extensions/YamlCppConverters.cpp b/tests/Extensions/YamlCppConverters.cpp new file mode 100644 index 0000000..5d0b257 --- /dev/null +++ b/tests/Extensions/YamlCppConverters.cpp @@ -0,0 +1,167 @@ +/* + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. + */ + +#include + +#include "Extensions/YamlCppConverters.hpp" +#include "Math/Math.hpp" + +using namespace OpenVulkano; +using namespace OpenVulkano::Math; + +TEST_CASE("UUID encoding and decoding", "[YamlCppConverters]") +{ + UUID uuid("123e4567-e89b-12d3-a456-426614174000"); + YAML::Node node = YAML::convert::encode(uuid); + REQUIRE(node.IsScalar()); + REQUIRE(node.as() == uuid.string()); + + UUID decoded_uuid; + REQUIRE(YAML::convert::decode(node, decoded_uuid)); + REQUIRE(decoded_uuid == uuid); +} + +TEST_CASE("AABB encoding and decoding", "[YamlCppConverters]") +{ + Math::AABB bbox { { 1.0f, 2.0f, 3.0f }, { 4.0f, 5.0f, 6.0f } }; + 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); +} + +TEST_CASE("PoseF encoding and decoding", "[YamlCppConverters]") +{ + Math::PoseF pose; + pose.SetPosition({1.0f, 2.0f, 3.0f}); + pose.SetOrientation({1.0f, 2.0f, 3.0f, 1.0f}); + 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()); +} + +TEST_CASE("Vector2 encoding and decoding", "[YamlCppConverters]") +{ + Math::Vector2 vec { 1.0f, 2.0f }; + 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); +} + +TEST_CASE("Vector3 encoding and decoding", "[YamlCppConverters]") +{ + Math::Vector3 vec { 1.0f, 2.0f, 3.0f }; + 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); +} + +TEST_CASE("Vector4 encoding and decoding", "[YamlCppConverters]") +{ + Math::Vector4 vec { 1.0f, 2.0f, 3.0f, 4.0f }; + 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); +} + +TEST_CASE("Matrix3 encoding and decoding", "[YamlCppConverters]") +{ + Math::Matrix3 mat { { 1.0f, 2.0f, 3.0f }, { 4.0f, 5.0f, 6.0f }, { 7.0f, 8.0f, 9.0f } }; + 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); +} + +TEST_CASE("Matrix4 encoding and decoding", "[YamlCppConverters]") +{ + Math::Matrix4 mat { { 1.0f, 2.0f, 3.0f, 4.0f }, + { 5.0f, 6.0f, 7.0f, 8.0f }, + { 9.0f, 10.0f, 11.0f, 12.0f }, + { 13.0f, 14.0f, 15.0f, 16.0f } }; + 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); +} + +TEST_CASE("Vector2_SIMD encoding and decoding", "[YamlCppConverters]") +{ + Math::Vector2_SIMD vec { 1.0f, 2.0f }; + 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); +} + +TEST_CASE("Vector3_SIMD encoding and decoding", "[YamlCppConverters]") +{ + Math::Vector3_SIMD vec { 1.0f, 2.0f, 3.0f }; + 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); +} + +TEST_CASE("Vector4_SIMD encoding and decoding", "[YamlCppConverters]") +{ + Math::Vector4_SIMD vec { 1.0f, 2.0f, 3.0f, 4.0f }; + 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); +} + +TEST_CASE("Matrix3_SIMD encoding and decoding", "[YamlCppConverters]") +{ + Math::Matrix3_SIMD mat { { 1.0f, 2.0f, 3.0f }, { 4.0f, 5.0f, 6.0f }, { 7.0f, 8.0f, 9.0f } }; + 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); +} + +TEST_CASE("Matrix4_SIMD encoding and decoding", "[YamlCppConverters]") +{ + Math::Matrix4_SIMD mat { { 1.0f, 2.0f, 3.0f, 4.0f }, + { 5.0f, 6.0f, 7.0f, 8.0f }, + { 9.0f, 10.0f, 11.0f, 12.0f }, + { 13.0f, 14.0f, 15.0f, 16.0f } }; + 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); +}