public static void Serialize(this SerializingContainer2 sc, ref SkelMeshChunk smc)
{
if (sc.IsLoading)
{
smc = new SkelMeshChunk();
}
sc.Serialize(ref smc.BaseVertexIndex);
sc.Serialize(ref smc.RigidVertices, Serialize);
sc.Serialize(ref smc.SoftVertices, Serialize);
sc.Serialize(ref smc.BoneMap, Serialize);
sc.Serialize(ref smc.NumRigidVertices);
sc.Serialize(ref smc.NumSoftVertices);
sc.Serialize(ref smc.MaxBoneInfluences);
}
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, Serialize);
sc.Serialize(ref url.Port);
sc.Serialize(ref url.Valid);
}
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 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 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]);
}
}
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.WriteFloat(matrix[0, 0]); sc.ms.WriteFloat(matrix[0, 1]); sc.ms.WriteFloat(matrix[0, 2]); sc.ms.WriteFloat(matrix[0, 3]);
sc.ms.WriteFloat(matrix[1, 0]); sc.ms.WriteFloat(matrix[1, 1]); sc.ms.WriteFloat(matrix[1, 2]); sc.ms.WriteFloat(matrix[1, 3]);
sc.ms.WriteFloat(matrix[2, 0]); sc.ms.WriteFloat(matrix[2, 1]); sc.ms.WriteFloat(matrix[2, 2]); sc.ms.WriteFloat(matrix[2, 3]);
sc.ms.WriteFloat(matrix[3, 0]); sc.ms.WriteFloat(matrix[3, 1]); sc.ms.WriteFloat(matrix[3, 2]); sc.ms.WriteFloat(matrix[3, 3]);
}
}
public static void Serialize(this SerializingContainer2 sc, ref MeshBone mb)
{
if (sc.IsLoading)
{
mb = new MeshBone();
}
sc.Serialize(ref mb.Name);
sc.Serialize(ref mb.Flags);
sc.Serialize(ref mb.Orientation);
sc.Serialize(ref mb.Position);
sc.Serialize(ref mb.NumChildren);
sc.Serialize(ref mb.ParentIndex);
if (sc.Game >= MEGame.ME3)
{
sc.Serialize(ref mb.BoneColor);
}
}
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.WriteByte(color.B);
sc.ms.WriteByte(color.G);
sc.ms.WriteByte(color.R);
sc.ms.WriteByte(color.A);
}
}
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 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, 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 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);
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.WriteInt32(endOffsetInFile);
sc.ms.JumpTo(endOffset);
}
}
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 Vector2D(vert.ShadowTexCoord.Y, vert.BackfaceShadowTexCoord.X);
}
}
public static void Serialize(this SerializingContainer2 sc, ref StaticMeshComponentLODInfo lod)
{
if (sc.IsLoading)
{
lod = new StaticMeshComponentLODInfo();
}
sc.Serialize(ref lod.ShadowMaps, Serialize);
sc.Serialize(ref lod.ShadowVertexBuffers, Serialize);
sc.Serialize(ref lod.LightMap);
if (sc.Game == MEGame.ME3)
{
sc.Serialize(ref lod.bLoadVertexColorData);
if (lod.bLoadVertexColorData > 0)
{
sc.Serialize(ref lod.OverrideVertexColors);
}
}
}
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, Serialize);
if (sc.Game == MEGame.ME3)
{
sc.Serialize(ref mat.LightingGuid);
}
}
public static void Serialize(this SerializingContainer2 sc, ref ColorVertexBuffer buff)
{
if (sc.IsLoading)
{
buff = new ColorVertexBuffer();
}
if (sc.IsSaving)
{
buff.Stride = buff.NumVertices > 0 ? 4u : 0u;
}
sc.Serialize(ref buff.Stride);
sc.Serialize(ref buff.NumVertices);
if (buff.NumVertices > 0)
{
int elementsize = 4;
sc.Serialize(ref elementsize);
sc.Serialize(ref buff.VertexData, Serialize);
}
}
public static void Serialize(this SerializingContainer2 sc, ref DecalVertex vert)
{
if (sc.IsLoading)
{
vert = new DecalVertex();
}
sc.Serialize(ref vert.Position);
sc.Serialize(ref vert.TangentX);
sc.Serialize(ref vert.TangentZ);
if (sc.Game < MEGame.ME3)
{
sc.Serialize(ref vert.ProjectedUVs);
}
sc.Serialize(ref vert.LightMapCoordinate);
if (sc.Game < MEGame.ME3)
{
sc.Serialize(ref vert.NormalTransform1);
sc.Serialize(ref vert.NormalTransform2);
}
}
public static void Serialize(this SerializingContainer2 sc, ref RigidSkinVertex rsv)
{
if (sc.IsLoading)
{
rsv = new RigidSkinVertex();
}
sc.Serialize(ref rsv.Position);
sc.Serialize(ref rsv.TangentX);
sc.Serialize(ref rsv.TangentY);
sc.Serialize(ref rsv.TangentZ);
sc.Serialize(ref rsv.UV);
if (sc.Game == MEGame.UDK)
{
sc.Serialize(ref rsv.UV2);
sc.Serialize(ref rsv.UV3);
sc.Serialize(ref rsv.UV4);
sc.Serialize(ref rsv.BoneColor);
}
sc.Serialize(ref rsv.Bone);
}
private static void Serialize(this SerializingContainer2 sc, LightMap_2D lmap)
{
sc.Serialize(ref lmap.LightGuids, Serialize);
sc.Serialize(ref lmap.Texture1);
sc.Serialize(ref lmap.ScaleVector1);
sc.Serialize(ref lmap.Texture2);
sc.Serialize(ref lmap.ScaleVector2);
sc.Serialize(ref lmap.Texture3);
sc.Serialize(ref lmap.ScaleVector3);
if (sc.Game != MEGame.ME3)
{
sc.Serialize(ref lmap.Texture4);
sc.Serialize(ref lmap.ScaleVector4);
}
else if (sc.IsLoading)
{
lmap.Texture4 = new UIndex(0);
}
sc.Serialize(ref lmap.CoordinateScale);
sc.Serialize(ref lmap.CoordinateBias);
}
private static void Serialize(this SerializingContainer2 sc, LightMap_4or6 lmap)
{
sc.Serialize(ref lmap.LightGuids, Serialize);
sc.Serialize(ref lmap.Texture1);
for (int i = 0; i < 8; i++)
{
sc.Serialize(ref lmap.unkFloats1[i]);
}
sc.Serialize(ref lmap.Texture2);
for (int i = 0; i < 8; i++)
{
sc.Serialize(ref lmap.unkFloats2[i]);
}
sc.Serialize(ref lmap.Texture3);
for (int i = 0; i < 8; i++)
{
sc.Serialize(ref lmap.unkFloats3[i]);
}
sc.Serialize(ref lmap.CoordinateScale);
sc.Serialize(ref lmap.CoordinateBias);
}
public static void Serialize(this SerializingContainer2 sc, ref StaticMeshElement meshElement)
{
if (sc.IsLoading)
{
meshElement = new StaticMeshElement();
}
sc.Serialize(ref meshElement.Material);
sc.Serialize(ref meshElement.EnableCollision);
sc.Serialize(ref meshElement.OldEnableCollision);
sc.Serialize(ref meshElement.bEnableShadowCasting);
sc.Serialize(ref meshElement.FirstIndex);
sc.Serialize(ref meshElement.NumTriangles);
sc.Serialize(ref meshElement.MinVertexIndex);
sc.Serialize(ref meshElement.MaxVertexIndex);
sc.Serialize(ref meshElement.MaterialIndex);
if (sc.Game >= MEGame.ME3)
{
sc.Serialize(ref meshElement.Fragments, Serialize);
byte dummy = 0;
sc.Serialize(ref dummy);
}
}
public static void Serialize <T>(this SerializingContainer2 sc, ref List <T> arr, SerializeDelegate <T> serialize)
{
int count = arr?.Count ?? 0;
sc.Serialize(ref count);
if (sc.IsLoading)
{
arr = new List <T>(count);
for (int i = 0; i < count; i++)
{
T tmp = default;
serialize(sc, ref tmp);
arr.Add(tmp);
}
}
else
{
for (int i = 0; i < count; i++)
{
T tmp = arr[i];
serialize(sc, ref tmp);
}
}
}
public static void Serialize(SerializingContainer2 sc, ref BspNode node)
{
if (sc.IsLoading)
{
node = new BspNode();
}
sc.Serialize(ref node.Plane);
sc.Serialize(ref node.iVertPool);
sc.Serialize(ref node.iSurf);
sc.Serialize(ref node.iVertexIndex);
sc.Serialize(ref node.ComponentIndex);
sc.Serialize(ref node.ComponentNodeIndex);
sc.Serialize(ref node.ComponentElementIndex);
sc.Serialize(ref node.iBack);
sc.Serialize(ref node.iFront);
sc.Serialize(ref node.iPlane);
sc.Serialize(ref node.iCollisionBound);
sc.Serialize(ref node.iZone0);
sc.Serialize(ref node.iZone1);
sc.Serialize(ref node.NumVertices);
sc.Serialize(ref node.NodeFlags);
sc.Serialize(ref node.iLeaf0);
sc.Serialize(ref node.iLeaf1);
}
public static void Serialize(this SerializingContainer2 sc, ref StaticLODModel slm)
{
if (sc.IsLoading)
{
slm = new StaticLODModel();
}
sc.Serialize(ref slm.Sections, Serialize);
if (sc.Game == MEGame.UDK)
{
sc.Serialize(ref slm.NeedsCPUAccess);
sc.Serialize(ref slm.DataTypeSize);
}
int ushortSize = 2;
sc.Serialize(ref ushortSize);
sc.Serialize(ref slm.IndexBuffer, Serialize);
if (sc.Game != MEGame.UDK)
{
sc.Serialize(ref slm.ShadowIndices, Serialize);
}
sc.Serialize(ref slm.ActiveBoneIndices, Serialize);
if (sc.Game != MEGame.UDK)
{
sc.Serialize(ref slm.ShadowTriangleDoubleSided, Serialize);
}
sc.Serialize(ref slm.Chunks, Serialize);
sc.Serialize(ref slm.Size);
sc.Serialize(ref slm.NumVertices);
if (sc.Game != MEGame.UDK)
{
sc.Serialize(ref slm.Edges, Serialize);
}
sc.Serialize(ref slm.RequiredBones, Serialize);
if (sc.Game == MEGame.UDK)
{
int[] UDKRawPointIndices = sc.IsSaving ? Array.ConvertAll(slm.RawPointIndices, u => (int)u) : Array.Empty <int>();
sc.SerializeBulkData(ref UDKRawPointIndices, Serialize);
slm.RawPointIndices = Array.ConvertAll(UDKRawPointIndices, i => (ushort)i);
}
else
{
sc.SerializeBulkData(ref slm.RawPointIndices, Serialize);
}
if (sc.Game == MEGame.UDK)
{
sc.Serialize(ref slm.NumTexCoords);
}
if (sc.Game == MEGame.ME1)
{
if (sc.IsSaving && slm.ME1VertexBufferGPUSkin == null)
{
GPUSkinVertex[] vertexData = slm.VertexBufferGPUSkin.VertexData;
slm.ME1VertexBufferGPUSkin = new SoftSkinVertex[vertexData.Length];
for (int i = 0; i < vertexData.Length; i++)
{
GPUSkinVertex vert = vertexData[i];
slm.ME1VertexBufferGPUSkin[i] = new SoftSkinVertex
{
Position = vert.Position,
TangentX = vert.TangentX,
TangentY = new PackedNormal(0, 1, 0, 0), //¯\_(ツ)_/¯
TangentZ = vert.TangentZ,
UV = new Vector2D(vert.UV.X, vert.UV.Y),
InfluenceBones = vert.InfluenceBones.TypedClone(),
InfluenceWeights = vert.InfluenceWeights.TypedClone()
};
}
}
int softSkinVertexSize = 40;
sc.Serialize(ref softSkinVertexSize);
sc.Serialize(ref slm.ME1VertexBufferGPUSkin, Serialize);
}
else
{
if (sc.IsSaving && slm.VertexBufferGPUSkin == null)
{
slm.VertexBufferGPUSkin = new SkeletalMeshVertexBuffer
{
MeshExtension = new Vector3(1, 1, 1),
NumTexCoords = 1,
VertexData = new GPUSkinVertex[slm.ME1VertexBufferGPUSkin.Length]
};
for (int i = 0; i < slm.ME1VertexBufferGPUSkin.Length; i++)
{
SoftSkinVertex vert = slm.ME1VertexBufferGPUSkin[i];
slm.VertexBufferGPUSkin.VertexData[i] = new GPUSkinVertex
{
Position = vert.Position,
TangentX = vert.TangentX,
TangentZ = vert.TangentZ,
UV = new Vector2DHalf(vert.UV.X, vert.UV.Y),
InfluenceBones = vert.InfluenceBones.TypedClone(),
InfluenceWeights = vert.InfluenceWeights.TypedClone()
};
}
}
sc.Serialize(ref slm.VertexBufferGPUSkin);
}
if (sc.Game >= MEGame.ME3)
{
int vertexInfluencesCount = 0;
sc.Serialize(ref vertexInfluencesCount);
if (vertexInfluencesCount != 0)
{
throw new Exception($"VertexInfluences exist on this SkeletalMesh! Mesh in: {sc.Pcc.FilePath}");
}
}
if (sc.Game == MEGame.UDK)
{
sc.Serialize(ref slm.NeedsCPUAccess);
sc.Serialize(ref slm.DataTypeSize);
int elementSize = 2;
sc.Serialize(ref elementSize);
ushort[] secondIndexBuffer = new ushort[0];
sc.Serialize(ref secondIndexBuffer, Serialize);
}
}
public static void Serialize(this SerializingContainer2 sc, ref StaticMeshVertexBuffer buff)
{
uint elementSize;
if (sc.IsLoading)
{
buff = new StaticMeshVertexBuffer();
}
else
{
elementSize = 8u + buff.NumTexCoords * (buff.bUseFullPrecisionUVs ? 8u : 4u);
if (sc.Game < MEGame.ME3)
{
elementSize += 4;
}
buff.Stride = elementSize;
}
sc.Serialize(ref buff.NumTexCoords);
sc.Serialize(ref buff.Stride);
sc.Serialize(ref buff.NumVertices);
sc.Serialize(ref buff.bUseFullPrecisionUVs);
if (sc.Game == MEGame.ME3)
{
sc.Serialize(ref buff.unk);
}
elementSize = buff.Stride;
sc.Serialize(ref elementSize);
int count = buff.VertexData?.Length ?? 0;
sc.Serialize(ref count);
if (sc.IsLoading)
{
buff.VertexData = new StaticMeshVertexBuffer.StaticMeshFullVertex[count];
}
for (int i = 0; i < count; i++)
{
if (sc.IsLoading)
{
buff.VertexData[i] = new StaticMeshVertexBuffer.StaticMeshFullVertex();
}
sc.Serialize(ref buff.VertexData[i].TangentX);
sc.Serialize(ref buff.VertexData[i].TangentZ);
if (sc.Game < MEGame.ME3)
{
sc.Serialize(ref buff.VertexData[i].Color);
}
if (buff.bUseFullPrecisionUVs)
{
if (buff.VertexData[i].FullPrecisionUVs == null)
{
buff.VertexData[i].FullPrecisionUVs = sc.IsLoading
? new Vector2D[buff.NumTexCoords]
//bUseFullPrecisionUVs was changed, copy data from the other one
: Array.ConvertAll(buff.VertexData[i].HalfPrecisionUVs, v2dHalf => new Vector2D(v2dHalf.X, v2dHalf.Y));
}
for (int j = 0; j < buff.NumTexCoords; j++)
{
sc.Serialize(ref buff.VertexData[i].FullPrecisionUVs[j]);
}
}
else
{
if (buff.VertexData[i].HalfPrecisionUVs == null)
{
buff.VertexData[i].HalfPrecisionUVs = sc.IsLoading
? new Vector2DHalf[buff.NumTexCoords]
//bUseFullPrecisionUVs was changed, copy data from the other one
: Array.ConvertAll(buff.VertexData[i].FullPrecisionUVs, v2d => new Vector2DHalf(v2d.X, v2d.Y));
}
for (int j = 0; j < buff.NumTexCoords; j++)
{
sc.Serialize(ref buff.VertexData[i].HalfPrecisionUVs[j]);
}
}
}
}
public static void Serialize(this SerializingContainer2 sc, ref StaticMeshRenderData data)
{
if (sc.IsLoading)
{
data = new StaticMeshRenderData();
}
sc.SerializeBulkData(ref data.RawTriangles, Serialize);
sc.Serialize(ref data.Elements, Serialize);
sc.Serialize(ref data.PositionVertexBuffer);
if (sc.IsSaving)
{
if (sc.Game >= MEGame.ME3 && data.ColorVertexBuffer == null)
{
//this was read in from ME1 or ME2, we need to seperate out the color data
data.ColorVertexBuffer = new ColorVertexBuffer
{
VertexData = data.VertexBuffer.VertexData.Select(vertex => vertex.Color).ToArray(),
NumVertices = (uint)data.VertexBuffer.VertexData.Length,
Stride = 4
};
}
else if (sc.Game < MEGame.ME3 && data.ColorVertexBuffer != null)
{
//this was read in from ME3 or UDK, we need to integrate the color data
for (int i = data.VertexBuffer.VertexData.Length - 1; i >= 0; i--)
{
data.VertexBuffer.VertexData[i].Color = data.ColorVertexBuffer.VertexData[i];
}
}
}
sc.Serialize(ref data.VertexBuffer);
if (sc.Game >= MEGame.ME3)
{
sc.Serialize(ref data.ColorVertexBuffer);
}
if (sc.Game < MEGame.UDK)
{
sc.Serialize(ref data.ShadowExtrusionVertexBuffer);
}
else if (sc.IsLoading)
{
data.ShadowExtrusionVertexBuffer = new ExtrusionVertexBuffer
{
Stride = 4,
VertexData = Array.Empty <float>()
};
}
sc.Serialize(ref data.NumVertices);
int elementSize = 2;
sc.Serialize(ref elementSize);
sc.Serialize(ref data.IndexBuffer, Serialize);
elementSize = 2;
sc.Serialize(ref elementSize);
sc.Serialize(ref data.WireframeIndexBuffer, Serialize);
if (sc.Game != MEGame.UDK)
{
elementSize = 16;
sc.Serialize(ref elementSize);
sc.Serialize(ref data.Edges, Serialize);
sc.Serialize(ref data.ShadowTriangleDoubleSided, Serialize);
}
else if (sc.IsLoading)
{
data.Edges = Array.Empty <MeshEdge>();
data.ShadowTriangleDoubleSided = Array.Empty <byte>();
}
if (sc.Game == MEGame.UDK)
{
sc.BulkSerialize(ref data.unkBuffer, Serialize, 2);
}
if (sc.Game == MEGame.ME1)
{
sc.Serialize(ref data.unk1);
int bulkDataFlags = 0;
sc.Serialize(ref bulkDataFlags);
int byteCount = data.xmlFile?.Length ?? 0;
sc.Serialize(ref byteCount);
sc.Serialize(ref byteCount);
int xmlOffsetInFile = sc.FileOffset + 4;
sc.Serialize(ref xmlOffsetInFile);
sc.Serialize(ref data.xmlFile, byteCount);
}
else if (sc.IsLoading)
{
data.xmlFile = Array.Empty <byte>();
}
}
public static void Serialize(this SerializingContainer2 sc, ref SkeletalMeshVertexBuffer svb)
{
if (sc.IsLoading)
{
svb = new SkeletalMeshVertexBuffer();
}
if (sc.Game == MEGame.UDK)
{
svb.bUsePackedPosition = true;
}
else
{
svb.bUsePackedPosition = false;
svb.bUseFullPrecisionUVs = false;
}
if (sc.Game == MEGame.UDK)
{
svb.NumTexCoords = 1;
sc.Serialize(ref svb.NumTexCoords);
}
else if (sc.IsLoading)
{
svb.NumTexCoords = 1;
}
sc.Serialize(ref svb.bUseFullPrecisionUVs);
if (sc.Game >= MEGame.ME3)
{
sc.Serialize(ref svb.bUsePackedPosition);
sc.Serialize(ref svb.MeshExtension);
sc.Serialize(ref svb.MeshOrigin);
}
int elementSize = 32;
sc.Serialize(ref elementSize);
//vertexData
int count = svb.VertexData?.Length ?? 0;
sc.Serialize(ref count);
if (sc.IsLoading)
{
svb.VertexData = new GPUSkinVertex[count];
}
for (int j = 0; j < count; j++)
{
ref GPUSkinVertex gsv = ref svb.VertexData[j];
if (sc.IsLoading)
{
gsv = new GPUSkinVertex();
}
if (sc.Game == MEGame.ME2)
{
sc.Serialize(ref gsv.Position);
}
sc.Serialize(ref gsv.TangentX);
sc.Serialize(ref gsv.TangentZ);
for (int i = 0; i < 4; i++)
{
sc.Serialize(ref gsv.InfluenceBones[i]);
}
for (int i = 0; i < 4; i++)
{
sc.Serialize(ref gsv.InfluenceWeights[i]);
}
if (sc.Game >= MEGame.ME3)
{
if (false)
{
if (sc.IsLoading)
{
uint packedPos = sc.ms.ReadUInt32();
gsv.Position = new Vector3(packedPos.bits(31, 21) / 1023f,
packedPos.bits(20, 10) / 1023f,
packedPos.bits(9, 0) / 1023f) * svb.MeshExtension + svb.MeshOrigin;
}
else
{
Vector3 pos = (gsv.Position - svb.MeshOrigin) - svb.MeshExtension; //puts values in -1.0 to 1.0 range
uint x;
uint y;
uint z;
unchecked
{
x = (uint)Math.Truncate(pos.X * 1023.0).ToInt32().Clamp(-1023, 1023) << 21;
y = (uint)Math.Truncate(pos.Y * 1023.0).ToInt32().Clamp(-1023, 1023) << 21 >> 11;
z = (uint)Math.Truncate(pos.Z * 1023.0).ToInt32().Clamp(-1023, 1023) << 22 >> 22;
}
sc.ms.WriteUInt32(x | y | z);
}
}
else
{
sc.Serialize(ref gsv.Position);
}
}
if (svb.bUseFullPrecisionUVs)
{
Vector2 fullUV = gsv.UV;
sc.Serialize(ref fullUV);
gsv.UV = fullUV;
}
else
{
sc.Serialize(ref gsv.UV);
}
if (svb.NumTexCoords > 1)
{
if (sc.IsLoading)
{
sc.ms.Skip((svb.NumTexCoords - 1) * (svb.bUseFullPrecisionUVs ? 8 : 4));
}
else
{
throw new Exception("Should never be saing more than one UV!");
}
}
}
public static void Serialize(this SerializingContainer2 sc, ref LightMap lmap)
{
if (sc.IsLoading)
{
var type = (ELightMapType)sc.ms.ReadInt32();
switch (type)
{
case ELightMapType.LMT_None:
lmap = new LightMap();
break;
case ELightMapType.LMT_1D:
lmap = new LightMap_1D();
break;
case ELightMapType.LMT_2D:
lmap = new LightMap_2D();
break;
case ELightMapType.LMT_3:
lmap = new LightMap_3();
break;
case ELightMapType.LMT_4:
case ELightMapType.LMT_6:
lmap = new LightMap_4or6();
break;
case ELightMapType.LMT_5:
lmap = new LightMap_5();
break;
default:
throw new ArgumentOutOfRangeException();
}
lmap.LightMapType = type;
}
else
{
sc.ms.WriteInt32((int)lmap.LightMapType);
}
switch (lmap.LightMapType)
{
case ELightMapType.LMT_None:
break;
case ELightMapType.LMT_1D:
sc.Serialize((LightMap_1D)lmap);
break;
case ELightMapType.LMT_2D:
sc.Serialize((LightMap_2D)lmap);
break;
case ELightMapType.LMT_3:
sc.Serialize((LightMap_3)lmap);
break;
case ELightMapType.LMT_4:
case ELightMapType.LMT_6:
sc.Serialize((LightMap_4or6)lmap);
break;
case ELightMapType.LMT_5:
sc.Serialize((LightMap_5)lmap);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
