flecs.h

Go to the documentation of this file.

 
#ifndef FLECS_H
#define FLECS_H
 
/* Flecs version macros */
#define FLECS_VERSION_MAJOR 4  
#define FLECS_VERSION_MINOR 1  
#define FLECS_VERSION_PATCH 5  
#define FLECS_VERSION FLECS_VERSION_IMPL(\
    FLECS_VERSION_MAJOR, FLECS_VERSION_MINOR, FLECS_VERSION_PATCH)
 
#ifdef FLECS_CONFIG_HEADER
#include "flecs_config.h"
#endif
 
#ifndef ecs_float_t
#define ecs_float_t float
#endif
 
#ifndef ecs_ftime_t
#define ecs_ftime_t ecs_float_t
#endif
 
 
// #define FLECS_ACCURATE_COUNTERS
 
// #define FLECS_DISABLE_COUNTERS
 
/* Make sure provided configuration is valid */
#if defined(FLECS_DEBUG) && defined(FLECS_NDEBUG)
#warning "invalid configuration: cannot both define FLECS_DEBUG and FLECS_NDEBUG"
#endif
#if defined(FLECS_DEBUG) && defined(NDEBUG)
#warning "invalid configuration: cannot both define FLECS_DEBUG and NDEBUG"
#endif
 
#if !defined(FLECS_DEBUG) && !defined(FLECS_NDEBUG)
#if defined(NDEBUG)
#define FLECS_NDEBUG
#else
#define FLECS_DEBUG
#endif
#endif
 
#ifdef FLECS_SANITIZE
#ifndef FLECS_DEBUG
#define FLECS_DEBUG /* If sanitized mode is enabled, so is debug mode */
#endif
#endif
 
#ifdef FLECS_DEBUG
#ifndef FLECS_DEBUG_INFO
#define FLECS_DEBUG_INFO
#endif
#endif
 
/* Tip: if you see weird behavior that you think might be a bug, make sure to
 * test with the FLECS_DEBUG or FLECS_SANITIZE flags enabled. There's a good
 * chance that this gives you more information about the issue! */
 
// #define FLECS_SOFT_ASSERT
 
// #define FLECS_KEEP_ASSERT
 
// #define FLECS_DEFAULT_TO_UNCACHED_QUERIES
 
// #define FLECS_CREATE_MEMBER_ENTITIES
 
// #define FLECS_CPP_NO_AUTO_REGISTRATION
 
// #define FLECS_CPP_NO_ENUM_REFLECTION
 
// #define FLECS_NO_ALWAYS_INLINE
 
// #define FLECS_CUSTOM_BUILD
 
#ifndef FLECS_CUSTOM_BUILD
#define FLECS_ALERTS         
#define FLECS_APP            
// #define FLECS_C           /**< C API convenience macros, always enabled. */
#define FLECS_CPP            
#define FLECS_DOC            
// #define FLECS_JOURNAL     /**< Journaling addon. */
#define FLECS_JSON           
#define FLECS_HTTP           
#define FLECS_LOG            
#define FLECS_META           
#define FLECS_METRICS        
#define FLECS_MODULE         
#define FLECS_OS_API_IMPL    
// #define FLECS_PERF_TRACE  /**< Enable performance tracing. */
#define FLECS_PIPELINE       
#define FLECS_REST           
#define FLECS_PARSER         
#define FLECS_QUERY_DSL      
#define FLECS_SCRIPT         
// #define FLECS_SCRIPT_MATH /**< Math functions for Flecs script (may require linking with libm). */
#define FLECS_SYSTEM         
#define FLECS_STATS          
#define FLECS_TIMER          
#define FLECS_UNITS          
#endif // ifndef FLECS_CUSTOM_BUILD
 
// #define FLECS_LOW_FOOTPRINT
#ifdef FLECS_LOW_FOOTPRINT
#define FLECS_HI_COMPONENT_ID 16
#define FLECS_HI_ID_RECORD_ID 16
#define FLECS_ENTITY_PAGE_BITS 6
#define FLECS_USE_OS_ALLOC
#define FLECS_DEFAULT_TO_UNCACHED_QUERIES
#endif
 
#ifndef FLECS_HI_COMPONENT_ID
#define FLECS_HI_COMPONENT_ID 256
#endif
 
#ifndef FLECS_HI_ID_RECORD_ID
#define FLECS_HI_ID_RECORD_ID 1024
#endif
 
#ifndef FLECS_SPARSE_PAGE_BITS
#define FLECS_SPARSE_PAGE_BITS 6
#endif
 
#ifndef FLECS_ENTITY_PAGE_BITS
#define FLECS_ENTITY_PAGE_BITS 10
#endif
 
// #define FLECS_USE_OS_ALLOC
 
#ifndef FLECS_ID_DESC_MAX
#define FLECS_ID_DESC_MAX 32
#endif
 
#ifndef FLECS_EVENT_DESC_MAX
#define FLECS_EVENT_DESC_MAX 8
#endif
 
#define FLECS_VARIABLE_COUNT_MAX 64
 
#ifndef FLECS_TERM_COUNT_MAX
#define FLECS_TERM_COUNT_MAX 32
#endif
 
#ifndef FLECS_TERM_ARG_COUNT_MAX
#define FLECS_TERM_ARG_COUNT_MAX 16
#endif
 
#ifndef FLECS_QUERY_VARIABLE_COUNT_MAX
#define FLECS_QUERY_VARIABLE_COUNT_MAX 64
#endif
 
#ifndef FLECS_QUERY_SCOPE_NESTING_MAX
#define FLECS_QUERY_SCOPE_NESTING_MAX 8
#endif
 
#ifndef FLECS_DAG_DEPTH_MAX
#define FLECS_DAG_DEPTH_MAX 128
#endif
 
#define FLECS_TREE_SPAWNER_DEPTH_CACHE_SIZE (6)
 
#include "flecs/private/api_defines.h"
 
typedef uint64_t ecs_id_t;
 
typedef ecs_id_t ecs_entity_t;
 
typedef struct {
    ecs_id_t *array;    
    int32_t count;      
} ecs_type_t;
 
typedef struct ecs_world_t ecs_world_t;
 
typedef struct ecs_stage_t ecs_stage_t;
 
typedef struct ecs_table_t ecs_table_t;
 
typedef struct ecs_term_t ecs_term_t;
 
typedef struct ecs_query_t ecs_query_t;
 
typedef struct ecs_observer_t ecs_observer_t;
 
typedef struct ecs_observable_t ecs_observable_t;
 
typedef struct ecs_iter_t ecs_iter_t;
 
typedef struct ecs_ref_t ecs_ref_t;
 
typedef struct ecs_type_hooks_t ecs_type_hooks_t;
 
typedef struct ecs_type_info_t ecs_type_info_t;
 
typedef struct ecs_record_t ecs_record_t;
 
typedef struct ecs_component_record_t ecs_component_record_t;
 
typedef void ecs_poly_t;
 
typedef struct ecs_mixins_t ecs_mixins_t;
 
typedef struct ecs_header_t {
    int32_t type;               
    int32_t refcount;           
    ecs_mixins_t *mixins;       
} ecs_header_t;
 
typedef struct ecs_table_record_t ecs_table_record_t;
 
#include "flecs/datastructures/vec.h"              /* Vector datatype */
#include "flecs/datastructures/sparse.h"           /* Sparse set */
#include "flecs/datastructures/block_allocator.h"  /* Block allocator */
#include "flecs/datastructures/stack_allocator.h"  /* Stack allocator */
#include "flecs/datastructures/map.h"              /* Map */
#include "flecs/datastructures/allocator.h"        /* Allocator */
#include "flecs/datastructures/strbuf.h"           /* String builder */
#include "flecs/os_api.h"  /* Abstraction for operating system functions */
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef void (*ecs_run_action_t)(
    ecs_iter_t *it);
 
typedef void (*ecs_iter_action_t)(
    ecs_iter_t *it);
 
typedef bool (*ecs_iter_next_action_t)(
    ecs_iter_t *it);
 
typedef void (*ecs_iter_fini_action_t)(
    ecs_iter_t *it);
 
typedef int (*ecs_order_by_action_t)(
    ecs_entity_t e1,
    const void *ptr1,
    ecs_entity_t e2,
    const void *ptr2);
 
