video: Import new shader recompiler + display a triangle (#142)

src/common/assert.cpp

@@ -14,6 +14,7 @@ void assert_fail_impl() {
 
 [[noreturn]] void unreachable_impl() {
     Common::Log::Stop();
+    std::fflush(stdout);
     Crash();
     throw std::runtime_error("Unreachable code");
 }

src/common/enum.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <type_traits>
+#include "common/types.h"
 
 #define DECLARE_ENUM_FLAG_OPERATORS(type)                                                          \
     [[nodiscard]] constexpr type operator|(type a, type b) noexcept {                              \
@@ -58,3 +59,103 @@
         using T = std::underlying_type_t<type>;                                                    \
         return static_cast<T>(key) == 0;                                                           \
     }
+
+namespace Common {
+
+template <typename T>
+class Flags {
+public:
+    using IntType = std::underlying_type_t<T>;
+
+    Flags() {}
+
+    Flags(IntType t) : m_bits(t) {}
+
+    template <typename... Tx>
+    Flags(T f, Tx... fx) {
+        this->set(f, fx...);
+    }
+
+    template <typename... Tx>
+    void set(Tx... fx) {
+        m_bits |= bits(fx...);
+    }
+
+    void set(Flags flags) {
+        m_bits |= flags.m_bits;
+    }
+
+    template <typename... Tx>
+    void clr(Tx... fx) {
+        m_bits &= ~bits(fx...);
+    }
+
+    void clr(Flags flags) {
+        m_bits &= ~flags.m_bits;
+    }
+
+    template <typename... Tx>
+    bool any(Tx... fx) const {
+        return (m_bits & bits(fx...)) != 0;
+    }
+
+    template <typename... Tx>
+    bool all(Tx... fx) const {
+        const IntType mask = bits(fx...);
+        return (m_bits & mask) == mask;
+    }
+
+    bool test(T f) const {
+        return this->any(f);
+    }
+
+    bool isClear() const {
+        return m_bits == 0;
+    }
+
+    void clrAll() {
+        m_bits = 0;
+    }
+
+    u32 raw() const {
+        return m_bits;
+    }
+
+    Flags operator&(const Flags& other) const {
+        return Flags(m_bits & other.m_bits);
+    }
+
+    Flags operator|(const Flags& other) const {
+        return Flags(m_bits | other.m_bits);
+    }
+
+    Flags operator^(const Flags& other) const {
+        return Flags(m_bits ^ other.m_bits);
+    }
+
+    bool operator==(const Flags& other) const {
+        return m_bits == other.m_bits;
+    }
+
+    bool operator!=(const Flags& other) const {
+        return m_bits != other.m_bits;
+    }
+
+private:
+    IntType m_bits = 0;
+
+    static IntType bit(T f) {
+        return IntType(1) << static_cast<IntType>(f);
+    }
+
+    template <typename... Tx>
+    static IntType bits(T f, Tx... fx) {
+        return bit(f) | bits(fx...);
+    }
+
+    static IntType bits() {
+        return 0;
+    }
+};
+
+} // namespace Common

src/common/func_traits.h

@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <tuple>
+
+namespace Common {
+
+template <class Func>
+struct FuncTraits {};
+
+template <class ReturnType_, class... Args>
+struct FuncTraits<ReturnType_ (*)(Args...)> {
+    using ReturnType = ReturnType_;
+
+    static constexpr size_t NUM_ARGS = sizeof...(Args);
+
+    template <size_t I>
+    using ArgType = std::tuple_element_t<I, std::tuple<Args...>>;
+};
+
+template <typename Func>
+struct LambdaTraits : LambdaTraits<decltype(&std::remove_reference_t<Func>::operator())> {};
+
+template <typename ReturnType, typename LambdaType, typename... Args>
+struct LambdaTraits<ReturnType (LambdaType::*)(Args...) const> {
+    template <size_t I>
+    using ArgType = std::tuple_element_t<I, std::tuple<Args...>>;
+
+    static constexpr size_t NUM_ARGS{sizeof...(Args)};
+};
+
+} // namespace Common