new proto doc

1 files changed, 144 insertions, 63 deletions

diff --git a/shared/src/resources.rs b/shared/src/resources.rs
index 5b2e852..d0094fa 100644
--- a/shared/src/resources.rs
+++ b/shared/src/resources.rs
@@ -8,10 +8,26 @@ use std::{
 };
 
 #[derive(Debug, Default, Clone)]
-pub struct Prefab(pub Vec<(Affine3A, Resource)>);
+pub struct Prefab {
+    pub mesh: Vec<(Affine3A, Resource)>,
+    pub light: Vec<(Vec3A, Resource)>,
+    pub environment: Option<EnvironmentPart>,
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct LightPart {
+    emission: Option<Vec3A>,
+    radius: Option<f32>,
+}
 
 #[derive(Debug, Default, Clone)]
-pub struct Part {
+pub struct EnvironmentPart {
+    skybox: Option<Resource>,
+    sun: Option<(Vec3A, Vec3A)>,
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MeshPart {
     pub index: Option<Resource>,
     pub g_metallic: Option<f32>,
     pub g_roughness: Option<f32>,
@@ -63,58 +79,69 @@ impl ReadWrite for PrefabIndex {
 
 impl ReadWrite for Prefab {
     fn write(&self, w: &mut dyn Write) -> Result<()> {
-        for (aff, res) in self.0.clone() {
-            aff.write(w)?;
-            res.write(w)?;
+        for x in &self.mesh {
+            write_kv_opt(w, b"mesh", &Some(*x))?;
+        }
+        for x in &self.light {
+            write_kv_opt(w, b"light", &Some(*x))?;
         }
+        write_kv_opt(w, b"environment", &self.environment)?;
         Ok(())
     }
     fn read(r: &mut dyn Read) -> Result<Self> {
-        let mut s = Prefab::default();
-        let mut g = Vec::new();
-        r.read_to_end(&mut g)?;
-        let mut g = g.as_slice();
-        while !g.is_empty() {
-            s.0.push((Affine3A::read(&mut g)?, Resource::read(&mut g)?))
-        }
+        let mut s = Self::default();
+        read_kv_iter(r, |k, v| match k {
+            b"mesh" => Ok(s.mesh.push(read_slice(v)?)),
+            b"light" => Ok(s.light.push(read_slice(v)?)),
+            b"environment" => Ok(s.environment = Some(read_slice(v)?)),
+            x => Ok(warn!(
+                "unknown prefab key: {:?}",
+                String::from_utf8_lossy(x)
+            )),
+        })?;
         Ok(s)
     }
 }
-impl ReadWrite for IndexArray {
+impl ReadWrite for LightPart {
     fn write(&self, w: &mut dyn Write) -> Result<()> {
-        for x in self.0.clone() {
-            w.write_all(x.map(|x| x.to_be_bytes()).as_flattened())?;
-        }
+        write_kv_opt(w, b"emission", &self.emission)?;
+        write_kv_opt(w, b"radius", &self.radius)?;
         Ok(())
     }
+
     fn read(r: &mut dyn Read) -> Result<Self> {
-        let mut s = Self(Vec::new());
-        let mut g = Vec::new();
-        r.read_to_end(&mut g)?;
-        for x in g.iter().array_chunks::<2>().array_chunks::<3>() {
-            s.0.push(x.map(|x| u16::from_be_bytes(x.map(|x| *x))))
-        }
+        let mut s = Self::default();
+        read_kv_iter(r, |k, v| match k {
+            b"emission" => Ok(s.emission = Some(read_slice(v)?)),
+            b"radius" => Ok(s.radius = Some(read_slice(v)?)),
+            x => Ok(warn!(
+                "unknown light part key: {:?}",
+                String::from_utf8_lossy(x)
+            )),
+        })?;
         Ok(s)
     }
 }
-impl ReadWrite for AttributeArray {
+impl ReadWrite for EnvironmentPart {
     fn write(&self, w: &mut dyn Write) -> Result<()> {
-        for x in self.0.clone() {
-            w.write_all(&x.to_be_bytes())?;
-        }
+        write_kv_opt(w, b"skybox", &self.skybox)?;
+        write_kv_opt(w, b"sun", &self.sun)?;
         Ok(())
     }
     fn read(r: &mut dyn Read) -> Result<Self> {
-        let mut s = Self(Vec::new());
-        let mut g = Vec::new();
-        r.read_to_end(&mut g)?;
-        for x in g.iter().array_chunks::<4>() {
-            s.0.push(f32::from_be_bytes(x.map(|x| *x)))
-        }
+        let mut s = Self::default();
+        read_kv_iter(r, |k, v| match k {
+            b"skybox" => Ok(s.skybox = Some(read_slice(v)?)),
+            b"sun" => Ok(s.sun = Some(read_slice(v)?)),
+            x => Ok(warn!(
+                "unknown environment part key: {:?}",
+                String::from_utf8_lossy(x)
+            )),
+        })?;
         Ok(s)
     }
 }
-impl ReadWrite for Part {
+impl ReadWrite for MeshPart {
     fn write(&self, w: &mut dyn Write) -> Result<()> {
         write_kv_opt(w, b"index", &self.index)?;
         write_kv_opt(w, b"g_metallic", &self.g_metallic)?;
@@ -140,36 +167,32 @@ impl ReadWrite for Part {
     }
     fn read(r: &mut dyn Read) -> Result<Self> {
         let mut s = Self::default();
-        let mut g = Vec::new();
-        r.read_to_end(&mut g)?;
-        let mut g = g.as_slice();
-        while !g.is_empty() {
-            let (k, v) = read_kv(&mut g)?;
-            let mut v = v.as_slice();
-            match k.as_slice() {
-                b"index" => s.index = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"g_metallic" => s.g_metallic = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"g_roughness" => s.g_roughness = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"g_albedo" => s.g_albedo = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"g_transmission" => s.g_transmission = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"g_emission" => s.g_emission = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"va_position" => s.va_position = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"va_normal" => s.va_normal = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"va_texcoord" => s.va_texcoord = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"va_roughness" => s.va_roughness = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"va_metallic" => s.va_metallic = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"va_albedo" => s.va_albedo = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"va_transmission" => s.va_transmission = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"va_emission" => s.va_emission = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"tex_normal" => s.tex_normal = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"tex_roughness" => s.tex_roughness = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"tex_metallic" => s.tex_metallic = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"tex_albedo" => s.tex_albedo = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"tex_transmission" => s.tex_transmission = Some(<_ as ReadWrite>::read(&mut v)?),
-                b"tex_emission" => s.tex_emission = Some(<_ as ReadWrite>::read(&mut v)?),
-                x => warn!("unknown part key: {:?}", String::from_utf8_lossy(x)),
-            }
-        }
+        read_kv_iter(r, |k, v| match k {
+            b"index" => Ok(s.index = Some(read_slice(v)?)),
+            b"g_metallic" => Ok(s.g_metallic = Some(read_slice(v)?)),
+            b"g_roughness" => Ok(s.g_roughness = Some(read_slice(v)?)),
+            b"g_albedo" => Ok(s.g_albedo = Some(read_slice(v)?)),
+            b"g_transmission" => Ok(s.g_transmission = Some(read_slice(v)?)),
+            b"g_emission" => Ok(s.g_emission = Some(read_slice(v)?)),
+            b"va_position" => Ok(s.va_position = Some(read_slice(v)?)),
+            b"va_normal" => Ok(s.va_normal = Some(read_slice(v)?)),
+            b"va_texcoord" => Ok(s.va_texcoord = Some(read_slice(v)?)),
+            b"va_roughness" => Ok(s.va_roughness = Some(read_slice(v)?)),
+            b"va_metallic" => Ok(s.va_metallic = Some(read_slice(v)?)),
+            b"va_albedo" => Ok(s.va_albedo = Some(read_slice(v)?)),
+            b"va_transmission" => Ok(s.va_transmission = Some(read_slice(v)?)),
+            b"va_emission" => Ok(s.va_emission = Some(read_slice(v)?)),
+            b"tex_normal" => Ok(s.tex_normal = Some(read_slice(v)?)),
+            b"tex_roughness" => Ok(s.tex_roughness = Some(read_slice(v)?)),
+            b"tex_metallic" => Ok(s.tex_metallic = Some(read_slice(v)?)),
+            b"tex_albedo" => Ok(s.tex_albedo = Some(read_slice(v)?)),
+            b"tex_transmission" => Ok(s.tex_transmission = Some(read_slice(v)?)),
+            b"tex_emission" => Ok(s.tex_emission = Some(read_slice(v)?)),
+            x => Ok(warn!(
+                "unknown mesh part key: {:?}",
+                String::from_utf8_lossy(x)
+            )),
+        })?;
         Ok(s)
     }
 }
@@ -188,6 +211,20 @@ fn read_kv(r: &mut &[u8]) -> Result<(Vec<u8>, Vec<u8>)> {
     Ok((key, value))
 }
 
+fn read_kv_iter(r: &mut dyn Read, mut cb: impl FnMut(&[u8], &[u8]) -> Result<()>) -> Result<()> {
+    let mut g = Vec::new();
+    r.read_to_end(&mut g)?;
+    let mut g = g.as_slice();
+    while !g.is_empty() {
+        let (k, v) = read_kv(&mut g)?;
+        cb(&k, &v)?
+    }
+    Ok(())
+}
+fn read_slice<T: ReadWrite>(mut r: &[u8]) -> Result<T> {
+    T::read(&mut r)
+}
+
 fn write_kv_opt(w: &mut dyn Write, key: &[u8], value: &Option<impl ReadWrite>) -> Result<()> {
     if let Some(v) = value {
         write_kv(w, key, &v.write_alloc())?;
@@ -236,3 +273,47 @@ impl ReadWrite for Affine3A {
         Ok(Self::from_cols_array(&[(); 12].try_map(|()| f32::read(r))?))
     }
 }
+impl ReadWrite for IndexArray {
+    fn write(&self, w: &mut dyn Write) -> Result<()> {
+        for x in self.0.clone() {
+            w.write_all(x.map(|x| x.to_be_bytes()).as_flattened())?;
+        }
+        Ok(())
+    }
+    fn read(r: &mut dyn Read) -> Result<Self> {
+        let mut s = Self(Vec::new());
+        let mut g = Vec::new();
+        r.read_to_end(&mut g)?;
+        for x in g.iter().array_chunks::<2>().array_chunks::<3>() {
+            s.0.push(x.map(|x| u16::from_be_bytes(x.map(|x| *x))))
+        }
+        Ok(s)
+    }
+}
+impl ReadWrite for AttributeArray {
+    fn write(&self, w: &mut dyn Write) -> Result<()> {
+        for x in self.0.clone() {
+            w.write_all(&x.to_be_bytes())?;
+        }
+        Ok(())
+    }
+    fn read(r: &mut dyn Read) -> Result<Self> {
+        let mut s = Self(Vec::new());
+        let mut g = Vec::new();
+        r.read_to_end(&mut g)?;
+        for x in g.iter().array_chunks::<4>() {
+            s.0.push(f32::from_be_bytes(x.map(|x| *x)))
+        }
+        Ok(s)
+    }
+}
+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)?))
+    }
+}