material handling

src/bsp.rs

@@ -1,10 +1,9 @@
+use crate::material::load_material_fallback;
 use crate::prop::load_props;
 use crate::{Error, Loader};
 use cgmath::vec4;
 use std::collections::HashMap;
-use three_d::{
-    Color, CpuMaterial, CpuMesh, CpuModel, CpuTexture, Mat4, Positions, TextureData, Vec2, Vec3,
-};
+use three_d::{CpuMesh, CpuModel, Mat4, Positions, Vec2, Vec3};
 use vbsp::{Bsp, Face, Handle};
 
 pub fn load_map(data: &[u8], loader: &mut Loader) -> Result<Vec<CpuModel>, Error> {
@@ -84,32 +83,7 @@ fn model_to_model(model: Handle<vbsp::data::Model>, loader: &Loader) -> CpuModel
         .values()
         .map(|face| {
             let texture = face.first().unwrap().texture();
-            let tex_file = format!("materials/{}.vtf", texture.name().to_lowercase());
-            let vtf_data = loader.load(&tex_file).ok();
-            let texture_data = vtf_data.and_then(|mut vtf_data| {
-                let vtf = vtf::from_bytes(&mut vtf_data).ok()?;
-                let image = vtf.highres_image.decode(0).ok()?;
-                Some(CpuTexture {
-                    name: texture.name().into(),
-                    data: TextureData::RgbaU8(
-                        image.into_rgba8().pixels().map(|pixel| pixel.0).collect(),
-                    ),
-                    height: texture.texture_data().height as u32,
-                    width: texture.texture_data().width as u32,
-                    ..CpuTexture::default()
-                })
-            });
-            let color = if texture_data.is_some() {
-                Color::default()
-            } else {
-                Color::new(255, 0, 255, 255)
-            };
-            CpuMaterial {
-                albedo: color,
-                albedo_texture: texture_data,
-                name: texture.name().into(),
-                ..Default::default()
-            }
+            load_material_fallback(texture.name(), &["".into()], loader)
         })
         .collect();
 

src/loader.rs

@@ -3,7 +3,7 @@ use std::fmt::{Debug, Formatter};
 use std::fs;
 use std::path::PathBuf;
 use steamlocate::SteamDir;
-use tracing::{debug, error};
+use tracing::{debug, error, info};
 use vbsp::Packfile;
 use vpk::VPK;
 
@@ -89,8 +89,8 @@ impl Loader {
                 return Ok(data);
             }
         }
-        error!("Failed to find {} in vpk", name);
-        Err(Error::Other("Can't find file in vpks"))
+        info!("Failed to find {} in vpk", name);
+        Err(Error::ResourceNotFound(name.to_string()))
     }
 
     pub fn load_from_paths(&self, name: &str, paths: &[String]) -> Result<Vec<u8>, Error> {
@@ -100,6 +100,6 @@ impl Loader {
             }
         }
         error!("Failed to find {} in vpk paths: {}", name, paths.join(", "));
-        Err(Error::Other("Can't find file in vpks"))
+        Err(Error::ResourceNotFound(name.to_string()))
     }
 }

src/main.rs

@@ -2,6 +2,7 @@ mod bsp;
 mod control;
 mod demo;
 mod loader;
+mod material;
 mod prop;
 mod renderer;
 mod ui;
@@ -9,6 +10,7 @@ mod wrapping;
 
 use clap::Parser;
 use std::fs;
+use std::string::FromUtf8Error;
 
 use crate::bsp::load_map;
 use crate::control::{Control, DemoCamera};
