Add support for multiple mods for a single ref

- This is essentially a merge of the `multimod-wip` branch
- Previously, if you wanted multiple textures on a mod, the only way to do that was to author a new override texture with all the data you want and then use that instead of the game's preferred texture - which is a pain and breaks game features like dyeing with custom colors.
- You could specify multiple mods for a ref, but they would be initialized as "variants" - which you can only render one of at a time.
- Now you can have multiple mods for a ref which are not variants but use one of the variants as a parent.  Just like the existing parent support, these will be rendered alongside the parent mod when it is active.  Since each mod can specify its own mesh and textures, you can use different data for those without having to cram everything into one set.
- This is a bit tedious to work with in practice since you generally need to align the mod meshes in one blend file and then create a secondary blend file with just the child data for the secondary mod - then delete that data from the primary blend file.  Export them both to different mmobj files and then create all the yaml files for the two mods.  I should probably document this somewhere.
- This also opens the door for future features such as shader mods on some parts of an aggregate mod, if I ever decide to do that.  But maybe reshade is better for that sort of thing.
- Performance: There is some additional housekeeping and some small allocations when the mod(s) are selected, but profiling with very sleepy indicates no real change in performance - after all the vast majority of the time no mod is even selected because the game is rendering something else.

Author: jmquigs

Native/hook_core/src/hook_render.rs

@@ -21,6 +21,7 @@ use dnclr::{init_clr, reload_managed_dll};
 use util;
 use mod_load;
 use mod_load::AsyncLoadState;
+use crate::debug_spam;
 use crate::input_commands;
 use crate::mod_render;
 use mod_stats::mod_stats;
@@ -730,9 +731,9 @@ pub enum CheckRenderModResult {
 }
 /// Check for a mod to render, and if one is found, render it using the supplied function `F`.
 /// Returns `CheckRenderModResult` to indicate to result of this check.
-pub unsafe fn check_and_render_mod<F>(primCount:u32, NumVertices: u32, rfunc:F) -> CheckRenderModResult
+pub unsafe fn check_and_render_mod<F>(primCount:u32, NumVertices: u32, mut rfunc:F) -> CheckRenderModResult
 where
-    F: FnOnce(&ModD3DData,&NativeModData) -> bool {
+    F: FnMut(&ModD3DData,&NativeModData) -> bool {
 
     let mut loading_mod_name = None;
     let res = GLOBAL_STATE.loaded_mods.as_mut()
@@ -745,36 +746,63 @@ where
             profile_end!(hdip, mod_select);
             r
         })
