surface: wgpu::Surface<'static>,

    instance: wgpu::Instance,
    adapter_state: Option<AdapterState>,
    surface_state: Option<SurfaceState>,
    size: winit::dpi::PhysicalSize<u32>,
    window: Arc<Window>,
}
struct AdapterState {
    adapter: wgpu::Adapter,

}
struct SurfaceState {
    surface: wgpu::Surface<'static>,

    size: winit::dpi::PhysicalSize<u32>,
    window: Arc<Window>,

    pub async fn new<S: assets_manager::source::Source>(
        window: Window,
        assets: &AssetCache<S>,
    ) -> color_eyre::Result<Self> {
        let size = {
            let actual_size = window.inner_size();
            if actual_size.width == 0 || actual_size.height == 0 {
                // Assume we are actually in-built height and notify
                let assumed_size = PhysicalSize::new(WINDOW_WIDTH, WINDOW_HEIGHT);
                window.set_min_inner_size(Some(assumed_size));
                assumed_size
            } else {
                // It's fine
                actual_size
            }
        };
        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
            backends: wgpu::Backends::all(),
            ..Default::default()
        });

    async fn acknoledge_surface(
        &mut self,
        surface: &wgpu::Surface<'static>,
    ) -> color_eyre::Result<()> {
        if self
            .adapter_state
            .as_ref()
            .is_some_and(|ads| ads.adapter.is_surface_supported(surface))
        {
            // Conserve work: we've already made a perfectly good adapter that supports the surface we want to draw to
            return Ok(());
        }

        let window = Arc::new(window);
        let surface = instance.create_surface(window.clone())?;

        log::info!("(Re)creating adapter to support {surface:?}");

        let adapter = instance

        let adapter = self
            .instance

                power_preference: wgpu::PowerPreference::HighPerformance,
                compatible_surface: Some(&surface),

                power_preference: wgpu::PowerPreference::default(),
                compatible_surface: Some(surface),

            .ok_or_else(|| eyre!("Adapter not found for surface"))?;

            .ok_or_else(|| eyre!("failed to find an adapter for surface"))?;

        self.adapter_state = Some(AdapterState {
            adapter,
            device,
            queue,
        });
        Ok(())
    }

        let surface_caps = surface.get_capabilities(&adapter);

    pub async fn create_surface<S: assets_manager::source::Source>(
        &mut self,
        assets: &AssetCache<S>,
    ) -> color_eyre::Result<()> {
        let surface = self.instance.create_surface(self.window.clone())?;
        self.acknoledge_surface(&surface).await?;
        let Some(adapter_state) = self.adapter_state.as_ref() else {
            unreachable!("adapter_state should have been created by `Screen::acknowledge_surface`");
        };
        let surface_caps = surface.get_capabilities(&adapter_state.adapter);

            width: size.width,
            height: size.height,

            width: self.size.width,
            height: self.size.height,

        surface.configure(&device, &config);

        surface.configure(&adapter_state.device, &config);

        let egui = egui_wgpu::Renderer::new(&device, surface_format, None, 1);

        let egui = egui_wgpu::Renderer::new(&adapter_state.device, surface_format, None, 1);

        let world_atlas = glyphon::TextAtlas::new(&device, &queue, world_texture_format);
        let camera_atlas = glyphon::TextAtlas::new(&device, &queue, surface_format);
        let world_renderer =
            middleware::WorldRenderer::new(&device, config.format, world_texture_format, assets)?;

        let world_atlas = glyphon::TextAtlas::new(
            &adapter_state.device,
            &adapter_state.queue,
            world_texture_format,
        );
        let camera_atlas =
            glyphon::TextAtlas::new(&adapter_state.device, &adapter_state.queue, surface_format);
        let world_renderer = middleware::WorldRenderer::new(
            &adapter_state.device,
            config.format,
            world_texture_format,
            assets,
        )?;

        Ok(Self {
            window,

        self.surface_state = Some(SurfaceState {

            device,
            queue,

            size,
            world_renderer,
            // composer,

            world_renderer,
        });
        Ok(())
    }
    pub async fn new(window: Window) -> color_eyre::Result<Self> {
        let size = {
            let actual_size = window.inner_size();
            if actual_size.width == 0 || actual_size.height == 0 {
                // Assume we are actually in-built height and notify
                let assumed_size = PhysicalSize::new(WINDOW_WIDTH, WINDOW_HEIGHT);
                window.set_min_inner_size(Some(assumed_size));
                assumed_size
            } else {
                // It's fine
                actual_size
            }
        };
        let window = Arc::new(window);
        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
            backends: wgpu::Backends::all(),
            ..Default::default()
        });
        let adapter = instance
            .request_adapter(&wgpu::RequestAdapterOptions {
                power_preference: wgpu::PowerPreference::default(),
                compatible_surface: None,
                force_fallback_adapter: false,
            })
            .await;
        let adapter_state = if let Some(adapter) = adapter {
            let (device, queue) = adapter
            .request_device(
                &wgpu::DeviceDescriptor {
                    required_features: wgpu::Features::empty(), //wgpu::Features::all_webgpu_mask(),
                    required_limits: if cfg!(target_arch = "wasm32") {
                        if cfg!(feature = "webgpu") {
                            wgpu::Limits::downlevel_defaults()
                        } else if cfg!(feature = "webgl") {
                            wgpu::Limits::downlevel_webgl2_defaults()
                        } else {
                            unreachable!("for `web` feature, you must also enable a backend feature: `webgpu`, `webgl`")
                        }
                    } else {
                        wgpu::Limits::default()
                    },
                    label: None,
                },
                None,
            )
            .await?;
            Some(AdapterState {
                adapter,
                device,
                queue,
            })
        } else {
            None
        };
        Ok(Self {
            instance,
            size,
            window,
            adapter_state,
            surface_state: None,

            self.size = new_size;
            self.config.width = new_size.width;
            self.config.height = new_size.height;
            self.surface.configure(&self.device, &self.config);

            if let Some((surface_state, adapter_state)) =
                self.surface_state.as_mut().zip(self.adapter_state.as_ref())
            {
                self.size = new_size;
                surface_state.config.width = new_size.width;
                surface_state.config.height = new_size.height;
                surface_state
                    .surface
                    .configure(&adapter_state.device, &surface_state.config);
            }

        self.surface.configure(&self.device, &self.config);

        if let Some((surface_state, adapter_state)) =
            self.surface_state.as_ref().zip(self.adapter_state.as_ref())
        {
            surface_state
                .surface
                .configure(&adapter_state.device, &surface_state.config);
        }

        match self.config.present_mode {
            wgpu::PresentMode::AutoVsync => true,
            wgpu::PresentMode::AutoNoVsync => false,
            _ => unreachable!(),

        if let Some(state) = self.surface_state.as_ref() {
            match state.config.present_mode {
                wgpu::PresentMode::AutoVsync => true,
                wgpu::PresentMode::AutoNoVsync => false,
                _ => unreachable!(),
            }
        } else {
            false

        let pm = if vsync {
            wgpu::PresentMode::AutoVsync
        } else {
            wgpu::PresentMode::AutoNoVsync
        };
        self.config.present_mode = pm;
        self.surface.configure(&self.device, &self.config);

        if let Some((surface_state, adapter_state)) =
            self.surface_state.as_mut().zip(self.adapter_state.as_ref())
        {
            let pm = if vsync {
                wgpu::PresentMode::AutoVsync
            } else {
                wgpu::PresentMode::AutoNoVsync
            };
            surface_state.config.present_mode = pm;
            surface_state
                .surface
                .configure(&adapter_state.device, &surface_state.config);
        }

        let output = self.surface.get_current_texture()?;

        let Some((surface_state, adapter_state)) =
            self.surface_state.as_mut().zip(self.adapter_state.as_ref())
        else {
            // Return early, as surface has not been initialized
            return Ok(());
        };
        let output = surface_state.surface.get_current_texture()?;

        let mut encoder = self
            .device
            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
                label: Some("Render Encoder"),
            });

        let mut encoder =
            adapter_state
                .device
                .create_command_encoder(&wgpu::CommandEncoderDescriptor {
                    label: Some("Render Encoder"),
                });

            self.egui
                .update_texture(&self.device, &self.queue, *tex_id, delta);

            surface_state.egui.update_texture(
                &adapter_state.device,
                &adapter_state.queue,
                *tex_id,
                delta,
            );

        let egui_commands = self.egui.update_buffers(
            &self.device,
            &self.queue,

        let egui_commands = surface_state.egui.update_buffers(
            &adapter_state.device,
            &adapter_state.queue,

            &mut self.world_atlas,
            &self.device,

            &mut surface_state.world_atlas,
            &adapter_state.device,

            &self.device,
            &self.queue,

            &adapter_state.device,
            &adapter_state.queue,

            &mut self.world_atlas,

            &mut surface_state.world_atlas,

                    view: self.world_renderer.world_texture_view(),

                    view: surface_state.world_renderer.world_texture_view(),

            world_glyphon.render(&self.world_atlas, &mut world_render_pass)?;

            world_glyphon.render(&surface_state.world_atlas, &mut world_render_pass)?;

            &mut self.camera_atlas,
            &self.device,

            &mut surface_state.camera_atlas,
            &adapter_state.device,

            &self.device,
            &self.queue,

            &adapter_state.device,
            &adapter_state.queue,

            &mut self.camera_atlas,

            &mut surface_state.camera_atlas,

        self.world_renderer.prepare(
            &self.device,
            &self.queue,

        surface_state.world_renderer.prepare(
            &adapter_state.device,
            &adapter_state.queue,

            self.world_renderer.render(&mut final_render_pass);

            surface_state.world_renderer.render(&mut final_render_pass);

            camera_glyphon.render(&self.camera_atlas, &mut final_render_pass)?;

            camera_glyphon.render(&surface_state.camera_atlas, &mut final_render_pass)?;

            self.egui

            surface_state
                .egui

            self.egui.free_texture(tex_id);

            surface_state.egui.free_texture(tex_id);

        self.queue.submit(

        adapter_state.queue.submit(

use std::time::Duration;

use std::{
    collections::HashMap,
    future::Future,
    pin::Pin,
    sync::{Arc, Mutex},
    task::{Context, Poll},
    time::Duration,
};

    event_loop::{ControlFlow, EventLoop},

    event_loop::{ControlFlow, EventLoop, EventLoopBuilder, EventLoopProxy},

}
// Poor man's executor for winit's poor man's async
type TaskId = usize;
struct PollTask(TaskId);
struct WinitExecutor<E> {
    // a better implementation should use a vec of options here.
    tasks: HashMap<TaskId, Pin<Box<dyn Future<Output = Result<(), E>>>>>,
    event_loop_proxy: EventLoopProxy<PollTask>,

impl<E> WinitExecutor<E> {
    /// Create a new `WinitExecutor`, driven by the given event loop.
    pub fn new(event_loop_proxy: EventLoopProxy<PollTask>) -> Self {
        Self {
            tasks: HashMap::new(),
            event_loop_proxy,
        }
    }
    fn next_task_id(&self) -> TaskId {
        static NEXT_TASK_ID: std::sync::atomic::AtomicUsize =
            std::sync::atomic::AtomicUsize::new(0);
        NEXT_TASK_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
    }
    /// Spawn a task.
    ///
    /// This immediately pools the task once, and then schedules it to be
    /// polled again if needed, using a `UserEvent::PollTask` event.
    pub fn spawn(&mut self, task: impl Future<Output = Result<(), E>> + 'static) {
        let task = Box::pin(task);
        let task_id = self.next_task_id();
        self.tasks.insert(task_id, task);
        self.poll(task_id);
    }

    /// Poll a task.
    ///
    /// Should be called when the event loop receives a `UserEvent::PollTask`.
    pub fn poll(&mut self, task_id: TaskId) -> Option<Result<(), E>> {
        // this wake only need to work once, I believe, so we could use some type of "oneshot box"
        // instead of a mutex?
        let winit_proxy = Mutex::new(self.event_loop_proxy.clone());
        let waker = waker_fn::waker_fn(move || {
            let _ = winit_proxy.lock().unwrap().send_event(PollTask(task_id));
        });
        let task = self.tasks.get_mut(&task_id).unwrap().as_mut();
        match task.poll(&mut Context::from_waker(&waker)) {
            Poll::Ready(res) => {
                _ = self.tasks.remove(&task_id);
                Some(res)
            }
            Poll::Pending => None,
        }
    }
}

    let event_loop = EventLoop::new()?;

    let event_loop: EventLoop<PollTask> =
        EventLoopBuilder::<PollTask>::with_user_event().build()?;

    let mut game = match Game::new(window, source).await {

    let game = match Game::new(window, source).await {

    let game = Arc::new(Mutex::new(game));
    let el_proxy = event_loop.create_proxy();
    let mut winit_executor = WinitExecutor::new(el_proxy);

            if !game.input(event) {

            if !game.lock().unwrap().input(event) {

                        let mut game = game.lock().unwrap();

                        game.screen_mut().resize(*phys_size);

                        game.lock().unwrap().screen_mut().resize(*phys_size);

        Event::Resumed => {
            // Actually create the surface (and panic if we fail...)
            winit_executor.spawn({
                let game = game.clone();
                async move { game.lock().unwrap().create_surface().await }
            });
        }
        Event::UserEvent(PollTask(tid)) => {
            if let Some(res) = winit_executor.poll(tid) {
                // the stuff here shouldn't fail
                res.unwrap();
            }
        }

            let mut game = game.lock().unwrap();

        let screen = Screen::new(window, &assets).await?;

        let screen = Screen::new(window).await?;

    pub async fn create_surface(&mut self) -> color_eyre::Result<()>
    where
        S: assets_manager::source::Source,
    {
        self.screen
            .create_surface(&self.internal_state.assets)
            .await
    }

oneshot = "0.1.6"
waker-fn = "1.1.1"

desktop = ["egui-winit/clipboard", "egui-winit/links", "egui-winit/wayland", 
  "egui-winit/x11", "wgpu/dx12", "wgpu/metal", "wgpu/webgpu", "wgpu/wgsl",
  "tracing-subscriber/env-filter", "dep:pollster"]

desktop = ["egui-winit/default", "wgpu/default", "tracing-subscriber/env-filter", "dep:pollster"]

 "oneshot",

 "waker-fn",

]
[[package]]
name = "generator"
version = "0.7.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5cc16584ff22b460a382b7feec54b23d2908d858152e5739a120b949293bd74e"
dependencies = [
 "cc",
 "libc",
 "log",
 "rustversion",
 "windows 0.48.0",

name = "loom"
version = "0.5.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ff50ecb28bb86013e935fb6683ab1f6d3a20016f123c76fd4c27470076ac30f5"
dependencies = [
 "cfg-if",
 "generator",
 "pin-utils",
 "scoped-tls",
 "tracing",
 "tracing-subscriber",
]
[[package]]

name = "oneshot"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6f6640c6bda7731b1fdbab747981a0f896dd1fedaf9f4a53fa237a04a84431f4"
dependencies = [
 "loom",
]
[[package]]

name = "rustversion"
version = "1.0.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
[[package]]

name = "waker-fn"
version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f3c4517f54858c779bbcbf228f4fca63d121bf85fbecb2dc578cdf4a39395690"
[[package]]

]
[[package]]
name = "windows"
version = "0.48.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f"
dependencies = [
 "windows-targets 0.48.5",