use crate::{
    screen::{Camera, RenderError, RenderInput, RenderOptions, Screen},
    text::{TextSystem, TextSystemData},
};
use winit::{
    event::{ElementState, KeyEvent, WindowEvent},
    keyboard::{Key, NamedKey},
    window::Window,
};
    screen: Screen,
}
        let mut camera = Camera::default();
        let mut render_options = RenderOptions::default();
        // The *only* time we need to manually do this, all others should use extract_view!
        let mut view = GameView {
            camera: &mut camera,
            render_options: &mut render_options,
            // executor: &mut executor,
        };
        initial_scene.on_enter(&mut view);
        let egui = egui::Context::default();
        let egui_winit =
            egui_winit::State::new(egui.clone(), egui::ViewportId::ROOT, &window, None, None);
        let screen = Screen::new(window).await?;
        Ok(Self {
            egui,
            egui_winit,
            screen,
            scene_library,
            current_scene: initial_scene,
            // systems
            show_debug: false,
            internal_state: GameState {
                camera,
                render_options,
            },
            text: TextSystem::new()?,
        })
    }
    }
    pub fn screen(&self) -> &Screen {
        &self.screen
    }
    pub fn screen_mut(&mut self) -> &mut Screen {
        &mut self.screen
    }
    /// Runs egui code
        egui_winit::update_viewport_info(
            self.egui_winit
                .egui_input_mut()
                .viewports
                .get_mut(&egui::ViewportId::ROOT)
                .unwrap(),
            &self.egui,
            self.screen.window(),
        );
        let input = self.egui_winit.take_egui_input(self.screen.window());
        let full_output = self.egui.run(input, |ctx| {
            egui::Window::new("Debug Tools")
                .open(&mut self.show_debug)
                .show(ctx, |ui| {
                    ui.horizontal(|ui| {
                        let mut vsync = self.screen.is_vsync();
                        let text = if vsync { "yes" } else { "no" };
                        ui.label("VSync");
                        ui.toggle_value(&mut vsync, text);
                        self.screen.vsync(vsync);
                    });
                    ui.add(
                        egui::Slider::new(&mut self.internal_state.render_options.gamma, 0.0..=2.0)
                            .text("Gamma"),
                    );
                });
            let mut view = extract_view!(self);
            self.current_scene.gui_egui(ctx, &mut view)
        });
        let prims = self
            .egui
            .tessellate(full_output.shapes.clone(), full_output.pixels_per_point);
        (full_output, prims)
    }
    /// Returns true if the event was handled
        #[cfg(debug_assertions)]
        if matches!(
            event,
            WindowEvent::KeyboardInput {
                event: KeyEvent {
                    logical_key: Key::Named(NamedKey::F1),
                    state: ElementState::Pressed,
                    repeat: false,
                    ..
                },
                ..
            }
        ) {
            self.show_debug = !self.show_debug;
            return true;
        }
        if self
            .egui_winit
            .on_window_event(self.screen.window(), event)
            .consumed
        {
            return true;
        }
        self.current_scene.input(event, &mut view)
    }
        puffin::profile_function!();
        // Run any in-progress tasks from the async executor
        // self.executor.run_until_stall(&mut self.internal_state);
        if let Some(reference) = self.current_scene.update(dt, &mut view) {
            let new_scene = self.scene_library.get_scene(&mut view, reference);
            self.current_scene.on_exit(&mut view);
            self.current_scene = new_scene;
            self.current_scene.on_enter(&mut view);
        }
    }
        puffin::profile_function!();
        // Any resources only used for the rendering process go here
        let camera_text_data = camera_text_data_info
            .iter()
            .map(|(buf, mapper)| mapper.produce(buf))
            .collect();
        let world_text_data = world_text_data_info
            .iter()
            .map(|(buf, mapper)| mapper.produce(buf))
            .collect();
        // Build the renderer input
        let input = RenderInput {
            paint_jobs: &paint_jobs,
            textures_delta: &egui_output.textures_delta,
            font_system: &mut self.text.fonts,
            swash_cache: &mut self.text.swash,
            camera_text_data,
            world_text_data,
        };
        self.screen.render(input)
    }
}
    // methods here might query the world to produce
    // rendering data ready for Screen to use
            camera: &mut self.internal_state.camera,
            render_options: &self.internal_state.render_options,
        let world_text_data_info: Vec<_> =
            self.text.produce_world(&text_data).into_iter().collect();
        let camera_text_data_info: Vec<_> =
            self.text.produce_camera(&text_data).into_iter().collect();
        self.text.prepare(&text_data);
        let (egui_output, paint_jobs) = self.gui_egui();
        let text_data = TextSystemData::extract();
    pub fn render(&mut self) -> Result<(), RenderError> {
        let mut view = extract_view!(self);
    pub fn update(&mut self, dt: std::time::Duration) {
        let mut view = extract_view!(self);
    pub fn input(&mut self, event: &WindowEvent) -> bool {
        self.egui_winit
            .handle_platform_output(self.screen.window(), full_output.platform_output.clone());
    pub fn gui_egui(&mut self) -> (egui::FullOutput, Vec<egui::ClippedPrimitive>) {
    pub async fn create_surface(&mut self) -> color_eyre::Result<()> {
        self.screen.create_surface().await
        let mut initial_scene = scene_library.get_scene(&mut view, ModeReference::Init);
impl Game {
    pub async fn new(window: Window) -> color_eyre::Result<Self> {
        let scene_library = ModeLibrary;
    egui: egui::Context,
    egui_winit: egui_winit::State,
    internal_state: GameState,
    // executor: Cosync<GameState<S>>,
    // systems
    text: TextSystem,
    // internal controls
    show_debug: bool,
}
pub struct GameState {
    pub camera: Camera,
    pub render_options: RenderOptions,
}
    pub camera: &'a mut Camera,
    pub render_options: &'a mut RenderOptions,
}
macro_rules! extract_view {
        GameView {
            camera: &mut $game.internal_state.camera,
            render_options: &mut $game.internal_state.render_options,
            // executor: &mut $game.executor,
        }
    };
    ($game: expr) => {
    // pub executor: &'a mut Cosync<GameState<S>>,
pub struct GameView<'a> {
    scene_library: ModeLibrary,
    current_scene: Box<dyn Mode + Send>,
pub struct Game {
use self::mode::{Mode, ModeLibrary, ModeReference};
mod mode;

fn meets_thresh(color: vec4<f32>) -> bool {
    // stack overflow magic \sqrt{0.299\cdot r^{2}+0.587\cdot g^{2}+0.114\cdot b^{2}}
    let brightness = sqrt(dot(color.rgb * color.rgb, vec3<f32>(0.299, 0.587, 0.114)));
    return brightness > 0.1;
}
const PI = 3.14159265359;
const STD_DEV: f32 = 50.0;

fn weight_calc(i: u32) -> f32 {
    let STD_DEV_P2 = pow(STD_DEV, 2.0);
    // use the gaussian kernel, until it's too slow otherwise
    return (1.0 / sqrt(2.0 * PI * STD_DEV_P2)) * exp(-pow(f32(i), 2.0) / (2.0 * STD_DEV_P2));
}

    let strength = 3.0;
    var added: vec4<f32>;
    // let offset = vec2<f32>(textureOffset.x, textureOffset.y);
    // Turns out this might be a cool astigmatism shader, gotta remember that
    let offset_y = vec2<f32>(0.0, textureOffset.y);
    let offset_x = vec2<f32>(textureOffset.x, 0.0);
    for(var i: u32 = 0; i < 9; i++) {
        let new_color_a = textureSample(t_world, s_world, t_tex_coords + offset_x * f32(i));
        let new_color_b = textureSample(t_world, s_world, t_tex_coords - offset_x * f32(i));
        if (meets_thresh(new_color_a)) {
            // result += vec4<f32>(new_color_a.rgb * weight[i], 0);
            added += vec4<f32>(new_color_a.rgb, 1.0 / strength) * weight_calc(i) * strength;
        }
        if (meets_thresh(new_color_b)) {
            // result += vec4<f32>(new_color_b.rgb * weight[i], 0);
            added += vec4<f32>(new_color_b.rgb, 1.0 / strength) * weight_calc(i) * strength;
        }
        let new_color_c = textureSample(t_world, s_world, t_tex_coords + offset_y * f32(i));
        let new_color_d = textureSample(t_world, s_world, t_tex_coords - offset_y * f32(i));
        if (meets_thresh(new_color_c)) {
            // result += vec4<f32>(new_color_a.rgb * weight[i], 0);
            added += vec4<f32>(new_color_c.rgb, 1.0 / strength) * weight_calc(i) * strength;
        }
        if (meets_thresh(new_color_d)) {
            // result += vec4<f32>(new_color_b.rgb * weight[i], 0);
            added += vec4<f32>(new_color_d.rgb, 1.0 / strength) * weight_calc(i) * strength;
        }
        let new_color_e = textureSample(t_world, s_world, t_tex_coords + offset_x * f32(i) + offset_y * f32(i));
        let new_color_f = textureSample(t_world, s_world, t_tex_coords + offset_x * f32(i) - offset_y * f32(i));
        if (meets_thresh(new_color_e)) {
            // result += vec4<f32>(new_color_a.rgb * weight[i], 0);
            added += vec4<f32>(new_color_e.rgb, 1.0 / strength) * weight_calc(i) * strength;
        }
        if (meets_thresh(new_color_f)) {
            // result += vec4<f32>(new_color_b.rgb * weight[i], 0);
            added += vec4<f32>(new_color_f.rgb, 1.0 / strength) * weight_calc(i) * strength;
        }
        let new_color_g = textureSample(t_world, s_world, t_tex_coords + offset_x * f32(i) + offset_y * f32(i));
        let new_color_h = textureSample(t_world, s_world, t_tex_coords - offset_x * f32(i) + offset_y * f32(i));
        if (meets_thresh(new_color_g)) {
            // result += vec4<f32>(new_color_a.rgb * weight[i], 0);
            added += vec4<f32>(new_color_g.rgb, 1.0 / strength) * weight_calc(i) * strength;
        }
        if (meets_thresh(new_color_h)) {
            // result += vec4<f32>(new_color_b.rgb * weight[i], 0);
            added += vec4<f32>(new_color_h.rgb, 1.0 / strength) * weight_calc(i) * strength;
        }
    }
    // We do it this weird way, cuz the world texture is *not* HDR atm
    let hdr = result + added;
    let sdr = hdr::aces_tone_map(hdr.rgb);
    // Map gamma while, we're at it
    result = vec4<f32>(pow(sdr, vec3<f32>(render_options.gamma)), hdr.a);
    // return in.color;
    // return in.color * textureSample(t_world, s_world, in.tex_coords);

    // return in.color + textureSample(t_world, s_world, in.tex_coords);

use glam::Vec3Swizzles;

use crate::screen::WORLD_HALF_EXTENTS;

    glyphon_to_world: glam::Affine3A,

            glyphon_to_world: (glam::Affine3A::from_translation(glam::Vec3::new(
                -(WORLD_HALF_EXTENTS.x as f32),
                -(WORLD_HALF_EXTENTS.y as f32),
                0.0,
            )) * glam::Affine3A::from_scale(glam::Vec3::new(
                2.0 * WORLD_HALF_EXTENTS.x as f32,
                2.0 * WORLD_HALF_EXTENTS.y as f32,
                1.0,
            )))
            .inverse(),

        let normalized = self.glyphon_to_world.transform_point3(point.extend(0.0));

        // let normalized = self.glyphon_to_world.transform_point3(point.extend(0.0));

        normalized.xy() * 2.0 * WORLD_HALF_EXTENTS.as_vec2()

        // normalized.xy() * 2.0 * WORLD_HALF_EXTENTS.as_vec2()
        point

            let attrs = Attrs::new().family(glyphon::Family::Name("Poiret One"));

            let srgb_red: palette::Srgb<u8> = palette::named::WHITE.into_format();
            let (r, g, b) = srgb_red.into_components();
            let color = glyphon::Color::rgb(r, g, b);
            let attrs = Attrs::new()
                .family(glyphon::Family::Name("Poiret One"))
                .color(color);

use crate::{WINDOW_HEIGHT, WINDOW_WIDTH};

use crate::{document::Document, WINDOW_HEIGHT, WINDOW_WIDTH};

    world_renderer: middleware::WorldRenderer,

    world_renderer: middleware::DocumentRenderer,

/// Defines maximum possible size of the world for rendering
///
/// The rendered coords are x in [-WHE.x, WHE.x] and y in [-WHE.y, WHE.y]
pub const WORLD_HALF_EXTENTS: glam::UVec2 = glam::UVec2::new(1024, 1024);

    world_width: u32,
    world_height: u32,

            width: 800.0,
            height: 600.0,

            width: WINDOW_WIDTH as f32,
            height: WINDOW_HEIGHT as f32,
            world_width: 1024,
            world_height: 1024,

        let world_extents = glam::Vec2::new(self.world_width as f32, self.world_height as f32);

            * WORLD_HALF_EXTENTS.as_vec2().recip() // 1 / (GW / 2) = 2 / GW
            * 0.25;

            * world_extents.recip() // 1 / (GW / 2) = 2 / GW
            * 0.5;

            -1.0 * WORLD_HALF_EXTENTS.x as f32,
            1.0 * WORLD_HALF_EXTENTS.x as f32,
            -1.0 * WORLD_HALF_EXTENTS.y as f32,
            1.0 * WORLD_HALF_EXTENTS.y as f32,

            -0.5 * self.world_width as f32,
            0.5 * self.world_width as f32,
            -0.5 * self.world_height as f32,
            0.5 * self.world_height as f32,

            gamma: 1.0,

            gamma: 0.4,

    pub document: &'a Document,

        let world_texture_format = wgpu::TextureFormat::Rgba16Float;

        let world_texture_format = wgpu::TextureFormat::Bgra8Unorm;

        let world_renderer = middleware::WorldRenderer::new(

        let world_renderer = middleware::DocumentRenderer::new(

            width: WORLD_HALF_EXTENTS.x * 2,
            height: WORLD_HALF_EXTENTS.y * 2,

            width: input.camera.world_width * 2,
            height: input.camera.world_height * 2,

            input.document,

    use crate::screen::{Camera, WORLD_HALF_EXTENTS};

    use crate::screen::Camera;

            width: WORLD_HALF_EXTENTS.x as f32 / 0.5,
            height: WORLD_HALF_EXTENTS.y as f32,

            width: 512.0,
            height: 1024.0,

pub use world::WorldRenderer;

pub use world::DocumentRenderer;

use crate::screen::{Camera, RenderOptions, WORLD_HALF_EXTENTS};

use crate::{
    document::Document,
    screen::{Camera, RenderOptions},
};

pub struct WorldRenderer {

pub struct DocumentRenderer {

impl WorldRenderer {

/// All document cells must fit within this area
pub const MAX_DOCUMENT_SIZE: glam::UVec2 = glam::UVec2::new(2048, 2048);
impl DocumentRenderer {

                width: WORLD_HALF_EXTENTS.x * 2,
                height: WORLD_HALF_EXTENTS.y * 2,

                width: MAX_DOCUMENT_SIZE.x,
                height: MAX_DOCUMENT_SIZE.y,

        _document: &Document,

mod game;

mod document;

use game::Game;

use document::Project;

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

    let game = match Project::new(window).await {

version = "1.14.2"

version = "1.14.3"

checksum = "ea31d69bda4949c1c1562c1e6f042a1caefac98cdc8a298260a2ff41c1e2d42b"

checksum = "a2ef034f05691a48569bd920a96c81b9d91bbad1ab5ac7c4616c1f6ef36cb79f"

version = "0.11.0"

version = "0.11.1"

checksum = "7fd9190de5c4b7d91a785c8ebf1cf1c1ecbfc1731eb0a171b3cb0972f58b4995"

checksum = "8761121fca0dbc275008ac1da10fac40d835d69f75bbf2fd443db29a409fcb55"

version = "0.4.10"

version = "0.4.11"

checksum = "0bad00257d07be169d870ab665980b06cdb366d792ad690bf2e76876dc503455"

checksum = "fe8f25ce1159c7740ff0b9b2f5cdf4a8428742ba7c112b9f20f22cd5219c7dab"

 "rustix",

 "libc",

version = "0.1.27"

version = "0.1.28"

checksum = "8c37f63953c4c63420ed5fd3d6d398c719489b9f872b9fa683262f8edd363c7d"

checksum = "ab46a6e9526ddef3ae7f787c06f0f2600639ba80ea3eade3d8e670a2230f51d6"

version = "1.4.0"

version = "1.5.0"

checksum = "977b1e897f9d764566891689e642653e5ed90c6895106acd005eb4c1d0203991"

checksum = "795915a3930a5d6bafd9053d37602fea3e61be2e5d4d788983a8ba9654c1c6f2"

version = "0.15.3"

version = "0.15.4"

checksum = "a1362980db95801b70031dd592dc052a44b1810ca9da8fbcf7b25983f3174ed0"

checksum = "d70252c718fb23d41771a4f927e924700edefc2a91ecd52a2ee6f2461d4e6b64"

version = "0.18.0"

version = "0.18.1"

checksum = "60e3d9941fa3bacf7c2bf4b065304faa14164151254cd16ce1b1bc8fc381600f"

checksum = "922fd3eeab3bd820d76537ce8f582b1cf951eceb5475c28500c7457d9d17f53a"