add lump hashing

Author: wyozi

Cargo.lock

@@ -12,7 +12,7 @@ edition = "2018"
 [features]
 default = ["workshop", "vtf", "bsp"]
 workshop = ["steamworks", "rust-lzma"]
-bsp = ["zip"]
+bsp = ["strum", "zip"]
 
 [dependencies]
 serde = { version = "1", features = ["derive"] }
@@ -31,6 +31,7 @@ lazy_static = "1"
 petgraph = "0.6"
 vtf = { version = "0.1", optional = true }
 zip = { version = "0.6", default-features = false, optional = true }
+strum = { version = "0.24", optional = true, features = ["derive"] }
 
 [[bin]]
 name = "gma"

Cargo.toml

@@ -1,10 +1,13 @@
 use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
+use std::collections::hash_map::DefaultHasher;
 use std::fs::File;
+use std::hash::Hasher;
 use std::io::{self, BufWriter};
 use std::io::{BufReader, Read};
 use std::path::{Path, PathBuf};
 use steamws::bsp::BSPHeader;
 use steamws::bsp::{lump_indices::LumpIndex, BSPReader};
+use strum::IntoEnumIterator;
 
 use clap::{Args, Parser, Subcommand};
 
@@ -31,6 +34,12 @@ enum SubCommand {
 struct InfoCommand {
     /// Source bsp
     input: PathBuf,
+
+    /// Print information about lumps
+    /// Includes length, offset, ident
+    /// Also calculates and print lump hashes (using arbitrary hashing algorithm, just for comparison purposes)
+    #[arg{short, long}]
+    lumps: bool,
 }
 
 #[derive(Args)]
@@ -67,13 +76,21 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             println!("map version = {}", bsp_reader.header().version);
             println!("map revision = {}", bsp_reader.header().map_revision);
 
-            println!("===");
+            if t.lumps {
+                let bsp = bsp_reader.into_buffered_bsp();
+                println!("===");
+
+                for lump_index in LumpIndex::iter() {
+                    let mut hasher = DefaultHasher::new();
+                    hasher.write(bsp.lump_slice(lump_index));
+                    let hash = hasher.finish();
 
-            for (i, lump) in bsp_reader.header().lumps.iter().enumerate() {
-                println!(
-                    "lump #{i}: off={} len={} ident={:?}",
-                    lump.off, lump.len, lump.ident
-                );
+                    let lump = &bsp.header.lumps[lump_index as usize];
+                    println!(
+                        "lump #{}: off={} len={} ident={:?} hash={:x}",
+                        lump_index as usize, lump.off, lump.len, lump.ident, hash
+                    );
+                }
             }
 
             Ok(())

src/bin/bsp.rs

@@ -12,6 +12,9 @@ pub struct BufferedBSP {
 impl BufferedBSP {
     pub fn lump_slice(&self, lump_index: LumpIndex) -> &[u8] {
         let lump = &self.header.lumps[lump_index as usize];
+        if lump.off < BSP_HEADER_LEN {
+            return &[];
+        }
 
         &self.data_without_header
             [(lump.off - BSP_HEADER_LEN) as usize..(lump.off + lump.len - BSP_HEADER_LEN) as usize]

src/bsp/buffered_bsp.rs

@@ -1,3 +1,6 @@
+use strum::{EnumIter, FromRepr};
+
+#[derive(Clone, Copy, FromRepr, Debug, PartialEq, EnumIter)]
 pub enum LumpIndex {
     LUMP_ENTITIES = 0,
     LUMP_PLANES = 1,