How can i get the reference to App or World

[haike0513]

What problem does this solve or what need does it fill?

I wan't to insert wasmer runtime resource into bevy, so i can run wasm as script in bevy.

But, when I get the ref to World on FromWorld trait or ref App on Plguin trait, It seems that the ref is to another instance.

for example

#[derive(Clone)]
pub struct SeekerEnv<'a> {
  pub world: Arc<Mutex<&'a mut World>>,
}

unsafe impl Sync for SeekerEnv<'_> {}
unsafe impl Send for SeekerEnv<'_> {}

pub struct SeekerEnvInstance {
  pub instance: Instance,
}


impl FromWorld for  SeekerEnv<'static> {
  fn from_world(world: &mut World) -> Self {

    let seeker_env;

    unsafe {
      let ref_world = &mut *(world as *mut World);
      seeker_env = SeekerEnv {
        world: Arc::new(Mutex::new(ref_world))
      }
    }

    let script_path = concat!(
      env!("CARGO_MANIFEST_DIR"),
      "/crates/wrst/target/wasm32-wasi/release/welcome.wasm"
    );

    info!("{}", script_path);
    let store = Store::default();
    let module = match Module::from_file(&store, script_path) {
        Ok(m) => m,
        Err(err) => {
          dbg!(err);
          panic!();
          // return ;
        },
    };

    let mut wasi_env = WasiState::new("seeker").finalize().unwrap();
    let mut import_object = wasi_env.import_object(&module).unwrap();

    let store = Store::default();

    
    let mut _seeker_env = Arc::new(Mutex::new(seeker_env.clone()));

    let mut seeker_ns: Exports = namespace! {
      "create_window" => Function::new_native_with_env(&store, _seeker_env.clone(), create_window),
      "add_sprite" => Function::new_native_with_env(&store, _seeker_env.clone(), add_sprite),
      "query_entity_ids" => Function::new_native_with_env(&store, _seeker_env.clone(), query_entity_ids),
      "create_entity_id" => Function::new_native_with_env(&store, _seeker_env.clone(), create_entity_id),
    };

    import_object.register_namespace("seeker", seeker_ns);


    let instance = Instance::new(&module, &import_object).unwrap();

    world.insert_resource(SeekerEnvInstance {
      instance
    });
    seeker_env

  }
}

But when I get the ref to World in system, The world id is 3, and I can not spawn entity in my app by this world ref.

So I need to add a exclusive_system to fixed it

fn setup_world(
  world: &mut World
) {

  unsafe {
    let ref_world = &mut *(world as *mut World);

    let mut env = world.get_resource_mut::<SeekerEnv>().unwrap();
    *(env.world.lock().unwrap()) = ref_world;
  }
}

After this exclusive_system, the world id is 0. and i can sapwn an entity by this world. Is there some better solution.

And I did not known how to get the ref to App in my resource.
I try to get the ref in Plugin trait, But it not work, I get the world by this ref to App, the world is 3, not 0, I did not know how to resolve it, Is there some solution can I resolve it.

[alice-i-cecile]

Hi! We use Github Discussions for questions here; I'm going to convert this to a discussion and hopefully someone can help you over there :)

[jakobhellermann]

You can't keep a &mut World alive in your environment for longer than the duration of one exclusive system, because rust rules require you to never, ever have two aliasing (=alive at the same time) mutable references to the same variable.

What you can do is fill the SeekerEnv with an empty dummy World::new() when creating it.
When you want to actually run the wasm script with access to the world, you can do something like this:

fn run_scripts_system(world: &mut World) {
  let seeker_env = ...;
  
  std::mem::swap(world, &mut seeker_env.world);
  // run scripts
  std::mem::swap(&mut seeker_env.world, world);
}

(it can't be exactly this because of the arc and mutex, but the point is to have the environment own the world for just the duration of execution)

I do something similar here in my experimentation with JS-Scripting via V8 and deno_core: https://github.com/jakobhellermann/bevy_mod_js_scripting/blob/307b3c471f63043390d1ba6a3f86f8da5fdc3b65/src/runtime/mod.rs#L38, although I keep the world in a RefCell since javascript is single-threaded anyways.

In a different experiment with lua I did use an Arc, but to get from an Arc to a &mut World you need to ensure that there is only one reference left alive after running the script. With mlua I used lua.gc_collect() which worked out there, but I don't know if that is an option for you. Alternatively maybe arc-swap could be an option for getting the world back.

pub fn with_world(
    world: &mut World,
    ...
) -> Result<(), mlua::Error> {
    let w = std::mem::take(world);
    let shared_world = Arc::new(RwLock::new(w));

    // insert shared world into lua and run script

    lua.gc_collect()?;

    *world = Arc::try_unwrap(shared_world)
        .expect("there are dangling references to the world left!")
        .into_inner()
        .expect("the world lock was poisoned");

    res
}

Also, I suggest to use unsafe only in situations where you have no other option and really know why exactly what you're doing is unsafe and what the safety requirements of whatever it is you're doing actually are. It helps to write a // SAFETY: this is safe because a, b, c comment, because it forces you to read the relevant documentation and explain to yourself and the code readers why what you're doing is justified.
https://doc.rust-lang.org/nomicon/what-unsafe-does.html has a list of what unsafe allows you to do and most importantly, the list of invariants that you as a programmer need to uphold even in unsafe code, which includes never breaking pointer aliasing rules.

[haike0513]

Thanks for your suggesion, I will try it