Add LTEX trimming and replacing

Author: Assumeru

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "StandardsValidator"
-version = "2.23.1"
+version = "2.24.0"
 edition = "2021"
 
 [dependencies]

Cargo.toml

@@ -39,3 +39,12 @@ This check computes the Levenshtein distance between NPC names. It also checks i
 `StandardsValidator.exe --names [mode] Morrowind.esm Tribunal.esm Bloodmoon.esm Tamriel_Data.esm file.esp`
 
 Like `--extended` above, this mode attempts to load master files automatically.
+
+# Land texture cleaner
+To remove unused LTEX from a plugin:
+
+`StandardsValidator.exe [mode] inputfile.esp --trim-ltex outputfile.esp`
+
+To also replace all uses of the `daedric stone` texture with the `ma_lavaridge` texture and all uses of `gl_grass_05` with `daedric stone`:
+
+`StandardsValidator.exe [mode] inputfile.esp --trim-ltex outputfile.esp --replace-ltex "daedric stone" "ma_lavaridge" --replace-ltex gl_grass_05 "daedric stone"`

README.md

@@ -0,0 +1,99 @@
+use std::collections::{HashMap, HashSet};
+
+use tes3::esp::{Landscape, LandscapeTexture, Plugin, TES3Object};
+
+fn build_replacement_table(
+    replacements: HashMap<String, String>,
+    textures: &[LandscapeTexture],
+) -> Result<HashMap<u32, u32>, String> {
+    let mut replace = HashMap::new();
+    for (current, replacement) in replacements {
+        if let Some(current_ltex) = textures
+            .iter()
+            .find(|ltex| ltex.id.eq_ignore_ascii_case(&current))
+        {
+            if let Some(replacement_ltex) = textures
+                .iter()
+                .find(|ltex| ltex.id.eq_ignore_ascii_case(&replacement))
+            {
+                if replace
+                    .insert(current_ltex.index + 1, replacement_ltex.index + 1)
+                    .is_some()
+                {
+                    return Err(format!("Found multiple replacements for LTEX {}", current));
+                }
+            } else {
+                println!(
+                    "Not replacing LTEX {} with {} because the latter doesn't exist",
+                    current, replacement
+                );
+            }
+        } else {
+            println!("Not replacing LTEX {} because it doesn't exist", current);
+        }
+    }
+    Ok(replace)
+}
+
+fn replace_textures(plugin: &mut Plugin, replace: HashMap<u32, u32>) -> HashSet<u32> {
+    let mut used = HashSet::new();
+    for landscape in plugin.objects_of_type_mut::<Landscape>() {
+        for row in landscape.texture_indices.data.as_mut_slice() {
+            for index in row {
+                if let Some(replacement) = replace.get(&(*index as u32)) {
+                    *index = *replacement as u16;
+                }
+                if *index > 0 {
+                    used.insert((*index as u32) - 1);
+                }
+            }
+        }
+    }
+    used
+}
+
+fn is_ltex(object: &TES3Object) -> bool {
+    matches!(object, TES3Object::LandscapeTexture(_))
+}
+
+pub fn deduplicate_ltex(
+    plugin: &mut Plugin,
+    replacements: HashMap<String, String>,
+) -> Result<(), String> {
+    let mut textures: Vec<LandscapeTexture> = plugin
+        .objects_of_type::<LandscapeTexture>()
+        .cloned()
+        .collect();
+    if textures.is_empty() {
+        return Err("Plugin did not contain any landscape textures".to_string());
+    }
+    let replace = build_replacement_table(replacements, &textures)?;
+    let used = replace_textures(plugin, replace);
+
+    let original_size = textures.len();
+    textures.retain(|ltex| used.contains(&ltex.index));
+    let removed = original_size - textures.len();
+    println!("Found {} unused landscape textures", removed);
+
+    let mut new_indices = HashMap::new();
+    for (index, texture) in textures.iter_mut().enumerate() {
+        let current = texture.index;
+        texture.index = index as u32;
+        new_indices.insert(current + 1, texture.index + 1);
+    }
+    replace_textures(plugin, new_indices);
+
+    let (first_ltex, _) = plugin
+        .objects
+        .iter()
+        .enumerate()
+        .find(|(_, object)| is_ltex(object))
+        .unwrap();
+    plugin.objects.retain(|object| !is_ltex(object));
+    plugin.objects.splice(
+        first_ltex..first_ltex,
+        textures.into_iter().map(TES3Object::LandscapeTexture),
+    );
+
+    Ok(())
+}

