Triforce v0.2.0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
ruckus7382sfgsgdf
2026-11-10 19:32:48 -06:00
commit 34b3683441
1730 changed files with 554853 additions and 0 deletions

View File

@@ -0,0 +1,10 @@
// ankerl::unordered_dense::map for suyu's shader_recompiler: std::unordered_map has the API it uses.
#pragma once
#include <unordered_map>
#include <unordered_set>
namespace ankerl::unordered_dense {
template <class K, class V, class H = std::hash<K>, class E = std::equal_to<K>>
using map = std::unordered_map<K, V, H, E>;
template <class K, class H = std::hash<K>, class E = std::equal_to<K>>
using set = std::unordered_set<K, H, E>;
}

View File

@@ -0,0 +1,54 @@
// boost::container::flat_set for suyu's shader_recompiler: a sorted vector.
#pragma once
#include <algorithm>
#include <functional>
#include <utility>
#include <vector>
namespace boost::container {
template <typename T, typename Compare = std::less<T>, typename Container = std::vector<T>>
class flat_set {
Container v;
Compare cmp;
public:
using value_type = T;
using iterator = typename Container::iterator;
using const_iterator = typename Container::const_iterator;
std::pair<iterator, bool> insert(const T& x) {
auto it = std::lower_bound(v.begin(), v.end(), x, cmp);
if (it != v.end() && !cmp(x, *it)) return {it, false};
return {v.insert(it, x), true};
}
template <typename... A>
std::pair<iterator, bool> emplace(A&&... a) { return insert(T(std::forward<A>(a)...)); }
iterator find(const T& x) {
auto it = std::lower_bound(v.begin(), v.end(), x, cmp);
return it != v.end() && !cmp(x, *it) ? it : v.end();
}
const_iterator find(const T& x) const {
auto it = std::lower_bound(v.begin(), v.end(), x, cmp);
return it != v.end() && !cmp(x, *it) ? it : v.end();
}
bool contains(const T& x) const { return find(x) != v.end(); }
std::size_t index_of(const_iterator it) const { return static_cast<std::size_t>(it - v.begin()); }
std::size_t index_of(iterator it) { return static_cast<std::size_t>(it - v.begin()); }
const T& operator[](std::size_t i) const { return v[i]; }
T& operator[](std::size_t i) { return v[i]; }
std::size_t count(const T& x) const { return contains(x) ? 1 : 0; }
iterator erase(const_iterator it) { return v.erase(it); }
std::size_t erase(const T& x) {
auto it = find(x);
if (it == v.end()) return 0;
v.erase(it);
return 1;
}
iterator begin() { return v.begin(); }
iterator end() { return v.end(); }
const_iterator begin() const { return v.begin(); }
const_iterator end() const { return v.end(); }
std::size_t size() const { return v.size(); }
bool empty() const { return v.empty(); }
void clear() { v.clear(); }
void reserve(std::size_t n) { v.reserve(n); }
};
} // namespace boost::container

View File

@@ -0,0 +1,14 @@
// boost::container::small_vector for suyu's shader_recompiler: a std::vector with the inline capacity reserved.
#pragma once
#include <cstddef>
#include <initializer_list>
#include <vector>
namespace boost::container {
template <typename T, std::size_t N, typename Alloc = void>
class small_vector : public std::vector<T> {
public:
using std::vector<T>::vector;
small_vector() { this->reserve(N); }
small_vector(std::initializer_list<T> list) : std::vector<T>(list) {}
};
} // namespace boost::container

View File

@@ -0,0 +1,21 @@
// boost::container::static_vector for suyu's code: a std::vector (capacity and options are not enforced).
#pragma once
#include <cstddef>
#include <vector>
namespace boost::container {
template <std::size_t A>
struct inplace_alignment {};
template <bool B>
struct throw_on_overflow {};
template <typename... Options>
struct static_vector_options {
using type = static_vector_options;
};
template <typename T, std::size_t N, typename Options = void>
class static_vector : public std::vector<T> {
public:
using std::vector<T>::vector;
static_vector() { this->reserve(N); }
};
} // namespace boost::container

View File

