robin/vmdl
1
0
Fork 0
mirror of https://codeberg.org/icewind/vmdl.git synced 2026-06-03 08:34:23 +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

105
Cargo.lock generated
View file

@ -201,6 +201,12 @@ version = "0.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
[[package]]
name = "beef"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1"
[[package]]
name = "binrw"
version = "0.13.3"
@ -1458,6 +1464,38 @@ version = "0.4.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
[[package]]
name = "logos"
version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c000ca4d908ff18ac99b93a062cb8958d331c3220719c52e77cb19cc6ac5d2c1"
dependencies = [
"logos-derive",
]
[[package]]
name = "logos-codegen"
version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc487311295e0002e452025d6b580b77bb17286de87b57138f3b5db711cded68"
dependencies = [
"beef",
"fnv",
"proc-macro2",
"quote",
"regex-syntax 0.6.29",
"syn 2.0.40",
]
[[package]]
name = "logos-derive"
version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dbfc0d229f1f42d790440136d941afd806bc9e949e2bcb8faa813b0f00d1267e"
dependencies = [
"logos-codegen",
]
[[package]]
name = "main_error"
version = "0.1.2"
@ -1538,12 +1576,6 @@ dependencies = [
"syn 2.0.40",
]
[[package]]
name = "minimal-lexical"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
[[package]]
name = "miniz_oxide"
version = "0.3.7"
@ -1674,16 +1706,6 @@ version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"
[[package]]
name = "nom"
version = "7.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
dependencies = [
"memchr",
"minimal-lexical",
]
[[package]]
name = "nu-ansi-term"
version = "0.46.0"
@ -2166,6 +2188,12 @@ dependencies = [
"regex-syntax 0.8.2",
]
[[package]]
name = "regex-syntax"
version = "0.6.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
[[package]]
name = "regex-syntax"
version = "0.7.5"
@ -2299,6 +2327,17 @@ dependencies = [
"serde",
]
[[package]]
name = "serde_repr"
version = "0.1.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3081f5ffbb02284dda55132aa26daecedd7372a42417bbbab6f14ab7d6bb9145"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.40",
]
[[package]]
name = "servo-fontconfig"
version = "0.5.1"
@ -2415,14 +2454,6 @@ dependencies = [
"winreg",
]
[[package]]
name = "steamy-vdf"
version = "0.3.0"
source = "git+https://github.com/icewind1991/steamy?branch=nom7#56b737b329ec27c198669d1f4fef9d827be80470"
dependencies = [
"nom",
]
[[package]]
name = "strsim"
version = "0.10.0"
@ -2805,6 +2836,18 @@ version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
[[package]]
name = "vdf-reader"
version = "0.1.0"
source = "git+https://github.com/icewind1991/vdf-reader#31977b9340e915944eeb27c96f3199f7c5560376"
dependencies = [
"logos",
"miette",
"parse-display",
"serde",
"thiserror",
]
[[package]]
name = "vec_map"
version = "0.8.2"
@ -2836,15 +2879,27 @@ dependencies = [
"miette",
"static_assertions",
"steamlocate",
"steamy-vdf",
"thiserror",
"three-d",
"tracing",
"tracing-subscriber",
"vmt-parser",
"vpk",
"vtf",
]
[[package]]
name = "vmt-parser"
version = "0.1.0"
source = "git+https://github.com/icewind1991/vmt-parser#40ffcb41debc5cc0561255401f48abe9c11d4d32"
dependencies = [
"miette",
"serde",
"serde_repr",
"thiserror",
"vdf-reader",
]
[[package]]
name = "vpk"
version = "0.2.0"

2
Cargo.toml
View file

@ -24,12 +24,12 @@ vtf = "0.1.6"
vpk = "0.2.0"
tracing = "0.1.40"
tracing-subscriber = "0.3.18"
steamy-vdf = { version = "0.3.0", git = "https://github.com/icewind1991/steamy", branch = "nom7" }
gltf-json = "1.3.0"
gltf = "1.3.0"
image = "0.23.14"
clap = { version = "4.4.11", features = ["derive"] }
main_error = "0.1.2"
vmt-parser = { version = "0.1", git = "https://github.com/icewind1991/vmt-parser" }
[[bench]]
name = "parse"

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