queries/basics

• C

  View on GitHub

  #include <basics.h>
  #include <stdio.h>
   
  typedef struct {
      double x;
      double y;
  } Position, Velocity;
   
  int main(int argc, char *argv[]) {
      ecs_world_t *ecs = ecs_init_w_args(argc, argv);
   
      ECS_COMPONENT(ecs, Position);
      ECS_COMPONENT(ecs, Velocity);
   
      // Create a cached query for Position, Velocity. Cached queries are the 
      // fastest way to iterate entities as they cache results.
      ecs_query_t *q = ecs_query(ecs, {
          .terms = {
              { .id = ecs_id(Position) }, 
              { .id = ecs_id(Velocity), .inout = EcsIn}
          },
   
          // QueryCache Auto automatically caches all terms that can be cached.
          .cache_kind = EcsQueryCacheAuto
      });
   
      // Create a few test entities for a Position, Velocity query
      ecs_entity_t e1 = ecs_entity(ecs, { .name = "e1" });
      ecs_set(ecs, e1, Position, {10, 20});
      ecs_set(ecs, e1, Velocity, {1, 2});
   
      ecs_entity_t e2 = ecs_entity(ecs, { .name = "e2" });
      ecs_set(ecs, e2, Position, {10, 20});
      ecs_set(ecs, e2, Velocity, {3, 4});
   
      // This entity will not match as it does not have Position, Velocity
      ecs_entity_t e3 = ecs_entity(ecs, { .name = "e3" });
      ecs_set(ecs, e3, Position, {10, 20});
   
      // Iterate entities matching the query
      ecs_iter_t it = ecs_query_iter(ecs, q);
   
      // Outer loop, iterates archetypes
      while (ecs_query_next(&it)) {
          Position *p = ecs_field(&it, Position, 0);
          const Velocity *v = ecs_field(&it, Velocity, 1);
   
          // Inner loop, iterates entities in archetype
          for (int i = 0; i < it.count; i ++) {
              p[i].x += v[i].x;
              p[i].y += v[i].y;
              printf("%s: {%f, %f}\n", ecs_get_name(ecs, it.entities[i]), 
                  p[i].x, p[i].y);
          }
      }
   
      // Cleanup query resources.
      ecs_query_fini(q);
   
      return ecs_fini(ecs);
  }

• C++

  View on GitHub

  #include <basics.h>
  #include <iostream>
   
  struct Position { 
      double x, y;
  };
   
  struct Velocity { 
      double x, y;
  };
   
  int main(int, char *[]) {
      flecs::world ecs;
   
      // Create a cached query for Position, Velocity. Cached queries are the 
      // fastest way to iterate entities as they cache results.
      flecs::query<Position, const Velocity> q = 
          ecs.query_builder<Position, const Velocity>()
              .cached()
              .build();
   
      // Create a few test entities for a Position, Velocity query
      ecs.entity("e1")
          .set<Position>({10, 20})
          .set<Velocity>({1, 2});
   
      ecs.entity("e2")
          .set<Position>({10, 20})
          .set<Velocity>({3, 4});
   
      // This entity will not match as it does not have Position, Velocity
      ecs.entity("e3")
          .set<Position>({10, 20});
   
   
      // The next lines show the different ways in which a query can be iterated.
      // Note how the 'const' qualifier matches the query template arguments.
   
      // The each() function iterates each entity individually and accepts an
      // entity argument plus arguments for each query component:
      q.each([](flecs::entity e, Position& p, const Velocity& v) {
          p.x += v.x;
          p.y += v.y;
          std::cout << e.name() << ": {" << p.x << ", " << p.y << "}\n";
      });
   
      // You can omit the flecs::entity argument if it's not needed:
      q.each([](Position& p, const Velocity& v) {
          p.x += v.x;
          p.y += v.y;
          std::cout << "{" << p.x << ", " << p.y << "}\n";
      });
   
      // Each also accepts flecs::iter + index (for the iterated entity) arguments
      // currently being iterated. A flecs::iter has lots of information on what
      // is being iterated, which is demonstrated in the "iter" example.
      q.each([](flecs::iter& it, size_t i, Position& p, const Velocity& v) {
          p.x += v.x;
          p.y += v.y;
          std::cout << it.entity(i).name() << ": {" << p.x << ", " << p.y << "}\n";
      });
   
      // Run is a bit more verbose, but allows for more control over how entities
      // are iterated as it provides multiple entities in the same callback.
      q.run([](flecs::iter& it) {
          while (it.next()) {
              auto p = it.field<Position>(0);
              auto v = it.field<const Velocity>(1);
   
              for (auto i : it) {
                  p[i].x += v[i].x;
                  p[i].y += v[i].y;
                  std::cout << it.entity(i).name() << 
                      ": {" << p[i].x << ", " << p[i].y << "}\n";
              }
          }
      });
  }