From 17f9cfa82fd593abf6df6bad777f173e74902f08 Mon Sep 17 00:00:00 2001
From: Volodymyr Zvarun <lolpie2651@gmail.com>
Date: Thu, 30 May 2024 16:51:16 +0300
Subject: [PATCH] Add glm vector support

---
 README.md                                | 54 ++++++++++++++++++++++++
 include/alpaca/alpaca.h                  |  1 +
 include/alpaca/detail/types/glm_vector.h | 52 +++++++++++++++++++++++
 3 files changed, 107 insertions(+)
 create mode 100644 include/alpaca/detail/types/glm_vector.h

diff --git a/README.md b/README.md
index 40de65b..ec2ce1b 100644
--- a/README.md
+++ b/README.md
@@ -800,6 +800,60 @@ pranav@ubuntu:~/dev/alpaca/build$ hexdump -C savefile.bin
 00000025
 ```
 
+## Add custom type serialization
+Not all types are supported by this library, but you can easily define serialization for custom types from other libraries. To do this, you need to create header file, in which define: `type_info`, `to_bytes` and `from_bytes` methods, and in the end of this file include `<alpaca/alpaca.h>`. After that, use your header file, instead of alpaca one.
+
+For example, we need to add serialization for type `MyCustomType<typename T, typename U, int L>`
+```cpp
+#pragma once
+
+#include <alpaca/detail/field_type.h>
+#include <alpaca/detail/options.h>
+#include <alpaca/detail/aggregate_arity.h>
+
+#include <system_error>
+#include <unordered_map>
+#include <vector>
+
+namespace alpaca {
+
+namespace detail {
+
+
+template <typename T> struct is_my_custom_type : std::false_type {};
+
+template <typename T, typename U, int L>
+struct is_my_custom_type<MY_CUSTOM_TYPE<T, U, L>> : std::true_type {};
+
+template <typename T>
+typename std::enable_if<is_my_custom_type<T>::value, void>::type
+type_info(
+    std::vector<uint8_t> &typeids,
+    std::unordered_map<std::string_view, std::size_t> &struct_visitor_map) {
+
+    // Run type_info for inner types
+	type_info<typename T::T>(typeids, struct_visitor_map);
+	type_info<typename T::U>(typeids, struct_visitor_map);
+}
+
+template <options O, typename Container, typename T, typename U, int L>
+void to_bytes(Container &bytes, std::size_t &byte_index, const MY_CUSTOM_TYPE<T, U, L> &input) {
+    // implement to bytes
+}
+
+template <options O, typename T, typename U, int L, typename Container>
+bool from_bytes(MY_CUSTOM_TYPE<T, U, L> &output, Container &bytes, std::size_t &byte_index, std::size_t &end_index,
+                std::error_code &error_code) {
+    // implement from bytes
+    return true;
+}
+}  // namespace detail
+}  // namespace alpaca
+
+#include <alpaca/alpaca.h>
+```
+
+
 ## Backward and Forward Compatibility
 
 * A change made to a system or technology in such a way that the existing users are unaffected is a ***backward compatible change***. The obvious advantage is that the existing users have a non-time sensitive and a graceful way of upgrading their integrations. On the other hand, a non backward-compatible change breaks the existing integrations and forces the existing users to deal with an immediate fix.
diff --git a/include/alpaca/alpaca.h b/include/alpaca/alpaca.h
index d9d870f..207d4d2 100644
--- a/include/alpaca/alpaca.h
+++ b/include/alpaca/alpaca.h
@@ -24,6 +24,7 @@
 #include <alpaca/detail/types/unique_ptr.h>
 #include <alpaca/detail/types/variant.h>
 #include <alpaca/detail/types/vector.h>
+#include <alpaca/detail/types/glm_vector.h>
 #include <alpaca/detail/variable_length_encoding.h>
 #include <cassert>
 #include <system_error>
diff --git a/include/alpaca/detail/types/glm_vector.h b/include/alpaca/detail/types/glm_vector.h
new file mode 100644
index 0000000..6672304
--- /dev/null
+++ b/include/alpaca/detail/types/glm_vector.h
@@ -0,0 +1,52 @@
+#pragma once
+#ifdef ALPACA_INCLUDE_SUPPORT_GLM_VECTOR
+#include <alpaca/detail/types/array.h>
+
+#include <glm/ext/vector_float3.hpp>
+#include <system_error>
+#include <unordered_map>
+#include <vector>
+
+namespace alpaca {
+
+namespace detail {
+
+
+template <typename T> struct is_glm_vec : std::false_type {};
+
+template <int L, typename T, glm::qualifier Q>
+struct is_glm_vec<glm::vec<L, T, Q>> : std::true_type {};
+
+template <typename T>
+typename std::enable_if<is_glm_vec<T>::value, void>::type
+type_info(
+    std::vector<uint8_t> &typeids,
+    std::unordered_map<std::string_view, std::size_t> &struct_visitor_map) {
+	type_info<std::array<typename T::T, T::L>>(typeids, struct_visitor_map);
+}
+
+template <options O, typename Container, int L, typename T, glm::qualifier Q>
+void to_bytes(Container &bytes, std::size_t &byte_index, const glm::vec<L, T, Q> &input) {
+    std::array<T, L> data;
+	for (int i = 0; i < L; i++)
+		data[i] = input[i];
+
+    to_bytes<O, Container, T, L>(bytes, byte_index, data);
+}
+
+template <options O, int L, typename T, glm::qualifier Q, typename Container>
+bool from_bytes(glm::vec<L, T, Q> &output, Container &bytes, std::size_t &byte_index, std::size_t &end_index,
+                std::error_code &error_code) {
+    std::array<T, L> output_array;
+    from_bytes<O, T, Container, L>(output_array, bytes, byte_index, end_index, error_code);
+
+	for (int i = 0; i < L; i++)
+		output[i] = output_array[i];
+
+    return true;
+}
+
+}  // namespace detail
+
+}  // namespace alpaca
+#endif