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(),

    /// Convert a 2d point as the world describes it, to a 2d point that
    /// the world glyphon can understand
    fn convert_world_to_glyphon_world(&self, point: glam::Vec2) -> glam::Vec2 {
        // Converts it to a representation of [0, 1] from the world domain of [-WHE, +WHE]
        let normalized = self.glyphon_to_world.transform_point3(point.extend(0.0));
        // Maps the normalized coords to the glyphon scale of 2 * WHE
        (normalized * 2.0 * WORLD_HALF_EXTENTS.as_vec2().extend(0.0)).xy()
    }

        let screen_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();

            buffer.set_size(200.0, 25.0);

            buffer.set_size(250.0, 25.0);

            buffer.set_text("Hello, game world! 🦀\n", attrs, Shaping::Advanced);

            buffer.set_text("Hello, game! 🦀\n", attrs, Shaping::Advanced);

        let loc = screen_to_world.transform_point3(glam::Vec3::new(0.0, 0.0, 0.0))
            * 2.0
            * WORLD_HALF_EXTENTS.as_vec2().extend(0.0);
        vec![(buffer, BufferMapper::new(loc.xy(), 1.0))]

        let loc = glam::Vec2::new(32.0, 32.0);
        vec![(
            buffer,
            BufferMapper::new(self.convert_world_to_glyphon_world(loc), 1.0),
        )]

                    scale: ta.scale * scale_factor.recip() as f32,

                    scale: ta.scale * scale_factor.recip(),

    pub camera: &'a mut Camera,

        let mut camera = Camera::default();

            camera: &mut camera,

        let camera = Camera::default();

                camera: &mut self.camera,

            camera: &mut self.camera,

        self.camera.transform.translation.x -= dt.as_secs_f32() * 0.005;
        self.camera.transform.translation.y -= dt.as_secs_f32() * 0.005;

            camera: &mut self.camera,

        let _ = game;
        let _ = dt;

        let negative = self.voop.starts_with('-');
        if self.voop.to_lowercase().ends_with("camera") {
            game.camera.transform.translation.x -=
                negative.then(|| -1.0).unwrap_or(1.0) * dt.as_secs_f32() * 0.0025;
        }

        egui::Window::new("gama").show(ctx, |ui| {
            ui.label(">> Welcome to Cat Waiter <<");
            if ui
                .text_edit_singleline(&mut self.voop)
                .on_hover_text("the best textbox of your life")
                .changed()
            {
                log::info!(">> new text: {}", self.voop);
            }
        });

        egui::Window::new("gama")
            .default_pos((10.0, 200.0))
            .show(ctx, |ui| {
                ui.label(">> Welcome to Cat Waiter <<");
                if ui
                    .text_edit_singleline(&mut self.voop)
                    .on_hover_text("the best textbox of your life")
                    .changed()
                {
                    log::info!(">> new text: {}", self.voop);
                }
            });