add guardrails (lgf) and lane decals (llf)

Author: amPerl

.gitignore

@@ -2,4 +2,5 @@
 Cargo.lock
 *.png
 tmp.bin
-.vscode/
+.vscode/
+tmp/

Cargo.toml

@@ -1,2 +1,3 @@
 [workspace]
-members = ["crates/*"]
+members = ["crates/*"]
+resolver = "2"

crates/slidetown-cli/src/lbf.rs

@@ -73,7 +73,7 @@ fn process_obj(obj_opts: ObjOpts) -> anyhow::Result<()> {
                 Err(e) => {
                     println!(
                         "Failed to parse NIF for block index {} unk {}: {:?}",
-                        block_object.index, block_object.unk, e
+                        block_object.block_index, block_object.unk, e
                     );
                     continue;
                 }
@@ -83,7 +83,7 @@ fn process_obj(obj_opts: ObjOpts) -> anyhow::Result<()> {
                 &nif,
                 Some(format!(
                     "Block{}Object{}",
-                    block_object.index, block_object.unk
+                    block_object.block_index, block_object.unk
                 )),
             );
         }
@@ -128,7 +128,7 @@ fn process_gltf(gltf_opts: GltfOpts) -> anyhow::Result<()> {
                 Err(e) => {
                     println!(
                         "Failed to parse NIF for block index {} unk {}: {:?}",
-                        block_object.index, block_object.unk, e
+                        block_object.block_index, block_object.unk, e
                     );
                     continue;
                 }
@@ -137,7 +137,10 @@ fn process_gltf(gltf_opts: GltfOpts) -> anyhow::Result<()> {
             gltf.visit_nif(
                 &nif,
                 Some("Block Objects"),
-                &format!("Block{}Object{}", block_object.index, block_object.unk),
+                &format!(
+                    "Block{}Object{}",
+                    block_object.block_index, block_object.unk
+                ),
             );
         }
     }

crates/slidetown-cli/src/lgf.rs

