per addon config

Cargo.toml

@@ -1,9 +1,9 @@
 [workspace]
 members = [
     "bin/app",
+    "bin/libs/config",
     "bin/libs/error",
     "bin/libs/internal",
-    "bin/libs/project",
 
     "libs/config",
     "libs/error",
@@ -16,8 +16,8 @@ members = [
 ]
 
 [workspace.dependencies]
-pest = "2.5.1"
-pest_derive = "2.5.1"
+pest = "2.5.2"
+pest_derive = "2.5.2"
 clap = "4.0.32"
-serde = { version = "1.0.151", features = ["derive"] }
+serde = { version = "1.0.152", features = ["derive"] }
 sha-1 = "0.10.1"

bin/app/Cargo.toml

@@ -9,7 +9,7 @@ hemtt-error = { path = "../../libs/error" }
 hemtt-bin-error = { path = "../libs/error"}
 
 hemtt-bin-internal = { path = "../libs/internal" }
-hemtt-bin-project = { path = "../libs/project" }
+hemtt-bin-config = { path = "../libs/config" }
 
 hemtt-config = { path = "../../libs/config" }
 hemtt-pbo = { path = "../../libs/pbo" }
@@ -23,7 +23,7 @@ clap = { workspace = true }
 dialoguer = "0.10.2"
 fs_extra = "1.2.0"
 git2 = "0.15.0"
-glob = "0.3.0"
+glob = "0.3.1"
 lazy_static = "1.4.0"
 peekmore = "1.0.0"
 rayon = "1.6.1"

bin/app/src/addons.rs

@@ -1,16 +1,30 @@
 use std::{fs::DirEntry, path::PathBuf, str::FromStr};
 
+use hemtt_bin_config::addon::Configuration;
 use hemtt_bin_error::Error;
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone)]
 pub struct Addon {
     name: String,
     location: Location,
+    config: Option<Configuration>,
 }
 
 impl Addon {
-    pub const fn new(name: String, location: Location) -> Self {
-        Self { name, location }
+    pub fn new(name: String, location: Location) -> Self {
+        Self {
+            config: {
+                let path =
+                    PathBuf::from(format!("{}/{}", location.to_string(), name)).join("hemtt.toml");
+                if path.exists() {
+                    Some(Configuration::from_file(&path).unwrap())
+                } else {
+                    None
+                }
+            },
+            location,
+            name,
+        }
     }
 
     pub fn name(&self) -> &str {
@@ -29,6 +43,10 @@ impl Addon {
         format!("{}/{}", self.location.to_string(), self.name)
     }
 
+    pub const fn config(&self) -> Option<&Configuration> {
+        self.config.as_ref()
+    }
+
     pub fn scan() -> Result<Vec<Self>, Error> {
         let mut addons = Vec::new();
         for location in [Location::Addons, Location::Optionals] {

bin/app/src/commands/build.rs

@@ -1,4 +1,4 @@
-use clap::{ArgMatches, Command, ArgAction};
+use clap::{ArgAction, ArgMatches, Command};
 use hemtt_bin_error::Error;
 
 use crate::{

bin/app/src/commands/launch.rs

@@ -1,8 +1,8 @@
 use std::path::Path;
 
 use clap::{ArgMatches, Command};
+use hemtt_bin_config::project::Configuration;
 use hemtt_bin_error::Error;
-use hemtt_bin_project::config::Configuration;
 use steamlocate::SteamDir;
 
 use crate::utils::create_link;

bin/app/src/context.rs

@@ -4,8 +4,8 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use hemtt_bin_config::project::Configuration;
 use hemtt_bin_error::Error;
-use hemtt_bin_project::config::Configuration;
 use vfs::{AltrootFS, MemoryFS, OverlayFS, PhysicalFS, VfsPath};
 
 use crate::addons::Addon;

bin/app/src/modules/binarize.rs

@@ -99,6 +99,23 @@ impl Module for Binarize {
                 if entry.metadata().unwrap().file_type == VfsFileType::File
                     && ["rtm", "p3d"].contains(&entry.extension().unwrap_or_default().as_str())
                 {
+                    if let Some(config) = addon.config() {
+                        if config
+                            .no_bin(&addon.folder())?
+                            .contains(&PathBuf::from(entry.as_str().trim_start_matches('/')))
+                        {
+                            println!("skipping binarization of {}", entry.as_str());
+                            continue;
+                        }
+                    }
+
+                    // skip OLOD & BMTR files as they are already binarized
+                    let mut buf = [0; 4];
+                    entry.open_file().unwrap().read_exact(&mut buf).unwrap();
+                    if buf == [0x4F, 0x4C, 0x4F, 0x44] || buf == [0x42, 0x4D, 0x54, 0x52] {
+                        continue;
+                    }
+
                     let addon_root = PathBuf::from(entry.as_str())
                         .components()
                         .take(3)

bin/app/src/modules/preprocessor.rs

@@ -28,18 +28,25 @@ impl Module for Preprocessor {
     fn pre_build(&self, ctx: &Context) -> Result<(), Error> {
         let resolver = VfsResolver::new(ctx)?;
         // TODO map to extra error
+        // TODO ^ remember what that means
         ctx.addons()
             .par_iter()
             .map(|addon| {
-                // TODO fix error in vfs
                 for entry in ctx.vfs().join(addon.folder())?.walk_dir()? {
                     let entry = entry?;
                     if entry.metadata()?.file_type == VfsFileType::File
                         && can_preprocess(entry.as_str())
                     {
+                        if entry.filename() == "config.cpp" {
+                            if let Some(config) = addon.config() {
+                                if !config.preprocess() {
+                                    println!("skiping {}", entry.as_str());
+                                    continue;
+                                }
+                            }
+                        }
                         println!("preprocessing {}", entry.as_str());
                         preprocess(entry.clone(), ctx, &resolver)?;
-                        println!("done {}", entry.as_str());
                     }
                 }
                 Ok(())