[script] Incremental updates

Author: SanderMertens

distr/flecs.c

@@ -1008,4 +1008,99 @@ void flecs_rtt_init_default_hooks(
     }
 }
 
+static
+void flecs_rtt_strip_call_data(
+    ecs_vec_t *vec,
+    const ecs_type_info_t *ti)
+{
+    int32_t i = 0;
+    while (i < ecs_vec_count(vec)) {
+        ecs_rtt_call_data_t *data = ecs_vec_get_t(
+            vec, ecs_rtt_call_data_t, i);
+        if (data->type_info == ti) {
+            ecs_vec_remove_t(vec, ecs_rtt_call_data_t, i);
+        } else {
+            i ++;
+        }
+    }
+}
+
+void flecs_rtt_type_info_freed(
+    ecs_world_t *world,
+    const ecs_type_info_t *freed_ti)
+{
+    ecs_vec_t invalidated;
+    ecs_vec_init_t(NULL, &invalidated, const ecs_type_info_t*, 0);
+    ecs_vec_append_t(NULL, &invalidated,
+        const ecs_type_info_t*)[0] = freed_ti;
+
+    int32_t w = 0;
+    while (w < ecs_vec_count(&invalidated)) {
+        const ecs_type_info_t *cur = ecs_vec_get_t(&invalidated,
+            const ecs_type_info_t*, w)[0];
+        w ++;
+
+        ecs_map_iter_t it = ecs_map_iter(&world->type_info);
+        while (ecs_map_next(&it)) {
+            ecs_type_info_t *ti = ecs_map_ptr(&it);
+            if (ti == cur) {
+                continue;
+            }
+
+            void *ctx = ti->hooks.lifecycle_ctx;
+            if (!ctx) {
+                continue;
+            }
+
+            if (ti->hooks.lifecycle_ctx_free ==
+                flecs_rtt_free_lifecycle_struct_ctx)
+            {
+                ecs_rtt_struct_ctx_t *sctx = ctx;
+                flecs_rtt_strip_call_data(&sctx->vctor, cur);
+                flecs_rtt_strip_call_data(&sctx->vdtor, cur);
+                flecs_rtt_strip_call_data(&sctx->vmove, cur);
+                flecs_rtt_strip_call_data(&sctx->vcopy, cur);
+                flecs_rtt_strip_call_data(&sctx->vcmp, cur);
+                flecs_rtt_strip_call_data(&sctx->vequals, cur);
+            } else if (ti->hooks.lifecycle_ctx_free ==
+                flecs_rtt_free_lifecycle_array_ctx)
+            {
+                ecs_rtt_array_ctx_t *actx = ctx;
+                if (actx->type_info == cur) {
+                    flecs_rtt_free_lifecycle_array_ctx(actx);
+                    ti->hooks.lifecycle_ctx = NULL;
+                    ti->hooks.lifecycle_ctx_free = flecs_rtt_free_lifecycle_nop;
+                    ti->hooks.ctor = flecs_default_ctor;
+                    ti->hooks.dtor = NULL;
+                    ti->hooks.move = NULL;
+                    ti->hooks.copy = NULL;
+                    ti->hooks.cmp = NULL;
+                    ti->hooks.equals = NULL;
+                    ecs_vec_append_t(NULL, &invalidated,
+                        const ecs_type_info_t*)[0] = ti;
+                }
+            } else if (ti->hooks.lifecycle_ctx_free ==
+                flecs_rtt_free_lifecycle_vector_ctx)
+            {
+                ecs_rtt_vector_ctx_t *vctx = ctx;
+                if (vctx->type_info == cur) {
+                    flecs_rtt_free_lifecycle_vector_ctx(vctx);
+                    ti->hooks.lifecycle_ctx = NULL;
+                    ti->hooks.lifecycle_ctx_free = flecs_rtt_free_lifecycle_nop;
+                    ti->hooks.ctor = flecs_default_ctor;
+                    ti->hooks.dtor = NULL;
+                    ti->hooks.move = NULL;
+                    ti->hooks.copy = NULL;
+                    ti->hooks.cmp = NULL;
+                    ti->hooks.equals = NULL;
+                    ecs_vec_append_t(NULL, &invalidated,
+                        const ecs_type_info_t*)[0] = ti;
+                }
+            }
+        }
+    }
+
+    ecs_vec_fini_t(NULL, &invalidated, const ecs_type_info_t*);
+}
+
 #endif

src/addons/meta/rtt_lifecycle.c

