Finish generic implementations for insert,pop,clear etc..

Author: makspll

assets/scripts/bevy_api.lua

@@ -38,6 +38,14 @@ function on_event()
     print(table_to_string(comp.vec_of_usize))
     comp.vec_of_usize = comp.vec_of_usize
     print(table_to_string(comp.vec_of_usize))
+    comp.vec_of_usize:insert(1, 42)
+    print(table_to_string(comp.vec_of_usize))
+
+    print("\nmap")
+    -- print(comp.map_of_strings["key"])
+    comp.map_of_strings:insert("key2", "value")
+    -- print(comp.map_of_strings["key2"])
+
 
 
     print("============")
@@ -75,42 +83,31 @@ function on_event()
     comp.vec_of_option_bools:insert(1,nil)
     print("comp.vec_of_option_bools after insert: ", table_to_string(comp.vec_of_option_bools))
 
+
+
     print("comp.vec_of_option_bools before push: ", table_to_string(comp.vec_of_option_bools))
     comp.vec_of_option_bools:push(false)
     print("comp.vec_of_option_bools after push: ", table_to_string(comp.vec_of_option_bools))
 
     print("comp.vec_of_option_bools len after push: ", #comp.vec_of_option_bools)
 
     print("comp.vec_of_option_bools before pop: ", table_to_string(comp.vec_of_option_bools))
-    print(comp.vec_of_option_bools:pop())
+    print(comp.vec_of_option_bools:pop():print_value())
     print("comp.vec_of_option_bools after pop: ", table_to_string(comp.vec_of_option_bools))
 
     print("the pairs inside comp.vec_of_option_bools: ")             
     for k,v in pairs(comp.vec_of_option_bools) do
         print(string.format(" - %s:%s",k,v))
     end
 
+
     comp.vec_of_option_bools:clear()
     print("comp.vec_of_option_bools after clear: ", table_to_string(comp.vec_of_option_bools))
-
     print("comp.vec_of_option_bools len after clear: ", #comp.vec_of_option_bools)
-    print("============")
-
-    print("comp.option_vec_of_bools before: ", table_to_string(comp.option_vec_of_bools))
-    print(comp.option_vec_of_bools:pop())
-    print("comp.option_vec_of_bools after pop: ", table_to_string(comp.option_vec_of_bools))
-
-
-    print("comp.option_vec_of_bools len after pop: ", #comp.option_vec_of_bools)
-
-    print("the pairs inside comp.option_vec_of_bools: ")
-    for k,v in pairs(comp.option_vec_of_bools) do
-        print(string.format(" - %s:%s",k,v))
-    end
 
     print("============")
 
-    local complex_vec_op = Vec3.new(0,1,0):any_orthonormal_vector() + comp.mat3.x_axis 
+    local complex_vec_op = Vec3.new(0,1,0):any_orthonormal_vector() + comp.mat3[1] 
     print("(0,1,0).any_orthonormal_vector() + mat3.x_axis is: ", complex_vec_op) 
 
     local new_mat3 = Mat3.from_cols(Vec3.new(1,0,0),Vec3.new(0,1,0),Vec3.new(0,0,-1))
@@ -121,8 +118,11 @@ function on_event()
     comp.f32 = comp.f32 + comp.f32 + comp.vec2:min_element()
     comp.vec2 = Vec2.new(2,1)
     comp.quat = Quat.from_xyzw(3,2,1,4)
-    comp.mat3.x_axis = Vec3.new(69,69,69)
+    comp.mat3[1] = Vec3.new(69,69,69)
 
+
+    world:exit()
+    do return end
     print("============")
 
     -- this is an example of something impossible to achieve with plain bevy reflection under the hood

crates/bevy_mod_scripting_core/src/bindings/allocator.rs

@@ -14,18 +14,54 @@ impl ReflectAllocationId {
     }
 }
 
+/// Pointer which owns the value it points to, and will deallocate it when dropped
+#[derive(Debug)]
+pub struct OwningPtr<T: ?Sized> {
+    ptr: *mut T,
+}
+
+impl<T: ?Sized> OwningPtr<T> {
+    /// Creates a new OwningPtr from a raw pointer
+    /// # Safety
+    /// The pointer must come from a Box::leak call, and no more than one OwningPtr can exist for a given pointer
+    pub unsafe fn new(ptr: *mut T) -> Self {
+        Self { ptr }
+    }
+}
+
+impl<T: ?Sized> Drop for OwningPtr<T> {
+    fn drop(&mut self) {
+        unsafe {
+            // Safety: we own the pointer, only one OwningPtr can exist for a given pointer
+            let _ = Box::from_raw(self.ptr);
+        }
+    }
+}
+
+// yikes, the indirection. I need this to store boxed values too though
 #[derive(Clone, Debug)]
-pub struct ReflectAllocation(pub(self) Arc<UnsafeCell<dyn PartialReflect>>);
+pub enum ReflectAllocation {
+    Double(Arc<OwningPtr<dyn PartialReflect>>),
+    Single(Arc<UnsafeCell<dyn PartialReflect>>),
+}
 
 unsafe impl Send for ReflectAllocation {}
 unsafe impl Sync for ReflectAllocation {}
 
 impl ReflectAllocation {
     pub fn get_ptr(&self) -> *mut dyn PartialReflect {
-        self.0.get()
+        match self {
+            ReflectAllocation::Double(v) => v.ptr,
+            ReflectAllocation::Single(v) => v.get(),
+        }
     }
     pub fn new(value: Arc<UnsafeCell<dyn PartialReflect>>) -> Self {
-        Self(value)
+        Self::Single(value)
+    }
+
+    pub fn new_boxed(value: Box<dyn PartialReflect>) -> Self {
+        let ptr = Box::leak::<'static>(value);
+        Self::Double(Arc::new(unsafe { OwningPtr::new(ptr) }))
     }
 }
 
@@ -62,6 +98,21 @@ impl ReflectAllocator {
         (id, value)
     }
 
+    pub fn allocate_boxed(
+        &mut self,
+        value: Box<dyn PartialReflect>,
+    ) -> (ReflectAllocationId, ReflectAllocation) {
+        let type_id = value.get_represented_type_info().map(|i| i.type_id());
+
+        let id = ReflectAllocationId(self.allocations.len());
+        let value = ReflectAllocation::new_boxed(value);
+        self.allocations.insert(id, value.clone());
+        if let Some(type_id) = type_id {
+            self.types.insert(id, type_id);
+        }
+        (id, value)
+    }
+
     // /// Moves the given boxed [`PartialReflect`] value into the allocator, returning an [`AllocationId`] which can be used to access it later
     // pub fn allocate_boxed(
     //     &mut self,
@@ -105,7 +156,10 @@ impl ReflectAllocator {
     /// Runs a garbage collection pass on the allocations, removing any allocations which have no more strong references
     /// Needs to be run periodically to prevent memory leaks
     pub fn clean_garbage_allocations(&mut self) {
-        self.allocations.retain(|_, v| Arc::strong_count(&v.0) > 1);
+        self.allocations.retain(|_, v| match v {
+            ReflectAllocation::Single(v) => Arc::strong_count(v) > 1,
+            ReflectAllocation::Double(v) => Arc::strong_count(v) > 1,
+        });
     }
 }