use new material loading

examples/common/error.rs

@@ -0,0 +1,29 @@
+use crate::loader::LoadError;
+use miette::Diagnostic;
+use std::string::FromUtf8Error;
+use thiserror::Error;
+use vmt_parser::VdfError;
+
+#[allow(dead_code)]
+#[derive(Debug, Error, Diagnostic)]
+pub enum Error {
+    #[error(transparent)]
+    Three(#[from] Box<dyn std::error::Error>),
+    #[error(transparent)]
+    Mdl(#[from] vmdl::ModelError),
+    #[error(transparent)]
+    IO(#[from] std::io::Error),
+    #[error(transparent)]
+    Loader(#[from] LoadError),
+    #[error(transparent)]
+    Vtf(#[from] vtf::Error),
+    #[error(transparent)]
+    #[diagnostic(transparent)]
+    Vdf(#[from] VdfError),
+    #[error("{0}")]
+    Other(String),
+    #[error("Skin index out of bounds: {0}, model only has {1} skins")]
+    SkinOutOfBounds(u16, u16),
+    #[error(transparent)]
+    Utf8(#[from] FromUtf8Error),
+}

examples/common/loader.rs

@@ -0,0 +1,118 @@
+use std::fmt::{Debug, Formatter};
+use std::fs;
+use std::path::PathBuf;
+use steamlocate::SteamDir;
+use thiserror::Error;
+use tracing::{debug, error, info};
+use vpk::VPK;
+
+#[derive(Debug, Error)]
+pub enum LoadError {
+    #[error("{0}")]
+    Other(&'static str),
+    #[error(transparent)]
+    IO(#[from] std::io::Error),
+}
+
+impl From<&'static str> for LoadError {
+    fn from(e: &'static str) -> Self {
+        LoadError::Other(e)
+    }
+}
+
+pub struct Loader {
+    tf_dir: PathBuf,
+    download: PathBuf,
+    vpks: Vec<VPK>,
+}
+
+impl Debug for Loader {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Loader")
+            .field("tf_dir", &self.tf_dir)
+            .finish_non_exhaustive()
+    }
+}
+
+impl Loader {
+    pub fn new() -> Result<Self, LoadError> {
+        let tf_dir = SteamDir::locate()
+            .ok_or("Can't find steam directory")?
+            .app(&440)
+            .ok_or("Can't find tf2 directory")?
+            .path
+            .join("tf");
+        let download = tf_dir.join("download");
+        let vpks = tf_dir
+            .read_dir()?
+            .filter_map(|item| item.ok())
+            .filter_map(|item| Some(item.path().to_str()?.to_string()))
+            .filter(|path| path.ends_with("dir.vpk"))
+            .map(|path| vpk::from_path(&path))
+            .filter_map(|res| res.ok())
+            .collect();
+
+        Ok(Loader {
+            tf_dir,
+            download,
+            vpks,
+        })
+    }
+
+    #[tracing::instrument]
+    pub fn exists(&self, name: &str) -> bool {
+        debug!("loading {}", name);
+        if name.ends_with("bsp") {
+            let path = self.tf_dir.join(name);
+            if path.exists() {
+                return true;
+            }
+            let path = self.download.join(name);
+            if path.exists() {
+                return true;
+            }
+        }
+        for vpk in self.vpks.iter() {
+            if vpk.tree.contains_key(name) {
+                return true;
+            }
+        }
+        false
+    }
+
+    #[tracing::instrument]
+    pub fn load(&self, name: &str) -> Result<Vec<u8>, LoadError> {
+        debug!("loading {}", name);
+        if name.ends_with("bsp") {
+            let path = self.tf_dir.join(name);
+            if path.exists() {
+                debug!("found in tf2 dir");
+                return Ok(fs::read(path)?);
+            }
+            let path = self.download.join(name);
+            if path.exists() {
+                debug!("found in download dir");
+                return Ok(fs::read(path)?);
+            }
+        }
+        for vpk in self.vpks.iter() {
+            if let Some(entry) = vpk.tree.get(name) {
+                let data = entry.get()?.into_owned();
+                debug!("got {} bytes from vpk", data.len());
+                return Ok(data);
+            }
+        }
+        info!("Failed to find {} in vpk", name);
+        Err(LoadError::Other("Can't find file in vpks"))
+    }
+
+    pub fn find_in_paths(&self, name: &str, paths: &[String]) -> Option<String> {
+        for path in paths {
+            let full_path = format!("{}{}", path, name);
+            if self.exists(&full_path) {
+                return Some(full_path);
+            }
+        }
+        None
+    }
+}

examples/common/materials.rs

@@ -0,0 +1,109 @@
+use crate::loader::{LoadError, Loader};
+use crate::Error;
+use image::DynamicImage;
+use tracing::{error, instrument};
+use vmt_parser::from_str;
+use vtf::vtf::VTF;
+
+pub fn load_material_fallback(name: &str, search_dirs: &[String], loader: &Loader) -> MaterialData {
+    match load_material(name, search_dirs, loader) {
+        Ok(mat) => mat,
+        Err(e) => {
+            error!(error = ?e, "failed to load material");
+            MaterialData {
+                name: name.into(),
+                color: [255, 0, 255, 255],
+                ..MaterialData::default()
+            }
+        }
+    }
+}
+
+#[derive(Default, Debug)]
+pub struct MaterialData {
+    pub name: String,
+    pub path: String,
+    pub color: [u8; 4],
+    pub texture: Option<TextureData>,
+    pub alpha_test: Option<f32>,
+    pub bump_map: Option<TextureData>,
+    pub translucent: bool,
+}
+
+#[derive(Debug)]
+pub struct TextureData {
+    pub name: String,
+    pub image: DynamicImage,
+}
+
+#[instrument(skip(loader))]
+pub fn load_material(
+    name: &str,
+    search_dirs: &[String],
+    loader: &Loader,
+) -> Result<MaterialData, 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().trim_end_matches(".vmt"));
+    let path = loader
+        .find_in_paths(&path, &dirs)
+        .ok_or(LoadError::Other("Can't find file in vpks"))?;
+    let raw = loader.load(&path)?;
+    let vdf = String::from_utf8(raw)?;
+
+    let material = from_str(&vdf).map_err(|e| {
+        let report = miette::ErrReport::new(e);
+        println!("{:?}", report);
+        Error::Other(format!("Failed to load material {}", path))
+    })?;
+    let material = material.resolve(|path| {
+        let data = loader.load(path)?;
+        let vdf = String::from_utf8(data)?;
+        Ok::<_, Error>(vdf)
+    })?;
+
+    let base_texture = material.base_texture();
+
+    let translucent = material.translucent();
+    let glass = material.surface_prop() == Some("glass");
+    let alpha_test = material.alpha_test();
+    let texture = load_texture(base_texture, loader)?;
+
+    let bump_map = material.bump_map().and_then(|path| {
+        Some(TextureData {
+            image: load_texture(&path, loader).ok()?,
+            name: path.into(),
+        })
+    });
+
+    Ok(MaterialData {
+        color: [255; 4],
+        name: name.into(),
+        path,
+        texture: Some(TextureData {
+            name: base_texture.into(),
+            image: texture,
+        }),
+        bump_map,
+        alpha_test,
+        translucent: translucent | glass,
+    })
+}
+
+fn load_texture(name: &str, loader: &Loader) -> Result<DynamicImage, 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(image)
+}