Add config and basic architecture for QUIC

substrate/src/transport/ecs.rs

@@ -0,0 +1,69 @@
+use std::sync::{Arc, Mutex};
+use bevy::prelude::*;
+use tokio::sync::mpsc;
+use crate::config::QuicConfig;
+use crate::transport::QuicMessage;
+use crate::transport::server::run_substrate_server;
+
+const T1_CAPACITY: usize = 1024;
+const T2_CAPACITY: usize = 512;
+const T3_CAPACITY: usize = 256;
+
+pub struct EcsQuicTransportPlugin{}
+
+#[derive(Resource)]
+struct BridgeReceivers {
+    t1: Mutex<mpsc::Receiver<QuicMessage>>,
+    t2: Mutex<mpsc::Receiver<QuicMessage>>,
+    t3: Mutex<mpsc::Receiver<QuicMessage>>,
+}
+
+fn ingest_system(bridge: Res<BridgeReceivers>){
+    let mut t1 = bridge.t1.lock().unwrap();
+    // Tier 1: drain up to N messages, drop the rest
+    for _ in 0..T1_CAPACITY {
+        match t1.try_recv() {
+            Ok(msg) => { /* write RawSensorData */ }
+            Err(_) => break,
+        }
+    }
+
+    // T2/T3: drain completely, these are low volume
+    let mut t2 = bridge.t2.lock().unwrap();
+    while let Ok(msg) = t2.try_recv() { /* ... */ }
+
+    let mut t3 = bridge.t3.lock().unwrap();
+    while let Ok(msg) = t3.try_recv() { /* ... */ }
+}
+
+impl Plugin for EcsQuicTransportPlugin{
+    fn build(&self, app: &mut App) {
+        // Create the channels for multi-thread communication
+        let (t1_tx, t1_rx) =
+            mpsc::channel::<QuicMessage>(T1_CAPACITY);
+        let (t2_tx, t2_rx) =
+            mpsc::channel::<QuicMessage>(T2_CAPACITY);
+        let (t3_tx, t3_rx) =
+            mpsc::channel::<QuicMessage>(T3_CAPACITY);
+
+        let quic_handle = std::thread::spawn(move || {
+            let rt = tokio::runtime::Builder::new_multi_thread()
+                .worker_threads(2)
+                .enable_all()
+                .build()
+                .unwrap();
+
+            rt.block_on(async move {
+                run_substrate_server(t1_tx, t2_tx, t3_tx).await;
+            });
+        });
+
+        app.insert_resource(BridgeReceivers {
+            t1: Mutex::new(t1_rx),
+            t2: Mutex::new(t2_rx),
+            t3: Mutex::new(t3_rx),
+        });
+
+        app.add_systems(PreUpdate, ingest_system);
+    }
+}