diff -r 1a4342d80de7 -r 654661eab7f3 src/basics.h
--- a/src/basics.h	Wed Jun 08 20:41:21 2022 +0300
+++ b/src/basics.h	Wed Jun 08 22:29:44 2022 +0300
@@ -18,13 +18,13 @@
 
 #pragma once
 #include <algorithm>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
 #include <cmath>
+#include <compare>
+#include <memory>
 #include <optional>
 #include <type_traits>
-#include <QMatrix4x4>
+#include <QDataStream>
+#include <QDebug>
 #include <QObject>
 #include <QPointF>
 #include <QSet>
@@ -32,64 +32,24 @@
 #include <QStringList>
 #include <QVariant>
 #include <QVector>
-#include <QVector3D>
 #include <glm/glm.hpp>
-
-using GLRotationMatrix = QMatrix4x4;
-
-enum Axis
-{
-	X = 0,
-	Y = 1,
-	Z = 2
-};
+#include "geometry.h"
+#include "functional.h"
 
-enum Result
-{
-	Success = 0,
-	PartialSuccess,
-	Failure
-};
-
-constexpr bool failed(Result r)
-{
-	return r == Failure;
-}
+template<typename T>
+using opt = std::optional<T>;
 
-enum Winding
-{
-	NoWinding,
-	Anticlockwise,
-	Clockwise,
-};
+Q_DECLARE_METATYPE(glm::vec3)
+Q_DECLARE_METATYPE(glm::mat4)
 
-/*
- * Special operator definition that implements the XOR operator for windings.
- * However, if either winding is NoWinding, then this function returns NoWinding.
- */
-inline Winding operator^(Winding one, Winding other)
-{
-	if (one == NoWinding or other == NoWinding)
-		return NoWinding;
-	else
-		return static_cast<Winding>(static_cast<int>(one) ^ static_cast<int>(other));
-}
-
-inline Winding& operator^=(Winding& one, Winding other)
-{
-	one = one ^ other;
-	return one;
-}
-
+//! \brief count the amount of elements in a basic array
 template<typename T, int N>
-constexpr int countof(T const (&)[N])
+constexpr int countof(T(&)[N])
 {
 	return N;
 }
 
-/**
- * @brief casts @c x to a suitable unsigned integer
- */
+//! \brief casts @c x to a suitable unsigned integer
 template<typename T>
 constexpr auto unsigned_cast(T x)
 	-> std::enable_if_t<std::is_integral_v<T>, std::make_unsigned_t<T>>
@@ -97,9 +57,7 @@
 	return static_cast<std::make_unsigned_t<T>>(x);
 }
 
-/**
- * @brief casts @c x to a suitable signed integer
- */
+//! \brief casts @c x to a suitable signed integer
 template<typename T>
 constexpr auto signed_cast(T x)
 	-> std::enable_if_t<std::is_integral_v<T>, std::make_signed_t<T>>
@@ -107,86 +65,42 @@
 	return static_cast<std::make_signed_t<T>>(x);
 }
 
-
-/**
-* @brief casts floating point values to float, converting non-floating point values causes an error
-* @param[in] x floating point value to cast
-* @returns float
-*/
+//! \brief casts floating point values to float
 template<typename T>
-auto toFloat(T x) -> std::enable_if_t<std::is_floating_point_v<T>, float>
+constexpr auto float_cast(T x)
+	-> std::enable_if_t<std::is_floating_point_v<T>, float>
 {
 	return static_cast<float>(x);
 }
 
-/**
-* @brief casts floating point values to double, converting non-floating point values causes an error
-* @param[in] x floating point value to cast
-* @returns double
-*/
+//! \brief casts floating point values to double
 template<typename T>
-auto toDouble(T x) -> std::enable_if_t<std::is_floating_point_v<T>, double>
+constexpr auto double_cast(T x)
+	-> std::enable_if_t<std::is_floating_point_v<T>, double>
 {
 	return static_cast<double>(x);
 }
 
-/**
-* @brief casts floating point values to qreal, converting non-floating point values causes an error
-* @param[in] x floating point value to cast
-* @returns qreal
-*/
+//! \brief casts floating point values to qreal
 template<typename T>
