a

1 files changed, 48 insertions, 13 deletions

diff --git a/world/src/main.rs b/world/src/main.rs
index 56b62c9..28a4ec4 100644
--- a/world/src/main.rs
+++ b/world/src/main.rs
@@ -1,13 +1,14 @@
 use anyhow::Result;
 use clap::Parser;
-use gltf::Gltf;
 use std::{
-    fs::File,
-    io::BufReader,
     net::{SocketAddr, TcpStream},
     path::PathBuf,
 };
-use weareshared::resources::Part;
+use weareshared::{
+    packets::{Object, Packet},
+    resources::{Part, Prefab, VertexAttributes},
+    store::ResourceStore,
+};
 
 #[derive(Parser)]
 struct Args {
@@ -19,21 +20,55 @@ fn main() -> Result<()> {
     env_logger::init_from_env("LOG");
     let args = Args::parse();
 
-    let sock = TcpStream::connect(args.address)?;
+    let mut sock = TcpStream::connect(args.address)?;
+    let store = ResourceStore::new_memory();
 
-    let scenefile = Gltf::from_reader(BufReader::new(File::open(args.scene)?))?;
-    let scene = scenefile
-        .default_scene()
-        .unwrap_or(scenefile.scenes().next().unwrap());
+    let (gltf, buffers, _) = gltf::import(args.scene)?;
 
-    for node in scene.nodes() {
+    let mut parts = Vec::new();
+    for node in gltf.nodes() {
         if let Some(mesh) = node.mesh() {
             for p in mesh.primitives() {
-                for (sem, iter) in p.attributes() {}
+                let reader = p.reader(|buf| Some(&buffers[buf.index()]));
+                let mut attrs = vec![vec![]; 3];
+                for p in reader.read_positions().unwrap() {
+                    attrs[0].push(p[0]);
+                    attrs[1].push(p[1]);
+                    attrs[2].push(p[2]);
+                }
+                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<_>, _>>()?,
+                    ..Part::default()
+                };
+                let mut out = Vec::new();
+                part.serialize(&mut out)?;
+                parts.push(store.set(&out)?);
             }
-            let part = Part { ..Part::default() };
         }
     }
 
-    Ok(())
+    let mut out = Vec::new();
+    Prefab(parts).serialize(&mut out)?;
+    let prefab = store.set(&out)?;
+
+    Packet::Add(Object::new(), prefab).serialize(&mut sock)?;
+
+    loop {
+        let packet = Packet::deserialize(&mut sock)?;
+        match packet {
+            Packet::RequestResource(hash) => {
+                if let Some(d) = store.get(hash)? {
+                    Packet::RespondResource(d).serialize(&mut sock)?;
+                }
+            }
+            _ => (),
+        }
+    }
 }