pico_ecs.h

Go to the documentation of this file.

 
#ifndef PICO_ECS_H
#define PICO_ECS_H
 
#include <stdbool.h> // bool, true, false
#include <stddef.h>  // size_t
#include <stdint.h>  // uint32_t
#include <limits.h>  // SIZE_MAX
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct ecs_s ecs_t;
 
#ifndef ECS_ID_TYPE
#define ECS_ID_TYPE uint64_t
#endif
 
typedef ECS_ID_TYPE ecs_id_t;
 
#ifndef ECS_MASK_TYPE
#define ECS_MASK_TYPE uint64_t
#endif
 
typedef ECS_MASK_TYPE ecs_mask_t;
 
typedef int32_t ecs_ret_t;
 
typedef struct ecs_entity_t { ecs_id_t id; } ecs_entity_t;
 
typedef struct ecs_comp_t { ecs_id_t id; } ecs_comp_t;
 
typedef struct ecs_system_t { ecs_id_t id; } ecs_system_t;
 
#define ECS_INVALID_ID ((ecs_id_t)-1)
 
#define ECS_IS_INVALID(obj) ((obj.id) == ECS_INVALID_ID)
 
ecs_t* ecs_new(size_t entity_count, void* mem_ctx);
 
void ecs_free(ecs_t* ecs);
 
void ecs_reset(ecs_t* ecs);
 
typedef void (*ecs_constructor_fn)(ecs_t* ecs,
                                   ecs_entity_t entity,
                                   void* comp_ptr,
                                   void* args);
 
typedef void (*ecs_destructor_fn)(ecs_t* ecs,
                                  ecs_entity_t entity,
                                  void* comp_ptr);
 
ecs_comp_t ecs_define_component(ecs_t* ecs,
                                size_t size,
                                ecs_constructor_fn constructor,
                                ecs_destructor_fn destructor);
 
typedef ecs_ret_t (*ecs_system_fn)(ecs_t* ecs,
                                   ecs_entity_t* entities,
                                   size_t entity_count,
                                   void* udata);
 
typedef void (*ecs_added_fn)(ecs_t* ecs, ecs_entity_t entity, void* udata);
 
typedef void (*ecs_removed_fn)(ecs_t* ecs, ecs_entity_t entity, void* udata);
 
ecs_system_t ecs_define_system(ecs_t* ecs,
                               ecs_mask_t mask,
                               ecs_system_fn system_cb,
                               ecs_added_fn add_cb,
                               ecs_removed_fn remove_cb,
                               void* udata);
void ecs_require_component(ecs_t* ecs, ecs_system_t sys, ecs_comp_t comp);
 
void ecs_exclude_component(ecs_t* ecs, ecs_system_t sys, ecs_comp_t comp);
 
void ecs_enable_system(ecs_t* ecs, ecs_system_t sys);
 
void ecs_disable_system(ecs_t* ecs, ecs_system_t sys);
 
void ecs_set_system_callbacks(ecs_t* ecs,
                              ecs_system_t sys,
                              ecs_system_fn system_cb,
                              ecs_added_fn add_cb,
                              ecs_removed_fn remove_cb);
 
void ecs_set_system_udata(ecs_t* ecs, ecs_system_t sys, void* udata);
 
void* ecs_get_system_udata(ecs_t* ecs, ecs_system_t sys);
 
void ecs_set_system_mask(ecs_t* ecs, ecs_system_t sys, ecs_mask_t mask);
 
ecs_mask_t ecs_get_system_mask(ecs_t* ecs, ecs_system_t sys);
 
size_t ecs_get_system_entity_count(ecs_t* ecs, ecs_system_t sys);
 
ecs_entity_t ecs_create(ecs_t* ecs);
 
bool ecs_is_ready(ecs_t* ecs, ecs_entity_t entity);
 
bool ecs_has(ecs_t* ecs, ecs_entity_t entity, ecs_comp_t comp);
 
void* ecs_add(ecs_t* ecs, ecs_entity_t entity, ecs_comp_t comp, void* args);
 
void* ecs_get(ecs_t* ecs, ecs_entity_t entity, ecs_comp_t comp);
 
void ecs_destroy(ecs_t* ecs, ecs_entity_t entity);
 
void ecs_remove(ecs_t* ecs, ecs_entity_t entity, ecs_comp_t comp);
 
ecs_ret_t ecs_run_system(ecs_t* ecs, ecs_system_t sys, ecs_mask_t mask);
 
ecs_ret_t ecs_run_systems(ecs_t* ecs, ecs_mask_t mask);
 
#ifdef __cplusplus
}
#endif
 
#endif // PICO_ECS_H
 
#ifdef PICO_ECS_IMPLEMENTATION // Define once
 
#ifndef PICO_ECS_MAX_COMPONENTS
#define PICO_ECS_MAX_COMPONENTS 32
#endif
 
#ifndef PICO_ECS_MAX_SYSTEMS
#define PICO_ECS_MAX_SYSTEMS 16
#endif
 
#ifdef NDEBUG
    #define PICO_ECS_ASSERT(expr) ((void)0)
#else
    #ifndef PICO_ECS_ASSERT
        #include <assert.h>
        #define PICO_ECS_ASSERT(expr) (assert(expr))
    #endif
#endif
 
#if !defined(PICO_ECS_MALLOC) || !defined(PICO_ECS_REALLOC) || !defined(PICO_ECS_FREE)
#include <stdlib.h>
#define PICO_ECS_MALLOC(size, ctx)       (malloc(size))
#define PICO_ECS_REALLOC(ptr, size, ctx) (realloc(ptr, size))
#define PICO_ECS_FREE(ptr, ctx)          (free(ptr))
#endif
 
#ifndef PICO_ECS_MEMSET
    #include <string.h>
    #define PICO_ECS_MEMSET memset
#endif
 
/*=============================================================================
 *  Aliases
 *============================================================================*/
 
#define ECS_ASSERT          PICO_ECS_ASSERT
#define ECS_MAX_COMPONENTS  PICO_ECS_MAX_COMPONENTS
#define ECS_MAX_SYSTEMS     PICO_ECS_MAX_SYSTEMS
#define ECS_MALLOC          PICO_ECS_MALLOC
#define ECS_REALLOC         PICO_ECS_REALLOC
#define ECS_FREE            PICO_ECS_FREE
#define ECS_MEMSET          PICO_ECS_MEMSET
 
/*=============================================================================
 *  Data structures
 *============================================================================*/
 
#if ECS_MAX_COMPONENTS <= 32
typedef uint32_t ecs_bitset_t;
#elif ECS_MAX_COMPONENTS <= 64
typedef uint64_t ecs_bitset_t;
#else
#define ECS_BITSET_WIDTH 64
#define ECS_BITSET_SIZE (((ECS_MAX_COMPONENTS - 1) / ECS_BITSET_WIDTH) + 1)
 
typedef struct
{
    uint64_t array[ECS_BITSET_SIZE];
} ecs_bitset_t;
 
#endif // ECS_MAX_COMPONENTS
 
// Data-structure for a packed array implementation that provides O(1) functions
// for adding, removing, and accessing entity IDs
typedef struct
{
    size_t        capacity;
    size_t        size;
    size_t*       sparse;
    ecs_entity_t* dense;
} ecs_sparse_set_t;
 
