flecs.h

Go to the documentation of this file.

 
#ifndef FLECS_H
#define FLECS_H
 
/* Flecs version macro */
#define FLECS_VERSION_MAJOR 3
#define FLECS_VERSION_MINOR 2
#define FLECS_VERSION_PATCH 12
#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_LEGACY
 
#define FLECS_NO_DEPRECATED_WARNINGS
 
// #define FLECS_ACCURATE_COUNTERS
 
/* Make sure provided configuration is valid */
#if defined(FLECS_DEBUG) && defined(FLECS_NDEBUG)
#error "invalid configuration: cannot both define FLECS_DEBUG and FLECS_NDEBUG"
#endif
#if defined(FLECS_DEBUG) && defined(NDEBUG)
#error "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
 
/* 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_CUSTOM_BUILD
 
// #define FLECS_CPP_NO_AUTO_REGISTRATION
 
#ifndef FLECS_CUSTOM_BUILD
// #define FLECS_C          /**< C API convenience macros, always enabled */
#define FLECS_CPP           
#define FLECS_MODULE        
#define FLECS_PARSER        
#define FLECS_PLECS         
#define FLECS_RULES         
#define FLECS_SNAPSHOT      
#define FLECS_STATS         
#define FLECS_MONITOR       
#define FLECS_METRICS       
#define FLECS_ALERTS        
#define FLECS_SYSTEM        
#define FLECS_PIPELINE      
#define FLECS_TIMER         
#define FLECS_META          
#define FLECS_META_C        
#define FLECS_UNITS         
#define FLECS_EXPR          
#define FLECS_JSON          
#define FLECS_DOC           
#define FLECS_LOG           
#define FLECS_APP           
#define FLECS_OS_API_IMPL   
#define FLECS_HTTP          
#define FLECS_REST          
// #define FLECS_JOURNAL    /**< Journaling addon (disabled by default) */
#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_SPARSE_PAGE_BITS (6)
#define FLECS_ENTITY_PAGE_BITS (6)
#define FLECS_USE_OS_ALLOC
#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 (12)
#endif
 
#ifndef FLECS_ENTITY_PAGE_BITS
#define FLECS_ENTITY_PAGE_BITS (12)
#endif
 
// #define FLECS_USE_OS_ALLOC
 
#ifndef FLECS_ID_DESC_MAX
#define FLECS_ID_DESC_MAX (32)
#endif
 
#define FLECS_TERM_DESC_MAX (16)
 
#define FLECS_EVENT_DESC_MAX (8)
 
#define FLECS_VARIABLE_COUNT_MAX (64)
 
#define FLECS_QUERY_SCOPE_NESTING_MAX (8)
 
#include "flecs/private/api_defines.h"
#include "flecs/private/vec.h"              /* Vector datatype */
#include "flecs/private/sparse.h"           /* Sparse set */
#include "flecs/private/block_allocator.h"  /* Block allocator */
#include "flecs/private/map.h"              /* Map */
#include "flecs/private/allocator.h"        /* Allocator */
#include "flecs/private/strbuf.h"           /* String builder */
#include "flecs/os_api.h"  /* Abstraction for operating system functions */
 
#ifdef __cplusplus
extern "C" {
#endif
 
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_table_t ecs_table_t;
 
typedef struct ecs_term_t ecs_term_t;
 
typedef struct ecs_filter_t ecs_filter_t;
 
typedef struct ecs_query_t ecs_query_t;
 
typedef struct ecs_rule_t ecs_rule_t;
 
typedef struct ecs_observer_t ecs_observer_t;
 
typedef struct ecs_observable_t ecs_observable_t;
 
/* Type used for iterating iterable objects.
 * Iterators are a common interface across iterable objects (world, filters,
 * rules, queries, systems, observers) to provide applications with information
 * about the currently iterated result, and to store any state required for the
 * iteration. */
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_id_record_t ecs_id_record_t;
 
typedef struct ecs_table_record_t ecs_table_record_t;
 
typedef void ecs_poly_t;
 
typedef struct ecs_mixins_t ecs_mixins_t;
 
typedef struct ecs_header_t {
    int32_t magic; /* Magic number verifying it's a flecs object */
    int32_t type;  /* Magic number indicating which type of flecs object */
    ecs_mixins_t *mixins; /* Table with offsets to (optional) mixins */
} ecs_header_t;
 
typedef void (*ecs_run_action_t)(
    ecs_iter_t *it);
 
typedef void (*ecs_iter_action_t)(
    ecs_iter_t *it);
 
typedef void (*ecs_iter_init_action_t)(
    const ecs_world_t *world,
    const ecs_poly_t *iterable,
    ecs_iter_t *it,
    ecs_term_t *filter);
 
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);
 
