- Added Raw Model Copy Functionality.

- Batched model copying into a transaction for speed and safety.

Author: Lunaretic

xivModdingFramework/Models/FileTypes/Mdl.cs

@@ -4407,14 +4407,29 @@ public async Task AddRacialModel(int setId, string slot, XivRace newRace, string
         /// <param name="originalPath"></param>
         /// <param name="newPath"></param>
         /// <returns></returns>
-        public async Task<long> CopyModel(string originalPath, string newPath, string source)
+        public async Task<long> CopyModel(string originalPath, string newPath, string source, bool copyTextures = false)
         {
             var _dat = new Dat(_gameDirectory);
-            var model = await GetModel(originalPath);
-            var xMdl = await GetRawMdlData(originalPath);
+            var _index = new Index(_gameDirectory);
+            var _modding = new Modding(_gameDirectory);
+
+            var fromRoot = await XivCache.GetFirstRoot(originalPath);
+            var toRoot = await XivCache.GetFirstRoot(newPath);
+
+            IItem item = null;
+            if (toRoot != null)
+            {
+                item = toRoot.GetFirstItem();
+            }
+
+            var df = IOUtil.GetDataFileFromPath(originalPath);
+
+            var index = await _index.GetIndexFile(df);
+            var modlist = await _modding.GetModListAsync();
 
-            var root = await XivCache.GetFirstRoot(newPath);
-            var item = root.GetFirstItem();
+            var offset = index.Get8xDataOffset(originalPath);
+            var xMdl = await GetRawMdlData(originalPath, false, offset);
+            var model = TTModel.FromRaw(xMdl);
 
             var originalRace = IOUtil.GetRaceFromPath(originalPath);
             var newRace = IOUtil.GetRaceFromPath(newPath);
@@ -4426,56 +4441,127 @@ public async Task<long> CopyModel(string originalPath, string newPath, string so
                 ModelModifiers.FixUpSkinReferences(model, newPath);
             }
 
-            var _imc = new Imc(_gameDirectory);
-
-            var imcEntries = await _imc.GetEntries(await root.GetImcEntryPaths());
-
-            var materialSets = new HashSet<byte>();
-            imcEntries.ForEach(x => materialSets.Add(x.MaterialSet));
-
             // Language is irrelevant here.
             var _mtrl = new Mtrl(_gameDirectory, IOUtil.GetDataFileFromPath(newPath), XivLanguage.None);
 
             // Get all variant materials.
-            var materialPaths = await GetReferencedMaterialPaths(originalPath, -1, false, false);
+            var materialPaths = await GetReferencedMaterialPaths(originalPath, -1, false, false, index, modlist);
+
 
             var _raceRegex = new Regex("c[0-9]{4}");
 
+            Dictionary<string, string> validNewMaterials = new Dictionary<string, string>();
+            HashSet<string> copiedPaths = new HashSet<string>();
             // Update Material References and clone materials.
-            foreach(var material in materialPaths)
+            foreach (var material in materialPaths)
             {
-                var newMtrlPath = _raceRegex.Replace(material, "c" + newRace.GetRaceCode());
-                if (newMtrlPath == material) continue;
 
+                // Get the new path.
+                var path = RootCloner.UpdatePath(fromRoot, toRoot, material);
+
+                // Adjust race code entries if needed.
+                if (toRoot.Info.PrimaryType == XivItemType.equipment || toRoot.Info.PrimaryType == XivItemType.accessory)
+                {
+                    path = _raceRegex.Replace(path, "c" + newRace.GetRaceCode());
+                }
+
+                // Get file names.
                 var io = material.LastIndexOf("/", StringComparison.Ordinal);
-                var baseMatName = material.Substring(io, material.Length - io);
+                var originalMatName = material.Substring(io, material.Length - io);
+
+                io = path.LastIndexOf("/", StringComparison.Ordinal);
+                var newMatName = path.Substring(io, path.Length - io);
+
 
-                io = newMtrlPath.LastIndexOf("/", StringComparison.Ordinal);
-                var newMatName = newMtrlPath.Substring(io, newMtrlPath.Length - io);
                 // Time to copy the materials!
                 try
                 {
-                    var mtrlData = await _dat.GetType2Data(material, false);
-                    var compressedData = await _dat.CreateType2Data(mtrlData);
-                    await _dat.WriteModFile(compressedData, newMtrlPath, source, item);
+                    offset = index.Get8xDataOffset(material);
+                    var mtrl = await _mtrl.GetMtrlData(offset, material, 11);
+
+                    if (copyTextures)
+                    {
+                        for(int i = 0; i < mtrl.TexturePathList.Count; i++)
+                        {
+                            var tex = mtrl.TexturePathList[i];
+                            var ntex = RootCloner.UpdatePath(fromRoot, toRoot, tex);
+                            if (toRoot.Info.PrimaryType == XivItemType.equipment || toRoot.Info.PrimaryType == XivItemType.accessory)
+                            {
+                                ntex = _raceRegex.Replace(ntex, "c" + newRace.GetRaceCode());
+                            }
+
+                            mtrl.TexturePathList[i] = ntex;
+
+                            await _dat.CopyFile(tex, ntex, source, true, item, index, modlist);
+                        }
+                    }
+
+                    mtrl.MTRLPath = path;
+                    await _mtrl.ImportMtrl(mtrl, item, source, index, modlist);
+
+                    if(!validNewMaterials.ContainsKey(newMatName))
+                    {
+                        validNewMaterials.Add(newMatName, path);
+                    }
+                    copiedPaths.Add(path);
+
 
                     // Switch out any material references to the material in the model file.
-                    foreach(var m in model.MeshGroups)
+                    foreach (var m in model.MeshGroups)
                     {
-                        if(m.Material == baseMatName)
+                        if(m.Material == originalMatName)
                         {
                             m.Material = newMatName;
                         }
                     }
+
                 } catch(Exception ex)
                 {
                     // Hmmm.  The original material didn't exist.   This is pretty not awesome, but I guess a non-critical error...?
                 }
             }
 
+            if (Imc.UsesImc(toRoot) && Imc.UsesImc(fromRoot))
+            {
+                var _imc = new Imc(XivCache.GameInfo.GameDirectory);
+
+                var toEntries = await _imc.GetEntries(await toRoot.GetImcEntryPaths(), false, index, modlist);
+                var fromEntries = await _imc.GetEntries(await fromRoot.GetImcEntryPaths(), false, index, modlist);
+
+                var toSets = toEntries.Select(x => x.MaterialSet).Where(x => x != 0).ToList();
+                var fromSets = fromEntries.Select(x => x.MaterialSet).Where(x => x != 0).ToList();
+
+                if(fromSets.Count > 0 && toSets.Count > 0)
+                {
+                    var vReplace = new Regex("/v[0-9]{4}/");
+
+                    // Validate that sufficient material sets have been created at the destination root.
+                    foreach(var mkv in validNewMaterials)
+                    {
+                        var validPath = mkv.Value;
+                        foreach(var msetId in toSets)
+                        {
+                            var testPath = vReplace.Replace(validPath, "/v" + msetId.ToString().PadLeft(4, '0') + "/");
+                            var copied = copiedPaths.Contains(testPath);
+
+                            // Missing a material set, copy in the known valid material.
+                            if(!copied)
+                            {
+                                await _dat.CopyFile(validPath, testPath, source, true, item, index, modlist);
+                            }
+                        }
+                    }
+                }
+            }
+
+
             // Save the final modified mdl.
             var data = await MakeNewMdlFile(model, xMdl);
-            var offset = await _dat.WriteModFile(data, newPath, source, item);
+            offset = await _dat.WriteModFile(data, newPath, source, item, index, modlist);
+
+            await _index.SaveIndexFile(index);
+            await _modding.SaveModListAsync(modlist);
+
             return offset;
         }
 

xivModdingFramework/Mods/RootCloner.cs

@@ -25,6 +25,16 @@ namespace xivModdingFramework.Mods
 {
     public static class RootCloner
     {
+
+        public static bool IsSupported(XivDependencyRoot root)
+        {
+            if (root.Info.PrimaryType == XivItemType.equipment) return true;
+            if (root.Info.PrimaryType == XivItemType.accessory) return true;
+            if (root.Info.PrimaryType == XivItemType.human && root.Info.SecondaryType == XivItemType.hair) return true;
+
+            return false;
+        }
+
         /// <summary>
         /// Copies the entirety of a given root to a new root.  
         /// </summary>
@@ -34,6 +44,11 @@ public static class RootCloner
         /// <returns>Returns a Dictionary of all the file conversion</returns>
         public static async Task<Dictionary<string, string>> CloneRoot(XivDependencyRoot Source, XivDependencyRoot Destination, string ApplicationSource, int singleVariant = -1, string saveDirectory = null, IProgress<string> ProgressReporter = null, IndexFile index = null, ModList modlist = null, ModPack modPack = null)
         {
+            if(!IsSupported(Source) || !IsSupported(Destination))
+            {
+                throw new InvalidDataException("Cannot clone unsupported root.");
+            }
+
 
             if (ProgressReporter != null)
             {
@@ -544,7 +559,7 @@ private static async Task<ItemMetadata> GetCachedMetadata(IndexFile index, ModLi
         const string CommonPath = "chara/common/";
         private static readonly Regex RemoveRootPathRegex = new Regex("chara\\/[a-z]+\\/[a-z][0-9]{4}(?:\\/obj\\/[a-z]+\\/[a-z][0-9]{4})?\\/(.+)");
 
-        private static string UpdatePath(XivDependencyRoot Source, XivDependencyRoot Destination, string path)
+        internal static string UpdatePath(XivDependencyRoot Source, XivDependencyRoot Destination, string path)
         {
             // For common path items, copy them to our own personal mimic of the path.
             if (path.StartsWith(CommonPath))

xivModdingFramework/Variants/FileTypes/Imc.cs

@@ -176,14 +176,15 @@ public async Task<FullImcInfo> GetFullImcInfo(IItemModel item, IndexFile index =
         /// </summary>
         /// <param name="pathsWithOffsets"></param>
         /// <returns></returns>
-        public async Task<List<XivImc>> GetEntries(List<string> pathsWithOffsets, bool forceDefault = false)
+        public async Task<List<XivImc>> GetEntries(List<string> pathsWithOffsets, bool forceDefault = false, IndexFile index = null, ModList modlist = null)
         {
             var entries = new List<XivImc>();
             var dat = new Dat(_gameDirectory);
 
             var lastPath = "";
             byte[] imcByteData = new byte[0];
 
+
             foreach (var combinedPath in pathsWithOffsets)
             {
                 var binaryMatch = _binaryOffsetRegex.Match(combinedPath);
@@ -198,7 +199,7 @@ public async Task<List<XivImc>> GetEntries(List<string> pathsWithOffsets, bool f
                 // Only reload this data if we need to.
                 if (path != lastPath)
                 {
-                    imcByteData = await dat.GetType2Data(path, forceDefault);
+                    imcByteData = await dat.GetType2Data(path, forceDefault, index, modlist);
                 }
                 lastPath = path;