// A data-structure for providing O(1) operations for working with IDs
typedef struct
{
    size_t    capacity;
    size_t    size; // array size
    ecs_id_t* data;
} ecs_id_array_t;
 
typedef struct
{
    size_t capacity;
    size_t size; // component size
    void*  data;
} ecs_comp_array_t;
 
typedef struct
{
    ecs_bitset_t comp_bits;
    bool         active;
    bool         ready;
} ecs_entity_data_t;
 
typedef struct
{
    ecs_constructor_fn constructor;
    ecs_destructor_fn  destructor;
} ecs_comp_data_t;
 
typedef struct
{
    bool             active;
    ecs_sparse_set_t entity_ids;
    ecs_mask_t       mask;
    ecs_system_fn    system_cb;
    ecs_added_fn     add_cb;
    ecs_removed_fn   remove_cb;
    ecs_bitset_t     require_bits;
    ecs_bitset_t     exclude_bits;
    void*            udata;
} ecs_sys_data_t;
 
struct ecs_s
{
    ecs_id_array_t     entity_pool;
    ecs_id_array_t     add_queue;
    ecs_id_array_t     remove_queue;
    ecs_id_array_t     destroy_queue;
    ecs_entity_data_t* entities;
    size_t             entity_count;
    size_t             next_entity_id;
    ecs_comp_data_t    comps[ECS_MAX_COMPONENTS];
    ecs_comp_array_t   comp_arrays[ECS_MAX_COMPONENTS];
    size_t             comp_count;
    ecs_sys_data_t     systems[ECS_MAX_SYSTEMS];
    size_t             system_count;
    int                active_system;
    void*              mem_ctx;
};
 
/*=============================================================================
 * Handle constructors
 *============================================================================*/
static inline ecs_entity_t ecs_make_entity(ecs_id_t id);
static inline ecs_comp_t ecs_make_comp(ecs_id_t id);
static inline ecs_system_t ecs_make_system(ecs_id_t id);
 
/*=============================================================================
 * Realloc wrapper
 *============================================================================*/
static void* ecs_realloc_zero(ecs_t* ecs, void* ptr, size_t old_size, size_t new_size);
 
/*=============================================================================
 * Calls destructors on all components of the entity
 *============================================================================*/
static void ecs_destruct(ecs_t* ecs, ecs_id_t entity);
 
/*=============================================================================
 * Tests if entity is active (created)
 *============================================================================*/
static inline bool ecs_is_active(ecs_t* ecs, ecs_id_t entity_id);
 
/*=============================================================================
 * Functions to flush destroyed entities and removed component
 *============================================================================*/
static void ecs_flush_added(ecs_t* ecs, ecs_id_t sys_id);
static void ecs_flush_removed(ecs_t* ecs, ecs_id_t sys_id);
static void ecs_flush_destroyed(ecs_t* ecs, ecs_id_t sys_id);
 
/*=============================================================================
 * Bitset functions
 *============================================================================*/
static inline void ecs_bitset_flip(ecs_bitset_t* set, int bit, bool on);
static inline bool ecs_bitset_is_zero(ecs_bitset_t* set);
static inline bool ecs_bitset_test(ecs_bitset_t* set, int bit);
static inline ecs_bitset_t ecs_bitset_and(ecs_bitset_t* set1, ecs_bitset_t* set2);
static inline ecs_bitset_t ecs_bitset_or(ecs_bitset_t* set1, ecs_bitset_t* set2);
static inline ecs_bitset_t ecs_bitset_not(ecs_bitset_t* set);
static inline bool ecs_bitset_equal(ecs_bitset_t* set1, ecs_bitset_t* set2);
static inline bool ecs_bitset_true(ecs_bitset_t* set);
 
/*=============================================================================
 * Sparse set functions
 *============================================================================*/
static void ecs_sparse_set_init(ecs_t* ecs, ecs_sparse_set_t* set, size_t capacity);
static void ecs_sparse_set_free(ecs_t* ecs, ecs_sparse_set_t* set);
static bool ecs_sparse_set_add(ecs_t* ecs, ecs_sparse_set_t* set, ecs_id_t id);
static inline bool ecs_sparse_set_find(ecs_sparse_set_t* set, ecs_id_t id, size_t* found);
static inline bool ecs_sparse_set_remove(ecs_sparse_set_t* set, ecs_id_t id);
 
/*=============================================================================
 * System entity add/remove functions
 *============================================================================*/
static bool ecs_entity_system_test(ecs_bitset_t* require_bits,
                                   ecs_bitset_t* exclude_bits,
                                   ecs_bitset_t* entity_bits);
 
static bool ecs_entity_system_remove_test(ecs_bitset_t* require_bits,
                                          ecs_bitset_t* exclude_bits,
                                          ecs_bitset_t* entity_bits);
 
/*=============================================================================
 * ID array functions
 *============================================================================*/
static void   ecs_id_array_init(ecs_t* ecs, ecs_id_array_t* pool, size_t capacity);
static void   ecs_id_array_free(ecs_t* ecs, ecs_id_array_t* pool);
static inline void  ecs_id_array_push(ecs_t* ecs, ecs_id_array_t* pool, ecs_id_t id);
static inline ecs_id_t ecs_id_array_pop(ecs_id_array_t* pool);
static int    ecs_id_array_size(ecs_id_array_t* pool);
 
/*=============================================================================
 * Component array functions
 *============================================================================*/
static void ecs_comp_array_init(ecs_t* ecs, ecs_comp_array_t* array, size_t size, size_t capacity);
static void ecs_comp_array_free(ecs_t* ecs, ecs_comp_array_t* array);
static void ecs_comp_array_resize(ecs_t* ecs, ecs_comp_array_t* array, ecs_id_t id);
 
/*=============================================================================
 * Validation functions
 *============================================================================*/
#ifndef NDEBUG
static bool ecs_is_not_null(void* ptr);
static bool ecs_is_valid_component_id(ecs_id_t id);
static bool ecs_is_valid_system_id(ecs_id_t id);
static bool ecs_is_valid_id(ecs_id_t id);
static bool ecs_is_valid_capacity(size_t capacity, size_t elem_size);
static bool ecs_is_entity_ready(ecs_t* ecs, ecs_id_t entity_id);
static bool ecs_is_component_ready(ecs_t* ecs, ecs_id_t comp_id);
static bool ecs_is_system_ready(ecs_t* ecs, ecs_id_t sys_id);
#endif // NDEBUG
 
/*=============================================================================
 * Public API implementation
 *============================================================================*/
 