@@ -34,6 +34,8 @@ typedef enum ecs_script_node_kind_t {
 typedef struct ecs_script_node_t {
     ecs_script_node_kind_t kind;
     const char *pos;
+    uint64_t depends_on;
+    bool contains_entities;
 } ecs_script_node_t;
 
 struct ecs_script_scope_t {
@@ -45,6 +47,15 @@ struct ecs_script_scope_t {
     /* Array with component ids that are added in scope. Used to limit
      * archetype moves. */
     ecs_vec_t components; /* vec<ecs_id_t> */
+
+    int32_t slot_start;
+    int32_t slot_end;
+    int32_t dyn_start;
+    int32_t dyn_end;
+    int32_t control_start;
+    int32_t control_end;
+    int32_t loop_id_start;
+    int32_t loop_id_end;
 };
 
 typedef struct ecs_script_id_t {
@@ -66,6 +77,10 @@ typedef struct ecs_script_id_t {
      * for entities that are defined inside of templates, which have different
      * values for each instantiation. */
     bool dynamic;
+
+    int32_t target_slot;
+    int32_t id_slot;
+    int32_t loop_id_slot;
 } ecs_script_id_t;
 
 typedef struct ecs_script_tag_t {
@@ -85,6 +100,7 @@ typedef struct ecs_script_default_component_t {
     ecs_script_node_t node;
     ecs_expr_node_t *expr;
     ecs_value_t eval;
+    int32_t loop_id_slot;
 } ecs_script_default_component_t;
 
 typedef struct ecs_script_var_component_t {
@@ -100,19 +116,25 @@ struct ecs_script_entity_t {
     bool name_is_var;
     bool kind_w_expr;
     bool non_fragmenting_parent;
+    bool is_expr_entity;
     ecs_script_scope_t *scope;
     ecs_expr_node_t *name_expr;
 
     /* Populated during eval */
     ecs_script_entity_t *parent;
     ecs_entity_t eval;
     ecs_entity_t eval_kind;
+
+    int32_t slot;
+    int32_t dyn_slot;
+    uint64_t name_depends_on;
 };
 
 typedef struct ecs_script_with_t {
     ecs_script_node_t node;
     ecs_script_scope_t *expressions;
     ecs_script_scope_t *scope;
+    uint64_t expr_depends_on;
 } ecs_script_with_t;
 
 typedef struct ecs_script_inherit_t {
@@ -124,6 +146,7 @@ typedef struct ecs_script_pair_scope_t {
     ecs_script_node_t node;
     ecs_script_id_t id;
     ecs_script_scope_t *scope;
+    uint64_t expr_depends_on;
 } ecs_script_pair_scope_t;
 
 typedef struct ecs_script_using_t {
@@ -160,6 +183,8 @@ typedef struct ecs_script_if_t {
     ecs_script_scope_t *if_true;
     ecs_script_scope_t *if_false;
     ecs_expr_node_t *expr;
+    uint64_t expr_depends_on;
+    int32_t control_slot;
 } ecs_script_if_t;
 
 typedef struct ecs_script_for_range_t {
@@ -168,6 +193,7 @@ typedef struct ecs_script_for_range_t {
     ecs_expr_node_t *from;
     ecs_expr_node_t *to;
     ecs_script_scope_t *scope;
+    uint64_t expr_depends_on;
 } ecs_script_for_range_t;
 
 typedef struct ecs_script_include_t {

src/addons/script/ast.h

@@ -940,10 +940,20 @@ int flecs_expr_new_visit_eval(
     ecs_script_eval_visitor_t temp_v = {0};
     ecs_script_eval_desc_t desc = {0};
 
+    if (v && v->template) {
+        if (ecs_script_visit_node(v, node->entity)) {
+            return -1;
+        }
+
+        *(ecs_entity_t*)out->value.ptr = 0;
+        out->value.type = ecs_id(ecs_entity_t);
+        return 0;
+    }
+
     if (!v) {
-        /* Safe const cast, script won't modify variables since it only contains 
+        /* Safe const cast, script won't modify variables since it only contains
          * an entity statement. */
-        desc.vars = ctx->desc ? 
+        desc.vars = ctx->desc ?
             ECS_CONST_CAST(ecs_script_vars_t*, ctx->desc->vars) : NULL;
         flecs_script_eval_visit_init(
             (const ecs_script_impl_t*)ctx->script, &temp_v, &desc);

src/addons/script/expr/visit_eval.c

@@ -14,7 +14,11 @@ void flecs_expr_value_visit_free(
     ecs_expr_value_node_t *node)
 {
     if (node->ptr != &node->storage) {
-        ecs_value_free(script->world, node->node.type, node->ptr);
+        if (ecs_is_alive(script->world, node->node.type) &&
+            ecs_get_type_info(script->world, node->node.type))
+        {
+            ecs_value_free(script->world, node->node.type, node->ptr);
+        }
     }
 }