public static void Serialize(this SerializingContainer2 sc, ref kDOPCollisionTriangle kTri)
{
if (sc.IsLoading)
{
kTri = new kDOPCollisionTriangle(sc.ms.ReadUInt16(), sc.ms.ReadUInt16(), sc.ms.ReadUInt16(), sc.ms.ReadUInt16());
}
else
{
sc.ms.Writer.WriteUInt16(kTri.Vertex1);
sc.ms.Writer.WriteUInt16(kTri.Vertex2);
sc.ms.Writer.WriteUInt16(kTri.Vertex3);
sc.ms.Writer.WriteUInt16(kTri.MaterialIndex);
}
}
private static void Serialize(this SerializingContainer2 sc, LightMap_1D lmap)
{
sc.Serialize(ref lmap.LightGuids, SCExt.Serialize);
sc.Serialize(ref lmap.Owner);
sc.SerializeBulkData(ref lmap.DirectionalSamples, Serialize);
sc.Serialize(ref lmap.ScaleVector1);
sc.Serialize(ref lmap.ScaleVector2);
sc.Serialize(ref lmap.ScaleVector3);
if (sc.Game < MEGame.ME3)
{
sc.Serialize(ref lmap.ScaleVector4);
}
sc.SerializeBulkData(ref lmap.SimpleSamples, Serialize);
}
public static void Serialize(this SerializingContainer2 sc, ref StaticMeshTriangle tri)
{
if (sc.IsLoading)
{
tri = new StaticMeshTriangle();
}
for (int i = 0; i < 3; i++)
{
sc.Serialize(ref tri.Vertices[i]);
}
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 8; j++)
{
sc.Serialize(ref tri.UVs[i, j]);
}
}
for (int i = 0; i < 3; i++)
{
sc.Serialize(ref tri.Colors[i]);
}
sc.Serialize(ref tri.MaterialIndex);
if (sc.Game >= MEGame.ME3)
{
sc.Serialize(ref tri.FragmentIndex);
}
sc.Serialize(ref tri.SmoothingMask);
sc.Serialize(ref tri.NumUVs);
if (sc.Game == MEGame.UDK)
{
sc.Serialize(ref tri.bExplicitNormals);
}
if (sc.Game >= MEGame.ME3)
{
for (int i = 0; i < 3; i++)
{
sc.Serialize(ref tri.TangentX[i]);
}
for (int i = 0; i < 3; i++)
{
sc.Serialize(ref tri.TangentY[i]);
}
for (int i = 0; i < 3; i++)
{
sc.Serialize(ref tri.TangentZ[i]);
}
sc.Serialize(ref tri.bOverrideTangentBasis);
}
}
public static void Serialize(this SerializingContainer2 sc, ref ExtrusionVertexBuffer vBuff)
{
if (sc.IsLoading)
{
vBuff = new ExtrusionVertexBuffer();
}
sc.Serialize(ref vBuff.Stride);
sc.Serialize(ref vBuff.NumVertices);
int elementsize = 4;
sc.Serialize(ref elementsize);
sc.Serialize(ref vBuff.VertexData, SCExt.Serialize);
}
public static void Serialize(this SerializingContainer2 sc, ref QuantizedDirectionalLightSample samp)
{
if (sc.IsLoading)
{
samp = new QuantizedDirectionalLightSample();
}
if (sc.Game < MEGame.ME3)
{
sc.Serialize(ref samp.Coefficient1);
}
sc.Serialize(ref samp.Coefficient2);
sc.Serialize(ref samp.Coefficient3);
}
public static void Serialize(this SerializingContainer2 sc, ref BioGestureRuntimeData.BioMeshPropData d)
{
if (sc.IsLoading)
{
d = new BioGestureRuntimeData.BioMeshPropData();
}
sc.Serialize(ref d.nmPropName);
sc.Serialize(ref d.sMesh);
sc.Serialize(ref d.nmAttachTo);
sc.Serialize(ref d.vOffsetLocation);
sc.Serialize(ref d.rOffsetRotation);
sc.Serialize(ref d.vOffsetScale);
sc.Serialize(ref d.mapActions, Serialize, Serialize);
}
protected override void Serialize(SerializingContainer2 sc)
{
if (sc.Game == MEGame.ME2)
{
int dummy = 0;
sc.Serialize(ref dummy);
sc.Serialize(ref dummy);
sc.Serialize(ref dummy);
sc.SerializeFileOffset();
}
if (sc.Game == MEGame.UDK)
{
if (sc.IsSaving && RawAnimationData is null)
{
DecompressAnimationData();
}
sc.Serialize(ref RawAnimationData, SCExt.Serialize);
}
if (sc.IsLoading)
{
compressedDataSource = sc.Game;
NumFrames = Export.GetProperty <IntProperty>("NumFrames")?.Value ?? 0;
RateScale = Export.GetProperty <FloatProperty>("RateScale")?.Value ?? 1f;
SequenceLength = Export.GetProperty <FloatProperty>("SequenceLength")?.Value ?? 0;
Name = Export.GetProperty <NameProperty>("SequenceName")?.Value ?? Export.ObjectName;
TrackOffsets = Export.GetProperty <ArrayProperty <IntProperty> >("CompressedTrackOffsets").Select(i => i.Value).ToArray();
if (compressedDataSource == MEGame.UDK)
{
Bones = ((ExportEntry)Export.Parent)?.GetProperty <ArrayProperty <NameProperty> >("TrackBoneNames")?.Select(np => $"{np}").ToList();
}
else
{
var animsetData = Export.GetProperty <ObjectProperty>("m_pBioAnimSetData");
//In ME2, BioAnimSetData can sometimes be in a different package.
Bones = animsetData != null && Export.FileRef.IsUExport(animsetData.Value)
? Export.FileRef.GetUExport(animsetData.Value)?.GetProperty <ArrayProperty <NameProperty> >("TrackBoneNames")?.Select(np => $"{np}").ToList()
: null;
}
Bones ??= Enumerable.Repeat("???", TrackOffsets.Length / 4).ToList();
Enum.TryParse(Export.GetProperty <EnumProperty>("KeyEncodingFormat")?.Value.Name, out keyEncoding);
Enum.TryParse(Export.GetProperty <EnumProperty>("RotationCompressionFormat")?.Value.Name, out rotCompression);
Enum.TryParse(Export.GetProperty <EnumProperty>("TranslationCompressionFormat")?.Value.Name, out posCompression);
}
sc.Serialize(ref CompressedAnimationData, SCExt.Serialize);
}
protected override void Serialize(SerializingContainer2 sc)
{
if (sc.IsLoading)
{
Id = Export.GetProperty <IntProperty>("Id");
Filename = Export.GetProperty <NameProperty>("Filename")?.Value;
}
if (sc.Game != MEGame.ME3 && sc.Game != MEGame.ME2)
{
throw new Exception($"WwiseStream is not a valid class for {sc.Game}!");
}
if (sc.Game == MEGame.ME2 && sc.Pcc.Platform != MEPackage.GamePlatform.PS3)
{
sc.Serialize(ref Unk1);
sc.Serialize(ref Unk2);
if (Unk1 == 0 && Unk2 == 0)
{
return; //not sure what's going on here
}
sc.Serialize(ref UnkGuid);
sc.Serialize(ref Unk3);
sc.Serialize(ref Unk4);
}
else if (sc.Game == MEGame.ME2 && sc.Pcc.Platform == MEPackage.GamePlatform.PS3)
{
// ME2 seems to have different wwisestream binary format than both ME2 and ME3 PC
sc.Serialize(ref Unk1);
sc.Serialize(ref Unk2);
if (Unk1 == 0 && Unk2 == 0)
{
// Dunno if these matter for PS3
return; //not sure what's going on here
}
}
sc.Serialize(ref Unk5);
if (sc.IsSaving && EmbeddedData != null)
{
DataOffset = sc.FileOffset + 12;
DataSize = EmbeddedData.Length;
}
sc.Serialize(ref DataSize);
sc.Serialize(ref DataSize);
sc.Serialize(ref DataOffset);
if (IsPCCStored)
{
sc.Serialize(ref EmbeddedData, DataSize);
}
}
public static void Serialize <T>(this SerializingContainer2 sc, ref T[] arr, SerializeDelegate <T> serialize)
{
int count = arr?.Length ?? 0;
sc.Serialize(ref count);
if (sc.IsLoading)
{
arr = new T[count];
}
for (int i = 0; i < count; i++)
{
serialize(sc, ref arr[i]);
}
}
public static void BulkSerialize(this SerializingContainer2 sc, ref byte[] arr, SerializeDelegate <byte> serialize, int elementSize)
{
sc.Serialize(ref elementSize);
int count = arr?.Length ?? 0;
sc.Serialize(ref count);
if (sc.IsLoading)
{
arr = sc.ms.ReadBytes(count);
}
else if (count > 0)
{
sc.ms.Writer.WriteBytes(arr);
}
}
public static void Serialize(this SerializingContainer2 sc, ref kDOPTree kDopTree)
{
if (sc.IsLoading)
{
kDopTree = new kDOPTree();
}
int elementSize = 32;
sc.Serialize(ref elementSize);
sc.Serialize(ref kDopTree.Nodes, Serialize);
elementSize = 8;
sc.Serialize(ref elementSize);
sc.Serialize(ref kDopTree.Triangles, Serialize);
}
public static void Serialize(this SerializingContainer2 sc, ref URL url)
{
if (sc.IsLoading)
{
url = new URL();
}
sc.Serialize(ref url.Protocol);
sc.Serialize(ref url.Host);
sc.Serialize(ref url.Map);
sc.Serialize(ref url.Portal);
sc.Serialize(ref url.Op, SCExt.Serialize);
sc.Serialize(ref url.Port);
sc.Serialize(ref url.Valid);
}
public static void Serialize(this SerializingContainer2 sc, ref BioGestureRuntimeData.BioGestCharOverride o)
{
if (sc.IsLoading)
{
o = new BioGestureRuntimeData.BioGestCharOverride();
}
sc.Serialize(ref o.nm_Female);
sc.Serialize(ref o.nm_Asari);
sc.Serialize(ref o.nm_Turian);
sc.Serialize(ref o.nm_Salarian);
sc.Serialize(ref o.nm_Quarian);
sc.Serialize(ref o.nm_Other);
sc.Serialize(ref o.nm_Krogan);
sc.Serialize(ref o.nm_Geth);
sc.Serialize(ref o.nm_Other_Artificial);
}
public static void Serialize(this SerializingContainer2 sc, ref kDOPTreeCompact kDopTree)
{
if (sc.IsLoading)
{
kDopTree = new kDOPTreeCompact();
}
sc.Serialize(ref kDopTree.RootBound);
int elementSize = 6;
sc.Serialize(ref elementSize);
sc.Serialize(ref kDopTree.Nodes, Serialize);
elementSize = 8;
sc.Serialize(ref elementSize);
sc.Serialize(ref kDopTree.Triangles, Serialize);
}
public static void Serialize(this SerializingContainer2 sc, ref kDOP kDop)
{
if (sc.IsLoading)
{
kDop = new kDOP();
}
for (int i = 0; i < 3; i++)
{
sc.Serialize(ref kDop.Min[i]);
}
for (int i = 0; i < 3; i++)
{
sc.Serialize(ref kDop.Max[i]);
}
}
public static void Serialize(this SerializingContainer2 sc, ref MeshEdge edge)
{
if (sc.IsLoading)
{
edge = new MeshEdge();
}
for (int i = 0; i < 2; i++)
{
sc.Serialize(ref edge.Vertices[i]);
}
for (int i = 0; i < 2; i++)
{
sc.Serialize(ref edge.Faces[i]);
}
}
protected override void Serialize(SerializingContainer2 sc)
{
base.Serialize(sc);
sc.Serialize(ref ArraySize);
sc.Serialize(ref PropertyFlags);
if (sc.Pcc.Platform == MEPackage.GamePlatform.PC)
{
sc.Serialize(ref Category);
sc.Serialize(ref ArraySizeEnum);
}
if (PropertyFlags.HasFlag(UnrealFlags.EPropertyFlags.Net))
{
sc.Serialize(ref ReplicationOffset);
}
}
public LightmassPrimitiveSettings[] LightmassSettings; //ME3
protected override void Serialize(SerializingContainer2 sc)
{
sc.Serialize(ref Bounds);
sc.BulkSerialize(ref Vectors, SCExt.Serialize, 12);
sc.BulkSerialize(ref Points, SCExt.Serialize, 12);
sc.BulkSerialize(ref Nodes, SCExt.Serialize, 64);
sc.Serialize(ref Self);
sc.Serialize(ref Surfs, SCExt.Serialize);
sc.BulkSerialize(ref Verts, SCExt.Serialize, sc.Game == MEGame.ME3 ? 16 : 24);
sc.Serialize(ref NumSharedSides);
sc.Serialize(ref Zones, SCExt.Serialize);
sc.Serialize(ref Polys);
sc.BulkSerialize(ref LeafHulls, SCExt.Serialize, 4);
sc.BulkSerialize(ref Leaves, SCExt.Serialize, 4);
sc.Serialize(ref RootOutside);
sc.Serialize(ref Linked);
sc.BulkSerialize(ref PortalNodes, SCExt.Serialize, 4);
if (sc.Game != MEGame.UDK)
{
sc.BulkSerialize(ref ShadowVolume, SCExt.Serialize, 16);
}
else if (sc.IsLoading)
{
ShadowVolume = Array.Empty <MeshEdge>();
}
sc.Serialize(ref NumVertices);
sc.BulkSerialize(ref VertexBuffer, SCExt.Serialize, 36);
if (sc.Game >= MEGame.ME3)
{
sc.Serialize(ref LightingGuid);
sc.Serialize(ref LightmassSettings, SCExt.Serialize);
}
else if (sc.IsLoading)
{
LightmassSettings = new[]
{
new LightmassPrimitiveSettings
{
FullyOccludedSamplesFraction = 1,
EmissiveLightFalloffExponent = 2,
EmissiveBoost = 1,
DiffuseBoost = 1,
SpecularBoost = 1
}
};
}
}
public static void Serialize(this SerializingContainer2 sc, ref MaterialShaderMap msm)
{
if (sc.IsLoading)
{
msm = new MaterialShaderMap();
}
if (sc.Game == MEGame.ME3)
{
uint unrealVersion = MEPackage.ME3UnrealVersion;
uint licenseeVersion = MEPackage.ME3LicenseeVersion;
sc.Serialize(ref unrealVersion);
sc.Serialize(ref licenseeVersion);
}
long endOffsetPos = sc.ms.Position;
int dummy = 0;
sc.Serialize(ref dummy);//file offset of end of MaterialShaderMap
sc.Serialize(ref msm.Shaders, Serialize, Serialize);
sc.Serialize(ref msm.MeshShaderMaps, Serialize);
sc.Serialize(ref msm.ID);
sc.Serialize(ref msm.FriendlyName);
sc.Serialize(ref msm.StaticParameters);
if (sc.Game == MEGame.ME3)
{
sc.Serialize(ref msm.UniformPixelVectorExpressions, Serialize);
sc.Serialize(ref msm.UniformPixelScalarExpressions, Serialize);
sc.Serialize(ref msm.Uniform2DTextureExpressions, Serialize);
sc.Serialize(ref msm.UniformCubeTextureExpressions, Serialize);
sc.Serialize(ref msm.UniformVertexVectorExpressions, Serialize);
sc.Serialize(ref msm.UniformVertexScalarExpressions, Serialize);
}
if (sc.Game == MEGame.ME2 || sc.Game == MEGame.ME3)
{
int platform = 0;
sc.Serialize(ref platform);
}
if (sc.IsSaving)
{
long endOffset = sc.ms.Position;
int endOffsetInFile = sc.FileOffset;
sc.ms.JumpTo(endOffsetPos);
sc.ms.Writer.WriteInt32(endOffsetInFile);
sc.ms.JumpTo(endOffset);
}
}
public static void Serialize(this SerializingContainer2 sc, ref Matrix matrix)
{
if (sc.IsLoading)
{
matrix = new Matrix(sc.ms.ReadFloat(), sc.ms.ReadFloat(), sc.ms.ReadFloat(), sc.ms.ReadFloat(),
sc.ms.ReadFloat(), sc.ms.ReadFloat(), sc.ms.ReadFloat(), sc.ms.ReadFloat(),
sc.ms.ReadFloat(), sc.ms.ReadFloat(), sc.ms.ReadFloat(), sc.ms.ReadFloat(),
sc.ms.ReadFloat(), sc.ms.ReadFloat(), sc.ms.ReadFloat(), sc.ms.ReadFloat());
}
else
{
sc.ms.Writer.WriteFloat(matrix[0, 0]); sc.ms.Writer.WriteFloat(matrix[0, 1]); sc.ms.Writer.WriteFloat(matrix[0, 2]); sc.ms.Writer.WriteFloat(matrix[0, 3]);
sc.ms.Writer.WriteFloat(matrix[1, 0]); sc.ms.Writer.WriteFloat(matrix[1, 1]); sc.ms.Writer.WriteFloat(matrix[1, 2]); sc.ms.Writer.WriteFloat(matrix[1, 3]);
sc.ms.Writer.WriteFloat(matrix[2, 0]); sc.ms.Writer.WriteFloat(matrix[2, 1]); sc.ms.Writer.WriteFloat(matrix[2, 2]); sc.ms.Writer.WriteFloat(matrix[2, 3]);
sc.ms.Writer.WriteFloat(matrix[3, 0]); sc.ms.Writer.WriteFloat(matrix[3, 1]); sc.ms.Writer.WriteFloat(matrix[3, 2]); sc.ms.Writer.WriteFloat(matrix[3, 3]);
}
}
protected override void Serialize(SerializingContainer2 sc)
{
if (sc.Game != MEGame.ME1)
{
throw new Exception($"BioTlkFileSet is not a valid class for {sc.Game}!");
}
sc.Serialize(ref TlkSets, SCExt.Serialize, (SerializingContainer2 sc2, ref BioTlkSet tlkSet) =>
{
if (sc2.IsLoading)
{
tlkSet = new BioTlkSet();
}
sc2.SerializeConstInt(2);
sc2.Serialize(ref tlkSet.Male);
sc2.Serialize(ref tlkSet.Female);
});
}
public static void SerializeBulkData(this SerializingContainer2 sc, ref byte[] arr, SerializeDelegate <byte> serialize = null)
{
sc.SerializeConstInt(0);//bulkdataflags
int elementCount = arr?.Length ?? 0;
sc.Serialize(ref elementCount);
sc.Serialize(ref elementCount); //sizeondisk, which is equal to elementcount for a byte array
sc.SerializeFileOffset();
if (sc.IsLoading)
{
arr = sc.ms.ReadBytes(elementCount);
}
else if (elementCount > 0)
{
sc.ms.Writer.WriteBytes(arr);
}
}
public static void Serialize(this SerializingContainer2 sc, ref WaveformSample sample)
{
if (sc.IsLoading)
{
sample = new WaveformSample();
}
sc.Serialize(ref sample.LeftAmplitude);
sc.Serialize(ref sample.RightAmplitude);
byte leftFunc = (byte)sample.LeftFunction;
byte rightFunc = (byte)sample.RightFunction;
sc.Serialize(ref leftFunc);
sc.Serialize(ref rightFunc);
sample.LeftFunction = (EWaveformFunction)leftFunc;
sample.RightFunction = (EWaveformFunction)rightFunc;
sc.Serialize(ref sample.Duration);
}
public static void Serialize(this SerializingContainer2 sc, ref PositionVertexBuffer buff)
{
if (sc.IsLoading)
{
buff = new PositionVertexBuffer();
}
sc.Serialize(ref buff.Stride);
sc.Serialize(ref buff.NumVertices);
if (sc.Game == MEGame.ME3)
{
sc.Serialize(ref buff.unk);
}
int elementsize = 12;
sc.Serialize(ref elementsize);
sc.Serialize(ref buff.VertexData, Serialize);
}
public NameReference FriendlyName; //ME1/2
protected override void Serialize(SerializingContainer2 sc)
{
base.Serialize(sc);
sc.Serialize(ref NativeIndex);
if (sc.Game <= MEGame.ME2) //This is present on PS3 ME1/ME2 but not ME3 for some reason.
{
sc.Serialize(ref OperatorPrecedence);
}
sc.Serialize(ref FunctionFlags);
if (sc.Game <= MEGame.ME2 && sc.Pcc.Platform != MEPackage.GamePlatform.PS3 && FunctionFlags.HasFlag(FunctionFlags.Net))
{
sc.Serialize(ref ReplicationOffset);
}
if (sc.Game <= MEGame.ME2 && sc.Pcc.Platform != MEPackage.GamePlatform.PS3)
{
sc.Serialize(ref FriendlyName);
}
}
public static void Serialize(this SerializingContainer2 sc, ref Color color)
{
if (sc.IsLoading)
{
byte b = (byte)sc.ms.ReadByte();
byte g = (byte)sc.ms.ReadByte();
byte r = (byte)sc.ms.ReadByte();
byte a = (byte)sc.ms.ReadByte();
color = new Color(r, g, b, a);
}
else
{
sc.ms.Writer.WriteByte(color.B);
sc.ms.Writer.WriteByte(color.G);
sc.ms.Writer.WriteByte(color.R);
sc.ms.Writer.WriteByte(color.A);
}
}
public static void Serialize(this SerializingContainer2 sc, ref StaticReceiverData dat)
{
if (sc.IsLoading)
{
dat = new StaticReceiverData();
}
sc.Serialize(ref dat.PrimitiveComponent);
sc.BulkSerialize(ref dat.Vertices, Serialize, sc.Game == MEGame.ME3 ? 28 : 52);
sc.BulkSerialize(ref dat.Indices, SCExt.Serialize, 2);
sc.Serialize(ref dat.NumTriangles);
sc.Serialize(ref dat.LightMap);
if (sc.Game == MEGame.ME3)
{
sc.Serialize(ref dat.ShadowMap1D, Serialize);
sc.Serialize(ref dat.Data);
sc.Serialize(ref dat.InstanceIndex);
}
}
public static HIRCObject Create(SerializingContainer2 sc)
{
HIRCType type = (HIRCType)(sc.Game == MEGame.ME3 ? sc.ms.ReadByte() : (byte)sc.ms.ReadInt32());
int len = sc.ms.ReadInt32();
uint id = sc.ms.ReadUInt32();
return(type switch
{
HIRCType.SoundSXFSoundVoice => SoundSFXVoice.Create(sc, id, len),
HIRCType.Event => Event.Create(sc, id),
HIRCType.EventAction => EventAction.Create(sc, id, len),
_ => new HIRCObject
{
Type = type,
ID = id,
unparsed = sc.ms.ReadBytes(len - 4)
}
});
public static void Serialize(this SerializingContainer2 sc, ref TerrainMaterialResource mat)
{
if (sc.IsLoading)
{
mat = new TerrainMaterialResource();
}
MaterialResource materialResource = mat;
sc.Serialize(ref materialResource);
sc.Serialize(ref mat.Terrain);
sc.Serialize(ref mat.Mask);
sc.Serialize(ref mat.MaterialIds, SCExt.Serialize);
if (sc.Game == MEGame.ME3)
{
sc.Serialize(ref mat.LightingGuid);
}
}
public static void Serialize(SerializingContainer2 sc, ref Vert vert)
{
if (sc.IsLoading)
{
vert = new Vert();
}
sc.Serialize(ref vert.pVertex);
sc.Serialize(ref vert.iSide);
sc.Serialize(ref vert.ShadowTexCoord);
if (sc.Game != MEGame.ME3)
{
sc.Serialize(ref vert.BackfaceShadowTexCoord);
}
else if (sc.IsLoading)
{
//probably wrong
vert.BackfaceShadowTexCoord = new Vector2(vert.ShadowTexCoord.Y, vert.BackfaceShadowTexCoord.X);
}
}
