Code cleanup

Author: SanderMertens

distr/flecs.c

@@ -10850,6 +10850,24 @@ void* ecs_field_w_size(
     size_t size,
     int8_t index);
 
+/** Get data for a field matched through component inheritance.
+ * This operation is like ecs_field_w_size(), but is used when a field is
+ * matched on a component that is derived from the queried (base) type. Because
+ * the stored (derived) component can be larger than the requested (base) type,
+ * the returned pointer is computed using the stride of the stored component. To
+ * iterate the values, use the stride returned by ecs_field_stride().
+ *
+ * @param it The iterator.
+ * @param size The size of the field type.
+ * @param index The index of the field.
+ * @return A pointer to the data of the field.
+ */
+FLECS_API
+void* ecs_base_field_w_size(
+    const ecs_iter_t *it,
+    size_t size,
+    int8_t index);
+
 /** Get data for a field at a specified row.
  * This operation should be used instead of ecs_field_w_size() for sparse 
  * component fields. This operation should be called for each returned row in a
@@ -12445,6 +12463,13 @@ int ecs_value_move_ctor(
 #define ecs_field(it, T, index)\
     (ECS_CAST(T*, ecs_field_w_size(it, sizeof(T), index)))
 
+/** Get field data for a component matched through component inheritance.
+ * Use this instead of ecs_field() when a field is matched on a component that
+ * is derived from the queried (base) type. The data is iterated with the stride
+ * returned by ecs_field_stride(). */
+#define ecs_base_field(it, T, index)\
+    (ECS_CAST(T*, ecs_base_field_w_size(it, sizeof(T), index)))
+
 /** Get field data for a self-owned component. */
 #define ecs_field_self(it, T, index)\
     (ECS_CAST(T*, ecs_field_self_w_size(it, sizeof(T), index)))
@@ -27870,7 +27895,7 @@ struct iter {
         }
 
         return flecs::base_field<A>(
-            static_cast<T*>(ecs_field_w_size(iter_, sizeof(A), index)),
+            static_cast<T*>(ecs_base_field_w_size(iter_, sizeof(A), index)),
             ecs_field_stride(iter_, index), count, is_shared);
     }
 