/* Callback invoked when a query creates a new group. */
typedef void* (*ecs_group_create_action_t)(
    ecs_world_t *world,
    uint64_t group_id,
    void *group_by_ctx); /* from ecs_query_desc_t */
 
/* Callback invoked when a query deletes an existing group. */
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);
 
/* Destructor function for poly objects */
typedef void (*ecs_poly_dtor_t)(
    ecs_poly_t *poly);
 
typedef struct ecs_iterable_t {
    ecs_iter_init_action_t init; 
} ecs_iterable_t;
 
typedef enum ecs_inout_kind_t {
    EcsInOutDefault,  
    EcsInOutNone,     
    EcsInOut,         
    EcsIn,            
    EcsOut,           
} ecs_inout_kind_t;
 
typedef enum ecs_oper_kind_t {
    EcsAnd,           
    EcsOr,            
    EcsNot,           
    EcsOptional,      
    EcsAndFrom,       
    EcsOrFrom,        
    EcsNotFrom,       
} ecs_oper_kind_t;
 
/* Term id flags  */
#define EcsSelf                       (1u << 1)  
#define EcsUp                         (1u << 2)  
#define EcsDown                       (1u << 3)  
#define EcsTraverseAll                (1u << 4)  
#define EcsCascade                    (1u << 5)  
#define EcsDesc                       (1u << 6)  
#define EcsParent                     (1u << 7)  
#define EcsIsVariable                 (1u << 8)  
#define EcsIsEntity                   (1u << 9)  
#define EcsIsName                     (1u << 10) 
#define EcsFilter                     (1u << 11) 
#define EcsTraverseFlags              (EcsUp|EcsDown|EcsTraverseAll|EcsSelf|EcsCascade|EcsDesc|EcsParent)
 
/* Term flags discovered & set during filter creation. Mostly used internally to
 * store information relevant to queries. */
#define EcsTermMatchAny               (1u << 0)
#define EcsTermMatchAnySrc            (1u << 1)
#define EcsTermSrcFirstEq             (1u << 2)
#define EcsTermSrcSecondEq            (1u << 3)
#define EcsTermTransitive             (1u << 4)
#define EcsTermReflexive              (1u << 5)
#define EcsTermIdInherited            (1u << 6)
#define EcsTermIsTrivial              (1u << 7)
#define EcsTermNoData                 (1u << 8)
 
/* Term flags used for term iteration */
#define EcsTermMatchDisabled          (1u << 7)
#define EcsTermMatchPrefab            (1u << 8)
 
typedef struct ecs_term_id_t {
    ecs_entity_t id;            
    const char *name;           
    ecs_entity_t trav;          
    ecs_flags32_t flags;        
} ecs_term_id_t;
 
struct ecs_term_t {
    ecs_id_t id;                
    ecs_term_id_t src;          
    ecs_term_id_t first;        
    ecs_term_id_t second;       
    ecs_inout_kind_t inout;     
    ecs_oper_kind_t oper;       
    ecs_id_t id_flags;          
    char *name;                 
    int32_t field_index;        
    ecs_id_record_t *idr;       
    ecs_flags16_t flags;        
    bool move;                  
};
 
FLECS_API extern ecs_filter_t ECS_FILTER_INIT;
 
struct ecs_filter_t {
    ecs_header_t hdr;
 
    int8_t term_count;        
    int8_t field_count;       
    ecs_flags32_t flags;      
    ecs_flags64_t data_fields; 
    ecs_term_t *terms;         
    char *variable_names[1];   
    int32_t *sizes;            
    ecs_id_t *ids;             
    int32_t eval_count;        
    /* Mixins */
    ecs_entity_t entity;       
    ecs_iterable_t iterable;   
    ecs_poly_dtor_t dtor;      
    ecs_world_t *world;        
};
 
