More idiomatic way for this? Using raw pointer in a Resource to read data from a reference coming from another library.

[GGalizzi]

Struggling for a good title and concise explanation of this but here goes:

I'm only using the bevy_ecs crate, and using bracket_lib (aka Rltk) for rendering.

There's a function tick that runs every frame, this is where I call the scheduler to run the systems, and then to render the function receives a reference to a context type called Rltk which has methods to put stuff on the screen.

I want to pass that &mut Rltk that I receive to systems which handle the rendering, here's how I'm doing it:

impl CtxRef {
    pub fn new() -> Self {
        CtxRef {
            ctx: std::ptr::null_mut(),
        }
    }

    pub fn set(&mut self, r: *mut Rltk) {
        self.ctx = r;
    }

    pub fn get(&mut self) -> *mut Rltk {
        self.ctx
    }
}

the_world_setup_function() {
    let mut render_stage = SystemStage::single_threaded();
    render_stage.add_system(draw_map.exclusive_system().label("map_render"));
    render_stage.add_system(draw_renderables.exclusive_system().after("map_render"));

    schedule.add_stage_after(RunStage::Main, RunStage::Render, render_stage);

    world.insert_resource(map);

    world.insert_non_send(CtxRef::new());
}

impl GameState for State {
    fn tick(&mut self, ctx: &mut Rltk) {
        ctx.cls(); // clear screen
        player_input(self, ctx); // receive input data

        let mut ctxref = self.ecs.get_non_send_resource_mut::<CtxRef>().unwrap();
        ctxref.set(ctx); // todo: only needs to be set once.

        self.schedule.run(&mut self.ecs);
    }
}

snippet_of_a_render_sys(
    mut ctx_ref: NonSendMut<CtxRef>,
    positions: Query<(&Position, &Renderable)>,
    viewshed: Query<&Viewshed, With<Player>>,
) {
    let player_viewshed = viewshed.single().unwrap();
    for (position, render) in positions.iter() {
            // ... stuff omitted
            let ctx = ctx_ref.get();
            unsafe {
                (*ctx).set(position.x, position.y, render.fg, render.bg, render.glyph);
            }
    }
}

Using & refences was giving me trouble with lifetime constraints (not 'static) and I'm fairly sure that this use of pointers is safe? Because the system will have exclusive access at this point and the reference will be available all the time. But it feels very dirty to me right now because using unsafe terrifies me.

Hoping for some guidance to improve the code if possible.

Much appreciated!

[DJMcNab]

We've had someone asking for this before (although it was called Context in that case).
Basically, your solution is safe, but we definitely could add a wrapper for it - interestingly we could make this non-bevy_ecs exclusive using some privacy cleverness - i.e. it could be a third party crate.

By the way, an alternative is to use a commands like system. Something like:

struct RltkCommands(Vec<Box<dyn FnMut(&mut Rltk + Send + Sync + 'static)>>);
//.. in snippet_of_a_render_sys - assuming you have made the trivial commands
my_res_rltk_commands.push(move |ctx| ctx.set(position.x, position.y, render.fg, render.bg, render.glyph));
// in GameState:
    let mut commands = self.ecs.get_resource_mut::<RltkCommands>().unwrap();
for command in commands{
(*command)(ctx)
}

Obviously you might need to do some surplus clones to make your commands non-'static.

[GGalizzi]

Thanks for the reply, very interesting pattern, I'm going to try it out and see which one feels better.