meta.h

Go to the documentation of this file.

 
#ifdef FLECS_META
 
#ifndef FLECS_MODULE
#define FLECS_MODULE
#endif
 
#ifndef FLECS_META_H
#define FLECS_META_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define ECS_MEMBER_DESC_CACHE_SIZE (32)
 
typedef bool ecs_bool_t;                                        
typedef char ecs_char_t;                                        
typedef unsigned char ecs_byte_t;                               
typedef uint8_t ecs_u8_t;                                       
typedef uint16_t ecs_u16_t;                                     
typedef uint32_t ecs_u32_t;                                     
typedef uint64_t ecs_u64_t;                                     
typedef uintptr_t ecs_uptr_t;                                   
typedef int8_t ecs_i8_t;                                        
typedef int16_t ecs_i16_t;                                      
typedef int32_t ecs_i32_t;                                      
typedef int64_t ecs_i64_t;                                      
typedef intptr_t ecs_iptr_t;                                    
typedef float ecs_f32_t;                                        
typedef double ecs_f64_t;                                       
typedef char* ecs_string_t;                                     
/* Meta module component ids */
FLECS_API extern const ecs_entity_t ecs_id(EcsType);            
FLECS_API extern const ecs_entity_t ecs_id(EcsTypeSerializer);  
FLECS_API extern const ecs_entity_t ecs_id(EcsPrimitive);       
FLECS_API extern const ecs_entity_t ecs_id(EcsEnum);            
FLECS_API extern const ecs_entity_t ecs_id(EcsBitmask);         
FLECS_API extern const ecs_entity_t ecs_id(EcsMember);          
FLECS_API extern const ecs_entity_t ecs_id(EcsMemberRanges);    
FLECS_API extern const ecs_entity_t ecs_id(EcsStruct);          
FLECS_API extern const ecs_entity_t ecs_id(EcsArray);           
FLECS_API extern const ecs_entity_t ecs_id(EcsVector);          
FLECS_API extern const ecs_entity_t ecs_id(EcsOpaque);          
FLECS_API extern const ecs_entity_t ecs_id(EcsUnit);            
FLECS_API extern const ecs_entity_t ecs_id(EcsUnitPrefix);      
FLECS_API extern const ecs_entity_t EcsQuantity;                
/* Primitive type component ids */
 
FLECS_API extern const ecs_entity_t ecs_id(ecs_bool_t);         
FLECS_API extern const ecs_entity_t ecs_id(ecs_char_t);         
FLECS_API extern const ecs_entity_t ecs_id(ecs_byte_t);         
FLECS_API extern const ecs_entity_t ecs_id(ecs_u8_t);           
FLECS_API extern const ecs_entity_t ecs_id(ecs_u16_t);          
FLECS_API extern const ecs_entity_t ecs_id(ecs_u32_t);          
FLECS_API extern const ecs_entity_t ecs_id(ecs_u64_t);          
FLECS_API extern const ecs_entity_t ecs_id(ecs_uptr_t);         
FLECS_API extern const ecs_entity_t ecs_id(ecs_i8_t);           
FLECS_API extern const ecs_entity_t ecs_id(ecs_i16_t);          
FLECS_API extern const ecs_entity_t ecs_id(ecs_i32_t);          
FLECS_API extern const ecs_entity_t ecs_id(ecs_i64_t);          
FLECS_API extern const ecs_entity_t ecs_id(ecs_iptr_t);         
FLECS_API extern const ecs_entity_t ecs_id(ecs_f32_t);          
FLECS_API extern const ecs_entity_t ecs_id(ecs_f64_t);          
FLECS_API extern const ecs_entity_t ecs_id(ecs_string_t);       
FLECS_API extern const ecs_entity_t ecs_id(ecs_entity_t);       
FLECS_API extern const ecs_entity_t ecs_id(ecs_id_t);           
typedef enum ecs_type_kind_t {
    EcsPrimitiveType,
    EcsBitmaskType,
    EcsEnumType,
    EcsStructType,
    EcsArrayType,
    EcsVectorType,
    EcsOpaqueType,
    EcsTypeKindLast = EcsOpaqueType
} ecs_type_kind_t;
 
typedef struct EcsType {
    ecs_type_kind_t kind;  
    bool existing;         
    bool partial;          
} EcsType;
 
typedef enum ecs_primitive_kind_t {
    EcsBool = 1,
    EcsChar,
    EcsByte,
    EcsU8,
    EcsU16,
    EcsU32,
    EcsU64,
    EcsI8,
    EcsI16,
    EcsI32,
    EcsI64,
    EcsF32,
    EcsF64,
    EcsUPtr,
    EcsIPtr,
    EcsString,
    EcsEntity,
    EcsId,
    EcsPrimitiveKindLast = EcsId
} ecs_primitive_kind_t;
 