ecs_t* ecs_new(size_t entity_count, void* mem_ctx)
{
    ECS_ASSERT(entity_count > 0);
    ECS_ASSERT(!ecs_is_valid_id(ECS_INVALID_ID) && "ecs_id_t is signed");
 
    ecs_t* ecs = (ecs_t*)ECS_MALLOC(sizeof(ecs_t), mem_ctx);
 
    // Out of memory
    if (NULL == ecs)
        return NULL;
 
    ECS_MEMSET(ecs, 0, sizeof(ecs_t));
 
    ecs->entity_count   = (entity_count > 0) ? entity_count : 1;
    ecs->next_entity_id = 0;
    ecs->active_system  = -1;
    ecs->mem_ctx        = mem_ctx;
 
    // Initialize entity pool and queues
    ecs_id_array_init(ecs, &ecs->entity_pool,   entity_count);
    ecs_id_array_init(ecs, &ecs->add_queue,     entity_count);
    ecs_id_array_init(ecs, &ecs->remove_queue,  entity_count);
    ecs_id_array_init(ecs, &ecs->destroy_queue, entity_count);
 
    // Allocate entity array
    ECS_ASSERT(ecs_is_valid_capacity(ecs->entity_count, sizeof(ecs_entity_data_t)));
    ecs->entities = (ecs_entity_data_t*)ECS_MALLOC(ecs->entity_count * sizeof(ecs_entity_data_t),
                                                   ecs->mem_ctx);
 
    // Zero entity array
    ECS_MEMSET(ecs->entities, 0, ecs->entity_count * sizeof(ecs_entity_data_t));
 
    return ecs;
}
 
void ecs_free(ecs_t* ecs)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
 
    for (ecs_id_t entity_id = 0; entity_id < ecs->entity_count; entity_id++)
    {
        if (ecs->entities[entity_id].active)
            ecs_destruct(ecs, entity_id);
    }
 
    ecs_id_array_free(ecs, &ecs->entity_pool);
    ecs_id_array_free(ecs, &ecs->add_queue);
    ecs_id_array_free(ecs, &ecs->remove_queue);
    ecs_id_array_free(ecs, &ecs->destroy_queue);
 
    for (ecs_id_t comp_id = 0; comp_id < ecs->comp_count; comp_id++)
    {
        ecs_comp_array_t* comp_array = &ecs->comp_arrays[comp_id];
        ecs_comp_array_free(ecs, comp_array);
    }
 
    for (ecs_id_t sys_id = 0; sys_id < ecs->system_count; sys_id++)
    {
        ecs_sys_data_t* sys = &ecs->systems[sys_id];
        ecs_sparse_set_free(ecs, &sys->entity_ids);
    }
 
    ECS_FREE(ecs->entities, ecs->mem_ctx);
    ECS_FREE(ecs, ecs->mem_ctx);
}
 
void ecs_reset(ecs_t* ecs)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
 
    for (ecs_id_t entity_id = 0; entity_id < ecs->entity_count; entity_id++)
    {
        if (ecs->entities[entity_id].active)
            ecs_destruct(ecs, entity_id);
    }
 
    ecs->entity_pool.size   = 0;
    ecs->add_queue.size     = 0;
    ecs->destroy_queue.size = 0;
    ecs->remove_queue.size  = 0;
 
    ECS_MEMSET(ecs->entities, 0, ecs->entity_count * sizeof(ecs_entity_data_t));
 
    ecs->next_entity_id = 0;
 
    for (ecs_id_t sys_id = 0; sys_id < ecs->system_count; sys_id++)
    {
        ecs->systems[sys_id].entity_ids.size = 0;
    }
}
 
ecs_comp_t ecs_define_component(ecs_t* ecs,
                                size_t size,
                                ecs_constructor_fn constructor,
                                ecs_destructor_fn destructor)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs->comp_count < ECS_MAX_COMPONENTS);
    ECS_ASSERT(size > 0);
 
    ecs_comp_t comp = ecs_make_comp(ecs->comp_count);
 
    ecs_comp_array_t* comp_array = &ecs->comp_arrays[comp.id];
    ecs_comp_array_init(ecs, comp_array, size, ecs->entity_count);
 
    ecs->comps[comp.id].constructor = constructor;
    ecs->comps[comp.id].destructor = destructor;
 
    ecs->comp_count++;
 
    return comp;
}
 
ecs_system_t ecs_define_system(ecs_t* ecs,
                               ecs_mask_t mask,
                               ecs_system_fn system_cb,
                               ecs_added_fn add_cb,
                               ecs_removed_fn remove_cb,
                               void* udata)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs->system_count < ECS_MAX_SYSTEMS);
    ECS_ASSERT(NULL != system_cb);
 
    ecs_system_t sys = ecs_make_system(ecs->system_count);
    ecs_sys_data_t* sys_data = &ecs->systems[sys.id];
 
    ecs_sparse_set_init(ecs, &sys_data->entity_ids, ecs->entity_count);
 
    sys_data->active = true;
    sys_data->mask = mask;
    sys_data->system_cb = system_cb;
    sys_data->add_cb = add_cb;
    sys_data->remove_cb = remove_cb;
    sys_data->udata = udata;
 
    ecs->system_count++;
 
    return sys;
}
 
void ecs_require_component(ecs_t* ecs, ecs_system_t sys, ecs_comp_t comp)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_valid_system_id(sys.id));
    ECS_ASSERT(ecs_is_valid_component_id(comp.id));
    ECS_ASSERT(ecs_is_system_ready(ecs, sys.id));
    ECS_ASSERT(ecs_is_component_ready(ecs, comp.id));
 
    // Set system component bit for the specified component
    ecs_sys_data_t* sys_data = &ecs->systems[sys.id];
    ecs_bitset_flip(&sys_data->require_bits, comp.id, true);
}
 
void ecs_exclude_component(ecs_t* ecs, ecs_system_t sys, ecs_comp_t comp)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_valid_system_id(sys.id));
    ECS_ASSERT(ecs_is_valid_component_id(comp.id));
    ECS_ASSERT(ecs_is_system_ready(ecs, sys.id));
    ECS_ASSERT(ecs_is_component_ready(ecs, comp.id));
 
    // Set system component bit for the specified component
    ecs_sys_data_t* sys_data = &ecs->systems[sys.id];
    ecs_bitset_flip(&sys_data->exclude_bits, comp.id, true);
}
 
void ecs_enable_system(ecs_t* ecs, ecs_system_t sys)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_valid_system_id(sys.id));
    ECS_ASSERT(ecs_is_system_ready(ecs, sys.id));
 
    ecs_sys_data_t* sys_data = &ecs->systems[sys.id];
    sys_data->active = true;
}
 
void ecs_disable_system(ecs_t* ecs, ecs_system_t sys)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_valid_system_id(sys.id));
    ECS_ASSERT(ecs_is_system_ready(ecs, sys.id));
 
    ecs_sys_data_t* sys_data = &ecs->systems[sys.id];
    sys_data->active = false;
}
 
void ecs_set_system_callbacks(ecs_t* ecs,
                              ecs_system_t sys,
                              ecs_system_fn system_cb,
                              ecs_added_fn add_cb,
                              ecs_removed_fn remove_cb)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_valid_system_id(sys.id));
    ECS_ASSERT(ecs_is_system_ready(ecs, sys.id));
    ECS_ASSERT(NULL != system_cb);
 
    ecs_sys_data_t* sys_data = &ecs->systems[sys.id];
    sys_data->system_cb = system_cb;
    sys_data->add_cb = add_cb;
    sys_data->remove_cb = remove_cb;
}
 
