.gitea/workflows/build.yaml

@@ -1,25 +0,0 @@
-name: Build
-on: [push]
-
-jobs:
-  Build:
-    env:
-      RUNNER_TOOL_CACHE: /toolcache
-    container: rust:alpine
-    steps:
-      - name: Install node
-        run: apk add nodejs gcc libc-dev pkgconf libx11-dev alsa-lib-dev eudev-dev tar
-      - name: Check out repository code
-        uses: actions/checkout@v4
-      - name: Restore cache
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin/
-            ~/.cargo/registry/index/
-            ~/.cargo/registry/cache/
-            ~/.cargo/git/db/
-            target/
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-      - name: Build
-        run: cargo build --release

.github/workflows/docs.yml

@@ -0,0 +1,50 @@
+name: Docs
+on:
+  push:
+    branches: [master]
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+concurrency:
+  group: deploy
+  cancel-in-progress: false
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Install Dependencies
+        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+      - name: Configure cache
+        uses: Swatinem/rust-cache@v2
+      - name: Setup pages
+        id: pages
+        uses: actions/configure-pages@v4
+      - name: Clean docs folder
+        run: cargo clean --doc
+      - name: Build docs
+        run: cargo doc --no-deps
+      - name: Add redirect
+        run: echo '<meta http-equiv="refresh" content="0;url=bevy_terminal_display/index.html">' > target/doc/index.html
+      - name: Remove lock file
+        run: rm target/doc/.lock
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: target/doc
+  deploy:
+    name: Deploy
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

.github/workflows/rust.yml

@@ -0,0 +1,24 @@
+name: Rust
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Install Dependencies
+      run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose

.gitignore

@@ -1,3 +1 @@
 /target
-Cargo.lock
-.cargo

Cargo.toml

@@ -1,40 +1,24 @@
 [package]
 name = "bevy_terminal_display"
-version = "0.7.0"
+version = "0.2.1"
 edition = "2021"
-license = "0BSD OR MIT OR Apache-2.0"
-description = "A plugin for the Bevy game engine which enables rendering to a terminal using unicode braille characters."
-repository = "https://git.soaos.dev/soaos/bevy_terminal_display"
-
-[profile.dev]
-opt-level = 1
-
-[profile.dev.package."*"]
-opt-level = 2
 
 [dependencies]
-crossbeam-channel = "0.5"
+crossterm = "0.27.0"
-downcast-rs = "2.0"
+downcast-rs = "1.2.1"
-once_cell = "1.19"
+once_cell = "1.19.0"
-ratatui = "0.29"
-color-eyre = "0.6"
-leafwing-input-manager = "0.16"
-serde = "1.0"
-smol_str = "0.2"
 
 [dependencies.bevy]
-version = "0.15"
+version = "0.13"
-default-features = false
-features = ["bevy_render"]
 
-[dependencies.crossterm]
+[dependencies.bevy_framebuffer_extract]
-version = "0.28"
+git = "https://github.com/exvacuum/bevy_framebuffer_extract"
-features = ["serde"]
+tag = "v0.1.2"
-
-# SOAOS DEPS
 
 [dependencies.bevy_dither_post_process]
-version = "0.3"
+git = "https://github.com/exvacuum/bevy_dither_post_process"
+tag = "v0.1.4"
+
+[dependencies.ratatui]
+version = "0.26.2"
 
-[dependencies.bevy_headless_render]
-version = "0.2"

LICENSE-0BSD

@@ -1,5 +0,0 @@
-Copyright (C) 2024 by Silas Bartha silas@exvacuum.dev
-
-Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

README.md

@@ -1,43 +1,37 @@
 # bevy_terminal_display
 