@@ -0,0 +1,209 @@
// boost::intrusive::list (the subset suyu's shader_recompiler uses): a circular doubly linked list threaded through
// a hook the element type derives from. Elements are never owned or copied by the list.
#pragma once
#include <cstddef>
#include <iterator>
#include <type_traits>
#include <utility>
namespace boost::intrusive {
struct normal_link {};
struct safe_link {};
template <typename Mode>
struct link_mode {};
template <typename Hook>
struct base_hook {};
template <bool B>
struct constant_time_size {};
namespace detail {
struct list_node {
list_node* prev_ = nullptr;
list_node* next_ = nullptr;
};
} // namespace detail
template <typename... Options>
struct list_base_hook : detail::list_node {};
template <typename T, typename... Options>
class list {
using node = detail::list_node;
node root;
std::size_t count = 0;
static T& value_of(node* n) { return static_cast<T&>(*n); }
static node* node_of(T& v) { return static_cast<node*>(&v); }
static node* node_of(const T& v) { return const_cast<node*>(static_cast<const node*>(&v)); }
void reset() {
root.prev_ = root.next_ = &root;
count = 0;
}
static void link_before(node* pos, node* n) {
n->prev_ = pos->prev_;
n->next_ = pos;
pos->prev_->next_ = n;
pos->prev_ = n;
}
static void unlink(node* n) {
n->prev_->next_ = n->next_;
n->next_->prev_ = n->prev_;
n->prev_ = n->next_ = nullptr;
}
public:
template <bool Const>
class iter {
friend class list;
node* n = nullptr;
public:
using iterator_category = std::bidirectional_iterator_tag;
using value_type = T;
using difference_type = std::ptrdiff_t;
using pointer = std::conditional_t<Const, const T*, T*>;
using reference = std::conditional_t<Const, const T&, T&>;
iter() = default;
explicit iter(node* n_) : n(n_) {}
// boost's iterators convert from an element pointer (structured_control_flow assigns `node = stmt->up`)
iter(std::conditional_t<Const, const T*, T*> p) : n(p ? node_of(*p) : nullptr) {}
template <bool C2, typename = std::enable_if_t<Const && !C2>>
iter(const iter<C2>& o) : n(o.raw()) {}
reference operator*() const { return value_of(n); }
pointer operator->() const { return &value_of(n); }
iter& operator++() {
n = n->next_;
return *this;
}
iter operator++(int) {
iter t = *this;
n = n->next_;
return t;
}
iter& operator--() {
n = n->prev_;
return *this;
}
iter operator--(int) {
iter t = *this;
n = n->prev_;
return t;
}
friend bool operator==(const iter& a, const iter& b) { return a.n == b.n; }
node* raw() const { return n; }
};
using value_type = T;
using reference = T&;
using const_reference = const T&;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
using iterator = iter<false>;
using const_iterator = iter<true>;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
list() { reset(); }
list(const list&) = delete;
list& operator=(const list&) = delete;
list(list&& o) noexcept {
reset();
take(o);
}
list& operator=(list&& o) noexcept {
if (this != &o) {
clear();
take(o);
}
return *this;
}
// Elements are not touched: they may already be gone (suyu frees them through ObjectPool), as boost allows.
~list() = default;
iterator begin() { return iterator(root.next_); }
iterator end() { return iterator(&root); }
const_iterator begin() const { return const_iterator(root.next_); }
const_iterator end() const { return const_iterator(const_cast<node*>(&root)); }
const_iterator cbegin() const { return begin(); }
const_iterator cend() const { return end(); }
reverse_iterator rbegin() { return reverse_iterator(end()); }
reverse_iterator rend() { return reverse_iterator(begin()); }
const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
const_reverse_iterator crbegin() const { return rbegin(); }
const_reverse_iterator crend() const { return rend(); }
bool empty() const { return root.next_ == &root; }
size_type size() const { return count; }
T& front() { return value_of(root.next_); }
T& back() { return value_of(root.prev_); }
const T& front() const { return value_of(root.next_); }
const T& back() const { return value_of(root.prev_); }
void push_back(T& v) {
link_before(&root, node_of(v));
++count;
}
void push_front(T& v) {
link_before(root.next_, node_of(v));
++count;
}
void pop_front() {
unlink(root.next_);
--count;
}
void pop_back() {
unlink(root.prev_);
--count;
}
iterator insert(const_iterator pos, T& v) {
link_before(pos.raw(), node_of(v));
++count;
return iterator(node_of(v));
}
iterator erase(const_iterator pos) {
node* next = pos.raw()->next_;
unlink(pos.raw());
--count;
return iterator(next);
}
iterator erase(const_iterator first, const_iterator last) {
while (first != last) first = erase(first);
return iterator(last.raw());
}
void clear() { reset(); } // elements keep stale links, as boost's normal_link mode leaves them
// Moves [first, last) of x in front of pos.
void splice(const_iterator pos, list& x, const_iterator first, const_iterator last) {
if (first == last) return;
std::size_t moved = 0;
for (const_iterator i = first; i != last; ++i) ++moved;
node* f = first.raw();
node* l = last.raw()->prev_;
f->prev_->next_ = last.raw();
last.raw()->prev_ = f->prev_;
node* p = pos.raw();
f->prev_ = p->prev_;
l->next_ = p;
p->prev_->next_ = f;
p->prev_ = l;
x.count -= moved;
count += moved;
}
void splice(const_iterator pos, list& x) { splice(pos, x, x.begin(), x.end()); }
static iterator s_iterator_to(T& v) { return iterator(node_of(v)); }
static const_iterator s_iterator_to(const T& v) { return const_iterator(node_of(v)); }
iterator iterator_to(T& v) { return iterator(node_of(v)); }
const_iterator iterator_to(const T& v) const { return const_iterator(node_of(v)); }
private:
void take(list& o) {
if (o.empty()) return;
root.next_ = o.root.next_;
root.prev_ = o.root.prev_;
root.next_->prev_ = &root;
root.prev_->next_ = &root;
count = o.count;
o.reset();
}
};
} // namespace boost::intrusive

