robin/vmdl
1
0
Fork 0
mirror of https://codeberg.org/icewind/vmdl.git synced 2026-06-03 16:44:11 +02:00
Code Issues Projects Releases Packages Wiki Activity

some cleanup

Browse source
This commit is contained in:
Robin Appelman 2023-12-10 15:52:21 +01:00
commit 0ec18ddbc8
3 changed files with 50 additions and 91 deletions
Download patch file Download diff file Expand all files Collapse all files

74
src/lib.rs
View file

@ -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>] {
&self.mdl.skin_table
pub fn skin_tables(&self) -> impl Iterator<Item = SkinTable> {
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> + '_> {
let mesh_vertex_offsets = self
.mdl
.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)
});
pub struct SkinTable<'a> {
textures: &'a [TextureInfo],
table: &'a [u16],
}
let vtx_meshes = self
.vtx
.body_parts
.iter()
.flat_map(|part| part.models.iter())
.flat_map(|model| model.lods.first())
.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
})
})
})
impl<'a> SkinTable<'a> {
pub fn texture(&self, index: i32) -> Option<&'a str> {
let texture_index = self.table.get(index as usize)?;
self.textures
.get(*texture_index as usize)
.map(|info| info.name.as_str())
}
}
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>(

10
src/mdl/mod.rs
View file

@ -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 = raw_skin_table
.chunks(header.skin_reference_count as usize)
.map(|chunk| chunk.into())
.collect();
dbg!(raw_skin_table);
let skin_table = read_relative::<u16, _>(data, header.skin_reference_indexes())?;
let bones = read_indexes(header.bone_indexes(), data).collect::<Result<_>>()?;
Ok(Mdl {