-[![Crates](https://img.shields.io/crates/v/bevy_terminal_display)](https://crates.io/crates/bevy_terminal_display)
+![License](https://img.shields.io/badge/license-MIT%2FApache-blue.svg)
-![License](https://img.shields.io/badge/license-0BSD%2FMIT%2FApache-blue.svg)
+![Tag](https://img.shields.io/github/v/tag/exvacuum/bevy_terminal_display)
+![Build](https://img.shields.io/github/actions/workflow/status/exvacuum/bevy_terminal_display/rust.yml)
+[![Docs](https://img.shields.io/website?url=https%3A%2F%2Fexvacuum.github.io%2Fbevy_terminal_display%2F&label=docs)](https://exvacuum.github.io/bevy_terminal_display)
 
 A (very experimental) plugin for the [Bevy](https://bevyengine.org) engine which allows for rendering to a terminal window.
 
 WARNING: I highly recommend using the kitty terminal emulator with this, not only due to the gpu-accelerated rendering, but also the implementation of the kitty protocol which enables the advanced input detection.
 
 Features Include:
-- `TerminalDisplay` automatically sets up a correctly-formatted render texture
+- `TerminalDisplayBundle` automatically sets up a correctly-formatted render texture
 - Post-process dithers colors to pure black and white, which are then printed as braille characters to the terminal
 - Responsiveness to terminal window resizing
 - `TerminalInput` resource which keeps track of pressed & released keys
 - `Widget` component for rendering ratatui TUI widgets
 - `TerminalWidget` trait for creating custom TUI widget components
-- Log redirection
+- Logging redirected to `output.log`
 
 ## Screenshots
-![](doc/screenshot.png)
+![](./doc/screenshot.png)
 ## Compatibility
 
 | Crate Version | Bevy Version |
-| ------------- | ------------ |
+|---            |---           |
-| 0.6-0.7       | 0.15         |
-| 0.4           | 0.14         |
 | 0.2           | 0.13         |
 
 ## Installation
 
-### crates.io
-```toml
-[dependencies]
-bevy_terminal_display = "0.7"
-```
-
 ### Using git URL in Cargo.toml
 ```toml
 [dependencies.bevy_terminal_display]
-git = "https://git.soaos.dev/soaos/bevy_terminal_display"
+git = "https://github.com/exvacuum/bevy_terminal_display.git"
 ```
 
 ## Example Usage
@@ -52,21 +46,28 @@ fn main() {
         .add_plugins((
             DefaultPlugins.build().disable::<WinitPlugin>().disable::<LogPlugin>,
             ScheduleRunnerPlugin::run_loop(Duration::from_secs_f32(1.0 / 60.0)),
-            bevy_terminal_display::TerminalDisplayPlugin::default(),
+            bevy_terminal_display::TerminalDisplayPlugin,
         ))
+        .insert_resource(Msaa::Off) // For post-process
         .run();
 }
 ```
 
 When spawning a camera:
 ```rs
+let terminal_display_bundle = bevy_terminal_display::display::components::TerminalDisplayBundle::new(3, &asset_server);
+
 commands.spawn((
-    // Camera3d...
+    Camera3dBundle {
-    TerminalDisplay(3), // Field is level of dithering
+        camera: Camera {
+            target: terminal_display_bundle.image_handle().into(),
+            ..Default::default()
+        },
+        ..Default::default()
+    },
+    terminal_display_bundle,
 ));
 ```
 
-## License
 
-This crate is licensed under your choice of 0BSD, Apache-2.0, or MIT license.
 

src/display/components.rs

@@ -1,87 +1,72 @@
-use bevy::{
+use bevy::{prelude::*, render::render_resource::{Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages}};
-    ecs::{component::ComponentId, world::DeferredWorld},
-    prelude::*,
-    render::render_resource::{
-        Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages,
-    },
-};
 use bevy_dither_post_process::components::DitherPostProcessSettings;
-use bevy_headless_render::components::HeadlessRenderSource;
+use bevy_framebuffer_extract::{components::{ExtractFramebufferBundle, FramebufferExtractDestination}, render_assets::FramebufferExtractSource};
-use ratatui::style::Style;
-
-// TODO: MULTIPLE WINDOWS (probably behind feature flag)
-// INFO: need abstraction for launching terminal emulators
-//
-// /// Structure to refer to a terminal window entity
-// #[derive(Clone, Debug)]
-// pub enum TerminalWindowRef {
-//     /// Refers to the primary window created by default in the terminal the command is run in
-//     Primary,
-//     /// Direct reference to an terminal window entity
-//     Entity(Entity),
-// }
-//
-// #[derive(Component, Debug)]
-// pub struct TerminalWindow;
 
 /// Marker component for terminal display
-#[derive(Component, Debug)]
+#[derive(Component)]
-#[component(on_add = on_add_terminal_display)]
+pub struct TerminalDisplay;
-pub struct TerminalDisplay {
+
-    /// Level of dithering performed on image
+/// Bundle for terminal display, contains a handle to an image to be used as a render target to
-    pub dither_level: u32,
+/// render to the terminal
-    /// Style applied to rendered text
+#[derive(Bundle)]
-    pub style: Style,
+pub struct TerminalDisplayBundle {
+    _terminal_display: TerminalDisplay,
+    extract_framebuffer_bundle: ExtractFramebufferBundle,
+    dither_post_process_settings: DitherPostProcessSettings,
+    image_handle: Handle<Image>,
 }
 
-fn on_add_terminal_display(mut world: DeferredWorld, entity: Entity, _id: ComponentId) {
+impl TerminalDisplayBundle {
-    let asset_server = world.get_resource::<AssetServer>().unwrap();
+    /// Create a new terminal display with the given dither level. A higher level exponentially
-    let dither_level = world
+    /// increases the size of the bayer matrix used in the ordered dithering calculations. If in
-        .entity(entity)
+    /// doubt, 3 is a good starting value to test with.
-        .get::<TerminalDisplay>()
+    pub fn new(dither_level: u32, asset_server: &AssetServer) -> Self {
-        .unwrap()
+        let terminal_size = crossterm::terminal::size().unwrap();
-        .dither_level;
+        let size = Extent3d {
+            width: (terminal_size.0 as u32) * 2,
+            height: (terminal_size.1 as u32) * 4,
+            depth_or_array_layers: 1,
+        };
 
-    let terminal_size = crossterm::terminal::size().unwrap();
+        let mut image = Image {
-    let size = Extent3d {
+            texture_descriptor: TextureDescriptor {
-        width: (terminal_size.0 as u32) * 2,
+                label: None,
-        height: (terminal_size.1 as u32) * 4,
+                size,
-        depth_or_array_layers: 1,
+                dimension: TextureDimension::D2,
-    };
+                format: TextureFormat::R8Unorm,
+                mip_level_count: 1,
+                sample_count: 1,
+                usage: TextureUsages::TEXTURE_BINDING
+                    | TextureUsages::COPY_SRC
+                    | TextureUsages::RENDER_ATTACHMENT,
+                view_formats: &[],
+            },
+            ..default()
+        };
 
-    let mut image = Image {
+        image.resize(size);
-        texture_descriptor: TextureDescriptor {
+        let image_handle = asset_server.add(image);
-            label: None,
-            size,
-            dimension: TextureDimension::D2,
-            format: TextureFormat::R8Unorm,
-            mip_level_count: 1,
-            sample_count: 1,
-            usage: TextureUsages::TEXTURE_BINDING
-                | TextureUsages::COPY_SRC
-                | TextureUsages::RENDER_ATTACHMENT,
-            view_formats: &[],
-        },
-        ..default()
-    };
 
-    image.resize(size);
+        let framebuffer_extract_source =
-    let image_handle = asset_server.add(image);
+            asset_server.add(FramebufferExtractSource(image_handle.clone()));
 
-    let headless_render_source = HeadlessRenderSource::new(asset_server, image_handle.clone());
+        Self {
-    let post_process_settings = DitherPostProcessSettings::new(dither_level, asset_server);
+            _terminal_display: TerminalDisplay,
-    world
+            extract_framebuffer_bundle: ExtractFramebufferBundle {
-        .commands()
+                source: framebuffer_extract_source,
-        .entity(entity)
+                dest: FramebufferExtractDestination::default(),
-        .insert((headless_render_source, post_process_settings));
+            },
-    if let Some(mut camera) = world.entity_mut(entity).get_mut::<Camera>() {
+            image_handle,
-        camera.target = image_handle.into();
+            dither_post_process_settings: DitherPostProcessSettings::new(
-    } else {
+                dither_level,
-        world.commands().entity(entity).insert(Camera {
+                asset_server,
-            target: image_handle.into(),
+            ),
-            hdr: true,
+        }
-            clear_color: ClearColorConfig::Custom(Color::LinearRgba(LinearRgba::BLACK)),
+    }
-            ..Default::default()
+
-        });
+    /// Retrieves the handle to this display's target image. Anything written here will be
+    /// displayed.
+    pub fn image_handle(&self) -> Handle<Image> {
+        self.image_handle.clone()
     }
 }

src/display/resources.rs

@@ -20,7 +20,9 @@ impl Default for Terminal {
         stdout().execute(EnterAlternateScreen).unwrap();
         stdout().execute(EnableMouseCapture).unwrap();
         stdout()
-            .execute(PushKeyboardEnhancementFlags(KeyboardEnhancementFlags::all()))
+            .execute(PushKeyboardEnhancementFlags(
+                KeyboardEnhancementFlags::REPORT_EVENT_TYPES,
+            ))
             .unwrap();
         enable_raw_mode().unwrap();
         let mut terminal = ratatui::Terminal::new(CrosstermBackend::new(stdout()))

src/display/systems.rs

@@ -2,15 +2,18 @@ use bevy::{
     prelude::*,
     render::render_resource::{Extent3d, TextureFormat},
 };
-use bevy_headless_render::{
+use bevy_framebuffer_extract::{
-    components::HeadlessRenderDestination, render_assets::HeadlessRenderSource,
+    components::FramebufferExtractDestination, render_assets::FramebufferExtractSource,
 };
 use crossterm::event::Event;
-use ratatui::widgets::{Paragraph, Wrap};
+use ratatui::{
+    style::Stylize,
+    widgets::{Paragraph, Wrap},
+};
 
 use crate::{input::events::TerminalInputEvent, widgets::components::Widget};
 
-use super::{components::TerminalDisplay, resources::Terminal};
+use super::resources::Terminal;
 
 const BRAILLE_CODE_MIN: u16 = 0x2800;
 const BRAILLE_CODE_MAX: u16 = 0x28FF;
@@ -24,13 +27,11 @@ const BRAILLE_DOT_BIT_POSITIONS: [u8; 8] = [0, 1, 2, 6, 3, 4, 5, 7];
 /// Prints out the contents of a render image to the terminal as braille characters
 pub fn print_to_terminal(
     mut terminal: ResMut<Terminal>,
-    image_exports: Query<(&TerminalDisplay, &HeadlessRenderDestination)>,
+    image_exports: Query<&FramebufferExtractDestination>,
     mut widgets: Query<&mut Widget>,
 ) {
-    let display = image_exports.get_single();
+    for image_export in image_exports.iter() {
-    let mut output_buffer = Vec::<char>::new();
+        let mut image = image_export
-    if let Ok((_, image)) = display {
-        let mut image = image
             .0
             .lock()
             .expect("Failed to get lock on output texture");
@@ -45,6 +46,7 @@ pub fn print_to_terminal(
             };
         }
 
+        let mut output_buffer = Vec::<char>::new();
         let width = image.width();
         let height = image.height();
         let data = &image.data;
@@ -64,31 +66,30 @@ pub fn print_to_terminal(
                 output_buffer.push(braille_char(mask));
             }
         }
-    }
 
-    let string = output_buffer.into_iter().collect::<String>();
+        let string = output_buffer.into_iter().collect::<String>();
-    terminal
+        terminal
-        .0
+            .0
-        .draw(|frame| {
+            .draw(|frame| {
-            if !string.is_empty() {
                 frame.render_widget(
                     Paragraph::new(string)
-                        .style(display.unwrap().0.style)
+                        .white()
+                        .bold()
                         .wrap(Wrap { trim: true }),
-                    frame.area(),
+                    frame.size(),
                 );
-            }
 
-            let mut active_widgets = widgets
+                let mut active_widgets = widgets
-                .iter_mut()
+                    .iter_mut()
-                .filter(|widget| widget.enabled)
+                    .filter(|widget| widget.enabled)
-                .collect::<Vec<_>>();
+                    .collect::<Vec<_>>();
-            active_widgets.sort_by(|a, b| a.depth.cmp(&b.depth));
+                active_widgets.sort_by(|a, b| a.depth.cmp(&b.depth));
-            for mut widget in active_widgets {
+                for mut widget in active_widgets {
-                widget.widget.render(frame, frame.area());
+                    widget.widget.render(frame, frame.size());
-            }
+                }
-        })
+            })
-        .expect("Failed to draw terminal frame");
+            .expect("Failed to draw terminal frame");
+    }
 }
 
 /// Utility function to convert a u8 into the corresponding braille character
@@ -107,7 +108,7 @@ fn braille_char(mask: u8) -> char {
 /// Watches for terminal resize events and resizes the render image accordingly
 pub fn resize_handling(
     mut images: ResMut<Assets<Image>>,
-    mut sources: ResMut<Assets<HeadlessRenderSource>>,
+    mut sources: ResMut<Assets<FramebufferExtractSource>>,
     mut event_reader: EventReader<TerminalInputEvent>,
 ) {
     for event in event_reader.read() {

src/input/components.rs

@@ -1,4 +0,0 @@
-use bevy::prelude::*;
-
-#[derive(Debug, Component)]
-pub struct DummyWindow;

src/input/mod.rs

@@ -6,6 +6,3 @@ pub mod resources;
 
 /// Systems for this module
 pub(crate) mod systems;
-
-/// Components for this module
-pub(crate) mod components;

src/input/resources.rs

@@ -1,7 +1,48 @@
-use bevy::prelude::*;
+use bevy::{prelude::*, utils::HashSet};
-use crossterm::event::Event;
+use crossterm::event::{Event, KeyCode};
 use std::sync::{Arc, Mutex};
 
+/// Resource containing currently pressed and released keys
+#[derive(Resource, Default)]
+pub struct TerminalInput {
+    pressed_keys: HashSet<KeyCode>,
+    released_keys: HashSet<KeyCode>,
+}
+
+impl TerminalInput {
+    /// Gets whether the given key is pressed
+    pub fn is_pressed(&self, code: KeyCode) -> bool {
+        self.pressed_keys.contains(&code)
+    }
+
+    /// Gets whether the given key is released
+    pub fn is_released(&self, code: KeyCode) -> bool {
+        self.released_keys.contains(&code)
+    }
+
+    /// Sets given key to pressed
+    pub(super) fn press(&mut self, code: KeyCode) {
+        if !self.is_pressed(code) {
+            self.pressed_keys.insert(code);
+        }
+    }
+
+    /// Sets given key to released and removes pressed state
+    pub(super) fn release(&mut self, code: KeyCode) {
+        if self.is_pressed(code) {
+            self.pressed_keys.remove(&code);
+        }
+        if !self.is_released(code) {
+            self.released_keys.insert(code);
+        }
+    }
+
+    /// Clears all released keys
+    pub(super) fn clear_released(&mut self) {
+        self.released_keys.clear();
+    }
+}
+
 /// Event queue for crossterm input event thread
 #[derive(Resource, Default)]
 pub(crate) struct EventQueue(pub(super) Arc<Mutex<Vec<Event>>>);

src/input/systems.rs

@@ -1,17 +1,10 @@
-use std::cmp::Ordering;
+use bevy::prelude::*;
+use crossterm::event::{read, Event, KeyEventKind};
 
-use bevy::{
+use super::{events::TerminalInputEvent, resources::{EventQueue, TerminalInput}};
-    input::{keyboard::KeyboardInput, ButtonState},
-    prelude::*,
-};
-use crossterm::event::{read, Event, KeyEvent, KeyEventKind, MediaKeyCode, ModifierKeyCode};
-use smol_str::SmolStr;
-
-use super::{components::DummyWindow, events::TerminalInputEvent, resources::EventQueue};
 
 /// Initializes event queue and thread
-pub fn setup_input(mut commands: Commands, event_queue: Res<EventQueue>) {
+pub fn setup_input(event_queue: Res<EventQueue>) {
-    commands.spawn(DummyWindow);
     let event_queue = event_queue.0.clone();
     std::thread::spawn(move || {
         loop {
@@ -31,305 +24,23 @@ pub fn setup_input(mut commands: Commands, event_queue: Res<EventQueue>) {
 /// Reads events from queue and broadcasts corresponding `TerminalInputEvent`s
 pub fn input_handling(
     event_queue: Res<EventQueue>,
-    dummy_window_query: Query<Entity, With<DummyWindow>>,
+    mut input: ResMut<TerminalInput>,
-    mut terminal_event_writer: EventWriter<TerminalInputEvent>,
+    mut event_writer: EventWriter<TerminalInputEvent>,
-    mut key_event_writer: EventWriter<KeyboardInput>,
 ) {
+    input.clear_released();
     let mut event_queue = event_queue.0.lock().unwrap();
-    let mut key_events = Vec::<KeyEvent>::new();
     while let Some(event) = event_queue.pop() {
         if let Event::Key(event) = event {
-            key_events.push(event);
+            match event.kind {
-        }
+                KeyEventKind::Press => {
-        terminal_event_writer.send(TerminalInputEvent(event));
+                    input.press(event.code);
-    }
-
-    key_events.sort_by(|&a, &b| a.kind.partial_cmp(&b.kind).unwrap_or(Ordering::Equal));
-    let window = dummy_window_query.single();
-    for event in key_events {
-        if let Some(key_code) = crossterm_keycode_to_bevy_keycode(event.code) {
-            if let Some(logical_key) = crossterm_keycode_to_bevy_key(event.code) {
-                match event.kind {
-                    KeyEventKind::Press => {
-                        key_event_writer.send(KeyboardInput {
-                            key_code,
-                            logical_key,
-                            state: ButtonState::Pressed,
-                            window,
-                            repeat: false,
-                        });
-                    }
-                    KeyEventKind::Repeat => {
-                        key_event_writer.send(KeyboardInput {
-                            key_code,
-                            logical_key,
-                            state: ButtonState::Pressed,
-                            window,
-                            repeat: true,
-                        });
-                    }
-                    KeyEventKind::Release => {
-                        key_event_writer.send(KeyboardInput {
-                            key_code,
-                            logical_key,
-                            state: ButtonState::Released,
-                            window,
-                            repeat: false,
-                        });
-                    }
                 }
+                KeyEventKind::Release => {
+                    input.release(event.code);
+                }
+                _ => (),
             }
         }
-    }
+        event_writer.send(TerminalInputEvent(event));
-}
-
-fn crossterm_keycode_to_bevy_keycode(
-    crossterm_keycode: crossterm::event::KeyCode,
-) -> Option<bevy::input::keyboard::KeyCode> {
-    use bevy::input::keyboard::KeyCode as BKey;
-    use crossterm::event::KeyCode as CKey;
-    match crossterm_keycode {
-        CKey::Backspace => Some(BKey::Backspace),
-        CKey::Enter => Some(BKey::Enter),
-        CKey::Left => Some(BKey::ArrowLeft),
-        CKey::Right => Some(BKey::ArrowRight),
-        CKey::Up => Some(BKey::ArrowUp),
-        CKey::Down => Some(BKey::ArrowDown),
-        CKey::Home => Some(BKey::Home),
-        CKey::End => Some(BKey::End),
-        CKey::PageUp => Some(BKey::PageUp),
-        CKey::PageDown => Some(BKey::PageDown),
-        CKey::Tab | CKey::BackTab => Some(BKey::Tab),
-        CKey::Delete => Some(BKey::Delete),
-        CKey::Insert => Some(BKey::Insert),
-        CKey::F(num) => match num {
-            1 => Some(BKey::F1),
-            2 => Some(BKey::F2),
-            3 => Some(BKey::F3),
-            4 => Some(BKey::F4),
-            5 => Some(BKey::F5),
-            6 => Some(BKey::F6),
-            7 => Some(BKey::F7),
-            8 => Some(BKey::F8),
-            9 => Some(BKey::F9),
-            10 => Some(BKey::F10),
-            11 => Some(BKey::F11),
-            12 => Some(BKey::F12),
-            13 => Some(BKey::F13),
-            14 => Some(BKey::F14),
-            15 => Some(BKey::F15),
-            16 => Some(BKey::F16),
-            17 => Some(BKey::F17),
-            18 => Some(BKey::F18),
-            19 => Some(BKey::F19),
-            20 => Some(BKey::F20),
-            21 => Some(BKey::F21),
-            22 => Some(BKey::F22),
-            23 => Some(BKey::F23),
-            24 => Some(BKey::F24),
-            25 => Some(BKey::F25),
-            26 => Some(BKey::F26),
-            27 => Some(BKey::F27),
-            28 => Some(BKey::F28),
-            29 => Some(BKey::F29),
-            30 => Some(BKey::F30),
-            31 => Some(BKey::F31),
-            32 => Some(BKey::F32),
-            33 => Some(BKey::F33),
-            34 => Some(BKey::F34),
-            35 => Some(BKey::F35),
-            _ => None,
-        },
-        CKey::Char(c) => match c {
-            '1' | '!' => Some(BKey::Digit1),
-            '2' | '@' => Some(BKey::Digit2),
-            '3' | '#' => Some(BKey::Digit3),
-            '4' | '$' => Some(BKey::Digit4),
-            '5' | '%' => Some(BKey::Digit5),
-            '6' | '^' => Some(BKey::Digit5),
-            '7' | '&' => Some(BKey::Digit7),
-            '8' | '*' => Some(BKey::Digit8),
-            '9' | '(' => Some(BKey::Digit9),
-            '0' | ')' => Some(BKey::Digit0),
-            '-' | '_' => Some(BKey::Minus),
-            '=' | '+' => Some(BKey::Equal),
-            '`' | '~' => Some(BKey::Backquote),
-            'q' | 'Q' => Some(BKey::KeyQ),
-            'w' | 'W' => Some(BKey::KeyW),
-            'e' | 'E' => Some(BKey::KeyE),
-            'r' | 'R' => Some(BKey::KeyR),
-            't' | 'T' => Some(BKey::KeyT),
-            'y' | 'Y' => Some(BKey::KeyY),
-            'u' | 'U' => Some(BKey::KeyU),
-            'i' | 'I' => Some(BKey::KeyI),
-            'o' | 'O' => Some(BKey::KeyO),
-            'p' | 'P' => Some(BKey::KeyP),
-            '[' | '{' => Some(BKey::BracketLeft),
-            ']' | '}' => Some(BKey::BracketRight),
-            'a' | 'A' => Some(BKey::KeyA),
-            's' | 'S' => Some(BKey::KeyS),
-            'd' | 'D' => Some(BKey::KeyD),
-            'f' | 'F' => Some(BKey::KeyF),
-            'g' | 'G' => Some(BKey::KeyG),
-            'h' | 'H' => Some(BKey::KeyH),
-            'j' | 'J' => Some(BKey::KeyJ),
-            'k' | 'K' => Some(BKey::KeyK),
-            'l' | 'L' => Some(BKey::KeyL),
-            ';' | ':' => Some(BKey::Semicolon),
-            '\'' | '"' => Some(BKey::Slash),
-            'z' | 'Z' => Some(BKey::KeyZ),
-            'x' | 'X' => Some(BKey::KeyX),
-            'c' | 'C' => Some(BKey::KeyC),
-            'v' | 'V' => Some(BKey::KeyV),
-            'b' | 'B' => Some(BKey::KeyB),
-            'n' | 'N' => Some(BKey::KeyN),
-            'm' | 'M' => Some(BKey::KeyM),
-            ',' | '<' => Some(BKey::Comma),
-            '.' | '>' => Some(BKey::Period),
-            '/' | '?' => Some(BKey::Slash),
-            ' ' => Some(BKey::Space),
-            _ => None,
-        },
-        CKey::Null => None,
-        CKey::Esc => Some(BKey::Escape),
-        CKey::CapsLock => Some(BKey::CapsLock),
-        CKey::ScrollLock => Some(BKey::ScrollLock),
-        CKey::NumLock => Some(BKey::NumLock),
-        CKey::PrintScreen => Some(BKey::PrintScreen),
-        CKey::Pause => Some(BKey::Pause),
-        CKey::Menu => Some(BKey::ContextMenu),
-        CKey::KeypadBegin => None,
-        CKey::Media(media) => match media {
-            MediaKeyCode::Play => Some(BKey::MediaPlayPause),
-            MediaKeyCode::Pause => Some(BKey::Pause),
-            MediaKeyCode::PlayPause => Some(BKey::MediaPlayPause),
-            MediaKeyCode::Reverse => None,
-            MediaKeyCode::Stop => Some(BKey::MediaStop),
-            MediaKeyCode::FastForward => Some(BKey::MediaTrackNext),
-            MediaKeyCode::Rewind => Some(BKey::MediaTrackPrevious),
-            MediaKeyCode::TrackNext => Some(BKey::MediaTrackNext),
-            MediaKeyCode::TrackPrevious => Some(BKey::MediaTrackPrevious),
-            MediaKeyCode::Record => None,
-            MediaKeyCode::LowerVolume => Some(BKey::AudioVolumeDown),
-            MediaKeyCode::RaiseVolume => Some(BKey::AudioVolumeUp),
-            MediaKeyCode::MuteVolume => Some(BKey::AudioVolumeMute),
-        },
-        CKey::Modifier(modifier) => match modifier {
-            ModifierKeyCode::LeftShift => Some(BKey::ShiftLeft),
-            ModifierKeyCode::LeftControl => Some(BKey::ControlLeft),
-            ModifierKeyCode::LeftAlt => Some(BKey::AltLeft),
-            ModifierKeyCode::LeftSuper => Some(BKey::SuperLeft),
-            ModifierKeyCode::LeftHyper => Some(BKey::Hyper),
-            ModifierKeyCode::LeftMeta => Some(BKey::Meta),
-            ModifierKeyCode::RightShift => Some(BKey::ShiftRight),
-            ModifierKeyCode::RightControl => Some(BKey::ControlRight),
-            ModifierKeyCode::RightAlt => Some(BKey::AltLeft),
-            ModifierKeyCode::RightSuper => Some(BKey::SuperRight),
-            ModifierKeyCode::RightHyper => Some(BKey::Hyper),
-            ModifierKeyCode::RightMeta => Some(BKey::Meta),
-            ModifierKeyCode::IsoLevel3Shift => None,
-            ModifierKeyCode::IsoLevel5Shift => None,
-        },
-    }
-}
-
-fn crossterm_keycode_to_bevy_key(
-    crossterm_keycode: crossterm::event::KeyCode,
-) -> Option<bevy::input::keyboard::Key> {
-    use bevy::input::keyboard::Key as BKey;
-    use crossterm::event::KeyCode as CKey;
-    match crossterm_keycode {
-        CKey::Backspace => Some(BKey::Backspace),
-        CKey::Enter => Some(BKey::Enter),
-        CKey::Left => Some(BKey::ArrowLeft),
-        CKey::Right => Some(BKey::ArrowRight),
-        CKey::Up => Some(BKey::ArrowUp),
-        CKey::Down => Some(BKey::ArrowDown),
-        CKey::Home => Some(BKey::Home),
-        CKey::End => Some(BKey::End),
-        CKey::PageUp => Some(BKey::PageUp),
-        CKey::PageDown => Some(BKey::PageDown),
-        CKey::Tab | CKey::BackTab => Some(BKey::Tab),
-        CKey::Delete => Some(BKey::Delete),
-        CKey::Insert => Some(BKey::Insert),
-        CKey::F(num) => match num {
-            1 => Some(BKey::F1),
-            2 => Some(BKey::F2),
-            3 => Some(BKey::F3),
-            4 => Some(BKey::F4),
-            5 => Some(BKey::F5),
-            6 => Some(BKey::F6),
-            7 => Some(BKey::F7),
-            8 => Some(BKey::F8),
-            9 => Some(BKey::F9),
-            10 => Some(BKey::F10),
-            11 => Some(BKey::F11),
-            12 => Some(BKey::F12),
-            13 => Some(BKey::F13),
-            14 => Some(BKey::F14),
-            15 => Some(BKey::F15),
-            16 => Some(BKey::F16),
-            17 => Some(BKey::F17),
-            18 => Some(BKey::F18),
-            19 => Some(BKey::F19),
-            20 => Some(BKey::F20),
-            21 => Some(BKey::F21),
-            22 => Some(BKey::F22),
-            23 => Some(BKey::F23),
-            24 => Some(BKey::F24),
-            25 => Some(BKey::F25),
-            26 => Some(BKey::F26),
-            27 => Some(BKey::F27),
-            28 => Some(BKey::F28),
-            29 => Some(BKey::F29),
-            30 => Some(BKey::F30),
-            31 => Some(BKey::F31),
-            32 => Some(BKey::F32),
-            33 => Some(BKey::F33),
-            34 => Some(BKey::F34),
-            35 => Some(BKey::F35),
-            _ => None,
-        },
-        CKey::Char(c) => Some(BKey::Character(SmolStr::from(c.encode_utf8(&mut [0; 4])))),
-        CKey::Null => None,
-        CKey::Esc => Some(BKey::Escape),
-        CKey::CapsLock => Some(BKey::CapsLock),
-        CKey::ScrollLock => Some(BKey::ScrollLock),
-        CKey::NumLock => Some(BKey::NumLock),
-        CKey::PrintScreen => Some(BKey::PrintScreen),
-        CKey::Pause => Some(BKey::Pause),
-        CKey::Menu => Some(BKey::ContextMenu),
-        CKey::KeypadBegin => None,
-        CKey::Media(media) => match media {
-            MediaKeyCode::Play => Some(BKey::MediaPlayPause),
-            MediaKeyCode::Pause => Some(BKey::Pause),
-            MediaKeyCode::PlayPause => Some(BKey::MediaPlayPause),
-            MediaKeyCode::Reverse => None,
-            MediaKeyCode::Stop => Some(BKey::MediaStop),
-            MediaKeyCode::FastForward => Some(BKey::MediaTrackNext),
-            MediaKeyCode::Rewind => Some(BKey::MediaTrackPrevious),
-            MediaKeyCode::TrackNext => Some(BKey::MediaTrackNext),
-            MediaKeyCode::TrackPrevious => Some(BKey::MediaTrackPrevious),
-            MediaKeyCode::Record => None,
-            MediaKeyCode::LowerVolume => Some(BKey::AudioVolumeDown),
-            MediaKeyCode::RaiseVolume => Some(BKey::AudioVolumeUp),
-            MediaKeyCode::MuteVolume => Some(BKey::AudioVolumeMute),
-        },
-        CKey::Modifier(modifier) => match modifier {
-            ModifierKeyCode::LeftShift => Some(BKey::Shift),
-            ModifierKeyCode::LeftControl => Some(BKey::Control),
-            ModifierKeyCode::LeftAlt => Some(BKey::Alt),
-            ModifierKeyCode::LeftSuper => Some(BKey::Super),
-            ModifierKeyCode::LeftHyper => Some(BKey::Hyper),
-            ModifierKeyCode::LeftMeta => Some(BKey::Meta),
-            ModifierKeyCode::RightShift => Some(BKey::Shift),
-            ModifierKeyCode::RightControl => Some(BKey::Control),
-            ModifierKeyCode::RightAlt => Some(BKey::Alt),
-            ModifierKeyCode::RightSuper => Some(BKey::Super),
-            ModifierKeyCode::RightHyper => Some(BKey::Hyper),
-            ModifierKeyCode::RightMeta => Some(BKey::Meta),
-            ModifierKeyCode::IsoLevel3Shift => Some(BKey::AltGraph),
-            ModifierKeyCode::IsoLevel5Shift => None,
-        },
     }
 }

src/lib.rs

@@ -4,28 +4,23 @@
 
 use std::{
     fs::OpenOptions,
-    io::{stdout, Write},
     path::PathBuf,
+    sync::{Arc, Mutex},
 };
 
 use bevy::{
     log::{
-        tracing_subscriber::{self, layer::SubscriberExt, EnvFilter, Layer, Registry},
+        tracing_subscriber::{self, prelude::*, Registry},
-        Level,
+        Level, LogPlugin,
     },
     prelude::*,
-    utils::tracing::subscriber,
+    utils::tracing::level_filters::LevelFilter,
 };
 use bevy_dither_post_process::DitherPostProcessPlugin;
+use bevy_framebuffer_extract::FramebufferExtractPlugin;
 
-use bevy_headless_render::HeadlessRenderPlugin;
-use color_eyre::config::HookBuilder;
 pub use crossterm;
-use crossterm::{
+use once_cell::sync::Lazy;
-    event::{DisableMouseCapture, PopKeyboardEnhancementFlags},
-    terminal::{disable_raw_mode, LeaveAlternateScreen},
-    ExecutableCommand,
-};
 pub use ratatui;
 
 /// Functions and types related to capture and display of world to terminal
@@ -37,6 +32,8 @@ pub mod input;
 /// Functions and types related to constructing and rendering TUI widgets
 pub mod widgets;
 
+static LOG_PATH: Lazy<Arc<Mutex<PathBuf>>> = Lazy::new(|| Arc::new(Mutex::new(PathBuf::default())));
+
 /// Plugin providing terminal display functionality
 pub struct TerminalDisplayPlugin {
     /// Path to redirect tracing logs to. Defaults to "debug.log"
@@ -53,67 +50,46 @@ impl Default for TerminalDisplayPlugin {
 
 impl Plugin for TerminalDisplayPlugin {
     fn build(&self, app: &mut App) {
-        let log_path = self.log_path.clone();
+        *LOG_PATH
-        let log_file = OpenOptions::new()
+            .lock()
-            .write(true)
+            .expect("Failed to get lock on log path mutex") = self.log_path.clone();
-            .create(true)
+        app.add_plugins((
-            .truncate(true)
+            DitherPostProcessPlugin,
-            .open(log_path)
+            FramebufferExtractPlugin,
-            .unwrap();
+            LogPlugin {
-        let file_layer = tracing_subscriber::fmt::Layer::new()
+                update_subscriber: Some(|_| {
-            .with_writer(log_file)
+                    let log_file = OpenOptions::new()
-            .with_filter(EnvFilter::builder().parse_lossy(format!(
+                        .write(true)
-                "{},{}",
+                        .create(true)
-                Level::INFO,
+                        .truncate(true)
-                "wgpu=error,naga=warn"
+                        .open(
-            )));
+                            LOG_PATH
-        let subscriber = Registry::default().with(file_layer);
+                                .lock()
-        subscriber::set_global_default(subscriber).unwrap();
+                                .expect("Failed to get lock on log path mutex")
-
+                                .clone(),
-        let (panic, error) = HookBuilder::default().into_hooks();
+                        )
-        let panic = panic.into_panic_hook();
+                        .unwrap();
-        let error = error.into_eyre_hook();
+                    let file_layer = tracing_subscriber::fmt::Layer::new()
-
+                        .with_writer(log_file)
-        color_eyre::eyre::set_hook(Box::new(move |e| {
+                        .with_filter(LevelFilter::from_level(Level::INFO));
-            restore_terminal();
+                    Box::new(Registry::default().with(file_layer))
-            error(e)
+                }),
-        }))
+                ..Default::default()
-        .unwrap();
+            },
-
+        ))
-        std::panic::set_hook(Box::new(move |info| {
+        .add_systems(Startup, input::systems::setup_input)
-            restore_terminal();
+        .add_systems(
-            error!("{info}");
+            Update,
-            panic(info);
+            (
-        }));
+                input::systems::input_handling,
-
+                display::systems::resize_handling,
-        app.add_plugins((DitherPostProcessPlugin, HeadlessRenderPlugin))
+                display::systems::print_to_terminal,
-            .add_systems(Startup, input::systems::setup_input)
+                widgets::systems::widget_input_handling,
-            .add_systems(
+            ),
-                Update,
+        )
-                (
+        .insert_resource(display::resources::Terminal::default())
-                    input::systems::input_handling,
+        .insert_resource(input::resources::EventQueue::default())
-                    display::systems::resize_handling,
+        .insert_resource(input::resources::TerminalInput::default())
-                    display::systems::print_to_terminal,
+        .add_event::<input::events::TerminalInputEvent>();
-                    widgets::systems::widget_input_handling,
-                    widgets::systems::update_widgets,
-                ),
-            )
-            .insert_resource(display::resources::Terminal::default())
-            .insert_resource(input::resources::EventQueue::default())
-            .init_resource::<widgets::resources::FocusedWidget>()
-            .add_event::<input::events::TerminalInputEvent>();
     }
 }
-
-fn restore_terminal() {
-    let _ = disable_raw_mode();
-    let mut stdout = stdout();
-    let _ = stdout
-        .execute(PopKeyboardEnhancementFlags)
-        .unwrap()
-        .execute(DisableMouseCapture)
-        .unwrap()
-        .execute(LeaveAlternateScreen)
-        .unwrap()
-        .flush();
-}

src/widgets/commands.rs

@@ -1,23 +0,0 @@
-use bevy::prelude::*;
-
-use super::resources::FocusedWidget;
-
-struct FocusWidgetCommand(Entity);
-
-impl Command for FocusWidgetCommand {
-    fn apply(self, world: &mut World) {
-        **world.resource_mut::<FocusedWidget>() = Some(self.0);
-    }
-}
-
-/// Command interface for manipulating terminal widget resources
-pub trait TerminalWidgetCommands {
-    /// Gives focus to the terminal widget on the provided entity.
-    fn focus_widget(&mut self, widget: Entity);
-}
-
-impl TerminalWidgetCommands for Commands<'_, '_> {
-    fn focus_widget(&mut self, widget: Entity) {
-        self.queue(FocusWidgetCommand(widget));
-    }
-}

src/widgets/mod.rs

@@ -7,15 +7,9 @@ use crate::input::events::TerminalInputEvent;
 /// Components for this module
 pub mod components;
 
-/// Resources for this module
-pub mod resources;
-
 /// Systems for this module
 pub(crate) mod systems;
 
-/// Commands for this module
-pub mod commands;
-
 /// Trait which defines an interface for terminal widgets
 pub trait TerminalWidget: DowncastSync {
     /// Called every frame to render the widget
@@ -23,8 +17,5 @@ pub trait TerminalWidget: DowncastSync {
 
     /// Called when a terminal input event is invoked to update any state accordingly
     fn handle_events(&mut self, _event: &TerminalInputEvent, _commands: &mut Commands) {}
-
-    /// Called every frame during the Update schedule
-    fn update(&mut self, _time: &Time, _commands: &mut Commands) {}
 }
 impl_downcast!(sync TerminalWidget);

src/widgets/resources.rs

@@ -1,7 +0,0 @@
-use bevy::prelude::*;
-
-/// Terminal widget entity currently focused and handling input
-/// Can be manipulated directly or you can request an entity be focused through
-/// the `focus_widget` command.
-#[derive(Resource, Default, Deref, DerefMut, Debug)]
-pub struct FocusedWidget(pub Option<Entity>);

src/widgets/systems.rs

@@ -2,28 +2,17 @@ use bevy::prelude::*;
 
 use crate::input::events::TerminalInputEvent;
 
-use super::{components::Widget, resources::FocusedWidget};
+use super::components::Widget;
 
-/// Invokes focused widget's `handle_events` methods for each incoming input event
+/// Invokes every enabled widget's `handle_events` methods for each incoming input event
 pub fn widget_input_handling(
     mut widgets: Query<&mut Widget>,
     mut event_reader: EventReader<TerminalInputEvent>,
     mut commands: Commands,
-    focused_widget: Res<FocusedWidget>,
 ) {
-    if let Some(entity) = **focused_widget {
+    for event in event_reader.read() {
-        if let Ok(mut widget) = widgets.get_mut(entity) {
+        for mut widget in widgets.iter_mut().filter(|widget| widget.enabled) {
-            if widget.enabled {
+            widget.widget.handle_events(event, &mut commands);
-                for event in event_reader.read() {
-                    widget.widget.handle_events(event, &mut commands);
-                }
-            }
         }
     }
 }
-
-pub fn update_widgets(mut widgets: Query<&mut Widget>, time: Res<Time>, mut commands: Commands) {
-    for mut widget in widgets.iter_mut() {
-        widget.widget.update(&time, &mut commands);
-    }
-}