Importing exports preservers latent action and netindex for same-game transfers. Change resynthesization experiment to reload the window as we cannot release a package easily.

Author: Mgamerz

LegendaryExplorer/LegendaryExplorer/Packages/SharedPackageTools.cs

@@ -58,14 +58,8 @@ public static void CompareToPackageWrapper(WPFBase wpfBase, Action<EntryStringPa
                                 return $"{nameof(CompareToPackageWrapper)}() requires at least one parameter be set!";
                             }
                         }
-                        var diff = PackageDiff.Create(wpfBase.Pcc, package);
-                        var list = new List<EntryStringPair>();
-                        list.AddRange(diff.ChangedEntries.Select(ed => new EntryStringPair(ed.A, $"{(ed.A.UIndex > 0 ? "Export" : "Import")} Changed #{ed.A.UIndex} {ed.A.InstancedFullPath}")));
-                        list.AddRange(diff.AOnlyEntries.Select(entry => new EntryStringPair(entry, $"{(entry.UIndex > 0 ? "Export" : "Import")} only exists in this file #{entry.UIndex} {entry.InstancedFullPath}")));
-                        list.AddRange(diff.BOnlyEntries.Select(entry => new EntryStringPair(entry, $"{(entry.UIndex > 0 ? "Export" : "Import")} only exists in other file #{entry.UIndex} {entry.InstancedFullPath}")));
-                        list.AddRange(diff.AOnlyNames.Select(name => new EntryStringPair($"Name only exists in this file: {name}")));
-                        list.AddRange(diff.BOnlyNames.Select(name => new EntryStringPair($"Name only exists in other file: {name}")));
-                        return list;
+
+                        return StructrualPackageCompare(wpfBase.Pcc, package);
                     }
                     if (package != null) return wpfBase.Pcc.CompareToPackage(package);
                     if (diskPath != null) return wpfBase.Pcc.CompareToPackage(diskPath);
@@ -100,6 +94,28 @@ public static void CompareToPackageWrapper(WPFBase wpfBase, Action<EntryStringPa
             });
         }
 
+        /// <summary>
+        /// Compares two ME packages and returns a list of differences between their entries and names.
+        /// </summary>
+        /// <remarks>The returned list provides a human-readable summary of differences, including whether
+        /// an entry is an export or import, and whether it is unique to one package or changed between the two. This
+        /// method does not modify the input packages.</remarks>
+        /// <param name="package1">The first ME package to compare.</param>
+        /// <param name="package2">The second ME package to compare.</param>
+        /// <returns>A list of entry string pairs describing the differences between the two packages. The list includes changed
+        /// entries, entries unique to each package, and names that exist only in one package.</returns>
+        public static List<EntryStringPair> StructrualPackageCompare(IMEPackage package1, IMEPackage package2)
+        {
+            var diff = PackageDiff.Create(package1, package2);
+            var list = new List<EntryStringPair>();
+            list.AddRange(diff.ChangedEntries.Select(ed => new EntryStringPair(ed.A, $"{(ed.A.UIndex > 0 ? "Export" : "Import")} Changed #{ed.A.UIndex} {ed.A.InstancedFullPath}")));
+            list.AddRange(diff.AOnlyEntries.Select(entry => new EntryStringPair(entry, $"{(entry.UIndex > 0 ? "Export" : "Import")} only exists in this file #{entry.UIndex} {entry.InstancedFullPath}")));
+            list.AddRange(diff.BOnlyEntries.Select(entry => new EntryStringPair(entry, $"{(entry.UIndex > 0 ? "Export" : "Import")} only exists in other file #{entry.UIndex} {entry.InstancedFullPath}")));
+            list.AddRange(diff.AOnlyNames.Select(name => new EntryStringPair($"Name only exists in this file: {name}")));
+            list.AddRange(diff.BOnlyNames.Select(name => new EntryStringPair($"Name only exists in other file: {name}")));
+            return list;
+        }
+
         /// <summary>
         /// Opens a compare to package
         /// </summary>

LegendaryExplorer/LegendaryExplorer/Tools/PackageEditor/Experiments/PackageEditorExperimentsM.cs