@@ -45,6 +47,8 @@ pub enum Error {
     #[error(transparent)]
     Vtf(#[from] vtf::Error),
     #[error(transparent)]
+    Vdf(#[from] steamy_vdf::Error),
+    #[error(transparent)]
     Mdl(#[from] vmdl::ModelError),
     #[error(transparent)]
     Demo(#[from] tf_demo_parser::ParseError),
@@ -54,6 +58,10 @@ pub enum Error {
     Window(#[from] WindowError),
     #[error(transparent)]
     Render(#[from] RendererError),
+    #[error(transparent)]
+    String(#[from] FromUtf8Error),
+    #[error("resource {0} not found in vpks or pack")]
+    ResourceNotFound(String),
 }
 
 impl From<&'static str> for Error {

src/material.rs

@@ -0,0 +1,127 @@
+use crate::loader::Loader;
+use crate::Error;
+use std::io::Cursor;
+use steamy_vdf::{Entry, Table};
+use three_d::{Color, CpuMaterial, CpuTexture, TextureData};
+use tracing::error;
+use vtf::vtf::VTF;
+
+pub fn load_material_fallback(name: &str, search_dirs: &[String], loader: &Loader) -> CpuMaterial {
+    match load_material(name, search_dirs, loader) {
+        Ok(material) => material,
+        Err(e) => {
+            error!(
+                material = name,
+                error = ?e,
+                "failed to load material, falling back"
+            );
+            CpuMaterial {
+                albedo: Color {
+                    r: 255,
+                    g: 0,
+                    b: 255,
+                    a: 255,
+                },
+                name: name.into(),
+                ..Default::default()
+            }
+        }
+    }
+}
+
+pub fn load_material(
+    name: &str,
+    search_dirs: &[String],
+    loader: &Loader,
+) -> Result<CpuMaterial, Error> {
+    let dirs = search_dirs
+        .iter()
+        .map(|dir| {
+            format!(
+                "materials/{}",
+                dir.to_ascii_lowercase().trim_start_matches("/")
+            )
+        })
+        .collect::<Vec<_>>();
+    let path = format!("{}.vmt", name.to_ascii_lowercase());
+    let raw = loader.load_from_paths(&path, &dirs)?;
+
+    let vmt = parse_vdf(raw)?;
+    let vmt = resolve_vmt_patch(vmt, loader)?;
+    let table = vmt
+        .values()
+        .next()
+        .expect("empty vmt")
+        .as_table()
+        .expect("vmt not a table");
+    let base_texture = table
+        .iter()
+        .find_map(|(key, value)| (key.to_ascii_lowercase() == "$basetexture").then_some(value))
+        .expect("no $basetexture")
+        .as_value()
+        .expect("$basetexture not a value")
+        .to_string()
+        .to_ascii_lowercase()
+        .replace('\\', "/")
+        .replace('\t', "/t");
+    let texture = load_texture(base_texture.as_str(), loader)?;
+    Ok(CpuMaterial {
+        name: name.into(),
+        albedo: Color::WHITE,
+        albedo_texture: Some(texture),
+        ..CpuMaterial::default()
+    })
+}
+
+fn parse_vdf(bytes: Vec<u8>) -> Result<Table, Error> {
+    let mut reader = steamy_vdf::read(Cursor::new(&bytes))?;
+    Table::load(&mut reader).map_err(|e| {
+        error!(
+            source = String::from_utf8_lossy(&bytes).to_string(),
+            "failed to parse vmt"
+        );
+        e.into()
+    })
+}
+
+fn load_texture(name: &str, loader: &Loader) -> Result<CpuTexture, Error> {
+    let path = format!(
+        "materials/{}.vtf",
+        name.trim_end_matches(".vtf").trim_start_matches("/")
+    );
+    let mut raw = loader.load(&path)?;
+    let vtf = VTF::read(&mut raw)?;
+    let image = vtf.highres_image.decode(0)?;
+    Ok(CpuTexture {
+        name: name.into(),
+        data: TextureData::RgbaU8(image.into_rgba8().pixels().map(|pixel| pixel.0).collect()),
+        height: vtf.header.height as u32,
+        width: vtf.header.width as u32,
+        ..CpuTexture::default()
+    })
+}
+
+fn resolve_vmt_patch(vmt: Table, loader: &Loader) -> Result<Table, Error> {
+    if vmt.len() != 1 {
+        panic!("vmt with more than 1 item?");
+    }
+    if let Some(Entry::Table(patch)) = vmt.get("patch") {
+        let include = patch
+            .get("include")
+            .expect("no include in patch")
+            .as_value()
+            .expect("include is not a value")
+            .to_string();
+        let _replace = patch
+            .get("replace")
+            .expect("no replace in patch")
+            .as_table()
+            .expect("replace is not a table");
+        let included_raw = loader.load(&include.to_ascii_lowercase())?;
+
+        // todo actually patch
+        parse_vdf(included_raw)
+    } else {
+        Ok(vmt)
+    }
+}

src/prop.rs

@@ -1,16 +1,14 @@
 use crate::bsp::{apply_transform, map_coords};
+use crate::material::load_material_fallback;
 use crate::{Error, Loader};
 use cgmath::{Matrix, SquareMatrix};
 use std::collections::HashMap;
-use three_d::{
-    Color, CpuMaterial, CpuMesh, CpuModel, CpuTexture, Mat4, Positions, TextureData, Vec2, Vec3,
-};
-use tracing::error;
+use three_d::{CpuMaterial, CpuMesh, CpuModel, Mat4, Positions, Vec2, Vec3};
+use tracing::warn;
 use vbsp::{Handle, StaticPropLump};
 use vmdl::mdl::{Mdl, TextureInfo};
 use vmdl::vtx::Vtx;
 use vmdl::vvd::Vvd;
-use vtf::vtf::VTF;
 
 #[tracing::instrument(skip(loader))]
 pub fn load_prop(loader: &Loader, name: &str) -> Result<vmdl::Model, Error> {
@@ -68,7 +66,7 @@ fn prop_to_meshes(prop: &PropData) -> impl Iterator<Item = CpuMesh> + '_ {
     let skin = match model.skin_tables().nth(prop.skin as usize) {
         Some(skin) => skin,
         None => {
-            error!(index = prop.skin, "invalid skin index");
+            warn!(index = prop.skin, "invalid skin index");
             model.skin_tables().next().unwrap()
         }
     };
@@ -104,40 +102,5 @@ fn prop_to_meshes(prop: &PropData) -> impl Iterator<Item = CpuMesh> + '_ {
 }
 
 fn prop_texture_to_material(texture: &TextureInfo, loader: &Loader) -> CpuMaterial {
-    match load_texture(&texture.name, &texture.search_paths, loader) {
-        Ok(texture) => CpuMaterial {
-            albedo: Color::default(),
-            name: texture.name.clone(),
-            albedo_texture: Some(texture),
-            ..Default::default()
-        },
-        Err(_) => CpuMaterial {
-            albedo: Color {
-                r: 255,
-                g: 0,
-                b: 255,
-                a: 255,
-            },
-            name: texture.name.clone(),
-            ..Default::default()
-        },
-    }
-}
-
-fn load_texture(name: &str, dirs: &[String], loader: &Loader) -> Result<CpuTexture, Error> {
-    let dirs = dirs
-        .iter()
-        .map(|dir| format!("materials/{}", dir))
-        .collect::<Vec<_>>();
-    let path = format!("{}.vtf", name);
-    let mut raw = loader.load_from_paths(&path, &dirs)?;
-    let vtf = VTF::read(&mut raw)?;
-    let image = vtf.highres_image.decode(0)?;
-    Ok(CpuTexture {
-        name: name.into(),
-        data: TextureData::RgbaU8(image.into_rgba8().pixels().map(|pixel| pixel.0).collect()),
-        height: vtf.header.height as u32,
-        width: vtf.header.width as u32,
-        ..CpuTexture::default()
-    })
+    load_material_fallback(&texture.name, &texture.search_paths, loader)
 }