void ecs_set_system_udata(ecs_t* ecs, ecs_system_t sys, void* udata)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_valid_system_id(sys.id));
    ECS_ASSERT(ecs_is_system_ready(ecs, sys.id));
 
    ecs->systems[sys.id].udata = udata;
}
 
void* ecs_get_system_udata(ecs_t* ecs, ecs_system_t sys)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_valid_system_id(sys.id));
    ECS_ASSERT(ecs_is_system_ready(ecs, sys.id));
 
    return ecs->systems[sys.id].udata;
}
 
void ecs_set_system_mask(ecs_t* ecs, ecs_system_t sys, ecs_mask_t mask)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_valid_system_id(sys.id));
    ECS_ASSERT(ecs_is_system_ready(ecs, sys.id));
 
    ecs->systems[sys.id].mask = mask;
}
 
ecs_mask_t ecs_get_system_mask(ecs_t* ecs, ecs_system_t sys)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_valid_system_id(sys.id));
    ECS_ASSERT(ecs_is_system_ready(ecs, sys.id));
 
    return ecs->systems[sys.id].mask;
}
 
size_t ecs_get_system_entity_count(ecs_t* ecs, ecs_system_t sys)
{
    return ecs->systems[sys.id].entity_ids.size;
}
 
ecs_entity_t ecs_create(ecs_t* ecs)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
 
    ecs_id_t entity_id = 0;
 
    // If there is an ID in the pool, pop it
    ecs_id_array_t* pool = &ecs->entity_pool;
 
    if (0 != ecs_id_array_size(pool))
    {
        entity_id = ecs_id_array_pop(pool);
    }
    else
    {
        // Otherwise, issue a fresh ID
        entity_id = ecs->next_entity_id++;
 
        // Grow the entities array if necessary
        if (entity_id >= ecs->entity_count)
        {
            size_t old_count = ecs->entity_count;
            size_t new_count = 2 * old_count;
 
            ECS_ASSERT(ecs_is_valid_capacity(new_count, sizeof(ecs_entity_data_t)));
            ecs->entities = (ecs_entity_data_t*)ecs_realloc_zero(ecs, ecs->entities,
                                                                 old_count * sizeof(ecs_entity_data_t),
                                                                 new_count * sizeof(ecs_entity_data_t));
 
            ecs->entity_count = new_count;
        }
    }
 
    // Activate the entity and return a handle
    ecs->entities[entity_id].active = true;
    ecs->entities[entity_id].ready  = true;
 
    return ecs_make_entity(entity_id);
}
 
bool ecs_is_ready(ecs_t* ecs, ecs_entity_t entity)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
 
    return ecs->entities[entity.id].ready;
}
 
void ecs_destroy(ecs_t* ecs, ecs_entity_t entity)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_valid_id(entity.id));
    ECS_ASSERT(ecs_is_active(ecs, entity.id));
 
    // Load entity data
    ecs_entity_data_t* entity_data = &ecs->entities[entity.id];
 
    // Remove entity from systems
    for (ecs_id_t sys_id = 0; sys_id < ecs->system_count; sys_id++)
    {
        // Skip if the system is active and matches the current system ID. This
        // system will be processed below
        if (ecs->active_system == (int)sys_id)
            continue;
 
        ecs_sys_data_t* sys_data = &ecs->systems[sys_id];
 
        // Test to see if entity's components matches the system
        if (ecs_entity_system_test(&sys_data->require_bits,
                                   &sys_data->exclude_bits,
                                   &entity_data->comp_bits))
        {
            // Directly remove from sparse set since no system is being
            // processed
            if (ecs_sparse_set_remove(&sys_data->entity_ids, entity.id))
            {
                if (sys_data->remove_cb)
                    sys_data->remove_cb(ecs, entity, sys_data->udata);
            }
        }
    }
 
    // True if a system is being processed
    if (ecs->active_system >= 0)
    {
        ecs_sys_data_t* sys_data = &ecs->systems[ecs->active_system];
 
            // Test to see if entity's components matches the system
        if (ecs_entity_system_test(&sys_data->require_bits,
                                   &sys_data->exclude_bits,
                                   &entity_data->comp_bits))
        {
            // Since a system is being processed we need to protect its sparse
            // set, so we queue a removed command
            if (ecs_sparse_set_find(&sys_data->entity_ids, entity.id, NULL))
            {
                if (sys_data->remove_cb)
                    sys_data->remove_cb(ecs, entity, sys_data->udata);
 
                ecs_id_array_push(ecs, &ecs->destroy_queue, entity.id);
 
                entity_data->ready = false;
                entity_data->active = true;
            }
        }
    }
 
    // Call destructors on entity components
    ecs_destruct(ecs, entity.id);
 
    // If a system is not active, then clean up
    if (ecs->active_system < 0)
    {
        // Push entity ID into pool
        ecs_id_array_t* pool = &ecs->entity_pool;
        ecs_id_array_push(ecs, pool, entity.id);
 
        // Reset entity (sets bitset to 0 and, active and ready to false)
        ECS_MEMSET(entity_data, 0, sizeof(ecs_entity_data_t));
    }
}
 
bool ecs_has(ecs_t* ecs, ecs_entity_t entity, ecs_comp_t comp)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_valid_id(entity.id));
    ECS_ASSERT(ecs_is_valid_component_id(comp.id));
    ECS_ASSERT(ecs_is_entity_ready(ecs, entity.id));
 
    // Load entity data
    ecs_entity_data_t* entity_data = &ecs->entities[entity.id];
 
    // Return true if the component belongs to the entity
    return ecs_bitset_test(&entity_data->comp_bits, comp.id);
}
 
void* ecs_get(ecs_t* ecs, ecs_entity_t entity, ecs_comp_t comp)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_valid_id(entity.id));
    ECS_ASSERT(ecs_is_valid_component_id(comp.id));
    ECS_ASSERT(ecs_is_component_ready(ecs, comp.id));
    ECS_ASSERT(ecs_is_entity_ready(ecs, entity.id));
 
    // Return pointer to component
    //  eid0,  eid1   eid2, ...
    // [comp0, comp1, comp2, ...]
    ecs_comp_array_t* comp_array = &ecs->comp_arrays[comp.id];
    return (char*)comp_array->data + (comp_array->size * entity.id);
}
 
