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

use new material loading

Browse source
This commit is contained in:
Robin Appelman 2023-12-19 17:21:12 +01:00
commit 585a485031
10 changed files with 266 additions and 491 deletions
Download patch file Download diff file Expand all files Collapse all files

13
examples/gltf/error.rs → examples/common/error.rs
View file

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

10
examples/gltf/loader.rs → examples/common/loader.rs
View file

@ -106,13 +106,13 @@ impl Loader {
Err(LoadError::Other("Can't find file in vpks"))
}
pub fn load_from_paths(&self, name: &str, paths: &[String]) -> Result<Vec<u8>, LoadError> {
pub fn find_in_paths(&self, name: &str, paths: &[String]) -> Option<String> {
for path in paths {
if self.exists(&format!("{}{}", path, name)) {
return self.load(&format!("{}{}", path, name));
let full_path = format!("{}{}", path, name);
if self.exists(&full_path) {
return Some(full_path);
}
}
error!("Failed to find {} in vpk paths: {}", name, paths.join(", "));
Err(LoadError::Other("Can't find file in vpks"))
None
}
}

109
examples/common/materials.rs Normal file
View file

@ -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)
}

3
examples/gltf/main.rs
View file

@ -1,6 +1,9 @@
mod convert;
#[path = "../common/error.rs"]
mod error;
#[path = "../common/loader.rs"]
mod loader;
#[path = "../common/materials.rs"]
mod material;
use gltf_json as json;

162
examples/gltf/material.rs
View file

@ -1,162 +0,0 @@
use crate::loader::Loader;
use crate::Error;
use image::DynamicImage;
use std::str::FromStr;
use steamy_vdf::{Entry, Table};
use tracing::error;
use vtf::vtf::VTF;
fn get_path(vmt: &Entry, name: &str) -> Option<String> {
Some(vmt.lookup(name)?.as_str()?.replace('\\', "/"))
}
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 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,
}
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 raw = loader.load_from_paths(&path, &dirs)?;
let vmt = parse_vdf(&raw)?;
let vmt = resolve_vmt_patch(vmt, loader)?;
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").and_then(|path| {
Some(TextureData {
image: load_texture(&path, loader, true).ok()?,
name: path,
})
});
Ok(MaterialData {
color: [255; 4],
name: name.into(),
texture: Some(TextureData {
name: base_texture,
image: texture,
}),
bump_map,
alpha_test: alpha_test.then_some(alpha_cutout),
translucent: translucent | glass | alpha_test,
})
}
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<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)
}
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)
}
}

97
examples/view/loader.rs
View file

@ -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"))
}
}

78
examples/view/main.rs
View file

@ -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()
}
}

178
examples/view/material.rs
View file

@ -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)
}
}