-auto toQreal(T x) -> std::enable_if_t<std::is_floating_point_v<T>, qreal>
+constexpr auto qreal_cast(T x)
+	-> std::enable_if_t<std::is_floating_point_v<T>, qreal>
 {
 	return static_cast<qreal>(x);
 }
 
 template<int N, typename T, glm::qualifier Q>
-inline QPoint toQPoint(const glm::vec<N, T, Q>& vec)
+constexpr QPointF toQPointF(const glm::vec<N, T, Q>& vec)
 {
-	return {static_cast<int>(vec.x), static_cast<int>(vec.y)};
+	return {double_cast(vec.x), double_cast(vec.y)};
 }
 
-template<int N, typename T, glm::qualifier Q>
-inline QPointF toQPointF(const glm::vec<N, T, Q>& vec)
-{
-	return {toDouble(vec.x), toDouble(vec.y)};
-}
-
-inline glm::vec2 toVec2(const QPoint& point)
-{
-	return {point.x(), point.y()};
-}
-
-inline glm::vec2 toVec2(const QPointF& point)
+constexpr glm::vec2 toVec2(const QPointF& point)
 {
 	return {point.x(), point.y()};
 }
 
-/*
- * coalesce(arg1, arg2, ..., argn)
- * Returns the first of the given arguments that evaluates to true.
- */
-template<typename T>
-T coalesce(T&& arg)
-{
-	// recursion base: 1 argument
-	return arg;
-}
 
-template<typename T, typename... Rest>
-std::common_type_t<T, Rest...> coalesce(T&& arg, Rest&&... rest)
-{
-	// general case: n arguments
-	return arg ? arg : coalesce(rest...);
-}
-
-/**
- * @brief Finds an element in a map and possibly returns a reference to it if find
- * @param map
- * @param key
- * @returns the value or nullptr if not found
- */
 template<typename T, typename R, typename K>
 const R* findInMap(const std::map<T, R>& map, K&& key)
 {
@@ -201,12 +115,6 @@
 	}
 }
 
-/**
- * @brief Finds an element in a map and possibly returns a reference to it if find
- * @param map
- * @param key
- * @returns the value or no value if not found
- */
 template<typename T, typename R, typename K>
 R* findInMap(std::map<T, R>& map, K&& key)
 {
@@ -221,10 +129,178 @@
 	}
 }
 
+template<typename T, typename R>
+void removeFromMap(std::map<T, R>& map, T&& key)
+{
+	const auto it = map.find(key);
+	if (it != map.end()) {
+		map.erase(it);
+	}
+}
+
 template<typename T = float>
 constexpr std::enable_if_t<std::is_floating_point_v<T>, T> pi = static_cast<T>(M_PIl);
-constexpr double infinity = std::numeric_limits<double>::infinity();
+
+inline QSizeF sizeToSizeF(const QSize& size)
+{
+	return {static_cast<qreal>(size.width()), static_cast<qreal>(size.height())};
+}
+
+//! \brief Hints to the specified vector that a certain amount of new elements
+//! are going to be added.
+template<typename T>
+void reserveMore(std::vector<T>& vector, std::size_t amount)
+{
+	vector.reserve(vector.size() + amount);
+}
+
+inline QString vectorToString(const glm::vec2& vec)
+{
+	return QStringLiteral("(%1, %2)")
+		.arg(double_cast(vec.x))
+		.arg(double_cast(vec.y));
+}
+
+inline QString vectorToString(const glm::vec3& vec)
+{
+	return QStringLiteral("(%1, %2, %3)")
+		.arg(double_cast(vec.x))
+		.arg(double_cast(vec.y))
+		.arg(double_cast(vec.z));
+}
+
+inline QString vectorToString(const glm::vec4& vec)
+{
+	return QStringLiteral("%1, %2, %3, %4)")
+		.arg(double_cast(vec.x))
+		.arg(double_cast(vec.y))
+		.arg(double_cast(vec.z))
+		.arg(double_cast(vec.w));
+}
 