void* ecs_add(ecs_t* ecs, ecs_entity_t entity, ecs_comp_t comp, void* args)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_valid_id(entity.id));
    ECS_ASSERT(ecs_is_valid_component_id(comp.id));
    ECS_ASSERT(ecs_is_entity_ready(ecs, entity.id));
    ECS_ASSERT(ecs_is_component_ready(ecs, comp.id));
 
    // Load entity data
    ecs_entity_data_t* entity_data = &ecs->entities[entity.id];
 
    // Load component
    ecs_comp_array_t* comp_array = &ecs->comp_arrays[comp.id];
    ecs_comp_data_t* comp_data = &ecs->comps[comp.id];
 
    // Grow the component array
    ecs_comp_array_resize(ecs, comp_array, entity.id);
 
    // Get pointer to component
    void* comp_ptr = ecs_get(ecs, entity, comp);
 
    // Zero component
    ECS_MEMSET(comp_ptr, 0, comp_array->size);
 
    // Call constructor
    if (comp_data->constructor)
        comp_data->constructor(ecs, entity, comp_ptr, args);
 
    // Set entity component bit that determines which systems this entity
    // belongs to
    ecs_bitset_flip(&entity_data->comp_bits, comp.id, true);
 
    // Add or remove entity from systems
    for (ecs_id_t sys_id = 0; sys_id < ecs->system_count; sys_id++)
    {
        // Skip if a system is active and matches the current system ID, this
        // system will be processed below
        if (ecs->active_system == (int)sys_id)
            continue;
 
        ecs_sys_data_t* sys_data = &ecs->systems[sys_id];
 
        // Test to see if entity's components matches the system
        if (ecs_entity_system_test(&sys_data->require_bits,
                                   &sys_data->exclude_bits,
                                   &entity_data->comp_bits))
        {
            // Add the entity directly to the sparse set
            if (ecs_sparse_set_add(ecs, &sys_data->entity_ids, entity.id))
            {
                if (sys_data->add_cb)
                    sys_data->add_cb(ecs, entity, sys_data->udata);
            }
        }
        else
        {
            // As a minor optimization, check if the system excludes components
            if (!ecs_bitset_is_zero(&sys_data->exclude_bits))
            {
                // Just remove the entity from the sparse set if its components
                // no longer match
                if (ecs_sparse_set_remove(&sys_data->entity_ids, entity.id))
                {
                    if (sys_data->remove_cb)
                        sys_data->remove_cb(ecs, entity, sys_data->udata);
                }
            }
        }
    }
 
    // True if a system is running
    if (ecs->active_system >= 0)
    {
        // Load active system data
        ecs_sys_data_t* sys_data = &ecs->systems[ecs->active_system];
 
        // Test to see if entity's components matches the system
        if (ecs_entity_system_test(&sys_data->require_bits,
                                   &sys_data->exclude_bits,
                                   &entity_data->comp_bits))
        {
            ecs_sparse_set_t* set = &sys_data->entity_ids;
 
            // If the sparse set has room to grow without allocation,
            // directly add the entity
            if (set->size < set->capacity)
            {
                // Add the entity directly to the sparse set
                if (ecs_sparse_set_add(ecs, set, entity.id))
                {
                    if (sys_data->add_cb)
                        sys_data->add_cb(ecs, entity, sys_data->udata);
                }
            }
            else
            {
                // The sparse set is full, so queue an add command
                if (!ecs_sparse_set_find(set, entity.id, NULL))
                {
                    if (sys_data->add_cb)
                        sys_data->add_cb(ecs, entity, sys_data->udata);
 
                    ecs_id_array_push(ecs, &ecs->add_queue, entity.id);
                }
            }
        }
        else
        {
            // As a minor optimization, check if the system excludes components
            if (!ecs_bitset_is_zero(&sys_data->exclude_bits))
            {
                // Since we are updating the active system, we need to protect
                // the sparse set. Thus, if the entity is in the set, queue
                // a remove command
                if (ecs_sparse_set_find(&sys_data->entity_ids, entity.id, NULL))
                {
                    if (sys_data->remove_cb)
                        sys_data->remove_cb(ecs, entity, sys_data->udata);
 
                    ecs_id_array_push(ecs, &ecs->remove_queue, entity.id);
                }
            }
        }
    }
 
    // Return component
    return comp_ptr;
}
 
void ecs_remove(ecs_t* ecs, ecs_entity_t entity, ecs_comp_t comp)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_valid_id(entity.id));
    ECS_ASSERT(ecs_is_valid_component_id(comp.id));
    ECS_ASSERT(ecs_is_component_ready(ecs, comp.id));
    ECS_ASSERT(ecs_is_entity_ready(ecs, entity.id));
 
    // Load entity data
    ecs_entity_data_t* entity_data = &ecs->entities[entity.id];
 
    // Create bit mask with comp bit flipped on
    ecs_bitset_t comp_bit;
 
    ECS_MEMSET(&comp_bit, 0, sizeof(ecs_bitset_t));
    ecs_bitset_flip(&comp_bit, comp.id, true);
 
    // Add or remove entity from systems
    for (ecs_id_t sys_id = 0; sys_id < ecs->system_count; sys_id++)
    {
        // Skip if the system is active and matches the current system ID. This
        // system will be processed below
        if (ecs->active_system == (int)sys_id)
            continue;
 
        ecs_sys_data_t* sys_data = &ecs->systems[sys_id];
 
        // Test to see if entity's components matches the system
        if (ecs_entity_system_remove_test(&sys_data->require_bits,
                                          &sys_data->exclude_bits,
                                          &comp_bit))
        {
            // No system is running, so we can directly remove the entity
            if (ecs_sparse_set_remove(&sys_data->entity_ids, entity.id))
            {
                if (sys_data->remove_cb)
                    sys_data->remove_cb(ecs, entity, sys_data->udata);
            }
        }
        else
        {
            // As a minor optimization, check if the system excludes components
            if (!ecs_bitset_is_zero(&sys_data->exclude_bits))
            {
                // No system is running, so we can add the entity directly
                if (ecs_sparse_set_add(ecs, &sys_data->entity_ids, entity.id))
                {
                    if (sys_data->add_cb)
                        sys_data->add_cb(ecs, entity, sys_data->udata);
                }
            }
        }
    }
 
    // True if a system is running
    if (ecs->active_system >= 0)
    {
        // Load active system data
        ecs_sys_data_t* sys_data = &ecs->systems[ecs->active_system];
 
        // Test to see if entity's components matches the system
        if (ecs_entity_system_remove_test(&sys_data->require_bits,
                                          &sys_data->exclude_bits,
                                          &comp_bit))
        {
            // Since we are updating the active system, we need to protect
            // the sparse set. Thus, if the entity is in the set, queue
            // a remove command
 
            if (ecs_sparse_set_find(&sys_data->entity_ids, entity.id, NULL))
            {
                if (sys_data->remove_cb)
                    sys_data->remove_cb(ecs, entity, sys_data->udata);
 
                ecs_id_array_push(ecs, &ecs->remove_queue, entity.id);
            }
        }
        else
        {
            // As a minor optimization, check if the system excludes components
            if (!ecs_bitset_is_zero(&sys_data->exclude_bits))
            {
                ecs_sparse_set_t* set = &sys_data->entity_ids;
 
                // If the sparse set has room to grow without allocation,
                // directly add the entity
                if (set->size < set->capacity)
                {
                    if (ecs_sparse_set_add(ecs, set, entity.id))
                    {
                        if (sys_data->add_cb)
                            sys_data->add_cb(ecs, entity, sys_data->udata);
                    }
                }
                else
                {
                    // Sparse set is full, so queue an entity id add command
                    if (!ecs_sparse_set_find(set, entity.id, NULL))
                    {
                        if (sys_data->add_cb)
                            sys_data->add_cb(ecs, entity, sys_data->udata);
 
                        ecs_id_array_push(ecs, &ecs->add_queue, entity.id);
                    }
                }
            }
        }
    }
 
    // Destroy component
    ecs_comp_data_t* comp_data = &ecs->comps[comp.id];
 
    if (comp_data->destructor)
    {
        void* comp_ptr = ecs_get(ecs, entity, comp);
        comp_data->destructor(ecs, entity, comp_ptr);
    }
 
    // Reset the relevant component mask bit
    ecs_bitset_flip(&entity_data->comp_bits, comp.id, false);
}
 