typedef struct EcsPrimitive {
    ecs_primitive_kind_t kind;                     
} EcsPrimitive;
 
typedef struct EcsMember {
    ecs_entity_t type;                             
    int32_t count;                                 
    ecs_entity_t unit;                             
    int32_t offset;                                
    bool use_offset;                               
} EcsMember;
 
typedef struct ecs_member_value_range_t {
    double min;                                    
    double max;                                    
} ecs_member_value_range_t;
 
typedef struct EcsMemberRanges {
    ecs_member_value_range_t value;                
    ecs_member_value_range_t warning;              
    ecs_member_value_range_t error;                
} EcsMemberRanges;
 
typedef struct ecs_member_t {
    const char *name;
 
    ecs_entity_t type;
 
    int32_t count;
 
    int32_t offset;
 
    ecs_entity_t unit;
 
    bool use_offset;
 
    ecs_member_value_range_t range;
 
    ecs_member_value_range_t error_range;
 
    ecs_member_value_range_t warning_range;
 
    ecs_size_t size;
 
    ecs_entity_t member;
} ecs_member_t;
 
typedef struct EcsStruct {
    ecs_vec_t members; /* vector<ecs_member_t> */
} EcsStruct;
 
typedef struct ecs_enum_constant_t {
    const char *name;
 
    int64_t value;
 
    uint64_t value_unsigned;
 
    ecs_entity_t constant;
} ecs_enum_constant_t;
 
typedef struct EcsEnum {
    ecs_entity_t underlying_type;
 
    ecs_map_t *constants; 
    ecs_vec_t ordered_constants; 
} EcsEnum;
 
typedef struct ecs_bitmask_constant_t {
    const char *name;
 
    ecs_flags64_t value;
 
    int64_t _unused;
 
    ecs_entity_t constant;
} ecs_bitmask_constant_t;
 
typedef struct EcsBitmask {
    /* Populated from child entities with Constant component */
    ecs_map_t *constants; 
    ecs_vec_t ordered_constants; 
} EcsBitmask;
 
typedef struct EcsArray {
    ecs_entity_t type; 
    int32_t count;     
} EcsArray;
 
typedef struct EcsVector {
    ecs_entity_t type; 
} EcsVector;
 
 
/* Opaque type support */
 
#if !defined(__cplusplus) || !defined(FLECS_CPP)
 
typedef struct ecs_serializer_t {
    /* Serialize value */
    int (*value)(
        const struct ecs_serializer_t *ser, 
        ecs_entity_t type,                  
        const void *value);                 
    /* Serialize member */
    int (*member)(
        const struct ecs_serializer_t *ser, 
        const char *member);                
    const ecs_world_t *world;               
    void *ctx;                              
} ecs_serializer_t;
 
#elif defined(__cplusplus)
 
} /* extern "C" { */
 
typedef struct ecs_serializer_t {
    /* Serialize value */
    int (*value_)(
        const struct ecs_serializer_t *ser,
        ecs_entity_t type,
        const void *value);
 
    /* Serialize member */
    int (*member_)(
        const struct ecs_serializer_t *ser,
        const char *name);
 
    /* Serialize value */
    int value(ecs_entity_t type, const void *value) const;
 
    /* Serialize value */
    template <typename T>
    int value(const T& value) const;
 
    /* Serialize member */
    int member(const char *name) const;
 
    const ecs_world_t *world;
    void *ctx;
} ecs_serializer_t;
 
