mirror of
https://codeberg.org/icewind/vmdl.git
synced 2026-06-03 16:44:11 +02:00
use new material loading
This commit is contained in:
parent
655c4a561f
commit
585a485031
10 changed files with 266 additions and 491 deletions
|
|
@ -1,97 +0,0 @@
|
|||
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 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 load_from_paths(&self, name: &str, paths: &[String]) -> Result<Vec<u8>, LoadError> {
|
||||
for path in paths {
|
||||
if let Ok(data) = self.load(&format!("{}{}", path, name)) {
|
||||
return Ok(data);
|
||||
}
|
||||
}
|
||||
error!("Failed to find {} in vpk paths: {}", name, paths.join(", "));
|
||||
Err(LoadError::Other("Can't find file in vpks"))
|
||||
}
|
||||
}
|
||||
|
|
@ -1,33 +1,20 @@
|
|||
#[path = "../common/error.rs"]
|
||||
mod error;
|
||||
#[path = "../common/loader.rs"]
|
||||
mod loader;
|
||||
#[path = "../common/materials.rs"]
|
||||
mod material;
|
||||
|
||||
use crate::loader::{LoadError, Loader};
|
||||
use crate::material::load_material_fallback;
|
||||
use crate::error::Error;
|
||||
use crate::loader::Loader;
|
||||
use crate::material::{load_material_fallback, MaterialData};
|
||||
use image::GenericImageView;
|
||||
use std::env::args_os;
|
||||
use std::path::PathBuf;
|
||||
use thiserror::Error;
|
||||
use three_d::*;
|
||||
use tracing::error;
|
||||
use vmdl::{Model, Vector};
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
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)]
|
||||
Render(#[from] RendererError),
|
||||
#[error(transparent)]
|
||||
Loader(#[from] LoadError),
|
||||
#[error(transparent)]
|
||||
Vtf(#[from] vtf::Error),
|
||||
#[error("{0}")]
|
||||
Other(&'static str),
|
||||
}
|
||||
|
||||
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
||||
#[allow(missing_docs)]
|
||||
pub enum DebugType {
|
||||
|
|
@ -294,6 +281,7 @@ fn model_to_model(model: &Model, loader: &Loader, skin: usize) -> CpuModel {
|
|||
.textures()
|
||||
.iter()
|
||||
.map(|texture| load_material_fallback(&texture.name, model.texture_directories(), loader))
|
||||
.map(convert_material)
|
||||
.collect();
|
||||
|
||||
CpuModel {
|
||||
|
|
@ -301,3 +289,51 @@ fn model_to_model(model: &Model, loader: &Loader, skin: usize) -> CpuModel {
|
|||
geometries,
|
||||
}
|
||||
}
|
||||
|
||||
fn convert_material(material: MaterialData) -> CpuMaterial {
|
||||
CpuMaterial {
|
||||
albedo: Color::new(
|
||||
material.color[0],
|
||||
material.color[1],
|
||||
material.color[2],
|
||||
material.color[3],
|
||||
),
|
||||
name: material.name,
|
||||
albedo_texture: material
|
||||
.texture
|
||||
.map(|tex| convert_texture(tex, material.translucent | material.alpha_test.is_some())),
|
||||
alpha_cutout: material.alpha_test,
|
||||
normal_texture: material.bump_map.map(|tex| convert_texture(tex, true)),
|
||||
..CpuMaterial::default()
|
||||
}
|
||||
}
|
||||
fn convert_texture(texture: material::TextureData, keep_alpha: bool) -> CpuTexture {
|
||||
let width = texture.image.width();
|
||||
let height = texture.image.height();
|
||||
let data = if keep_alpha {
|
||||
TextureData::RgbaU8(
|
||||
texture
|
||||
.image
|
||||
.into_rgba8()
|
||||
.pixels()
|
||||
.map(|pixel| pixel.0)
|
||||
.collect(),
|
||||
)
|
||||
} else {
|
||||
TextureData::RgbU8(
|
||||
texture
|
||||
.image
|
||||
.into_rgb8()
|
||||
.pixels()
|
||||
.map(|pixel| pixel.0)
|
||||
.collect(),
|
||||
)
|
||||
};
|
||||
CpuTexture {
|
||||
data,
|
||||
name: texture.name,
|
||||
height,
|
||||
width,
|
||||
..CpuTexture::default()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,178 +0,0 @@
|
|||
use crate::loader::Loader;
|
||||
use crate::Error;
|
||||
use std::str::FromStr;
|
||||
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()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn get_path(vmt: &Entry, name: &str) -> Option<String> {
|
||||
Some(vmt.lookup(name)?.as_str()?.replace('\\', "/"))
|
||||
}
|
||||
|
||||
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()
|
||||
.cloned()
|
||||
.ok_or(Error::Other("empty vmt"))?;
|
||||
let base_texture = get_path(&table, "$basetexture").ok_or(Error::Other("no $basetexture"))?;
|
||||
|
||||
let translucent = table
|
||||
.lookup("$translucent")
|
||||
.map(|val| val.as_str() == Some("1"))
|
||||
.unwrap_or_default();
|
||||
let glass = table
|
||||
.lookup("$surfaceprop")
|
||||
.map(|val| val.as_str() == Some("glass"))
|
||||
.unwrap_or_default();
|
||||
let alpha_test = table
|
||||
.lookup("$alphatest")
|
||||
.map(|val| val.as_str() == Some("1"))
|
||||
.unwrap_or_default();
|
||||
let texture = load_texture(
|
||||
base_texture.as_str(),
|
||||
loader,
|
||||
translucent | glass | alpha_test,
|
||||
)?;
|
||||
|
||||
let alpha_cutout = table
|
||||
.lookup("$alphatestreference")
|
||||
.and_then(Entry::as_str)
|
||||
.and_then(|val| f32::from_str(val).ok())
|
||||
.unwrap_or(1.0);
|
||||
|
||||
let bump_map = get_path(&table, "$bumpmap")
|
||||
.map(|path| load_texture(&path, loader, true).ok())
|
||||
.flatten();
|
||||
|
||||
Ok(CpuMaterial {
|
||||
name: name.into(),
|
||||
albedo: Color::WHITE,
|
||||
albedo_texture: Some(texture),
|
||||
alpha_cutout: alpha_test.then_some(alpha_cutout),
|
||||
normal_texture: bump_map,
|
||||
..CpuMaterial::default()
|
||||
})
|
||||
}
|
||||
|
||||
fn parse_vdf(bytes: &[u8]) -> Result<Table, Error> {
|
||||
let bytes = bytes.to_ascii_lowercase();
|
||||
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, alpha: bool) -> 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)?;
|
||||
let texture_data = if alpha {
|
||||
TextureData::RgbaU8(image.into_rgba8().pixels().map(|pixel| pixel.0).collect())
|
||||
} else {
|
||||
TextureData::RgbU8(image.into_rgb8().pixels().map(|pixel| pixel.0).collect())
|
||||
};
|
||||
Ok(CpuTexture {
|
||||
name: name.into(),
|
||||
data: texture_data,
|
||||
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)
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue