.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,19 @@
 [package]
 name = "bevy_terminal_display"
-version = "0.7.0"
+version = "0.4.2"
 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"
+repository = "https://github.com/exvacuum/bevy_terminal_display"
-
-[profile.dev]
-opt-level = 1
-
-[profile.dev.package."*"]
-opt-level = 2
 
 [dependencies]
 crossbeam-channel = "0.5"
-downcast-rs = "2.0"
+crossterm = "0.27"
+downcast-rs = "1.2"
 once_cell = "1.19"
-ratatui = "0.29"
+bevy = "0.14"
+bevy_headless_render = "0.1"
+bevy_dither_post_process = "0.2"
+ratatui = "0.26"
 color-eyre = "0.6"
-leafwing-input-manager = "0.16"
-serde = "1.0"
-smol_str = "0.2"
 
-[dependencies.bevy]
-version = "0.15"
-default-features = false
-features = ["bevy_render"]
-
-[dependencies.crossterm]
-version = "0.28"
-features = ["serde"]
-
-# SOAOS DEPS
-
-[dependencies.bevy_dither_post_process]
-version = "0.3"
-
-[dependencies.bevy_headless_render]
-version = "0.2"

README.md

@@ -2,13 +2,16 @@
 
 [![Crates](https://img.shields.io/crates/v/bevy_terminal_display)](https://crates.io/crates/bevy_terminal_display)
 ![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
@@ -17,13 +20,12 @@ Features Include:
 - Log redirection
 
 ## Screenshots
-![](doc/screenshot.png)
+![](./doc/screenshot.png)
 ## Compatibility
 
 | Crate Version | Bevy Version |
-| ------------- | ------------ |
+|---            |---           |
-| 0.6-0.7       | 0.15         |
+| 0.3-0.4       | 0.14         |
-| 0.4           | 0.14         |
 | 0.2           | 0.13         |
 
 ## Installation
@@ -31,13 +33,13 @@ Features Include:
 ### crates.io
 ```toml
 [dependencies]
-bevy_terminal_display = "0.7"
+bevy_terminal_display = "0.3"
 ```
 
 ### 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
@@ -54,15 +56,24 @@ fn main() {
             ScheduleRunnerPlugin::run_loop(Duration::from_secs_f32(1.0 / 60.0)),
             bevy_terminal_display::TerminalDisplayPlugin::default(),
         ))
+        .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,
 ));
 ```
 

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_headless_render::{components::{HeadlessRenderBundle, HeadlessRenderDestination}, render_assets::HeadlessRenderSource};
-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,
+    _headless_render_bundle: HeadlessRenderBundle,
+    _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(HeadlessRenderSource(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
+            _headless_render_bundle: HeadlessRenderBundle {
-        .commands()
+                source: framebuffer_extract_source,
-        .entity(entity)
+                dest: HeadlessRenderDestination::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,16 @@ use bevy::{
     prelude::*,
     render::render_resource::{Extent3d, TextureFormat},
 };
-use bevy_headless_render::{
+use bevy_headless_render::{components::HeadlessRenderDestination, render_assets::HeadlessRenderSource};
-    components::HeadlessRenderDestination, render_assets::HeadlessRenderSource,
-};
 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 +25,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<&HeadlessRenderDestination>,
     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 +44,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 +64,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

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,56 @@
-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>,
+    just_pressed_keys: HashSet<KeyCode>,
+    just_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 was just pressed
+    pub fn just_pressed(&self, code: KeyCode) -> bool {
+        self.just_pressed_keys.contains(&code)
+    }
+
+    /// Gets whether the given key was just released
+    pub fn just_released(&self, code: KeyCode) -> bool {
+        self.just_released_keys.contains(&code)
+    }
+
+    /// Sets given key to pressed
+    pub(super) fn press(&mut self, code: KeyCode) {
+        if !self.pressed_keys.contains(&code) {
+            self.pressed_keys.insert(code);
+            self.just_pressed_keys.insert(code);
+        }
+    }
+
+    /// Sets given key to released and removes pressed state
+    pub(super) fn release(&mut self, code: KeyCode) {
+        self.pressed_keys.remove(&code);
+        self.just_released_keys.insert(code);
+    }
+
+    /// Clears all just released keys
+    pub(super) fn clear_just_released(&mut self) {
+        self.just_released_keys.clear();
+    }
+
+    /// Clears all just pressed keys
+    pub(super) fn clear_just_pressed(&mut self) {
+        self.just_pressed_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,12 @@
 use std::cmp::Ordering;
 
-use bevy::{
+use bevy::prelude::*;
-    input::{keyboard::KeyboardInput, ButtonState},
+use crossterm::event::{read, Event, KeyEvent, KeyEventKind};
-    prelude::*,
-};
-use crossterm::event::{read, Event, KeyEvent, KeyEventKind, MediaKeyCode, ModifierKeyCode};
-use smol_str::SmolStr;
 
-use super::{components::DummyWindow, events::TerminalInputEvent, resources::EventQueue};
+use super::{events::TerminalInputEvent, resources::{EventQueue, TerminalInput}};
 
 /// 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 +26,30 @@ 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_just_released();
+    input.clear_just_pressed();
     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);
         }
-        terminal_event_writer.send(TerminalInputEvent(event));
+        event_writer.send(TerminalInputEvent(event));
     }
 
     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) {
+        match event.kind {
-            if let Some(logical_key) = crossterm_keycode_to_bevy_key(event.code) {
+            KeyEventKind::Press => {
-                match event.kind {
+                input.press(event.code);
-                    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);
+            }
+            _ => (),
         }
     }
 }
-
-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

@@ -3,29 +3,22 @@
 //! Bevy plugin which allows a camera to render to a terminal window.
 
 use std::{
-    fs::OpenOptions,
+    fs::OpenOptions, io::stdout, path::PathBuf, sync::{Arc, Mutex}
-    io::{stdout, Write},
-    path::PathBuf,
 };
 
 use bevy::{
     log::{
         tracing_subscriber::{self, layer::SubscriberExt, EnvFilter, Layer, Registry},
         Level,
-    },
+    }, prelude::*, utils::tracing::subscriber,
-    prelude::*,
-    utils::tracing::subscriber,
 };
 use bevy_dither_post_process::DitherPostProcessPlugin;
 
 use bevy_headless_render::HeadlessRenderPlugin;
 use color_eyre::config::HookBuilder;
 pub use crossterm;
-use crossterm::{
+use crossterm::{event::{DisableMouseCapture, PopKeyboardEnhancementFlags}, terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen}, ExecutableCommand};
-    event::{DisableMouseCapture, PopKeyboardEnhancementFlags},
+use once_cell::sync::Lazy;
-    terminal::{disable_raw_mode, LeaveAlternateScreen},
-    ExecutableCommand,
-};
 pub use ratatui;
 
 /// Functions and types related to capture and display of world to terminal
@@ -37,6 +30,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,20 +48,23 @@ impl Default for TerminalDisplayPlugin {
 
 impl Plugin for TerminalDisplayPlugin {
     fn build(&self, app: &mut App) {
-        let log_path = self.log_path.clone();
+        *LOG_PATH
+            .lock()
+            .expect("Failed to get lock on log path mutex") = self.log_path.clone();
         let log_file = OpenOptions::new()
             .write(true)
             .create(true)
             .truncate(true)
-            .open(log_path)
+            .open(
+                LOG_PATH
+                    .lock()
+                    .expect("Failed to get lock on log path mutex")
+                    .clone(),
+            )
             .unwrap();
         let file_layer = tracing_subscriber::fmt::Layer::new()
             .with_writer(log_file)
-            .with_filter(EnvFilter::builder().parse_lossy(format!(
+            .with_filter(EnvFilter::builder().parse_lossy(format!("{},{}", Level::INFO, "wgpu=error,naga=warn")));
-                "{},{}",
-                Level::INFO,
-                "wgpu=error,naga=warn"
-            )));
         let subscriber = Registry::default().with(file_layer);
         subscriber::set_global_default(subscriber).unwrap();
 
@@ -75,45 +73,40 @@ impl Plugin for TerminalDisplayPlugin {
         let error = error.into_eyre_hook();
 
         color_eyre::eyre::set_hook(Box::new(move |e| {
-            restore_terminal();
+            let _ = restore_terminal();
             error(e)
-        }))
+        })).unwrap();
-        .unwrap();
 
         std::panic::set_hook(Box::new(move |info| {
-            restore_terminal();
+            let _ = restore_terminal();
-            error!("{info}");
             panic(info);
         }));
-
+        
-        app.add_plugins((DitherPostProcessPlugin, HeadlessRenderPlugin))
+        app.add_plugins((
-            .add_systems(Startup, input::systems::setup_input)
+            DitherPostProcessPlugin,
-            .add_systems(
+            HeadlessRenderPlugin,
-                Update,
+        ))
-                (
+        .add_systems(Startup, input::systems::setup_input)
-                    input::systems::input_handling,
+        .add_systems(
-                    display::systems::resize_handling,
+            Update,
-                    display::systems::print_to_terminal,
+            (
-                    widgets::systems::widget_input_handling,
+                input::systems::input_handling,
-                    widgets::systems::update_widgets,
+                display::systems::resize_handling,
-                ),
+                display::systems::print_to_terminal,
-            )
+                widgets::systems::widget_input_handling,
-            .insert_resource(display::resources::Terminal::default())
+            ),
-            .insert_resource(input::resources::EventQueue::default())
+        )
-            .init_resource::<widgets::resources::FocusedWidget>()
+        .insert_resource(display::resources::Terminal::default())
-            .add_event::<input::events::TerminalInputEvent>();
+        .insert_resource(input::resources::EventQueue::default())
+        .insert_resource(input::resources::TerminalInput::default())
+        .add_event::<input::events::TerminalInputEvent>();
     }
 }
 
 fn restore_terminal() {
-    let _ = disable_raw_mode();
     let mut stdout = stdout();
-    let _ = stdout
+    let _ = stdout.execute(PopKeyboardEnhancementFlags);
-        .execute(PopKeyboardEnhancementFlags)
+    let _ = stdout.execute(DisableMouseCapture);
-        .unwrap()
+    let _ = stdout.execute(LeaveAlternateScreen);
-        .execute(DisableMouseCapture)
+    let _ = disable_raw_mode();
-        .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);
-    }
-}