Built up instances and default assets.

src/duck/instance.rs

@@ -1,16 +1,29 @@
+use std::marker::PhantomData;
 use bevy::prelude::*;
 use mlua::prelude::*;
 
 use crate::duck::part::*;
 use crate::duck::script::*;
 
-pub trait Class {
+#[derive(Component,Resource)]
-    fn new(entity: EntityWorldMut) -> AnyInstance;
+pub struct DefaultAsset<S: Asset>(Handle<S>);
-    fn add_fields<T, F: LuaUserDataFields<T>>(_fields: &mut F) {}
+impl<S: Asset> DefaultAsset<S> {
-    fn add_methods<T, F: LuaUserDataMethods<T>>(_methods: &mut F) {}
+    pub fn clone(world: &World) -> Handle<S> {
+        world.get_resource::<DefaultAsset<S>>().unwrap().0.clone()
+    }
+    pub fn new(commands: &mut Commands, handle: Handle<S>) {
+        commands.insert_resource(DefaultAsset(handle));
+    }
 }
 
-pub struct Instance<S: Class>(pub S);
+pub trait Class {
+    fn new(entity: &mut EntityWorldMut) -> AnyInstance;
+    fn add_fields<T, F: LuaUserDataFields<T>>(_fields: &mut F) {}
+    fn add_methods<T, F: LuaUserDataMethods<T>>(_methods: &mut F) {}
+    fn class_name() -> &'static str {"Instance"}
+}
+
+pub struct Instance<S: Class>(Entity,PhantomData<S>);
 
 impl<S: Class> LuaUserData for Instance<S> {
     fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
@@ -25,8 +38,13 @@ impl<S: Class> Instance<S> {
     fn new_entity(world: &mut World) -> Entity {
         let mut entity = world.spawn_empty();
         entity.entry().or_insert(Name::new("Instance"));
-        entity.insert(AnyInstance {sub: S::new(entity)});
+        let instance = S::new(&mut entity);
-        return entity.id();
+        entity.entry().or_insert(instance);
+        entity.id()
+    }
+
+    pub(crate) fn new(entity: &mut EntityWorldMut) -> Instance<S> {
+        Instance(entity.id(),PhantomData)
     }
 }
 
@@ -35,14 +53,6 @@ pub enum AnyInstance {
     Script(Instance<Script>),
     Part(Instance<Located<Part>>)
 }
-impl AnyInstance {
-    fn new(instance: Instance<Script>) -> AnyInstance {
-        AnyInstance::Script(instance)
-    }
-    fn new(instance: Instance<Located<Part>>) -> AnyInstance {
-        AnyInstance::Part(instance)
-    }
-}
 
 pub fn setup(app: &mut App) {
 

src/duck/part.rs

@@ -1,13 +1,9 @@
 use bevy::prelude::*;
 use crate::duck::instance::*;
 
-struct DefaultMaterial {
+pub struct Located<S: Class>(S);
-
-}
-
-pub struct Located<S: Class>(pub S)
 impl<S: Class> Class for Located<S> {
-    fn new(mut entity: EntityWorldMut) -> AnyInstance {
+    fn new(entity: &mut EntityWorldMut) -> AnyInstance {
         entity.insert(Transform::IDENTITY);
         S::new(entity)
     }
@@ -15,17 +11,27 @@ impl<S: Class> Class for Located<S> {
 
 pub struct Part();
 impl Class for Part {
-    fn new(mut entity: EntityWorldMut) -> AnyInstance {
+    fn new(entity: &mut EntityWorldMut) -> AnyInstance {
-        let mut meshes = entity.world_mut().get_resource_mut::<Assets<Mesh>>().unwrap();
+        let world = entity.world();
-        let mut materials = entity.world_mut().get_resource_mut::<Assets<StandardMaterial>>().unwrap();
+        let mesh = DefaultAsset::<Mesh>::clone(world);
+        let material = DefaultAsset::<StandardMaterial>::clone(world);
         entity.insert((
-            Mesh3d(meshes.add(Cuboid::new(2.0, 1.0, 4.0))),
+            Mesh3d(mesh),
-            MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255)))
+            MeshMaterial3d(material),
         ));
-        AnyInstance::Part(Instance(Located(Part())))
+        AnyInstance::Part(Instance::new(entity))
     }
 }
 
+pub fn startup(
+    mut commands: Commands,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut mesh: ResMut<Assets<Mesh>>,
+) {
+    DefaultAsset::new(&mut commands,mesh.add(Cuboid::new(2.,1.,4.)));
+    DefaultAsset::new(&mut commands,materials.add(StandardMaterial::from(Color::NONE)));
+}
+
 pub fn setup(app: &mut App) {
-    
+    app.add_systems(Startup,startup);
 }

src/duck/script.rs

@@ -1,3 +1,4 @@
+use std::ops::Deref;
 use bevy::asset::AsyncReadExt;
 use bevy::prelude::*;
 use bevy::asset::{io::Reader, AssetLoader, LoadContext};
@@ -5,7 +6,7 @@ use thiserror::Error;
 use crate::duck::instance::*;
 
 #[derive(Asset, TypePath, Debug)]
-struct ScriptAsset {
+pub struct ScriptAsset {
     source: String
 }
 
@@ -32,34 +33,31 @@ impl AssetLoader for ScriptAssetLoader {
         info!("Loading Script...");
         let mut raw = String::new();
         reader.read_to_string(&mut raw).await?;
-        Ok(ScriptAsset { source: Source { raw } })
+        Ok(ScriptAsset { source: raw })
     }
 }
 
-pub struct Script();
+#[derive(Component)]
+pub struct Script(Handle<ScriptAsset>);
 impl Class for Script {
-    fn new(mut entity: EntityWorldMut) -> AnyInstance {
+    fn new(entity: &mut EntityWorldMut) -> AnyInstance {
-        entity.entry().or_insert(
+        let handle = DefaultAsset::<ScriptAsset>::clone(entity.world());
-        );
+        entity.entry().or_insert(Script(handle));
-        AnyInstance::Script(Instance(Script()))
+        AnyInstance::Script(Instance::new(entity))
     }
 }
 
-#[derive(Resource, Component)]
-struct DefaultScriptAsset(ScriptAsset);
-
 pub fn startup(
+    mut commands: Commands,
     mut script_assets: ResMut<Assets<ScriptAsset>>,
-    mut commands: Commands
 ) {
-    commands.insert_resource::<DefaultScriptAsset>(
+    DefaultAsset::new(&mut commands,script_assets.add(ScriptAsset {
-        DefaultScriptAsset(script_assets.add(
+        source: "print(\"Hello world!\")".into()
-            ScriptAsset { source: "print(\"Hello world!\")".to_string() }
+    }));
-        ))
-    )
 }
 
 pub fn setup(app: &mut App) {
     app.init_asset::<ScriptAsset>();
     app.init_asset_loader::<ScriptAssetLoader>();
+    app.add_systems(Startup,startup);
 }