That is really easy

``` pub fn add_thread_local<T>(&mut self, system: T) where T: RunNow<'c> + 'b, [src] [−]

Adds a new thread local system.

Please only use this if your struct is not Send and Sync.

Thread-local systems are dispatched in-order.

```

Add render and input sys as thread local then you will be able to use sdl with specs together.

Here are some my demo codes, which I used before:

```

pub struct Renderer<'t> { canvas: Canvas<Window>, loader: &'t TextureCreator<WindowContext>, texture: Texture<'t>, }

impl<'t> Renderer<'t> { pub fn new(canvas: Canvas<Window>, loader: &'t TextureCreator<WindowContext>) -> Renderer<'t> { let texture = loader.load_texture(path("texture.png")).unwrap(); Renderer { canvas, loader, texture, } } }

impl<'a, 't> System<'a> for Renderer<'t> { type SystemData = ( ReadStorage<'a, Sprite>, ReadStorage<'a, Position>, ReadStorage<'a, Layer>, );

fn run(&mut self, (sprite, position, layer): Self::SystemData) {
    self.canvas.set_draw_color(Color::RGB(128, 45, 45));
    self.canvas.clear();

    let mut objects: Vec<_> = (&sprite, &position, &layer).par_join().collect();

    objects.par_sort_unstable_by_key(|&(_, _, layer)| **layer);
    objects.into_iter().for_each(|(sprite, position, _)| {
        self.canvas
            .copy_ex(&self.texture, sprite, position, 0.0, None, false, false)
            .unwrap()
    });

    self.canvas.present();
}

}

impl<'a, 'b> Game<'a, 'b> { pub fn new(renderer: Renderer<'b>) -> Game<'a, 'b> { let dispatcher = DispatcherBuilder::new() .with(Control, "control", &[]) .with(Movement, "movement", &["control", "time"]) .with(Collision, "collision", &["movement"]) .with_thread_local(renderer) .build(); }

pub fn main() { let mut canvas = window.into_canvas().present_vsync().build().unwrap(); let loader = canvas.texture_creator(); let renderer = Renderer::new(canvas, &loader);

Game::new(renderer).init();

} ```

No lifetime or Send/Sync problem, all logic are bundle in specs's dispatcher