src/ltex.rs

@@ -1,15 +1,18 @@
-use clap::{crate_version, Arg, ArgGroup, ArgMatches, Command};
+use clap::{crate_version, Arg, ArgAction, ArgGroup, ArgMatches, Command};
 use context::{Context, Mode};
 use extended::ExtendedValidator;
 use oob::fix_oob;
-use std::{error::Error, fs, path::Path};
+use std::{collections::HashMap, error::Error, fs, path::Path};
 use tes3::esp::Plugin;
 use toml::{Table, Value};
 use validators::Validator;
 
+use crate::ltex::deduplicate_ltex;
+
 mod context;
 mod extended;
 mod handlers;
+mod ltex;
 mod oob;
 mod util;
 mod validators;
@@ -20,6 +23,10 @@ static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 fn main() -> Result<(), Box<dyn Error>> {
     let args = Command::new("StandardsValidator")
         .args(&[
+            Arg::new("ltexdedup")
+                .long("trim-ltex")
+                .value_name("output file")
+                .help("Remove unused landscape textures and save the trimmed output to a new file. Warning: overwrites the output file!"),
             Arg::new("ooboutput")
                 .long("fix-out-of-bounds")
                 .value_name("output file")
@@ -60,6 +67,13 @@ fn main() -> Result<(), Box<dyn Error>> {
                     "Squared distance at which two objects with the same id, \
                 scale, and orientation are considered duplicates.",
                 ),
+            Arg::new("replaceltex")
+                .long("replace-ltex")
+                .num_args(2)
+                .action(ArgAction::Append)
+                .requires("ltexdedup")
+                .value_names(["original", "new"])
+                .help("Replaces all uses of landscape textures with the original id with the new one"),
             Arg::new("mode")
                 .required(true)
                 .value_parser(["PT", "TD", "TR", "Vanilla"])
@@ -70,16 +84,22 @@ fn main() -> Result<(), Box<dyn Error>> {
                 .help("C:/path/to/plugin.esp"),
         ])
         .groups([
-            ArgGroup::new("g_validator").args(["duplicatethreshold"]),
+            ArgGroup::new("g_ltex").args(["ltexdedup"]),
+            ArgGroup::new("g_ltexreplace")
+                .args(["replaceltex"])
+                .requires("g_ltex"),
+            ArgGroup::new("g_validator")
+                .args(["duplicatethreshold"])
+                .conflicts_with("g_ltex"),
             ArgGroup::new("g_extended")
                 .args(["extended", "names"])
-                .conflicts_with("g_validator"),
+                .conflicts_with_all(["g_validator", "g_ltex"]),
             ArgGroup::new("g_autoload")
                 .arg("dontautoload")
                 .requires("g_extended"),
             ArgGroup::new("g_oob")
                 .arg("ooboutput")
-                .conflicts_with_all(["g_validator", "g_extended"]),
+                .conflicts_with_all(["g_validator", "g_extended", "g_ltex"]),
         ])
         .version(crate_version!())
         .get_matches();
@@ -94,6 +114,9 @@ fn main() -> Result<(), Box<dyn Error>> {
     if let Some(output) = args.get_one::<String>("ooboutput") {
         return run_oob_fixes(paths.next().unwrap(), output);
     }
+    if let Some(output) = args.get_one::<String>("ltexdedup") {
+        return run_ltex_dedup(paths.next().unwrap(), output, &args);
+    }
 
     validate(paths.next().unwrap(), &args)
 }
@@ -212,3 +235,21 @@ fn run_oob_fixes(input: &str, output: &str) -> Result<(), Box<dyn Error>> {
     plugin.save_path(output)?;
     Ok(())
 }
+
+fn run_ltex_dedup(input: &str, output: &str, args: &ArgMatches) -> Result<(), Box<dyn Error>> {
+    let mut replacements = HashMap::new();
+    if args.contains_id("replaceltex") {
+        let vals: Vec<Vec<&String>> = args
+            .get_occurrences("replaceltex")
+            .unwrap()
+            .map(Iterator::collect)
+            .collect();
+        for pair in vals {
+            replacements.insert(pair[0].clone(), pair[1].clone());
+        }
+    }
+    let mut plugin = load_plugin(input, None)?;
+    deduplicate_ltex(&mut plugin, replacements)?;
+    plugin.save_path(output)?;
+    Ok(())
+}