/* An observer reacts to events matching a filter */
struct ecs_observer_t {
    ecs_header_t hdr;
 
    ecs_filter_t filter;        
    /* Observer events */
    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 *binding_ctx;          
    ecs_ctx_free_t ctx_free;    
    ecs_ctx_free_t binding_ctx_free; 
    ecs_observable_t *observable; 
    int32_t *last_event_id;     
    int32_t last_event_id_storage;
 
    ecs_id_t register_id;       
    int32_t term_index;         
    ecs_flags32_t flags;        
    /* Mixins */
    ecs_poly_dtor_t dtor;
};
 
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_iter_action_t on_add;
 
    ecs_iter_action_t on_set;
 
    ecs_iter_action_t on_remove;
 
    void *ctx;                       
    void *binding_ctx;               
    ecs_ctx_free_t ctx_free;         
    ecs_ctx_free_t binding_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/private/vec.h"              /* Vector */
#include "flecs/private/hashmap.h"          /* Hashmap */
 
typedef struct ecs_entity_desc_t {
    int32_t _canary;
 
    ecs_entity_t id;      
    const char *name;     
    const char *sep;      
    const char *root_sep; 
    const char *symbol;   
    bool use_low_id;      
    ecs_id_t add[FLECS_ID_DESC_MAX];
 
    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;
 
typedef struct ecs_filter_desc_t {
    int32_t _canary;
 
    ecs_term_t terms[FLECS_TERM_DESC_MAX];
 
    ecs_term_t *terms_buffer;
 
    int32_t terms_buffer_count;
 
    ecs_filter_t *storage;
 
    bool instanced;
 
    ecs_flags32_t flags;
 
    const char *expr;
 
    ecs_entity_t entity;
} ecs_filter_desc_t;
 
typedef struct ecs_query_desc_t {
    int32_t _canary;
 
    ecs_filter_desc_t filter;
 
    ecs_entity_t order_by_component;
 
    ecs_order_by_action_t order_by;
 
    ecs_sort_table_action_t sort_table;
 
    ecs_id_t group_by_id;
 
    ecs_group_by_action_t group_by;
 
    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;
 
    ecs_query_t *parent;
 
    void *ctx;
 
    void *binding_ctx;
 
    ecs_ctx_free_t ctx_free;
 
    ecs_ctx_free_t binding_ctx_free;
} ecs_query_desc_t;
 
typedef struct ecs_observer_desc_t {
    int32_t _canary;
 
    ecs_entity_t entity;
 
    ecs_filter_desc_t filter;
 
    ecs_entity_t events[FLECS_EVENT_DESC_MAX];
 
    bool yield_existing;
 
    ecs_iter_action_t callback;
 
    ecs_run_action_t run;
 
    void *ctx;
 
    void *binding_ctx;
 
    ecs_ctx_free_t ctx_free;
 
    ecs_ctx_free_t binding_ctx_free;
 
    ecs_poly_t *observable;
 
    int32_t *last_event_id;
 
    int32_t term_index;
} 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;
 
    /* Same as param, but with the guarantee that the value won't be modified.
     * When an event with a const parameter is enqueued, the value of the param
     * is copied to a temporary storage of the event type. */
    const void *const_param;
 
    ecs_poly_t *observable;
 
    ecs_flags32_t flags;
} ecs_event_desc_t;
 
 
/* Utility to hold a value of a dynamic type */
typedef struct ecs_value_t {
    ecs_entity_t type;
    void *ptr;
} ecs_value_t;
 
