public static void Serialize <TKey, TValue>(this SerializingContainer2 sc, ref OrderedMultiValueDictionary <TKey, TValue> dict, SerializeDelegate <TKey> serializeKey, SerializeDelegate <TValue> serializeValue)
{
int count = dict?.Count ?? 0;
sc.Serialize(ref count);
if (sc.IsLoading)
{
dict = new OrderedMultiValueDictionary <TKey, TValue>(count);
for (int i = 0; i < count; i++)
{
TKey key = default;
serializeKey(sc, ref key);
TValue value = default;
serializeValue(sc, ref value);
dict.Add(key, value);
}
}
else
{
for (int i = 0; i < count; i++)
{
var key = dict[i].Key;
serializeKey(sc, ref key);
var value = dict[i].Value;
serializeValue(sc, ref value);
}
}
}
public OrderedMultiValueDictionary <NameReference, PropertyCollection> CameraList; //PropertyCollection is struct of type BioStageCamera, which contains nothing that needs relinking
protected override void Serialize(SerializingContainer2 sc)
{
if (sc.Game != MEGame.ME3)
{
if (sc.IsLoading)
{
CameraList = new OrderedMultiValueDictionary <NameReference, PropertyCollection>();
}
return;
}
long startPos = sc.ms.Position;
sc.Serialize(ref length);
if (length == 0 && (sc.IsLoading || CameraList.Count == 0))
{
if (sc.IsLoading)
{
CameraList = new OrderedMultiValueDictionary <NameReference, PropertyCollection>();
}
return;
}
NameReference arrayName = "m_aCameraList";
sc.Serialize(ref arrayName);
int dummy = 0;
sc.Serialize(ref dummy);
if (sc.IsLoading)
{
int count = sc.ms.ReadInt32();
sc.ms.SkipInt32();
CameraList = new OrderedMultiValueDictionary <NameReference, PropertyCollection>(count);
for (int i = 0; i < count; i++)
{
CameraList.Add(sc.ms.ReadNameReference(sc.Pcc), PropertyCollection.ReadProps(Export, sc.ms, "BioStageCamera", true, entry: Export));
}
}
else
{
sc.ms.WriteInt32(CameraList.Count);
sc.ms.WriteInt32(0);
foreach ((NameReference name, PropertyCollection props) in CameraList)
{
sc.ms.WriteNameReference(name, sc.Pcc);
props.WriteTo(sc.ms, sc.Pcc);
}
}
if (sc.IsSaving)
{
long endPos = sc.ms.Position;
sc.ms.JumpTo(startPos);
sc.ms.WriteInt32((int)(endPos - startPos - 4));
sc.ms.JumpTo(endPos);
}
}
protected override void Serialize(SerializingContainer2 sc)
{
if (sc.Pcc.Platform != MEPackage.GamePlatform.PC)
{
return; //We do not support non-PC shader cache
}
byte platform = 0;
sc.Serialize(ref platform);
sc.Serialize(ref ShaderTypeCRCMap, SCExt.Serialize, SCExt.Serialize);
if (sc.Game == MEGame.ME3 && sc.IsLoading)
{
int nameMapCount = sc.ms.ReadInt32();
sc.ms.Skip(nameMapCount * 12);
}
else if (sc.Game == MEGame.ME3 && sc.IsSaving)
{
sc.ms.Writer.WriteInt32(0);
}
if (sc.Game == MEGame.ME1)
{
sc.Serialize(ref VertexFactoryTypeCRCMap, SCExt.Serialize, SCExt.Serialize);
}
if (sc.IsLoading)
{
int shaderCount = sc.ms.ReadInt32();
Shaders = new OrderedMultiValueDictionary <Guid, Shader>(shaderCount);
for (int i = 0; i < shaderCount; i++)
{
Shader shader = null;
sc.Serialize(ref shader);
Shaders.Add(shader.Guid, shader);
}
}
else
{
sc.ms.Writer.WriteInt32(Shaders.Count);
foreach ((_, Shader shader) in Shaders)
{
var temp = shader;
sc.Serialize(ref temp);
}
}
if (sc.Game != MEGame.ME1)
{
sc.Serialize(ref VertexFactoryTypeCRCMap, SCExt.Serialize, SCExt.Serialize);
}
sc.Serialize(ref MaterialShaderMaps, SCExt.Serialize, SCExt.Serialize);
if (sc.Game != MEGame.ME2)
{
int dummy = 0;
sc.Serialize(ref dummy);
}
}
private static EntryStringPair relinkUIndex(IMEPackage importingPCC, ExportEntry relinkingExport, ref int uIndex, string propertyName,
OrderedMultiValueDictionary <IEntry, IEntry> crossPCCObjectMappingList, string prefix, bool importExportDependencies = false, RelinkerCache relinkerCache = null)
{
if (uIndex == 0)
{
return(null); //do not relink 0
}
IMEPackage destinationPcc = relinkingExport.FileRef;
if (importingPCC == destinationPcc && uIndex < 0)
{
return(null); //do not relink same-pcc imports.
}
int sourceObjReference = uIndex;
//Debug.WriteLine($"{prefix} Relinking:{propertyName}");
if (crossPCCObjectMappingList.TryGetValue(entry => entry.UIndex == sourceObjReference, out IEntry targetEntry))
{
//relink
uIndex = targetEntry.UIndex;
//Debug.WriteLine($"{prefix} Relink hit: {sourceObjReference}{propertyName} : {targetEntry.FullPath}");
}
else if (uIndex < 0) //It's an unmapped import
{
//objProperty is currently pointing to importingPCC as that is where we read the properties from
int n = uIndex;
int origvalue = n;
//Debug.WriteLine("Relink miss, attempting JIT relink on " + n + " " + rootNode.Text);
if (importingPCC.IsImport(n))
{
//Get the original import
ImportEntry origImport = importingPCC.GetImport(n);
string origImportFullName = origImport.FullPath;
//Debug.WriteLine("We should import " + origImport.GetFullPath);
IEntry crossImport = null;
string linkFailedDueToError = null;
try
{
crossImport = EntryImporter.GetOrAddCrossImportOrPackage(origImportFullName, importingPCC, destinationPcc, relinkerCache: relinkerCache);
}
catch (Exception e)
{
//Error during relink
linkFailedDueToError = e.Message;
}
if (crossImport != null)
{
crossPCCObjectMappingList.Add(origImport, crossImport); //add to mapping to speed up future relinks
uIndex = crossImport.UIndex;
// Debug.WriteLine($"Relink hit: Dynamic CrossImport for {origvalue} {importingPCC.GetEntry(origvalue).FullPath} -> {uIndex}");
}
else
{
string path = importingPCC.GetEntry(uIndex) != null?importingPCC.GetEntry(uIndex).FullPath : "Entry not found: " + uIndex;
if (linkFailedDueToError != null)
{
Debug.WriteLine($"Relink failed: CrossImport porting failed for {relinkingExport.ObjectName.Instanced} {relinkingExport.UIndex}: {propertyName} ({uIndex}): {importingPCC.GetEntry(origvalue).FullPath}");
return(new EntryStringPair(relinkingExport, $"Relink failed for {prefix}{propertyName} {uIndex} in export {path}({relinkingExport.UIndex}): {linkFailedDueToError}"));
}
if (destinationPcc.GetEntry(uIndex) != null)
{
Debug.WriteLine($"Relink failed: CrossImport porting failed for {relinkingExport.ObjectName.Instanced} {relinkingExport.UIndex}: {propertyName} ({uIndex}): {importingPCC.GetEntry(origvalue).FullPath}");
return(new EntryStringPair(relinkingExport, $"Relink failed: CrossImport porting failed for {prefix}{propertyName} {uIndex} {destinationPcc.GetEntry(uIndex).FullPath} in export {relinkingExport.FullPath}({relinkingExport.UIndex})"));
}
return(new EntryStringPair(relinkingExport, $"Relink failed: New export does not exist - this is probably a bug in cross import code for {prefix}{propertyName} {uIndex} in export {relinkingExport.FullPath}({relinkingExport.UIndex})"));
}
}
}
else
{
bool importingFromGlobalFile = false;
//It's an export
//Attempt lookup
ExportEntry sourceExport = importingPCC.GetUExport(uIndex);
string instancedFullPath = sourceExport.InstancedFullPath;
string sourceFilePath = sourceExport.FileRef.FilePath;
if (EntryImporter.IsSafeToImportFrom(sourceFilePath, destinationPcc.Game))
{
importingFromGlobalFile = true;
instancedFullPath = $"{Path.GetFileNameWithoutExtension(sourceFilePath)}.{instancedFullPath}";
}
IEntry existingEntry = null;
if (relinkerCache != null)
{
relinkerCache.destInstancedFullPathToEntryMap.TryGetValue(instancedFullPath, out existingEntry);
}
else
{
existingEntry = destinationPcc.Exports.FirstOrDefault(x => x.InstancedFullPath == instancedFullPath);
existingEntry ??= destinationPcc.Imports.FirstOrDefault(x => x.InstancedFullPath == instancedFullPath);
}
if (existingEntry != null)
{
//Debug.WriteLine($"Relink hit [EXPERIMENTAL]: Existing entry in file was found, linking to it: {uIndex} {sourceExport.InstancedFullPath} -> {existingEntry.InstancedFullPath}");
uIndex = existingEntry.UIndex;
}
else if (importExportDependencies)
{
if (importingFromGlobalFile)
{
uIndex = EntryImporter.GetOrAddCrossImportOrPackageFromGlobalFile(sourceExport.FullPath, importingPCC, destinationPcc, crossPCCObjectMappingList, relinkerCache: relinkerCache).UIndex;
}
else
{
if (!crossPCCObjectMappingList.TryGetValue(sourceExport.Parent, out IEntry parent))
{
parent = EntryImporter.GetOrAddCrossImportOrPackage(sourceExport.ParentFullPath, importingPCC, destinationPcc, true, crossPCCObjectMappingList, relinkerCache: relinkerCache);
}
ExportEntry importedExport = EntryImporter.ImportExport(destinationPcc, sourceExport, parent?.UIndex ?? 0, true, crossPCCObjectMappingList, relinkerCache: relinkerCache);
uIndex = importedExport.UIndex;
}
}
else
{
string path = importingPCC.GetEntry(uIndex)?.FullPath ?? $"Entry not found: {uIndex}";
Debug.WriteLine($"Relink failed in {relinkingExport.ObjectName.Instanced} {relinkingExport.UIndex}: {propertyName} {uIndex} {path}");
return(new EntryStringPair(relinkingExport, $"Relink failed: {prefix}{propertyName} {uIndex} in export {relinkingExport.FullPath}({relinkingExport.UIndex})"));
}
}
return(null);
}