typedef void (*ecs_sort_table_action_t)(
    ecs_world_t* world,
    ecs_table_t* table,
    ecs_entity_t* entities,
    void* ptr,
    int32_t size,
    int32_t lo,
    int32_t hi,
    ecs_order_by_action_t order_by);
 
typedef uint64_t (*ecs_group_by_action_t)(
    ecs_world_t *world,
    ecs_table_t *table,
    ecs_id_t group_id,
    void *ctx);
 
typedef void* (*ecs_group_create_action_t)(
    ecs_world_t *world,
    uint64_t group_id,
    void *group_by_ctx); /* from ecs_query_desc_t */
 
typedef void (*ecs_group_delete_action_t)(
    ecs_world_t *world,
    uint64_t group_id,
    void *group_ctx,     /* return value from ecs_group_create_action_t */
    void *group_by_ctx); /* from ecs_query_desc_t */
 
typedef void (*ecs_module_action_t)(
    ecs_world_t *world);
 
typedef void (*ecs_fini_action_t)(
    ecs_world_t *world,
    void *ctx);
 
typedef void (*ecs_ctx_free_t)(
    void *ctx);
 
typedef int (*ecs_compare_action_t)(
    const void *ptr1,
    const void *ptr2);
 
typedef uint64_t (*ecs_hash_value_action_t)(
    const void *ptr);
 
typedef void (*ecs_xtor_t)(
    void *ptr,
    int32_t count,
    const ecs_type_info_t *type_info);
 
typedef void (*ecs_copy_t)(
    void *dst_ptr,
    const void *src_ptr,
    int32_t count,
    const ecs_type_info_t *type_info);
 
typedef void (*ecs_move_t)(
    void *dst_ptr,
    void *src_ptr,
    int32_t count,
    const ecs_type_info_t *type_info);
 
typedef int (*ecs_cmp_t)(
    const void *a_ptr,
    const void *b_ptr,
    const ecs_type_info_t *type_info);
 
typedef bool (*ecs_equals_t)(
    const void *a_ptr,
    const void *b_ptr,
    const ecs_type_info_t *type_info);
 
typedef void (*flecs_poly_dtor_t)(
    ecs_poly_t *poly);
 
typedef enum ecs_inout_kind_t {
    EcsInOutDefault,  
    EcsInOutNone,     
    EcsInOutFilter,   
    EcsInOut,         
    EcsIn,            
    EcsOut,           
} ecs_inout_kind_t;
 
typedef enum ecs_oper_kind_t {
    EcsAnd,           
    EcsOr,            
    EcsNot,           
    EcsOptional,      
    EcsAndFrom,       
    EcsOrFrom,        
    EcsNotFrom,       
} ecs_oper_kind_t;
 
typedef enum ecs_query_cache_kind_t {
    EcsQueryCacheDefault,   
    EcsQueryCacheAuto,      
    EcsQueryCacheAll,       
    EcsQueryCacheNone,      
} ecs_query_cache_kind_t;
 
#define EcsSelf                       (1llu << 63)
 
#define EcsUp                         (1llu << 62)
 
#define EcsTrav                       (1llu << 61)
 
#define EcsCascade                    (1llu << 60)
 
#define EcsDesc                       (1llu << 59)
 
#define EcsIsVariable                 (1llu << 58)
 
#define EcsIsEntity                   (1llu << 57)
 
#define EcsIsName                     (1llu << 56)
 
#define EcsTraverseFlags              (EcsSelf|EcsUp|EcsTrav|EcsCascade|EcsDesc)
 
#define EcsTermRefFlags               (EcsTraverseFlags|EcsIsVariable|EcsIsEntity|EcsIsName)
 
typedef struct ecs_term_ref_t {
    ecs_entity_t id;            
    const char *name;           
} ecs_term_ref_t;
 
struct ecs_term_t {
    ecs_id_t id;                
    ecs_term_ref_t src;          
    ecs_term_ref_t first;        
    ecs_term_ref_t second;       
    ecs_entity_t trav;          
    int16_t inout;              
    int16_t oper;               
    int8_t field_index;         
    ecs_flags16_t flags_;       
};
 
struct ecs_query_t {
    ecs_header_t hdr;           
    ecs_term_t *terms;          
    int32_t *sizes;             
    ecs_id_t *ids;              
    uint64_t bloom_filter;      
    ecs_flags32_t flags;        
    int8_t var_count;           
    int8_t term_count;          
    int8_t field_count;         
    ecs_termset_t fixed_fields; 
    ecs_termset_t var_fields;   
    ecs_termset_t static_id_fields; 
    ecs_termset_t data_fields;  
    ecs_termset_t write_fields; 
    ecs_termset_t read_fields;  
    ecs_termset_t row_fields;   
    ecs_termset_t shared_readonly_fields; 
    ecs_termset_t set_fields;   
    ecs_query_cache_kind_t cache_kind;  
    char **vars;                
    void *ctx;                  
    void *binding_ctx;          
    ecs_entity_t entity;        
    ecs_world_t *real_world;    
    ecs_world_t *world;         
    int32_t eval_count;         
};
 
struct ecs_observer_t {
    ecs_header_t hdr;           
    ecs_query_t *query;         
    ecs_entity_t events[FLECS_EVENT_DESC_MAX];
    int32_t event_count;        
    ecs_iter_action_t callback; 
    ecs_run_action_t run;       
    void *ctx;                  
    void *callback_ctx;         
    void *run_ctx;              
    ecs_ctx_free_t ctx_free;    
    ecs_ctx_free_t callback_ctx_free; 
    ecs_ctx_free_t run_ctx_free; 
    ecs_observable_t *observable; 
    ecs_world_t *world;         
    ecs_entity_t entity;        
};
 
/* Flags that can be used to check which hooks a type has set */
#define ECS_TYPE_HOOK_CTOR                   ECS_CAST(ecs_flags32_t, 1 << 0)
#define ECS_TYPE_HOOK_DTOR                   ECS_CAST(ecs_flags32_t, 1 << 1)
#define ECS_TYPE_HOOK_COPY                   ECS_CAST(ecs_flags32_t, 1 << 2)
#define ECS_TYPE_HOOK_MOVE                   ECS_CAST(ecs_flags32_t, 1 << 3)
#define ECS_TYPE_HOOK_COPY_CTOR              ECS_CAST(ecs_flags32_t, 1 << 4)
#define ECS_TYPE_HOOK_MOVE_CTOR              ECS_CAST(ecs_flags32_t, 1 << 5)
#define ECS_TYPE_HOOK_CTOR_MOVE_DTOR         ECS_CAST(ecs_flags32_t, 1 << 6)
#define ECS_TYPE_HOOK_MOVE_DTOR              ECS_CAST(ecs_flags32_t, 1 << 7)
#define ECS_TYPE_HOOK_CMP                    ECS_CAST(ecs_flags32_t, 1 << 8)
#define ECS_TYPE_HOOK_EQUALS                 ECS_CAST(ecs_flags32_t, 1 << 9)
 
 
/* Flags that can be used to set/check which hooks of a type are invalid */
#define ECS_TYPE_HOOK_CTOR_ILLEGAL           ECS_CAST(ecs_flags32_t, 1 << 10)
#define ECS_TYPE_HOOK_DTOR_ILLEGAL           ECS_CAST(ecs_flags32_t, 1 << 12)
#define ECS_TYPE_HOOK_COPY_ILLEGAL           ECS_CAST(ecs_flags32_t, 1 << 13)
#define ECS_TYPE_HOOK_MOVE_ILLEGAL           ECS_CAST(ecs_flags32_t, 1 << 14)
#define ECS_TYPE_HOOK_COPY_CTOR_ILLEGAL      ECS_CAST(ecs_flags32_t, 1 << 15)
#define ECS_TYPE_HOOK_MOVE_CTOR_ILLEGAL      ECS_CAST(ecs_flags32_t, 1 << 16)
#define ECS_TYPE_HOOK_CTOR_MOVE_DTOR_ILLEGAL ECS_CAST(ecs_flags32_t, 1 << 17)
#define ECS_TYPE_HOOK_MOVE_DTOR_ILLEGAL      ECS_CAST(ecs_flags32_t, 1 << 18)
#define ECS_TYPE_HOOK_CMP_ILLEGAL            ECS_CAST(ecs_flags32_t, 1 << 19)
#define ECS_TYPE_HOOK_EQUALS_ILLEGAL         ECS_CAST(ecs_flags32_t, 1 << 20)
 