ecs_ret_t ecs_run_system(ecs_t* ecs, ecs_system_t sys, ecs_mask_t mask)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_valid_system_id(sys.id));
    ECS_ASSERT(ecs_is_system_ready(ecs, sys.id));
 
    ecs_sys_data_t* sys_data = &ecs->systems[sys.id];
 
    if (!sys_data->active)
        return 0;
 
    if (0 != sys_data->mask && !(sys_data->mask & mask))
        return 0;
 
    ecs->active_system = (int)sys.id;
 
    ecs_ret_t code = sys_data->system_cb(ecs,
                     sys_data->entity_ids.dense,
                     sys_data->entity_ids.size,
                     sys_data->udata);
 
    ecs_flush_added(ecs, sys.id);
    ecs_flush_removed(ecs, sys.id);
    ecs_flush_destroyed(ecs, sys.id);
 
    ecs->active_system = -1;
 
    return code;
}
 
ecs_ret_t ecs_run_systems(ecs_t* ecs, ecs_mask_t mask)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
 
    for (ecs_id_t sys_id = 0; sys_id < ecs->system_count; sys_id++)
    {
        ecs_system_t sys = ecs_make_system(sys_id);
        ecs_ret_t code = ecs_run_system(ecs, sys, mask);
 
        if (0 != code)
            return code;
    }
 
    return 0;
}
 
/*=============================================================================
 * Handle constructors
 *============================================================================*/
static inline ecs_entity_t ecs_make_entity(ecs_id_t id)
{
    ecs_entity_t entity = { id };
    return entity;
}
 
static inline ecs_comp_t ecs_make_comp(ecs_id_t id)
{
    ecs_comp_t comp = { id };
    return comp;
}
 
static inline ecs_system_t ecs_make_system(ecs_id_t id)
{
    ecs_system_t sys = { id };
    return sys;
}
 
/*=============================================================================
 * Realloc wrapper
 *============================================================================*/
static void* ecs_realloc_zero(ecs_t* ecs, void* ptr, size_t old_size, size_t new_size)
{
    (void)ecs;
 
    ptr = ECS_REALLOC(ptr, new_size, ecs->mem_ctx);
 
    if (new_size > old_size && ptr) {
        size_t diff = new_size - old_size;
        void* start = ((char*)ptr)+ old_size;
        ECS_MEMSET(start, 0, diff);
    }
 
    return ptr;
}
 
/*=============================================================================
 * Tests if entity is active (created)
 *============================================================================*/
static inline bool ecs_is_active(ecs_t* ecs, ecs_id_t entity_id)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    return ecs->entities[entity_id].active;
}
 
/*=============================================================================
 * Calls destructors on all components of the entity
 *============================================================================*/
static void ecs_destruct(ecs_t* ecs, ecs_id_t entity_id)
{
    // Load entity
    ecs_entity_data_t* entity = &ecs->entities[entity_id];
 
    // Loop through components and call the destructors
    for (ecs_id_t comp_id = 0; comp_id < ecs->comp_count; comp_id++)
    {
        if (ecs_bitset_test(&entity->comp_bits, comp_id))
        {
            ecs_comp_data_t* comp = &ecs->comps[comp_id];
 
            if (comp->destructor)
            {
                // Get component pointer directly without ecs_get to avoid
                // ready assertion, since entity may be queued for destruction
                ecs_comp_array_t* comp_array = &ecs->comp_arrays[comp_id];
                void* comp_ptr = (char*)comp_array->data + (comp_array->size * entity_id);
                ecs_entity_t entity = ecs_make_entity(entity_id);
 
                comp->destructor(ecs, entity, comp_ptr);
            }
        }
    }
}
 
/*=============================================================================
 * Functions to flush destroyed entity and removed component
 *============================================================================*/
static void ecs_flush_added(ecs_t* ecs, ecs_id_t sys_id)
{
    ecs_id_array_t* queue = &ecs->add_queue;
 
    for (size_t i = 0; i < queue->size; i++)
    {
        ecs_id_t entity_id = queue->data[i];
 
        ECS_ASSERT(ecs_is_active(ecs, entity_id));
        ecs_sparse_set_add(ecs, &ecs->systems[sys_id].entity_ids, entity_id);
    }
 
    queue->size = 0;
}
 
 static void ecs_flush_removed(ecs_t* ecs, ecs_id_t sys_id)
{
    ecs_id_array_t* remove_queue = &ecs->remove_queue;
 
    for (size_t i = 0; i < remove_queue->size; i++)
    {
        ecs_id_t entity_id = remove_queue->data[i];
 
        ECS_ASSERT(ecs_is_active(ecs, entity_id));
        ecs_sparse_set_remove(&ecs->systems[sys_id].entity_ids, entity_id);
    }
 
    remove_queue->size = 0;
}
 
static void ecs_flush_destroyed(ecs_t* ecs, ecs_id_t sys_id)
{
    ecs_id_array_t* destroy_queue = &ecs->destroy_queue;
 
    for (size_t i = 0; i < destroy_queue->size; i++)
    {
        ecs_id_t entity_id = destroy_queue->data[i];
 
        ECS_ASSERT(ecs_is_active(ecs, entity_id));
        ecs_sparse_set_remove(&ecs->systems[sys_id].entity_ids, entity_id);
 
        // Push entity ID into pool
        ecs_id_array_t* pool = &ecs->entity_pool;
        ecs_id_array_push(ecs, pool, entity_id);
 
        // Reset entity (sets bitset to 0 and, active and ready to false)
        ECS_MEMSET(&ecs->entities[entity_id], 0, sizeof(ecs_entity_data_t));
    }
 
    destroy_queue->size = 0;
}
 
 
/*=============================================================================
 * Bitset functions
 *============================================================================*/
 
#if ECS_MAX_COMPONENTS <= 64
 
static inline bool ecs_bitset_is_zero(ecs_bitset_t* set)
{
    return *set == 0;
}
 
static inline void ecs_bitset_flip(ecs_bitset_t* set, int bit, bool on)
{
    if (on)
        *set |=  ((uint64_t)1 << bit);
    else
        *set &= ~((uint64_t)1 << bit);
}
 
static inline bool ecs_bitset_test(ecs_bitset_t* set, int bit)
{
    return *set & ((uint64_t)1 << bit);
}
 
static inline ecs_bitset_t ecs_bitset_and(ecs_bitset_t* set1, ecs_bitset_t* set2)
{
    return *set1 & *set2;
}
 
static inline ecs_bitset_t ecs_bitset_or(ecs_bitset_t* set1, ecs_bitset_t* set2)
{
    return *set1 | *set2;
}
 
static inline ecs_bitset_t ecs_bitset_not(ecs_bitset_t* set)
{
    return ~(*set);
}
 
static inline bool ecs_bitset_equal(ecs_bitset_t* set1, ecs_bitset_t* set2)
{
    return *set1 == *set2;
}
 