@@ -4139,13 +4139,20 @@ public static void CompilePackageUScriptFromFolder(PackageEditorWindow window)
 
         public static void ResynthesizePackage(PackageEditorWindow peWindow)
         {
-            var result = MessageBox.Show("WARNING: This will save the package to disk and may break it!! Continue?",
+            var result = MessageBox.Show("WARNING: This will save the package to disk and may break it!! It will also close this window and re-open it. Continue?",
                 "Destructive operation", MessageBoxButton.YesNo, MessageBoxImage.Warning);
 
             if (result == MessageBoxResult.Yes)
             {
                 var p = PackageResynthesizer.ResynthesizePackage(peWindow.Pcc, new PackageCache(), true);
                 p.Save();
+                peWindow.Close();
+
+                PackageEditorWindow peWpf = new PackageEditorWindow();
+                peWpf.LoadFile(p.FilePath); // Reload file from disk
+                peWpf.ShowActivated = true;
+                peWpf.Show();
+                MessageBox.Show("Package has been resynthesized. If the package was open in multiple windows, the new window may not reflect the changes.");
             }
         }
 

LegendaryExplorer/LegendaryExplorerCore/Packages/CloningImportingAndRelinking/EntryImporter.cs

@@ -1,10 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Runtime.InteropServices;
-using LegendaryExplorerCore.GameFilesystem;
+using LegendaryExplorerCore.GameFilesystem;
 using LegendaryExplorerCore.Gammtek.IO;
 using LegendaryExplorerCore.Helpers;
 using LegendaryExplorerCore.Memory;
@@ -14,6 +8,12 @@
 using LegendaryExplorerCore.Unreal.BinaryConverters;
 using LegendaryExplorerCore.Unreal.ObjectInfo;
 using LegendaryExplorerCore.UnrealScript;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
 
 namespace LegendaryExplorerCore.Packages.CloningImportingAndRelinking
 {
@@ -203,7 +203,7 @@ public static List<EntryStringPair> ImportAndRelinkEntries(PortingOption porting
             }
 
             if (!rop.ForceAllowMaterialPorting && !allowedToPortShaders)
-            {   
+            {
                 rop.ErrorOccurredCallback?.Invoke($"You cannot port Materials from {sourcePcc.Game} into {destPcc.Game}");
             }
 
@@ -431,7 +431,7 @@ public static IEntry ImportExport(IMEPackage destPackage, ExportEntry sourceExpo
                             }
 
                             // If IFP is the same but class changed the lookup earlier failed. We should retry here (used at least in Crossgen)
-                            if (destPackage.FindExport(seIFP, testExp.ClassName) is {} existingExport)
+                            if (destPackage.FindExport(seIFP, testExp.ClassName) is { } existingExport)
                             {
                                 // Export already in destination package
                                 return existingExport;
@@ -546,10 +546,32 @@ public static IEntry ImportExport(IMEPackage destPackage, ExportEntry sourceExpo
             byte[] prePropBinary;
             if (sourceExport.HasStack)
             {
-                var dummy = GetStackDummy(destPackage.Game);
-                prePropBinary = new byte[8 + dummy.Length];
-                sourceExport.DataReadOnly[..8].CopyTo(prePropBinary);
-                dummy.CopyTo(prePropBinary.AsSpan(8));
+                if (sourceExport.Game == destPackage.Game)
+                {
+                    // Same game - preserve latent action and net index so
+                    // comparisons are better and latent action is preserved
+                    // (whatever that does...)
+                    StateFrame oStack = StateFrame.FromExport(sourceExport);
+                    var newStack = oStack.ToBytes(destPackage);
+                    prePropBinary = new byte[newStack.Length + 4];
+                    newStack.CopyTo(prePropBinary);
+
+                    // Create a span representing the target slice of the byte array
+                    Span<byte> destination = prePropBinary.AsSpan().Slice(newStack.Length, 4);
+
+                    // Write the integer to that span. This handles platform endianness automatically.
+                    MemoryMarshal.Write(destination, sourceExport.NetIndex);
+                }
+                else
+                {
+                    // Use the old code when porting across games since latent
+                    // actinos may or may not be the same.
+                    var dummy = GetStackDummy(destPackage.Game);
+                    prePropBinary = new byte[8 + dummy.Length];
+                    sourceExport.DataReadOnly[..8].CopyTo(prePropBinary);
+                    dummy.CopyTo(prePropBinary.AsSpan(8));
+
+                }
             }
             else
             {
@@ -862,6 +884,8 @@ private static bool CanDonateObject(ExportEntry export)
         public static bool ReplaceExportDataWithAnother(ExportEntry incomingExport, ExportEntry targetExport, RelinkerOptionsPackage rop)
         {
             using var res = new EndianReader(MemoryManager.GetMemoryStream()) { Endian = targetExport.FileRef.Endian };
+
+            // Write Pre-Properties binary =======================================================
             if (incomingExport.HasStack)
             {
                 // Seems like this doesn't work, maybe stack has already been written
@@ -886,10 +910,13 @@ public static bool ReplaceExportDataWithAnother(ExportEntry incomingExport, Expo
             List<string> names = [.. targetExport.FileRef.Names];
             try
             {
+                // Write Properties ============================================================================
                 PropertyCollection props = incomingExport.GetProperties();
                 ApplyCrossGamePropertyFixes(incomingExport, targetExport.FileRef, props);
                 ObjectBinary binary = ExportBinaryConverter.ConvertPostPropBinary(incomingExport, targetExport.Game, props);
                 props.WriteTo(res.Writer, targetExport.FileRef);
+
+                // Write Binary ================================================================================
                 // 11/12/2024 - Set file offset to start of binary data so it can accurately serialize offsets for class types that depend on it being proper (ShaderCache) - Mgamerz
                 res.Writer.WriteFromBuffer(binary.ToBytes(targetExport.FileRef, fileOffset: targetExport.DataOffset + (int)res.Writer.BaseStream.Length));
             }
@@ -1699,7 +1726,7 @@ public static List<string> GetPossibleImportFiles(IMEPackage package, ImportEntr
             // 01/14/2024 - Support looking in package by name if our source package doesn't indicate needing it already loaded
             else if ((package.Flags & UnrealFlags.EPackageFlags.RequireImportsAlreadyLoaded) == 0)
             {
-                filesToCheck.Add($"{entry.GetRootName()}{Path.GetExtension(package.FilePath)}" );
+                filesToCheck.Add($"{entry.GetRootName()}{Path.GetExtension(package.FilePath)}");
             }
 
             //add base definition files that are always loaded (Core, Engine, etc.)
@@ -2252,7 +2279,7 @@ public static ImportEntry ConvertExportToImport(ExportEntry export, string force
 
             // Move any children to the new import
             var children = export.FileRef.Exports.Where(x => x.idxLink == export.UIndex).OfType<IEntry>().Concat(export.FileRef.Imports.Where(x => x.idxLink == export.UIndex)).ToList();
-            foreach(var child in children)
+            foreach (var child in children)
             {
                 child.idxLink = convertedItem.UIndex;
             }

LegendaryExplorer/LegendaryExplorerCore/Packages/PackageResynthesizer.cs

@@ -121,7 +121,7 @@ public static IMEPackage ResynthesizePackage(IMEPackage package, PackageCache ca
             return newPackage;
         }
 
-        private static IMEPackage DumpUnreferencedObjects(IMEPackage package, PackageCache cache)
+        public static IMEPackage DumpUnreferencedObjects(IMEPackage package, PackageCache cache)
         {
             // Package must be inventoried before dumping objects because otherwise we will try to resolve array types
             // when package may not yet be fully setup, which causes problems.
@@ -269,13 +269,6 @@ private static void PortOrdering(EntryOrdering ordering, IMEPackage newPackage,
                             new RelinkerOptionsPackage() { RelinkAllowDifferingClassesInRelink = true, ImportExportDependencies = false }, out _);
 
 
-                        // Restore NetIndex and LatentAction
-                        //destExp.NetIndex = oExp.NetIndex;
-                        //if (destExp.HasStack)
-                        //{
-                        //    StateFrame oStack = StateFrame.FromExport(oExp);
-                        //    destExp.WritePrePropsAndProperties(oStack, destExp.GetProperties());
-                        //}
                     }
                 }
             }