update vdf and special case eye textures for now

examples/view/main.rs

@@ -1,6 +1,8 @@
 mod loader;
+mod material;
 
 use crate::loader::{LoadError, Loader};
+use crate::material::load_material_fallback;
 use std::env::args_os;
 use std::fs;
 use std::path::{Path, PathBuf};
@@ -11,10 +13,9 @@ use vmdl::mdl::Mdl;
 use vmdl::vtx::Vtx;
 use vmdl::vvd::Vvd;
 use vmdl::{Model, Vector};
-use vtf::vtf::VTF;
 
 #[derive(Debug, Error)]
-enum Error {
+pub enum Error {
     #[error(transparent)]
     Three(#[from] Box<dyn std::error::Error>),
     #[error(transparent)]
@@ -27,6 +28,8 @@ enum Error {
     Loader(#[from] LoadError),
     #[error(transparent)]
     Vtf(#[from] vtf::Error),
+    #[error("{0}")]
+    Other(&'static str),
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -306,30 +309,7 @@ fn model_to_model(model: &Model, loader: &Loader, skin: usize) -> CpuModel {
     let materials = model
         .textures()
         .iter()
-        .map(|texture| {
-            let dirs = model.texture_directories();
-            match load_texture(&texture.name, dirs, loader) {
-                Ok(texture) => CpuMaterial {
-                    albedo: Color::default(),
-                    name: texture.name.clone(),
-                    albedo_texture: Some(texture),
-                    ..Default::default()
-                },
-                Err(e) => {
-                    error!("{:#}", e);
-                    CpuMaterial {
-                        albedo: Color {
-                            r: 255,
-                            g: 0,
-                            b: 255,
-                            a: 255,
-                        },
-                        name: texture.name.clone(),
-                        ..Default::default()
-                    }
-                }
-            }
-        })
+        .map(|texture| load_material_fallback(&texture.name, model.texture_directories(), loader))
         .collect();
 
     CpuModel {
@@ -337,21 +317,3 @@ fn model_to_model(model: &Model, loader: &Loader, skin: usize) -> CpuModel {
         geometries,
     }
 }
-
-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()
-    })
-}

examples/view/material.rs

@@ -0,0 +1,158 @@
+use crate::loader::Loader;
+use crate::Error;
+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().trim_end_matches(".vmt"));
+    let raw = loader.load_from_paths(&path, &dirs)?;
+
+    let vmt = parse_vdf(raw)?;
+    let vmt = resolve_vmt_patch(vmt, loader)?;
+
+    let material_type = vmt
+        .keys()
+        .next()
+        .ok_or(Error::Other("empty vmt"))?
+        .to_ascii_lowercase();
+    if material_type == "water" {
+        return Ok(CpuMaterial {
+            albedo: Color {
+                r: 82,
+                g: 180,
+                b: 217,
+                a: 128,
+            },
+            name: name.into(),
+            ..Default::default()
+        });
+    }
+
+    let table = vmt
+        .values()
+        .next()
+        .ok_or(Error::Other("empty vmt"))?
+        .as_table()
+        .ok_or(Error::Other("vmt not a table"))?;
+    let base_texture = table
+        .iter()
+        .find_map(|(key, value)| (key.to_ascii_lowercase() == "$basetexture").then_some(value))
+        .or_else(|| {
+            table
+                .iter()
+                .find_map(|(key, value)| (key.to_ascii_lowercase() == "eyes_dx8").then_some(value))
+                .and_then(|eyes| eyes.as_table())
+                .and_then(|eyes| {
+                    eyes.iter().find_map(|(key, value)| {
+                        (key.to_ascii_lowercase() == "$basetexture").then_some(value)
+                    })
+                })
+        })
+        .ok_or(Error::Other("no $basetexture"))?
+        .as_value()
+        .ok_or(Error::Other("$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::Reader::from(bytes.as_slice());
+    Table::load(&mut reader).map_err(|e| {
+        println!("{}", String::from_utf8_lossy(&bytes));
+        error!(
+            source = String::from_utf8_lossy(&bytes).to_string(),
+            error = ?e,
+            "failed to parse vmt"
+        );
+        Error::Other("failed to parse vdf")
+    })
+}
+
+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)
+    }
+}