Update 2.0.12.6

Author: KoraLyn

xivModdingFramework/Materials/DataContainers/XivMtrl.cs

@@ -58,7 +58,11 @@ public class XivMtrl
         /// <remarks>
         /// Can be 0 if there is no ColorSet Data
         /// </remarks>
-        public ushort ColorSetDataSize { get; set; }
+        public ushort ColorSetDataSize { get {
+            var size = ColorSetData.Count * 2;
+            size += ColorSetExtraData == null ? 0 : ColorSetExtraData.Length;
+            return (ushort) size;
+        } }
 
         /// <summary>
         /// The size of the Material Data section
@@ -442,7 +446,6 @@ public void SetShaderInfo(ShaderInfo info, bool forced = false)
                 ColorSetCount = 1;
                 ColorSetData = new List<Half>();
                 ColorSetExtraData = null;
-                ColorSetDataSize = 0;
             } else
             {
                 if(ColorSetCount == 0 || ColorSetData == null || ColorSetData.Count != 256)
@@ -454,9 +457,6 @@ public void SetShaderInfo(ShaderInfo info, bool forced = false)
                 {
                     ColorSetExtraData = Tex.GetColorsetExtraDataFromDDS(Tex.GetDefaultTexturePath(XivTexType.ColorSet));
                 }
-
-                // Standard Colorset Size. -- This could really be generated automatically later.
-                ColorSetDataSize = 544;
             }
 
 
@@ -465,13 +465,16 @@ public void SetShaderInfo(ShaderInfo info, bool forced = false)
             {
                 TexturePathUnknownList[idx] = 0;
             }
+
             for (var idx = 0; idx < Unknown2.Length; idx++)
             {
-                Unknown2[idx] = 0;
-            }
-            if (Unknown2.Length > 0)
-            {
-                Unknown2[0] = 12;
+                if(idx == 0)
+                {
+                    Unknown2[idx] = 12;
+                } else
+                {
+                    Unknown2[idx] = 0;
+                } 
             }
         }
 

xivModdingFramework/Materials/FileTypes/Mtrl.cs

