Release

.drone.yml

@@ -1,42 +0,0 @@
-kind: pipeline
-type: docker
-name: default
-
-steps:
-  - name: test
-    image: rust
-    pull: always
-    commands:
-      - rustup component add clippy rustfmt
-      - apt-get update -qq
-      - apt-get install -qqy llvm-dev libclang-dev clang libspeechd-dev pkg-config libx11-dev libasound2-dev libudev-dev libxcb-xfixes0-dev libwayland-dev libxkbcommon-dev libvulkan-dev libpulse-dev
-      - cargo fmt --check
-      - cargo test --no-default-features --features=speech_dispatcher_0_10
-      - cargo clippy --no-default-features --features=speech_dispatcher_0_10
-  - name: release
-    image: rust
-    pull: always
-    commands:
-      - cargo publish --no-verify
-    when:
-      ref:
-        - refs/tags/v*
-    environment:
-      CARGO_REGISTRY_TOKEN:
-        from_secret: cargo_registry_token
-  - name: discord notification
-    image: appleboy/drone-discord
-    when:
-      status: [success, failure]
-    settings:
-      webhook_id:
-        from_secret: discord_webhook_id
-      webhook_token:
-        from_secret: discord_webhook_token
-      tts: true
-      message: >
-        {{#success build.status}}
-          {{repo.name}} build {{build.number}} succeeded: <{{build.link}}>
-        {{else}}
-          {{repo.name}} build {{build.number}} failed: <{{build.link}}>
-        {{/success}}

.gitea/workflows/release.yml

@@ -0,0 +1,39 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v[0-9]+.[0-9]+.[0-9]+*"
+  workflow_dispatch:
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: ~/.cache/pre-commit
+          key: pre-commit|${{ env.PY }}|${{ hashFiles('.pre-commit-config.yaml') }}
+      - 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') }}
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: stable
+          components: rustfmt, clippy
+      - name: install Linux build dependencies
+        run: sudo apt-get update; sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev libwayland-dev libclang-dev libspeechd-dev
+        if: runner.os == 'linux'
+      - uses: actions/setup-python@v3
+      - uses: pre-commit/action@v3.0.1
+      - name: Publish
+        run: cargo publish
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}

.gitea/workflows/test.yml

@@ -0,0 +1,37 @@
+name: Test
+
+on:
+  pull_request:
+  push:
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        # os: [windows-latest, ubuntu-latest, macos-latest]
+        os: [ubuntu-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: ~/.cache/pre-commit
+          key: pre-commit|${{ env.PY }}|${{ hashFiles('.pre-commit-config.yaml') }}
+      - 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') }}
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: stable
+          components: rustfmt, clippy
+      - name: install Linux build dependencies
+        run: sudo apt-get update; sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev libwayland-dev libclang-dev libspeechd-dev
+        if: runner.os == 'linux'
+      - uses: actions/setup-python@v3
+      - uses: pre-commit/action@v3.0.1

.pre-commit-config.yaml

@@ -0,0 +1,10 @@
+fail_fast: true
+repos:
+  - repo: https://github.com/doublify/pre-commit-rust
+    rev: v1.0
+    hooks:
+      - id: fmt
+        args: [--, --check]
+      - id: cargo-check
+        args: [--bins, --examples]
+      - id: clippy

CHANGELOG.md

@@ -2,6 +2,54 @@
 
 All notable changes to this project will be documented in this file.
 
+## Version 0.10.0 - 2024-12-05
+
+### Features
+
+- `Tts` can now be used as a component, and multiple TTS instances are supported.
+
+### Miscellaneous Tasks
+
+- Upgrade to Bevy 0.15.
+
+## Version 0.9.0 - 2024-07-07
+
+### Miscellaneous Tasks
+
+- Switch to Gitea Actions.
+- Integrate pre-commit.
+- Update to Bevy 0.14.
+
+## Version 0.8.0 - 2024-03-14
+
+### Miscellaneous Tasks
+
+- Upgrade to Bevy v0.13.
+
+## Version 0.7.0 - 2024-02-09
+
+### Miscellaneous Tasks
+
+- Bump dependencies.
+
+## Version 0.6.0 - 2023-07-16
+
+### Miscellaneous Tasks
+
+- Update to Bevy 0.11.
+
+## Version 0.5.0 - 2023-03-06
+
+### Miscellaneous Tasks
+
+- Update Bevy to 0.10.
+
+## Version 0.4.0 - 2022-12-20
+
+### Features
+
+- Make wrapped `Tts` instance public.
+
 ## Version 0.3.0 - 2022-12-20
 
 ### Features

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy_tts"
-version = "0.3.0"
+version = "0.10.0"
 description = "Text-to-speech for the Bevy game engine"
 repository = "https://labs.lightsout.games/projects/bevy_tts"
 authors = ["Nolan Darilek <nolan@thewordnerd.info>"]
@@ -17,12 +17,12 @@ speech_dispatcher_0_11 = ["tts/speech_dispatcher_0_11"]
 tolk = ["tts/tolk"]
 
 [dependencies]
-bevy = { version = "0.9", default-features = false }
+bevy = { version = "0.15", default-features = false }
 crossbeam-channel = "0.5"
-tts = { version = "0.25", default-features = false }
+tts = { version = "0.26", default-features = false }
 
 [dev-dependencies]
-bevy = { version = "0.9", default-features = true }
+bevy = { version = "0.15", default-features = true }
 
 [package.metadata.release]
 publish = false

examples/hello_world.rs

@@ -3,17 +3,25 @@ use bevy_tts::*;
 
 fn main() {
     App::new()
-        .add_plugins(DefaultPlugins)
+        .add_plugins((DefaultPlugins, bevy_tts::TtsPlugin))
-        .add_plugin(bevy_tts::TtsPlugin)
+        .add_systems(Startup, setup)
-        .add_system(bevy::window::close_on_esc)
+        .add_systems(Update, (event_poll, greet))
-        .add_startup_system(setup)
+        .add_observer(|trigger: Trigger<TtsEvent>| {
-        .add_system(event_poll)
+            println!("{:?}", trigger.event());
-        .add_system(greet)
+        })
         .run();
 }
 
 // Speaks a bunch of messages and changes TTS properties.
-fn setup(mut tts: ResMut<Tts>) {
+fn setup(mut commands: Commands, mut tts: ResMut<Tts>) {
+    let mut other_tts = Tts::default();
+    let Features { voice, .. } = other_tts.supported_features();
+    if voice {
+        let voices = other_tts.voices().unwrap();
+        let v = voices.last().unwrap();
+        other_tts.set_voice(&v.clone()).unwrap();
+    }
+    commands.spawn(other_tts);
     tts.speak("Hello, world.", false).unwrap();
     let Features { rate, .. } = tts.supported_features();
     if rate {
@@ -60,18 +68,30 @@ fn setup(mut tts: ResMut<Tts>) {
         tts.set_volume(original_volume).unwrap();
     }
     tts.speak("Press G for a greeting.", false).unwrap();
+    tts.speak(
+        "Press S to speak with a second voice, if you're lucky.",
+        false,
+    )
+    .unwrap();
 }
 
 // Reports events from TTS subsystem.
 fn event_poll(mut events: EventReader<TtsEvent>) {
-    for event in events.iter() {
+    for event in events.read() {
         println!("{:?}", event);
     }
 }
 
 // Shows how to output speech in response to a keypress.
-fn greet(input: Res<Input<KeyCode>>, mut tts: ResMut<Tts>) {
+fn greet(input: Res<ButtonInput<KeyCode>>, mut tts: ResMut<Tts>, mut speaker: Query<&mut Tts>) {
-    if input.just_pressed(KeyCode::G) {
+    if input.just_pressed(KeyCode::KeyG) {
         tts.speak("Hey there!", true).unwrap();
     }
+    if input.just_pressed(KeyCode::KeyS) {
+        if let Ok(mut speaker) = speaker.get_single_mut() {
+            speaker
+                .speak("Hey there from the TTS component!", true)
+                .unwrap();
+        }
+    }
 }

src/lib.rs

@@ -1,9 +1,19 @@
-use bevy::prelude::*;
+use bevy::{
+    ecs::{component::ComponentId, world::DeferredWorld},
+    prelude::*,
+};
 use crossbeam_channel::{unbounded, Receiver};
 pub use tts::{self, Backends, Error, Features, UtteranceId};
 
-#[derive(Resource, Clone, Deref, DerefMut)]
+#[derive(Component, Resource, Clone, Deref, DerefMut)]
-pub struct Tts(tts::Tts);
+#[component(on_add = on_tts_added, on_remove=on_tts_removed)]
+pub struct Tts(pub tts::Tts);
+
+impl Default for Tts {
+    fn default() -> Self {
+        Self(tts::Tts::default().unwrap())
+    }
+}
 
 impl Tts {
     pub fn screen_reader_available() -> bool {
@@ -11,53 +21,76 @@ impl Tts {
     }
 }
 
-#[derive(Debug)]
+#[derive(Event, Debug)]
 pub enum TtsEvent {
     UtteranceBegin(UtteranceId),
     UtteranceEnd(UtteranceId),
     UtteranceStop(UtteranceId),
 }
 
-#[derive(Resource)]
+#[derive(Component, Resource)]
 struct TtsChannel(Receiver<TtsEvent>);
 
-fn poll_callbacks(channel: Res<TtsChannel>, mut events: EventWriter<TtsEvent>) {
+fn on_tts_added(mut world: DeferredWorld, entity: Entity, _: ComponentId) {
+    let tts = &world.get::<Tts>(entity).unwrap();
+    let channel = setup_tts(tts);
+    world.commands().entity(entity).insert(channel);
+}
+
+fn on_tts_removed(mut world: DeferredWorld, entity: Entity, _: ComponentId) {
+    world.commands().entity(entity).remove::<TtsChannel>();
+}
+
+fn poll_callbacks(
+    mut commands: Commands,
+    channel: Res<TtsChannel>,
+    mut events: EventWriter<TtsEvent>,
+    speakers: Query<(Entity, &TtsChannel), With<Tts>>,
+) {
     if let Ok(msg) = channel.0.try_recv() {
         events.send(msg);
     }
+    for (entity, channel) in &speakers {
+        if let Ok(msg) = channel.0.try_recv() {
+            commands.entity(entity).trigger(msg);
+        }
+    }
 }
 
+fn setup_tts(tts: &Tts) -> TtsChannel {
+    let (tx, rx) = unbounded();
+    let tx_begin = tx.clone();
+    let tx_end = tx.clone();
+    let tx_stop = tx;
+    let Features {
+        utterance_callbacks,
+        ..
+    } = tts.supported_features();
+    if utterance_callbacks {
+        tts.on_utterance_begin(Some(Box::new(move |utterance| {
+            tx_begin.send(TtsEvent::UtteranceBegin(utterance)).unwrap();
+        })))
+        .unwrap();
+        tts.on_utterance_end(Some(Box::new(move |utterance| {
+            tx_end.send(TtsEvent::UtteranceEnd(utterance)).unwrap();
+        })))
+        .unwrap();
+        tts.on_utterance_stop(Some(Box::new(move |utterance| {
+            tx_stop.send(TtsEvent::UtteranceStop(utterance)).unwrap();
+        })))
+        .unwrap();
+    }
+    TtsChannel(rx)
+}
 pub struct TtsPlugin;
 
 impl Plugin for TtsPlugin {
     fn build(&self, app: &mut App) {
-        let tts = tts::Tts::default().unwrap();
+        let tts = Tts::default();
-        let (tx, rx) = unbounded();
+        let channel = setup_tts(&tts);
-        let tx_begin = tx.clone();
-        let tx_end = tx.clone();
-        let tx_stop = tx;
-        let Features {
-            utterance_callbacks,
-            ..
-        } = tts.supported_features();
-        if utterance_callbacks {
-            tts.on_utterance_begin(Some(Box::new(move |utterance| {
-                tx_begin.send(TtsEvent::UtteranceBegin(utterance)).unwrap();
-            })))
-            .unwrap();
-            tts.on_utterance_end(Some(Box::new(move |utterance| {
-                tx_end.send(TtsEvent::UtteranceEnd(utterance)).unwrap();
-            })))
-            .unwrap();
-            tts.on_utterance_stop(Some(Box::new(move |utterance| {
-                tx_stop.send(TtsEvent::UtteranceStop(utterance)).unwrap();
-            })))
-            .unwrap();
-        }
-        let tts = Tts(tts);
         app.add_event::<TtsEvent>()
-            .insert_resource(TtsChannel(rx))
+            .insert_resource(channel)
             .insert_resource(tts)
-            .add_system(poll_callbacks);
+            .add_systems(Update, poll_callbacks);
     }
 }