View File

@@ -0,0 +1,100 @@
// boost::intrusive::set (the subset suyu's shader_recompiler uses): an ordered set of element references, ordered by
// the element's operator<. Built on std::multiset of pointers, whose iterators survive inserts as boost's do.
// Lookups with a separate key and comparator are linear: a shader's control-flow graph has few blocks.
#pragma once
#include <boost/intrusive/list.hpp>
#include <cstddef>
#include <iterator>
#include <set>
#include <type_traits>
#include <utility>
namespace boost::intrusive {
template <typename... Options>
struct set_base_hook {};
template <typename T, typename... Options>
class set {
struct less {
bool operator()(const T* a, const T* b) const { return *a < *b; }
};
using base = std::multiset<T*, less>;
base s;
public:
template <typename It, typename Ref>
class iter {
friend class set;
It it{};
public:
using iterator_category = std::bidirectional_iterator_tag;
using value_type = T;
using difference_type = std::ptrdiff_t;
using pointer = std::remove_reference_t<Ref>*;
using reference = Ref;
iter() = default;
explicit iter(It i) : it(i) {}
reference operator*() const { return **it; }
pointer operator->() const { return *it; }
iter& operator++() {
++it;
return *this;
}
iter operator++(int) {
iter t = *this;
++it;
return t;
}
iter& operator--() {
--it;
return *this;
}
iter operator--(int) {
iter t = *this;
--it;
return t;
}
friend bool operator==(const iter& a, const iter& b) { return a.it == b.it; }
};
using iterator = iter<typename base::iterator, T&>;
using const_iterator = iter<typename base::const_iterator, const T&>;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
using size_type = std::size_t;
using value_type = T;
std::pair<iterator, bool> insert(T& v) { return {iterator(s.insert(&v)), true}; }
iterator insert(iterator hint, T& v) { return iterator(s.insert(hint.it, &v)); }
iterator erase(iterator it) { return iterator(s.erase(it.it)); }
template <typename Key, typename Compare>
iterator find(const Key& key, Compare comp) {
for (auto i = s.begin(); i != s.end(); ++i)
if (!comp(**i, key) && !comp(key, **i)) return iterator(i);
return end();
}
template <typename Key, typename Compare>
iterator upper_bound(const Key& key, Compare comp) {
for (auto i = s.begin(); i != s.end(); ++i)
if (comp(key, **i)) return iterator(i);
return end();
}
template <typename Key, typename Compare>
iterator lower_bound(const Key& key, Compare comp) {
for (auto i = s.begin(); i != s.end(); ++i)
if (!comp(**i, key)) return iterator(i);
return end();
}
iterator begin() { return iterator(s.begin()); }
iterator end() { return iterator(s.end()); }
const_iterator begin() const { return const_iterator(s.begin()); }
const_iterator end() const { return const_iterator(s.end()); }
reverse_iterator rbegin() { return reverse_iterator(end()); }
reverse_iterator rend() { return reverse_iterator(begin()); }
const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
bool empty() const { return s.empty(); }
size_type size() const { return s.size(); }
void clear() { s.clear(); }
};
} // namespace boost::intrusive