/* Internal debug flag that indicates type hooks have been invoked */
#define ECS_TYPE_HOOK_IN_USE                 ECS_CAST(ecs_flags32_t, 1 << 21)
 
 
/* All valid hook flags */
#define ECS_TYPE_HOOKS (ECS_TYPE_HOOK_CTOR|ECS_TYPE_HOOK_DTOR|\
    ECS_TYPE_HOOK_COPY|ECS_TYPE_HOOK_MOVE|ECS_TYPE_HOOK_COPY_CTOR|\
    ECS_TYPE_HOOK_MOVE_CTOR|ECS_TYPE_HOOK_CTOR_MOVE_DTOR|\
    ECS_TYPE_HOOK_MOVE_DTOR|ECS_TYPE_HOOK_CMP|ECS_TYPE_HOOK_EQUALS)
 
/* All invalid hook flags */
#define ECS_TYPE_HOOKS_ILLEGAL (ECS_TYPE_HOOK_CTOR_ILLEGAL|\
    ECS_TYPE_HOOK_DTOR_ILLEGAL|ECS_TYPE_HOOK_COPY_ILLEGAL|\
    ECS_TYPE_HOOK_MOVE_ILLEGAL|ECS_TYPE_HOOK_COPY_CTOR_ILLEGAL|\
    ECS_TYPE_HOOK_MOVE_CTOR_ILLEGAL|ECS_TYPE_HOOK_CTOR_MOVE_DTOR_ILLEGAL|\
    ECS_TYPE_HOOK_MOVE_DTOR_ILLEGAL|ECS_TYPE_HOOK_CMP_ILLEGAL|\
    ECS_TYPE_HOOK_EQUALS_ILLEGAL)
struct ecs_type_hooks_t {
    ecs_xtor_t ctor;            
    ecs_xtor_t dtor;            
    ecs_copy_t copy;            
    ecs_move_t move;            
    ecs_copy_t copy_ctor;
 
    ecs_move_t move_ctor;
 
    ecs_move_t ctor_move_dtor;
 
    ecs_move_t move_dtor;
 
    ecs_cmp_t cmp;
 
    ecs_equals_t equals;
 
    ecs_flags32_t flags;
    
    ecs_iter_action_t on_add;
 
    ecs_iter_action_t on_set;
 
    ecs_iter_action_t on_remove;
 
    ecs_iter_action_t on_replace;
 
    void *ctx;                         
    void *binding_ctx;                 
    void *lifecycle_ctx;               
    ecs_ctx_free_t ctx_free;           
    ecs_ctx_free_t binding_ctx_free;   
    ecs_ctx_free_t lifecycle_ctx_free; 
};
 
struct ecs_type_info_t {
    ecs_size_t size;         
    ecs_size_t alignment;    
    ecs_type_hooks_t hooks;  
    ecs_entity_t component;  
    const char *name;        
};
 
#include "flecs/private/api_types.h"        /* Supporting API types */
#include "flecs/private/api_support.h"      /* Supporting API functions */
#include "flecs/datastructures/hashmap.h"   /* Hashmap */
#include "flecs/private/api_internals.h"    /* Supporting API functions */
 
typedef struct ecs_value_t {
    ecs_entity_t type;      
    void *ptr;              
} ecs_value_t;
 
typedef struct ecs_entity_desc_t {
    int32_t _canary;      
    ecs_entity_t id;      
    ecs_entity_t parent;  
    const char *name;     
    const char *sep;      
    const char *root_sep; 
    const char *symbol;   
    bool use_low_id;      
    const ecs_id_t *add;
 
    const ecs_value_t *set;
 
    const char *add_expr;
} ecs_entity_desc_t;
 
typedef struct ecs_bulk_desc_t {
    int32_t _canary;        
    ecs_entity_t *entities; 
    int32_t count;     
    ecs_id_t ids[FLECS_ID_DESC_MAX]; 
    void **data;       
    ecs_table_t *table; 
} ecs_bulk_desc_t;
 
typedef struct ecs_component_desc_t {
    int32_t _canary;        
    ecs_entity_t entity;
 
    ecs_type_info_t type;
} ecs_component_desc_t;
 
struct ecs_iter_t {
    /* World */
    ecs_world_t *world;           
    ecs_world_t *real_world;      
    /* Matched data */
    int32_t offset;               
    int32_t count;                
    const ecs_entity_t *entities; 
    void **ptrs;                  
    const ecs_table_record_t **trs; 
    const ecs_size_t *sizes;      
    ecs_table_t *table;           
    ecs_table_t *other_table;     
    ecs_id_t *ids;                
    ecs_entity_t *sources;        
    ecs_flags64_t constrained_vars; 
    ecs_termset_t set_fields;     
    ecs_termset_t ref_fields;     
    ecs_termset_t row_fields;     
    ecs_termset_t up_fields;      
    /* Input information */
    ecs_entity_t system;          
    ecs_entity_t event;           
    ecs_id_t event_id;            
    int32_t event_cur;            
    /* Query information */
    int8_t field_count;           
    int8_t term_index;            
    const ecs_query_t *query;     
    /* Context */
    void *param;                  
    void *ctx;                    
    void *binding_ctx;            
    void *callback_ctx;           
    void *run_ctx;                
    /* Time */
    ecs_ftime_t delta_time;       
    ecs_ftime_t delta_system_time;
    /* Iterator counters */
    int32_t frame_offset;         
    /* Misc */
    ecs_flags32_t flags;          
    ecs_entity_t interrupted_by;  
    ecs_iter_private_t priv_;     
    /* Chained iterators */
    ecs_iter_next_action_t next;  
    ecs_iter_action_t callback;   
    ecs_iter_fini_action_t fini;  
    ecs_iter_t *chain_it;         
};
 
 
#define EcsQueryMatchPrefab           (1u << 1u)
 
#define EcsQueryMatchDisabled         (1u << 2u)
 
#define EcsQueryMatchEmptyTables      (1u << 3u)
 
#define EcsQueryAllowUnresolvedByName (1u << 6u)
 
#define EcsQueryTableOnly             (1u << 7u)
 
#define EcsQueryDetectChanges         (1u << 8u)
 
 
typedef struct ecs_query_desc_t {
    int32_t _canary;
 
    ecs_term_t terms[FLECS_TERM_COUNT_MAX];
 
    const char *expr;
 
    ecs_query_cache_kind_t cache_kind;
 
    ecs_flags32_t flags;
 
    ecs_order_by_action_t order_by_callback;
 
    ecs_sort_table_action_t order_by_table_callback;
 
    ecs_entity_t order_by;
 
    ecs_id_t group_by;
 
    ecs_group_by_action_t group_by_callback;
 
    ecs_group_create_action_t on_group_create;
 
    ecs_group_delete_action_t on_group_delete;
 
    void *group_by_ctx;
 
    ecs_ctx_free_t group_by_ctx_free;
 
    void *ctx;
 
    void *binding_ctx;
 
    ecs_ctx_free_t ctx_free;
 
    ecs_ctx_free_t binding_ctx_free;
 
    ecs_entity_t entity;
} ecs_query_desc_t;
 
typedef struct ecs_observer_desc_t {
    int32_t _canary;
 
    ecs_entity_t entity;
 
    ecs_query_desc_t query;
 
    ecs_entity_t events[FLECS_EVENT_DESC_MAX];
 
    bool yield_existing;
 
    bool global_observer;
 
    ecs_iter_action_t callback;
 
    ecs_run_action_t run;
 
    void *ctx;
 
    ecs_ctx_free_t ctx_free;
 
    void *callback_ctx;
 
    ecs_ctx_free_t callback_ctx_free;
 
    void *run_ctx;
 
    ecs_ctx_free_t run_ctx_free;
 
    int32_t *last_event_id;
    int8_t term_index_;    
    ecs_flags32_t flags_;  
} ecs_observer_desc_t;
 
typedef struct ecs_event_desc_t {
    ecs_entity_t event;
 
    const ecs_type_t *ids;
 
    ecs_table_t *table;
 
    ecs_table_t *other_table;
 
    int32_t offset;
 
    int32_t count;
 
    ecs_entity_t entity;
 
    void *param;
 
    const void *const_param;
 
    ecs_poly_t *observable;
 
    ecs_flags32_t flags;
} ecs_event_desc_t;
 
 
typedef struct ecs_build_info_t {
    const char *compiler;           
    const char **addons;            
    const char **flags;             
    const char *version;            
    int16_t version_major;          
    int16_t version_minor;          
    int16_t version_patch;          
    bool debug;                     
    bool sanitize;                  
    bool perf_trace;                
} ecs_build_info_t;
 
