From 64a9db2e82ea589030389e9ea45580bfc891521c Mon Sep 17 00:00:00 2001
From: Billy Laws <blaws05@gmail.com>
Date: Wed, 31 Aug 2022 13:39:16 +0100
Subject: [PATCH] Introduce `MergeInto` helper for simplified construction of
 arrays of structs

In the upcoming GPU code each state member will hold a reference to its corresponding Maxwell 3D regs, this helper is needed to allow easy transformation from the the main 3D register struct into them.

Example:
```c++
struct Regs {
    std::array<View, 10> viewRegs;
    u32 enable;
} regs;

struct ViewState {
    const View &view;
    const u32 &enable;
    size_t index;
};

std::array<ViewState, 10> viewStates{MergeInto<ViewState, 10>(regs.viewRegs, regs.enable, IncrementingT{})
```
---
 app/src/main/cpp/skyline/common/utils.h | 40 +++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/app/src/main/cpp/skyline/common/utils.h b/app/src/main/cpp/skyline/common/utils.h
index 3fe316f4..d82a1925 100644
--- a/app/src/main/cpp/skyline/common/utils.h
+++ b/app/src/main/cpp/skyline/common/utils.h
@@ -8,6 +8,7 @@
 #include <span>
 #include <frozen/unordered_map.h>
 #include <frozen/string.h>
+#include <type_traits>
 #include <xxhash.h>
 #include "base.h"
 #include "exception.h"
@@ -309,4 +310,43 @@ namespace skyline::util {
     std::array<T, Size> MakeFilledArray(TArgs &&... args) {
         return MakeFilledArray<T>(std::make_index_sequence<Size>(), std::forward<TArgs>(args)...);
     }
+
+    template<typename T>
+    struct IncrementingT {
+        using Type = T;
+    };
+
+
+    template<typename T>
+    struct IsIncrementingT : std::false_type {};
+
+    template<typename T>
+    struct IsIncrementingT<IncrementingT<T>> : std::true_type {};
+
+    template<typename T, size_t Index, typename... TSrcs>
+    T MakeMergeElem(TSrcs &&... srcs) {
+        auto readElem{[index = Index](auto &&src) -> decltype(auto) {
+            using SrcType = std::decay_t<decltype(src)>;
+            if constexpr (requires { src[Index]; })
+                return src[Index];
+            else if constexpr (IsIncrementingT<SrcType>{})
+                return static_cast<typename SrcType::Type>(index);
+            else
+                return src;
+        }};
+        return T{readElem(std::forward<TSrcs>(srcs))...};
+    }
+
+    template<typename T, size_t... Is, typename... TSrcs>
+    std::array<T, sizeof...(Is)> MergeInto(std::index_sequence<Is...> seq, TSrcs &&... srcs) {
+        return {MakeMergeElem<T, Is>(std::forward<TSrcs>(srcs)...)...};
+    }
+
+    /**
+     * @brief Constructs {{scalar0, array0[0], array1[0], ... arrayN[0], scalar1}, {scalar0, array0[1], array1[1]. ... arrayN[1], scalar0}, ...}
+     */
+    template<typename T, size_t Size, typename... TSrcs>
+    std::array<T, Size> MergeInto(TSrcs &&... srcs) {
+        return MergeInto<T>(std::make_index_sequence<Size>(), std::forward<TSrcs>(srcs)...);
+    }
 }