86
gpu/compat/fmt/format.h Normal file
View File

@@ -0,0 +1,86 @@
// The {fmt} API subset suyu's shader_recompiler uses, on C++20 std::format (no external {fmt} needed).
// Types given a fmt::formatter specialization are formattable by std::format too (the bridge at the end).
#pragma once
#include <format>
#include <iterator>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
namespace fmt {
using std::format_context;
using std::format_parse_context;
template <typename T, typename Char = char, typename Enable = void>
struct formatter; // specialized by the code that uses it
template <>
struct formatter<std::string_view> : std::formatter<std::string_view> {};
struct runtime_format_string {
std::string_view str;
};
inline runtime_format_string runtime(std::string_view s) { return {s}; }
// (hookshot) Formats read as they run, not checked at compile time: std::format_string is missing from Visual Studio's
// C++ library before 17.5, and a player's build stopped on it with 303 files failed (Hookshot issue 39)
template <typename... Args>
std::string format(std::string_view f, Args&&... args) {
return std::vformat(f, std::make_format_args(args...));
}
template <typename... Args>
std::string format(runtime_format_string f, Args&&... args) {
return std::vformat(f.str, std::make_format_args(args...));
}
template <typename Out, typename... Args>
Out format_to(Out out, std::string_view f, Args&&... args) {
return std::vformat_to(std::move(out), f, std::make_format_args(args...));
}
template <typename Out, typename... Args>
auto format_to_n(Out out, std::iter_difference_t<Out> n, std::string_view f, Args&&... args) { // (mkw-recomp: Eden's
const std::string text = std::vformat(f, std::make_format_args(args...));
const auto size = (std::iter_difference_t<Out>)text.size();
for (std::iter_difference_t<Out> i = 0; i < size && i < n; i++) *out++ = text[(size_t)i];
return std::format_to_n_result<Out>{std::move(out), size};
}
template <typename Out, typename... Args>
Out format_to(Out out, runtime_format_string f, Args&&... args) {
return std::vformat_to(std::move(out), f.str, std::make_format_args(args...));
}
template <typename T>
std::string to_string(const T& value) {
return std::format("{}", value);
}
namespace detail {
template <typename T>
concept has_fmt_formatter = requires { sizeof(::fmt::formatter<T>); };
template <typename T>
concept has_format_as = requires(const T& t) { format_as(t); }; // {fmt} 10's customization point (ADL)
}
} // namespace fmt
template <typename T>
requires(fmt::detail::has_fmt_formatter<T> && !std::is_same_v<T, std::string_view>)
struct std::formatter<T, char> : ::fmt::formatter<T> {};
// {fmt} before 10 formatted enums as their underlying integer, and suyu relies on it; std::format does not.
template <typename T>
requires(std::is_enum_v<T> && !fmt::detail::has_fmt_formatter<T> && !fmt::detail::has_format_as<T>)
struct std::formatter<T, char> : std::formatter<std::underlying_type_t<T>, char> {
template <typename Ctx>
auto format(T v, Ctx& ctx) const {
return std::formatter<std::underlying_type_t<T>, char>::format(static_cast<std::underlying_type_t<T>>(v), ctx);
}
};
template <typename T>
requires(fmt::detail::has_format_as<T> && !fmt::detail::has_fmt_formatter<T>)
struct std::formatter<T, char> : std::formatter<std::decay_t<decltype(format_as(std::declval<const T&>()))>, char> {
template <typename Ctx>
auto format(const T& v, Ctx& ctx) const {
using Base = std::formatter<std::decay_t<decltype(format_as(std::declval<const T&>()))>, char>;
return Base::format(format_as(v), ctx);
}
};

2
gpu/compat/fmt/ranges.h Normal file
View File

@@ -0,0 +1,2 @@
#pragma once
#include <fmt/format.h>