From 3ac853862b5965c1ebfb10b12fb35cf5c671232f Mon Sep 17 00:00:00 2001
From: metamuffin <metamuffin@disroot.org>
Date: Fri, 10 Jan 2025 20:06:01 +0100
Subject: physics extension and fixes

---
 shared/src/helper.rs | 140 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 140 insertions(+)

(limited to 'shared/src/helper.rs')

diff --git a/shared/src/helper.rs b/shared/src/helper.rs
index 706e36b..61e149f 100644
--- a/shared/src/helper.rs
+++ b/shared/src/helper.rs
@@ -16,6 +16,7 @@
 */
 use crate::packets::{Data, Object, Resource};
 use anyhow::Result;
+use glam::{Affine3A, Vec2, Vec3A};
 use std::{
     io::{Read, Write},
     marker::PhantomData,
@@ -65,6 +66,81 @@ impl ReadWrite for Vec<u8> {
         Ok(buf)
     }
 }
+impl ReadWrite for Vec<Vec3A> {
+    fn write(&self, w: &mut dyn Write) -> Result<()> {
+        for e in self {
+            e.write(w)?;
+        }
+        Ok(())
+    }
+    fn read(r: &mut dyn Read) -> Result<Self> {
+        let mut buf = Vec::new();
+        r.read_to_end(&mut buf)?;
+        Ok(buf
+            .into_iter()
+            .array_chunks::<4>()
+            .map(f32::from_be_bytes)
+            .array_chunks::<3>()
+            .map(Vec3A::from_array)
+            .collect())
+    }
+}
+impl ReadWrite for Vec<Vec2> {
+    fn write(&self, w: &mut dyn Write) -> Result<()> {
+        for e in self {
+            e.write(w)?;
+        }
+        Ok(())
+    }
+    fn read(r: &mut dyn Read) -> Result<Self> {
+        let mut buf = Vec::new();
+        r.read_to_end(&mut buf)?;
+        Ok(buf
+            .into_iter()
+            .array_chunks::<4>()
+            .map(f32::from_be_bytes)
+            .array_chunks::<2>()
+            .map(Vec2::from_array)
+            .collect())
+    }
+}
+impl ReadWrite for Vec<[u16; 3]> {
+    fn write(&self, w: &mut dyn Write) -> Result<()> {
+        for e in self {
+            w.write_all(&e[0].to_be_bytes())?;
+            w.write_all(&e[1].to_be_bytes())?;
+            w.write_all(&e[2].to_be_bytes())?;
+        }
+        Ok(())
+    }
+    fn read(r: &mut dyn Read) -> Result<Self> {
+        let mut buf = Vec::new();
+        r.read_to_end(&mut buf)?;
+        Ok(buf
+            .into_iter()
+            .array_chunks::<2>()
+            .map(u16::from_be_bytes)
+            .array_chunks::<3>()
+            .collect())
+    }
+}
+impl ReadWrite for Vec<f32> {
+    fn write(&self, w: &mut dyn Write) -> Result<()> {
+        for e in self {
+            e.write(w)?;
+        }
+        Ok(())
+    }
+    fn read(r: &mut dyn Read) -> Result<Self> {
+        let mut buf = Vec::new();
+        r.read_to_end(&mut buf)?;
+        Ok(buf
+            .into_iter()
+            .array_chunks::<4>()
+            .map(f32::from_be_bytes)
+            .collect())
+    }
+}
 impl ReadWrite for String {
     fn write(&self, w: &mut dyn Write) -> Result<()> {
         w.write_all(self.as_bytes())?;
@@ -134,3 +210,67 @@ impl ReadWrite for () {
         Ok(())
     }
 }
+impl ReadWrite for Vec2 {
+    fn write(&self, w: &mut dyn Write) -> Result<()> {
+        self.x.write(w)?;
+        self.y.write(w)?;
+        Ok(())
+    }
+    fn read(r: &mut dyn Read) -> Result<Self> {
+        Ok(Self::new(f32::read(r)?, f32::read(r)?))
+    }
+}
+impl ReadWrite for Vec3A {
+    fn write(&self, w: &mut dyn Write) -> Result<()> {
+        self.x.write(w)?;
+        self.y.write(w)?;
+        self.z.write(w)?;
+        Ok(())
+    }
+    fn read(r: &mut dyn Read) -> Result<Self> {
+        Ok(Self::new(f32::read(r)?, f32::read(r)?, f32::read(r)?))
+    }
+}
+impl ReadWrite for Affine3A {
+    fn write(&self, w: &mut dyn Write) -> Result<()> {
+        for v in self.to_cols_array() {
+            v.write(w)?
+        }
+        Ok(())
+    }
+    fn read(r: &mut dyn Read) -> Result<Self> {
+        Ok(Self::from_cols_array(&[(); 12].try_map(|()| f32::read(r))?))
+    }
+}
+impl<A: ReadWrite, B: ReadWrite> ReadWrite for (A, B) {
+    fn write(&self, w: &mut dyn Write) -> Result<()> {
+        self.0.write(w)?;
+        self.1.write(w)?;
+        Ok(())
+    }
+    fn read(r: &mut dyn Read) -> Result<Self> {
+        Ok((A::read(r)?, B::read(r)?))
+    }
+}
+impl<A: ReadWrite, B: ReadWrite, C: ReadWrite> ReadWrite for (A, B, C) {
+    fn write(&self, w: &mut dyn Write) -> Result<()> {
+        self.0.write(w)?;
+        self.1.write(w)?;
+        self.2.write(w)?;
+        Ok(())
+    }
+    fn read(r: &mut dyn Read) -> Result<Self> {
+        Ok((A::read(r)?, B::read(r)?, C::read(r)?))
+    }
+}
+impl ReadWrite for u8 {
+    fn write(&self, w: &mut dyn Write) -> Result<()> {
+        w.write_all(&[*self])?;
+        Ok(())
+    }
+    fn read(r: &mut dyn Read) -> Result<Self> {
+        let mut buf = [0u8; 1];
+        r.read_exact(&mut buf)?;
+        Ok(buf[0])
+    }
+}
-- 
cgit v1.2.3-70-g09d2