typedef struct ecs_build_info_t {
    const char *compiler;           
    const char **addons;            
    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_entity_t min_id;              
    ecs_entity_t max_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 world_time_total;     
    ecs_ftime_t world_time_total_raw; 
    ecs_ftime_t rematch_time_total;   
    int64_t frame_count_total;        
    int64_t merge_count_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_frame;        
    int64_t observers_ran_frame;      
    int32_t tag_id_count;             
    int32_t component_id_count;       
    int32_t pair_id_count;            
    int32_t table_count;              
    int32_t empty_table_count;        
    /* -- 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 {
    int32_t match_count;  
    int32_t table_count;  
    void *ctx;            
} ecs_query_group_info_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 EcsFlattenTarget {
    int32_t count;
    ecs_record_t *target;
} EcsFlattenTarget;
 
typedef ecs_iterable_t EcsIterable;
 
/* 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_OVERRIDE;
 
FLECS_API extern const ecs_id_t ECS_TOGGLE;
 
FLECS_API extern const ecs_id_t ECS_AND;
 
/* Builtin 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(EcsIterable);
FLECS_API extern const ecs_entity_t ecs_id(EcsPoly);
 
FLECS_API extern const ecs_entity_t EcsQuery;
FLECS_API extern const ecs_entity_t EcsObserver;
 
/* System module component ids */
FLECS_API extern const ecs_entity_t EcsSystem;
FLECS_API extern const ecs_entity_t ecs_id(EcsTickSource);
 
/* Pipeline module component ids */
FLECS_API extern const ecs_entity_t ecs_id(EcsPipelineQuery);
 
/* Timer module component ids */
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 EcsDontInherit;
 
FLECS_API extern const ecs_entity_t EcsAlwaysOverride;
 
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 EcsTag;
 
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 EcsUnion;
 
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 EcsModule;
 
FLECS_API extern const ecs_entity_t EcsPrivate;
 
FLECS_API extern const ecs_entity_t EcsPrefab;
 
FLECS_API extern const ecs_entity_t EcsDisabled;
 
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 EcsUnSet;
 
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 EcsOnTableEmpty;
 
FLECS_API extern const ecs_entity_t EcsOnTableFill;
 
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 ecs_id(EcsFlattenTarget);
 
FLECS_API extern const ecs_entity_t EcsFlatten;
 
FLECS_API extern const ecs_entity_t EcsDefaultChildComponent;
 
/* Builtin predicates for comparing entity ids in queries. Only supported by rules */
FLECS_API extern const ecs_entity_t EcsPredEq;
FLECS_API extern const ecs_entity_t EcsPredMatch;
FLECS_API extern const ecs_entity_t EcsPredLookup;
 
/* Builtin marker entities for opening/closing query scopes */
FLECS_API extern const ecs_entity_t EcsScopeOpen;
FLECS_API extern const ecs_entity_t EcsScopeClose;
 
FLECS_API extern const ecs_entity_t EcsEmpty;
 
/* Pipeline module tags */
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;
 
#define EcsLastInternalComponentId (ecs_id(EcsPoly))
 
#define EcsFirstUserComponentId (8)
 
#define EcsFirstUserEntityId (FLECS_HI_COMPONENT_ID + 128)
 
/* When visualized the reserved id ranges look like this:
 * [1..8]: Builtin components
 * [9..FLECS_HI_COMPONENT_ID]: Low ids reserved for application components
 * [FLECS_HI_COMPONENT_ID + 1..EcsFirstUserEntityId]: Builtin 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);
 
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
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 *world);
 
FLECS_API
bool ecs_defer_begin(
    ecs_world_t *world);
 
FLECS_API
bool ecs_is_deferred(
    const 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
void ecs_set_automerge(
    ecs_world_t *world,
    bool automerge);
 
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
int32_t ecs_get_stage_id(
    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_async_stage_new(
    ecs_world_t *world);
 
FLECS_API
void ecs_async_stage_free(
    ecs_world_t *stage);
 
FLECS_API
bool ecs_stage_is_async(
    ecs_world_t *stage);
 
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);
 
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_set_entity_range(
    ecs_world_t *world,
    ecs_entity_t id_start,
    ecs_entity_t id_end);
 
FLECS_API
bool ecs_enable_range_check(
    ecs_world_t *world,
    bool enable);
 
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);
 
FLECS_API
int32_t ecs_delete_empty_tables(
    ecs_world_t *world,
    ecs_id_t id,
    uint16_t clear_generation,
    uint16_t delete_generation,
    int32_t min_id_count,
    double time_budget_seconds);
 
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 ecs_poly_is_(
    const ecs_poly_t *object,
    int32_t type);
 
#define ecs_poly_is(object, type)\
    ecs_poly_is_(object, type##_magic)
 
FLECS_API
ecs_id_t ecs_make_pair(
    ecs_entity_t first,
    ecs_entity_t second);
 
FLECS_API
ecs_entity_t ecs_new_id(
    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 id);
 
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 id,
    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 id);
 
FLECS_API
void ecs_add_id(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t id);
 
FLECS_API
void ecs_remove_id(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t id);
 
FLECS_API
void ecs_override_id(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t id);
 
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 id);
 
FLECS_API
ecs_entity_t ecs_set_with(
    ecs_world_t *world,
    ecs_id_t id);
 
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 id,
    bool enable);
 
FLECS_API
bool ecs_is_enabled_id(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t id);
 
FLECS_API
const void* ecs_get_id(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t id);
 
FLECS_API
void* ecs_get_mut_id(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t id);
 
FLECS_API
void* ecs_ensure_id(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t id);
 
FLECS_API
void* ecs_ensure_modified_id(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t id);
 
FLECS_API
ecs_ref_t ecs_ref_init_id(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t id);
 
FLECS_API
void* ecs_ref_get_id(
    const ecs_world_t *world,
    ecs_ref_t *ref,
    ecs_id_t id);
 
FLECS_API
void ecs_ref_update(
    const ecs_world_t *world,
    ecs_ref_t *ref);
 
FLECS_API
ecs_record_t* ecs_write_begin(
    ecs_world_t *world,
    ecs_entity_t entity);
 
FLECS_API
void ecs_write_end(
    ecs_record_t *record);
 
FLECS_API
const ecs_record_t* ecs_read_begin(
    ecs_world_t *world,
    ecs_entity_t entity);
 
FLECS_API
void ecs_read_end(
    const ecs_record_t *record);
 
FLECS_API
ecs_entity_t ecs_record_get_entity(
    const ecs_record_t *record);
 
FLECS_API
const void* ecs_record_get_id(
    const ecs_world_t *world,
    const ecs_record_t *record,
    ecs_id_t id);
 
FLECS_API
void* ecs_record_ensure_id(
    ecs_world_t *world,
    ecs_record_t *record,
    ecs_id_t id);
 
FLECS_API
bool ecs_record_has_id(
    ecs_world_t *world,
    const ecs_record_t *record,
    ecs_id_t id);
 
FLECS_API
void* ecs_emplace_id(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t id);
 
FLECS_API
void ecs_modified_id(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t id);
 
FLECS_API
ecs_entity_t ecs_set_id(
    ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t id,
    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
void ecs_set_entity_generation(
    ecs_world_t *world,
    ecs_entity_t entity);
 
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 id);
 
FLECS_API
bool ecs_exists(
    const ecs_world_t *world,
    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
bool ecs_has_id(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t id);
 
FLECS_API
bool ecs_owns_id(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_id_t id);
 
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_get_target_for_id(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_entity_t rel,
    ecs_id_t id);
 
FLECS_API
int32_t ecs_get_depth(
    const ecs_world_t *world,
    ecs_entity_t entity,
    ecs_entity_t rel);
 
typedef struct ecs_flatten_desc_t {
    /* When true, the flatten operation will not remove names from entities in
     * the flattened tree. This may fail if entities from different subtrees
     * have the same name. */
    bool keep_names;
 
    /* When true, the flattened tree won't contain information about the
     * original depth of the entities. This can reduce fragmentation, but may
     * cause existing code, such as cascade queries, to no longer work. */
    bool lose_depth;
} ecs_flatten_desc_t;
 
