modules/simple_module

• C

  View on GitHub

  include/simple_module.h

  #ifndef SIMPLE_MODULE_H
  #define SIMPLE_MODULE_H
   
  /* This generated file contains includes for project dependencies */
  #include "simple_module/bake_config.h"
   
  #ifdef __cplusplus
  extern "C" {
  #endif
   
  // Component types
  typedef struct {
      double x, y;
  } Position, Velocity;
   
  // Global variables that hold component ids
  extern ECS_COMPONENT_DECLARE(Position);
  extern ECS_COMPONENT_DECLARE(Velocity);
   
  // Module import function
  void SimpleModuleImport(ecs_world_t *world);
   
  #ifdef __cplusplus
  }
  #endif
   
  #endif

  src/main.c

  #include <simple_module.h>
  #include <stdio.h>
   
  void PrintPosition(ecs_iter_t *it) {
      Position *p = ecs_field(it, Position, 0);
   
      for (int i = 0; i < it->count; i ++) {
          printf("p = {%f, %f} (system)\n", p[i].x, p[i].y);
      }
  }
   
  int main(int argc, char *argv[]) {
      ecs_world_t *world = ecs_init_w_args(argc, argv);
   
      // Import module which calls the SimpleModuleImport function
      ECS_IMPORT(world, SimpleModule);
   
      // Create system that uses component from module. Note how the component
      // identifier is prefixed with the module.
      ECS_SYSTEM(world, PrintPosition, EcsOnUpdate, simple.module.Position);
   
      // Create entity with components imported from module
      ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
                       ecs_set(world, e, Velocity, {1, 2});
   
      // Call progress which runs imported Move system
      ecs_progress(world, 0);
   
      // Use component from module in operation
      const Position *p = ecs_get(world, e, Position);
      printf("p = {%f, %f} (get)\n", p->x, p->y);
   
      return ecs_fini(world);
   
      // Output:
      //   p = {11.000000, 22.000000} (system)
      //   p = {11.000000, 22.000000} (get)
  }

  src/simple_module.c

  #include <simple_module.h>
   
  ECS_COMPONENT_DECLARE(Position);
  ECS_COMPONENT_DECLARE(Velocity);
   
  void Move(ecs_iter_t *it) {
      Position *p = ecs_field(it, Position, 0);
      Velocity *v = ecs_field(it, Velocity, 1);
   
      for (int i = 0; i < it->count; i ++) {
          p[i].x += v[i].x;
          p[i].y += v[i].y;
      }
  }
   
  void SimpleModuleImport(ecs_world_t *world) {
      // Create the module entity. The PascalCase module name is translated to a
      // lower case path for the entity name, like "simple.module".
      ECS_MODULE(world, SimpleModule);
   
      // All contents of the module are created inside the module's namespace, so
      // the Position component will be created as simple.module.Position
   
      ECS_COMPONENT_DEFINE(world, Position);
      ECS_COMPONENT_DEFINE(world, Velocity);
   
      ECS_SYSTEM(world, Move, EcsOnUpdate, Position, Velocity);
  }

• C++

  View on GitHub

  include/simple_module.h

  #ifndef SIMPLE_MODULE_H
  #define SIMPLE_MODULE_H
   
  /* This generated file contains includes for project dependencies */
  #include "simple_module/bake_config.h"
   
  #ifdef __cplusplus
  extern "C" {
  #endif
   
  namespace simple {
   
  struct Position {
      double x, y;
  };
   
  struct Velocity {
      double x, y;
  };
   
  struct module {
      module(flecs::world& world); // Ctor that loads the module
  };
   
  }
   
  #ifdef __cplusplus
  }
  #endif
   
  #endif
   

  src/main.cpp

  #include <simple_module.h>
  #include <iostream>
   
  int main(int, char *[]) {
      flecs::world ecs;
   
      ecs.import<simple::module>();
   
      // Create system that uses component from module
      ecs.system<const simple::Position>("PrintPosition")
          .each([](const simple::Position& p) {
              std::cout << "p = {" << p.x << ", " << p.y << "} (system)\n";
          });
   
      // Create entity with imported components
      flecs::entity e = ecs.entity()
          .set<simple::Position>({10, 20})
          .set<simple::Velocity>({1, 1});
   
      // Call progress which runs imported Move system
      ecs.progress();
   
      // Use component from module in operation
      e.get([](const simple::Position& p) {
          std::cout << "p = {" << p.x << ", " << p.y << "} (get)\n";
      });
   
      // Output:
      //   p = {11.000000, 22.000000} (system)
      //   p = {11.000000, 22.000000} (get)
  }

  src/simple_module.cpp

  #include <simple_module.h>
   
  namespace simple {
   
  module::module(flecs::world& ecs) {
      // Register module with world. The module entity will be created with the
      // same hierarchy as the C++ namespaces (e.g. simple::module)
      ecs.module<module>();
   
      // All contents of the module are created inside the module's namespace, so
      // the Position component will be created as simple::module::Position
   
      // Component registration is optional, however by registering components
      // inside the module constructor, they will be created inside the scope
      // of the module.
      ecs.component<Position>();
      ecs.component<Velocity>();
   
      ecs.system<Position, const Velocity>("Move")
          .each([](Position& p, const Velocity& v) {    
              p.x += v.x;
              p.y += v.y;
          });        
  }
   
  }