GeorgH93/OpenVulkano
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

YamlCppConverters update + tests

Browse Source
This commit is contained in:
Vladyslav Baranovskyi
2024-10-31 19:02:29 +02:00
parent 3437261917
commit 583cbaccff
2 changed files with 342 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

175
openVulkanoCpp/Extensions/YamlCppConverters.hpp
View File

@@ -71,4 +71,179 @@ namespace YAML
return false; return false;
} }
}; };
template<typename T>
struct convert<OpenVulkano::Math::Vector2<T>>
{
static Node encode(const OpenVulkano::Math::Vector2<T>& v)
{
return Node(fmt::format("({},{})", v.x, v.y));
}
static bool decode(const Node& node, OpenVulkano::Math::Vector2<T>& 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<typename T>
struct convert<OpenVulkano::Math::Vector3<T>>
{
static Node encode(const OpenVulkano::Math::Vector3<T>& v)
{
return Node(fmt::format("({},{},{})", v.x, v.y, v.z));
}
static bool decode(const Node& node, OpenVulkano::Math::Vector3<T>& 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<typename T>
struct convert<OpenVulkano::Math::Vector4<T>>
{
static Node encode(const OpenVulkano::Math::Vector4<T>& v)
{
return Node(fmt::format("({},{},{},{})", v.x, v.y, v.z, v.w));
}
static bool decode(const Node& node, OpenVulkano::Math::Vector4<T>& 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<typename T>
struct convert<OpenVulkano::Math::Vector2_SIMD<T>>
{
static Node encode(const OpenVulkano::Math::Vector2_SIMD<T>& v)
{
return Node(fmt::format("({},{})", v.x, v.y));
}
static bool decode(const Node& node, OpenVulkano::Math::Vector2_SIMD<T>& 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<typename T>
struct convert<OpenVulkano::Math::Vector3_SIMD<T>>
{
static Node encode(const OpenVulkano::Math::Vector3_SIMD<T>& v)
{
return Node(fmt::format("({},{},{})", v.x, v.y, v.z));
}
static bool decode(const Node& node, OpenVulkano::Math::Vector3_SIMD<T>& 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<typename T>
struct convert<OpenVulkano::Math::Matrix3<T>>
{
static Node encode(const OpenVulkano::Math::Matrix3<T>& 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<T>& 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<typename T>
struct convert<OpenVulkano::Math::Matrix3_SIMD<T>>
{
static Node encode(const OpenVulkano::Math::Matrix3_SIMD<T>& 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<T>& 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<typename T>
struct convert<OpenVulkano::Math::Matrix4<T>>
{
static Node encode(const OpenVulkano::Math::Matrix4<T>& 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<T>& 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;
}
};
} }

167
tests/Extensions/YamlCppConverters.cpp Normal file
View File

@@ -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 <catch2/catch_all.hpp>
#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<UUID>::encode(uuid);
REQUIRE(node.IsScalar());
REQUIRE(node.as<std::string>() == uuid.string());
UUID decoded_uuid;
REQUIRE(YAML::convert<UUID>::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<Math::AABB>::encode(bbox);
REQUIRE(node.IsScalar());
Math::AABB decoded_bbox;
REQUIRE(YAML::convert<Math::AABB>::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<Math::PoseF>::encode(pose);
REQUIRE(node.IsScalar());
Math::PoseF decoded_pose;
REQUIRE(YAML::convert<Math::PoseF>::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<float> vec { 1.0f, 2.0f };
YAML::Node node = YAML::convert<Math::Vector2<float>>::encode(vec);
REQUIRE(node.IsScalar());
Math::Vector2<float> decoded_vec;
REQUIRE(YAML::convert<Math::Vector2<float>>::decode(node, decoded_vec));
REQUIRE(decoded_vec == vec);
}
TEST_CASE("Vector3 encoding and decoding", "[YamlCppConverters]")
{
Math::Vector3<float> vec { 1.0f, 2.0f, 3.0f };
YAML::Node node = YAML::convert<Math::Vector3<float>>::encode(vec);
REQUIRE(node.IsScalar());
Math::Vector3<float> decoded_vec;
REQUIRE(YAML::convert<Math::Vector3<float>>::decode(node, decoded_vec));
REQUIRE(decoded_vec == vec);
}
TEST_CASE("Vector4 encoding and decoding", "[YamlCppConverters]")
{
Math::Vector4<float> vec { 1.0f, 2.0f, 3.0f, 4.0f };
YAML::Node node = YAML::convert<Math::Vector4<float>>::encode(vec);
REQUIRE(node.IsScalar());
Math::Vector4<float> decoded_vec;
REQUIRE(YAML::convert<Math::Vector4<float>>::decode(node, decoded_vec));
REQUIRE(decoded_vec == vec);
}
TEST_CASE("Matrix3 encoding and decoding", "[YamlCppConverters]")
{
Math::Matrix3<float> mat { { 1.0f, 2.0f, 3.0f }, { 4.0f, 5.0f, 6.0f }, { 7.0f, 8.0f, 9.0f } };
YAML::Node node = YAML::convert<Math::Matrix3<float>>::encode(mat);
REQUIRE(node.IsScalar());
Math::Matrix3<float> decoded_mat;
REQUIRE(YAML::convert<Math::Matrix3<float>>::decode(node, decoded_mat));
REQUIRE(decoded_mat == mat);
}
TEST_CASE("Matrix4 encoding and decoding", "[YamlCppConverters]")
{
Math::Matrix4<float> 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<Math::Matrix4<float>>::encode(mat);
REQUIRE(node.IsScalar());
Math::Matrix4<float> decoded_mat;
REQUIRE(YAML::convert<Math::Matrix4<float>>::decode(node, decoded_mat));
REQUIRE(decoded_mat == mat);
}
TEST_CASE("Vector2_SIMD encoding and decoding", "[YamlCppConverters]")
{
Math::Vector2_SIMD<float> vec { 1.0f, 2.0f };
YAML::Node node = YAML::convert<Math::Vector2_SIMD<float>>::encode(vec);
REQUIRE(node.IsScalar());
Math::Vector2_SIMD<float> decoded_vec;
REQUIRE(YAML::convert<Math::Vector2_SIMD<float>>::decode(node, decoded_vec));
REQUIRE(decoded_vec == vec);
}
TEST_CASE("Vector3_SIMD encoding and decoding", "[YamlCppConverters]")
{
Math::Vector3_SIMD<float> vec { 1.0f, 2.0f, 3.0f };
YAML::Node node = YAML::convert<Math::Vector3_SIMD<float>>::encode(vec);
REQUIRE(node.IsScalar());
Math::Vector3_SIMD<float> decoded_vec;
REQUIRE(YAML::convert<Math::Vector3_SIMD<float>>::decode(node, decoded_vec));
REQUIRE(decoded_vec == vec);
}
TEST_CASE("Vector4_SIMD encoding and decoding", "[YamlCppConverters]")
{
Math::Vector4_SIMD<float> vec { 1.0f, 2.0f, 3.0f, 4.0f };
YAML::Node node = YAML::convert<Math::Vector4_SIMD<float>>::encode(vec);
REQUIRE(node.IsScalar());
Math::Vector4_SIMD<float> decoded_vec;
REQUIRE(YAML::convert<Math::Vector4_SIMD<float>>::decode(node, decoded_vec));
REQUIRE(decoded_vec == vec);
}
TEST_CASE("Matrix3_SIMD encoding and decoding", "[YamlCppConverters]")
{
Math::Matrix3_SIMD<float> mat { { 1.0f, 2.0f, 3.0f }, { 4.0f, 5.0f, 6.0f }, { 7.0f, 8.0f, 9.0f } };
YAML::Node node = YAML::convert<Math::Matrix3_SIMD<float>>::encode(mat);
REQUIRE(node.IsScalar());
Math::Matrix3_SIMD<float> decoded_mat;
REQUIRE(YAML::convert<Math::Matrix3_SIMD<float>>::decode(node, decoded_mat));
REQUIRE(decoded_mat == mat);
}
TEST_CASE("Matrix4_SIMD encoding and decoding", "[YamlCppConverters]")
{
Math::Matrix4_SIMD<float> 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<Math::Matrix4_SIMD<float>>::encode(mat);
REQUIRE(node.IsScalar());
Math::Matrix4_SIMD<float> decoded_mat;
REQUIRE(YAML::convert<Math::Matrix4_SIMD<float>>::decode(node, decoded_mat));
REQUIRE(decoded_mat == mat);
}