Always import models and export textures using appropriate racial material for the model.

Author: Lunaretic

xivModdingFramework/Materials/FileTypes/Mtrl.cs

@@ -935,6 +935,7 @@ private async Task<List<TexTypePath>> GetTexNames(IEnumerable<string> texPathLis
         private readonly Regex _raceRegex = new Regex("(c[0-9]{4})");
         private readonly Regex _weaponMatch = new Regex("(w[0-9]{4})");
         private readonly Regex _tailMatch = new Regex("(t[0-9]{4})");
+        private readonly Regex _raceMatch = new Regex("(c[0-9]{4})");
         private readonly Regex _skinRegex = new Regex("^/mt_c([0-9]{4})b([0-9]{4})_.+\\.mtrl$");
         /// <summary>
         /// Resolves the MTRL path for a given MDL path.
@@ -945,13 +946,24 @@ private async Task<List<TexTypePath>> GetTexNames(IEnumerable<string> texPathLis
         /// <returns></returns>
         public string GetMtrlPath(string mdlPath, string mtrlName, int mtrlVariant = 1)
         {
-            var match = _skinRegex.Match(mtrlName);
-            
+
+
+            // So we have to do this step first.
+            var mdlMatch = _raceMatch.Match(mdlPath);
+            var mtrlMatch = _raceMatch.Match(mtrlName);
+
+            // Both Items have racial model information in their path, and the races DON'T match.
+            if (mdlMatch.Success && mtrlMatch.Success && mdlMatch.Groups[1].Value != mtrlMatch.Groups[1].Value)
+            {
+                // In this case, we actually replace the race in the Material the race from the MODEL, which has priority.
+                mtrlName = mtrlName.Replace(mtrlMatch.Groups[1].Value, mdlMatch.Groups[1].Value);
+            }
+
 
             var mtrlFolder = "";
 
-            // Skin is the only known exception case.  Skin materials are auto resolved out of their item root path
-            // and into the character base directory.
+            // Now then, skin materials resolve to their racial path, always.
+            var match = _skinRegex.Match(mtrlName);
             if (match.Success)
             {
                 var race = match.Groups[1].Value;
@@ -965,6 +977,7 @@ public string GetMtrlPath(string mdlPath, string mtrlName, int mtrlVariant = 1)
                 // This a furniture item or something else that specifies an explicit full material path.
                 // We can just return that.
                 return mtrlName;
+
             } else if (mdlPath.Contains("/face/f") || mdlPath.Contains("/zear/z")) {
 
                 // Faces and ears don't use material variants.
@@ -973,10 +986,11 @@ public string GetMtrlPath(string mdlPath, string mtrlName, int mtrlVariant = 1)
                 var baseFolder = mdlFolder.Substring(0, mdlFolder.LastIndexOf("/"));
                 mtrlFolder = baseFolder + "/material";
             }
+
             else {
 
-                var mdlMatch = _raceRegex.Match(mdlPath);
-                var mtrlMatch = _raceRegex.Match(mtrlName);
+                mdlMatch = _raceRegex.Match(mdlPath);
+                mtrlMatch = _raceRegex.Match(mtrlName);
 
                 // Both items have racaial information in their path, and the races DON'T match.
                 if(mdlMatch.Success && mtrlMatch.Success && mdlMatch.Groups[1].Value != mtrlMatch.Groups[1].Value)
@@ -1008,6 +1022,7 @@ public string GetMtrlPath(string mdlPath, string mtrlName, int mtrlVariant = 1)
                     mdlPath = mdlPath.Replace(mdlMatch.Groups[1].Value, mtrlMatch.Groups[1].Value);
                 }
 
+
                 var mdlFolder = Path.GetDirectoryName(mdlPath);
                 mdlFolder = mdlFolder.Replace("\\", "/");
 

xivModdingFramework/Models/FileTypes/Mdl.cs

@@ -53,6 +53,7 @@
 using xivModdingFramework.Variants.FileTypes;
 using SixLabors.ImageSharp.Formats.Png;
 using System.Data;
+using System.Text.RegularExpressions;
 
 namespace xivModdingFramework.Models.FileTypes
 {
@@ -1869,6 +1870,7 @@ public async Task ImportModel(IItemModel item, XivRace race, string path, ModelM
             // Wrapping this in an await ensures we're run asynchronously on a new thread.
             await Task.Run(async () =>
             {
+                var filePath = currentMdl.MdlPath;
 
                 #region TTModel Loading
                 // Probably could stand to push this out to its own function later.
@@ -1910,12 +1912,15 @@ await Task.Run(async () =>
                 }
                 #endregion
 
+
                 var sane = TTModel.SanityCheck(ttModel, loggingFunction);
-                if(!sane)
+                if (!sane)
                 {
                     throw new InvalidDataException("Model was deemed invalid.");
                 }
 
+
+
                 // At this point we now have a fully populated TTModel entry.
                 // Time to pull in the Model Modifier for any extra steps before we pass
                 // it to the raw MDL creation function.
@@ -1956,6 +1961,10 @@ await Task.Run(async () =>
                     }
                 }
 
+                // Fix up the skin references, just because we can/it helps user expectation.
+                // Doesn't really matter as these get auto-resolved in game no matter what race they point to.
+                ModelModifiers.FixUpSkinReferences(ttModel, filePath, loggingFunction);
+
                 // Time to create the raw MDL.
                 loggingFunction(false, "Creating MDL file from processed data...");
                 var bytes = await MakeNewMdlFile(ttModel, currentMdl, loggingFunction);
@@ -1968,7 +1977,6 @@ await Task.Run(async () =>
                 var modEntry = await modding.TryGetModEntry(mdlPath);
 
 
-                var filePath = currentMdl.MdlPath;
 
                 if (!rawDataOnly)
                 {

xivModdingFramework/Models/Helpers/ModelModifiers.cs

@@ -1092,6 +1092,42 @@ public static void CalculateTangentsFromBinormals(TTModel model, Action<bool, st
             }
         }
 
+
+
+        /// <summary>
+        /// Fixes up the racial skin references in the model's materials.
+        /// this isn't actually necessary as the game will auto-resolve these regardless, but it's nice to do.
+        /// </summary>
+        /// <param name="model"></param>
+        /// <param name="newInternalPath"></param>
+        public static void FixUpSkinReferences(TTModel model, string newInternalPath, Action<bool, string> loggingFunction = null)
+        {
+
+            // Here we should to go in and correct any Skin Material references to point to the skin material for this race.
+            // It's not actually -NEEDED-, as the game will dynamically resolve them anyways to the player's skin material, but it's good for user expectation and sanity.
+
+            var raceRegex = new Regex("(c[0-9]{4})");
+            // So we have to do this step first.
+            var newRaceMatch = raceRegex.Match(newInternalPath);
+
+            if(!newRaceMatch.Success)
+            {
+                return;
+            }
+
+            loggingFunction(false, "Fixing up racial skin references...");
+
+            foreach (var m in model.MeshGroups)
+            {
+                var mtrlMatch = raceRegex.Match(m.Material);
+                if(mtrlMatch.Success)
+                {
+                    m.Material.Replace(mtrlMatch.Groups[1].Value, newRaceMatch.Groups[1].Value);
+                }
+            }
+
+        }
+
         /// <summary>
         /// /dev/null function used when no logging parameter is supplied, 
         /// just to make sure we don't have to constantly null-check the logging functions.