-        .and_then(|nmod| {
-            // early out if mod is a deletion mod
-            if nmod.mod_data.numbers.mod_type == types::interop::ModType::Deletion as i32 {
-                return Some(nmod.mod_data.numbers.mod_type);
-            }
-            // if the mod d3d data isn't loaded, can't render
-            let d3dd = match nmod.d3d_data {
-                native_mod::ModD3DState::Loaded(ref d3dd) => d3dd,
-                // could observe partial if we noted it previously but the deferred load
-                // hasn't happened yet (since it happens less often)
-                native_mod::ModD3DState::Partial(_)
-                | native_mod::ModD3DState::Unloaded => {
-                    // tried to render an unloaded mod, make a note that it should be loaded
-                    let load_next_hs = GLOBAL_STATE.load_on_next_frame.get_or_insert_with(
-                        || fnv::FnvHashSet::with_capacity_and_hasher(
-                            100,
-                            Default::default(),
-                        ));
-                    loading_mod_name = Some(nmod.name.to_owned());
-                    load_next_hs.insert(nmod.name.to_owned());
-                    return None;
-                }
-            };
+        .and_then(|nmods| {
+            
+            let modslice = nmods.as_slice();
+            let nmodlen = modslice.len();
 
-            let rendered = rfunc(d3dd,nmod);
-            if rendered {
-                Some(nmod.mod_data.numbers.mod_type)
+            debug_spam!(|| format!("select returned {} mods, first: {}", nmodlen, if nmodlen > 0 { 
+                &modslice[0].name
             } else {
-                None
+                "none"
+            }));
+            for nmod in modslice {
+                // early out if mod is a deletion mod
+                if nmod.mod_data.numbers.mod_type == types::interop::ModType::Deletion as i32 {
+                    return Some(nmod.mod_data.numbers.mod_type);
+                }
+                // if the mod d3d data isn't loaded, can't render
+                match nmod.d3d_data {
+                    native_mod::ModD3DState::Loaded(_) => (),
+                    // could observe partial if we noted it previously but the deferred load
+                    // hasn't happened yet (since it happens less often)
+                    native_mod::ModD3DState::Partial(_)
+                    | native_mod::ModD3DState::Unloaded => {
+                        debug_spam!(|| format!("starting load of requested mod: {}", nmod.name));
+                        // tried to render an unloaded mod, make a note that it should be loaded
+                        let load_next_hs = GLOBAL_STATE.load_on_next_frame.get_or_insert_with(
+                            || fnv::FnvHashSet::with_capacity_and_hasher(
+                                100,
+                                Default::default(),
+                            ));
+                        loading_mod_name = Some(nmod.name.to_owned());
+                        load_next_hs.insert(nmod.name.to_owned());
+                        return None;
+                    }
+                };
+            }
+            // If it returned multiple mods we currently assume they have the same type.  Since all these mods must share the same 
+            // ref, it doesn't make sense to have (for instance) two mods where one is a deletion, the other a replacement, 
+            // or one a replacement other an addition; the semantics are mostly exclusive.
+            let mut first_mod_type = None;
+            for nmod in modslice {
+                debug_spam!(|| format!("rend mod: {}, loadstate: {:?}, ({} total)", nmod.name, nmod.d3d_data, modslice.len()));
+                if let native_mod::ModD3DState::Loaded(ref d3dd) = nmod.d3d_data {
+                    debug_spam!(|| format!("rendering loaded mod: {}", nmod.name));
+                    let rendered = rfunc(d3dd,nmod);
+                    if rendered {
+                        debug_spam!(|| format!("{} was rendered", nmod.name));
+                        if first_mod_type.is_none() {
+                            first_mod_type = Some(nmod.mod_data.numbers.mod_type)
+                        }
+                    }
+                } else {
+                    debug_spam!(|| format!("cannot render mod {} because it isn't loaded", nmod.name));
+                }
+                debug_spam!(|| format!("finish rend: {}", nmod.name));
             }
+            debug_spam!(|| format!("done rend loop for {} mods", modslice.len() ));
+            first_mod_type
         });
 
     match (res,loading_mod_name) {

Native/hook_core/src/input_commands.rs

@@ -17,6 +17,7 @@ use crate::hook_render::hook_set_texture;
 use crate::global_state::MAX_STAGE;
 use crate::hook_render::CLR_OK;
 use crate::input;
+use crate::mod_render;
 use mod_load::AsyncLoadState;
 
 use dnclr::reload_managed_dll;
@@ -319,41 +320,7 @@ fn select_next_variant() {
     let lastframe = hookstate.metrics.total_frames;
 
     hookstate.loaded_mods.as_mut().map(|mstate| {
-        for (mkey, nmdv) in mstate.mods.iter() {
-            if nmdv.len() <= 1 {
-                // most mods have no variants
-                continue;
-            }
-
-            // don't change the selection if none have been rendered recently
-            let foundrecent = nmdv.iter().find(|nmd| nmd.recently_rendered(lastframe));
-            if foundrecent.is_none() {
-                continue;
-            }
-
-            // get the current variant for this mod
-            let sel_index_entry = mstate.selected_variant.entry(*mkey).or_insert(0);
-            let mut sel_index = *sel_index_entry;
-            let start = sel_index;
-            // select next, skipping over child mods.  stop if we wrap to where we started
-            sel_index += 1;
-            loop {
-                if sel_index >= nmdv.len() {
-                    sel_index = 0;
-                }
-                if sel_index == start {
-                    break;
-                }
-                if nmdv[sel_index].parent_mod_names.is_empty() {
-                    // found one
-                    write_log_file(&format!("selected next variant: {}", nmdv[sel_index].name));
-                    *sel_index_entry = sel_index;
-                    break;
-                }
-                // keep looking
-                sel_index += 1;
-            }
-        }
+        mod_render::select_next_variant(mstate, lastframe);
     });
 }
 

Native/hook_core/src/lib.rs

@@ -31,6 +31,9 @@ extern crate types;
 #[macro_use]
 extern crate profiler;
 
+pub const ENABLE_DEBUG_SPAM:bool = false;
+pub const DEBUG_SPAM_TO_STDERR:bool = false;
+
 mod debugmode;
 mod hook_render;
 mod hook_render_d3d11;