@@ -0,0 +1,147 @@
+use std::{
+    fs::File,
+    io::{Cursor, Read, Seek, SeekFrom},
+};
+
+use clap::{Parser, Subcommand};
+use slidetown::parsers::lgf;
+
+use crate::nif_obj;
+
+#[derive(Parser)]
+pub struct LgfOpts {
+    #[command(subcommand)]
+    cmd: Command,
+}
+
+#[derive(Subcommand)]
+enum Command {
+    /// display info about archive contents
+    Info(InfoOpts),
+
+    /// export preview obj with terrain guardrails
+    Obj(ObjOpts),
+
+    /// export preview gltf with terrain guardrails
+    Gltf(GltfOpts),
+}
+
+#[derive(Parser)]
+struct InfoOpts {
+    /// input file
+    #[arg(short, long)]
+    input_path: String,
+}
+
+fn process_info(info_opts: InfoOpts) -> anyhow::Result<()> {
+    let mut file = File::open(&info_opts.input_path)?;
+    let lgf: lgf::Lgf = lgf::Lgf::read(&mut file)?;
+
+    println!("Block count: {}", lgf.blocks.len());
+
+    Ok(())
+}
+
+#[derive(Parser)]
+struct ObjOpts {
+    /// input file
+    #[arg(short, long)]
+    input_path: String,
+
+    /// output file
+    #[arg(short, long)]
+    output_path: String,
+}
+
+fn process_obj(obj_opts: ObjOpts) -> anyhow::Result<()> {
+    let mut file = File::open(&obj_opts.input_path)?;
+    let lgf: lgf::Lgf = lgf::Lgf::read(&mut file)?;
+
+    let mut obj = nif_obj::Obj::default();
+
+    for block in lgf.blocks {
+        file.seek(SeekFrom::Start(block.file_offset as u64))?;
+
+        let mut nif_buf = vec![0u8; block.file_length as usize];
+        file.read_exact(&mut nif_buf)?;
+
+        let mut nif_cursor = Cursor::new(nif_buf);
+
+        let nif = match nif::Nif::parse(&mut nif_cursor) {
+            Ok(nif) => nif,
+            Err(e) => {
+                println!(
+                    "Failed to parse NIF for block index {}: {:?}",
+                    block.block_index, e
+                );
+                continue;
+            }
+        };
+
+        obj.visit_nif(&nif, Some(format!("Block{}Guardrail", block.block_index)));
+    }
+
+    let obj_path = std::path::PathBuf::from(obj_opts.output_path);
+    let mtl_path = obj_path.with_extension("mtl");
+
+    obj.write_to_files(obj_path, mtl_path)?;
+
+    Ok(())
+}
+
+#[derive(Parser)]
+struct GltfOpts {
+    /// input file
+    #[arg(short, long)]
+    input_path: String,
+
+    /// output file
+    #[arg(short, long)]
+    output_path: String,
+}
+
+fn process_gltf(gltf_opts: GltfOpts) -> anyhow::Result<()> {
+    let mut file = File::open(&gltf_opts.input_path)?;
+    let lgf: lgf::Lgf = lgf::Lgf::read(&mut file)?;
+
+    let mut gltf = nif::collectors::gltf::Gltf::new();
+
+    for block in lgf.blocks {
+        file.seek(SeekFrom::Start(block.file_offset as u64))?;
+
+        let mut nif_buf = vec![0u8; block.file_length as usize];
+        file.read_exact(&mut nif_buf)?;
+
+        let mut nif_cursor = Cursor::new(nif_buf);
+
+        let nif = match nif::Nif::parse(&mut nif_cursor) {
+            Ok(nif) => nif,
+            Err(e) => {
+                println!(
+                    "Failed to parse NIF for block index {} : {:?}",
+                    block.block_index, e
+                );
+                continue;
+            }
+        };
+
+        gltf.visit_nif(
+            &nif,
+            Some("Block Guardrails"),
+            &format!("Block{}Guardrail", block.block_index),
+        );
+    }
+
+    let gltf_path = std::path::PathBuf::from(gltf_opts.output_path);
+    gltf.write_to_files(gltf_path)?;
+
+    Ok(())
+}
+
+pub fn process_lgf(lgf_opts: LgfOpts) -> anyhow::Result<()> {
+    match lgf_opts.cmd {
+        Command::Info(info_opts) => process_info(info_opts),
+        Command::Obj(obj_opts) => process_obj(obj_opts),
+        Command::Gltf(gltf_opts) => process_gltf(gltf_opts),
+    }
+}

crates/slidetown-cli/src/llf.rs

