internal FFieldClass(PackageReader reader)
{
Name = reader.ReadFName();
//Id = reader.ReadUInt64();
//CastFlags = reader.ReadUInt64();
ClassFlags = (EClassFlags)reader.ReadUInt32();
}
internal FFieldClass(PackageReader reader)
{
Name = reader.ReadFName();
Id = reader.ReadUInt64();
CastFlags = reader.ReadUInt64();
ClassFlags = (EClassFlags)reader.ReadUInt32();
//TODO finish this
}
public override void Write(AssetBinaryWriter writer)
{
base.Write(writer);
writer.Write(FuncMap.Count);
for (int i = 0; i < FuncMap.Count; i++)
{
writer.Write(FuncMap.Keys.ElementAt(i));
writer.Write(FuncMap[i].Index);
}
EClassFlags serializingClassFlags = ClassFlags;
if (Asset.EngineVersion < UE4Version.VER_UE4_CLASS_NOTPLACEABLE_ADDED)
{
serializingClassFlags ^= EClassFlags.CLASS_NotPlaceable;
}
writer.Write((uint)serializingClassFlags);
writer.Write(ClassWithin.Index);
writer.Write(ClassConfigName);
if (Asset.EngineVersion < UE4Version.VER_UE4_UCLASS_SERIALIZE_INTERFACES_AFTER_LINKING)
{
SerializeInterfaces(writer);
}
// Linking procedure here; I don't think anything is really serialized during this
writer.Write(ClassGeneratedBy.Index);
if (Asset.EngineVersion >= UE4Version.VER_UE4_UCLASS_SERIALIZE_INTERFACES_AFTER_LINKING)
{
SerializeInterfaces(writer);
}
writer.Write(bDeprecatedForceScriptOrder ? 1 : 0);
writer.Write(new FName("None"));
if (Asset.EngineVersion >= UE4Version.VER_UE4_ADD_COOKED_TO_UCLASS)
{
writer.Write(bCooked ? 1 : 0);
}
writer.Write(ClassDefaultObject.Index);
}
public override void Read(AssetBinaryReader reader, int nextStarting)
{
base.Read(reader, nextStarting);
int numFuncIndexEntries = reader.ReadInt32();
FuncMap = new TMap <FName, FPackageIndex>();
for (int i = 0; i < numFuncIndexEntries; i++)
{
FName functionName = reader.ReadFName();
FPackageIndex functionExport = FPackageIndex.FromRawIndex(reader.ReadInt32());
FuncMap.Add(functionName, functionExport);
}
ClassFlags = (EClassFlags)reader.ReadUInt32();
if (Asset.EngineVersion < UE4Version.VER_UE4_CLASS_NOTPLACEABLE_ADDED)
{
ClassFlags ^= EClassFlags.CLASS_NotPlaceable;
}
ClassWithin = new FPackageIndex(reader.ReadInt32());
ClassConfigName = reader.ReadFName();
Asset.AddNameReference(ClassConfigName.Value);
int numInterfaces = 0;
long interfacesStart = 0;
if (Asset.EngineVersion < UE4Version.VER_UE4_UCLASS_SERIALIZE_INTERFACES_AFTER_LINKING)
{
interfacesStart = reader.BaseStream.Position;
numInterfaces = reader.ReadInt32();
reader.BaseStream.Seek(interfacesStart + sizeof(int) + numInterfaces * (sizeof(int) * 3), SeekOrigin.Begin);
}
// Linking procedure here; I don't think anything is really serialized during this
ClassGeneratedBy = new FPackageIndex(reader.ReadInt32());
long currentOffset = reader.BaseStream.Position;
if (Asset.EngineVersion < UE4Version.VER_UE4_UCLASS_SERIALIZE_INTERFACES_AFTER_LINKING)
{
reader.BaseStream.Seek(interfacesStart, SeekOrigin.Begin);
}
numInterfaces = reader.ReadInt32();
Interfaces = new SerializedInterfaceReference[numInterfaces];
for (int i = 0; i < numInterfaces; i++)
{
Interfaces[i] = new SerializedInterfaceReference(reader.ReadInt32(), reader.ReadInt32(), reader.ReadInt32() == 1);
}
if (Asset.EngineVersion < UE4Version.VER_UE4_UCLASS_SERIALIZE_INTERFACES_AFTER_LINKING)
{
reader.BaseStream.Seek(currentOffset, SeekOrigin.Begin);
}
bDeprecatedForceScriptOrder = reader.ReadInt32() == 1;
reader.ReadInt64(); // None
if (Asset.EngineVersion >= UE4Version.VER_UE4_ADD_COOKED_TO_UCLASS)
{
bCooked = reader.ReadInt32() == 1;
}
ClassDefaultObject = new FPackageIndex(reader.ReadInt32());
// CDO serialization usually comes after this export has finished serializing
}
/// <summary>
/// Used to safely check whether all of the passed in flags are set.
/// </summary>
/// <param name="flagsToCheck">Class flags to check for</param>
/// <returns>true if all of the passed in flags are set (including no flags passed in), false otherwise</returns>
public bool HasAllClassFlags(EClassFlags flagsToCheck)
{
return(Native_UClass.HasAllClassFlags(Address, flagsToCheck));
}