static inline bool ecs_bitset_true(ecs_bitset_t* set)
{
    return *set;
}
 
#else // ECS_MAX_COMPONENTS
 
static inline bool ecs_bitset_is_zero(ecs_bitset_t* set)
{
    for (int i = 0; i < ECS_BITSET_SIZE; i++)
    {
        if (set->array[i] != 0)
            return false;
    }
 
    return true;
}
 
static inline void ecs_bitset_flip(ecs_bitset_t* set, int bit, bool on)
{
    int index = bit / ECS_BITSET_WIDTH;
 
    if (on)
        set->array[index] |=  ((uint64_t)1 << bit % ECS_BITSET_WIDTH);
    else
        set->array[index] &= ~((uint64_t)1 << bit % ECS_BITSET_WIDTH);
}
 
static inline bool ecs_bitset_test(ecs_bitset_t* set, int bit)
{
    int index = bit / ECS_BITSET_WIDTH;
    return set->array[index] & ((uint64_t)1 << bit % ECS_BITSET_WIDTH);
}
 
static inline ecs_bitset_t ecs_bitset_and(ecs_bitset_t* set1,
                                          ecs_bitset_t* set2)
{
    ecs_bitset_t set;
 
    for (int i = 0; i < ECS_BITSET_SIZE; i++)
    {
        set.array[i] = set1->array[i] & set2->array[i];
    }
 
    return set;
}
 
static inline ecs_bitset_t ecs_bitset_or(ecs_bitset_t* set1,
                                         ecs_bitset_t* set2)
{
    ecs_bitset_t set;
 
    for (int i = 0; i < ECS_BITSET_SIZE; i++)
    {
        set.array[i] = set1->array[i] | set2->array[i];
    }
 
    return set;
}
 
static inline ecs_bitset_t ecs_bitset_not(ecs_bitset_t* set)
{
    ecs_bitset_t out;
 
    for (int i = 0; i < ECS_BITSET_SIZE; i++)
    {
        out.array[i] = ~set->array[i];
    }
 
    return out;
}
 
static inline bool ecs_bitset_equal(ecs_bitset_t* set1, ecs_bitset_t* set2)
{
    for (int i = 0; i < ECS_BITSET_SIZE; i++)
    {
        if (set1->array[i] != set2->array[i])
        {
            return false;
        }
    }
 
    return true;
}
 
static inline bool ecs_bitset_true(ecs_bitset_t* set)
{
    for (int i = 0; i < ECS_BITSET_SIZE; i++)
    {
        if (set->array[i])
            return true;
    }
 
    return false;
}
 
#endif // ECS_MAX_COMPONENTS
 
/*=============================================================================
 * Sparse set functions
 *============================================================================*/
 
static void ecs_sparse_set_init(ecs_t* ecs, ecs_sparse_set_t* set, size_t capacity)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_not_null(set));
 
    (void)ecs;
 
    set->capacity = capacity;
    set->size = 0;
 
    ECS_ASSERT(ecs_is_valid_capacity(capacity, sizeof(ecs_entity_t)));
    set->dense  = (ecs_entity_t*)ECS_MALLOC(capacity * sizeof(ecs_entity_t), ecs->mem_ctx);
 
    ECS_ASSERT(ecs_is_valid_capacity(capacity, sizeof(size_t)));
    set->sparse = (size_t*)      ECS_MALLOC(capacity * sizeof(size_t),   ecs->mem_ctx);
 
    ECS_MEMSET(set->sparse, 0, capacity * sizeof(size_t));
}
 
static void ecs_sparse_set_free(ecs_t* ecs, ecs_sparse_set_t* set)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_not_null(set));
 
    (void)ecs;
 
    ECS_FREE(set->dense,  ecs->mem_ctx);
    ECS_FREE(set->sparse, ecs->mem_ctx);
}
 
static bool ecs_sparse_set_add(ecs_t* ecs, ecs_sparse_set_t* set, ecs_id_t id)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_not_null(set));
    ECS_ASSERT(ecs_is_valid_id(id));
 
    (void)ecs;
 
    // Check if ID exists within the set
    if (ecs_sparse_set_find(set, id, NULL))
        return false;
 
    // Grow sparse set if necessary
    if (id >= set->capacity)
    {
        size_t old_capacity = set->capacity;
        size_t new_capacity = old_capacity;
 
        // Note that since a valid id doesn't have its high bit set, and
        // capacity is in terms of elements, doubling the capacity won't wrap
        do {
            new_capacity *= 2;
        } while (id >= new_capacity);
 
 
        // Grow dense array
        ECS_ASSERT(ecs_is_valid_capacity(set->capacity, sizeof(ecs_entity_t)));
        set->dense = (ecs_entity_t*)ecs_realloc_zero(ecs,
                                                set->dense,
                                                old_capacity * sizeof(ecs_entity_t),
                                                new_capacity * sizeof(ecs_entity_t));
 
 
        // Grow sparse array and zero it
        ECS_ASSERT(ecs_is_valid_capacity(set->capacity, sizeof(size_t)));
        set->sparse = (size_t*)ecs_realloc_zero(ecs,
                                                set->sparse,
                                                old_capacity * sizeof(size_t),
                                                new_capacity * sizeof(size_t));
 
        // Set the new capacity
        set->capacity = new_capacity;
    }
 
    // Add ID to set
    set->dense[set->size].id = id;
    set->sparse[id] = set->size;
    set->size++;
 
    return true;
}
 
static inline bool ecs_sparse_set_find(ecs_sparse_set_t* set, ecs_id_t id, size_t* found)
{
    ECS_ASSERT(ecs_is_not_null(set));
    ECS_ASSERT(ecs_is_valid_id(id));
 
    if (id < set->capacity && set->sparse[id] < set->size && set->dense[set->sparse[id]].id == id)
    {
        if (found) *found = set->sparse[id];
        return true;
    }
    else
    {
        if (found) *found = 0;
        return false;
    }
}
 
static inline bool ecs_sparse_set_remove(ecs_sparse_set_t* set, ecs_id_t id)
{
    ECS_ASSERT(ecs_is_not_null(set));
    ECS_ASSERT(ecs_is_valid_id(id));
 
    if (!ecs_sparse_set_find(set, id, NULL))
        return false;
 
    // Swap and remove (changes order of array)
    ecs_id_t tmp = set->dense[set->size - 1].id;
    set->dense[set->sparse[id]].id = tmp;
    set->sparse[tmp] = set->sparse[id];
 
    set->size--;
 
    return true;
}
 
/*=============================================================================
 * System entity add/remove functions
 *============================================================================*/
 
static inline bool ecs_entity_system_test(ecs_bitset_t* require_bits,
                                          ecs_bitset_t* exclude_bits,
                                          ecs_bitset_t* entity_bits)
{
    if (!ecs_bitset_is_zero(exclude_bits))
    {
        ecs_bitset_t overlap = ecs_bitset_and(entity_bits, exclude_bits);
 
        if (ecs_bitset_true(&overlap))
        {
            return false;
        }
    }
 
    ecs_bitset_t entity_and_require = ecs_bitset_and(entity_bits, require_bits);
    return ecs_bitset_equal(&entity_and_require, require_bits);
}
 
