new network

1 files changed, 43 insertions, 19 deletions

diff --git a/shared/src/packets.rs b/shared/src/packets.rs
index 0ceed73..a1636cd 100644
--- a/shared/src/packets.rs
+++ b/shared/src/packets.rs
@@ -1,5 +1,5 @@
 use anyhow::{Result, bail};
-use glam::Vec3;
+use glam::Vec3A;
 use std::{
     fmt::{Debug, Display},
     io::{Read, Write},
@@ -10,16 +10,21 @@ pub struct Resource(pub [u8; 32]);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Object(pub u128);
 
+#[derive(Clone)]
+pub struct Data(pub Vec<u8>);
+
 #[derive(Debug, Clone)]
 pub enum Packet {
+    Connect(u128),
+    Disconnect,
     RequestResource(Resource),
-    RespondResource(Vec<u8>),
+    RespondResource(Data),
     Add(Object, Resource),
     Remove(Object),
-    Position(Object, Vec3, Vec3),
+    Position(Object, Vec3A, Vec3A),
     Pose(Object, Vec<f32>),
     Parent(Object, Object),
-    Sound(Object, Vec<u8>),
+    Sound(Object, Data),
 }
 
 pub trait ReadWrite: Sized {
@@ -41,14 +46,20 @@ impl Object {
 impl Packet {
     fn serialize_inner(&self, w: &mut impl Write) -> Result<()> {
         match self {
+            Packet::Connect(id) => {
+                w.write_all(&[0x00])?;
+                w.write_all(&id.to_be_bytes())?;
+            }
+            Packet::Disconnect => {
+                w.write_all(&[0xff])?;
+            }
             Packet::RequestResource(resource) => {
                 w.write_all(&[0x01])?;
                 w.write_all(&resource.0)?;
             }
             Packet::RespondResource(data) => {
                 w.write_all(&[0x02])?;
-                w.write_all(&(data.len() as u16).to_be_bytes())?;
-                w.write_all(&data)?;
+                data.write(w)?;
             }
             Packet::Add(object, resource) => {
                 w.write_all(&[0x03])?;
@@ -79,10 +90,10 @@ impl Packet {
                 w.write_all(&parent.0.to_be_bytes())?;
                 w.write_all(&child.0.to_be_bytes())?;
             }
-            Packet::Sound(object, vec) => {
+            Packet::Sound(object, data) => {
                 w.write_all(&[0x08])?;
                 w.write_all(&object.0.to_be_bytes())?;
-                w.write_all(&(vec.len() as u16).to_be_bytes())?;
+                data.write(w)?;
             }
         }
         Ok(())
@@ -100,18 +111,19 @@ impl ReadWrite for Packet {
         let mut size_tag = [0u8; 3];
         r.read_exact(&mut size_tag)?;
         Ok(match size_tag[2] {
+            0x00 => Packet::Connect(read_u128(r)?),
             0x01 => Packet::RequestResource(Resource::read(r)?),
-            0x02 => Packet::RespondResource(read_data(r)?),
+            0x02 => Packet::RespondResource(Data::read(r)?),
             0x03 => Packet::Add(Object(read_u128(r)?), Resource::read(r)?),
             0x04 => Packet::Remove(Object(read_u128(r)?)),
             0x05 => Packet::Position(
                 Object(read_u128(r)?),
-                Vec3::new(f32::read(r)?, f32::read(r)?, f32::read(r)?),
-                Vec3::new(f32::read(r)?, f32::read(r)?, f32::read(r)?),
+                Vec3A::new(f32::read(r)?, f32::read(r)?, f32::read(r)?),
+                Vec3A::new(f32::read(r)?, f32::read(r)?, f32::read(r)?),
             ),
             0x06 => Packet::Pose(Object(read_u128(r)?), read_params(r)?),
             0x07 => Packet::Parent(Object(read_u128(r)?), Object(read_u128(r)?)),
-            0x08 => Packet::Sound(Object(read_u128(r)?), read_data(r)?),
+            0x08 => Packet::Sound(Object(read_u128(r)?), Data::read(r)?),
             _ => {
                 for _ in 0..u16::from_be_bytes([size_tag[0], size_tag[1]]) - 1 {
                     r.read_exact(&mut [0])?;
@@ -138,13 +150,20 @@ impl ReadWrite for Resource {
         Ok(s)
     }
 }
-fn read_data(r: &mut dyn Read) -> Result<Vec<u8>> {
-    let mut size = [0; 2];
-    r.read_exact(&mut size)?;
-    let size = u16::from_be_bytes(size);
-    let mut buf = vec![0; size as usize];
-    r.read_exact(&mut buf)?;
-    Ok(buf)
+impl ReadWrite for Data {
+    fn write(&self, w: &mut dyn Write) -> Result<()> {
+        w.write_all(&(self.0.len() as u16).to_be_bytes())?;
+        w.write_all(&self.0)?;
+        Ok(())
+    }
+    fn read(r: &mut dyn Read) -> Result<Self> {
+        let mut size = [0; 2];
+        r.read_exact(&mut size)?;
+        let size = u16::from_be_bytes(size);
+        let mut buf = vec![0; size as usize];
+        r.read_exact(&mut buf)?;
+        Ok(Data(buf))
+    }
 }
 fn read_params(r: &mut dyn Read) -> Result<Vec<f32>> {
     let mut size = [0; 2];
@@ -200,3 +219,8 @@ impl<T: ReadWrite, const N: usize> ReadWrite for [T; N] {
         [(); N].try_map(|()| T::read(r))
     }
 }
+impl Debug for Data {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("Data").finish_non_exhaustive()
+    }
+}