extern "C" {
#endif
 
typedef int (*ecs_meta_serialize_t)(
    const ecs_serializer_t *ser,
    const void *src);                  
typedef int (*ecs_meta_serialize_member_t)(
    const ecs_serializer_t *ser,
    const void *src,                   
    const char* name);                 
typedef int (*ecs_meta_serialize_element_t)(
    const ecs_serializer_t *ser,
    const void *src,                   
    size_t elem);                      
typedef struct EcsOpaque {
    ecs_entity_t as_type;              
    ecs_meta_serialize_t serialize;    
    ecs_meta_serialize_member_t serialize_member; 
    ecs_meta_serialize_element_t serialize_element; 
    /* Deserializer interface
     * Only override the callbacks that are valid for the opaque type. If a
     * deserializer attempts to assign a value type that is not supported by the
     * interface, a conversion error is thrown.
     */
 
    void (*assign_bool)(
        void *dst,
        bool value);
 
    void (*assign_char)(
        void *dst,
        char value);
 
    void (*assign_int)(
        void *dst,
        int64_t value);
 
    void (*assign_uint)(
        void *dst,
        uint64_t value);
 
    void (*assign_float)(
        void *dst,
        double value);
 
    void (*assign_string)(
        void *dst,
        const char *value);
 
    void (*assign_entity)(
        void *dst,
        ecs_world_t *world,
        ecs_entity_t entity);
 
    void (*assign_id)(
        void *dst,
        ecs_world_t *world,
        ecs_id_t id);
 
    void (*assign_null)(
        void *dst);
 
    void (*clear)(
        void *dst);
 
    void* (*ensure_element)(
        void *dst,
        size_t elem);
 
    void* (*ensure_member)(
        void *dst,
        const char *member);
 
    size_t (*count)(
        const void *dst);
 
    void (*resize)(
        void *dst,
        size_t count);
} EcsOpaque;
 
 
/* Units */
 
typedef struct ecs_unit_translation_t {
    int32_t factor; 
    int32_t power;  
} ecs_unit_translation_t;
 
typedef struct EcsUnit {
    char *symbol;                                  
    ecs_entity_t prefix;                           
    ecs_entity_t base;                             
    ecs_entity_t over;                             
    ecs_unit_translation_t translation;            
} EcsUnit;
 
typedef struct EcsUnitPrefix {
    char *symbol;                                 
    ecs_unit_translation_t translation;           
} EcsUnitPrefix;
 
 
/* Serializer utilities */
 
typedef enum ecs_meta_op_kind_t {
    EcsOpPushStruct,   
    EcsOpPushArray,    
    EcsOpPushVector,   
    EcsOpPop,          
    EcsOpOpaqueStruct, 
    EcsOpOpaqueArray,  
    EcsOpOpaqueVector, 
    EcsOpForward,      
    EcsOpScope,        
    EcsOpOpaqueValue,  
    EcsOpEnum,
    EcsOpBitmask,
 
    EcsOpPrimitive,    
    EcsOpBool,
    EcsOpChar,
    EcsOpByte,
    EcsOpU8,
    EcsOpU16,
    EcsOpU32,
    EcsOpU64,
    EcsOpI8,
    EcsOpI16,
    EcsOpI32,
    EcsOpI64,
    EcsOpF32,
    EcsOpF64,
    EcsOpUPtr,
    EcsOpIPtr,
    EcsOpString,
    EcsOpEntity,
    EcsOpId,
    EcsMetaTypeOpKindLast = EcsOpId
} ecs_meta_op_kind_t;
 
typedef struct ecs_meta_op_t {
    ecs_meta_op_kind_t kind;                       
    ecs_size_t offset;                             
    const char *name;                              
    ecs_size_t elem_size;                          
    int16_t op_count;                              
    int16_t member_index;                          
    ecs_entity_t type;                             
    const ecs_type_info_t *type_info;              
    union {
        ecs_hashmap_t *members;                    
        ecs_map_t *constants;                      
        ecs_meta_serialize_t opaque;               
    } is;
} ecs_meta_op_t;
 
typedef struct EcsTypeSerializer {
    ecs_type_kind_t kind;         
    ecs_vec_t ops;                
} EcsTypeSerializer;
 
 
/* Deserializer utilities */
 
#define ECS_META_MAX_SCOPE_DEPTH (32)
 
typedef struct ecs_meta_scope_t {
    ecs_entity_t type;                             
    ecs_meta_op_t *ops;                       
    int16_t ops_count;                             
    int16_t ops_cur;                               
    int16_t prev_depth;                            
    void *ptr;                                     
    const EcsOpaque *opaque;                       
    ecs_hashmap_t *members;                        
    bool is_collection;                            
    bool is_empty_scope;                           
    bool is_moved_scope;                           
    int32_t elem, elem_count;                      
} ecs_meta_scope_t;
 
typedef struct ecs_meta_cursor_t {
    const ecs_world_t *world;                      
    ecs_meta_scope_t scope[ECS_META_MAX_SCOPE_DEPTH]; 
    int16_t depth;                                 
    bool valid;                                    
    bool is_primitive_scope;                       
    ecs_entity_t (*lookup_action)(ecs_world_t*, const char*, void*);
    void *lookup_ctx;                              
} ecs_meta_cursor_t;
 
FLECS_API
char* ecs_meta_serializer_to_str(
    ecs_world_t *world,
    ecs_entity_t type);
 
FLECS_API
ecs_meta_cursor_t ecs_meta_cursor(
    const ecs_world_t *world,
    ecs_entity_t type,
    void *ptr);
 
FLECS_API
void* ecs_meta_get_ptr(
    ecs_meta_cursor_t *cursor);
 
FLECS_API
int ecs_meta_next(
    ecs_meta_cursor_t *cursor);
 
FLECS_API
int ecs_meta_elem(
    ecs_meta_cursor_t *cursor,
    int32_t elem);
 
FLECS_API
int ecs_meta_member(
    ecs_meta_cursor_t *cursor,
    const char *name);
 
FLECS_API
int ecs_meta_dotmember(
    ecs_meta_cursor_t *cursor,
    const char *name);
 
FLECS_API
int ecs_meta_push(
    ecs_meta_cursor_t *cursor);
 
FLECS_API
int ecs_meta_pop(
    ecs_meta_cursor_t *cursor);
 
FLECS_API
bool ecs_meta_is_collection(
    const ecs_meta_cursor_t *cursor);
 
FLECS_API
ecs_entity_t ecs_meta_get_type(
    const ecs_meta_cursor_t *cursor);
 
FLECS_API
ecs_entity_t ecs_meta_get_unit(
    const ecs_meta_cursor_t *cursor);
 
FLECS_API
const char* ecs_meta_get_member(
    const ecs_meta_cursor_t *cursor);
 
FLECS_API
ecs_entity_t ecs_meta_get_member_id(
    const ecs_meta_cursor_t *cursor);
 
/* The set functions assign the field with the specified value. If the value
 * does not have the same type as the field, it will be cased to the field type.
 * If no valid conversion is available, the operation will fail. */
 
FLECS_API
int ecs_meta_set_bool(
    ecs_meta_cursor_t *cursor,
    bool value);
 
FLECS_API
int ecs_meta_set_char(
    ecs_meta_cursor_t *cursor,
    char value);
 
FLECS_API
int ecs_meta_set_int(
    ecs_meta_cursor_t *cursor,
    int64_t value);
 
FLECS_API
int ecs_meta_set_uint(
    ecs_meta_cursor_t *cursor,
    uint64_t value);
 
FLECS_API
int ecs_meta_set_float(
    ecs_meta_cursor_t *cursor,
    double value);
 
FLECS_API
int ecs_meta_set_string(
    ecs_meta_cursor_t *cursor,
    const char *value);
 
FLECS_API
int ecs_meta_set_string_literal(
    ecs_meta_cursor_t *cursor,
    const char *value);
 
FLECS_API
int ecs_meta_set_entity(
    ecs_meta_cursor_t *cursor,
    ecs_entity_t value);
 
FLECS_API
int ecs_meta_set_id(
    ecs_meta_cursor_t *cursor,
    ecs_id_t value);
 
FLECS_API
int ecs_meta_set_null(
    ecs_meta_cursor_t *cursor);
 
FLECS_API
int ecs_meta_set_value(
    ecs_meta_cursor_t *cursor,
    const ecs_value_t *value);
 
/* Functions for getting members. */
 
FLECS_API
bool ecs_meta_get_bool(
    const ecs_meta_cursor_t *cursor);
 
FLECS_API
char ecs_meta_get_char(
    const ecs_meta_cursor_t *cursor);
 
FLECS_API
int64_t ecs_meta_get_int(
    const ecs_meta_cursor_t *cursor);
 
FLECS_API
uint64_t ecs_meta_get_uint(
    const ecs_meta_cursor_t *cursor);
 
FLECS_API
double ecs_meta_get_float(
    const ecs_meta_cursor_t *cursor);
 
FLECS_API
const char* ecs_meta_get_string(
    const ecs_meta_cursor_t *cursor);
 
FLECS_API
ecs_entity_t ecs_meta_get_entity(
    const ecs_meta_cursor_t *cursor);
 
FLECS_API
ecs_id_t ecs_meta_get_id(
    const ecs_meta_cursor_t *cursor);
 
FLECS_API
double ecs_meta_ptr_to_float(
    ecs_primitive_kind_t type_kind,
    const void *ptr);
 
FLECS_API
ecs_size_t ecs_meta_op_get_elem_count(
    const ecs_meta_op_t *op,
    const void *ptr);
 
/* API functions for creating meta types */
 
typedef struct ecs_primitive_desc_t {
    ecs_entity_t entity;       
    ecs_primitive_kind_t kind; 
} ecs_primitive_desc_t;
 
FLECS_API
ecs_entity_t ecs_primitive_init(
    ecs_world_t *world,
    const ecs_primitive_desc_t *desc);
 
 
typedef struct ecs_enum_desc_t {
    ecs_entity_t entity;       
    ecs_enum_constant_t constants[ECS_MEMBER_DESC_CACHE_SIZE]; 
    ecs_entity_t underlying_type;
} ecs_enum_desc_t;
 
FLECS_API
ecs_entity_t ecs_enum_init(
    ecs_world_t *world,
    const ecs_enum_desc_t *desc);
 
 
typedef struct ecs_bitmask_desc_t {
    ecs_entity_t entity;       
    ecs_bitmask_constant_t constants[ECS_MEMBER_DESC_CACHE_SIZE]; 
} ecs_bitmask_desc_t;
 
FLECS_API
ecs_entity_t ecs_bitmask_init(
    ecs_world_t *world,
    const ecs_bitmask_desc_t *desc);
 
 
typedef struct ecs_array_desc_t {
    ecs_entity_t entity;  
    ecs_entity_t type;    
    int32_t count;        
} ecs_array_desc_t;
 
FLECS_API
ecs_entity_t ecs_array_init(
    ecs_world_t *world,
    const ecs_array_desc_t *desc);
 
 
typedef struct ecs_vector_desc_t {
    ecs_entity_t entity;  
    ecs_entity_t type;    
} ecs_vector_desc_t;
 
FLECS_API
ecs_entity_t ecs_vector_init(
    ecs_world_t *world,
    const ecs_vector_desc_t *desc);
 
 
typedef struct ecs_struct_desc_t {
    ecs_entity_t entity; 
    ecs_member_t members[ECS_MEMBER_DESC_CACHE_SIZE]; 
} ecs_struct_desc_t;
 
FLECS_API
ecs_entity_t ecs_struct_init(
    ecs_world_t *world,
    const ecs_struct_desc_t *desc);
 
 
typedef struct ecs_opaque_desc_t {
    ecs_entity_t entity;  
    EcsOpaque type;       
} ecs_opaque_desc_t;
 
FLECS_API
ecs_entity_t ecs_opaque_init(
    ecs_world_t *world,
    const ecs_opaque_desc_t *desc);
 
 
typedef struct ecs_unit_desc_t {
    ecs_entity_t entity;
 
    const char *symbol;
 
    ecs_entity_t quantity;
 
    ecs_entity_t base;
 
    ecs_entity_t over;
 
    ecs_unit_translation_t translation;
 
    ecs_entity_t prefix;
} ecs_unit_desc_t;
 
FLECS_API
ecs_entity_t ecs_unit_init(
    ecs_world_t *world,
    const ecs_unit_desc_t *desc);
 
 
typedef struct ecs_unit_prefix_desc_t {
    ecs_entity_t entity;
 
    const char *symbol;
 
    ecs_unit_translation_t translation;
} ecs_unit_prefix_desc_t;
 
FLECS_API
ecs_entity_t ecs_unit_prefix_init(
    ecs_world_t *world,
    const ecs_unit_prefix_desc_t *desc);
 
 
FLECS_API
ecs_entity_t ecs_quantity_init(
    ecs_world_t *world,
    const ecs_entity_desc_t *desc);
 
/* Convenience macros */
 
#define ecs_primitive(world, ...)\
    ecs_primitive_init(world, &(ecs_primitive_desc_t) __VA_ARGS__ )
 
#define ecs_enum(world, ...)\
    ecs_enum_init(world, &(ecs_enum_desc_t) __VA_ARGS__ )
 
#define ecs_bitmask(world, ...)\
    ecs_bitmask_init(world, &(ecs_bitmask_desc_t) __VA_ARGS__ )
 
#define ecs_array(world, ...)\
    ecs_array_init(world, &(ecs_array_desc_t) __VA_ARGS__ )
 
#define ecs_vector(world, ...)\
    ecs_vector_init(world, &(ecs_vector_desc_t) __VA_ARGS__ )
 
#define ecs_opaque(world, ...)\
    ecs_opaque_init(world, &(ecs_opaque_desc_t) __VA_ARGS__ )
 
#define ecs_struct(world, ...)\
    ecs_struct_init(world, &(ecs_struct_desc_t) __VA_ARGS__ )
 
#define ecs_unit(world, ...)\
    ecs_unit_init(world, &(ecs_unit_desc_t) __VA_ARGS__ )
 
#define ecs_unit_prefix(world, ...)\
    ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) __VA_ARGS__ )
 
#define ecs_quantity(world, ...)\
    ecs_quantity_init(world, &(ecs_entity_desc_t) __VA_ARGS__ )
 
 
FLECS_API
void FlecsMetaImport(
    ecs_world_t *world);
 
#ifdef __cplusplus
}
#endif
 
#include "meta_c.h"
 
#endif
 
#endif