413 lines
10 KiB
C
413 lines
10 KiB
C
#include <addons.h>
|
|
|
|
void Modules_setup(void) {
|
|
}
|
|
|
|
/* -- Begin module code -- */
|
|
|
|
typedef struct SimpleFooComponent {
|
|
float value;
|
|
} SimpleFooComponent;
|
|
|
|
typedef struct NestedComponent {
|
|
float value;
|
|
} NestedComponent;
|
|
|
|
static
|
|
void Move(ecs_iter_t *it) { }
|
|
|
|
static
|
|
void SimpleFooSystem(ecs_iter_t *it) { }
|
|
|
|
static
|
|
void SimpleFooTrigger(ecs_iter_t *it) { }
|
|
|
|
static ECS_COMPONENT_DECLARE(NestedComponent);
|
|
|
|
static ECS_COMPONENT_DECLARE(Position);
|
|
static ECS_COMPONENT_DECLARE(Velocity);
|
|
static ECS_COMPONENT_DECLARE(SimpleFooComponent);
|
|
static ECS_DECLARE(Tag);
|
|
static ECS_DECLARE(SimpleFooTag);
|
|
static ECS_DECLARE(Entity);
|
|
static ECS_DECLARE(SimpleFooEntity);
|
|
static ECS_DECLARE(SimpleFooPrefab);
|
|
static ECS_DECLARE(SimpleFooPipeline);
|
|
static ECS_DECLARE(Simple_underscore);
|
|
|
|
static ECS_SYSTEM_DECLARE(Move);
|
|
static ECS_SYSTEM_DECLARE(SimpleFooSystem);
|
|
static ECS_SYSTEM_DECLARE(SimpleFooTrigger);
|
|
|
|
void NestedModuleImport(
|
|
ecs_world_t *world)
|
|
{
|
|
ECS_MODULE(world, NestedModule);
|
|
|
|
ecs_set_name_prefix(world, "Nested");
|
|
|
|
ECS_COMPONENT_DEFINE(world, NestedComponent);
|
|
}
|
|
|
|
void SimpleModuleImport(
|
|
ecs_world_t *world)
|
|
{
|
|
ECS_MODULE(world, SimpleModule);
|
|
|
|
ECS_IMPORT(world, NestedModule);
|
|
|
|
ecs_set_name_prefix(world, "Simple");
|
|
|
|
ECS_COMPONENT_DEFINE(world, Position);
|
|
ECS_COMPONENT_DEFINE(world, Velocity);
|
|
ECS_COMPONENT_DEFINE(world, SimpleFooComponent);
|
|
|
|
ECS_TAG_DEFINE(world, Tag);
|
|
ECS_ENTITY_DEFINE(world, Entity, 0);
|
|
|
|
ECS_SYSTEM_DEFINE(world, Move, EcsOnUpdate, Position, Velocity);
|
|
ECS_SYSTEM_DEFINE(world, SimpleFooSystem, EcsOnUpdate, Position);
|
|
ECS_OBSERVER_DEFINE(world, SimpleFooTrigger, EcsOnAdd, Position);
|
|
|
|
ECS_TAG_DEFINE(world, SimpleFooTag);
|
|
ECS_ENTITY_DEFINE(world, SimpleFooEntity, 0);
|
|
ECS_PREFAB_DEFINE(world, SimpleFooPrefab, 0);
|
|
ECS_PIPELINE_DEFINE(world, SimpleFooPipeline, flecs.system.System, Tag);
|
|
ECS_TAG_DEFINE(world, Simple_underscore);
|
|
}
|
|
|
|
/* -- End module code -- */
|
|
|
|
void Modules_simple_module(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
test_assert(e != 0);
|
|
test_assert( ecs_has(world, e, Position));
|
|
|
|
ecs_add(world, e, Velocity);
|
|
test_assert( ecs_has(world, e, Velocity));
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
static
|
|
void AddVtoP(ecs_iter_t *it) {
|
|
int i;
|
|
for (i = 0; i < it->count; i ++) {
|
|
ecs_add(it->world, it->entities[i], Velocity);
|
|
}
|
|
}
|
|
|
|
void Modules_import_module_from_system(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
ECS_SYSTEM(world, AddVtoP, EcsOnUpdate, simple.module.Position);
|
|
|
|
ecs_entity_t e = ecs_new(world, Position);
|
|
test_assert(e != 0);
|
|
test_assert( ecs_has(world, e, Position));
|
|
|
|
ecs_progress(world, 1);
|
|
|
|
test_assert( ecs_has(world, e, Velocity));
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_import_again(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t m1 = ECS_IMPORT(world, SimpleModule);
|
|
ecs_entity_t m2 = ECS_IMPORT(world, SimpleModule);
|
|
|
|
test_assert(m1 != 0);
|
|
test_assert(m2 != 0);
|
|
test_assert(m1 == m2);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_scoped_component(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
|
|
ecs_entity_t e = ecs_lookup_fullpath(world, "simple.module.Position");
|
|
test_assert(e != 0);
|
|
test_assert(e == ecs_id(Position));
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_scoped_tag(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
|
|
ecs_entity_t e = ecs_lookup_fullpath(world, "simple.module.Tag");
|
|
test_assert(e != 0);
|
|
test_assert(e == Tag);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_scoped_system(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
|
|
ecs_entity_t e = ecs_lookup_fullpath(world, "simple.module.Move");
|
|
test_assert(e != 0);
|
|
test_assert(e == ecs_id(Move));
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_scoped_entity(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
|
|
ecs_entity_t e = ecs_lookup_fullpath(world, "simple.module.Entity");
|
|
test_assert(e != 0);
|
|
test_assert(e == Entity);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_name_prefix_component(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
|
|
ecs_entity_t e = ecs_lookup_fullpath(world, "simple.module.FooComponent");
|
|
test_assert(e != 0);
|
|
test_assert(e == ecs_id(SimpleFooComponent));
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_name_prefix_tag(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
|
|
ecs_entity_t e = ecs_lookup_fullpath(world, "simple.module.FooTag");
|
|
test_assert(e != 0);
|
|
test_assert(e == SimpleFooTag);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_name_prefix_system(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
|
|
ecs_entity_t e = ecs_lookup_fullpath(world, "simple.module.FooSystem");
|
|
test_assert(e != 0);
|
|
test_assert(e == ecs_id(SimpleFooSystem));
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_name_prefix_entity(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
|
|
ecs_entity_t e = ecs_lookup_fullpath(world, "simple.module.FooEntity");
|
|
test_assert(e != 0);
|
|
test_assert(e == SimpleFooEntity);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_name_prefix_prefab(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
|
|
ecs_entity_t e = ecs_lookup_fullpath(world, "simple.module.FooPrefab");
|
|
test_assert(e != 0);
|
|
test_assert(e == SimpleFooPrefab);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_name_prefix_pipeline(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
|
|
ecs_entity_t e = ecs_lookup_fullpath(world, "simple.module.FooPipeline");
|
|
test_assert(e != 0);
|
|
test_assert(e == SimpleFooPipeline);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_name_prefix_trigger(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
|
|
ecs_entity_t e = ecs_lookup_fullpath(world, "simple.module.FooTrigger");
|
|
test_assert(e != 0);
|
|
test_assert(e == ecs_id(SimpleFooTrigger));
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_name_prefix_underscore(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
|
|
ecs_entity_t e = ecs_lookup_fullpath(world, "simple.module.underscore");
|
|
test_assert(e != 0);
|
|
test_assert(e == Simple_underscore);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_lookup_by_symbol(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
|
|
ecs_entity_t e = ecs_lookup_symbol(world, "Position", true, true);
|
|
test_assert(e != 0);
|
|
test_assert(e == ecs_id(Position));
|
|
|
|
e = ecs_lookup_symbol(world, "SimpleFooComponent", true, true);
|
|
test_assert(e != 0);
|
|
test_assert(e == ecs_id(SimpleFooComponent));
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_nested_module(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
|
|
ecs_entity_t e = ecs_lookup_fullpath(world, "nested.module.Component");
|
|
test_assert(e != 0);
|
|
|
|
char *path = ecs_get_fullpath(world, e);
|
|
test_str(path, "nested.module.Component");
|
|
ecs_os_free(path);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_module_tag_on_namespace(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, SimpleModule);
|
|
|
|
ecs_entity_t mid = ecs_lookup_fullpath(world, "simple.module");
|
|
test_assert(mid != 0);
|
|
test_assert(ecs_has_id(world, mid, EcsModule));
|
|
|
|
ecs_entity_t nid = ecs_lookup_fullpath(world, "simple");
|
|
test_assert(nid != 0);
|
|
test_assert(ecs_has_id(world, nid, EcsModule));
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_module_tag_on_namespace_on_add(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t parent = ecs_new_id(world);
|
|
test_assert(parent != 0);
|
|
|
|
ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
|
|
test_assert(child != 0);
|
|
|
|
ecs_add_id(world, child, EcsModule);
|
|
test_assert( ecs_has_id(world, child, EcsModule));
|
|
test_assert( ecs_has_id(world, parent, EcsModule));
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_module_tag_on_namespace_on_add_2_levels(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t root = ecs_new_id(world);
|
|
test_assert(root != 0);
|
|
|
|
ecs_entity_t parent = ecs_new_w_pair(world, EcsChildOf, root);
|
|
test_assert(parent != 0);
|
|
|
|
ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
|
|
test_assert(child != 0);
|
|
|
|
ecs_add_id(world, child, EcsModule);
|
|
test_assert( ecs_has_id(world, child, EcsModule));
|
|
test_assert( ecs_has_id(world, parent, EcsModule));
|
|
test_assert( ecs_has_id(world, root, EcsModule));
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void Modules_import_2_worlds(void) {
|
|
ecs_world_t *world_1 = ecs_init();
|
|
ecs_world_t *world_2 = ecs_init();
|
|
|
|
ECS_IMPORT(world_1, SimpleModule);
|
|
ECS_IMPORT(world_2, SimpleModule);
|
|
|
|
test_assert(ecs_lookup_fullpath(world_1, "simple.module") != 0);
|
|
test_assert(ecs_lookup_fullpath(world_2, "simple.module") != 0);
|
|
|
|
{
|
|
ecs_entity_t e = ecs_new(world_1, Position);
|
|
test_assert(e != 0);
|
|
test_assert( ecs_has(world_1, e, Position));
|
|
ecs_add(world_1, e, Velocity);
|
|
test_assert( ecs_has(world_1, e, Velocity));
|
|
}
|
|
{
|
|
ecs_entity_t e = ecs_new(world_2, Position);
|
|
test_assert(e != 0);
|
|
test_assert( ecs_has(world_2, e, Position));
|
|
ecs_add(world_2, e, Velocity);
|
|
test_assert( ecs_has(world_2, e, Velocity));
|
|
}
|
|
|
|
ecs_fini(world_1);
|
|
ecs_fini(world_2);
|
|
}
|
|
|
|
void Modules_import_monitor_2_worlds(void) {
|
|
ecs_world_t *world_1 = ecs_init();
|
|
ecs_world_t *world_2 = ecs_init();
|
|
|
|
ECS_IMPORT(world_1, FlecsMonitor);
|
|
ECS_IMPORT(world_2, FlecsMonitor);
|
|
|
|
test_assert(ecs_exists(world_1, ecs_id(FlecsMonitor)));
|
|
test_assert(ecs_exists(world_2, ecs_id(FlecsMonitor)));
|
|
|
|
ecs_fini(world_1);
|
|
ecs_fini(world_2);
|
|
}
|
|
|
|
void Modules_import_monitor_after_mini(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_IMPORT(world, FlecsMonitor);
|
|
|
|
test_assert(ecs_exists(world, ecs_id(FlecsMonitor)));
|
|
|
|
ecs_fini(world);
|
|
}
|