code: update flecs & rework vehicle enter/leave states

code/game/src/player.c

@@ -19,8 +19,7 @@ uint64_t player_spawn(char *name) {
         name = zpl_bprintf("player_%d", e);
     }
     
-    ecs_set(world_ecs(), e, EcsName, {.alloc_value = name });
+    ecs_set_name(world_ecs(), e, name);
-    ecs_add(world_ecs(), e, EcsClient);
     ecs_set(world_ecs(), e, ClientInfo, {0});
     ecs_set(world_ecs(), e, Input, {0});
     ecs_set(world_ecs(), e, Health, {.hp = PLAYER_MAX_HP, .max_hp = PLAYER_MAX_HP});

code/modules/modules/components.c

@@ -10,14 +10,13 @@ ECS_COMPONENT_DECLARE(ClientInfo);
 ECS_COMPONENT_DECLARE(Health);
 ECS_COMPONENT_DECLARE(Classify);
 ECS_COMPONENT_DECLARE(Vehicle);
+ECS_COMPONENT_DECLARE(IsInVehicle);
 ECS_TAG_DECLARE(EcsActor);
 ECS_TAG_DECLARE(EcsDemoNPC);
-ECS_TAG_DECLARE(EcsInVehicle);
 ECS_TYPE_DECLARE(Player);
 ECS_TYPE_DECLARE(Movement);
 ECS_TYPE_DECLARE(Walking);
 ECS_TYPE_DECLARE(Flying);
