Reference:
Data Storage in Entity Component Systems - Mathieu Ropert - Meeting C++ 2023
https://www.youtube.com/watch?v=b9hNKFj5R3Y
https://en.wikipedia.org/wiki/Entity_component_system
https://skypjack.github.io/2019-02-14-ecs-baf-part-1/
https://github.com/skypjack/entt
Reference:
https://www.youtube.com/watch?v=XJzs4kC9d-Y
https://github.com/rollbear/columnist
https://godbolt.org/z/a8P7oTjoh
#include <functional>
#include <iostream>
#include <tuple>
#include <vector>
template<typename... Ts>
class Table {
public:
using row = std::tuple<Ts&...>;
row operator[](size_t i) {
auto access = [&]<size_t... Is>(std::index_sequence<Is...>) {
return row{std::get<Is>(data_)[i]...};
};
return std::invoke(access, indexes);
}
Table() {
init(indexes);
}
private:
static constexpr std::index_sequence_for<Ts...> indexes{};
std::tuple<std::vector<Ts>...> data_;
private:
template<size_t... I>
constexpr void init(std::index_sequence<I...>) {
((std::get<I>(data_).push_back({42}),...));
}
};
struct Data1 {
int value;
};
struct Data2 {
int value;
};
int main() {
Table<Data1, Data2> table;
auto row = table[0];
std::cout << std::get<0>(row).value << '\n'; // print 42
}; |
struct sentinel {}; // or using sentinal = void;
struct iterator {
using value_type = row;
using difference_type = ssize_t;
value_type operator*() const {
return std::invoke([&]<size_t... Is>(std::index_sequence<Is...>) {
return value_type{std::get<Is>(t->data_)[offset]...};
}, t->indexes);
}
iterator& operator++() { ++offset; return *this;}
iterator operator++(int) { auto copy = *this; ++*this; return copy;}
bool operator==(const iterator&) const = default;
bool operator==(sentinel) const { return offset == t->size(); }
table* t;
size_t offset;
};template<typename... Ts>
class Table {
public:
friend class iterator;
iterator begin() { return {this, 0}; }
sentinel end() { return {}; }
...
};template<typename...>
struct Table;
template<typename, typename>
struct Row;
template <typename... Ts, size_t... Cs>
struct Row<Table<Ts...>, std::index_sequence<Cs...>> {
using row_id = typename Table<Ts...>::row_id;
// Indirection to make std::index_sequence<0, 2, 4> -> I==1 means std::get<2>(...)
template<size_t I>
friend auto& get(const Row& r) {
static constexpr std::array columns{Cs...};
return std::get<columns[I]>(r.t->data_)[r.offset];
}
...
Table<Ts...>* t;
size_t offset;
};
template<typename Table, size_t... Cs>
struct std::tuple_size<Row<Table, std::index_sequence<Cs...>>>
: std::integral_constant<size_t, sizeof...(Cs)> {};
template <size_t I, typename... Ts, size_t... Cs>
struct std::tuple_element<I, Row<Table<Ts...>, std::index_sequence<Cs...>>> {
static constexpr std::array indexes = { Cs... };
using type = Ts...[indexes[I]]&;
};template<size_t... Is, typename Table, size_t... Cs>
auto select(const Row<Table, std::index_sequence<Cs...>>& r) {
static constexpr size_t columns[] { Cs... };
return Row<Table, std::index_sequence<columns[Is]...>>(r);
}
drop_if(values, [](auto r){ auto [x,z] = select<0, 2>(r); return x < z; });template<typename R, size_t... Cs>
struct range_selector {
using r_iterator = decltype(std::declval<R&>().begin());
struct iterator : r_iterator {
using difference_type = ssize_t;
using value_type = decltype(select<Cs...>(*std::declval<r_iterator>()));
iterator(const r_iterator& i) : r_iterator(i) {}
auto operator*() const {
const r_iterator& i = *this;
return select<Cs...>(*i);
}
};
iterator begin() { return iterator{ r.begin() }; }
auto end() { return r.end(); }
R& r;
};template<size_t... Cs>
struct range_selector_maker {
template<typename R>
friend range_selector<R, Cs...> operator|(R& r, range_selector_maker) {
return { r };
}
};
template<size_t... Cs>
range_selector_maker<Cs...> select() { return {}; }for (auto [x, d] : values | select<0, 3>()) {
std::println("d={} x={}", d, x);
}template<typename>
inline constexpr bool row_type_v = false;
template<typename T, typename Cs>
inline constexpr bool row_type_v<Row<T, Cs>> = true;
template<typename T>
concept row_type = row_type_v<T>;template<size_t... Cs, typename F>
auto select(F&& f)
requires (! row_type<std::remove_cvref_t<F>>)
{
return [f = std::forward<F>(f)]<typename T, typename Is>(row<T, Is> r) {
return f(select<Cs...>(r));
};
}template<typename F>
auto apply(F&& f) {
return [f = std::forward<F>(f)]<row_type R>(R r) {
return std::invoke([&]<size_t... Cs>(std::index_sequence<Cs...>) {
return f(get<Cs>(r)...);
}, std::make_index_sequence<std::tuple_size_v<R>>{});
};
}drop_if(values, select<0, 2>(apply([](auto x, auto z) { return x < z; })));drop_if(values, select<0, 2>(apply(std::less{})));
bool; // 2, true, false
char; // 256
void; // 0
struct Foo {}; // 1
enum FireSwampDangers : int8_t { // 3
FLAME_SPURTS,
LIGHTNING_SAND,
ROUSES
};
template <typename T> // as many values as T
struct Foo {
T m_t;
};
std::pair<char, bool>; // 256 * 2
struct Foo { // 256 * 2
char a;
bool b;
};
std::tuple<bool, bool, bool>; // 2 * 2 * 2 = 8
template <typename T, typename U> // (# of values in T) * (# of values in U)
struct Foo {
T m_t;
U m_u;
};
std::optional<char>; // 256 + 1
std::variant<char, bool>; // 256 + 2
template <typename T, typename U> // (# of values in T) + (# of values in U)
struct Foo {
std::variant<T, U>;
}
bool f(bool); // 2^2 = 4
char f(bool); // 256 ^ 2
enum class Foo
{
BAR,
BAZ,
QUUX
};
char f(Foo); // 256 ^ 3
template <class T, class U> // U ^ T
U f(T);
template <typename T>
struct Foo {
std::variant<T, T> m_v;
};template <typename T>
struct Bar {
T m_t;
bool m_b;
};
enum class ConnectionState {
DISCONNECTED,
CONNECTING,
CONNECTED,
CONNECTION_INTERRUPTED
};
struct Connection {
ConnectionState m_connectionState;
std::string m_serverAddress;
ConnectionId m_id;
std::chrono::system_clock::time_point m_connectedTime;
std::chrono::milliseconds m_lastPingTime;
Timer m_reconnectTimer;
};
struct Connection {
std::string m_serverAddress;
struct Disconnected {};
struct Connecting {};
struct Connected {
ConnectionId m_id;
std::chrono::system_clock::time_point m_connectedTime;
std::optional<std::chrono::milliseconds> m_lastPingTime;};
struct ConnectionInterrupted {
std::chrono::system_clock::time_point m_disconnectedTime;
Timer m_reconnectTimer;};
std::variant<Disconnected,
Connecting,
Connected,
ConnectionInterrupted> m_connection;
};
class Friend {
std::string m_alias;
bool m_aliasPopulated;
...
};
class Friend {
std::optional<std::string> m_alias;
...
};
std::string GetFormData();
std::string SanitizeFormData(const std::string&);
void ExecuteQuery(const std::string&);
template <typename T>
struct FormData {
explicit FormData(const string& input) : m_input(input) {}
std::string m_input;
};
struct sanitized {};
struct unsanitized {};FormData<unsanitized> GetFormData();
std::optional<FormData<sanitized>>
SanitizeFormData(const FormData<unsanitized>&);
void ExecuteQuery(const FormData<sanitized>&);
template <typename T>
T f(T);
// identity
// int f(int);
template <typename T, typename U>
T f(pair<T, U>);
// first
template <typename T>
T f(bool, T, T);
// select
template <typename T, typename U>
U f(function<U(T)>, T);
// apply or call
template <typename T>
vector<T> f(vector<T>);
// reverse, shuffle, ...
template <typename T>
optional<T> f(vector<T>);
template <typename T, typename U>
vector<U> f(function<U(T)>, vector<T>);
// transform
template <typename T>
vector<T> f(function<bool(T)>, vector<T>);
// remove_if, partition, ...
template <typename K, typename V>
optional<V> f(map<K, V>, K);
// lookup
template <typename T>
T f(vector<T>);
// Not possible! It's a partial function - the vector might be empty.
// T& vector<T>::front();
template <typename T>
T f(optional<T>);
// Not possible!
template <typename K, typename V>
V f(map<K, V>, K);
// Not possible! (The key might not be in the map.)
// V& map<K, V>::operator[](const K&);
template<typename T, int N>
using SmallVector = std::vector<T, short_alloc<T, N>>;
void fun(){
SmallVector<int, 4>::allocator_type::arena_type a;
SmallVector<int> v{a};
}
void jump(SmallVector<int, 4> &v);
void fun(){
// Taking short_alloc<int, 8>
SmallVector<int, 8>::allocator_type::arena_type a;
SmallVector<int> v{a};
jump(v); // doesn't work... callee taking short_alloc<int, 4>
}
SmallVector<int, 4> fun(){
SmallVector<int, 4>::allocator_type::arena_type a;
SmallVector<int> v{a};
return v; // BAD
}
template <typename T, unsigned N>
class SmallVector : public SmallVectorImpl<T> {
typedef typename SmallVectorImpl<T>::U U; // expected-error {{no type named 'U' in 'SmallVectorImpl<CallSite>'}}
enum {
MinUs = (static_cast<unsigned int>(sizeof(T))*N + // expected-error {{invalid application of 'sizeof' to an incomplete type 'CallSite'}}
static_cast<unsigned int>(sizeof(U)) - 1) /
static_cast<unsigned int>(sizeof(U)),
NumInlineEltsElts = MinUs
};
U InlineElts[NumInlineEltsElts];
public:
SmallVector() : SmallVectorImpl<T>(NumInlineEltsElts) {
}
};
SmallVector<std::unique_ptr<BigObject>, 4> Objects;BumpPtrAllocator impl, purpose, make BigObject as compact as possible on heap memory.
// FAST
class BumpPtrAllocator {
constexpr int SlabSize = 4096;
SmallVector<void *, 4> Slabs;
void *CurPtr, *End;
public:
void *Allocate(int Size) P
if (Size >= (End - CurPtr)) {
CurPtr = malloc(SlabSize);
End = CurPtr + SlabSize;
Slabs.push_back(CurPtr);
}
void *Ptr = CurPtr;
CurPtr += Size;
return Ptr;
}
// ...
};
template<typename KeyT, typename ValueT> using SmallMultiMap = SmallDenseMap<KeyT, TinyPtrVector<ValueT>>;
struct AnimationController{
AnimationState* as_ [];
};
// Golang style.
// No shared_ptr, every instance of this type
// has it's own value.
// Thread safe.
struct AnimationState{
AnimationID Id;
time StartTime;
time PauseTime;
...
};
// Avoid type erasure, use template
template<typename T>
struct AnimationStateProperty : public AnimationState {
AnimatedDefiniationFrames<T> Keyframes;
};
// We can't use vector<baseType>
// But since we know every property types,
// create vector for each type
CSSVector<AnimationStateProperty<ZIndex>> m_ZIndexActiveAnimState;
// Iterates them for every CSSVector types