FLECS_API
void ecs_flatten(
    ecs_world_t *world,
    ecs_id_t pair,
    const ecs_flatten_desc_t *desc);
 
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);
 
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);
 
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 id);
 
FLECS_API
void ecs_set_hooks_id(
    ecs_world_t *world,
    ecs_entity_t id,
    const ecs_type_hooks_t *hooks);
 
FLECS_API
const ecs_type_hooks_t* ecs_get_hooks_id(
    ecs_world_t *world,
    ecs_entity_t id);
 
FLECS_API
bool ecs_id_is_tag(
    const ecs_world_t *world,
    ecs_id_t id);
 
FLECS_API
bool ecs_id_is_union(
    const ecs_world_t *world,
    ecs_id_t id);
 
FLECS_API
bool ecs_id_in_use(
    const ecs_world_t *world,
    ecs_id_t id);
 
FLECS_API
ecs_entity_t ecs_get_typeid(
    const ecs_world_t *world,
    ecs_id_t id);
 
FLECS_API
bool ecs_id_match(
    ecs_id_t id,
    ecs_id_t pattern);
 
FLECS_API
bool ecs_id_is_pair(
    ecs_id_t id);
 
FLECS_API
bool ecs_id_is_wildcard(
    ecs_id_t id);
 
FLECS_API
bool ecs_id_is_valid(
    const ecs_world_t *world,
    ecs_id_t id);
 
