migrate work on core improvements from feature/better-trait-system to bevy 0.15

Author: makspll

crates/bevy_mod_scripting_core/Cargo.toml

@@ -21,19 +21,9 @@ doc_always = []
 
 
 [dependencies]
-bevy = { workspace = true, default-features = false, features = [
-    "bevy_asset",
-    "bevy_gltf",
-    "bevy_animation",
-    "bevy_core_pipeline",
-    "bevy_ui",
-    "bevy_pbr",
-    "bevy_render",
-    "bevy_text",
-    "bevy_sprite",
-] }
-bevy_event_priority = { path = "../bevy_event_priority", version = "0.8.0-alpha.1" }
+bevy = { workspace = true, default-features = false, features = ["bevy_asset"] }
 thiserror = "1.0.31"
 paste = "1.0.7"
 parking_lot = "0.12.1"
-anyhow = "1.0.75"
+lockable = "0.0.8"
+smallvec = "1.11"

crates/bevy_mod_scripting_core/src/asset.rs

@@ -1,8 +1,85 @@
-use bevy::asset::Asset;
+use std::{
+    borrow::Cow,
+    path::{Path, PathBuf},
+};
 
-/// All code assets share this common interface.
-/// When adding a new code asset don't forget to implement asset loading
-/// and inserting appropriate systems when registering with the app
-pub trait CodeAsset: Asset {
-    fn bytes(&self) -> &[u8];
+use bevy::{
+    asset::{Asset, AssetLoader, AsyncReadExt},
+    ecs::system::Resource,
+    reflect::TypePath,
+    utils::BoxedFuture,
+};
+
+use crate::{prelude::ScriptError, script::ScriptId};
+
+/// Represents a script loaded into memory as an asset
+#[derive(Asset, TypePath)]
+pub struct ScriptAsset {
+    pub content: Box<[u8]>,
+    /// The virtual filesystem path of the asset, used to map to the script Id for asset backed scripts
+    pub asset_path: PathBuf,
+    pub language: Cow<'static, str>,
+}
+
+pub struct ScriptAssetLoader {
+    /// Used to set the language of the script
+    pub language: Cow<'static, str>,
+    /// The file extensions this loader should handle
+    pub extensions: &'static [&'static str],
+    /// preprocessor to run on the script before saving the content to an asset
+    pub preprocessor: Option<Box<dyn Fn(&mut [u8]) -> Result<(), ScriptError> + Send + Sync>>,
+}
+
+impl AssetLoader for ScriptAssetLoader {
+    type Asset = ScriptAsset;
+
+    type Settings = ();
+
+    type Error = ScriptError;
+
+    async fn load(
+        &self,
+        reader: &mut dyn bevy::asset::io::Reader,
+        _settings: &Self::Settings,
+        load_context: &mut bevy::asset::LoadContext<'_>,
+    ) -> Result<Self::Asset, Self::Error> {
+        let mut content = Vec::new();
+        reader.read_to_end(&mut content).await.map_err(|e| {
+            ScriptError::new_lifecycle_error(e).with_context(load_context.asset_path())
+        })?;
+        if let Some(processor) = &self.preprocessor {
+            processor(&mut content)?;
+        }
+        let asset = ScriptAsset {
+            content: content.into_boxed_slice(),
+            asset_path: load_context.path().to_owned(),
+            language: self.language.clone(),
+        };
+        Ok(asset)
+    }
+
+    fn extensions(&self) -> &[&str] {
+        self.extensions
+    }
+}
+
+#[derive(Clone, Copy, Resource)]
+pub struct ScriptAssetSettings {
+    pub script_id_mapper: AssetPathToScriptIdMapper,
+}
+
+impl Default for ScriptAssetSettings {
+    fn default() -> Self {
+        Self {
+            script_id_mapper: AssetPathToScriptIdMapper {
+                map: (|path: &Path| path.to_string_lossy().into_owned().into()),
+            },
+        }
+    }
+}
+
+/// Strategy for mapping asset paths to script ids, by default this is the identity function
+#[derive(Clone, Copy)]
+pub struct AssetPathToScriptIdMapper {
+    pub map: fn(&Path) -> ScriptId,
 }

crates/bevy_mod_scripting_core/src/bindings/allocator.rs

@@ -0,0 +1,97 @@
+use bevy::ecs::system::Resource;
+use bevy::reflect::{PartialReflect, Reflect};
+use std::any::TypeId;
+use std::cell::UnsafeCell;
+use std::collections::HashMap;
+use std::fmt::{Display, Formatter};
+use std::sync::Arc;
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
+pub struct ReflectAllocationId(pub(crate) usize);
+impl ReflectAllocationId {
+    pub fn id(&self) -> usize {
+        self.0
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ReflectAllocation(pub(self) 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()
+    }
+    pub fn new(value: Arc<UnsafeCell<dyn PartialReflect>>) -> Self {
+        Self(value)
+    }
+}
+
+impl Display for ReflectAllocationId {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+/// Allocator used to allocate and deallocate `dyn PartialReflect` values
+/// Used to be able to ensure we have a "common root" for values allocated outside the world.
+#[derive(Resource, Default)]
+pub struct ReflectAllocator {
+    // TODO: experiment with object pools, sparse set etc.
+    allocations: HashMap<ReflectAllocationId, ReflectAllocation>,
+    types: HashMap<ReflectAllocationId, TypeId>,
+}
+
+impl ReflectAllocator {
+    /// Allocates a new [`Reflect`] value and returns an [`AllocationId`] which can be used to access it later
+    pub fn allocate<T: PartialReflect>(
+        &mut self,
+        value: T,
+    ) -> (ReflectAllocationId, ReflectAllocation) {
+        let id = ReflectAllocationId(self.allocations.len());
+        let value = ReflectAllocation::new(Arc::new(UnsafeCell::new(value)));
+        self.allocations.insert(id, value.clone());
+        self.types.insert(id, TypeId::of::<T>());
+        (id, value)
+    }
+
+    pub fn get(&self, id: ReflectAllocationId) -> Option<ReflectAllocation> {
+        self.allocations.get(&id).cloned()
+    }
+
+    pub fn get_type_id(&self, id: ReflectAllocationId) -> Option<TypeId> {
+        self.types.get(&id).cloned()
+    }
+
+    pub fn get_mut(&self, id: ReflectAllocationId) -> Option<ReflectAllocation> {
+        self.allocations.get(&id).cloned()
+    }
+
+    /// Deallocates the [`PartialReflect`] value with the given [`AllocationId`]
+    pub fn deallocate(&mut self, id: ReflectAllocationId) {
+        self.allocations.remove(&id);
+    }
+
+    /// 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);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_reflect_allocator() {
+        let mut allocator = ReflectAllocator::default();
+        let (id, val) = allocator.allocate(0);
+        assert_eq!(allocator.allocations.len(), 1);
+        drop(val);
+        allocator.clean_garbage_allocations();
+        assert_eq!(allocator.allocations.len(), 0);
+    }
+}

crates/bevy_mod_scripting_core/src/bindings/mod.rs

@@ -0,0 +1,7 @@
+pub mod allocator;
+pub mod proxy;
+pub mod query;
+pub mod reference;
+pub mod world;
+
+pub use {allocator::*, proxy::*, query::*, reference::*, world::*};