chore(flecs_ecs_sys): (part 1) upgrade flecs C to commit d23b34a

tests pass, but C++ API changes have not been done yet in Rust API (that's part 2)

flecs_ecs/examples/flecs/z_ignore_main_test.rs

@@ -4,6 +4,7 @@
 #![allow(unused_imports)]
 #![allow(unused_variables)]
 #![allow(unused)]
+#![allow(unexpected_cfgs)]
 
 // to initialize the OS api for flecs before tests run.
 #[cfg(test)]

flecs_ecs/src/addons/doc.rs

@@ -775,7 +775,8 @@ fn test_compile_doc() {
     #[derive(flecs_ecs_derive::Component)]
     struct Tag;
 
-    let world = World::default();
+    let world = World::new();
+
     let entity = world.entity();
     entity.set_doc_name("name");
 

flecs_ecs/src/addons/script/script_entity_view.rs

@@ -87,7 +87,7 @@ impl<'a> ScriptEntityView<'a> {
     pub fn ast(&mut self) -> Option<String> {
         let script = self.get::<&flecs::Script>(|script| script.script);
 
-        let ast = unsafe { sys::ecs_script_ast_to_str(script) };
+        let ast = unsafe { sys::ecs_script_ast_to_str(script, false) };
 
         if ast.is_null() {
             ecs_assert!(

flecs_ecs/src/addons/script/unmanaged_script.rs

@@ -47,17 +47,32 @@ impl<'a> Script<'a> {
     ///
     /// * C API: `ecs_script_parse`
     #[doc(alias = "ecs_script_parse")]
-    pub fn parse(world: impl WorldProvider<'a>, name: &str, code: &str) -> Option<Script<'a>> {
+    pub fn parse(
+        world: impl WorldProvider<'a>,
+        name: &str,
+        code: &str,
+        desc: Option<sys::ecs_script_eval_desc_t>,
+    ) -> Option<Script<'a>> {
         let name = compact_str::format_compact!("{}\0", name);
         let code = compact_str::format_compact!("{}\0", code);
         let world_ptr = world.world_ptr_mut();
 
         let ptr = unsafe {
-            sys::ecs_script_parse(
-                world_ptr,
-                name.as_ptr() as *const _,
-                code.as_ptr() as *const _,
-            )
+            if let Some(desc) = desc {
+                sys::ecs_script_parse(
+                    world_ptr,
+                    name.as_ptr() as *const _,
+                    code.as_ptr() as *const _,
+                    &desc,
+                )
+            } else {
+                sys::ecs_script_parse(
+                    world_ptr,
+                    name.as_ptr() as *const _,
+                    code.as_ptr() as *const _,
+                    std::ptr::null(),
+                )
+            }
         };
         if ptr.is_null() {
             None
@@ -80,8 +95,12 @@ impl<'a> Script<'a> {
     ///
     /// * C API: `ecs_script_eval`
     #[doc(alias = "ecs_script_eval")]
-    pub fn eval(&self) -> bool {
-        unsafe { sys::ecs_script_eval(self.script) == 0 }
+    pub fn eval(&self, desc: Option<sys::ecs_script_eval_desc_t>) -> bool {
+        if let Some(desc) = desc {
+            unsafe { sys::ecs_script_eval(self.script, &desc) == 0 }
+        } else {
+            unsafe { sys::ecs_script_eval(self.script, std::ptr::null()) == 0 }
+        }
     }
 
     pub fn destroy(self) {
@@ -152,7 +171,7 @@ impl<'a> Script<'a> {
     /// * C API: `script_ast_to_buf`
     #[doc(alias = "script_ast_to_buf")]
     pub fn ast(&mut self) -> Option<String> {
-        let ast = unsafe { sys::ecs_script_ast_to_str(self.script) };
+        let ast = unsafe { sys::ecs_script_ast_to_str(self.script, false) };
 
         if !ast.is_null() {
             if self.ast.is_null() {

flecs_ecs/src/core/c_types.rs

@@ -394,8 +394,6 @@ pub(crate) const ECS_ON_DELETE: u64 = FLECS_HI_COMPONENT_ID + 43;
 pub(crate) const ECS_ON_DELETE_TARGET: u64 = FLECS_HI_COMPONENT_ID + 44;
 pub(crate) const ECS_ON_TABLE_CREATE: u64 = FLECS_HI_COMPONENT_ID + 45;
 pub(crate) const ECS_ON_TABLE_DELETE: u64 = FLECS_HI_COMPONENT_ID + 46;
-pub(crate) const ECS_ON_TABLE_EMPTY: u64 = FLECS_HI_COMPONENT_ID + 47;
-pub(crate) const ECS_ON_TABLE_FILL: u64 = FLECS_HI_COMPONENT_ID + 48;
 
 // Timers
 pub(crate) const ECS_TICK_SOURCE: u64 = FLECS_HI_COMPONENT_ID + 49;

flecs_ecs/src/core/component_registration/registration.rs

@@ -1,5 +1,6 @@
 #![doc(hidden)]
 use std::ffi::c_char;
+use std::os::raw::c_void;
 
 use crate::core::*;
 use crate::sys;
@@ -17,6 +18,7 @@ pub fn internal_register_component<
 where
     T: ComponentId,
 {
+    let world = world.world();
     let world_ptr = world.world_ptr_mut();
 
     let id = if IS_NAMED {
@@ -26,7 +28,9 @@ where
     };
 
     if T::IS_ENUM {
-        register_enum_data::<T>(world_ptr, id);
+        //TODO no full enum support yet with different types
+        let underlying_enum_type_id = world.component_id::<i32>();
+        register_enum_data::<T>(world_ptr, id, *underlying_enum_type_id);
     }
     id
 }
@@ -68,23 +72,28 @@ where
 }
 
 /// registers enum fields with the world.
-pub(crate) fn register_enum_data<T>(world: *mut sys::ecs_world_t, id: sys::ecs_entity_t)
-where
+pub(crate) fn register_enum_data<T>(
+    world: *mut sys::ecs_world_t,
+    id: sys::ecs_entity_t,
+    underlying_type_id: sys::ecs_entity_t,
+) where
     T: ComponentId,
 {
     //TODO we should convert this ecs_cpp functions to rust so if it ever changes, our solution won't break
-    unsafe { sys::ecs_cpp_enum_init(world, id) };
+    unsafe { sys::ecs_cpp_enum_init(world, id, underlying_type_id) };
     let enum_array_ptr = T::UnderlyingEnumType::__enum_data_mut();
 
-    for (index, enum_item) in T::UnderlyingEnumType::iter().enumerate() {
+    for (mut index, enum_item) in T::UnderlyingEnumType::iter().enumerate() {
         let name = enum_item.name_cstr();
         let entity_id: sys::ecs_entity_t = unsafe {
             sys::ecs_cpp_enum_constant_register(
                 world,
                 id,
                 T::UnderlyingEnumType::id_variant_of_index_unchecked(enum_item.enum_index()),
                 name.as_ptr(),
-                index as i32,
+                &mut index as *mut usize as *mut c_void,
+                underlying_type_id, //hardcoded
+                4,                  //hardcoded
             )
         };
         if !T::UnderlyingEnumType::is_index_registered_as_entity(index) {

flecs_ecs/src/core/flecs.rs

@@ -381,8 +381,6 @@ create_pre_registered_component!(
 );
 create_pre_registered_component!(OnTableCreate, ECS_ON_TABLE_CREATE);
 create_pre_registered_component!(OnTableDelete, ECS_ON_TABLE_DELETE);
-create_pre_registered_component!(OnTableEmpty, ECS_ON_TABLE_EMPTY);
-create_pre_registered_component!(OnTableFill, ECS_ON_TABLE_FILL);
 
 // System
 #[cfg(feature = "flecs_system")]
@@ -813,8 +811,6 @@ mod tests {
             assert_eq!(flecs::OnSet, sys::EcsOnSet);
             assert_eq!(flecs::OnTableCreate, sys::EcsOnTableCreate);
             assert_eq!(flecs::OnTableDelete, sys::EcsOnTableDelete);
-            assert_eq!(flecs::OnTableEmpty, sys::EcsOnTableEmpty);
-            assert_eq!(flecs::OnTableFill, sys::EcsOnTableFill);
 
             // System
             #[cfg(feature = "flecs_system")]

flecs_ecs/src/core/get_tuple.rs

@@ -183,6 +183,7 @@ where
     fn populate_array_ptrs<'a, const SHOULD_PANIC: bool>(
         world: impl WorldProvider<'a>, entity: Entity, record: *const ecs_record_t, components: &mut [*mut c_void]
     ) -> bool {
+        let world = world.world();
         let world_ptr = unsafe { sys::ecs_get_world(world.world_ptr() as *const c_void) as *mut sys::ecs_world_t };
         let table = unsafe { (*record).table };
         let entity = *entity;
@@ -208,18 +209,38 @@ where
                 if !A::IS_IMMUTABLE {
                     ecs_assert!(false, "Enums registered with `add_enum` should be `get` immutable, changing it won't actually change the value.");
                 }
-
-                // get constant value from constant entity
-                let constant_value = unsafe { sys::ecs_get_id(world_ptr, target, id) } as *mut c_void;
-
-                ecs_assert!(
-                    !constant_value.is_null(),
-                    FlecsErrorCode::InternalError, 
-                    "missing enum constant value {}",
-                    std::any::type_name::<A>()
-                );
-
-                unsafe { constant_value }
+
+                #[cfg(feature = "flecs_meta")]
+                {
+                    let id_underlying_type = world.component_id::<i32>();
+                    let pair_id = ecs_pair(flecs::meta::Constant::ID, *id_underlying_type);
+                    let constant_value = unsafe { sys::ecs_get_id(world_ptr, target, pair_id) } as *mut c_void;
+
+                    ecs_assert!(
+                        !constant_value.is_null(),
+                        FlecsErrorCode::InternalError,
+                        "missing enum constant value {}",
+                        std::any::type_name::<A>()
+                    );
+
+                    unsafe { constant_value }
+                }
+
+               // Fallback if we don't have the reflection addon
+               #[cfg(not(feature = "flecs_meta"))]
+               {
+                 // get constant value from constant entity
+                 let constant_value = unsafe { sys::ecs_get_id(world_ptr, target, id) } as *mut c_void;
+
+                 ecs_assert!(
+                     !constant_value.is_null(),
+                     FlecsErrorCode::InternalError,
+                     "missing enum constant value {}",
+                     std::any::type_name::<A>()
+                 );
+
+                 unsafe { constant_value }
+               }
             } else {
                 // if there is no matching pair for (r,*), try just r
                 unsafe { sys::ecs_rust_get_id(world_ptr, entity, record,table,id) }
@@ -348,17 +369,37 @@ macro_rules! impl_get_tuple {
                                 ecs_assert!(false, "Enums registered with `set_enum` should be `get` immutable, changing it won't actually change the value.");
                             }
 
-                            // get constant value from constant entity
-                            let constant_value = unsafe { sys::ecs_get_id(world_ptr, target, id) } as *mut c_void;
+                            #[cfg(feature = "flecs_meta")]
+                            {
+                                let id_underlying_type = world_ref.component_id::<i32>();
+                                let pair_id = ecs_pair(flecs::meta::Constant::ID, *id_underlying_type);
+                                let constant_value = unsafe { sys::ecs_get_id(world_ptr, target, pair_id) } as *mut c_void;
+
+                                ecs_assert!(
+                                    !constant_value.is_null(),
+                                    FlecsErrorCode::InternalError,
+                                    "missing enum constant value {}",
+                                    std::any::type_name::<$t>()
+                                );
 
-                            ecs_assert!(
-                                !constant_value.is_null(),
-                                FlecsErrorCode::InternalError,
-                                "missing enum constant value {}",
-                                std::any::type_name::<$t>()
-                            );
+                                unsafe { constant_value }
+                            }
 
-                            unsafe { constant_value }
+                           // Fallback if we don't have the reflection addon
+                           #[cfg(not(feature = "flecs_meta"))]
+                           {
+                             // get constant value from constant entity
+                             let constant_value = unsafe { sys::ecs_get_id(world_ptr, target, id) } as *mut c_void;
+
+                             ecs_assert!(
+                                 !constant_value.is_null(),
+                                 FlecsErrorCode::InternalError,
+                                 "missing enum constant value {}",
+                                 std::any::type_name::<$t>()
+                             );
+
+                             unsafe { constant_value }
+                           }
                         } else {
                             // if there is no matching pair for (r,*), try just r
                             unsafe { sys::ecs_rust_get_id(world_ptr, entity, record,table,id) }

flecs_ecs/src/core/world.rs

@@ -128,6 +128,7 @@ impl World {
             self.component_named::<crate::prelude::meta::EcsPrimitiveKind>(
                 "flecs::meta::primitive_kind",
             );
+
             //self.component_named::<crate::prelude::meta::EcsMember>("flecs::meta::member_t");
             //self.component_named::<crate::prelude::meta::EcsEnumConstant>(
             //    "flecs::meta::enum_constant",
@@ -4668,23 +4669,7 @@ impl World {
     /// * C API: `ecs_delete_empty_tables`
     #[doc(alias = "ecs_delete_empty_tables")]
     #[inline(always)] //min_id_count: i32, time_budget_seconds: f64) -> i32
-    pub fn delete_empty_tables(
-        &self,
-        id: impl Into<Id>,
-        clear_generation: u16,
-        delete_generation: u16,
-        min_id_count: i32,
-        time_budget_seconds: f64,
-    ) -> i32 {
-        unsafe {
-            sys::ecs_delete_empty_tables(
-                self.raw_world.as_ptr(),
-                *id.into(),
-                clear_generation,
-                delete_generation,
-                min_id_count,
-                time_budget_seconds,
-            )
-        }
+    pub fn delete_empty_tables(&self, desc: sys::ecs_delete_empty_tables_desc_t) -> i32 {
+        unsafe { sys::ecs_delete_empty_tables(self.raw_world.as_ptr(), &desc) }
     }
 }

flecs_ecs/tests/flecs/common_test.rs

@@ -1,5 +1,6 @@
 #![allow(dead_code)]
 #![allow(unused_imports)]
+#![allow(unexpected_cfgs)]
 
 use std::{
     collections::HashMap,

flecs_ecs/tests/flecs/flecs_docs_test.rs

@@ -416,7 +416,13 @@ fn flecs_query_docs_compile_test() {
         .build();
 
     // Delete empty archetypes that have been empty for 10 calls to this function.
-    world.delete_empty_tables(0, 0, 10, 0, 0.0);
+    world.delete_empty_tables(sys::ecs_delete_empty_tables_desc_t {
+        id: 0,
+        clear_generation: 10,
+        delete_generation: 0,
+        min_id_count: 0,
+        time_budget_seconds: 0.0,
+    });
 
     let q = world.new_query::<(&mut Position, &Velocity)>();
 

flecs_ecs/tests/flecs/meta_trait_test.rs

@@ -105,6 +105,8 @@ fn test_enum() {
         .add_enum(Color::Green)
         .set(TypeWithEnum { color: Color::Blue });
 
+    dbg!(e);
+
     // Convert TypeWithEnum component to flecs expression string
     e.get::<(&Color, &TypeWithEnum)>(|(color, type_enum)| {
         let expr: String = world.to_expr(color);