use std::path::{Path, PathBuf};
use crate::transform::Transform;
use crate::vmf::entities::Entity;
use crate::vmf::world::World;
use crate::{EntId, VmfFile, VmfResult};
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Instance {
pub file: usize,
pub parent: Option<(usize, EntId)>,
pub transform: Transform,
}
#[derive(Debug)]
pub struct VmfSystem {
pub files: Vec<VmfFile>,
pub instances: Vec<Instance>,
pub search_dirs: Vec<PathBuf>,
pub warnings: Vec<String>,
}
#[derive(Debug, Clone)]
pub struct Flattened {
pub vmf: VmfFile,
pub sources: Vec<(usize, EntId)>,
}
impl VmfSystem {
pub fn open(path: impl AsRef<Path>) -> VmfResult<Self> {
Self::open_with(path, Vec::new())
}
pub fn open_with(path: impl AsRef<Path>, search_dirs: Vec<PathBuf>) -> VmfResult<Self> {
let root = VmfFile::open(path.as_ref().canonicalize()?)?;
let mut system = Self {
files: vec![root],
instances: Vec::new(),
search_dirs,
warnings: Vec::new(),
};
system.relink();
Ok(system)
}
pub fn relink(&mut self) {
self.warnings.clear();
self.instances.clear();
self.instances.push(Instance {
file: 0,
parent: None,
transform: Transform::IDENTITY,
});
let mut current = 0;
while current < self.instances.len() {
let vmf = &self.files[self.instances[current].file];
let placer = vmf.path.clone().unwrap_or_default();
let dir = Path::new(&placer).parent().map(Path::to_path_buf);
let links: Vec<(u32, String, Transform)> = vmf
.entities
.iter()
.enumerate()
.filter(|(_, ent)| is_class(ent, "func_instance"))
.filter_map(|(idx, ent)| {
Some((
idx as u32,
ent.get("file")?.clone(),
Transform::from_entity(ent),
))
})
.collect();
for (idx, name, local) in links {
let Some(file) = self.load(&name, dir.as_deref(), &placer) else {
continue;
};
if self.chain(current).any(|i| self.instances[i].file == file) {
self.warnings
.push(format!("{placer}: instance '{name}' includes itself"));
continue;
}
let transform = self.instances[current].transform * local;
self.instances.push(Instance {
file,
parent: Some((current, EntId { hidden: false, idx })),
transform,
});
}
current += 1;
}
}
pub fn chain(&self, instance: usize) -> impl Iterator<Item = usize> {
std::iter::successors(Some(instance), |&i| {
self.instances[i].parent.map(|(parent, _)| parent)
})
}
pub fn iter_entities(&self) -> impl Iterator<Item = (usize, EntId, &Entity)> {
self.files
.iter()
.enumerate()
.flat_map(|(file, vmf)| vmf.iter_entities().map(move |(id, ent)| (file, id, ent)))
}
pub fn iter_entities_mut(&mut self) -> impl Iterator<Item = (usize, EntId, &mut Entity)> {
self.files.iter_mut().enumerate().flat_map(|(file, vmf)| {
vmf.iter_entities_mut()
.map(move |(id, ent)| (file, id, ent))
})
}
pub fn flatten(&self) -> Flattened {
let root = &self.files[0];
let mut vmf = VmfFile {
path: None,
versioninfo: root.versioninfo.clone(),
visgroups: root.visgroups.clone(),
viewsettings: root.viewsettings.clone(),
world: World {
key_values: root.world.key_values.clone(),
groups: root.world.groups.clone(),
extra: root.world.extra.clone(),
..Default::default()
},
cameras: root.cameras.clone(),
cordons: root.cordons.clone(),
extra_blocks: root.extra_blocks.clone(),
..Default::default()
};
let mut sources = Vec::new();
for (index, inst) in self.instances.iter().enumerate() {
let file = &self.files[inst.file];
for solid in &file.world.solids {
let mut solid = solid.clone();
inst.transform.apply_solid(&mut solid);
vmf.world.solids.push(solid);
}
for (idx, ent) in file.entities.iter().enumerate() {
if is_class(ent, "func_instance") || is_class(ent, "func_instance_parms") {
continue;
}
let mut ent = ent.clone();
inst.transform.apply_entity(&mut ent);
vmf.entities.push(ent);
sources.push((index, EntId { hidden: false, idx: idx as u32 }));
}
}
Flattened { vmf, sources }
}
pub fn save(&self) -> VmfResult<()> {
for vmf in &self.files {
if let Some(path) = &vmf.path {
vmf.save(path)?;
}
}
Ok(())
}
fn load(&mut self, name: &str, dir: Option<&Path>, placer: &str) -> Option<usize> {
if name.trim().is_empty() {
return None;
}
let Some(path) = resolve(name, dir, &self.search_dirs) else {
self.warnings
.push(format!("{placer}: instance '{name}' not found"));
return None;
};
let loaded = self
.files
.iter()
.position(|vmf| vmf.path.as_deref().map(Path::new) == Some(path.as_path()));
if loaded.is_some() {
return loaded;
}
match VmfFile::open(&path) {
Ok(vmf) => {
self.files.push(vmf);
Some(self.files.len() - 1)
}
Err(err) => {
self.warnings
.push(format!("{placer}: instance '{}': {err}", path.display()));
None
}
}
}
}
fn is_class(ent: &Entity, class: &str) -> bool {
ent.classname()
.is_some_and(|name| name.eq_ignore_ascii_case(class))
}
fn resolve(name: &str, dir: Option<&Path>, search_dirs: &[PathBuf]) -> Option<PathBuf> {
let mut relative = PathBuf::from(name.trim().replace('\\', "/"));
relative.set_extension("vmf");
let maps = dir.and_then(|dir| {
dir.ancestors()
.filter(|dir| {
dir.file_name()
.is_some_and(|name| name.eq_ignore_ascii_case("maps"))
})
.last()
});
dir.into_iter()
.chain(maps)
.chain(search_dirs.iter().map(PathBuf::as_path))
.map(|base| base.join(&relative))
.find(|candidate| candidate.is_file())?
.canonicalize()
.ok()
}