Why do I get a "borrowed data escapes outside of method" error?

I have a variable renderer that I have to edit over an event loop. The issue is that I keep getting the same borrowed data escapes outside of method error for the event loop in the run function of my App struct. How do I fix this with still being able to adjust the values of renderer over runtime? All the solutions I've seen resulted in some form of copy being passed, which is not what I need. Thanks for the help!

Full error:

error[E0521]: borrowed data escapes outside of method
  --> src/app.rs:54:9
   |
50 |       pub fn run(mut self, renderer: &mut Renderer) -> Result<(), pixels::Error> {
   |                            --------  - let's call the lifetime of this reference `'1`
   |                            |
   |                            `renderer` is a reference that is only valid in the method body
...
54 | /         self.event_loop.run(move |event, _, control_flow| {
55 | |             if let Event::RedrawRequested(_) = event {
56 | |
57 | |                 let current_frame_time = Instant::now();
...  |
84 | |             }
85 | |         });
   | |          ^
   | |          |
   | |__________`renderer` escapes the method body here
   |            argument requires that `'1` must outlive `'static`

For the full, long code, here is my GitHub repo: https://github.com/KGL8/RayTracingPaper/tree/working_snapshot

Shortened version of my App.rs:

pub struct App {
    // ***
}

impl App {
    pub fn new() -> Result<Self, pixels::Error> {
        // ***
    }

    pub fn create_window(event_loop: &EventLoop<()>) -> Window {
        // ***
    }

    pub fn run(mut self, renderer: &mut Renderer) -> Result<(), pixels::Error> {

        let mut previous_frame_time = Instant::now();

        self.event_loop.run(move |event, _, control_flow| {
            if let Event::RedrawRequested(_) = event {

                let current_frame_time = Instant::now();
                let timestep = current_frame_time.duration_since(previous_frame_time).as_secs_f32();
                previous_frame_time = current_frame_time;
                renderer.on_update(timestep, &self.input);

                if let Err(err) = renderer.render(&mut self.pixels) {
                    log_error("renderer.draw_frame", err);
                    *control_flow = ControlFlow::Exit;
                    return;
                }
            }

            // ***

                self.window.request_redraw();
            }
        });
    }
}

You are passing renderer, which is a mutable reference, into event_loop.run, which is closure with a 'static lifetime.

Let's look at the source for EventLoop::run

    pub fn run<F>(self, event_handler: F) -> !
    where
        F: 'static + FnMut(Event<'_, T>, [ ... ] ),

The 'static + FnMut part means "this argument is a closure with a static lifetime". To break it down a bit:

• a closure is a lot like function, but it's "bundled together" with all other variables needed to call the function
• 'static is a special lifetime bound, it tells rust our closure will not borrow any data with non-'static lifetime

Since the event loop wants to call the event_handler indefinitely, event_handler has to continue to exist as long as the program is running.
You correctly used a move closure, which causes all the variables referred to in your closure to be captured and moved into the closure (that's the "bundling" above). renderer is problematic, because it's a reference, so we can't move it into the closure.

We have a closure that has to live until the program ends, yet includes a reference that will die as soon as the program ends! This is what the compiler means by borrowed data escapes outside of method.

To solve this, we need to promise the compiler that renderer will stick around until the program exits. Easiest way is to make it 'static,
In App::run()

pub fn run(mut self, renderer: &'static mut Renderer)

then, when you instantiate Renderer, use lazy_static:

lazy_static! {
    static ref RENDERER: Renderer = Renderer::new();
}