411 lines
11 KiB
C++
411 lines
11 KiB
C++
/*
|
|
* 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/.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#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 <yaml-cpp/yaml.h>
|
|
#include <fmt/format.h>
|
|
#include <c4/format.hpp>
|
|
|
|
namespace YAML
|
|
{
|
|
template<>
|
|
struct convert<OpenVulkano::UUID>
|
|
{
|
|
static Node encode(const OpenVulkano::UUID& uuid)
|
|
{
|
|
return Node(uuid.string());
|
|
}
|
|
|
|
static bool decode(const Node& node, OpenVulkano::UUID& uuid)
|
|
{
|
|
if (node.IsScalar())
|
|
{
|
|
uuid.assign(node.Scalar());
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct convert<OpenVulkano::Math::AABB>
|
|
{
|
|
static Node encode(const OpenVulkano::Math::AABB& bbox)
|
|
{
|
|
return Node(fmt::format("({},{},{}),({},{},{})", bbox.min.x, bbox.min.y, bbox.min.z, bbox.max.x, bbox.max.y, bbox.max.z));
|
|
}
|
|
|
|
static bool decode(const Node& node, OpenVulkano::Math::AABB& bbox)
|
|
{
|
|
if (node.IsScalar())
|
|
{
|
|
size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{},{}),({},{},{})", bbox.min.x, bbox.min.y, bbox.min.z, bbox.max.x, bbox.max.y, bbox.max.z);
|
|
return ret != c4::csubstr::npos;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct convert<OpenVulkano::Math::PoseF>
|
|
{
|
|
static Node encode(const OpenVulkano::Math::PoseF& pose)
|
|
{
|
|
return Node(fmt::format("({},{},{}),({},{},{},{})", pose.GetPosition().x, pose.GetPosition().y, pose.GetPosition().z, pose.GetOrientation().x, pose.GetOrientation().y, pose.GetOrientation().z, pose.GetOrientation().w));
|
|
}
|
|
|
|
static bool decode(const Node& node, OpenVulkano::Math::PoseF& pose)
|
|
{
|
|
if (node.IsScalar())
|
|
{
|
|
size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{},{}),({},{},{},{})", pose.GetPosition().x, pose.GetPosition().y, pose.GetPosition().z, pose.GetOrientation().x, pose.GetOrientation().y, pose.GetOrientation().z, pose.GetOrientation().w);
|
|
return ret != c4::csubstr::npos;
|
|
}
|
|
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;
|
|
}
|
|
};
|
|
|
|
template<typename T, bool REDUCE_Y_RESOLUTION, bool ASSERT_INPUT_VALUES, int BITS_PER_COMPONENT>
|
|
struct convert<OpenVulkano::Math::DenseVector3i<T, REDUCE_Y_RESOLUTION, ASSERT_INPUT_VALUES, BITS_PER_COMPONENT>>
|
|
{
|
|
static Node encode(const OpenVulkano::Math::DenseVector3i<T, REDUCE_Y_RESOLUTION, ASSERT_INPUT_VALUES, BITS_PER_COMPONENT>& v)
|
|
{
|
|
return Node(fmt::format("({},{},{})", v.X(), v.Y(), v.Z()));
|
|
}
|
|
|
|
static bool decode(const Node& node, OpenVulkano::Math::DenseVector3i<T, REDUCE_Y_RESOLUTION, ASSERT_INPUT_VALUES, BITS_PER_COMPONENT>& 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<T, REDUCE_Y_RESOLUTION, ASSERT_INPUT_VALUES, BITS_PER_COMPONENT>(x, y, z);
|
|
return ret != c4::csubstr::npos;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct convert<OpenVulkano::int24>
|
|
{
|
|
static Node encode(const OpenVulkano::int24& v)
|
|
{
|
|
return Node(fmt::format("{}", static_cast<int>(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<typename T>
|
|
struct convert<OpenVulkano::Math::Range<T>>
|
|
{
|
|
static Node encode(const OpenVulkano::Math::Range<T>& r)
|
|
{
|
|
return Node(fmt::format("[{},{}]", r.GetMin(), r.GetMax()));
|
|
}
|
|
|
|
static bool decode(const Node& node, OpenVulkano::Math::Range<T>& 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<T>(minVal, maxVal);
|
|
return ret != c4::csubstr::npos;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
struct convert<OpenVulkano::Math::RGB10A2<T>>
|
|
{
|
|
static Node encode(const OpenVulkano::Math::RGB10A2<T>& c)
|
|
{
|
|
return Node(fmt::format("[{},{},{},{}]", c.r, c.g, c.b, c.a));
|
|
}
|
|
|
|
static bool decode(const Node& node, OpenVulkano::Math::RGB10A2<T>& 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<OpenVulkano::Math::RGB565>
|
|
{
|
|
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<OpenVulkano::Math::RGBA5551>
|
|
{
|
|
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<OpenVulkano::Math::Timestamp>
|
|
{
|
|
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;
|
|
}
|
|
};
|
|
} |