EnTT Entity Component System

The entt::organizer class template allows you to build an execution graph from a set of functions and their resource requirements. This graph can be used to safely schedule tasks in parallel.

Registering Tasks

Functions can be free functions, member functions, or lambdas. Supported parameters include:

• entt::registry (or const entt::registry &)
• entt::basic_view (any combination of storage classes)
• A context variable of type T (or const T &)

Resource Management

When a function is registered, the organizer treats its parameters as resources. The const qualifier determines if access is Read-Only (RO) or Read-Write (RW). You can explicitly declare additional resources or override access modes via template parameters.

Workflow

1. Emplace tasks into the organizer.
2. Generate the graph using .graph().
3. Prepare the registry for execution using the graph's prepare function.
4. Schedule the tasks using your own preferred scheduler.

```cpp
entt::organizer organizer;

// 1. Register tasks
organizer.emplace<&free_function>(

EnTT provides entt::sigh (signals) to manage event listeners. To maintain a clean API, it is recommended to keep the signal as a private member and expose a entt::sink to clients. The sink is the tool used to connect and disconnect listeners.

Key Concepts:

• Signal (entt::sigh<Signature>): The object that holds the listeners and triggers them.
• Sink (entt::sink): The interface used to manage connections (connect/disconnect) to a signal.
• Connection: connect returns a connection object. You can call .release() on it to disconnect, or wrap it in a scoped_connection to disconnect automatically when it goes out of scope.

Listener Types:

• Free functions.
• Member functions (requires an instance).
• Lambdas and functors.

entt::sigh<void(int, char)> signal;
entt::sink sink{signal};

void foo(int, char) { /* ... */ }
struct listener {
    void bar(const int &, char) { /* ... */ }
};

listener instance;

sink.connect<&foo>();
sink.connect<&listener::bar>(instance);

sink.disconnect<&foo>();
sink.disconnect<&listener::bar>(instance);
sink.disconnect(&instance);
sink.disconnect(); // Discards all listeners

An entt::handle is a thin, non-owning wrapper around an entity and a registry. It replicates the entt::registry API (e.g., get, emplace) but implicitly passes the wrapped entity to every call.

• Validity: A default-constructed handle is invalid (contains a null registry/entity). Use its implicit conversion to bool to check validity.
• Mutability: Handles are trivially copyable. Because they are non-owning, mutability is part of the type (entt::handle vs entt::const_handle).
• Customization: You can create custom handles for your own identifier types using entt::basic_handle.

// Standard handles
entt::handle handle{registry, entity};

// Custom handles for custom identifiers
using my_handle = entt::basic_handle<entt::basic_registry<my_identifier>>;
using my_const_handle = entt::basic_handle<const entt::basic_registry<my_identifier>>;

// Check validity
if (handle) {
    handle.get<position>();
}

An entt::delegate is a general-purpose invoker designed to be a lightweight alternative to std::function. It provides zero memory overhead for free functions, lambdas, and member functions (when provided with an instance).

Key Characteristics:

• No Allocations: Unlike std::function, it avoids hidden memory allocations.
• Signature Flexibility: It supports functions with shorter argument lists than the delegate's signature (extra arguments are silently discarded). It also supports "payload" functions where the first argument is a reference to data passed during connection.
• Safety: Invoking an empty delegate results in undefined behavior or a crash. Always check if a delegate is valid using if(delegate) before calling it.
• Resetting: Use .reset() to clear a delegate; there is no disconnect method for individual delegates.

// Create an empty delegate for a specific signature
entt::delegate<int(int)> delegate{};

// Check if it is valid before use
if(delegate) {
    auto ret = delegate(42);
}

// Clear the delegate
delegate.reset();

By default, a view iterates along the pool that contains the smallest number of elements to minimize work. The order of types in the template arguments does not affect the iteration order.

Enforcing Order

If you need to force the view to iterate based on a specific component's pool, use the .use<T>() method.

Reverse Iteration

Single type views support reverse iteration via rbegin() and rend(). Multi-type views do not support reverse iterators; you must implement this manually or use a single-type view to lead the iteration.

// Default: iterates the smallest pool
for(auto entity: registry.view<position, velocity>()) { 
    // ...
}

// Enforce iteration based on position pool
auto view = registry.view<position, velocity>();
view.use<position>();
for(auto entity: view) { 
    // ...
}

// Reverse iteration (Single type views only)
auto view = registry.view<position>();
for(auto it = view.rbegin(), last = view.rend(); it != last; ++it) {
    // ...
}

The entt::flow builder does not have an explicit before() or after() API. Instead, execution order is determined by resource access modes. To force a specific order, you can use fake resources.

• To force Task A to run BEFORE Task B: Have Task A request a fake resource in rw (read-write) mode, and have Task B request the same fake resource in ro (read-only) mode.
• To force Task B to run AFTER a group of tasks: Have the group of tasks request a fake resource in ro mode, and have Task B request that same fake resource in rw mode.

This works because accessing a resource in opposite modes (one rw, one ro) requires sequential scheduling rather than parallel execution.

// Force task_1 to run BEFORE task_2 and task_3
builder
    .bind("task_1"_hs)
        .ro("resource_1"_hs)
        .rw("fake"_hs)
    .bind("task_2"_hs)
        .ro("resource_2"_hs)
        .ro("fake"_hs)
    .bind("task_3"_hs)
        .ro("resource_2"_hs)
        .ro("fake"_hs);

// Force task_3 to run AFTER task_1 and task_2
builder
    .bind("task_1"_hs)
        .ro("resource_1"_hs)
        .ro("fake"_hs)
    .bind("task_2"_hs)
        .ro("resource_1"_hs)
        .ro("fake"_hs)
    .bind("task_3"_hs)
        .ro("resource_2"_hs)
        .rw("fake"_hs);