add debug information about voice chat

audio/src/lib.rs

···
 use bevy::{app::{App, Plugin, Startup, Update}, ecs::{component::Component, system::{Commands, Query}}, math::{Quat, Vec3}, transform::components::Transform};
-use cpal::{BufferSize, SampleRate, StreamConfig};
-use kira::{AudioManager, AudioManagerSettings, DefaultBackend, Tween, backend::cpal::CpalBackendSettings, listener::ListenerHandle};
+use kira::{AudioManager, AudioManagerSettings, DefaultBackend, Tween, listener::ListenerHandle};
 
 use crate::source::FelixAudioSource;
 
···
 pub mod source;
 pub mod utils;
 pub mod voice;
+
+// TODO: Make this use HRTF at some point
+//       Maybe revisit steam audio?
+//       Or just find some other library that does HRTFs.
 
 fn update_audio_system(
   mut audio_system: Query<&mut FelixAudioComponent>,
···
 impl Plugin for FelixAudio{
   fn build(&self, app: &mut App) {
     app.add_systems(Startup, move | mut commands: Commands | {
-      let mut settings = AudioManagerSettings::default();
-      settings.backend_settings = CpalBackendSettings {
-        config: Some(StreamConfig {
-          channels: 2,
-          sample_rate: SampleRate(48_000),
-          buffer_size: BufferSize::Fixed(512)
-        }),
-        ..Default::default()
-      };
-
-      let mut manager = AudioManager::<DefaultBackend>::new(settings).unwrap();
+      let mut manager = AudioManager::<DefaultBackend>::new(AudioManagerSettings::default()).unwrap();
       let main_listener = manager.add_listener(Vec3::default(), Quat::default()).unwrap();
 
       let handle = FelixAudioComponent { manager, main_listener };

audio/src/voice/decoder.rs

···
-use std::{collections::VecDeque, sync::{Arc, Mutex, mpsc::{Sender, channel}}, thread};
+use std::{collections::VecDeque, sync::{Arc, Mutex, RwLock, mpsc::{Sender, channel}}, thread};
 
 use opus::{Channels, Decoder};
 
 use crate::{MONO_20MS, SAMPLE_RATE};
 
 pub struct VoiceChatDecoder{
-  stream_in: Sender<Vec<u8>>
+  stream_in: Sender<Vec<u8>>,
+  last_rms: Arc<RwLock<f32>>
 }
 
 impl VoiceChatDecoder{
···
     let mut decoder = Decoder::new(SAMPLE_RATE as u32, Channels::Mono).unwrap();
     let ( stream_in, stream_out ) = channel();
 
+    let set_rms = Arc::new(RwLock::new(0.0));
+    let set_rms_1 = set_rms.clone();
+
     thread::spawn(move || {
       let mut buffer = [0.0; MONO_20MS];
 
···
         let packet: Vec<u8> = stream_out.recv().unwrap();
         decoder.decode_float(&packet, &mut buffer, false).unwrap();
 
+        let mut total = 0.0;
+        for sample in buffer{ total += sample.powi(2) }
+        *set_rms.write().unwrap() = ( total / buffer.len() as f32 ).sqrt();
+
         let mut voice = queue.lock().unwrap();
         for sample in buffer{ voice.push_back(sample); }
       }
     });
 
-    Self { stream_in }
+    Self {
+      stream_in,
+      last_rms: set_rms_1
+    }
   }
 
   pub fn decode( &self, packet: Vec<u8> ){
     self.stream_in.send(packet).unwrap();
+  }
+
+  pub fn get_last_rms( &self ) -> f32{
+    *self.last_rms.read().unwrap()
   }
 }

audio/src/voice/microphone.rs

···
-use std::{env, net::{ToSocketAddrs, UdpSocket}, sync::{Arc, Mutex}};
+use std::{env, net::{ToSocketAddrs, UdpSocket}, sync::{Arc, Mutex, RwLock}};
 
 use bevy::ecs::component::Component;
 use cpal::{BufferSize, SampleRate, Stream, StreamConfig, traits::{DeviceTrait, HostTrait, StreamTrait}};
···
 pub struct VoiceChatMicrophone{
   stream: Option<Stream>,
   udp: Option<UdpSocket>,
-  muted: Arc<Mutex<bool>>
+  muted: Arc<Mutex<bool>>,
+  last_rms: Arc<RwLock<isize>>
 }
 
 impl VoiceChatMicrophone{
···
     Self {
       stream: None,
       udp: Some(socket),
-      muted: Arc::new(Mutex::new(false))
+      muted: Arc::new(Mutex::new(false)), // TODO: Default to muted
+      last_rms: Arc::new(RwLock::new(0))
     }
   }
 
···
     let mut encoder = Encoder::new(SAMPLE_RATE as u32, Channels::Mono, Application::Voip)?;
 
     let host = cpal::default_host();
-    let mic = host.default_input_device().unwrap();
+
+    let mut i = 0;
+    let devices = host.input_devices().unwrap();
+    for device in devices{
+      println!("{}) {:?}", i, device.name());
+      i += 1;
+    }
+
+    let mut devices = host.input_devices().unwrap();
+    let mic = if let Ok(device_index) = env::var("MIC_INDEX"){
+      devices.nth(device_index.parse()?).unwrap()
+    } else{
+      host.default_input_device().unwrap()
+    };
+
+    println!("Using Device: {:?}", mic.name());
 
     let mut output = [0; 512];
 
···
 
     let addr = env::var("HOST")?.to_socket_addrs()?.nth(0).unwrap();
 
+    for conf in mic.supported_input_configs().unwrap(){
+      println!("{} {:?} {} {:?}", conf.channels(), conf.buffer_size(), conf.sample_format(), conf.with_max_sample_rate());
+    }
+
+    let set_rms = self.last_rms.clone();
+
     let stream = mic.build_input_stream(
       &StreamConfig {
         channels: 1,
···
 
             if buffer_indx >= MONO_20MS{
               buffer_indx = 0;
+
+              let mut total = 0;
+              for sample in buffer{ total += (sample as isize).pow(2) }
+              *set_rms.write().unwrap() = ( total / buffer.len() as isize ).isqrt();
 
               let len = encoder.encode(&buffer, &mut output).unwrap();
               let buf_to_send = output[0..len].to_vec();
···
     self.stream = Some(stream);
 
     Ok(())
+  }
+
+  pub fn get_rms_of_last_packet( &self ) -> f32{
+    *self.last_rms.read().unwrap() as f32 / i16::MAX as f32
   }
 }

client/src/components/debug_camera.rs

···
 use std::f32::consts::PI;
 
 use bevy::{ input::mouse::MouseMotion, prelude::* };
+use felix_audio::voice::microphone::VoiceChatMicrophone;
+
+use crate::net::connection::Connection;
 
 #[derive(Component)]
 pub struct DebugCamera{
···
   keys: Res<ButtonInput<KeyCode>>,
   mouse_buttons: Res<ButtonInput<MouseButton>>,
   mut mouse_motion: MessageReader<MouseMotion>,
+
+  // Debug Text
+  mut debug_text: Query<(&mut Text, &DebugText)>,
+  voice: Query<&VoiceChatMicrophone>,
+  networking: Query<&Connection>,
 ){
+  let net_manager = networking.single().unwrap();
+
   let mut delta_time = time.delta_secs();
   if keys.pressed(KeyCode::ShiftLeft){ delta_time *= 2.0; }
 
···
     let dir = -transform.up();
     transform.translation += dir * delta_time;
   }
+
+  let mut remote_rms = "".to_owned();
+  for id in net_manager.get_remote_player_voice_ids(){
+    remote_rms += format!("{}: {:.4}\n", id, net_manager.get_remote_player_voice_rms(&id)).as_str();
+  }
+
+  let rms = if let Ok(mic) = voice.single(){
+    mic.get_rms_of_last_packet()
+  } else{
+    -1.0
+  };
+
+  let ( mut text, _ ) = debug_text.single_mut().unwrap();
+  text.0 = format!(
+"Microphone RMS: {:.4}
+{}Position: {:.2} {:.2} {:.2}
+Rotation: {:.2} {:.2} {:.2} {:.2}",
+    rms,
+
+    remote_rms,
+
+    transform.translation.x,
+    transform.translation.y,
+    transform.translation.z,
+
+    transform.rotation.x,
+    transform.rotation.y,
+    transform.rotation.z,
+    transform.rotation.w
+  );
+}
+
+#[derive(Component)]
+pub struct DebugText;
+
+pub fn setup(
+  mut commands: Commands
+){
+  commands.spawn((
+    Node {
+      position_type: PositionType::Absolute,
+      bottom: px(5.0),
+      right: px(5.0),
+      ..default()
+    },
+    Text::new("Here is some text"),
+    TextColor(Color::WHITE),
+    TextLayout::new_with_justify(Justify::Right),
+    DebugText
+  ));
 }

client/src/components/network_interface.rs

···
         let mut lock = listener.lock().unwrap();
 
         for i in 0..buf.len(){
-          buf[i] = lock.pop_front().unwrap(); }
+          buf[i] = lock.pop_front().unwrap_or(0.0); }
 
         buf
       }))