typedef struct ecs_world_info_t {
    ecs_entity_t last_component_id;   
    ecs_ftime_t delta_time_raw;       
    ecs_ftime_t delta_time;           
    ecs_ftime_t time_scale;           
    ecs_ftime_t target_fps;           
    ecs_ftime_t frame_time_total;     
    ecs_ftime_t system_time_total;    
    ecs_ftime_t emit_time_total;      
    ecs_ftime_t merge_time_total;     
    ecs_ftime_t rematch_time_total;   
    double world_time_total;          
    double world_time_total_raw;      
    int64_t frame_count_total;        
    int64_t merge_count_total;        
    int64_t eval_comp_monitors_total; 
    int64_t rematch_count_total;      
    int64_t id_create_total;          
    int64_t id_delete_total;          
    int64_t table_create_total;       
    int64_t table_delete_total;       
    int64_t pipeline_build_count_total; 
    int64_t systems_ran_total;        
    int64_t observers_ran_total;      
    int64_t queries_ran_total;        
    int32_t tag_id_count;             
    int32_t component_id_count;       
    int32_t pair_id_count;            
    int32_t table_count;              
    uint32_t creation_time;           
    /* -- Command counts -- */
    struct {
        int64_t add_count;             
        int64_t remove_count;          
        int64_t delete_count;          
        int64_t clear_count;           
        int64_t set_count;             
        int64_t ensure_count;          
        int64_t modified_count;        
        int64_t discard_count;         
        int64_t event_count;           
        int64_t other_count;           
        int64_t batched_entity_count;  
        int64_t batched_command_count; 
    } cmd;                             
    const char *name_prefix;          
} ecs_world_info_t;
 
typedef struct ecs_query_group_info_t {
    uint64_t id;          
    int32_t match_count;  
    int32_t table_count;  
    void *ctx;            
} ecs_query_group_info_t;
 
typedef struct ecs_entity_range_t {
    uint32_t min;           
    uint32_t max;           
    uint32_t cur;           
    ecs_vec_t recycled;     
} ecs_entity_range_t;
 
typedef struct EcsIdentifier {
    char *value;          
    ecs_size_t length;    
    uint64_t hash;        
    uint64_t index_hash;  
    ecs_hashmap_t *index; 
} EcsIdentifier;
 
typedef struct EcsComponent {
    ecs_size_t size;           
    ecs_size_t alignment;      
} EcsComponent;
 
typedef struct EcsPoly {
    ecs_poly_t *poly;          
} EcsPoly;
 
typedef struct EcsDefaultChildComponent {
    ecs_id_t component;  
} EcsDefaultChildComponent;
 
typedef struct EcsParent {
    ecs_entity_t value;     
} EcsParent;
 
typedef struct {
    const char *child_name; 
    ecs_table_t *table;     
    uint32_t child;         
    int32_t parent_index;   
} ecs_tree_spawner_child_t;
 
typedef struct {
    ecs_vec_t children;     
} ecs_tree_spawner_t;
 
typedef struct EcsTreeSpawner {
    ecs_tree_spawner_t data[FLECS_TREE_SPAWNER_DEPTH_CACHE_SIZE]; 
} EcsTreeSpawner;
 
/* Only include deprecated definitions if deprecated addon is required */
#ifdef FLECS_DEPRECATED
#include "flecs/addons/deprecated.h"
#endif
 
FLECS_API extern const ecs_id_t ECS_PAIR;
 
FLECS_API extern const ecs_id_t ECS_AUTO_OVERRIDE;
 
FLECS_API extern const ecs_id_t ECS_TOGGLE;
 
FLECS_API extern const ecs_id_t ECS_VALUE_PAIR;
 
/* Built-in component IDs */
 
FLECS_API extern const ecs_entity_t ecs_id(EcsComponent);
 
FLECS_API extern const ecs_entity_t ecs_id(EcsIdentifier);
 
FLECS_API extern const ecs_entity_t ecs_id(EcsPoly);
 
FLECS_API extern const ecs_entity_t ecs_id(EcsParent);
 
FLECS_API extern const ecs_entity_t ecs_id(EcsTreeSpawner);
 
FLECS_API extern const ecs_entity_t ecs_id(EcsDefaultChildComponent);
 
FLECS_API extern const ecs_entity_t EcsParentDepth;
 
FLECS_API extern const ecs_entity_t EcsQuery;
 
FLECS_API extern const ecs_entity_t EcsObserver;
 
FLECS_API extern const ecs_entity_t EcsSystem;
 
FLECS_API extern const ecs_entity_t ecs_id(EcsTickSource);
 
FLECS_API extern const ecs_entity_t ecs_id(EcsPipelineQuery);
 
FLECS_API extern const ecs_entity_t ecs_id(EcsTimer);
 
FLECS_API extern const ecs_entity_t ecs_id(EcsRateFilter);
 
FLECS_API extern const ecs_entity_t EcsFlecs;
 
FLECS_API extern const ecs_entity_t EcsFlecsCore;
 
FLECS_API extern const ecs_entity_t EcsWorld;
 
FLECS_API extern const ecs_entity_t EcsWildcard;
 
FLECS_API extern const ecs_entity_t EcsAny;
 
FLECS_API extern const ecs_entity_t EcsThis;
 
FLECS_API extern const ecs_entity_t EcsVariable;
 
FLECS_API extern const ecs_entity_t EcsTransitive;
 
FLECS_API extern const ecs_entity_t EcsReflexive;
 
FLECS_API extern const ecs_entity_t EcsFinal;
 
FLECS_API extern const ecs_entity_t EcsInheritable;
 
FLECS_API extern const ecs_entity_t EcsOnInstantiate;
 
FLECS_API extern const ecs_entity_t EcsOverride;
 
FLECS_API extern const ecs_entity_t EcsInherit;
 
FLECS_API extern const ecs_entity_t EcsDontInherit;
 
FLECS_API extern const ecs_entity_t EcsSymmetric;
 
FLECS_API extern const ecs_entity_t EcsExclusive;
 
FLECS_API extern const ecs_entity_t EcsAcyclic;
 
FLECS_API extern const ecs_entity_t EcsTraversable;
 
FLECS_API extern const ecs_entity_t EcsWith;
 
FLECS_API extern const ecs_entity_t EcsOneOf;
 
FLECS_API extern const ecs_entity_t EcsCanToggle;
 
FLECS_API extern const ecs_entity_t EcsTrait;
 
FLECS_API extern const ecs_entity_t EcsRelationship;
 
FLECS_API extern const ecs_entity_t EcsTarget;
 
FLECS_API extern const ecs_entity_t EcsPairIsTag;
 
FLECS_API extern const ecs_entity_t EcsName;
 
FLECS_API extern const ecs_entity_t EcsSymbol;
 
FLECS_API extern const ecs_entity_t EcsAlias;
 
FLECS_API extern const ecs_entity_t EcsChildOf;
 
FLECS_API extern const ecs_entity_t EcsIsA;
 
FLECS_API extern const ecs_entity_t EcsDependsOn;
 
FLECS_API extern const ecs_entity_t EcsSlotOf;
 
FLECS_API extern const ecs_entity_t EcsOrderedChildren;
 
FLECS_API extern const ecs_entity_t EcsModule;
 
FLECS_API extern const ecs_entity_t EcsPrefab;
 
FLECS_API extern const ecs_entity_t EcsDisabled;
 
FLECS_API extern const ecs_entity_t EcsNotQueryable;
 
FLECS_API extern const ecs_entity_t EcsOnAdd;
 
FLECS_API extern const ecs_entity_t EcsOnRemove;
 
FLECS_API extern const ecs_entity_t EcsOnSet;
 
FLECS_API extern const ecs_entity_t EcsMonitor;
 
FLECS_API extern const ecs_entity_t EcsOnTableCreate;
 
FLECS_API extern const ecs_entity_t EcsOnTableDelete;
 
FLECS_API extern const ecs_entity_t EcsOnDelete;
 
FLECS_API extern const ecs_entity_t EcsOnDeleteTarget;
 
FLECS_API extern const ecs_entity_t EcsRemove;
 
FLECS_API extern const ecs_entity_t EcsDelete;
 
FLECS_API extern const ecs_entity_t EcsPanic;
 