@@ -331,15 +331,15 @@ await Task.Run((Func<Task>)(async () =>
                         {
                             Signature = br.ReadInt32(),
                             FileSize = br.ReadInt16(),
-                            ColorSetDataSize = br.ReadUInt16(),
-                            MaterialDataSize = br.ReadUInt16(),
-                            TexturePathsDataSize = br.ReadUInt16(),
-                            TextureCount = br.ReadByte(),
-                            MapCount = br.ReadByte(),
-                            ColorSetCount = br.ReadByte(),
-                            UnknownDataSize = br.ReadByte(),
-                            MTRLPath = mtrlPath
                         };
+                        var colorSetDataSize = br.ReadUInt16();
+                        xivMtrl.MaterialDataSize = br.ReadUInt16();
+                        xivMtrl.TexturePathsDataSize = br.ReadUInt16();
+                        xivMtrl.TextureCount = br.ReadByte();
+                        xivMtrl.MapCount = br.ReadByte();
+                        xivMtrl.ColorSetCount = br.ReadByte();
+                        xivMtrl.UnknownDataSize = br.ReadByte();
+                        xivMtrl.MTRLPath = mtrlPath;
 
                         var pathSizeList = new List<int>();
 
@@ -453,7 +453,7 @@ await Task.Run((Func<Task>)(async () =>
 
                         xivMtrl.ColorSetData = new List<Half>();
                         xivMtrl.ColorSetExtraData = null;
-                        if (xivMtrl.ColorSetDataSize > 0)
+                        if (colorSetDataSize > 0)
                         {
                             // Color Data is always 512 (6 x 14 = 64 x 8bpp = 512)
                             var colorDataSize = 512;
@@ -464,7 +464,7 @@ await Task.Run((Func<Task>)(async () =>
                             }
 
                             // If the color set is 544 in length, it has an extra 32 bytes at the end
-                            if (xivMtrl.ColorSetDataSize == 544)
+                            if (colorSetDataSize == 544)
                             {
                                 xivMtrl.ColorSetExtraData = br.ReadBytes(32);
                             }
@@ -594,16 +594,14 @@ public Task<XivTex> MtrlToXivTex(XivMtrl xivMtrl, TexTypePath ttp)
         /// <param name="race">The selected race for the item</param>
         public void SaveColorSetExtraData(IItem item, XivMtrl xivMtrl, DirectoryInfo saveDirectory, XivRace race)
         {
-            if (xivMtrl.ColorSetExtraData != null)
-            {
-                var path = IOUtil.MakeItemSavePath(item, saveDirectory, race);
+            var toWrite = xivMtrl.ColorSetExtraData != null ? xivMtrl.ColorSetExtraData : new byte[32];
+            var path = IOUtil.MakeItemSavePath(item, saveDirectory, race);
 
-                Directory.CreateDirectory(path);
+            Directory.CreateDirectory(path);
 
-                var savePath = Path.Combine(path, Path.GetFileNameWithoutExtension(xivMtrl.MTRLPath) + ".dat");
+            var savePath = Path.Combine(path, Path.GetFileNameWithoutExtension(xivMtrl.MTRLPath) + ".dat");
 
-                File.WriteAllBytes(savePath, xivMtrl.ColorSetExtraData);
-            }
+            File.WriteAllBytes(savePath, toWrite);
         }
 
 
@@ -757,6 +755,7 @@ public byte[] CreateMtrlFile(XivMtrl xivMtrl, IItem item)
             // Write the actual string list (including padding).
             mtrlBytes.AddRange(stringListBytes);
 
+            // Don't know what these (4) bytes do, but hey, whatever.
             mtrlBytes.AddRange(xivMtrl.Unknown2);
 
             foreach (var colorSetHalf in xivMtrl.ColorSetData)

xivModdingFramework/SqPack/FileTypes/Index.cs

@@ -199,6 +199,15 @@ public Task<bool> HaveFilesAddedByTexTools(XivDataFile dataFile)
             });
         }
 
+        public async Task<int> GetDataOffset(string fullPath)
+        {
+            var dataFile = IOUtil.GetDataFileFromPath(fullPath);
+
+            var pathHash = HashGenerator.GetHash(fullPath.Substring(0, fullPath.LastIndexOf("/", StringComparison.Ordinal)));
+            var fileHash = HashGenerator.GetHash(Path.GetFileName(fullPath));
+            return await GetDataOffset(pathHash, fileHash, dataFile);
+
+        }
         /// <summary>
         /// Gets the offset for the data in the .dat file
         /// </summary>
@@ -372,14 +381,32 @@ public async Task<bool> FileExists(string fullPath)
             return await FileExists(fileHash, pathHash, dataFile);
         }
 
-            /// <summary>
-            /// Determines whether the given file path exists
-            /// </summary>
-            /// <param name="fileHash">The hashed file</param>
-            /// <param name="folderHash">The hashed folder</param>
-            /// <param name="dataFile">The data file</param>
-            /// <returns>True if it exists, False otherwise</returns>
-            public async Task<bool> FileExists(int fileHash, int folderHash, XivDataFile dataFile)
+
+        /// <summary>
+        /// Tests if a given file path in FFXIV's internal directory structure
+        /// is one that ships with FFXIV, or something added by the framework.
+        /// </summary>
+        /// <returns></returns>
+        public async Task<bool> IsDefaultFilePath(string fullPath)
+        {
+            // The framework adds flag files alongside every custom created file.
+            // This lets you check for them even if the Modlist gets corrupted/lost.
+            var exists = await FileExists(fullPath);
+            var hasFlag = await FileExists(fullPath + ".flag");
+
+            // In order to be considered a DEFAULT file, the file must both EXIST *and* not have a flag.
+            var stockFile = exists && !hasFlag;
+            return stockFile;
+        }
+
+        /// <summary>
+        /// Determines whether the given file path exists
+        /// </summary>
+        /// <param name="fileHash">The hashed file</param>
+        /// <param name="folderHash">The hashed folder</param>
+        /// <param name="dataFile">The data file</param>
+        /// <returns>True if it exists, False otherwise</returns>
+        public async Task<bool> FileExists(int fileHash, int folderHash, XivDataFile dataFile)
         {
             var indexPath = Path.Combine(_gameDirectory.FullName, $"{dataFile.GetDataFileName()}{IndexExtension}");
 
@@ -747,13 +774,26 @@ public bool DeleteFileDescriptor(string fullPath, XivDataFile dataFile)
                     // Update folder size
                     if (iHash == uPathHash)
                     {
-                        foundFolder = true;
-                        Array.Copy(BitConverter.GetBytes(iFolderSize - 16), 0, modifiedIndex, position + 8, 4);
+                        if(iFolderSize == 0)
+                        {
+                            // No more files in the folder, the folder needs to be deleted from the listing
+                            // (0 size folders are not listed, even if they're parent folders for other folders)
+                            remainder = modifiedIndex.Length - position - 16;
+                            Array.Copy(modifiedIndex, position + 16, modifiedIndex, position, remainder);
+
+                            var newIndex = new byte[modifiedIndex.Length - 16];
+                            Array.Copy(modifiedIndex, 0, modifiedIndex, 0, newIndex.Length);
+                            foundFolder = true;
+                        } else
+                        {
+                            Array.Copy(BitConverter.GetBytes(iFolderSize - 16), 0, modifiedIndex, position + 8, 4);
+                        }
                     }
                 }
 
                 if (!foundFolder)
                 {
+                    // Something went wrong here / The index is in a bad state.
                     return false;
                 }
 
@@ -876,13 +916,14 @@ public bool DeleteFileDescriptor(string fullPath, XivDataFile dataFile)
             return true;
         }
 
-        /// <summary>
-        /// Adds a new file descriptor/stub into the Index files.
-        /// </summary>
-        /// <param name="fullPath">Full path to the new file.</param>
-        /// <param name="dataOffset">Raw DAT file offset to use for the new file.</param>
-        /// <param name="dataFile">Which data file set to use.</param>
-        /// <returns></returns>
+
+                /// <summary>
+                /// Adds a new file descriptor/stub into the Index files.
+                /// </summary>
+                /// <param name="fullPath">Full path to the new file.</param>
+                /// <param name="dataOffset">Raw DAT file offset to use for the new file.</param>
+                /// <param name="dataFile">Which data file set to use.</param>
+                /// <returns></returns>
         public bool AddFileDescriptor(string fullPath, int dataOffset, XivDataFile dataFile)
         {
             fullPath = fullPath.Replace("\\", "/");
@@ -910,7 +951,6 @@ public bool AddFileDescriptor(string fullPath, int dataOffset, XivDataFile dataF
 
                 // Dump the index into memory, since we're going to have to inject data.
                 byte[] originalIndex = File.ReadAllBytes(indexPath);
-                byte[] modifiedIndex = new byte[originalIndex.Length + 16];
 
                 // Get all the segment header data
                 for (int i = 0; i < SegmentHeaders.Length; i++)
@@ -946,6 +986,11 @@ public bool AddFileDescriptor(string fullPath, int dataOffset, XivDataFile dataF
                             injectLocation = position;
                             break;
                         }
+                    } else if (iPathHash > uPathHash)
+                    {
+                        // This is where the folder should go, it just has no files currently.
+                        injectLocation = position;
+                        break;
                     }
                     else
                     {
@@ -958,11 +1003,9 @@ public bool AddFileDescriptor(string fullPath, int dataOffset, XivDataFile dataF
                     }
                 }
 
-                // Cancel if we failed to find the path.
-                if (foundFolder == false)
-                {
-                    return false;
-                }
+
+                var totalInjectSize = foundFolder ? 16 : 32;
+                byte[] modifiedIndex = new byte[originalIndex.Length + totalInjectSize];
 
                 // Split the file at the injection point.
                 int remainder = originalIndex.Length - injectLocation;
@@ -983,8 +1026,16 @@ public bool AddFileDescriptor(string fullPath, int dataOffset, XivDataFile dataF
                     // Update other segments' offsets.
                     else
                     {
+
                         SegmentOffsets[i] += 16;
                         Array.Copy(BitConverter.GetBytes(SegmentOffsets[i]), 0, modifiedIndex, SegmentHeaders[i] + 4, 4);
+
+                        // We need to create the folder as well.
+                        if (i == 3 && !foundFolder)
+                        {
+                            SegmentSizes[i] += 16;
+                            Array.Copy(BitConverter.GetBytes(SegmentSizes[i]), 0, modifiedIndex, SegmentHeaders[i] + 8, 4);
+                        }
                     }
                 }
 
@@ -995,7 +1046,6 @@ public bool AddFileDescriptor(string fullPath, int dataOffset, XivDataFile dataF
 
                 // Update the folder structure
                 var folderCount = SegmentSizes[3] / 16;
-                foundFolder = false;
 
                 for (int i = 0; i < folderCount; i++)
                 {
@@ -1010,19 +1060,24 @@ public bool AddFileDescriptor(string fullPath, int dataOffset, XivDataFile dataF
                         Array.Copy(BitConverter.GetBytes(iOffset + 16), 0, modifiedIndex, position + 4, 4);
                     }
 
-                    // Update folder size
+                    // Folder exists, but needs its size updated.
                     if (iHash == uPathHash)
                     {
-                        foundFolder = true;
                         Array.Copy(BitConverter.GetBytes(iFolderSize + 16), 0, modifiedIndex, position + 8, 4);
+                    } else if (foundFolder == false && iHash > uPathHash) {
+                        foundFolder = true;
+                        // This is where we need to cut the index the second time to make room for the folder data.
+                        remainder = modifiedIndex.Length - position - 16;
+                        Array.Copy(modifiedIndex, position, modifiedIndex, position +16, remainder);
+
+                        // The new folder entry now goes at the 16 bytes starting at position
+                        Array.Copy(BitConverter.GetBytes(uPathHash), 0, modifiedIndex, position, 4);
+                        Array.Copy(BitConverter.GetBytes(injectLocation), 0, modifiedIndex, position + 4, 4);
+                        Array.Copy(BitConverter.GetBytes(16), 0, modifiedIndex, position + 8, 4);
+                        Array.Copy(BitConverter.GetBytes(16), 0, modifiedIndex, position + 12, 4);
                     }
                 }
 
-                if(!foundFolder)
-                {
-                    return false;
-                }
-                
                 // Update SHA-1 Hashes.
                 SHA1 sha = new SHA1CryptoServiceProvider();
                 byte[] shaHash;

xivModdingFramework/Textures/FileTypes/Tex.cs

@@ -992,16 +992,16 @@ public async Task<int> TexColorImporter(XivMtrl xivMtrl, DirectoryInfo ddsFileDi
 
 
             colorSetData = GetColorsetDataFromDDS(ddsFileDirectory);
-
-            // If the colorset size is 544, it contains extra data that must be imported
-            if (xivMtrl.ColorSetDataSize == 544)
-            {
-                colorSetExtraData = GetColorsetExtraDataFromDDS(ddsFileDirectory);
-            }
+            colorSetExtraData = GetColorsetExtraDataFromDDS(ddsFileDirectory);
 
             // Replace the color set data with the imported data
             xivMtrl.ColorSetData = colorSetData;
             xivMtrl.ColorSetExtraData = colorSetExtraData;
+            if (xivMtrl.Unknown2.Length > 0)
+            {
+                // This byte enables the dye set if it's not already enabled.
+                xivMtrl.Unknown2[0] = 12;
+            }
 
             var mtrl = new Mtrl(_gameDirectory, xivMtrl.TextureTypePathList[0].DataFile, lang);
             return await mtrl.ImportMtrl(xivMtrl, item, source);
@@ -1098,15 +1098,24 @@ public byte[] DDStoMtrlData(XivMtrl xivMtrl, DirectoryInfo ddsFileDirectory, IIt
 
             var colorSetExtraData = new byte[32];
             // If the colorset size is 544, it contains extra data that must be imported
-            if (xivMtrl.ColorSetDataSize == 544)
+            try
             {
                 colorSetExtraData = GetColorsetExtraDataFromDDS(ddsFileDirectory);
+            } catch
+            {
+                colorSetExtraData = new byte[32];
             }
 
             // Replace the color set data with the imported data
             xivMtrl.ColorSetData = colorSetData;
             xivMtrl.ColorSetExtraData = colorSetExtraData;
 
+            if (xivMtrl.Unknown2.Length > 0)
+            {
+                // This byte enables the dye set if it's not already enabled.
+                xivMtrl.Unknown2[0] = 12;
+            }
+
             var mtrl = new Mtrl(_gameDirectory, xivMtrl.TextureTypePathList[0].DataFile, lang);
             return mtrl.CreateMtrlFile(xivMtrl, item);
         }