client/src/main.rs

···
 mod net;
 
 fn main() {
-  dotenvy::dotenv().unwrap();
+  if let Err(err) = dotenvy::dotenv(){ println!("[WARN] .ENV failed loading {:#?}", err); }
 
   App::new()
     .add_plugins((
···
     ))
     .add_systems(Startup, setup)
     .add_systems(Startup, move | mut commands: Commands |{
-      let ( comp, voice ) = net::handle_net().expect("Network Module Failed.");
-
+      let ( comp, voice ) = net::handle_net().expect("Network Module Failed");
       commands.spawn(comp);
-      commands.spawn(voice::init_microphone(voice).expect("Failed to start microphone."));
+
+      match voice::init_microphone(voice){
+        Ok(voice) => { commands.spawn(voice); },
+        Err(err) => println!("[WARN] Failed to start microphone: {}", err)
+      }
     })
     .add_systems(Update, debug_camera::update)
+    .add_systems(Startup, debug_camera::setup)
     .add_systems(Update, remote_player::update)
     .add_systems(FixedUpdate, network_interface::fixed_update)
     .run();

client/src/net/connection.rs

···
-use std::{collections::{HashMap, VecDeque}, io::{Read, Write}, net::{SocketAddr, TcpStream, UdpSocket}, sync::{Arc, Mutex, RwLock}, thread};
+use std::{collections::{HashMap, VecDeque}, io::{Read, Write}, net::{Shutdown, SocketAddr, TcpStream, UdpSocket}, sync::{Arc, Mutex, RwLock}, thread};
 use bevy::ecs::component::Component;
 use felix_audio::voice::decoder::VoiceChatDecoder;
 use tokio::sync::broadcast::{self, Receiver, Sender};
···
   udp: UdpSocket,
   udp_server_address: SocketAddr,
 
+  net_send: Sender<NetClientCommand>,
   net_recv: Receiver<NetClientCommand>,
 
   voice_queues: Arc<RwLock<HashMap<String, VoiceChatDecoder>>>,
-  pub id: String
+  pub id: String,
+
+  killed_signal: broadcast::Sender<()>
 }
 
 impl Connection{
   pub fn new( stream: TcpStream, udp: UdpSocket, udp_server_address: SocketAddr ) -> Self{
     let ( event_sender, event_recv ) = broadcast::channel(32);
+    let ( killed_signal_send, killed_signal ) = broadcast::channel(32);
 
     let mut conn = Self {
       tcp: stream,
···
       udp,
       udp_server_address,
 
+      net_send: event_sender.clone(),
       net_recv: event_recv,
 
       voice_queues: Arc::new(RwLock::new(HashMap::new())),
-      id: "".to_owned()
+      id: "".to_owned(),
+
+      killed_signal:  killed_signal_send
     };
 
-    conn.start_listener_thread(event_sender).unwrap();
+    conn.start_listener_thread(event_sender, killed_signal).unwrap();
 
     let packet = NotifyConnectionInfo { id: conn.id.clone() };
     conn.send_reliable(packet).unwrap();
···
     conn
   }
 
-  fn start_listener_thread(&self, cmd: Sender<NetClientCommand>) -> anyhow::Result<()>{
+  fn start_listener_thread(&self, cmd: Sender<NetClientCommand>, mut signal: Receiver<()>) -> anyhow::Result<()>{
     let mut tcp = self.tcp.try_clone()?;
     let udp = self.udp.try_clone()?;
 
···
     let srv_addr = self.udp_server_address.clone();
     let voice_queues = self.voice_queues.clone();
 
+    let mut signal_1 = signal.resubscribe();
+
     thread::spawn(move || { // UDP RECV THREAD
       let mut buf = [0; 1024];
 
       while let Ok((length, addr)) = udp_1.recv_from(&mut buf){
         if addr != srv_addr{ continue; }
+        if signal_1.try_recv().is_ok(){ break; }
 
         let mut msg: Buffer = (&buf[0..length]).into();
 
         while msg.left() > 0{
           let packet = packet::parse(&mut msg);
-          cmd_1.send(NetClientCommand::RecvPacket(packet)).unwrap();
+
+          match packet{
+            PacketTypes::PlayerVoicePacket(packet) => {
+              let voices = voice_queues.try_read().unwrap();
+              if let Some(decoder) = voices.get(&packet.id){
+                decoder.decode(packet.packet); }
+            },
+            _ => {
+              cmd_1.send(NetClientCommand::RecvPacket(packet)).unwrap();
+            }
+          }
         }
       }
     });
···
 
       while let Ok(length) = tcp.read(&mut buf){
         if length == 0 { break; }
+        if signal.try_recv().is_ok(){ break; }
 
         let mut msg: Buffer = (&buf[0..length]).into();
 
···
               let packet = LinkUDP { id: info.id };
               let packet: Vec<_> = packet.to_buf().into();
 
-              udp.send_to(&packet, "127.0.0.1:2603").unwrap();
-            },
-            PacketTypes::PlayerVoicePacket(packet) => {
-              let voices = voice_queues.read().unwrap();
-              if let Some(decoder) = voices.get(&packet.id){
-                decoder.decode(packet.packet); }
+              udp.send_to(&packet, srv_addr).unwrap();
             },
             _ => {
               cmd.send(NetClientCommand::RecvPacket(packet)).unwrap();
···
     Ok(())
   }
 
-  pub fn start_listening_for_player_voice( &mut self, id: &String ) -> Arc<Mutex<VecDeque<f32>>>{
+  pub fn get_remote_player_voice_ids( &self ) -> Vec<String>{
+    let voices = self.voice_queues.read().unwrap();
+    voices.iter().map(| x | x.0.clone()).collect()
+  }
+
+  pub fn get_remote_player_voice_rms( &self, id: &String ) -> f32{
+    let voices = self.voice_queues.read().unwrap();
+    let decoder = voices.get(id).unwrap();
+
+    decoder.get_last_rms()
+  }
+
+  pub fn start_listening_for_player_voice( &self, id: &String ) -> Arc<Mutex<VecDeque<f32>>>{
     let voice_queue = Arc::new(Mutex::new(VecDeque::new()));
     let decoder = VoiceChatDecoder::new(voice_queue.clone());
 
···
     voice_queue
   }
 
-  pub fn stop_listening_for_player_voice( &mut self, id: &String ){
+  pub fn stop_listening_for_player_voice( &self, id: &String ){
     let mut voices = self.voice_queues.write().unwrap();
     voices.remove(id);
   }
···
     self.udp.send_to(&buf, self.udp_server_address)?;
 
     Ok(())
+  }
+}
+
+impl Drop for Connection{
+  fn drop(&mut self) {
+    println!("Killing connection to: {}", self.udp_server_address);
+    self.net_send.send(NetClientCommand::Disconnected).unwrap();
+
+    self.killed_signal.send(()).unwrap();
+    self.tcp.shutdown(Shutdown::Both).unwrap();
   }
 }

client/src/setup.rs

···
 use bevy::prelude::*;
 use felix_audio::FelixAudioListener;
 
-use crate::debug_camera;
+use crate::components::debug_camera::DebugCamera;
 
 pub fn setup(
   mut commands: Commands,
   mut meshes: ResMut<Assets<Mesh>>,
   mut materials: ResMut<Assets<StandardMaterial>>
 ){
+  // TODO: World loading from server
+
+  // TODO: World loading format? Could build an asset bundle parser?
+
+  // TODO: UI and Menus
+
   commands.spawn((
     Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
     MeshMaterial3d(materials.add(Color::WHITE)),
···
   ));
 
   commands.spawn((
-    debug_camera::DebugCamera::default(),
+    DebugCamera::default(), // TODO: Build a proper player controller
     Camera3d::default(),
     Transform::from_xyz(0.0, 0.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y),
     FelixAudioListener

server/src/net/connection.rs

···
         self.position = packet.position;
         self.rotation = packet.rotation;
       },
-      PacketTypes::PlayerVoicePacket(mut voice) => {
-        voice.id = self.id.clone(); // NOTE: See "audio/src/voice/microphone.rs:71"
-        self.main_thread_sender.send(NetServerCommand::BroadcastVoice(voice)).unwrap();
-      },
       _ => {}
     }
 

server/src/net/mod.rs

···
 use std::{collections::HashMap, env, net::{SocketAddr, TcpListener, TcpStream, UdpSocket}, thread, time::Duration};
 
-use felix_net::{buffer::Buffer, packet::{self, PacketTypes}, packets::{player_join_packet::PlayerJoinPacket, player_leave_packet::PlayerLeavePacket, player_list_packet::PlayerListPacket, player_voice_packet::PlayerVoicePacket, update_clients_positions::UpdateClientsPositions}};
+use felix_net::{buffer::Buffer, packet::{self, PacketTypes}, packets::{player_join_packet::PlayerJoinPacket, player_leave_packet::PlayerLeavePacket, player_list_packet::PlayerListPacket, update_clients_positions::UpdateClientsPositions}};
 
 use crate::net::connection::Connection;
 
···
   SendOverUDP(Vec<u8>, SocketAddr),
   RecvOverUDP(SocketAddr, PacketTypes),
   RecvOverTCP(String, PacketTypes),
-  BroadcastVoice(PlayerVoicePacket),
   BroadcastPlayerPositions
 }
 
 pub fn handle_net() -> anyhow::Result<()>{
+  // TODO: Multiple instances
+  //       Need to decide if i want to run each instance on a seperate thread
+
   let port = env::var("HOST_PORT")?;
 
   let tcp_listener = TcpListener::bind(format!("0.0.0.0:{}", port))?;
···
       },
       NetServerCommand::RecvOverUDP(addr, packet) => {
         if let Some(conn_id) = connections_by_address.get(&addr){
-          let conn = connections.get_mut(conn_id).unwrap();
-          conn.recv_packet(packet)?;
+          match packet {
+            PacketTypes::PlayerVoicePacket(mut voice) => { // Keep voice stuff in one thread to avoid copying a lot of data all over the place
+              voice.id = conn_id.clone(); // NOTE: See "audio/src/voice/microphone.rs:71"
+
+              for ( remote_id, conn ) in &mut connections{
+                if remote_id == &voice.id { continue; }
+                conn.try_send_unreliable(voice.clone())?;
+              }
+            },
+            _ => {
+              let conn = connections.get_mut(conn_id).unwrap();
+              conn.recv_packet(packet)?;
+            }
+          }
+
         }
       },
       NetServerCommand::RecvOverTCP(conn_id, packet) => {
···
 
         for (_, conn) in &mut connections{
           conn.try_send_unreliable(packet.clone())?; }
-      },
-      NetServerCommand::BroadcastVoice(packet) => {
-        for ( remote_id, conn ) in &mut connections{
-          if remote_id == &packet.id { continue; }
-          conn.try_send_unreliable(packet.clone())?;
-        }
       }
     }
   }