@@ -31903,7 +31928,7 @@ struct field_ptrs {
                 fields_[index].is_ref = true;
                 fields_[index].index = static_cast<int8_t>(index);
             } else {
-                fields_[index].ptr = ecs_field_w_size(iter, sizeof(A),
+                fields_[index].ptr = ecs_base_field_w_size(iter, sizeof(A),
                     static_cast<int8_t>(index));
                 fields_[index].is_ref = iter->sources[index] != 0;
             }

distr/flecs.h

@@ -5820,6 +5820,24 @@ void* ecs_field_w_size(
     size_t size,
     int8_t index);
 
+/** Get data for a field matched through component inheritance.
+ * This operation is like ecs_field_w_size(), but is used when a field is
+ * matched on a component that is derived from the queried (base) type. Because
+ * the stored (derived) component can be larger than the requested (base) type,
+ * the returned pointer is computed using the stride of the stored component. To
+ * iterate the values, use the stride returned by ecs_field_stride().
+ *
+ * @param it The iterator.
+ * @param size The size of the field type.
+ * @param index The index of the field.
+ * @return A pointer to the data of the field.
+ */
+FLECS_API
+void* ecs_base_field_w_size(
+    const ecs_iter_t *it,
+    size_t size,
+    int8_t index);
+
 /** Get data for a field at a specified row.
  * This operation should be used instead of ecs_field_w_size() for sparse 
  * component fields. This operation should be called for each returned row in a

include/flecs.h

@@ -73,7 +73,7 @@ struct field_ptrs {
                 fields_[index].is_ref = true;
                 fields_[index].index = static_cast<int8_t>(index);
             } else {
-                fields_[index].ptr = ecs_field_w_size(iter, sizeof(A),
+                fields_[index].ptr = ecs_base_field_w_size(iter, sizeof(A),
                     static_cast<int8_t>(index));
                 fields_[index].is_ref = iter->sources[index] != 0;
             }

include/flecs/addons/cpp/delegate.hpp

@@ -554,7 +554,7 @@ struct iter {
         }
 
         return flecs::base_field<A>(
-            static_cast<T*>(ecs_field_w_size(iter_, sizeof(A), index)),
+            static_cast<T*>(ecs_base_field_w_size(iter_, sizeof(A), index)),
             ecs_field_stride(iter_, index), count, is_shared);
     }
 

include/flecs/addons/cpp/iter.hpp

@@ -727,6 +727,13 @@
 #define ecs_field(it, T, index)\
     (ECS_CAST(T*, ecs_field_w_size(it, sizeof(T), index)))
 
+/** Get field data for a component matched through component inheritance.
+ * Use this instead of ecs_field() when a field is matched on a component that
+ * is derived from the queried (base) type. The data is iterated with the stride
+ * returned by ecs_field_stride(). */
+#define ecs_base_field(it, T, index)\
+    (ECS_CAST(T*, ecs_base_field_w_size(it, sizeof(T), index)))
+
 /** Get field data for a self-owned component. */
 #define ecs_field_self(it, T, index)\
     (ECS_CAST(T*, ecs_field_self_w_size(it, sizeof(T), index)))

include/flecs/addons/flecs_c.h

@@ -123,6 +123,43 @@ void* ecs_field_w_size(
         return it->ptrs[index];
     }
 
+    int16_t column = it->columns[index];
+    if (column >= 0) {
+        ecs_column_t *col = &it->table->data.columns[column];
+        ecs_assert((ecs_size_t)size == col->ti->size,
+            ECS_INVALID_PARAMETER, NULL);
+        return ECS_ELEM(col->data, (ecs_size_t)size, it->offset);
+    }
+
+    return flecs_field_shared(it, size, index);
+error:
+    return NULL;
+}
+
+void* ecs_base_field_w_size(
+    const ecs_iter_t *it,
+    size_t size,
+    int8_t index)
+{
+    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER,
+        "operation invalid before calling next()");
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER,
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER,
+        "field index %d out of bounds", index);
+    ecs_check(size != 0, ECS_INVALID_PARAMETER,
+        "missing size for field %d", index);
+    ecs_check(ecs_field_size(it, index) == size ||
+        !ecs_field_size(it, index),
+            ECS_INVALID_PARAMETER,
+            "mismatching size for field %d (expected '%s')",
+            index,
+            flecs_errstr(ecs_id_str(it->world, it->ids[index])));
+
+    if (it->ptrs) {
+        return it->ptrs[index];
+    }
+
     int16_t column = it->columns[index];
     if (column >= 0) {
         ecs_column_t *col = &it->table->data.columns[column];

src/iter.c

@@ -110,14 +110,9 @@ ecs_id_t flecs_query_op_get_id(
     const ecs_query_run_ctx_t *ctx);
 
 int16_t flecs_query_next_column(
-    ecs_table_t *table,
-    ecs_id_t id,
-    int32_t column);
-
-int16_t flecs_query_next_inherited_column(
     const ecs_world_t *world,
     ecs_table_t *table,
-    ecs_id_t base,
+    ecs_id_t id,
     int32_t column);
 
 void flecs_query_it_set_tr(

src/query/engine/engine.h

@@ -17,20 +17,6 @@ bool flecs_query_dispatch(
     bool redo,
     ecs_query_run_ctx_t *ctx);
 
-static
-int16_t flecs_query_next_column_w_inherited(
-    const ecs_world_t *world,
-    ecs_table_t *table,
-    const ecs_table_record_t *tr,
-    ecs_id_t id,
-    int32_t column)
-{
-    if (!ecs_id_match(table->type.array[tr->index], tr->hdr.cr->id)) {
-        return flecs_query_next_inherited_column(world, table, id, column);
-    }
-    return flecs_query_next_column(table, id, column);
-}
-
 bool flecs_query_select_w_id(
     const ecs_query_op_t *op,
     bool redo,
@@ -77,8 +63,8 @@ bool flecs_query_select_w_id(
         tr = (const ecs_table_record_t*)op_ctx->it.cur;
         ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
         table = tr->hdr.table;
-        op_ctx->column = flecs_query_next_column_w_inherited(
-            ctx->world, table, tr, cr->id, op_ctx->column);
+        op_ctx->column = flecs_query_next_column(
+            ctx->world, table, cr->id, op_ctx->column);
         op_ctx->remaining --;
     }
 
@@ -142,9 +128,8 @@ bool flecs_query_with(
             return false;
         }
 
-        tr = (const ecs_table_record_t*)op_ctx->it.cur;
-        op_ctx->column = flecs_query_next_column_w_inherited(
-            ctx->world, table, tr, cr->id, op_ctx->column);
+        op_ctx->column = flecs_query_next_column(
+            ctx->world, table, cr->id, op_ctx->column);
         ecs_assert(op_ctx->column != -1, ECS_INTERNAL_ERROR, NULL);
     }
 

src/query/engine/eval.c

@@ -330,104 +330,17 @@ ecs_id_t flecs_query_op_get_id(
 }
 
 int16_t flecs_query_next_column(
+    const ecs_world_t *world,
     ecs_table_t *table,
     ecs_id_t id,
     int32_t column)
 {
-    if (!ECS_IS_PAIR(id) || (ECS_PAIR_FIRST(id) != EcsWildcard)) {
-        column = column + 1;
-    } else {
-        ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
-        column = ecs_search_offset(NULL, table, column + 1, id, NULL);
-        ecs_assert(column != -1, ECS_INTERNAL_ERROR, NULL);
-    }
+    ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+    column = ecs_search_offset(world, table, column + 1, id, NULL);
+    ecs_assert(column != -1, ECS_INTERNAL_ERROR, NULL);
     return flecs_ito(int16_t, column);
 }
 
-static
-bool flecs_component_inherits_from(
-    const ecs_world_t *world,
-    ecs_entity_t component,
-    ecs_entity_t base,
-    int32_t depth)
-{
-    if (depth >= FLECS_DAG_DEPTH_MAX) {
-        return false;
-    }
-
-    ecs_record_t *r = flecs_entities_get(world, component);
-    if (!r) {
-        return false;
-    }
-
-    ecs_table_t *table = r->table;
-    if (!table || !(table->flags & EcsTableHasIsA)) {
-        return false;
-    }
-
-    const ecs_table_record_t *tr_isa = flecs_component_get_table(
-        world->cr_isa_wildcard, table);
-    if (!tr_isa) {
-        return false;
-    }
-
-    ecs_id_t *ids = table->type.array;
-    int32_t i = tr_isa->index, end = i + tr_isa->count;
-    for (; i < end; i ++) {
-        ecs_entity_t b = ecs_pair_second(world, ids[i]);
-        if (b == base) {
-            return true;
-        }
-        if (flecs_component_inherits_from(world, b, base, depth + 1)) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-int16_t flecs_query_next_inherited_column(
-    const ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_id_t base,
-    int32_t column)
-{
-    ecs_id_t *ids = table->type.array;
-    int32_t i, count = table->type.count;
-
-    if (ECS_IS_PAIR(base)) {
-        ecs_entity_t base_rel = ecs_pair_first(world, base);
-        ecs_entity_t tgt = ECS_PAIR_SECOND(base);
-        bool any_tgt = (tgt == EcsWildcard) || (tgt == EcsAny);
-        for (i = column + 1; i < count; i ++) {
-            ecs_id_t id = ids[i];
-            if (!ECS_IS_PAIR(id)) {
-                continue;
-            }
-            if (!any_tgt && (ECS_PAIR_SECOND(id) != tgt)) {
-                continue;
-            }
-            if (flecs_component_inherits_from(
-                world, ecs_pair_first(world, id), base_rel, 0))
-            {
-                return flecs_ito(int16_t, i);
-            }
-        }
-    } else {
-        for (i = column + 1; i < count; i ++) {
-            ecs_id_t id = ids[i];
-            if (id & ECS_ID_FLAGS_MASK) {
-                continue;
-            }
-            if (flecs_component_inherits_from(world, id, base, 0)) {
-                return flecs_ito(int16_t, i);
-            }
-        }
-    }
-
-    ecs_abort(ECS_INTERNAL_ERROR, NULL);
-}
-
 void flecs_query_it_set_tr(
     ecs_iter_t *it,
     int32_t field_index,