@@ -0,0 +1,147 @@
+use std::{
+    fs::File,
+    io::{Cursor, Read, Seek, SeekFrom},
+};
+
+use clap::{Parser, Subcommand};
+use slidetown::parsers::llf;
+
+use crate::nif_obj;
+
+#[derive(Parser)]
+pub struct LlfOpts {
+    #[command(subcommand)]
+    cmd: Command,
+}
+
+#[derive(Subcommand)]
+enum Command {
+    /// display info about archive contents
+    Info(InfoOpts),
+
+    /// export preview obj with terrain lane decals
+    Obj(ObjOpts),
+
+    /// export preview gltf with terrain lane decals
+    Gltf(GltfOpts),
+}
+
+#[derive(Parser)]
+struct InfoOpts {
+    /// input file
+    #[arg(short, long)]
+    input_path: String,
+}
+
+fn process_info(info_opts: InfoOpts) -> anyhow::Result<()> {
+    let mut file = File::open(&info_opts.input_path)?;
+    let llf: llf::Llf = llf::Llf::read(&mut file)?;
+
+    println!("Block count: {}", llf.blocks.len());
+
+    Ok(())
+}
+
+#[derive(Parser)]
+struct ObjOpts {
+    /// input file
+    #[arg(short, long)]
+    input_path: String,
+
+    /// output file
+    #[arg(short, long)]
+    output_path: String,
+}
+
+fn process_obj(obj_opts: ObjOpts) -> anyhow::Result<()> {
+    let mut file = File::open(&obj_opts.input_path)?;
+    let llf: llf::Llf = llf::Llf::read(&mut file)?;
+
+    let mut obj = nif_obj::Obj::default();
+
+    for block in llf.blocks {
+        file.seek(SeekFrom::Start(block.file_offset as u64))?;
+
+        let mut nif_buf = vec![0u8; block.file_length as usize];
+        file.read_exact(&mut nif_buf)?;
+
+        let mut nif_cursor = Cursor::new(nif_buf);
+
+        let nif = match nif::Nif::parse(&mut nif_cursor) {
+            Ok(nif) => nif,
+            Err(e) => {
+                println!(
+                    "Failed to parse NIF for block index {}: {:?}",
+                    block.block_index, e
+                );
+                continue;
+            }
+        };
+
+        obj.visit_nif(&nif, Some(format!("Block{}Lane", block.block_index)));
+    }
+
+    let obj_path = std::path::PathBuf::from(obj_opts.output_path);
+    let mtl_path = obj_path.with_extension("mtl");
+
+    obj.write_to_files(obj_path, mtl_path)?;
+
+    Ok(())
+}
+
+#[derive(Parser)]
+struct GltfOpts {
+    /// input file
+    #[arg(short, long)]
+    input_path: String,
+
+    /// output file
+    #[arg(short, long)]
+    output_path: String,
+}
+
+fn process_gltf(gltf_opts: GltfOpts) -> anyhow::Result<()> {
+    let mut file = File::open(&gltf_opts.input_path)?;
+    let llf: llf::Llf = llf::Llf::read(&mut file)?;
+
+    let mut gltf = nif::collectors::gltf::Gltf::new();
+
+    for block in llf.blocks {
+        file.seek(SeekFrom::Start(block.file_offset as u64))?;
+
+        let mut nif_buf = vec![0u8; block.file_length as usize];
+        file.read_exact(&mut nif_buf)?;
+
+        let mut nif_cursor = Cursor::new(nif_buf);
+
+        let nif = match nif::Nif::parse(&mut nif_cursor) {
+            Ok(nif) => nif,
+            Err(e) => {
+                println!(
+                    "Failed to parse NIF for block index {} : {:?}",
+                    block.block_index, e
+                );
+                continue;
+            }
+        };
+
+        gltf.visit_nif(
+            &nif,
+            Some("Block Lane Decals"),
+            &format!("Block{}Lane", block.block_index),
+        );
+    }
+
+    let gltf_path = std::path::PathBuf::from(gltf_opts.output_path);
+    gltf.write_to_files(gltf_path)?;
+
+    Ok(())
+}
+
+pub fn process_llf(llf_opts: LlfOpts) -> anyhow::Result<()> {
+    match llf_opts.cmd {
+        Command::Info(info_opts) => process_info(info_opts),
+        Command::Obj(obj_opts) => process_obj(obj_opts),
+        Command::Gltf(gltf_opts) => process_gltf(gltf_opts),
+    }
+}

crates/slidetown/Cargo.toml

@@ -10,13 +10,31 @@ repository = "https://github.com/amPerl/slidetown"
 license = "MIT"
 
 [features]
-default = ["agt", "hit", "lbf", "levelmodifier", "lf", "lif", "lof", "loi", "nui", "chpath", "xlt", "tdf", "ntx"]
+default = [
+    "agt",
+    "hit",
+    "levelmodifier",
+    "lf",
+    "lbf",
+    "lgf",
+    "lif",
+    "llf",
+    "lof",
+    "loi",
+    "nui",
+    "chpath",
+    "xlt",
+    "tdf",
+    "ntx",
+]
 agt = ["flate2"]
 hit = []
-lbf = []
 levelmodifier = []
 lf = []
+lbf = []
+lgf = []
 lif = []
+llf = []
 lof = []
 loi = []
 nui = ["quick-xml"]
@@ -32,7 +50,7 @@ serde = { version = "1.0.127", features = ["derive"] }
 thiserror = "1.0.26"
 binrw = "0.11.2"
 flate2 = { version = "1.0.24", optional = true }
-quick-xml = { version = "0.22.0", features = ["encoding"], optional = true }
+quick-xml = { version = "0.23.1", features = ["encoding"], optional = true }
 
 [dev-dependencies]
 chrono = "0.4.19"