FLECS_API
ecs_flags32_t ecs_id_get_flags(
    const ecs_world_t *world,
    ecs_id_t id);
 
FLECS_API
const char* ecs_id_flag_str(
    ecs_id_t id_flags);
 
FLECS_API
char* ecs_id_str(
    const ecs_world_t *world,
    ecs_id_t id);
 
FLECS_API
void ecs_id_str_buf(
    const ecs_world_t *world,
    ecs_id_t id,
    ecs_strbuf_t *buf);
 
FLECS_API
ecs_iter_t ecs_term_iter(
    const ecs_world_t *world,
    ecs_term_t *term);
 
FLECS_API
ecs_iter_t ecs_term_chain_iter(
    const ecs_iter_t *it,
    ecs_term_t *term);
 
FLECS_API
bool ecs_term_next(
    ecs_iter_t *it);
 
FLECS_API
ecs_iter_t ecs_children(
    const ecs_world_t *world,
    ecs_entity_t parent);
 
FLECS_API
bool ecs_children_next(
    ecs_iter_t *it);
 
FLECS_API
bool ecs_term_id_is_set(
    const ecs_term_id_t *id);
 
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
int ecs_term_finalize(
    const ecs_world_t *world,
    ecs_term_t *term);
 
FLECS_API
ecs_term_t ecs_term_copy(
    const ecs_term_t *src);
 
FLECS_API
ecs_term_t ecs_term_move(
    ecs_term_t *src);
 
FLECS_API
void ecs_term_fini(
    ecs_term_t *term);
 
FLECS_API
ecs_filter_t * ecs_filter_init(
    ecs_world_t *world,
    const ecs_filter_desc_t *desc);
 
FLECS_API
void ecs_filter_fini(
    ecs_filter_t *filter);
 
FLECS_API
int ecs_filter_finalize(
    const ecs_world_t *world,
    ecs_filter_t *filter);
 
FLECS_API
int32_t ecs_filter_find_this_var(
    const ecs_filter_t *filter);
 
FLECS_API
char* ecs_term_str(
    const ecs_world_t *world,
    const ecs_term_t *term);
 
FLECS_API
char* ecs_filter_str(
    const ecs_world_t *world,
    const ecs_filter_t *filter);
 
FLECS_API
ecs_iter_t ecs_filter_iter(
    const ecs_world_t *world,
    const ecs_filter_t *filter);
 
FLECS_API
ecs_iter_t ecs_filter_chain_iter(
    const ecs_iter_t *it,
    const ecs_filter_t *filter);
 
FLECS_API
int32_t ecs_filter_pivot_term(
    const ecs_world_t *world,
    const ecs_filter_t *filter);
 
FLECS_API
bool ecs_filter_next(
    ecs_iter_t *it);
 
FLECS_API
bool ecs_filter_next_instanced(
    ecs_iter_t *it);
 
FLECS_API
void ecs_filter_move(
    ecs_filter_t *dst,
    ecs_filter_t *src);
 
FLECS_API
void ecs_filter_copy(
    ecs_filter_t *dst,
    const ecs_filter_t *src);
 
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
const ecs_filter_t* ecs_query_get_filter(
    const ecs_query_t *query);
 
FLECS_API
ecs_iter_t ecs_query_iter(
    const ecs_world_t *world,
    ecs_query_t *query);
 
FLECS_API
bool ecs_query_next(
    ecs_iter_t *iter);
 
FLECS_API
bool ecs_query_next_instanced(
    ecs_iter_t *iter);
 
