Проблемы с Winit и пикселями в Rust

У меня возникли проблемы с моим проектом Rust, в котором используются Winit 0.30.5 и Pixels 0.13.

Проблема в том, что я не могу заставить рендерер писать в окно. Программа компилируется и запускается без каких-либо ошибок, так что это либо моя собственная ошибка, либо происходит какое-то странное взаимодействие с библиотекой.

Я ценю помощь.

Вот мой груз.toml:

[package]
name = "terminal-squares"
version = "0.1.0"
edition = "2021"

[dependencies]
pixels = "0.13.0"
winit = { version = "0.30.5", features = ["rwh_05"]}

Вот мой основной код.

use winit::{
    event_loop::{
        ControlFlow,
        EventLoop,
    },
};

fn main() {

    let event_loop = EventLoop::new().unwrap();
    event_loop.set_control_flow(ControlFlow::Poll);

    let mut app = application::Application::new();

    event_loop.run_app(&mut app).unwrap();
}

pub mod application {
    use super::window_manager::WindowManager;

    use pixels::{
        Pixels,
        SurfaceTexture,
        wgpu::Color,
    };

    use winit::{
        application::ApplicationHandler,
        dpi::LogicalSize,
        window::{
            Window,
            WindowId,
        },
        event::{
            WindowEvent,
        },
        event_loop::{
            ActiveEventLoop,
        },
    };

    pub struct Application {
        window_width: f32,
        window_height: f32,

        windows: Vec<WindowManager>,
    }

    impl Application {
        pub fn new() -> Self {
            Self {
                window_width: 500.0,
                window_height:500.0,

                windows: Vec::new(),
            }
        }

        fn create_window(&mut self, event_loop: &ActiveEventLoop) {
            let window = {
                let size = LogicalSize::new(self.window_width as f64, self.window_height as f64);

                let window_attributes = Window::default_attributes()
                    .with_title("Hello Pixels")
                    .with_inner_size(size)
                    .with_min_inner_size(size);

                event_loop.create_window(window_attributes).unwrap()
            };

            let pixels = {
                let window_size = window.inner_size();

                let surface_texture = SurfaceTexture::new(window_size.width, window_size.height, &window);

                Pixels::new(self.window_width as u32, self.window_height as u32, surface_texture).unwrap()
            };

            // Try and remember to ask someone what to do when the window closes and resume is called for a new one. Doesn't seem to be any check closed function.
            self.windows.push(WindowManager::new(window, pixels));
        }
    }

    impl ApplicationHandler for Application {
        fn resumed(&mut self, event_loop: &ActiveEventLoop) {
            // This will need to be revisited after I find the answer to the closing windows thing.
            if self.windows.len() == 0 {
                self.create_window(&event_loop);
            }
        }

        fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
            // /self.windows[0].request_redraw();
            match event {
                WindowEvent::CloseRequested => {
                    println!("The close button was pressed; stopping");
                    event_loop.exit();
                },
                WindowEvent::RedrawRequested => {
                    if self.windows.len() > 0 { // Revisit this.
                        /*let win_len = self.windows.len() - 1 as usize;
                        self.windows[win_len].clear();
                        println!("Test");*/

                        self.windows[0].clear();
                    }
                },
                _ => (),
            }
        }
    }
}

pub mod window_manager {
    use pixels::{
        Pixels,
    };

    use winit::{
        window::{
            Window,
            WindowId,
        },
    };

    pub struct WindowManager {
        window: Window,
        pixels: Pixels,
    }

    impl WindowManager {
        pub fn new(window: Window, pixels: Pixels) -> Self {
            Self{
                window,
                pixels,
            }
        }

        pub fn clear(&mut self) {
            for (i, pixel) in self.pixels.frame_mut().chunks_exact_mut(4).enumerate() {
                pixel.copy_from_slice(&[0x48, 0xb2, 0xe8, 0xff]);
            }
            //self.window.draw();
            //self.window.request_redraw();
        }

        //pub fn get_window(self) -> &Window { &self.window } // Another area that needs revisited.

        pub fn get_window_id(self) -> WindowId { self.window.id() }
    }
}