-ECS_TYPE_DECLARE(EcsClient);
 
 void ComponentsImport(ecs_world_t *ecs) {
     ECS_MODULE(ecs, Components);
@@ -34,13 +33,13 @@ void ComponentsImport(ecs_world_t *ecs) {
     ECS_META_DEFINE(ecs, Classify);
     ECS_META_DEFINE(ecs, Vehicle);
     
+    ECS_COMPONENT_DEFINE(ecs, IsInVehicle);
+    
     ECS_TAG_DEFINE(ecs, Walking);
     ECS_TAG_DEFINE(ecs, Flying);
-    ECS_TAG_DEFINE(ecs, EcsClient);
     
     ECS_TAG_DEFINE(ecs, EcsActor);
     ECS_TAG_DEFINE(ecs, EcsDemoNPC);
-    ECS_TAG_DEFINE(ecs, EcsInVehicle);
     
     ECS_PREFAB(ecs, Base, Position, Velocity, Input, EcsActor);
     ECS_TYPE_DEFINE(ecs, Movement, Walking, Flying);
@@ -55,11 +54,10 @@ void ComponentsImport(ecs_world_t *ecs) {
     ECS_SET_COMPONENT(Health);
     ECS_SET_COMPONENT(Classify);
     ECS_SET_COMPONENT(Vehicle);
-    ECS_SET_ENTITY(EcsClient);
+    ECS_SET_COMPONENT(IsInVehicle);
     ECS_SET_ENTITY(Walking);
     ECS_SET_ENTITY(Flying);
     ECS_SET_ENTITY(EcsActor);
     ECS_SET_ENTITY(EcsDemoNPC);
-    ECS_SET_ENTITY(EcsInVehicle);
     ECS_SET_TYPE(Movement);
 }

code/modules/modules/components.h

@@ -41,8 +41,6 @@ ECS_STRUCT(Input, {
                uint8_t use;
                uint8_t sprint;
                uint8_t is_blocked;
-               
-               ecs_entity_t parent;
            });
 
 ECS_STRUCT(ClientInfo, {
@@ -72,6 +70,10 @@ ECS_STRUCT(Vehicle, {
                float wheel_base;
            });
 
+typedef struct {
+    ecs_entity_t veh;
+} IsInVehicle;
+
 ECS_COMPONENT_EXTERN(Chunk);
 ECS_COMPONENT_EXTERN(Position);
 ECS_COMPONENT_EXTERN(Vector2D);
@@ -82,9 +84,9 @@ ECS_COMPONENT_EXTERN(ClientInfo);
 ECS_COMPONENT_EXTERN(Health);
 ECS_COMPONENT_EXTERN(Classify);
 ECS_COMPONENT_EXTERN(Vehicle);
+ECS_COMPONENT_EXTERN(IsInVehicle);
 ECS_TAG_EXTERN(EcsActor);
 ECS_TAG_EXTERN(EcsDemoNPC);
-ECS_TAG_EXTERN(EcsInVehicle);
 ECS_TYPE_EXTERN(Player);
 ECS_TYPE_EXTERN(Movement);
 ECS_TYPE_EXTERN(Walking);
@@ -102,15 +104,14 @@ typedef struct {
     ECS_DECLARE_COMPONENT(Health);
     ECS_DECLARE_COMPONENT(Classify);
     ECS_DECLARE_COMPONENT(Vehicle);
+    ECS_DECLARE_COMPONENT(IsInVehicle);
     ECS_DECLARE_ENTITY(EcsActor);
     ECS_DECLARE_ENTITY(EcsDemoNPC);
-    ECS_DECLARE_ENTITY(EcsInVehicle);
     ECS_DECLARE_TYPE(Player);
     ECS_DECLARE_TYPE(Builder);
     ECS_DECLARE_TYPE(Movement);
     ECS_DECLARE_ENTITY(Walking);
     ECS_DECLARE_ENTITY(Flying);
-    ECS_DECLARE_ENTITY(EcsClient);
 } Components;
 
 #define ComponentsImportHandles(handles)\
@@ -124,6 +125,7 @@ ECS_IMPORT_COMPONENT(handles, ClientInfo);\
 ECS_IMPORT_COMPONENT(handles, Health);\
 ECS_IMPORT_COMPONENT(handles, Classify);\
 ECS_IMPORT_COMPONENT(handles, Vehicle);\
+ECS_IMPORT_COMPONENT(handles, IsInVehicle);\
 ECS_IMPORT_TYPE(handles, Player);\
 ECS_IMPORT_TYPE(handles, Builder);\
 ECS_IMPORT_TYPE(handles, Movement);\
@@ -131,7 +133,5 @@ ECS_IMPORT_ENTITY(handles, EcsActor);\
 ECS_IMPORT_ENTITY(handles, EcsDemoNPC);\
 ECS_IMPORT_ENTITY(handles, Walking);\
 ECS_IMPORT_ENTITY(handles, Flying);\
-ECS_IMPORT_ENTITY(handles, EcsClient);\
-ECS_IMPORT_ENTITY(handles, EcsInVehicle);\
 
 void ComponentsImport(ecs_world_t *ecs);

code/modules/modules/systems.c

@@ -102,10 +102,11 @@ void RegenerateHP(ecs_iter_t *it) {
 void SystemsImport(ecs_world_t *ecs) {
     ECS_MODULE(ecs, Systems);
     
-    ECS_SYSTEM(ecs, MovementImpulse, EcsOnLoad, components.Input, components.Velocity);
+    ECS_SYSTEM(ecs, MovementImpulse, EcsOnLoad, components.Input, components.Velocity, !components.IsInVehicle);
     //ECS_SYSTEM(ecs, DemoPlaceIceBlock, EcsOnLoad, components.Input, components.Position);
     ECS_SYSTEM(ecs, DemoNPCMoveAround, EcsOnLoad, components.Velocity, components.EcsDemoNPC);
-    ECS_SYSTEM(ecs, EnterOrLeaveVehicle, EcsOnLoad, components.Input, components.Position);
+    ECS_SYSTEM(ecs, EnterVehicle, EcsOnLoad, components.Input, components.Position, !components.IsInVehicle);
+    ECS_SYSTEM(ecs, LeaveVehicle, EcsOnLoad, components.Input, components.IsInVehicle);
     
     ECS_SYSTEM(ecs, MoveWalk, EcsOnUpdate, components.Position, components.Velocity);
     ECS_SYSTEM(ecs, HurtOnHazardBlock, EcsOnUpdate, components.Position, components.Health);

code/modules/source/system_onfoot.c

@@ -19,7 +19,6 @@ void MovementImpulse(ecs_iter_t *it) {
     Velocity *v = ecs_column(it, Velocity, 2);
     
     for (int i = 0; i < it->count; i++) {
-        if (world_entity_valid(in[i].parent)) continue;
         double speed = PLR_MOVE_SPEED * (in[i].sprint ? PLR_MOVE_SPEED_MULT : 1.0);
         if (zpl_abs(v[i].x) < speed && in[i].x)
             v[i].x = in[i].x*speed;

code/modules/source/system_vehicle.c

@@ -1,7 +1,31 @@
 
 #define VEH_ENTER_RADIUS 45.0f
 
-void EnterOrLeaveVehicle(ecs_iter_t *it) {
+void LeaveVehicle(ecs_iter_t *it) {
+    Input *in = ecs_column(it, Input, 1);
+    IsInVehicle *vehp = ecs_column(it, IsInVehicle, 2);
+    
+    for (int i = 0; i < it->count; i++) {
+        if (!in[i].use) continue;
+        in[i].use = false;
+        
+        Vehicle *veh = 0;
+        if ((veh = ecs_get_mut_if(it->world, vehp->veh, Vehicle))) {
+            for (int k = 0; k < 4; k++) {
+                if (veh->seats[k] == it->entities[i]) {
+                    veh->seats[k] = 0;
+                    break;
+                }
+            }
+            
+            ecs_remove(it->world, it->entities[i], IsInVehicle);
+        } else {
+            ZPL_PANIC("unreachable code");
+        }
+    }
+}
+
+void EnterVehicle(ecs_iter_t *it) {
     Input *in = ecs_column(it, Input, 1);
     Position *p = ecs_column(it, Position, 2);
     
@@ -9,14 +33,13 @@ void EnterOrLeaveVehicle(ecs_iter_t *it) {
         if (!in[i].use) continue;
         in[i].use = false;
         
-        if (!world_entity_valid(in[i].parent)) {
         size_t ents_count;
         int64_t *ents = world_chunk_query_entities(it->entities[i], &ents_count, 2);
         
         for (size_t j = 0; j < ents_count; j++) {
             Vehicle *veh = 0;
-                if ((veh = ecs_get_mut_if(world_ecs(), ents[j], Vehicle))) {
+            if ((veh = ecs_get_mut_if(it->world, ents[j], Vehicle))) {
-                    Position const* p2 = ecs_get(world_ecs(), ents[j], Position);
+                Position const* p2 = ecs_get(it->world, ents[j], Position);
                 
                 float dx = p2->x - p[i].x;
                 float dy = p2->y - p[i].y;
@@ -27,28 +50,15 @@ void EnterOrLeaveVehicle(ecs_iter_t *it) {
                         
                         // NOTE(zaklaus): We can enter the vehicle, yay!
                         veh->seats[k] = it->entities[i];
-                            in[i].parent = ents[j];
+                        ecs_set(it->world, it->entities[i], IsInVehicle, {
+                                    .veh = ents[j]
+                                });
                         p[i] = *p2;
                         break;
                     }
                 }
             }
         }
-        } else {
-            Vehicle *veh = 0;
-            if ((veh = ecs_get_mut_if(world_ecs(), in[i].parent, Vehicle))) {
-                for (int k = 0; k < 4; k++) {
-                    if (veh->seats[k] == it->entities[i]) {
-                        veh->seats[k] = 0;
-                        break;
-                    }
-                }
-                
-                in[i].parent = 0;
-            } else {
-                ZPL_PANIC("unreachable code");
-            }
-        }
     }
 }
 
@@ -81,15 +91,15 @@ void VehicleHandling(ecs_iter_t *it) {
             
             // NOTE(zaklaus): Update passenger position
             {
-                Position *p2 = ecs_get_mut(world_ecs(), pe, Position, NULL);
+                Position *p2 = ecs_get_mut(it->world, pe, Position, NULL);
-                Velocity *v2 = ecs_get_mut(world_ecs(), pe, Velocity, NULL);
+                Velocity *v2 = ecs_get_mut(it->world, pe, Velocity, NULL);
                 *p2 = p[i];
                 *v2 = v[i];
             }
             
             // NOTE(zaklaus): Handle driver input
             if (j == 0) {
-                Input const* in = ecs_get(world_ecs(), pe, Input);
+                Input const* in = ecs_get(it->world, pe, Input);
                 
                 car->force += zpl_lerp(0.0f, in->y * VEHICLE_FORCE, VEHICLE_ACCEL);
                 car->steer += in->x * -VEHICLE_STEER;

code/vendors/flecs/CMakeLists.txt

@@ -2,16 +2,9 @@ use_cxx11()
 
 file(GLOB SRCS *.h
 	flecs.c
-	flecs_json.c
 	flecs_meta.c
-	flecs_rest.c
+
-	flecs_player.c
-	flecs_rest.c
-	flecs_systems_civetweb.c
-	flecs_dash.c
-	flecs_monitor.c
 	flecs-os_api-stdcpp.cpp
-	flecs_components_http.c
 )
 
 add_library(flecs-bundle STATIC ${SRCS})

code/vendors/flecs/flecs_meta.c

@@ -60,6 +60,35 @@ void ecs_meta_parse_params(
     ecs_meta_params_t *token_out,
     ecs_meta_parse_ctx_t *ctx);
 
+#endif
+#ifndef FLECS_META_SERIALIZER_H
+#define FLECS_META_SERIALIZER_H
+
+
+void EcsAddStruct(
+    ecs_iter_t *it);
+
+void EcsSetPrimitive(
+    ecs_iter_t *it);
+
+void EcsSetEnum(
+    ecs_iter_t *it);
+
+void EcsSetBitmask(
+    ecs_iter_t *it);
+
+void EcsSetStruct(
+    ecs_iter_t *it);
+
+void EcsSetArray(
+    ecs_iter_t *it);
+
+void EcsSetVector(
+    ecs_iter_t *it);
+
+void EcsSetMap(
+    ecs_iter_t *it);
+
 #endif
 
 static
@@ -67,8 +96,7 @@ ecs_vector_t* serialize_type(
     ecs_world_t *world,
     ecs_entity_t entity,
     ecs_vector_t *ops,
-    int32_t offset,
+    int32_t offset);
-    FlecsMeta *module);
 
 static
 ecs_size_t ecs_get_primitive_size(
@@ -129,12 +157,10 @@ ecs_vector_t* serialize_primitive(
     ecs_world_t *world,
     ecs_entity_t entity,
     const EcsPrimitive *type,
-    ecs_vector_t *ops,
+    ecs_vector_t *ops)
-    FlecsMeta *module)
 {
     (void)world;
     (void)entity;
-    (void)module;
 
     ecs_type_op_t *op;
     if (!ops) {
@@ -164,13 +190,10 @@ ecs_vector_t* serialize_enum(
     ecs_world_t *world,
     ecs_entity_t entity,
     const EcsEnum *type,
-    ecs_vector_t *ops,
+    ecs_vector_t *ops)
-    FlecsMeta *module)
 {
     (void)type;
 
-    FlecsMetaImportHandles(*module);
-
     ecs_type_op_t *op;
     if (!ops) {
         op = ecs_vector_add(&ops, ecs_type_op_t);
@@ -202,13 +225,10 @@ ecs_vector_t* serialize_bitmask(
     ecs_world_t *world,
     ecs_entity_t entity,
     const EcsBitmask *type,
-    ecs_vector_t *ops,
+    ecs_vector_t *ops)
-    FlecsMeta *module)
 {
     (void)type;
 
-    FlecsMetaImportHandles(*module);
-
     ecs_type_op_t *op;
     if (!ops) {
         op = ecs_vector_add(&ops, ecs_type_op_t);
@@ -241,11 +261,8 @@ ecs_vector_t* serialize_struct(
     ecs_entity_t entity,
     const EcsStruct *type,
     ecs_vector_t *ops,
-    int32_t offset,
+    int32_t offset)
-    FlecsMeta *module)
 {
-    FlecsMetaImportHandles(*module);
-
     ecs_type_op_t *op_header = NULL;
     if (!ops) {
         op_header = ecs_vector_add(&ops, ecs_type_op_t);
@@ -267,7 +284,7 @@ ecs_vector_t* serialize_struct(
     for (i = 0; i < count; i ++) {
         /* Add type operations of member to struct ops */
         int32_t prev_count = ecs_vector_count(ops);
-        ops = serialize_type(world, members[i].type, ops, offset + size, module);
+        ops = serialize_type(world, members[i].type, ops, offset + size);
 
 #ifndef NDEBUG
         int32_t op_count = ecs_vector_count(ops);
@@ -281,7 +298,7 @@ ecs_vector_t* serialize_struct(
         op->name = members[i].name;
 
         const EcsMetaType *meta_type = ecs_get(world, members[i].type, EcsMetaType);
-        ecs_size_t member_size = meta_type->size * op->count;
+        ecs_size_t member_size = meta_type->size * (meta_type->kind == EcsStructType ? 1 : op->count);
         int16_t member_alignment = meta_type->alignment;
 
         ecs_assert(member_size != 0, ECS_INTERNAL_ERROR, op->name);
@@ -367,7 +384,7 @@ ecs_vector_t* serialize_struct(
     ecs_assert(op_push->kind == EcsOpPush, ECS_INTERNAL_ERROR, NULL);
     op_push->size = size;
     op_push->alignment = alignment;
-    op_push->count = 1;
+    op_push->count = count;
 
     return ops;
 }
@@ -377,13 +394,10 @@ ecs_vector_t* serialize_array(
     ecs_world_t *world,
     ecs_entity_t entity,
     const EcsArray *type,
-    ecs_vector_t *ops,
+    ecs_vector_t *ops)
-    FlecsMeta *handles)
 {
     (void)entity;
 
-    FlecsMetaImportHandles(*handles);
-
     ecs_type_op_t *op_header = NULL;
     if (!ops) {
         op_header = ecs_vector_add(&ops, ecs_type_op_t);
@@ -428,13 +442,10 @@ ecs_vector_t* serialize_vector(
     ecs_world_t *world,
     ecs_entity_t entity,
     const EcsVector *type,
-    ecs_vector_t *ops,
+    ecs_vector_t *ops)
-    FlecsMeta *handles)
 {
     (void)entity;
 
-    FlecsMetaImportHandles(*handles);
-
     ecs_type_op_t *op = NULL;
     if (!ops) {
         op = ecs_vector_add(&ops, ecs_type_op_t);
@@ -468,11 +479,8 @@ ecs_vector_t* serialize_map(
     ecs_world_t *world,
     ecs_entity_t entity,
     const EcsMap *type,
-    ecs_vector_t *ops,
+    ecs_vector_t *ops)
-    FlecsMeta *handles)
 {
-    FlecsMetaImportHandles(*handles);
-
     ecs_type_op_t *op = NULL;
     if (!ops) {
         op = ecs_vector_add(&ops, ecs_type_op_t);
@@ -545,11 +553,8 @@ ecs_vector_t* serialize_type(
     ecs_world_t *world,
     ecs_entity_t entity,
     ecs_vector_t *ops,
-    int32_t offset,
+    int32_t offset)
-    FlecsMeta *module)
 {
-    FlecsMetaImportHandles(*module);
-
     const EcsMetaType *type = ecs_get(world, entity, EcsMetaType);
     ecs_assert(type != NULL, ECS_INVALID_PARAMETER, NULL);
 
@@ -557,43 +562,43 @@ ecs_vector_t* serialize_type(
     case EcsPrimitiveType: {
         const EcsPrimitive *t = ecs_get(world, entity, EcsPrimitive);
         ecs_assert(t != NULL, ECS_INTERNAL_ERROR, NULL);
-        return serialize_primitive(world, entity, t, ops, module);
+        return serialize_primitive(world, entity, t, ops);
     }
 
     case EcsEnumType: {
         const EcsEnum *t = ecs_get(world, entity, EcsEnum);
         ecs_assert(t != NULL, ECS_INTERNAL_ERROR, NULL);
-        return serialize_enum(world, entity, t, ops, module);
+        return serialize_enum(world, entity, t, ops);
     }
 
     case EcsBitmaskType: {
         const EcsBitmask *t = ecs_get(world, entity, EcsBitmask);
         ecs_assert(t != NULL, ECS_INTERNAL_ERROR, NULL);
-        return serialize_bitmask(world, entity, t, ops, module);
+        return serialize_bitmask(world, entity, t, ops);
     }
 
     case EcsStructType: {
         const EcsStruct *t = ecs_get(world, entity, EcsStruct);
         ecs_assert(t != NULL, ECS_INTERNAL_ERROR, NULL);
-        return serialize_struct(world, entity, t, ops, offset, module);
+        return serialize_struct(world, entity, t, ops, offset);
     }
 
     case EcsArrayType: {
         const EcsArray *t = ecs_get(world, entity, EcsArray);
         ecs_assert(t != NULL, ECS_INTERNAL_ERROR, NULL);
-        return serialize_array(world, entity, t, ops, module);
+        return serialize_array(world, entity, t, ops);
     }
 
     case EcsVectorType: {
         const EcsVector *t = ecs_get(world, entity, EcsVector);
         ecs_assert(t != NULL, ECS_INTERNAL_ERROR, NULL);
-        return serialize_vector(world, entity, t, ops, module);
+        return serialize_vector(world, entity, t, ops);
     }
 
     case EcsMapType: {
         const EcsMap *t = ecs_get(world, entity, EcsMap);
         ecs_assert(t != NULL, ECS_INTERNAL_ERROR, NULL);
-        return serialize_map(world, entity, t, ops, module);
+        return serialize_map(world, entity, t, ops);
     }
 
     default:
@@ -605,7 +610,6 @@ ecs_vector_t* serialize_type(
 
 void EcsSetPrimitive(ecs_iter_t *it) {
     EcsPrimitive *type = ecs_column(it, EcsPrimitive, 1);
-    ECS_IMPORT_COLUMN(it, FlecsMeta, 2);
 
     ecs_world_t *world = it->world;
 
@@ -625,14 +629,13 @@ void EcsSetPrimitive(ecs_iter_t *it) {
 
         ecs_set(world, e, EcsMetaTypeSerializer, {
             serialize_primitive(
-                world, e, &type[i], NULL, &ecs_module(FlecsMeta))
+                world, e, &type[i], NULL)
         });
     }
 }
 
 void EcsSetEnum(ecs_iter_t *it) {
     EcsEnum *type = ecs_column(it, EcsEnum, 1);
-    ECS_IMPORT_COLUMN(it, FlecsMeta, 2);
 
     ecs_world_t *world = it->world;
 
@@ -641,14 +644,13 @@ void EcsSetEnum(ecs_iter_t *it) {
         ecs_entity_t e = it->entities[i];
 
         ecs_set(it->world, e, EcsMetaTypeSerializer, {
-            serialize_enum(world, e, &type[i], NULL, &ecs_module(FlecsMeta))
+            serialize_enum(world, e, &type[i], NULL)
         });
     }
 }
 
 void EcsSetBitmask(ecs_iter_t *it) {
     EcsBitmask *type = ecs_column(it, EcsBitmask, 1);
-    ECS_IMPORT_COLUMN(it, FlecsMeta, 2);
 
     ecs_world_t *world = it->world;
 
@@ -656,14 +658,13 @@ void EcsSetBitmask(ecs_iter_t *it) {
     for (i = 0; i < it->count; i ++) {
         ecs_entity_t e = it->entities[i];
         ecs_set(it->world, e, EcsMetaTypeSerializer, {
-            serialize_bitmask(world, e, &type[i], NULL, &ecs_module(FlecsMeta))
+            serialize_bitmask(world, e, &type[i], NULL)
         });
     }
 }
 
 void EcsSetStruct(ecs_iter_t *it) {
     EcsStruct *type = ecs_column(it, EcsStruct, 1);
-    ECS_IMPORT_COLUMN(it, FlecsMeta, 2);
 
     ecs_world_t *world = it->world;
 
@@ -671,14 +672,13 @@ void EcsSetStruct(ecs_iter_t *it) {
     for (i = 0; i < it->count; i ++) {
         ecs_entity_t e = it->entities[i];
         ecs_set(it->world, e, EcsMetaTypeSerializer, {
-            serialize_struct(world, e, &type[i], NULL, 0, &ecs_module(FlecsMeta))
+            serialize_struct(world, e, &type[i], NULL, 0)
         });
     }
 }
 
 void EcsSetArray(ecs_iter_t *it) {
     EcsArray *type = ecs_column(it, EcsArray, 1);
-    ECS_IMPORT_COLUMN(it, FlecsMeta, 2);
 
     ecs_world_t *world = it->world;
 
@@ -686,14 +686,13 @@ void EcsSetArray(ecs_iter_t *it) {
     for (i = 0; i < it->count; i ++) {
         ecs_entity_t e = it->entities[i];
         ecs_set(it->world, e, EcsMetaTypeSerializer, {
-            serialize_array(world, e, &type[i], NULL, &ecs_module(FlecsMeta))
+            serialize_array(world, e, &type[i], NULL)
         });
     }
 }
 
 void EcsSetVector(ecs_iter_t *it) {
     EcsVector *type = ecs_column(it, EcsVector, 1);
-    ECS_IMPORT_COLUMN(it, FlecsMeta, 2);
 
     ecs_world_t *world = it->world;
 
@@ -701,14 +700,13 @@ void EcsSetVector(ecs_iter_t *it) {
     for (i = 0; i < it->count; i ++) {
         ecs_entity_t e = it->entities[i];
         ecs_set(it->world, e, EcsMetaTypeSerializer, {
-            serialize_vector(world, e, &type[i], NULL, &ecs_module(FlecsMeta))
+            serialize_vector(world, e, &type[i], NULL)
         });
     }
 }
 
 void EcsSetMap(ecs_iter_t *it) {
     EcsMap *type = ecs_column(it, EcsMap, 1);
-    ECS_IMPORT_COLUMN(it, FlecsMeta, 2);
 
     ecs_world_t *world = it->world;
 
@@ -716,7 +714,7 @@ void EcsSetMap(ecs_iter_t *it) {
     for (i = 0; i < it->count; i ++) {
         ecs_entity_t e = it->entities[i];
         ecs_set(it->world, e, EcsMetaTypeSerializer, {
-            serialize_map(world, e, &type[i], NULL, &ecs_module(FlecsMeta))
+            serialize_map(world, e, &type[i], NULL)
         });
     }
 }
@@ -935,7 +933,7 @@ void str_ser_primitive(
         ecs_strbuf_append(str, "%lld", *(int64_t*)base);
         break;
     case EcsF32:
-        ecs_strbuf_append(str, "%f", *(float*)base);
+        ecs_strbuf_append(str, "%f", (double)*(float*)base);
         break;
     case EcsF64:
         ecs_strbuf_append(str, "%f", *(double*)base);
@@ -969,12 +967,13 @@ void str_ser_primitive(
     }
     case EcsEntity: {
         ecs_entity_t e = *(ecs_entity_t*)base;
-        const char *name = ecs_get_name(world, e);
+        const char *name;
-        if (name) {
+        if (e && (name = ecs_get_name(world, e))) {
             ecs_strbuf_appendstr(str, name);
         } else {
             ecs_strbuf_append(str, "%u", e);
         }
+
         break;
     }
     }
@@ -1263,7 +1262,6 @@ char* ecs_ptr_to_str(
     ecs_entity_t type, 
     void* ptr)
 {
-    ecs_entity_t ecs_entity(EcsMetaTypeSerializer) = ecs_lookup_fullpath(world, "flecs.meta.MetaTypeSerializer");
     const EcsMetaTypeSerializer *ser = ecs_get(world, type, EcsMetaTypeSerializer);
     ecs_assert(ser != NULL, ECS_INVALID_PARAMETER, NULL);
 
@@ -1283,7 +1281,6 @@ char* ecs_entity_to_str(
     ecs_entity_t *ids = (ecs_entity_t*)ecs_vector_first(type, ecs_entity_t);
     int32_t count = ecs_vector_count(type);
     
-    ecs_entity_t ecs_entity(EcsMetaTypeSerializer) = ecs_lookup_fullpath(world, "flecs.meta.MetaTypeSerializer");
     ecs_strbuf_t str = ECS_STRBUF_INIT;
 
     const char *name = ecs_get_name(world, entity);
@@ -1315,35 +1312,6 @@ error:
     ecs_strbuf_reset(&str);
     return NULL;
 }
-#ifndef FLECS_META_SERIALIZER_H
-#define FLECS_META_SERIALIZER_H
-
-
-void EcsAddStruct(
-    ecs_iter_t *it);
-
-void EcsSetPrimitive(
-    ecs_iter_t *it);
-
-void EcsSetEnum(
-    ecs_iter_t *it);
-
-void EcsSetBitmask(
-    ecs_iter_t *it);
-
-void EcsSetStruct(
-    ecs_iter_t *it);
-
-void EcsSetArray(
-    ecs_iter_t *it);
-
-void EcsSetVector(
-    ecs_iter_t *it);
-
-void EcsSetMap(
-    ecs_iter_t *it);
-
-#endif
 #ifndef FLECS_META_TYPE_H
 #define FLECS_META_TYPE_H
 
@@ -1366,6 +1334,12 @@ ecs_entity_t ecs_meta_lookup_map(
     const char *params_decl,
     ecs_meta_parse_ctx_t *ctx);
 
+ecs_entity_t ecs_meta_lookup_bitmask(
+    ecs_world_t *world,
+    ecs_entity_t e,
+    const char *params_decl,
+    ecs_meta_parse_ctx_t *ctx);
+
 ecs_entity_t ecs_meta_lookup(
     ecs_world_t *world,
     ecs_meta_type_t *token,
@@ -1375,18 +1349,31 @@ ecs_entity_t ecs_meta_lookup(
 
 #endif
 
-ECS_CTOR(EcsMetaType, ptr, {
+ECS_COMPONENT_DECLARE(EcsPrimitive);
+ECS_COMPONENT_DECLARE(EcsEnum);
+ECS_COMPONENT_DECLARE(EcsBitmask);
+ECS_COMPONENT_DECLARE(EcsMember);
+ECS_COMPONENT_DECLARE(EcsStruct);
+ECS_COMPONENT_DECLARE(EcsArray);
+ECS_COMPONENT_DECLARE(EcsVector);
+ECS_COMPONENT_DECLARE(EcsMap);
+ECS_COMPONENT_DECLARE(EcsMetaType);
+ECS_COMPONENT_DECLARE(ecs_type_op_kind_t);
+ECS_COMPONENT_DECLARE(ecs_type_op_t);
+ECS_COMPONENT_DECLARE(EcsMetaTypeSerializer);
+
+static ECS_CTOR(EcsMetaType, ptr, {
     ptr->descriptor = NULL;
     ptr->alias = NULL;
 })
 
-ECS_DTOR(EcsMetaType, ptr, {
+static ECS_DTOR(EcsMetaType, ptr, {
     ecs_os_free((char*)ptr->descriptor);
     ptr->descriptor = NULL;
     ptr->alias = NULL;
 })
 
-ECS_COPY(EcsMetaType, dst, src, {
+static ECS_COPY(EcsMetaType, dst, src, {
     if (dst->descriptor) {
         ecs_os_free((char*)dst->descriptor);
         dst->descriptor = NULL;
@@ -1404,55 +1391,45 @@ ECS_COPY(EcsMetaType, dst, src, {
     dst->alias = src->alias;
 })
 
-ECS_MOVE(EcsMetaType, dst, src, {
+static ECS_CTOR(EcsStruct, ptr, {
-    dst->kind = src->kind;
-    dst->size = src->size;
-    dst->alignment = src->alignment;
-    dst->alias = src->alias;
-
-    src->descriptor = NULL;
-    src->alias = NULL;
-})
-
-ECS_CTOR(EcsStruct, ptr, {
     ptr->members = NULL;
     ptr->is_partial = false;
 })
 
-ECS_DTOR(EcsStruct, ptr, {
+static ECS_DTOR(EcsStruct, ptr, {
     ecs_vector_each(ptr->members, EcsMember, m, {
         ecs_os_free(m->name);
     });
     ecs_vector_free(ptr->members);
 })
 
-ECS_CTOR(EcsEnum, ptr, {
+static ECS_CTOR(EcsEnum, ptr, {
     ptr->constants = NULL;
 })
 
-ECS_DTOR(EcsEnum, ptr, {
+static ECS_DTOR(EcsEnum, ptr, {
     ecs_map_each(ptr->constants, char*, key, c_ptr, {
         ecs_os_free(*c_ptr);
     })
     ecs_map_free(ptr->constants);
 })
 
-ECS_CTOR(EcsBitmask, ptr, {
+static ECS_CTOR(EcsBitmask, ptr, {
     ptr->constants = NULL;
 })
 
-ECS_DTOR(EcsBitmask, ptr, {
+static ECS_DTOR(EcsBitmask, ptr, {
     ecs_map_each(ptr->constants, char*, key, c_ptr, {
         ecs_os_free(*c_ptr);
     })
     ecs_map_free(ptr->constants);
 })
 
-ECS_CTOR(EcsMetaTypeSerializer, ptr, {
+static ECS_CTOR(EcsMetaTypeSerializer, ptr, {
     ptr->ops = NULL;
 })
 
-ECS_DTOR(EcsMetaTypeSerializer, ptr, {
+static ECS_DTOR(EcsMetaTypeSerializer, ptr, {
     ecs_vector_free(ptr->ops);
 })
 
@@ -1466,9 +1443,6 @@ void ecs_set_primitive(
     ecs_assert(e != 0, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(type != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_entity_t ecs_entity(EcsPrimitive) = ecs_lookup_fullpath(world, "flecs.meta.Primitive");
-    ecs_assert(ecs_entity(EcsPrimitive) != 0, ECS_INTERNAL_ERROR, NULL);
-
     const char *descr = type->descriptor;
 
     if (!strcmp(descr, "bool")) {
@@ -1513,7 +1487,7 @@ void ecs_set_primitive(
     if (!strcmp(descr, "uptr")) {
         ecs_set(world, e, EcsPrimitive, {EcsUPtr});
     } else
-    if (!strcmp(descr, "string")) {
+    if (!strcmp(descr, "string_t")) {
         ecs_set(world, e, EcsPrimitive, {EcsString});
     } else
     if (!strcmp(descr, "entity")) {
@@ -1570,9 +1544,7 @@ void ecs_set_bitmask(
     ecs_entity_t e,
     EcsMetaType *type)
 {
-    ecs_entity_t comp = ecs_lookup_fullpath(world, "flecs.meta.Bitmask");
+    ecs_set_constants(world, e, ecs_id(EcsBitmask), true, type);
-    ecs_assert(comp != 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_set_constants(world, e, comp, true, type);
 }
 
 static
@@ -1581,9 +1553,7 @@ void ecs_set_enum(
     ecs_entity_t e,
     EcsMetaType *type)
 {
-    ecs_entity_t comp = ecs_lookup_fullpath(world, "flecs.meta.Enum");
+    ecs_set_constants(world, e, ecs_id(EcsEnum), false, type);
-    ecs_assert(comp != 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_set_constants(world, e, comp, false, type);
 }
 
 static
@@ -1615,10 +1585,12 @@ void ecs_set_struct(
         ecs_assert(type != 0, ECS_INTERNAL_ERROR, NULL);
     }
 
+    if (!ecs_vector_count(members)) {
+        ecs_parser_error(name, type->descriptor, 0, "empty struct declaration");
+    }
+
     is_partial = token.is_partial;
 
-    ecs_entity_t ecs_entity(EcsStruct) = ecs_lookup_fullpath(world, "flecs.meta.Struct");
-    ecs_assert(ecs_entity(EcsStruct) != 0, ECS_INTERNAL_ERROR, NULL);
     ecs_set(world, e, EcsStruct, {members, is_partial});
 }
 
@@ -1687,7 +1659,7 @@ void ecs_set_map(
 
 static
 void EcsSetType(ecs_iter_t *it) {
-    ECS_COLUMN(it, EcsMetaType, type, 1);
+    EcsMetaType *type = ecs_column(it, EcsMetaType, 1);
 
     ecs_world_t *world = it->world;
 
@@ -1754,9 +1726,7 @@ void ecs_new_meta(
     ecs_entity_t component,
     EcsMetaType *meta_type)
 {
-    ecs_entity_t ecs_entity(EcsMetaType) =
+    ecs_assert(ecs_id(EcsMetaType) != 0, ECS_MODULE_UNDEFINED, "flecs.meta");
-        ecs_lookup_fullpath(world, "flecs.meta.MetaType");
-    ecs_assert(ecs_entity(EcsMetaType) != 0, ECS_MODULE_UNDEFINED, "flecs.meta");
 
     if (meta_type->alias) {
         EcsMetaType *alias = meta_type->alias;
@@ -1769,13 +1739,13 @@ void ecs_new_meta(
 
 /* Utility macro to insert meta data for type with meta descriptor */
 #define ECS_COMPONENT_TYPE(world, type)\
-    ecs_set_ptr(world, ecs_entity(type), EcsMetaType, &__##type##__)
+    ecs_set_ptr(world, ecs_id(type), EcsMetaType, &__##type##__)
 
 /* Utility macro to insert metadata for primitive type */
 #define ECS_COMPONENT_PRIMITIVE(world, type, kind)\
     ECS_COMPONENT(world, type);\
-    ecs_set(world, ecs_entity(type), EcsMetaType, {EcsPrimitiveType, 0, 0, NULL, NULL});\
+    ecs_set(world, ecs_id(type), EcsMetaType, {EcsPrimitiveType, 0, 0, NULL, NULL});\
-    ecs_set(world, ecs_entity(type), EcsPrimitive, {kind})
+    ecs_set(world, ecs_id(type), EcsPrimitive, {kind})
 
 void FlecsMetaImport(
     ecs_world_t *world)
@@ -1784,26 +1754,25 @@ void FlecsMetaImport(
 
     ecs_set_name_prefix(world, "Ecs");
 
-    ECS_COMPONENT(world, EcsPrimitive);
+    ECS_COMPONENT_DEFINE(world, EcsPrimitive);
-    ECS_COMPONENT(world, EcsEnum);
+    ECS_COMPONENT_DEFINE(world, EcsEnum);
-    ECS_COMPONENT(world, EcsBitmask);
+    ECS_COMPONENT_DEFINE(world, EcsBitmask);
-    ECS_COMPONENT(world, EcsMember);
+    ECS_COMPONENT_DEFINE(world, EcsMember);
-    ECS_COMPONENT(world, EcsStruct);
+    ECS_COMPONENT_DEFINE(world, EcsStruct);
-    ECS_COMPONENT(world, EcsArray);
+    ECS_COMPONENT_DEFINE(world, EcsArray);
-    ECS_COMPONENT(world, EcsVector);
+    ECS_COMPONENT_DEFINE(world, EcsVector);
-    ECS_COMPONENT(world, EcsMap);
+    ECS_COMPONENT_DEFINE(world, EcsMap);
-    ECS_COMPONENT(world, EcsMetaType);
+    ECS_COMPONENT_DEFINE(world, EcsMetaType);
-    ECS_COMPONENT(world, ecs_type_op_kind_t);
+    ECS_COMPONENT_DEFINE(world, ecs_type_op_kind_t);
-    ECS_COMPONENT(world, ecs_type_op_t);
+    ECS_COMPONENT_DEFINE(world, ecs_type_op_t);
-    ECS_COMPONENT(world, EcsMetaTypeSerializer);
+    ECS_COMPONENT_DEFINE(world, EcsMetaTypeSerializer);
 
     ECS_SYSTEM(world, EcsSetType, EcsOnSet, EcsMetaType);
 
     ecs_set_component_actions(world, EcsMetaType, {
         .ctor = ecs_ctor(EcsMetaType),
         .dtor = ecs_dtor(EcsMetaType),
-        .copy = ecs_copy(EcsMetaType),
+        .copy = ecs_copy(EcsMetaType)
-        .move = ecs_move(EcsMetaType)
     });
 
     ecs_set_component_actions(world, EcsStruct, {
@@ -1826,13 +1795,13 @@ void FlecsMetaImport(
         .dtor = ecs_dtor(EcsMetaTypeSerializer)
     });
 
-    ECS_SYSTEM(world, EcsSetPrimitive, EcsOnSet, Primitive, flecs.meta:flecs.meta);
+    ECS_SYSTEM(world, EcsSetPrimitive, EcsOnSet, Primitive);
-    ECS_SYSTEM(world, EcsSetEnum, EcsOnSet, Enum, flecs.meta:flecs.meta);
+    ECS_SYSTEM(world, EcsSetEnum, EcsOnSet, Enum);
-    ECS_SYSTEM(world, EcsSetBitmask, EcsOnSet, Bitmask, flecs.meta:flecs.meta);
+    ECS_SYSTEM(world, EcsSetBitmask, EcsOnSet, Bitmask);
-    ECS_SYSTEM(world, EcsSetStruct, EcsOnSet, Struct, flecs.meta:flecs.meta);
+    ECS_SYSTEM(world, EcsSetStruct, EcsOnSet, Struct);
-    ECS_SYSTEM(world, EcsSetArray, EcsOnSet, Array, flecs.meta:flecs.meta);
+    ECS_SYSTEM(world, EcsSetArray, EcsOnSet, Array);
-    ECS_SYSTEM(world, EcsSetVector, EcsOnSet, Vector, flecs.meta:flecs.meta);
+    ECS_SYSTEM(world, EcsSetVector, EcsOnSet, Vector);
-    ECS_SYSTEM(world, EcsSetMap, EcsOnSet, Map, flecs.meta:flecs.meta);
+    ECS_SYSTEM(world, EcsSetMap, EcsOnSet, Map);
 
     ECS_EXPORT_COMPONENT(EcsPrimitive);
     ECS_EXPORT_COMPONENT(EcsEnum);
@@ -1870,8 +1839,12 @@ void FlecsMetaImport(
      * registered with the name _Bool. To make sure meta also knows the type by
      * its regular name, check and register if necessary */
     if (!ecs_lookup(world, "bool")) {
-        ecs_entity_t type = ecs_new_component(
+        ecs_entity_t type = ecs_component_init(world, &(ecs_component_desc_t) {
-            world, 0, "bool", sizeof(bool), ECS_ALIGNOF(bool));
+            .entity.name = "bool",
+            .size = sizeof(bool),
+            .alignment = ECS_ALIGNOF(bool)
+        });
+
         ecs_set(world, type, EcsMetaType, {
             EcsPrimitiveType, 0, 0, NULL, NULL});
         ecs_set(world, type, EcsPrimitive, {EcsBool});
@@ -1880,12 +1853,11 @@ void FlecsMetaImport(
     ecs_set_scope(world, old_scope);
 
     /* -- Initialize builtin meta components -- */
-    ecs_set_ptr(world, ecs_set(world, 0,
+    
-        EcsName, {"ecs_primitive_kind_t", NULL, NULL}),
+    ecs_set_ptr(world, ecs_set_name(world, 0, "ecs_primitive_kind_t"),
         EcsMetaType, &__ecs_primitive_kind_t__);
 
-    ecs_set(world, ecs_set(world, 0,
+    ecs_set(world, ecs_set_name(world, 0, "ecs_type_kind_t"),
-        EcsName, {"ecs_type_kind_t", NULL, NULL}),
         EcsMetaType, {
             EcsEnumType,
             sizeof(ecs_type_kind_t),
@@ -1909,29 +1881,21 @@ void FlecsMetaImport(
     ECS_COMPONENT_TYPE(world, EcsMetaTypeSerializer);
 
     /* -- Initialize metadata for public Flecs core components -- */
-    ecs_set(world, ecs_entity(EcsName), EcsMetaType, {
+    ecs_set(world, ecs_id(EcsIdentifier), EcsMetaType, {
         .kind = EcsStructType,
-        .size = sizeof(EcsName),
+        .size = sizeof(EcsIdentifier),
-        .alignment = ECS_ALIGNOF(EcsName),
+        .alignment = ECS_ALIGNOF(EcsIdentifier),
-        .descriptor = "{ecs_string_t value; ECS_PRIVATE; }",
+        .descriptor = "{ char *value; ECS_PRIVATE }",
         .alias = NULL
     });
 
-    ecs_set(world, ecs_entity(EcsComponent), EcsMetaType, {
+    ecs_set(world, ecs_id(EcsComponent), EcsMetaType, {
         .kind = EcsStructType,
         .size = sizeof(EcsComponent),
         .alignment = ECS_ALIGNOF(EcsComponent),
         .descriptor = "{int32_t size; int32_t alignment;}",
         .alias = NULL
     });
-
-    ecs_set(world, ecs_entity(EcsSignatureExpr), EcsMetaType, {
-        .kind = EcsStructType,
-        .size = sizeof(EcsSignatureExpr),
-        .alignment = ECS_ALIGNOF(EcsSignatureExpr),
-        .descriptor = "{const char *expr;}",
-        .alias = NULL
-    });
 }
 
 ecs_entity_t ecs_meta_lookup_array(
@@ -1955,16 +1919,13 @@ ecs_entity_t ecs_meta_lookup_array(
         ecs_meta_error(ctx, params_decl, "invalid array size");
     }
 
-    ecs_entity_t element_type = ecs_lookup_symbol(world, params.type.type);
+    ecs_entity_t element_type = ecs_lookup_symbol(world, params.type.type, true);
     if (!element_type) {
         ecs_meta_error(ctx, params_decl, "unknown element type '%s'",
             params.type.type);
     }
 
     if (!e) {
-        ecs_entity_t ecs_entity(EcsMetaType) = ecs_lookup_fullpath(world, "flecs.meta.MetaType");
-        ecs_assert(ecs_entity(EcsMetaType) != 0, ECS_INTERNAL_ERROR, NULL);
-
         const EcsMetaType *elem_type = ecs_get(world, element_type, EcsMetaType);
         ecs_assert(elem_type != NULL, ECS_INTERNAL_ERROR, NULL);
 
@@ -1977,9 +1938,6 @@ ecs_entity_t ecs_meta_lookup_array(
         });
     }
 
-    ecs_entity_t ecs_entity(EcsArray) = ecs_lookup_fullpath(world, "flecs.meta.Array");
-    ecs_assert(ecs_entity(EcsArray) != 0, ECS_INTERNAL_ERROR, NULL);
-
     ecs_assert(params.count <= INT32_MAX, ECS_INVALID_PARAMETER, NULL);
 
     return ecs_set(world, e, EcsArray, { element_type, (int32_t)params.count });
@@ -2007,15 +1965,9 @@ ecs_entity_t ecs_meta_lookup_vector(
         world, &params.type, params_decl, 1, &param_ctx);
 
     if (!e) {
-        ecs_entity_t ecs_entity(EcsMetaType) = ecs_lookup_fullpath(world, "flecs.meta.MetaType");
-        ecs_assert(ecs_entity(EcsMetaType) != 0, ECS_INTERNAL_ERROR, NULL);
-
         e = ecs_set(world, 0, EcsMetaType, {EcsVectorType, 0, 0, NULL, NULL});
     }
 
-    ecs_entity_t ecs_entity(EcsVector) = ecs_lookup_fullpath(world, "flecs.meta.Vector");
-    ecs_assert(ecs_entity(EcsVector) != 0, ECS_INTERNAL_ERROR, NULL);
-
     return ecs_set(world, e, EcsVector, { element_type });
 }
 
@@ -2044,15 +1996,9 @@ ecs_entity_t ecs_meta_lookup_map(
         world, &params.type, params_decl, 1, &param_ctx);
 
     if (!e) {
-        ecs_entity_t ecs_entity(EcsMetaType) = ecs_lookup_fullpath(world, "flecs.meta.MetaType");
-        ecs_assert(ecs_entity(EcsMetaType) != 0, ECS_INTERNAL_ERROR, NULL);
-        
         e = ecs_set(world, 0, EcsMetaType, {EcsMapType, 0, 0, NULL, NULL});
     }
 
-    ecs_entity_t ecs_entity(EcsMap) = ecs_lookup_fullpath(world, "flecs.meta.Map");
-    ecs_assert(ecs_entity(EcsMap) != 0, ECS_INTERNAL_ERROR, NULL);
-
     return ecs_set(world, e, EcsMap, { key_type, element_type });
 }
 
@@ -2087,9 +2033,6 @@ ecs_entity_t ecs_meta_lookup_bitmask(
 
 #ifndef NDEBUG
     /* Make sure this is a bitmask type */
-    ecs_entity_t ecs_entity(EcsMetaType) = ecs_lookup_fullpath(world, "flecs.meta.MetaType");
-    ecs_assert(ecs_entity(EcsMetaType) != 0, ECS_INTERNAL_ERROR, NULL);
-
     const EcsMetaType *type_ptr = ecs_get(world, bitmask_type, EcsMetaType);
     ecs_assert(type_ptr != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_assert(type_ptr->kind == EcsBitmaskType, ECS_INVALID_PARAMETER, NULL);
@@ -2140,7 +2083,7 @@ ecs_entity_t ecs_meta_lookup(
             typename = "ecs_string_t";
         }
 
-        type = ecs_lookup_symbol(world, typename);
+        type = ecs_lookup_symbol(world, typename, true);
         if (!type) {
             ecs_meta_error(ctx, ptr, "unknown type '%s'", typename);
             return 0;
@@ -2151,8 +2094,6 @@ ecs_entity_t ecs_meta_lookup(
         /* If count is not 1, insert array type. First lookup EcsMetaType of the
          * element type to get the size and alignment. Then create a new
          * entity for the array type, and assign it to the member type. */
-        ecs_entity_t ecs_entity(EcsMetaType) = ecs_lookup_fullpath(world, "flecs.meta.MetaType");
-        ecs_entity_t ecs_entity(EcsArray) = ecs_lookup_fullpath(world, "flecs.meta.Array");
         const EcsMetaType *type_ptr = ecs_get(world, type, EcsMetaType);
 
         ecs_assert(count <= INT32_MAX, ECS_INVALID_PARAMETER, NULL);
@@ -2197,7 +2138,7 @@ ecs_type_op_t* get_ptr(
 }
 
 ecs_meta_cursor_t ecs_meta_cursor(
-    ecs_world_t *world,
+    const ecs_world_t *world,
     ecs_entity_t type,
     void *base)
 {
@@ -2206,9 +2147,6 @@ ecs_meta_cursor_t ecs_meta_cursor(
     ecs_assert(base != NULL, ECS_INVALID_PARAMETER, NULL);
 
     ecs_meta_cursor_t result;
-    ecs_entity_t ecs_entity(EcsMetaTypeSerializer) =
-        ecs_lookup_fullpath(world, "flecs.meta.MetaTypeSerializer");
-    ecs_assert(ecs_entity(EcsMetaTypeSerializer) != 0, ECS_INVALID_PARAMETER, NULL);
 
     const EcsMetaTypeSerializer *ser = ecs_get(world, type, EcsMetaTypeSerializer);
     ecs_assert(ser != NULL, ECS_INVALID_PARAMETER, NULL);

code/vendors/flecs/flecs_meta.h

@@ -51,22 +51,22 @@
 #define ECS_ENUM_BOOTSTRAP(name, ...)\
 typedef enum name __VA_ARGS__ name;\
 ECS_UNUSED \
-static const char * __##name##__ = #__VA_ARGS__
+static const char * __##name##__ = #__VA_ARGS__;
 
 #define ECS_STRUCT_IMPL(name, descriptor, ...)\
 typedef struct name __VA_ARGS__ name;\
 ECS_UNUSED \
-static EcsMetaType __##name##__ = {EcsStructType, sizeof(name), ECS_ALIGNOF(name), descriptor, NULL}\
+static EcsMetaType __##name##__ = {EcsStructType, sizeof(name), ECS_ALIGNOF(name), descriptor, NULL};
 
 #define ECS_ENUM_IMPL(name, descriptor, ...)\
 typedef enum name __VA_ARGS__ name;\
 ECS_UNUSED \
-static EcsMetaType __##name##__ = {EcsEnumType, sizeof(name), ECS_ALIGNOF(name), descriptor, NULL}
+static EcsMetaType __##name##__ = {EcsEnumType, sizeof(name), ECS_ALIGNOF(name), descriptor, NULL};
 
 #define ECS_BITMASK_IMPL(name, descriptor, ...)\
 typedef enum name __VA_ARGS__ name;\
 ECS_UNUSED \
-static EcsMetaType __##name##__ = {EcsBitmaskType, sizeof(name), ECS_ALIGNOF(name), descriptor, NULL}
+static EcsMetaType __##name##__ = {EcsBitmaskType, sizeof(name), ECS_ALIGNOF(name), descriptor, NULL};
 
 #define ECS_STRUCT_C(T, ...) ECS_STRUCT_IMPL(T, #__VA_ARGS__, __VA_ARGS__)
 #define ECS_ENUM_C(T, ...) ECS_ENUM_IMPL(T, #__VA_ARGS__, __VA_ARGS__)
@@ -96,7 +96,7 @@ class __meta__ { };
 }
 
 // Specialized C++ class that stores name and descriptor of type
-#define ECS_META_CPP(T, kind, descr);\
+#define ECS_META_CPP(T, kind, descr)\
 namespace flecs {\
 template<>\
 class __meta__ <T> {\
@@ -124,17 +124,17 @@ public:\
 
 // Define a struct
 #define ECS_STRUCT(T, ...)\
-    ECS_STRUCT_IMPL(T, #__VA_ARGS__, __VA_ARGS__);\
+    ECS_STRUCT_IMPL(T, #__VA_ARGS__, __VA_ARGS__)\
     ECS_META_CPP(T, EcsStructType, #__VA_ARGS__)
 
 // Define an enumeration
 #define ECS_ENUM(T, ...)\
-    ECS_ENUM_IMPL(T, #__VA_ARGS__, __VA_ARGS__);\
+    ECS_ENUM_IMPL(T, #__VA_ARGS__, __VA_ARGS__)\
-    ECS_META_CPP(T, EcsEnumType, #__VA_ARGS__);
+    ECS_META_CPP(T, EcsEnumType, #__VA_ARGS__)
 
 // Define a bitmask
 #define ECS_BITMASK(T, ...)\
-    ECS_BITMASK_IMPL(T, #__VA_ARGS__, __VA_ARGS__);\
+    ECS_BITMASK_IMPL(T, #__VA_ARGS__, __VA_ARGS__)\
     ECS_META_CPP(T, EcsBitmaskType, #__VA_ARGS__)
 
 #else
@@ -189,8 +189,8 @@ typedef uint8_t ecs_byte_t;
 #ifdef __cplusplus
 
 namespace flecs {
-    using string = ecs_string_t;
+    using string_t = ecs_string_t;
-    using byte = ecs_byte_t;
+    using byte_t = ecs_byte_t;
 
     // Define a bitmask
     // In C++ trying to assign multiple flags to a variable of an enum type will
@@ -210,7 +210,7 @@ ECS_ENUM_BOOTSTRAP( ecs_type_kind_t, {
     EcsArrayType,
     EcsVectorType,
     EcsMapType
-});
+})
 
 ECS_STRUCT( EcsMetaType, {
     ecs_type_kind_t kind;
@@ -218,7 +218,7 @@ ECS_STRUCT( EcsMetaType, {
     int16_t alignment;
     const char *descriptor;
     void *alias;
-});
+})
 
 ECS_ENUM( ecs_primitive_kind_t, {
     EcsBool,
@@ -238,40 +238,40 @@ ECS_ENUM( ecs_primitive_kind_t, {
     EcsIPtr,
     EcsString,
     EcsEntity
-});
+})
 
 ECS_STRUCT( EcsPrimitive, {
     ecs_primitive_kind_t kind;
-});
+})
 
 // Define EcsBitmask for both C and C++. Both representations are equivalent in
 // memory, but allow for a nicer type-safe API in C++
 #if defined(__cplusplus) && !defined(FLECS_NO_CPP)
 ECS_STRUCT( EcsBitmask, {
-    flecs::map<int32_t, flecs::string> constants;
+    flecs::map<int32_t, flecs::string_t> constants;
-});
+})
 #else
 ECS_STRUCT( EcsBitmask, {
     ecs_map(int32_t, ecs_string_t) constants;
-});
+})
 #endif
 
 // Define EcsEnum for both C and C++. Both representations are equivalent in
 // memory, but allow for a nicer type-safe API in C++
 #if defined(__cplusplus) && !defined(FLECS_NO_CPP)
 ECS_STRUCT( EcsEnum, {
-    flecs::map<int32_t, flecs::string> constants;
+    flecs::map<int32_t, flecs::string_t> constants;
-});
+})
 #else
 ECS_STRUCT( EcsEnum, {
     ecs_map(int32_t, ecs_string_t) constants;
-});
+})
 #endif
 
 ECS_STRUCT( EcsMember, {
     char *name;
     ecs_entity_t type;
-});
+})
 
 // Define EcsStruct for both C and C++. Both representations are equivalent in
 // memory, but allow for a nicer type-safe API in C++
@@ -279,27 +279,27 @@ ECS_STRUCT( EcsMember, {
 ECS_STRUCT( EcsStruct, {
     flecs::vector<EcsMember> members;
     bool is_partial;
-});
+})
 #else
 ECS_STRUCT( EcsStruct, {
     ecs_vector(EcsMember) members;
     bool is_partial;
-});
+})
 #endif
 
 ECS_STRUCT( EcsArray, {
     ecs_entity_t element_type;
     int32_t count;
-});
+})
 
 ECS_STRUCT( EcsVector, {
     ecs_entity_t element_type;
-});
+})
 
 ECS_STRUCT( EcsMap, {
     ecs_entity_t key_type;
     ecs_entity_t element_type;
-});
+})
 
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -316,7 +316,7 @@ ECS_ENUM_C( ecs_type_op_kind_t, {
     EcsOpArray,
     EcsOpVector,
     EcsOpMap
-});
+})
 
 typedef ecs_vector_t ecs_type_op_vector_t;
 typedef ecs_vector_t ecs_constant_vector_t;
@@ -326,7 +326,7 @@ ECS_STRUCT_C( ecs_type_op_t, {
     ecs_type_op_kind_t kind;
     ecs_size_t size;      /* Size of value or element type if array or vector */
     int16_t alignment; /* Alignment of value */
-    int32_t count;        /* Number of elements (only used for arrays) */
+    int32_t count;        /* Number of array elements or struct members */
     int32_t offset;       /* Offset of value */
     const char *name;     /* Name of value (only used for struct members) */
 
@@ -343,11 +343,11 @@ ECS_PRIVATE
             ecs_ref_t element;
         } map;
     } is;
-});
+})
 
 ECS_STRUCT_C( EcsMetaTypeSerializer, {
     ecs_vector(ecs_type_op_t) ops;
-});
+})
 
 #endif
 
@@ -457,14 +457,14 @@ typedef struct ecs_meta_scope_t {
 } ecs_meta_scope_t;
 
 typedef struct ecs_meta_cursor_t {
-    ecs_world_t *world;
+    const ecs_world_t *world;
     ecs_meta_scope_t scope[ECS_META_MAX_SCOPE_DEPTH];
     int32_t depth;
 } ecs_meta_cursor_t;
 
 FLECS_META_API
 ecs_meta_cursor_t ecs_meta_cursor(
-    ecs_world_t *world,
+    const ecs_world_t *world,
     ecs_entity_t type,
     void *base);
 
@@ -554,20 +554,24 @@ typedef struct FlecsMeta {
 extern "C" {
 #endif
 
+FLECS_META_API ECS_COMPONENT_EXTERN(EcsPrimitive);
+FLECS_META_API ECS_COMPONENT_EXTERN(EcsEnum);
+FLECS_META_API ECS_COMPONENT_EXTERN(EcsBitmask);
+FLECS_META_API ECS_COMPONENT_EXTERN(EcsMember);
+FLECS_META_API ECS_COMPONENT_EXTERN(EcsStruct);
+FLECS_META_API ECS_COMPONENT_EXTERN(EcsArray);
+FLECS_META_API ECS_COMPONENT_EXTERN(EcsVector);
+FLECS_META_API ECS_COMPONENT_EXTERN(EcsMap);
+FLECS_META_API ECS_COMPONENT_EXTERN(EcsMetaType);
+FLECS_META_API ECS_COMPONENT_EXTERN(ecs_type_op_kind_t);
+FLECS_META_API ECS_COMPONENT_EXTERN(ecs_type_op_t);
+FLECS_META_API ECS_COMPONENT_EXTERN(EcsMetaTypeSerializer);
+
 FLECS_META_API
 void FlecsMetaImport(
     ecs_world_t *world);
 
-#define FlecsMetaImportHandles(handles)\
+#define FlecsMetaImportHandles(handles)
-    ECS_IMPORT_COMPONENT(handles, EcsPrimitive);\
-    ECS_IMPORT_COMPONENT(handles, EcsEnum);\
-    ECS_IMPORT_COMPONENT(handles, EcsBitmask);\
-    ECS_IMPORT_COMPONENT(handles, EcsStruct);\
-    ECS_IMPORT_COMPONENT(handles, EcsArray);\
-    ECS_IMPORT_COMPONENT(handles, EcsVector);\
-    ECS_IMPORT_COMPONENT(handles, EcsMap);\
-    ECS_IMPORT_COMPONENT(handles, EcsMetaType);\
-    ECS_IMPORT_COMPONENT(handles, EcsMetaTypeSerializer);
 
 ////////////////////////////////////////////////////////////////////////////////
 //// Macro for inserting metadata in C application
@@ -583,6 +587,14 @@ void ecs_new_meta(
     ECS_COMPONENT(world, T);\
     ecs_new_meta(world, ecs_entity(T), &__##T##__);
 
+/** Define a meta component, store in variable outside of the current scope.
+* Use this macro in a header when defining a component identifier globally.
+* Must be used together with ECS_COMPONENT_DECLARE.
+*/
+#define ECS_META_DEFINE(world, T)\
+    ECS_COMPONENT_DEFINE(world, T);\
+    ecs_new_meta(world, ecs_entity(T), &__##T##__);
+
 #ifdef __cplusplus
 }
 #endif
@@ -620,18 +632,18 @@ public:
     };
 
     meta(flecs::world& world) {
-        FlecsMetaImport(world.c_ptr());
+        FlecsMetaImport(world);
 
-        flecs::module<flecs::components::meta>(world, "flecs::components::meta");
+        world.module<flecs::components::meta>("flecs::components::meta");
 
-        flecs::component<Primitive>(world, "EcsPrimitive");
+        world.component<Primitive>("EcsPrimitive");
-        flecs::component<Enum>(world, "EcsEnum");
+        world.component<Enum>("EcsEnum");
-        flecs::component<Bitmask>(world, "EcsBitmask");
+        world.component<Bitmask>("EcsBitmask");
-        flecs::component<Struct>(world, "EcsStruct");
+        world.component<Struct>("EcsStruct");
-        flecs::component<Array>(world, "EcsArray");
+        world.component<Array>("EcsArray");
-        flecs::component<Vector>(world, "EcsVector");
+        world.component<Vector>("EcsVector");
-        flecs::component<Type>(world, "EcsMetaType");
+        world.component<Type>("EcsMetaType");
-        flecs::component<TypeSerializer>(world, "EcsMetaTypeSerializer");
+        world.component<TypeSerializer>("EcsMetaTypeSerializer");
     }
 };
 }
@@ -654,29 +666,27 @@ flecs::entity meta(flecs::world& world) {
 ////////////////////////////////////////////////////////////////////////////////
 
 template <typename T>
-std::string pretty_print(flecs::world& world, flecs::entity_t type, T& data) {
+flecs::string pretty_print(flecs::world& world, flecs::entity_t type, T& data) {
     char *str = ecs_ptr_to_str(world.c_ptr(), type, &data);
-    std::string result = std::string(str);
+    flecs::string result = flecs::string(str);
-    free(str);
     return result;
 }
 
 template <typename T>
-std::string pretty_print(flecs::world& world, flecs::entity type, T& data) {
+flecs::string pretty_print(flecs::world& world, flecs::entity type, T& data) {
     return pretty_print(world, type.id(), data);
 }
 
 template <typename T>
-std::string pretty_print(flecs::world& world, T& data) {
+flecs::string pretty_print(flecs::world& world, T& data) {
-    entity_t type = _::component_info<T>::id();
+    entity_t type = _::cpp_type<T>::id();
     return flecs::pretty_print(world, type, data);
 }
 
 template <>
-inline std::string pretty_print<flecs::entity>(flecs::world& world, flecs::entity& entity) {
+inline flecs::string pretty_print<flecs::entity>(flecs::world& world, flecs::entity& entity) {
     char *str = ecs_entity_to_str(world.c_ptr(), entity.id());
-    std::string result = std::string(str);
+    flecs::string result = flecs::string(str);
-    free(str);
     return result;
 }