static inline bool ecs_entity_system_remove_test(ecs_bitset_t* require_bits,
                                                 ecs_bitset_t* exclude_bits,
                                                 ecs_bitset_t* entity_bits)
{
    if (!ecs_bitset_is_zero(exclude_bits))
    {
        ecs_bitset_t overlap = ecs_bitset_and(entity_bits, exclude_bits);
 
        if (ecs_bitset_true(&overlap))
        {
            return false;
        }
    }
 
    ecs_bitset_t entity_and_require = ecs_bitset_and(entity_bits, require_bits);
    return ecs_bitset_true(&entity_and_require);
}
 
/*=============================================================================
 * ID array functions
 *============================================================================*/
 
static void ecs_id_array_init(ecs_t* ecs, ecs_id_array_t* array, size_t capacity)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_not_null(array));
 
    (void)ecs;
 
    array->size = 0;
    array->capacity = capacity;
 
    ECS_ASSERT(ecs_is_valid_capacity(capacity, sizeof(ecs_id_t)));
    array->data = (ecs_id_t*)ECS_MALLOC(capacity * sizeof(ecs_id_t), ecs->mem_ctx);
}
 
static void ecs_id_array_free(ecs_t* ecs, ecs_id_array_t* array)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_not_null(array));
 
    (void)ecs;
 
    ECS_FREE(array->data, ecs->mem_ctx);
}
 
static inline void ecs_id_array_push(ecs_t* ecs, ecs_id_array_t* array, ecs_id_t id)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_not_null(array));
    ECS_ASSERT(ecs_is_valid_id(id));
 
    (void)ecs;
 
    if (array->size == array->capacity)
    {
 
        // Note that since a valid id doesn't have its high bit set, and
        // capacity is in terms of elements, doubling the capacity won't wrap
        array->capacity *= 2;
 
        ECS_ASSERT(ecs_is_valid_capacity(array->capacity, sizeof(ecs_id_t)));
        array->data = (ecs_id_t*)ECS_REALLOC(array->data,
                                             array->capacity * sizeof(ecs_id_t),
                                             ecs->mem_ctx);
    }
 
    array->data[array->size++] = id;
}
 
static inline ecs_id_t ecs_id_array_pop(ecs_id_array_t* array)
{
    ECS_ASSERT(ecs_is_not_null(array));
    return array->data[--array->size];
}
 
static inline int ecs_id_array_size(ecs_id_array_t* array)
{
    return array->size;
}
 
static void ecs_comp_array_init(ecs_t* ecs, ecs_comp_array_t* array, size_t size, size_t capacity)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_not_null(array));
 
    (void)ecs;
 
    ECS_MEMSET(array, 0, sizeof(ecs_comp_array_t));
 
    array->capacity = capacity;
    array->size = size;
 
    ECS_ASSERT(ecs_is_valid_capacity(capacity, size));
    array->data = ECS_MALLOC(capacity * size, ecs->mem_ctx);
}
 
static void ecs_comp_array_free(ecs_t* ecs, ecs_comp_array_t* array)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_not_null(array));
 
    (void)ecs;
 
    ECS_FREE(array->data, ecs->mem_ctx);
}
 
static void ecs_comp_array_resize(ecs_t* ecs, ecs_comp_array_t* array, ecs_id_t id)
{
    ECS_ASSERT(ecs_is_not_null(ecs));
    ECS_ASSERT(ecs_is_not_null(array));
    ECS_ASSERT(ecs_is_valid_id(id));
 
    (void)ecs;
 
    if (id >= array->capacity)
    {
        // Note that since a valid id doesn't have its high bit set, and
        // capacity is in terms of elements, doubling the capacity won't wrap
        do {
            array->capacity *= 2;
        } while (id >= array->capacity);
 
        ECS_ASSERT(ecs_is_valid_capacity(array->capacity, array->size));
        array->data = ECS_REALLOC(array->data,
                                  array->capacity * array->size,
                                  ecs->mem_ctx);
    }
}
 
/*=============================================================================
 * Validation functions
 *============================================================================*/
#ifndef NDEBUG
static bool ecs_is_not_null(void* ptr)
{
    return NULL != ptr;
}
 
static bool ecs_is_valid_component_id(ecs_id_t id)
{
    return id < ECS_MAX_COMPONENTS;
}
 
static bool ecs_is_valid_system_id(ecs_id_t id)
{
    return id < ECS_MAX_SYSTEMS;
}
 
static bool ecs_is_valid_id(ecs_id_t id)
{
    // Ensures high bit is not set - works for any unsigned ecs_id_t
    return id == ((id << 1) >> 1);
}
 
static bool ecs_is_valid_capacity(size_t capacity, size_t elem_size)
{
    // Ensures any array allocations won't overflow a signed size_t and are
    // nonzero. This is not the most efficient implementation, but it is simple
 
    if (capacity == 0 || elem_size == 0)
    {
        return false;
    }
 
    size_t max_cap = (SIZE_MAX >> 1) / elem_size;
    return capacity <= max_cap;
}
 
static bool ecs_is_entity_ready(ecs_t* ecs, ecs_id_t entity_id)
{
    return ecs->entities[entity_id].ready;
}
 
static bool ecs_is_component_ready(ecs_t* ecs, ecs_id_t comp_id)
{
    return comp_id < ecs->comp_count;
}
 
static bool ecs_is_system_ready(ecs_t* ecs, ecs_id_t sys_id)
{
    return sys_id < ecs->system_count;
}
 
#endif // NDEBUG
 
#endif // PICO_ECS_IMPLEMENTATION
 
/*
    ----------------------------------------------------------------------------
    This software is available under two licenses (A) or (B). You may choose
    either one as you wish:
    ----------------------------------------------------------------------------
 
    (A) The zlib License
 
    Copyright (c) 2025 James McLean
 
    This software is provided 'as-is', without any express or implied warranty.
    In no event will the authors be held liable for any damages arising from the
    use of this software.
 
    Permission is granted to anyone to use this software for any purpose,
    including commercial applications, and to alter it and redistribute it
    freely, subject to the following restrictions:
 
    1. The origin of this software must not be misrepresented; you must not
    claim that you wrote the original software. If you use this software in a
    product, an acknowledgment in the product documentation would be appreciated
    but is not required.
 
    2. Altered source versions must be plainly marked as such, and must not be
    misrepresented as being the original software.
 
    3. This notice may not be removed or altered from any source distribution.
 
    ----------------------------------------------------------------------------
 
    (B) Public Domain (www.unlicense.org)
 
    This is free and unencumbered software released into the public domain.
 
    Anyone is free to copy, modify, publish, use, compile, sell, or distribute
    this software, either in source code form or as a compiled binary, for any
    purpose, commercial or non-commercial, and by any means.
 
    In jurisdictions that recognize copyright laws, the author or authors of
    this software dedicate any and all copyright interest in the software to the
    public domain. We make this dedication for the benefit of the public at
    large and to the detriment of our heirs and successors. We intend this
    dedication to be an overt act of relinquishment in perpetuity of all present
    and future rights to this software under copyright law.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
    ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
 
// EoF