new proto

1 files changed, 37 insertions, 28 deletions

diff --git a/world/src/main.rs b/world/src/main.rs
index 4f641c3..772c87d 100644
--- a/world/src/main.rs
+++ b/world/src/main.rs
@@ -6,8 +6,8 @@ use std::{
     path::PathBuf,
 };
 use weareshared::{
-    packets::{Object, Packet},
-    resources::{Indecies, Part, Prefab, VertexAttributes},
+    packets::{Object, Packet, ReadWrite},
+    resources::{Attribute, AttributeArray, IndexArray, Part},
     store::ResourceStore,
 };
 
@@ -30,11 +30,21 @@ fn main() -> Result<()> {
         if let Some(mesh) = node.mesh() {
             for p in mesh.primitives() {
                 let reader = p.reader(|buf| Some(&buffers[buf.index()]));
-                let mut attrs = vec![vec![]; 3];
+                let mut pos_x = vec![];
+                let mut pos_y = vec![];
+                let mut pos_z = vec![];
+                let mut norm_x = vec![];
+                let mut norm_y = vec![];
+                let mut norm_z = vec![];
                 for p in reader.read_positions().unwrap() {
-                    attrs[0].push(p[0]);
-                    attrs[1].push(p[1]);
-                    attrs[2].push(p[2]);
+                    pos_x.push(p[0]);
+                    pos_y.push(p[1]);
+                    pos_z.push(p[2]);
+                }
+                for p in reader.read_normals().unwrap() {
+                    norm_x.push(p[0]);
+                    norm_y.push(p[1]);
+                    norm_z.push(p[2]);
                 }
                 let index = reader
                     .read_indices()
@@ -44,41 +54,40 @@ fn main() -> Result<()> {
                     .array_chunks::<3>()
                     .collect::<Vec<_>>();
 
-                let part = Part {
-                    vertex: attrs
-                        .into_iter()
-                        .map(|d| {
-                            let mut out = Vec::new();
-                            VertexAttributes(d).serialize(&mut out)?;
-                            store.set(&out)
-                        })
-                        .collect::<Result<Vec<_>, _>>()?,
-                    index: Some({
-                        let mut out = Vec::new();
-                        Indecies(index).serialize(&mut out)?;
-                        store.set(&out)?
-                    }),
-                    ..Part::default()
-                };
-                let mut out = Vec::new();
-                part.serialize(&mut out)?;
-                Packet::Add(Object::new(), store.set(&out)?).serialize(&mut sock)?;
+                let part = store.set(
+                    &Part {
+                        va_position: Some([
+                            Attribute::Vertex(store.set(&AttributeArray(pos_x).write_alloc())?),
+                            Attribute::Vertex(store.set(&AttributeArray(pos_y).write_alloc())?),
+                            Attribute::Vertex(store.set(&AttributeArray(pos_z).write_alloc())?),
+                        ]),
+                        va_normal: Some([
+                            Attribute::Vertex(store.set(&AttributeArray(norm_x).write_alloc())?),
+                            Attribute::Vertex(store.set(&AttributeArray(norm_y).write_alloc())?),
+                            Attribute::Vertex(store.set(&AttributeArray(norm_z).write_alloc())?),
+                        ]),
+                        index: Some(store.set(&IndexArray(index).write_alloc())?),
+                        ..Part::default()
+                    }
+                    .write_alloc(),
+                )?;
+                Packet::Add(Object::new(), part).write(&mut sock)?;
             }
         }
     }
 
     store.iter(|d| {
         Packet::RespondResource(d.to_vec())
-            .serialize(&mut sock)
+            .write(&mut sock)
             .unwrap();
     })?;
 
     loop {
-        let packet = Packet::deserialize(&mut sock)?;
+        let packet = Packet::read(&mut sock)?;
         match packet {
             Packet::RequestResource(hash) => {
                 if let Some(d) = store.get(hash)? {
-                    Packet::RespondResource(d).serialize(&mut sock)?;
+                    Packet::RespondResource(d).write(&mut sock)?;
                 }
             }
             _ => (),