FLECS_API
bool ecs_query_next_table(
    ecs_iter_t *iter);
 
FLECS_API
int ecs_query_populate(
    ecs_iter_t *iter,
    bool when_changed);
 
FLECS_API
bool ecs_query_changed(
    ecs_query_t *query,
    const ecs_iter_t *it);
 
FLECS_API
void ecs_query_skip(
    ecs_iter_t *it);
 
FLECS_API
void ecs_query_set_group(
    ecs_iter_t *it,
    uint64_t group_id);
 
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);
 
FLECS_API
bool ecs_query_orphaned(
    const ecs_query_t *query);
 
FLECS_API
char* ecs_query_str(
    const ecs_query_t *query);
 
FLECS_API
int32_t ecs_query_table_count(
    const ecs_query_t *query);
 
FLECS_API
int32_t ecs_query_empty_table_count(
    const ecs_query_t *query);
 
FLECS_API
int32_t ecs_query_entity_count(
    const ecs_query_t *query);
 
FLECS_API
void* ecs_query_get_ctx(
    const ecs_query_t *query);
 
FLECS_API
void* ecs_query_get_binding_ctx(
    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
bool ecs_observer_default_run_action(
    ecs_iter_t *it);
 
FLECS_API
void* ecs_observer_get_ctx(
    const ecs_world_t *world,
    ecs_entity_t observer);
 
FLECS_API
void* ecs_observer_get_binding_ctx(
    const ecs_world_t *world,
    ecs_entity_t observer);
 
FLECS_API
const ecs_filter_t* ecs_observer_get_filter(
    const ecs_world_t *world,
    ecs_entity_t observer);
 
FLECS_API
void ecs_iter_poly(
    const ecs_world_t *world,
    const ecs_poly_t *poly,
    ecs_iter_t *iter,
    ecs_term_t *filter);
 
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
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
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,
    int32_t index);
 
FLECS_API
bool ecs_field_is_readonly(
    const ecs_iter_t *it,
    int32_t index);
 
FLECS_API
bool ecs_field_is_writeonly(
    const ecs_iter_t *it,
    int32_t index);
 
FLECS_API
bool ecs_field_is_set(
    const ecs_iter_t *it,
    int32_t index);
 
FLECS_API
ecs_id_t ecs_field_id(
    const ecs_iter_t *it,
    int32_t index);
 
FLECS_API
int32_t ecs_field_column_index(
    const ecs_iter_t *it,
    int32_t index);
 
FLECS_API
ecs_entity_t ecs_field_src(
    const ecs_iter_t *it,
    int32_t index);
 
FLECS_API
size_t ecs_field_size(
    const ecs_iter_t *it,
    int32_t index);
 
FLECS_API
bool ecs_field_is_self(
    const ecs_iter_t *it,
    int32_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 id);
 
FLECS_API
int32_t ecs_table_get_column_index(
    const ecs_world_t *world,
    const ecs_table_t *table,
    ecs_id_t id);
 
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 id,
    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
bool ecs_table_has_id(
    const ecs_world_t *world,
    const ecs_table_t *table,
    ecs_id_t id);
 
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 id);
 
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 id);
 
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
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
ecs_record_t* ecs_record_find(
    const ecs_world_t *world,
    ecs_entity_t entity);
 
FLECS_API
void* ecs_record_get_column(
    const ecs_record_t *r,
    int32_t column,
    size_t c_size);
 
FLECS_API
int32_t ecs_search(
    const ecs_world_t *world,
    const ecs_table_t *table,
    ecs_id_t id,
    ecs_id_t *id_out);
 
FLECS_API
int32_t ecs_search_offset(
    const ecs_world_t *world,
    const ecs_table_t *table,
    int32_t offset,
    ecs_id_t id,
    ecs_id_t *id_out);
 
FLECS_API
int32_t ecs_search_relation(
    const ecs_world_t *world,
    const ecs_table_t *table,
    int32_t offset,
    ecs_id_t id,
    ecs_entity_t rel,
    ecs_flags32_t flags, /* EcsSelf and/or EcsUp */
    ecs_entity_t *subject_out,
    ecs_id_t *id_out,
    struct ecs_table_record_t **tr_out);
 
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