some cleanup

examples/view/main.rs

@@ -263,48 +263,33 @@ fn model_to_model(model: &Model, loader: &Loader) -> CpuModel {
         z: 0.0,
     };
 
-    let positions: Vec<Vec3> = model
+    let skin = model.skin_tables().next().unwrap();
-        .vertices()
-        .iter()
-        .map(|vertex| ((vertex.position + offset) * UNIT_SCALE * 10.0).into())
-        .collect();
-    let normals: Vec<Vec3> = model
-        .vertices()
-        .iter()
-        .map(|vertex| vertex.normal.into())
-        .collect();
-    let uvs: Vec<Vec2> = model
-        .vertices()
-        .iter()
-        .map(|vertex| Vec2 {
-            x: vertex.texture_coordinates[0],
-            y: vertex.texture_coordinates[1],
-        })
-        .collect();
-
-    let texture_names = model.textures();
-    let skin = dbg!(&model.skin_tables()[1]);
 
     let geometries = model
         .meshes()
         .map(|mesh| {
-            let indices = Indices::U32(
+            let texture = skin
-                mesh.vertex_strip_indices()
+                .texture(mesh.material_index())
-                    .flat_map(|strip| strip.map(|index| index as u32))
+                .expect("texture out of bounds");
-                    .collect(),
+
-            );
+            let positions: Vec<Vec3> = mesh
-            let texture_index = skin[mesh.material_index() as usize] as usize;
+                .vertices()
+                .map(|vertex| ((vertex.position + offset) * UNIT_SCALE * 10.0).into())
+                .collect();
+            let normals: Vec<Vec3> = mesh.vertices().map(|vertex| vertex.normal.into()).collect();
+            let uvs: Vec<Vec2> = mesh
+                .vertices()
+                .map(|vertex| Vec2 {
+                    x: vertex.texture_coordinates[0],
+                    y: vertex.texture_coordinates[1],
+                })
+                .collect();
 
             CpuMesh {
-                positions: Positions::F32(positions.clone()),
+                positions: Positions::F32(positions),
-                normals: Some(normals.clone()),
+                normals: Some(normals),
-                uvs: Some(uvs.clone()),
+                uvs: Some(uvs),
-                material_name: Some(dbg!(texture_names
+                material_name: Some(texture.into()),
-                    .get(texture_index)
-                    .expect("texture out of bounds")
-                    .name
-                    .clone())),
-                indices,
                 ..Default::default()
             }
         })

src/lib.rs

@@ -29,11 +29,6 @@ impl Model {
         Model { mdl, vtx, vvd }
     }
 
-    pub fn vertex_strips(&self) -> impl Iterator<Item = impl Iterator<Item = &'_ Vertex> + '_> {
-        self.vertex_strip_indices()
-            .map(|strip| strip.map(|index| &self.vvd.vertices[index]))
-    }
-
     pub fn vertices(&self) -> &[Vertex] {
         &self.vvd.vertices
     }
@@ -46,8 +41,14 @@ impl Model {
         &self.mdl.textures
     }
 
-    pub fn skin_tables(&self) -> &[Vec<u16>] {
+    pub fn skin_tables(&self) -> impl Iterator<Item = SkinTable> {
-        &self.mdl.skin_table
+        self.mdl
+            .skin_table
+            .chunks(self.mdl.header.skin_reference_count as usize)
+            .map(|chunk| SkinTable {
+                table: chunk,
+                textures: &self.mdl.textures,
+            })
     }
 
     pub fn meshes(&self) -> impl Iterator<Item = Mesh> {
@@ -75,62 +76,36 @@ impl Model {
             .zip(vtx_meshes)
             .map(|((mdl, model_vertex_offset), vtx)| Mesh {
                 model_vertex_offset,
+                vertices: self.vertices(),
                 mdl,
                 vtx,
             })
     }
+}
 
-    pub fn vertex_strip_indices(&self) -> impl Iterator<Item = impl Iterator<Item = usize> + '_> {
+pub struct SkinTable<'a> {
-        let mesh_vertex_offsets = self
+    textures: &'a [TextureInfo],
-            .mdl
+    table: &'a [u16],
-            .body_parts
+}
-            .iter()
-            .flat_map(|part| part.models.iter())
-            .flat_map(|model| {
-                model
-                    .meshes
-                    .iter()
-                    .map(move |mesh| (mesh.vertex_offset + model.vertex_offset) as usize)
-            });
 