+template<typename T, typename IdentifierType>
+struct TypeValue
+{
+	T value;
+	auto operator<=>(TypeValue other) const = default;
+};
+
+template<typename T, typename R>
+int qHash(TypeValue<T, R> value)
+{
+	return qHash(value.value);
+}
+
+/**
+ * Iterates a @c glm::mat
+ */
+template<int X, int Y, typename T, glm::qualifier Q, typename Fn>
+void iter_matrix(const glm::mat<X, Y, T, Q>& matrix, Fn&& fn)
+{
+	for (int i = 0; i < X; ++i)
+	{
+		for (int j = 0; j < Y; ++j)
+		{
+			fn(i, j, matrix[i][j]);
+		}
+	}
+}
+
+inline QDataStream& operator<<(QDataStream& stream, const glm::vec3& vec)
+{
+	return stream << vec.x << vec.y << vec.z;
+}
+
+inline QDataStream& operator>>(QDataStream& stream, glm::vec3& vec)
+{
+	return stream >> vec.x >> vec.y >> vec.z;
+}
 
-Q_DECLARE_METATYPE(glm::vec3)
-Q_DECLARE_METATYPE(glm::mat4)
+template<int X, int Y, typename T, glm::qualifier Q>
+QDataStream& operator<<(QDataStream& stream, const glm::mat<X, Y, T, Q>& mat)
+{
+	iter_matrix(mat, [&stream](int, int, float x)
+	{
+		stream << x;
+	});
+	return stream;
+}
+
+template<int X, int Y, typename T, glm::qualifier Q>
+QDataStream& operator>>(QDataStream& stream, glm::mat<X, Y, T, Q>& mat)
+{
+	iter_matrix(mat, [&stream](int, int, float x)
+	{
+		stream >> x;
+	});
+	return stream;
+}
+
+//! \brief Converts a pointer value to an \c std::optional value. If p has a
+//! value, it will be copied into the result value.
+template<typename T>
+std::optional<T> pointerToOptional(const T* p)
+{
+	std::optional<T> result;
+	if (p != nullptr) {
+		result = *p;
+	}
+	return result;
+}
+
+// some magic code from https://en.cppreference.com/w/cpp/utility/variant/visit
+// for use with std::visit
+template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
+template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
+
+// http://stackoverflow.com/a/18204188/3629665
+template<typename T>
+constexpr T rotl10(T x)
+{
+	return (x << 10) | ((x >> 22) & 0x000000ff);
+}
+
+template<typename T>
+constexpr T rotl20(T x)
+{
+	return (x << 20) | ((x >> 12) & 0x000000ff);
+}
+
+inline QString quoted(QString string)
+{
+	if (string.contains("'"))
+	{
+		string.replace("\"", "\\\"");
+		string = "\"" + string + "\"";
+	}
+	else
+	{
+		string = "'" + string + "'";
+	}
+	return string;
+}
+
+inline QString vertexToString(const glm::vec3& vertex)
+{
+	return QStringLiteral("%1 %2 %3").arg(vertex.x).arg(vertex.y).arg(vertex.z);
+}
+
+inline QString vertexToStringParens(const glm::vec3& vertex)
+{
+	return QStringLiteral("(%1 %2 %3)").arg(vertex.x).arg(vertex.y).arg(vertex.z);
+}
+
+inline QString transformToString(const glm::mat4& matrix)
+{
+	return QStringLiteral("%1 %2 %3 %4 %5 %6 %7 %8 %9 %10 %11 %12")
+		.arg(matrix[3][0], matrix[3][1], matrix[3][2])
+		.arg(matrix[0][0], matrix[1][0], matrix[2][0])
+		.arg(matrix[0][1], matrix[1][1], matrix[2][1])
+		.arg(matrix[0][2], matrix[1][2], matrix[2][2]);
+}
+
+template<typename T, glm::qualifier Q>
+constexpr unsigned int qHash(const glm::vec<3, T, Q>& key)
+{
+	return qHash(key.x) ^ rotl10(qHash(key.y)) ^ rotl20(qHash(key.z));
+}