FLECS_API extern const ecs_entity_t EcsSingleton;
 
FLECS_API extern const ecs_entity_t EcsSparse;
 
FLECS_API extern const ecs_entity_t EcsDontFragment;
 
FLECS_API extern const ecs_entity_t EcsPredEq;
 
FLECS_API extern const ecs_entity_t EcsPredMatch;
 
FLECS_API extern const ecs_entity_t EcsPredLookup;
 
FLECS_API extern const ecs_entity_t EcsScopeOpen;
 
FLECS_API extern const ecs_entity_t EcsScopeClose;
 
FLECS_API extern const ecs_entity_t EcsEmpty;
 
FLECS_API extern const ecs_entity_t ecs_id(EcsPipeline); 
FLECS_API extern const ecs_entity_t EcsOnStart;     
FLECS_API extern const ecs_entity_t EcsPreFrame;    
FLECS_API extern const ecs_entity_t EcsOnLoad;      
FLECS_API extern const ecs_entity_t EcsPostLoad;    
FLECS_API extern const ecs_entity_t EcsPreUpdate;   
FLECS_API extern const ecs_entity_t EcsOnUpdate;    
FLECS_API extern const ecs_entity_t EcsOnValidate;  
FLECS_API extern const ecs_entity_t EcsPostUpdate;  
FLECS_API extern const ecs_entity_t EcsPreStore;    
FLECS_API extern const ecs_entity_t EcsOnStore;     
FLECS_API extern const ecs_entity_t EcsPostFrame;   
FLECS_API extern const ecs_entity_t EcsPhase;       
FLECS_API extern const ecs_entity_t EcsConstant;    
#define EcsLastInternalComponentId (ecs_id(EcsTreeSpawner))
 
#define EcsFirstUserComponentId (8)
 
#define EcsFirstUserEntityId (FLECS_HI_COMPONENT_ID + 128)
 
/* When visualized, the reserved ID ranges look like this:
 * - [1..8]: Built-in components
 * - [9..FLECS_HI_COMPONENT_ID]: Low IDs reserved for application components
 * - [FLECS_HI_COMPONENT_ID + 1..EcsFirstUserEntityId]: Built-in entities
 */
 
FLECS_API
ecs_world_t* ecs_init(void);
 
FLECS_API
ecs_world_t* ecs_mini(void);
 
FLECS_API
ecs_world_t* ecs_init_w_args(
    int argc,
    char *argv[]);
 
FLECS_API
int ecs_fini(
    ecs_world_t *world);
 
FLECS_API
bool ecs_is_fini(
    const ecs_world_t *world);
 
FLECS_API
void ecs_atfini(
    ecs_world_t *world,
    ecs_fini_action_t action,
    void *ctx);
 
typedef struct ecs_entities_t {
    const ecs_entity_t *ids; 
    int32_t count;           
    int32_t alive_count;     
} ecs_entities_t;
 
FLECS_API
ecs_entities_t ecs_get_entities(
    const ecs_world_t *world);
 
FLECS_API
ecs_flags32_t ecs_world_get_flags(
    const ecs_world_t *world);
 
FLECS_API
ecs_ftime_t ecs_frame_begin(
    ecs_world_t *world,
    ecs_ftime_t delta_time);
 
FLECS_API
void ecs_frame_end(
    ecs_world_t *world);
 
FLECS_API
void ecs_run_post_frame(
    ecs_world_t *world,
    ecs_fini_action_t action,
    void *ctx);
 
FLECS_API
void ecs_quit(
    ecs_world_t *world);
 
FLECS_API
bool ecs_should_quit(
    const ecs_world_t *world);
 
FLECS_API void ecs_measure_frame_time(
    ecs_world_t *world,
    bool enable);
 
FLECS_API void ecs_measure_system_time(
    ecs_world_t *world,
    bool enable);
 
FLECS_API
void ecs_set_target_fps(
    ecs_world_t *world,
    ecs_ftime_t fps);
 
FLECS_API
void ecs_set_default_query_flags(
    ecs_world_t *world,
    ecs_flags32_t flags);
 
FLECS_API
bool ecs_readonly_begin(
    ecs_world_t *world,
    bool multi_threaded);
 
FLECS_API
void ecs_readonly_end(
    ecs_world_t *world);
 
FLECS_API
void ecs_merge(
    ecs_world_t *stage);
 
FLECS_API
bool ecs_defer_begin(
    ecs_world_t *world);
 
FLECS_API
bool ecs_defer_end(
    ecs_world_t *world);
 
FLECS_API
void ecs_defer_suspend(
    ecs_world_t *world);
 
FLECS_API
void ecs_defer_resume(
    ecs_world_t *world);
 
FLECS_API
bool ecs_is_deferred(
    const ecs_world_t *world);
 
FLECS_API
bool ecs_is_defer_suspended(
    const ecs_world_t *world);
 
FLECS_API
void ecs_set_stage_count(
    ecs_world_t *world,
    int32_t stages);
 
FLECS_API
int32_t ecs_get_stage_count(
    const ecs_world_t *world);
 
FLECS_API
ecs_world_t* ecs_get_stage(
    const ecs_world_t *world,
    int32_t stage_id);
 
FLECS_API
bool ecs_stage_is_readonly(
    const ecs_world_t *world);
 
FLECS_API
ecs_world_t* ecs_stage_new(
    ecs_world_t *world);
 
FLECS_API
void ecs_stage_free(
    ecs_world_t *stage);
 
FLECS_API
int32_t ecs_stage_get_id(
    const ecs_world_t *world);
 
FLECS_API
void ecs_set_ctx(
    ecs_world_t *world,
    void *ctx,
    ecs_ctx_free_t ctx_free);
 
FLECS_API
void ecs_set_binding_ctx(
    ecs_world_t *world,
    void *ctx,
    ecs_ctx_free_t ctx_free);
 
FLECS_API
void* ecs_get_ctx(
    const ecs_world_t *world);
 
FLECS_API
void* ecs_get_binding_ctx(
    const ecs_world_t *world);
 
FLECS_API
const ecs_build_info_t* ecs_get_build_info(void);
 
FLECS_API
const ecs_world_info_t* ecs_get_world_info(
    const ecs_world_t *world);
 
FLECS_API
void ecs_dim(
    ecs_world_t *world,
    int32_t entity_count);
 
FLECS_API
void ecs_shrink(
    ecs_world_t *world);
 
FLECS_API
const ecs_entity_range_t* ecs_entity_range_new(
    ecs_world_t *world,
    uint32_t min,
    uint32_t max);
 
FLECS_API
void ecs_entity_range_set(
    ecs_world_t *world,
    const ecs_entity_range_t *range);
 
FLECS_API
const ecs_entity_range_t* ecs_entity_range_get(
    const ecs_world_t *world);
 
FLECS_API
ecs_entity_t ecs_get_max_id(
    const ecs_world_t *world);
 
FLECS_API
void ecs_run_aperiodic(
    ecs_world_t *world,
    ecs_flags32_t flags);
 
typedef struct ecs_delete_empty_tables_desc_t {
    uint16_t clear_generation;
 
    uint16_t delete_generation;
 
    double time_budget_seconds;
 
    int32_t offset;
} ecs_delete_empty_tables_desc_t;
 
FLECS_API
int32_t ecs_delete_empty_tables(
    ecs_world_t *world,
    const ecs_delete_empty_tables_desc_t *desc);
 
FLECS_API
const ecs_world_t* ecs_get_world(
    const ecs_poly_t *poly);
 
FLECS_API
ecs_entity_t ecs_get_entity(
    const ecs_poly_t *poly);
 
FLECS_API
bool flecs_poly_is_(
    const ecs_poly_t *object,
    int32_t type);
 