-        let vtx_meshes = self
+impl<'a> SkinTable<'a> {
-            .vtx
+    pub fn texture(&self, index: i32) -> Option<&'a str> {
-            .body_parts
+        let texture_index = self.table.get(index as usize)?;
-            .iter()
+        self.textures
-            .flat_map(|part| part.models.iter())
+            .get(*texture_index as usize)
-            .flat_map(|model| model.lods.first())
+            .map(|info| info.name.as_str())
-            .flat_map(|lod| lod.meshes.iter());
-
-        vtx_meshes
-            .zip(mesh_vertex_offsets)
-            .flat_map(|(vtx_mesh, vertex_offset)| {
-                vtx_mesh
-                    .strip_groups
-                    .iter()
-                    .map(move |strip_group| (strip_group, vertex_offset))
-            })
-            .flat_map(|(strip_group, mesh_vertex_offset)| {
-                let group_indices = &strip_group.indices;
-                let vertices = &strip_group.vertices;
-                strip_group.strips.iter().map(move |strip| {
-                    strip
-                        .indices()
-                        .map(move |index| group_indices[index] as usize)
-                        .map(move |index| {
-                            vertices[index].original_mesh_vertex_id as usize + mesh_vertex_offset
-                        })
-                })
-            })
     }
 }
 
 pub struct Mesh<'a> {
     model_vertex_offset: usize,
+    vertices: &'a [Vertex],
     mdl: &'a mdl::Mesh,
     vtx: &'a vtx::Mesh,
 }
 
 impl<'a> Mesh<'a> {
+    /// Vertex indices into the model's vertex list
     pub fn vertex_strip_indices(&self) -> impl Iterator<Item = impl Iterator<Item = usize> + '_> {
         let mdl_offset = self.mdl.vertex_offset as usize + self.model_vertex_offset;
         self.vtx.strip_groups.iter().flat_map(move |strip_group| {
@@ -148,6 +123,11 @@ impl<'a> Mesh<'a> {
     pub fn material_index(&self) -> i32 {
         self.mdl.material
     }
+
+    pub fn vertices(&self) -> impl Iterator<Item = &'a Vertex> + '_ {
+        self.vertex_strip_indices()
+            .flat_map(|strip| strip.map(|index| &self.vertices[index]))
+    }
 }
 
 fn read_indexes<I: Iterator<Item = usize> + 'static, T: Readable>(

src/mdl/mod.rs

@@ -20,7 +20,7 @@ pub struct Mdl {
     pub body_parts: Vec<BodyPart>,
     pub textures: Vec<TextureInfo>,
     pub texture_paths: Vec<String>,
-    pub skin_table: Vec<Vec<u16>>,
+    pub skin_table: Vec<u16>,
 }
 
 impl Mdl {
@@ -37,13 +37,7 @@ impl Mdl {
         .map(|path| path.map(|path| path.replace('\\', "/")))
         .collect::<Result<Vec<_>>>()?;
 
-        let raw_skin_table = read_relative::<u16, _>(data, header.skin_reference_indexes())?;
+        let skin_table = read_relative::<u16, _>(data, header.skin_reference_indexes())?;
-        let skin_table = raw_skin_table
-            .chunks(header.skin_reference_count as usize)
-            .map(|chunk| chunk.into())
-            .collect();
-
-        dbg!(raw_skin_table);
 
         let bones = read_indexes(header.bone_indexes(), data).collect::<Result<_>>()?;
         Ok(Mdl {