Update 2.1.0.3

Author: KoraLyn

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/DataContainers/TTModel.cs

@@ -1160,6 +1160,39 @@ private Dictionary<string, SkeletonData> ResolveBoneHeirarchy()
             return skelDict;
         }
 
+
+        /// <summary>
+        /// Performs a basic sanity check on an incoming TTModel
+        /// Returns true if there were no errors or errors that were resolvable.
+        /// Returns false if the model was deemed insane.
+        /// </summary>
+        /// <param name="model"></param>
+        /// <param name="loggingFunction"></param>
+        /// <returns></returns>
+        public static bool SanityCheck(TTModel model, Action<bool, string> loggingFunction = null)
+        {
+            if (loggingFunction == null)
+            {
+                loggingFunction = ModelModifiers.NoOp;
+            }
+
+            if(model.MeshGroups.Count == 0)
+            {
+                loggingFunction(true, "Model has no data. - Model must have at least one valid Mesh Group.");
+                return false;
+            }
+
+
+            var Group0Valid = model.MeshGroups[0].Parts.Any(x => x.Vertices.Count > 0);
+            if(!Group0Valid)
+            {
+                loggingFunction(true, "Mesh Group 0 has no valid parts - Model must have at least one vertex in Mesh Group 0.");
+                return false;
+            }
+
+            return true;
+        }
+
         #endregion
     }
 }

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
 {
@@ -424,6 +425,7 @@ public async Task<XivMdl> GetRawMdlData(string mdlPath, bool getOriginal = false
                 if (modded)
                 {
                     offset = mod.data.originalOffset;
+                    modded = false;
                 }
             }
 
@@ -1868,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.
@@ -1909,27 +1912,33 @@ await Task.Run(async () =>
                 }
                 #endregion
 
-                if (ttModel.MeshGroups.Count == 0)
+
+                var sane = TTModel.SanityCheck(ttModel, loggingFunction);
+                if (!sane)
                 {
-                    throw new InvalidDataException("The imported model has no data.");
+                    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.
 
                 loggingFunction(false, "Merging in existing Attribute & Material Data...");
 
                 XivMdl ogMdl = null;
-                if (options.EnableShapeData && !ttModel.HasShapeData)
+
+                // Load the original model if we're actually going to need it.
+                var mod = await modding.TryGetModEntry(mdlPath);
+                if (mod != null)
                 {
-                    // Load the original model if we're actually going to need it.
-                    var mod = await modding.TryGetModEntry(mdlPath);
-                    if (mod != null)
-                    {
-                        loggingFunction(false, "Loading original SE model to retrieve Shape Data...");
-                        var ogOffset = mod.data.originalOffset;
-                        ogMdl = await GetRawMdlData(item, IOUtil.GetRaceFromPath(mdlPath), submeshId, true);
-                    }
+                    loggingFunction(false, "Loading original SE model...");
+                    var ogOffset = mod.data.originalOffset;
+                    ogMdl = await GetRawMdlData(item, IOUtil.GetRaceFromPath(mdlPath), submeshId, true);
+                } else
+                {
+                    ogMdl = currentMdl;
                 }
 
                 // Apply our Model Modifier options to the model.
@@ -1942,7 +1951,7 @@ await Task.Run(async () =>
                     loggingFunction(false, "Waiting on user...");
 
                     // Bool says whether or not we should continue.
-                    var oldModel = TTModel.FromRaw(currentMdl);
+                    var oldModel = TTModel.FromRaw(ogMdl);
                     bool cont = await intermediaryFunction(ttModel, oldModel);
                     if (!cont)
                     {
@@ -1952,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);
@@ -1964,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.

xivModdingFramework/Models/ModelTextures/ModelTexture.cs

@@ -541,18 +541,22 @@ private static void ComputeShaderColors(CustomModelColors colors,  ShaderInfo in
 
                 // New diffuse starts from regular diffuse file.
                 // Then factors in the player's skin color multiplied by the shader value.
-                float skinInfluence = ByteToFloat(baseSpecular.R) * 0.5f;
-                Color skinColor = MultiplyColor(colors.SkinColor, 1.0f);
+                float skinInfluence = ByteToFloat(baseSpecular.R);
+                var coloredSkin = MultiplyColor(baseDiffuse, colors.SkinColor);
 
-                newDiffuse = Blend(baseDiffuse, skinColor, skinInfluence);
+                newDiffuse = Blend(baseDiffuse, coloredSkin, skinInfluence);
 
                 if (info.Preset == MtrlShaderPreset.Face)
                 {
                     // Face shaders also allow for lip color.
-                    Color lipColor = MultiplyColor(colors.LipColor, 1.0f);
+                    var coloredLip = MultiplyColor(baseDiffuse, colors.LipColor);
                     float lipInfluence = ByteToFloat(baseSpecular.B);
-                    newDiffuse = Blend(newDiffuse, lipColor, lipInfluence);
-                    
+                    newDiffuse = Blend(newDiffuse, coloredLip, lipInfluence);
+
+                    // For lipstick, increase the specular value slightly.
+                    float specAmp = 1.0f + (lipInfluence * 0.25f);
+                    newSpecular = MultiplyColor(newSpecular, specAmp);
+
                 }