#define flecs_poly_is(object, type)\
    flecs_poly_is_(object, type##_magic)
 
FLECS_API
ecs_id_t ecs_make_pair(
    ecs_entity_t first,
    ecs_entity_t second);
 
FLECS_API
void ecs_exclusive_access_begin(
    ecs_world_t *world,
    const char *thread_name);
 
FLECS_API
void ecs_exclusive_access_end(
    ecs_world_t *world,
    bool lock_world);
 
FLECS_API
ecs_entity_t ecs_new(
    ecs_world_t *world);
 
FLECS_API
ecs_entity_t ecs_new_low_id(
    ecs_world_t *world);
 
FLECS_API
ecs_entity_t ecs_new_w_id(
    ecs_world_t *world,
    ecs_id_t component);
 
FLECS_API
ecs_entity_t ecs_new_w_table(
    ecs_world_t *world,
    ecs_table_t *table);
 
FLECS_API
ecs_entity_t ecs_entity_init(
    ecs_world_t *world,
    const ecs_entity_desc_t *desc);
 
FLECS_API
const ecs_entity_t* ecs_bulk_init(
    ecs_world_t *world,
    const ecs_bulk_desc_t *desc);
 
FLECS_API
const ecs_entity_t* ecs_bulk_new_w_id(
    ecs_world_t *world,
    ecs_id_t component,
    int32_t count);
 
FLECS_API
ecs_entity_t ecs_clone(
    ecs_world_t *world,
    ecs_entity_t dst,
    ecs_entity_t src,
    bool copy_value);
 
FLECS_API
void ecs_delete(
    ecs_world_t *world,
    ecs_entity_t entity);
 
FLECS_API
void ecs_delete_with(
    ecs_world_t *world,
    ecs_id_t component);
 
FLECS_API
void ecs_set_child_order(
    ecs_world_t *world,
    ecs_entity_t parent,
    const ecs_entity_t *children,
    int32_t child_count);
 
FLECS_API
ecs_entities_t ecs_get_ordered_children(
    const ecs_world_t *world,
    ecs_entity_t parent);
 
FLECS_API
void ecs_add_id(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t component);
 
FLECS_API
void ecs_remove_id(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t component);
 
FLECS_API
void ecs_auto_override_id(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t component);
 
FLECS_API
void ecs_clear(
    ecs_world_t *world,
    ecs_entity_t entity);
 
FLECS_API
void ecs_remove_all(
    ecs_world_t *world,
    ecs_id_t component);
 
FLECS_API
ecs_entity_t ecs_set_with(
    ecs_world_t *world,
    ecs_id_t component);
 
FLECS_API
ecs_id_t ecs_get_with(
    const ecs_world_t *world);
 
FLECS_API
void ecs_enable(
    ecs_world_t *world,
    ecs_entity_t entity,
    bool enabled);
 
FLECS_API
void ecs_enable_id(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t component,
    bool enable);
 
FLECS_API
bool ecs_is_enabled_id(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t component);
 
FLECS_API
FLECS_ALWAYS_INLINE const void* ecs_get_id(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t component);
 
FLECS_API
FLECS_ALWAYS_INLINE void* ecs_get_mut_id(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t component);
 
FLECS_API
void* ecs_ensure_id(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t component,
    size_t size);
 
FLECS_ALWAYS_INLINE FLECS_API
ecs_ref_t ecs_ref_init_id(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t component);
 
FLECS_ALWAYS_INLINE FLECS_API
void* ecs_ref_get_id(
    const ecs_world_t *world,
    ecs_ref_t *ref,
    ecs_id_t component);
 
FLECS_ALWAYS_INLINE FLECS_API
void ecs_ref_update(
    const ecs_world_t *world,
    ecs_ref_t *ref);
 
FLECS_API
void* ecs_emplace_id(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t component,
    size_t size,
    bool *is_new);
 
FLECS_API
void ecs_modified_id(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t component);
 
FLECS_API
void ecs_set_id(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t component,
    size_t size,
    const void *ptr);
 
FLECS_API
bool ecs_is_valid(
    const ecs_world_t *world,
    ecs_entity_t e);
 
FLECS_API
bool ecs_is_alive(
    const ecs_world_t *world,
    ecs_entity_t e);
 
FLECS_API
ecs_id_t ecs_strip_generation(
    ecs_entity_t e);
 
FLECS_API
ecs_entity_t ecs_get_alive(
    const ecs_world_t *world,
    ecs_entity_t e);
 
FLECS_API
void ecs_make_alive(
    ecs_world_t *world,
    ecs_entity_t entity);
 
FLECS_API
void ecs_make_alive_id(
    ecs_world_t *world,
    ecs_id_t component);
 
FLECS_API
bool ecs_exists(
    const ecs_world_t *world,
    ecs_entity_t entity);
 
FLECS_API
void ecs_set_version(
    ecs_world_t *world,
    ecs_entity_t entity);
 
FLECS_API
uint32_t ecs_get_version(
    ecs_entity_t entity);
 
FLECS_API
const ecs_type_t* ecs_get_type(
    const ecs_world_t *world,
    ecs_entity_t entity);
 
FLECS_API
ecs_table_t* ecs_get_table(
    const ecs_world_t *world,
    ecs_entity_t entity);
 
FLECS_API
char* ecs_type_str(
    const ecs_world_t *world,
    const ecs_type_t* type);
 
FLECS_API
char* ecs_table_str(
    const ecs_world_t *world,
    const ecs_table_t *table);
 
FLECS_API
char* ecs_entity_str(
    const ecs_world_t *world,
    ecs_entity_t entity);
 
FLECS_API
FLECS_ALWAYS_INLINE bool ecs_has_id(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t component);
 
FLECS_API
FLECS_ALWAYS_INLINE bool ecs_owns_id(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t component);
 
FLECS_API
ecs_entity_t ecs_get_target(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_entity_t rel,
    int32_t index);
 
FLECS_API
ecs_entity_t ecs_get_parent(
    const ecs_world_t *world,
    ecs_entity_t entity);
 
FLECS_API
ecs_entity_t ecs_new_w_parent(
    ecs_world_t *world,
    ecs_entity_t parent,
    const char *name);
 
FLECS_API
ecs_entity_t ecs_get_target_for_id(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_entity_t rel,
    ecs_id_t component);
 
FLECS_API
int32_t ecs_get_depth(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_entity_t rel);
 
FLECS_API
int32_t ecs_count_id(
    const ecs_world_t *world,
    ecs_id_t entity);
 
FLECS_API
const char* ecs_get_name(
    const ecs_world_t *world,
    ecs_entity_t entity);
 
FLECS_API
const char* ecs_get_symbol(
    const ecs_world_t *world,
    ecs_entity_t entity);
 
FLECS_API
ecs_entity_t ecs_set_name(
    ecs_world_t *world,
    ecs_entity_t entity,
    const char *name);
 
FLECS_API
ecs_entity_t ecs_set_symbol(
    ecs_world_t *world,
    ecs_entity_t entity,
    const char *symbol);
 
FLECS_API
void ecs_set_alias(
    ecs_world_t *world,
    ecs_entity_t entity,
    const char *alias);
 
FLECS_API
ecs_entity_t ecs_lookup(
    const ecs_world_t *world,
    const char *path);
 
FLECS_API
ecs_entity_t ecs_lookup_child(
    const ecs_world_t *world,
    ecs_entity_t parent,
    const char *name);
 
FLECS_API
ecs_entity_t ecs_lookup_path_w_sep(
    const ecs_world_t *world,
    ecs_entity_t parent,
    const char *path,
    const char *sep,
    const char *prefix,
    bool recursive);
 
FLECS_API
ecs_entity_t ecs_lookup_symbol(
    const ecs_world_t *world,
    const char *symbol,
    bool lookup_as_path,
    bool recursive);
 
FLECS_API
char* ecs_get_path_w_sep(
    const ecs_world_t *world,
    ecs_entity_t parent,
    ecs_entity_t child,
    const char *sep,
    const char *prefix);
 
FLECS_API
void ecs_get_path_w_sep_buf(
    const ecs_world_t *world,
    ecs_entity_t parent,
    ecs_entity_t child,
    const char *sep,
    const char *prefix,
    ecs_strbuf_t *buf,
    bool escape);
 
FLECS_API
ecs_entity_t ecs_new_from_path_w_sep(
    ecs_world_t *world,
    ecs_entity_t parent,
    const char *path,
    const char *sep,
    const char *prefix);
 
FLECS_API
ecs_entity_t ecs_add_path_w_sep(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_entity_t parent,
    const char *path,
    const char *sep,
    const char *prefix);
 
FLECS_API
ecs_entity_t ecs_set_scope(
    ecs_world_t *world,
    ecs_entity_t scope);
 
FLECS_API
ecs_entity_t ecs_get_scope(
    const ecs_world_t *world);
 
FLECS_API
const char* ecs_set_name_prefix(
    ecs_world_t *world,
    const char *prefix);
 
FLECS_API
ecs_entity_t* ecs_set_lookup_path(
    ecs_world_t *world,
    const ecs_entity_t *lookup_path);
 
FLECS_API
ecs_entity_t* ecs_get_lookup_path(
    const ecs_world_t *world);
 
FLECS_API
ecs_entity_t ecs_component_init(
    ecs_world_t *world,
    const ecs_component_desc_t *desc);
 
FLECS_API
const ecs_type_info_t* ecs_get_type_info(
    const ecs_world_t *world,
    ecs_id_t component);
 
FLECS_API
void ecs_set_hooks_id(
    ecs_world_t *world,
    ecs_entity_t component,
    const ecs_type_hooks_t *hooks);
 
FLECS_API
const ecs_type_hooks_t* ecs_get_hooks_id(
    const ecs_world_t *world,
    ecs_entity_t component);
 
FLECS_API
bool ecs_id_is_tag(
    const ecs_world_t *world,
    ecs_id_t component);
 
FLECS_API
bool ecs_id_in_use(
    const ecs_world_t *world,
    ecs_id_t component);
 
FLECS_API
ecs_entity_t ecs_get_typeid(
    const ecs_world_t *world,
    ecs_id_t component);
 
FLECS_API
bool ecs_id_match(
    ecs_id_t component,
    ecs_id_t pattern);
 
FLECS_API
bool ecs_id_is_pair(
    ecs_id_t component);
 
FLECS_API
bool ecs_id_is_wildcard(
    ecs_id_t component);
 
bool ecs_id_is_any(
    ecs_id_t component);
 
FLECS_API
bool ecs_id_is_valid(
    const ecs_world_t *world,
    ecs_id_t component);
 
FLECS_API
ecs_flags32_t ecs_id_get_flags(
    const ecs_world_t *world,
    ecs_id_t component);
 
FLECS_API
const char* ecs_id_flag_str(
    uint64_t component_flags);
 
FLECS_API
char* ecs_id_str(
    const ecs_world_t *world,
    ecs_id_t component);
 
FLECS_API
void ecs_id_str_buf(
    const ecs_world_t *world,
    ecs_id_t component,
    ecs_strbuf_t *buf);
 
FLECS_API
ecs_id_t ecs_id_from_str(
    const ecs_world_t *world,
    const char *expr);
 
FLECS_API 
bool ecs_term_ref_is_set(
    const ecs_term_ref_t *ref);
 
FLECS_API
bool ecs_term_is_initialized(
    const ecs_term_t *term);
 
FLECS_API
bool ecs_term_match_this(
    const ecs_term_t *term);
 
FLECS_API
bool ecs_term_match_0(
    const ecs_term_t *term);
 
FLECS_API
char* ecs_term_str(
    const ecs_world_t *world,
    const ecs_term_t *term);
 
FLECS_API 
char* ecs_query_str(
    const ecs_query_t *query); 
 
FLECS_API
ecs_iter_t ecs_each_id(
    const ecs_world_t *world,
    ecs_id_t component);
 
FLECS_API
bool ecs_each_next(
    ecs_iter_t *it);
 
FLECS_API
FLECS_ALWAYS_INLINE ecs_iter_t ecs_children(
    const ecs_world_t *world,
    ecs_entity_t parent);
 
FLECS_API
FLECS_ALWAYS_INLINE ecs_iter_t ecs_children_w_rel(
    const ecs_world_t *world,
    ecs_entity_t relationship,
    ecs_entity_t parent);
 
FLECS_API
bool ecs_children_next(
    ecs_iter_t *it);
 
FLECS_API
ecs_query_t* ecs_query_init(
    ecs_world_t *world,
    const ecs_query_desc_t *desc);
 
FLECS_API
void ecs_query_fini(
    ecs_query_t *query);
 
FLECS_API
int32_t ecs_query_find_var(
    const ecs_query_t *query,
    const char *name);    
 
FLECS_API
const char* ecs_query_var_name(
    const ecs_query_t *query,
    int32_t var_id);
 
FLECS_API
bool ecs_query_var_is_entity(
    const ecs_query_t *query,
    int32_t var_id);  
 
FLECS_API
ecs_iter_t ecs_query_iter(
    const ecs_world_t *world,
    const ecs_query_t *query);
 
FLECS_API
bool ecs_query_next(
    ecs_iter_t *it);
 
FLECS_API
bool ecs_query_has(
    const ecs_query_t *query,
    ecs_entity_t entity,
    ecs_iter_t *it);
 
FLECS_API
bool ecs_query_has_table(
    const ecs_query_t *query,
    ecs_table_t *table,
    ecs_iter_t *it);
 
FLECS_API
bool ecs_query_has_range(
    const ecs_query_t *query,
    ecs_table_range_t *range,
    ecs_iter_t *it);
 
FLECS_API
int32_t ecs_query_match_count(
    const ecs_query_t *query);
 
FLECS_API
char* ecs_query_plan(
    const ecs_query_t *query);
 
FLECS_API
char* ecs_query_plan_w_profile(
    const ecs_query_t *query,
    const ecs_iter_t *it);
 
FLECS_API
char* ecs_query_plans(
    const ecs_query_t *query);
 
FLECS_API
const char* ecs_query_args_parse(
    ecs_query_t *query,
    ecs_iter_t *it,
    const char *expr);
 
FLECS_API
bool ecs_query_changed(
    ecs_query_t *query);
 
FLECS_API
const ecs_query_t* ecs_query_get(
    const ecs_world_t *world,
    ecs_entity_t query);
 
FLECS_API
void ecs_iter_skip(
    ecs_iter_t *it);
 
FLECS_API
void ecs_iter_set_group(
    ecs_iter_t *it,
    uint64_t group_id);
 
FLECS_API
const ecs_map_t* ecs_query_get_groups(
    const ecs_query_t *query);
 
FLECS_API
void* ecs_query_get_group_ctx(
    const ecs_query_t *query,
    uint64_t group_id);
 
FLECS_API
const ecs_query_group_info_t* ecs_query_get_group_info(
    const ecs_query_t *query,
    uint64_t group_id);
 
typedef struct ecs_query_count_t {
    int32_t results;      
    int32_t entities;     
    int32_t tables;       
} ecs_query_count_t;
 
FLECS_API
ecs_query_count_t ecs_query_count(
    const ecs_query_t *query);
 
FLECS_API
bool ecs_query_is_true(
    const ecs_query_t *query);
 
FLECS_API
const ecs_query_t* ecs_query_get_cache_query(
    const ecs_query_t *query);
 
FLECS_API
void ecs_emit(
    ecs_world_t *world,
    ecs_event_desc_t *desc);
 
FLECS_API
void ecs_enqueue(
    ecs_world_t *world,
    ecs_event_desc_t *desc);
 
FLECS_API
ecs_entity_t ecs_observer_init(
    ecs_world_t *world,
    const ecs_observer_desc_t *desc);
 
FLECS_API
const ecs_observer_t* ecs_observer_get(
    const ecs_world_t *world,
    ecs_entity_t observer);
 
FLECS_API
bool ecs_iter_next(
    ecs_iter_t *it);
 
FLECS_API
void ecs_iter_fini(
    ecs_iter_t *it);
 
FLECS_API
int32_t ecs_iter_count(
    ecs_iter_t *it);
 
FLECS_API
bool ecs_iter_is_true(
    ecs_iter_t *it);
 
FLECS_API
ecs_entity_t ecs_iter_first(
    ecs_iter_t *it);
 
FLECS_API
void ecs_iter_set_var(
    ecs_iter_t *it,
    int32_t var_id,
    ecs_entity_t entity);
 
FLECS_API
void ecs_iter_set_var_as_table(
    ecs_iter_t *it,
    int32_t var_id,
    const ecs_table_t *table);
 
FLECS_API
void ecs_iter_set_var_as_range(
    ecs_iter_t *it,
    int32_t var_id,
    const ecs_table_range_t *range);
 
FLECS_API
ecs_entity_t ecs_iter_get_var(
    ecs_iter_t *it,
    int32_t var_id);
 
FLECS_API
const char* ecs_iter_get_var_name(
    const ecs_iter_t *it,
    int32_t var_id);
 
FLECS_API
int32_t ecs_iter_get_var_count(
    const ecs_iter_t *it);
 
FLECS_API
ecs_var_t* ecs_iter_get_vars(
    const ecs_iter_t *it);
 
FLECS_API
ecs_table_t* ecs_iter_get_var_as_table(
    ecs_iter_t *it,
    int32_t var_id);
 
FLECS_API
ecs_table_range_t ecs_iter_get_var_as_range(
    ecs_iter_t *it,
    int32_t var_id);
 
FLECS_API
bool ecs_iter_var_is_constrained(
    ecs_iter_t *it,
    int32_t var_id);
 
FLECS_API
uint64_t ecs_iter_get_group(
    const ecs_iter_t *it);
 
FLECS_API
bool ecs_iter_changed(
    ecs_iter_t *it);
 
FLECS_API
char* ecs_iter_str(
    const ecs_iter_t *it);
 
FLECS_API
ecs_iter_t ecs_page_iter(
    const ecs_iter_t *it,
    int32_t offset,
    int32_t limit);
 
FLECS_API
bool ecs_page_next(
    ecs_iter_t *it);
 
FLECS_API
ecs_iter_t ecs_worker_iter(
    const ecs_iter_t *it,
    int32_t index,
    int32_t count);
 
FLECS_API
bool ecs_worker_next(
    ecs_iter_t *it);
 
FLECS_API
void* ecs_field_w_size(
    const ecs_iter_t *it,
    size_t size,
    int8_t index);
 
FLECS_API
void* ecs_field_at_w_size(
    const ecs_iter_t *it,
    size_t size,
    int8_t index,
    int32_t row);
 
FLECS_API
bool ecs_field_is_readonly(
    const ecs_iter_t *it,
    int8_t index);
 
FLECS_API
bool ecs_field_is_writeonly(
    const ecs_iter_t *it,
    int8_t index);
 
FLECS_API
bool ecs_field_is_set(
    const ecs_iter_t *it,
    int8_t index);
 
FLECS_API
ecs_id_t ecs_field_id(
    const ecs_iter_t *it,
    int8_t index);
 
FLECS_API
int32_t ecs_field_column(
    const ecs_iter_t *it,
    int8_t index);
 
FLECS_API
ecs_entity_t ecs_field_src(
    const ecs_iter_t *it,
    int8_t index);
 
FLECS_API
size_t ecs_field_size(
    const ecs_iter_t *it,
    int8_t index);
 
FLECS_API
bool ecs_field_is_self(
    const ecs_iter_t *it,
    int8_t index);
 
FLECS_API
const ecs_type_t* ecs_table_get_type(
    const ecs_table_t *table);
 
FLECS_API
int32_t ecs_table_get_type_index(
    const ecs_world_t *world,
    const ecs_table_t *table,
    ecs_id_t component);
 
FLECS_API
int32_t ecs_table_get_column_index(
    const ecs_world_t *world,
    const ecs_table_t *table,
    ecs_id_t component);
 
FLECS_API
int32_t ecs_table_column_count(
    const ecs_table_t *table);
 
FLECS_API
int32_t ecs_table_type_to_column_index(
    const ecs_table_t *table,
    int32_t index);
 
FLECS_API
int32_t ecs_table_column_to_type_index(
    const ecs_table_t *table,
    int32_t index);
 
FLECS_API
void* ecs_table_get_column(
    const ecs_table_t *table,
    int32_t index,
    int32_t offset);
 
FLECS_API
void* ecs_table_get_id(
    const ecs_world_t *world,
    const ecs_table_t *table,
    ecs_id_t component,
    int32_t offset);
 
FLECS_API
size_t ecs_table_get_column_size(
    const ecs_table_t *table,
    int32_t index);
 
FLECS_API
int32_t ecs_table_count(
    const ecs_table_t *table);
 
FLECS_API
int32_t ecs_table_size(
    const ecs_table_t *table);
 
FLECS_API
const ecs_entity_t* ecs_table_entities(
    const ecs_table_t *table);
 
FLECS_API
bool ecs_table_has_id(
    const ecs_world_t *world,
    const ecs_table_t *table,
    ecs_id_t component);
 
FLECS_API
ecs_entity_t ecs_table_get_target(
    const ecs_world_t *world,
    const ecs_table_t *table,
    ecs_entity_t relationship,
    int32_t index);
 
FLECS_API
int32_t ecs_table_get_depth(
    const ecs_world_t *world,
    const ecs_table_t *table,
    ecs_entity_t rel);
 
FLECS_API
ecs_table_t* ecs_table_add_id(
    ecs_world_t *world,
    ecs_table_t *table,
    ecs_id_t component);
 
FLECS_API
ecs_table_t* ecs_table_find(
    ecs_world_t *world,
    const ecs_id_t *ids,
    int32_t id_count);
 
FLECS_API
ecs_table_t* ecs_table_remove_id(
    ecs_world_t *world,
    ecs_table_t *table,
    ecs_id_t component);
 
FLECS_API
void ecs_table_lock(
    ecs_world_t *world,
    ecs_table_t *table);
 
FLECS_API
void ecs_table_unlock(
    ecs_world_t *world,
    ecs_table_t *table);
 
FLECS_API
bool ecs_table_has_flags(
    ecs_table_t *table,
    ecs_flags32_t flags);
 
FLECS_API
bool ecs_table_has_traversable(
    const ecs_table_t *table);
 
FLECS_API
void ecs_table_swap_rows(
    ecs_world_t* world,
    ecs_table_t* table,
    int32_t row_1,
    int32_t row_2);
 
FLECS_API
bool ecs_commit(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_record_t *record,
    ecs_table_t *table,
    const ecs_type_t *added,
    const ecs_type_t *removed);
 
 
FLECS_API
int32_t ecs_search(
    const ecs_world_t *world,
    const ecs_table_t *table,
    ecs_id_t component,
    ecs_id_t *component_out);
 
FLECS_API
int32_t ecs_search_offset(
    const ecs_world_t *world,
    const ecs_table_t *table,
    int32_t offset,
    ecs_id_t component,
    ecs_id_t *component_out);
 
FLECS_API
int32_t ecs_search_relation(
    const ecs_world_t *world,
    const ecs_table_t *table,
    int32_t offset,
    ecs_id_t component,
    ecs_entity_t rel,
    ecs_flags64_t flags, /* EcsSelf and/or EcsUp */
    ecs_entity_t *tgt_out,
    ecs_id_t *component_out,
    struct ecs_table_record_t **tr_out);
 
FLECS_API
int32_t ecs_search_relation_for_entity(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t id,
    ecs_entity_t rel,
    bool self,
    ecs_component_record_t *cr,
    ecs_entity_t *tgt_out,
    ecs_id_t *id_out,
    struct ecs_table_record_t **tr_out);
 
FLECS_API
void ecs_table_clear_entities(
    ecs_world_t* world,
    ecs_table_t* table);
 
FLECS_API
int ecs_value_init(
    const ecs_world_t *world,
    ecs_entity_t type,
    void *ptr);
 
FLECS_API
int ecs_value_init_w_type_info(
    const ecs_world_t *world,
    const ecs_type_info_t *ti,
    void *ptr);
 
FLECS_API
void* ecs_value_new(
    ecs_world_t *world,
    ecs_entity_t type);
 
void* ecs_value_new_w_type_info(
    ecs_world_t *world,
    const ecs_type_info_t *ti);
 
int ecs_value_fini_w_type_info(
    const ecs_world_t *world,
    const ecs_type_info_t *ti,
    void *ptr);
 
FLECS_API
int ecs_value_fini(
    const ecs_world_t *world,
    ecs_entity_t type,
    void* ptr);
 
FLECS_API
int ecs_value_free(
    ecs_world_t *world,
    ecs_entity_t type,
    void* ptr);
 
FLECS_API
int ecs_value_copy_w_type_info(
    const ecs_world_t *world,
    const ecs_type_info_t *ti,
    void* dst,
    const void *src);
 
FLECS_API
int ecs_value_copy(
    const ecs_world_t *world,
    ecs_entity_t type,
    void* dst,
    const void *src);
 
int ecs_value_move_w_type_info(
    const ecs_world_t *world,
    const ecs_type_info_t *ti,
    void* dst,
    void *src);
 
int ecs_value_move(
    const ecs_world_t *world,
    ecs_entity_t type,
    void* dst,
    void *src);
 
int ecs_value_move_ctor_w_type_info(
    const ecs_world_t *world,
    const ecs_type_info_t *ti,
    void* dst,
    void *src);
 
int ecs_value_move_ctor(
    const ecs_world_t *world,
    ecs_entity_t type,
    void* dst,
    void *src);
 
#include "flecs/addons/flecs_c.h"
 
#ifdef __cplusplus
}
#endif
 
#include "flecs/private/addons.h"
 
#endif