a

1 files changed, 75 insertions, 24 deletions

diff --git a/client/src/scene_prepare.rs b/client/src/scene_prepare.rs
index 5376145..8d50fc3 100644
--- a/client/src/scene_prepare.rs
+++ b/client/src/scene_prepare.rs
@@ -1,5 +1,5 @@
 use crate::download::Downloader;
-use anyhow::Result;
+use anyhow::{Context, Result};
 use std::{
     collections::{HashMap, HashSet},
     sync::Arc,
@@ -12,22 +12,23 @@ use weareshared::{
 use wgpu::Buffer;
 
 pub struct ScenePreparer {
-    index_buffers: HashMap<Resource, Arc<Buffer>>,
+    index_buffers: HashMap<Resource, (Arc<Buffer>, u32)>,
     index_buffers_needed: HashSet<Resource>,
     vertex_buffers: HashMap<Resource, Arc<Buffer>>,
     vertex_buffers_needed: HashSet<Resource>,
     parts: HashMap<Resource, Arc<RPart>>,
     parts_needed: HashSet<Resource>,
-    prefabs: HashMap<Resource, RPrefab>,
-    prefabs_needed: HashSet<Resource>,
+    pub prefabs: HashMap<Resource, RPrefab>,
+    pub prefabs_needed: HashSet<Resource>,
 }
 
 pub struct RPrefab(pub Vec<(Affine3A, Arc<RPart>)>);
 pub struct RPart {
     pub index_count: u32,
     pub index: Arc<Buffer>,
-    pub positions: Arc<Buffer>,
-    pub normals: Arc<Buffer>,
+    pub position: [Arc<Buffer>; 3],
+    pub normal: [Arc<Buffer>; 3],
+    pub texcoord: [Arc<Buffer>; 2],
 }
 
 impl ScenePreparer {
@@ -47,7 +48,7 @@ impl ScenePreparer {
         let mut done = Vec::new();
         for pres in &self.prefabs_needed {
             if let Some(buf) = dls.try_get(*pres)? {
-                let prefab = Prefab::read(&mut buf.as_slice())?;
+                let prefab = Prefab::read(&mut buf.as_slice()).context("parsing prefab")?;
                 let mut rprefab = RPrefab(Vec::new());
                 for (aff, partres) in &prefab.0 {
                     if let Some(part) = self.parts.get(partres) {
@@ -62,28 +63,78 @@ impl ScenePreparer {
                 }
             }
         }
+        for pres in &self.index_buffers_needed {
+            if let Some(buf) = dls.try_get(*pres)? {}
+        }
         for pres in &self.parts_needed {
             if let Some(buf) = dls.try_get(*pres)? {
-                let part = Part::read(&mut buf.as_slice())?;
-                if let Some(indexres) = part.index {
-                    if let Some(vertexres) = part.va_position {
-                        let Some(index) = self.index_buffers.get(&indexres) else {
-                            self.index_buffers_needed.insert(indexres);
-                            continue;
-                        };
-                        for vr in vertexres {
-                            match vr {
-                                Attribute::Constant(_) => todo!(),
-                                Attribute::Vertex(resource) => {
-                                    let Some(vertex) = self.index_buffers.get(&resource) else {
-                                        self.index_buffers_needed.insert(indexres);
-                                        continue;
-                                    };
-                                }
-                                Attribute::Texture(resource) => todo!(),
+                let part = Part::read(&mut buf.as_slice()).context("parsing part")?;
+                if let (Some(indexres), Some(positionres), Some(normalres), Some(texcoordres)) = (
+                    part.index,
+                    part.va_position,
+                    part.va_normal,
+                    part.va_texcoord,
+                ) {
+                    let Some((index, index_count)) = self.index_buffers.get(&indexres).cloned()
+                    else {
+                        self.index_buffers_needed.insert(indexres);
+                        continue;
+                    };
+                    let mut positions = Vec::new();
+                    for vr in positionres {
+                        match vr {
+                            Attribute::Constant(_) => todo!(),
+                            Attribute::Vertex(resource) => {
+                                let Some(vertex) = self.vertex_buffers.get(&resource).cloned()
+                                else {
+                                    self.vertex_buffers_needed.insert(indexres);
+                                    continue;
+                                };
+                                positions.push(vertex);
+                            }
+                            Attribute::Texture(_resource) => todo!(),
+                        }
+                    }
+                    let mut normals = Vec::new();
+                    for vr in normalres {
+                        match vr {
+                            Attribute::Constant(_) => todo!(),
+                            Attribute::Vertex(resource) => {
+                                let Some(vertex) = self.vertex_buffers.get(&resource).cloned()
+                                else {
+                                    self.vertex_buffers_needed.insert(indexres);
+                                    continue;
+                                };
+                                normals.push(vertex);
+                            }
+                            Attribute::Texture(_resource) => todo!(),
+                        }
+                    }
+                    let mut texcoords = Vec::new();
+                    for vr in texcoordres {
+                        match vr {
+                            Attribute::Constant(_) => todo!(),
+                            Attribute::Vertex(resource) => {
+                                let Some(vertex) = self.vertex_buffers.get(&resource).cloned()
+                                else {
+                                    self.vertex_buffers_needed.insert(indexres);
+                                    continue;
+                                };
+                                texcoords.push(vertex);
                             }
+                            Attribute::Texture(_resource) => todo!(),
                         }
                     }
+                    self.parts.insert(
+                        *pres,
+                        Arc::new(RPart {
+                            index_count,
+                            index,
+                            texcoord: texcoords.try_into().unwrap(),
+                            normal: normals.try_into().unwrap(),
+                            position: positions.try_into().unwrap(),
+                        }),
+                    );
                 }
             }
         }