void UWheeledVehicleMovementComponent4W::Serialize(FArchive & Ar)
{
Super::Serialize(Ar);
#if WITH_VEHICLE
if (Ar.IsLoading() && Ar.UE4Ver() < VER_UE4_VEHICLES_UNIT_CHANGE)
{
PxVehicleEngineData DefEngineData;
float DefaultRPM = OmegaToRPM(DefEngineData.mMaxOmega);
//we need to convert from old units to new. This backwards compatable code fails in the rare case that they were using very strange values that are the new defaults in the correct units.
EngineSetup.MaxRPM = EngineSetup.MaxRPM != DefaultRPM ? OmegaToRPM(EngineSetup.MaxRPM) : DefaultRPM; //need to convert from rad/s to RPM
}
if (Ar.IsLoading() && Ar.UE4Ver() < VER_UE4_VEHICLES_UNIT_CHANGE2)
{
PxVehicleEngineData DefEngineData;
PxVehicleClutchData DefClutchData;
//we need to convert from old units to new. This backwards compatable code fails in the rare case that they were using very strange values that are the new defaults in the correct units.
BackwardsConvertCm2ToM2(EngineSetup.DampingRateFullThrottle, DefEngineData.mDampingRateFullThrottle);
BackwardsConvertCm2ToM2(EngineSetup.DampingRateZeroThrottleClutchDisengaged, DefEngineData.mDampingRateZeroThrottleClutchDisengaged);
BackwardsConvertCm2ToM2(EngineSetup.DampingRateZeroThrottleClutchEngaged, DefEngineData.mDampingRateZeroThrottleClutchEngaged);
BackwardsConvertCm2ToM2(EngineSetup.MOI, DefEngineData.mMOI);
BackwardsConvertCm2ToM2(TransmissionSetup.ClutchStrength, DefClutchData.mStrength);
}
#endif
}
bool FBuildPatchAppManifest::Serialize(FArchive& Ar)
{
// Make sure we use the correct serialization version, this is now fixed and must never use a newer version,
// because the property tag has changed in structure meaning older clients would not read correctly.
Ar.SetUE4Ver(VER_UE4_STRUCT_GUID_IN_PROPERTY_TAG - 1);
if (Ar.IsLoading())
{
DestroyData();
}
Data->Serialize(Ar);
if (Ar.IsLoading())
{
// If we didn't load the version number, we know it was skipped when saving therefore must be
// the first UObject version
if (Data->ManifestFileVersion == static_cast<uint8>(EBuildPatchAppManifestVersion::Invalid))
{
Data->ManifestFileVersion = EBuildPatchAppManifestVersion::StoredAsCompressedUClass;
}
// Setup internal lookups
InitLookups();
}
return !Ar.IsError();
}
PRAGMA_POP
bool FStringAssetReference::Serialize(FArchive& Ar)
{
#if WITH_EDITOR
if (Ar.IsSaving() && Ar.IsPersistent() && FCoreUObjectDelegates::StringAssetReferenceSaving.IsBound())
{
SetPath(FCoreUObjectDelegates::StringAssetReferenceSaving.Execute(ToString()));
}
#endif // WITH_EDITOR
Ar << *this;
#if WITH_EDITOR
if (Ar.IsLoading() && Ar.IsPersistent() && FCoreUObjectDelegates::StringAssetReferenceLoaded.IsBound())
{
FCoreUObjectDelegates::StringAssetReferenceLoaded.Execute(ToString());
}
#endif // WITH_EDITOR
if (Ar.IsLoading() && (Ar.GetPortFlags()&PPF_DuplicateForPIE))
{
// Remap unique ID if necessary
FixupForPIE();
}
return true;
}
void ARadiantStaticMeshWebViewActor::Serialize(FArchive& Ar)
{
Super::Serialize(Ar);
static const int ArchiveVersion = 1;
int Version = ArchiveVersion;
Ar << Version;
bool bCooked = Ar.IsCooking();
Ar << bCooked;
if (bCooked)
{
#if WITH_EDITORONLY_DATA
check(!Ar.IsLoading());
if (!InteractionMesh)
{
ExtractInteractionMesh();
}
#else
check(Ar.IsLoading());
#endif
Ar << InteractionMesh;
}
}
void FTextHistory_FormatNumber::Serialize(FArchive& Ar)
{
Ar << SourceValue;
bool bHasFormatOptions = FormatOptions != nullptr;
Ar << bHasFormatOptions;
if(bHasFormatOptions)
{
if(Ar.IsLoading())
{
FormatOptions = new FNumberFormattingOptions;
}
CA_SUPPRESS(6011)
Ar << *FormatOptions;
}
if(Ar.IsSaving())
{
FString CultureName = TargetCulture.IsValid()? TargetCulture->GetName() : FString();
Ar << CultureName;
}
else if(Ar.IsLoading())
{
FString CultureName;
Ar << CultureName;
if(!CultureName.IsEmpty())
{
TargetCulture = FInternationalization::Get().GetCulture(CultureName);
}
}
}
bool FEdGraphPinType::Serialize(FArchive& Ar)
{
if (Ar.UE4Ver() < VER_UE4_EDGRAPHPINTYPE_SERIALIZATION)
{
return false;
}
Ar << PinCategory;
Ar << PinSubCategory;
// See: FArchive& operator<<( FArchive& Ar, FWeakObjectPtr& WeakObjectPtr )
// The PinSubCategoryObject should be serialized into the package.
if(!Ar.IsObjectReferenceCollector() || Ar.IsModifyingWeakAndStrongReferences() || Ar.IsPersistent())
{
UObject* Object = PinSubCategoryObject.Get(true);
Ar << Object;
if( Ar.IsLoading() || Ar.IsModifyingWeakAndStrongReferences() )
{
PinSubCategoryObject = Object;
}
}
Ar << bIsArray;
Ar << bIsReference;
Ar << bIsWeakPointer;
if (Ar.UE4Ver() >= VER_UE4_MEMBERREFERENCE_IN_PINTYPE)
{
Ar << PinSubCategoryMemberReference;
}
else if (Ar.IsLoading() && Ar.IsPersistent())
{
if ((PinCategory == TEXT("delegate")) || (PinCategory == TEXT("mcdelegate")))
{
if (const UFunction* Signature = Cast<const UFunction>(PinSubCategoryObject.Get()))
{
PinSubCategoryMemberReference.MemberName = Signature->GetFName();
PinSubCategoryMemberReference.MemberParent = Signature->GetOwnerClass();
PinSubCategoryObject = NULL;
}
else
{
ensure(true);
}
}
}
if (Ar.UE4Ver() >= VER_UE4_SERIALIZE_PINTYPE_CONST)
{
Ar << bIsConst;
}
else if (Ar.IsLoading())
{
bIsConst = false;
}
return true;
}
bool operator<<(FArchive& Ar,FVertexFactoryParameterRef& Ref)
{
bool bShaderHasOutdatedParameters = false;
Ar << Ref.VertexFactoryType;
uint8 ShaderFrequencyByte = Ref.ShaderFrequency;
Ar << ShaderFrequencyByte;
if(Ar.IsLoading())
{
Ref.ShaderFrequency = (EShaderFrequency)ShaderFrequencyByte;
}
Ar << Ref.VFHash;
if (Ar.IsLoading())
{
delete Ref.Parameters;
if (Ref.VertexFactoryType)
{
Ref.Parameters = Ref.VertexFactoryType->CreateShaderParameters(Ref.ShaderFrequency);
}
else
{
bShaderHasOutdatedParameters = true;
Ref.Parameters = NULL;
}
}
// Need to be able to skip over parameters for no longer existing vertex factories.
int32 SkipOffset = Ar.Tell();
{
FArchive::FScopeSetDebugSerializationFlags S(Ar, DSF_IgnoreDiff);
// Write placeholder.
Ar << SkipOffset;
}
if(Ref.Parameters)
{
Ref.Parameters->Serialize(Ar);
}
else if(Ar.IsLoading())
{
Ar.Seek( SkipOffset );
}
if( Ar.IsSaving() )
{
int32 EndOffset = Ar.Tell();
Ar.Seek( SkipOffset );
Ar << EndOffset;
Ar.Seek( EndOffset );
}
return bShaderHasOutdatedParameters;
}
/*-----------------------------------------------------------------------------
UByteProperty.
-----------------------------------------------------------------------------*/
void UByteProperty::SerializeItem( FArchive& Ar, void* Value, void const* Defaults ) const
{
if(Enum && Ar.UseToResolveEnumerators())
{
const int32 ResolvedIndex = Enum->ResolveEnumerator(Ar, *(uint8*)Value);
*(uint8*)Value = static_cast<uint8>(ResolvedIndex);
return;
}
// Serialize enum values by name unless we're not saving or loading OR for backwards compatibility
const bool bUseBinarySerialization = (Enum == NULL) || (!Ar.IsLoading() && !Ar.IsSaving());
if( bUseBinarySerialization )
{
Super::SerializeItem(Ar, Value, Defaults);
}
// Loading
else if (Ar.IsLoading())
{
FName EnumValueName;
Ar << EnumValueName;
// Make sure enum is properly populated
if( Enum->HasAnyFlags(RF_NeedLoad) )
{
Ar.Preload(Enum);
}
// There's no guarantee EnumValueName is still present in Enum, in which case Value will be set to the enum's max value.
// On save, it will then be serialized as NAME_None.
int32 EnumIndex = Enum->FindEnumIndex(EnumValueName);
if (EnumIndex == INDEX_NONE)
{
*(uint8*)Value = Enum->GetMaxEnumValue();
}
else
{
*(uint8*)Value = Enum->GetValueByIndex(EnumIndex);
}
}
// Saving
else
{
FName EnumValueName;
uint8 ByteValue = *(uint8*)Value;
// subtract 1 because the last entry in the enum's Names array
// is the _MAX entry
if ( Enum->IsValidEnumValue(ByteValue) )
{
EnumValueName = Enum->GetNameByValue(ByteValue);
}
else
{
EnumValueName = NAME_None;
}
Ar << EnumValueName;
}
}
void FTransaction::FObjectRecord::SerializeContents( FArchive& Ar, int32 InOper )
{
if( Array )
{
//UE_LOG( LogEditorTransaction, Log, TEXT("Array %s %i*%i: %i"), Object ? *Object->GetFullName() : TEXT("Invalid Object"), Index, ElementSize, InOper);
check((SIZE_T)Array >= (SIZE_T)Object.Get() + sizeof(UObject));
check((SIZE_T)Array + sizeof(FScriptArray) <= (SIZE_T)Object.Get() + Object->GetClass()->GetPropertiesSize());
check(ElementSize!=0);
check(DefaultConstructor!=NULL);
check(Serializer!=NULL);
check(Index>=0);
check(Count>=0);
if( InOper==1 )
{
// "Saving add order" or "Undoing add order" or "Redoing remove order".
if( Ar.IsLoading() )
{
checkSlow(Index+Count<=Array->Num());
for( int32 i=Index; i<Index+Count; i++ )
{
Destructor( (uint8*)Array->GetData() + i*ElementSize );
}
Array->Remove( Index, Count, ElementSize );
}
}
else
{
// "Undo/Redo Modify" or "Saving remove order" or "Undoing remove order" or "Redoing add order".
if( InOper==-1 && Ar.IsLoading() )
{
Array->InsertZeroed( Index, Count, ElementSize );
for( int32 i=Index; i<Index+Count; i++ )
{
DefaultConstructor( (uint8*)Array->GetData() + i*ElementSize );
}
}
// Serialize changed items.
check(Index+Count<=Array->Num());
for( int32 i=Index; i<Index+Count; i++ )
{
Serializer( Ar, (uint8*)Array->GetData() + i*ElementSize );
}
}
}
else
{
//UE_LOG(LogEditorTransaction, Log, TEXT("Object %s"), *Object->GetFullName());
check(Index==0);
check(ElementSize==0);
check(DefaultConstructor==NULL);
check(Serializer==NULL);
Object->Serialize( Ar );
}
}
void UBodySetup::Serialize(FArchive& Ar)
{
Super::Serialize(Ar);
// Load GUID (or create one for older versions)
Ar << BodySetupGuid;
// If we loaded a ZERO Guid, fix that
if(Ar.IsLoading() && !BodySetupGuid.IsValid())
{
MarkPackageDirty();
UE_LOG(LogPhysics, Log, TEXT("FIX GUID FOR: %s"), *GetPathName());
BodySetupGuid = FGuid::NewGuid();
}
bool bCooked = Ar.IsCooking();
Ar << bCooked;
if (FPlatformProperties::RequiresCookedData() && !bCooked && Ar.IsLoading())
{
UE_LOG(LogPhysics, Fatal, TEXT("This platform requires cooked packages, and physX data was not cooked into %s."), *GetFullName());
}
if (bCooked)
{
if (Ar.IsCooking())
{
// Make sure to reset bHasCookedCollision data to true before calling GetCookedData for cooking
bHasCookedCollisionData = true;
FName Format = Ar.CookingTarget()->GetPhysicsFormat(this);
bHasCookedCollisionData = GetCookedData(Format) != NULL; // Get the data from the DDC or build it
TArray<FName> ActualFormatsToSave;
ActualFormatsToSave.Add(Format);
Ar << bHasCookedCollisionData;
CookedFormatData.Serialize(Ar, this, &ActualFormatsToSave);
}
else
{
if (Ar.UE4Ver() >= VER_UE4_STORE_HASCOOKEDDATA_FOR_BODYSETUP)
{
Ar << bHasCookedCollisionData;
}
CookedFormatData.Serialize(Ar, this);
}
}
if ( Ar.IsLoading() )
{
AggGeom.Serialize( Ar );
}
}
void FKSphereElem::Serialize( const FArchive& Ar )
{
if ( Ar.IsLoading() && Ar.UE4Ver() < VER_UE4_REFACTOR_PHYSICS_TRANSFORMS )
{
Center = TM_DEPRECATED.GetOrigin();
}
}
void FShadowMap2D::Serialize(FArchive& Ar)
{
FShadowMap::Serialize(Ar);
if( Ar.IsCooking() && !Ar.CookingTarget()->SupportsFeature(ETargetPlatformFeatures::DistanceFieldShadows) )
{
UShadowMapTexture2D* Dummy = NULL;
Ar << Dummy;
}
else
{
Ar << Texture;
}
Ar << CoordinateScale << CoordinateBias;
for (int Channel = 0; Channel < ARRAY_COUNT(bChannelValid); Channel++)
{
Ar << bChannelValid[Channel];
}
if (Ar.UE4Ver() >= VER_UE4_STATIC_SHADOWMAP_PENUMBRA_SIZE)
{
Ar << InvUniformPenumbraSize;
}
else if (Ar.IsLoading())
{
const float LegacyValue = 1.0f / .05f;
InvUniformPenumbraSize = FVector4(LegacyValue, LegacyValue, LegacyValue, LegacyValue);
}
}
bool FPredictionKey::NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess)
{
if (Ar.IsLoading())
{
Ar << Current;
if (Current > 0)
{
Ar << Base;
}
PredictiveConnection = Map;
}
else
{
/**
* Only serialize the payload if we have no owning connection (Client sending to server).
* or if the owning connection is this connection (Server only sends the prediction key to the client who gave it to us).
*/
if (PredictiveConnection == nullptr || (Map == PredictiveConnection))
{
Ar << Current;
if (Current > 0)
{
Ar << Base;
}
}
else
{
int16 Payload = 0;
Ar << Payload;
}
}
bOutSuccess = true;
return true;
}
void FTextHistory_AsDate::Serialize(FArchive& Ar)
{
if(Ar.IsSaving())
{
int8 HistoryType = (int8)ETextHistoryType::AsDate;
Ar << HistoryType;
}
Ar << SourceDateTime;
int8 DateStyleInt8 = (int8)DateStyle;
Ar << DateStyleInt8;
DateStyle = (EDateTimeStyle::Type)DateStyleInt8;
if( Ar.UE4Ver() >= VER_UE4_FTEXT_HISTORY_DATE_TIMEZONE )
{
Ar << TimeZone;
}
if(Ar.IsSaving())
{
FString CultureName = TargetCulture.IsValid()? TargetCulture->GetName() : FString();
Ar << CultureName;
}
else if(Ar.IsLoading())
{
FString CultureName;
Ar << CultureName;
if(!CultureName.IsEmpty())
{
TargetCulture = FInternationalization::Get().GetCulture(CultureName);
}
}
}
void FTextHistory_AsTime::Serialize(FArchive& Ar)
{
if(Ar.IsSaving())
{
int8 HistoryType = (int8)ETextHistoryType::AsTime;
Ar << HistoryType;
}
Ar << SourceDateTime;
int8 TimeStyleInt8 = (int8)TimeStyle;
Ar << TimeStyleInt8;
TimeStyle = (EDateTimeStyle::Type)TimeStyleInt8;
Ar << TimeZone;
if(Ar.IsSaving())
{
FString CultureName = TargetCulture.IsValid()? TargetCulture->GetName() : FString();
Ar << CultureName;
}
else if(Ar.IsLoading())
{
FString CultureName;
Ar << CultureName;
if(!CultureName.IsEmpty())
{
TargetCulture = FInternationalization::Get().GetCulture(CultureName);
}
}
}
void UClassProperty::Serialize( FArchive& Ar )
{
Super::Serialize( Ar );
Ar << MetaClass;
#if USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
if (Ar.IsLoading() || Ar.IsObjectReferenceCollector())
{
if (ULinkerPlaceholderClass* PlaceholderClass = Cast<ULinkerPlaceholderClass>(MetaClass))
{
PlaceholderClass->AddReferencingProperty(this);
}
}
#endif // USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
if( !(MetaClass||HasAnyFlags(RF_ClassDefaultObject)) )
{
// If we failed to load the MetaClass and we're not a CDO, that means we relied on a class that has been removed or doesn't exist.
// The most likely cause for this is either an incomplete recompile, or if content was migrated between games that had native class dependencies
// that do not exist in this game. We allow blueprint classes to continue, because compile on load will error out, and stub the class that was using it
UClass* TestClass = dynamic_cast<UClass*>(GetOwnerStruct());
if( TestClass && TestClass->HasAllClassFlags(CLASS_Native) && !TestClass->HasAllClassFlags(CLASS_NewerVersionExists) && (TestClass->GetOutermost() != GetTransientPackage()) )
{
checkf(false, TEXT("Class property tried to serialize a missing class. Did you remove a native class and not fully recompile?"));
}
}
}
void FRawCurveTracks::Serialize(FArchive& Ar)
{
// @TODO: If we're about to serialize vector curve, add here
if(Ar.UE4Ver() >= VER_UE4_SKELETON_ADD_SMARTNAMES)
{
for(FFloatCurve& Curve : FloatCurves)
{
Curve.Serialize(Ar);
}
}
#if WITH_EDITORONLY_DATA
if( !Ar.IsCooking() )
{
if( Ar.UE4Ver() >= VER_UE4_ANIMATION_ADD_TRACKCURVES )
{
for( FTransformCurve& Curve : TransformCurves )
{
Curve.Serialize( Ar );
}
}
}
#endif // WITH_EDITORONLY_DATA
if (Ar.IsLoading())
{
SortFloatCurvesByUID();
}
}
void UK2Node_Variable::Serialize(FArchive& Ar)
{
Super::Serialize(Ar);
// Fix old content
if(Ar.IsLoading())
{
if(Ar.UE4Ver() < VER_UE4_VARK2NODE_USE_MEMBERREFSTRUCT)
{
// Copy info into new struct
VariableReference.SetDirect(VariableName_DEPRECATED, FGuid(), VariableSourceClass_DEPRECATED, bSelfContext_DEPRECATED);
}
if(Ar.UE4Ver() < VER_UE4_K2NODE_REFERENCEGUIDS)
{
FGuid VarGuid;
if (UBlueprint::GetGuidFromClassByFieldName<UProperty>(GetBlueprint()->GeneratedClass, VariableReference.GetMemberName(), VarGuid))
{
const bool bSelf = VariableReference.IsSelfContext();
VariableReference.SetDirect(VariableReference.GetMemberName(), VarGuid, (bSelf ? NULL : VariableReference.GetMemberParentClass((UClass*)NULL)), bSelf);
}
}
}
}
void FLazyObjectPtr::PossiblySerializeObjectGuid(UObject *Object, FArchive& Ar)
{
if (Ar.IsSaving() || Ar.IsCountingMemory())
{
FUniqueObjectGuid Guid = GuidAnnotation.GetAnnotation(Object);
bool HasGuid = Guid.IsValid();
Ar << HasGuid;
if (HasGuid)
{
if (Ar.GetPortFlags() & PPF_DuplicateForPIE)
{
check(GPlayInEditorID != -1);
FGuid &FoundGuid = PIEGuidMap[GPlayInEditorID % MAX_PIE_INSTANCES].FindOrAdd(Guid.GetGuid());
if (!FoundGuid.IsValid())
{
Guid = FoundGuid = FGuid::NewGuid();
}
else
{
Guid = FoundGuid;
}
}
Ar << Guid;
}
}
else if (Ar.IsLoading())
{
bool HasGuid = false;
Ar << HasGuid;
if (HasGuid)
{
FUniqueObjectGuid Guid;
Ar << Guid;
// Don't try and resolve GUIDs when loading a package for diff'ing
const UPackage* Package = Object->GetOutermost();
const bool bLoadedForDiff = (Package && Package->HasAnyPackageFlags(PKG_ForDiffing));
if (!bLoadedForDiff && (!(Ar.GetPortFlags() & PPF_Duplicate) || (Ar.GetPortFlags() & PPF_DuplicateForPIE)))
{
check(!Guid.IsDefault());
UObject* OtherObject = Guid.ResolveObject();
if (OtherObject != Object) // on undo/redo, the object (potentially) already exists
{
if (OtherObject != NULL)
{
UE_CLOG(!((FApp::IsGame() || GIsPlayInEditorWorld) && Package && Package->ContainsMap()), LogUObjectGlobals, Warning, TEXT("Guid is in use by %s and %s, which should never happen in the editor but could happen at runtime with duplicate level loading or PIE"), *OtherObject->GetFullName(), !!Object ? *Object->GetFullName() : TEXT("NULL"));
// This guid is in use, which should never happen in the editor but could happen at runtime with duplicate level loading or PIE. If so give it an invalid GUID and don't add to the annotation map.
Guid = FGuid();
}
else
{
GuidAnnotation.AddAnnotation(Object, Guid);
}
FUniqueObjectGuid::InvalidateTag();
}
}
}
}
}
void UPhysicsConstraintTemplate::Serialize(FArchive& Ar)
{
#if WITH_EDITOR
FConstraintProfileProperties CurrentProfile = DefaultInstance.ProfileInstance; //Save off current profile in case they save in editor and we don't want to lose their work
if(Ar.IsSaving() && !Ar.IsTransacting())
{
DefaultInstance.ProfileInstance = DefaultProfile;
}
#endif
Super::Serialize(Ar);
// If old content, copy properties out of setup into instance
if(Ar.UE4Ver() < VER_UE4_ALL_PROPS_TO_CONSTRAINTINSTANCE)
{
CopySetupPropsToInstance(&DefaultInstance);
}
if(!Ar.IsTransacting())
{
//Make sure to keep default profile and instance in sync
if (Ar.IsLoading())
{
DefaultProfile = DefaultInstance.ProfileInstance;
}
#if WITH_EDITOR
else if(Ar.IsSaving())
{
DefaultInstance.ProfileInstance = CurrentProfile; //recover their settings before we saved
}
#endif
}
}
void UK2Node_EditablePinBase::Serialize(FArchive& Ar)
{
Super::Serialize(Ar);
TArray<FUserPinInfo> SerializedItems;
if (Ar.IsLoading())
{
Ar << SerializedItems;
UserDefinedPins.Empty(SerializedItems.Num());
for (int32 Index = 0; Index < SerializedItems.Num(); ++Index)
{
UserDefinedPins.Add(MakeShareable( new FUserPinInfo(SerializedItems[Index]) ));
}
}
else
{
SerializedItems.Empty(UserDefinedPins.Num());
for (int32 Index = 0; Index < UserDefinedPins.Num(); ++Index)
{
SerializedItems.Add(*(UserDefinedPins[Index].Get()));
}
Ar << SerializedItems;
}
}
FLocMetadataValueObject::FLocMetadataValueObject( FArchive& Archive )
: Value(new FLocMetadataObject)
{
check(Archive.IsLoading());
Archive << *Value;
}
bool FLevelSequenceObjectReferenceMap::Serialize(FArchive& Ar)
{
int32 Num = Map.Num();
Ar << Num;
if (Ar.IsLoading())
{
while(Num-- > 0)
{
FGuid Key;
Ar << Key;
FLevelSequenceObjectReference Value;
Ar << Value;
Map.Add(Key, Value);
}
}
else if (Ar.IsSaving() || Ar.IsCountingMemory() || Ar.IsObjectReferenceCollector())
{
for (auto& Pair : Map)
{
Ar << Pair.Key;
Ar << Pair.Value;
}
}
return true;
}
void FShaderResource::Serialize(FArchive& Ar)
{
Ar << SpecificType;
Ar << Target;
Ar << Code;
Ar << OutputHash;
Ar << NumInstructions;
Ar << NumTextureSamplers;
if (Ar.IsLoading())
{
INC_DWORD_STAT_BY_FName(GetMemoryStatType((EShaderFrequency)Target.Frequency).GetName(), (int64)Code.Num());
INC_DWORD_STAT_BY(STAT_Shaders_ShaderResourceMemory, GetSizeBytes());
FShaderCache::LogShader((EShaderPlatform)Target.Platform, (EShaderFrequency)Target.Frequency, OutputHash, Code);
// The shader resource has been serialized in, so this shader resource is now initialized.
check(Canary != FShader::ShaderMagic_CleaningUp);
Canary = FShader::ShaderMagic_Initialized;
}
#if WITH_EDITORONLY_DATA
else if(Ar.IsCooking())
{
FShaderCache::CookShader((EShaderPlatform)Target.Platform, (EShaderFrequency)Target.Frequency, OutputHash, Code);
}
#endif
}
bool FBuildPatchAppManifest::Serialize(FArchive& Ar)
{
if (Ar.IsLoading())
{
DestroyData();
}
Data->Serialize(Ar);
if (Ar.IsLoading())
{
InitLookups();
}
return !Ar.IsError();
}
void UPolys::Serialize( FArchive& Ar )
{
Super::Serialize( Ar );
if( Ar.IsTransacting() )
{
Ar << Element;
}
else
{
Element.CountBytes( Ar );
int32 DbNum=Element.Num(), DbMax=DbNum;
Ar << DbNum << DbMax;
UObject* ElementOwner = Element.GetOwner();
Ar << ElementOwner;
Element.SetOwner(ElementOwner);
if( Ar.IsLoading() )
{
Element.Empty( DbNum );
Element.AddZeroed( DbNum );
}
for( int32 i=0; i<Element.Num(); i++ )
{
Ar << Element[i];
}
}
}
bool FGameplayEffectContext::NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess)
{
Ar << Instigator;
Ar << EffectCauser;
Ar << Actors;
bool HasHitResults = HitResult.IsValid();
Ar << HasHitResults;
if (Ar.IsLoading())
{
if (HasHitResults)
{
if (!HitResult.IsValid())
{
HitResult = TSharedPtr<FHitResult>(new FHitResult());
}
}
AddInstigator(Instigator.Get(), EffectCauser.Get()); // Just to initialize InstigatorAbilitySystemComponent
}
if (HasHitResults == 1)
{
HitResult->NetSerialize(Ar, Map, bOutSuccess);
}
Ar << bHasWorldOrigin;
Ar << WorldOrigin;
bOutSuccess = true;
return true;
}
void UUserDefinedStruct::Serialize(FArchive& Ar)
{
Super::Serialize( Ar );
if (Ar.IsLoading() && (EUserDefinedStructureStatus::UDSS_UpToDate == Status))
{
// We need to force the editor data to be preload in case anyone needs to extract variable
// information at editor time about the user structure.
if ( EditorData != nullptr )
{
Ar.Preload(EditorData);
if (!(Ar.GetPortFlags() & PPF_Duplicate))
{
FStructureEditorUtils::RecreateDefaultInstanceInEditorData(this);
}
}
const FStructureEditorUtils::EStructureError Result = FStructureEditorUtils::IsStructureValid(this, NULL, &ErrorMessage);
if (FStructureEditorUtils::EStructureError::Ok != Result)
{
Status = EUserDefinedStructureStatus::UDSS_Error;
UE_LOG(LogClass, Log, TEXT("UUserDefinedStruct.Serialize '%s' validation: %s"), *GetName(), *ErrorMessage);
}
}
}
void UFontBulkData::Serialize(FArchive& Ar)
{
Super::Serialize(Ar);
BulkData.Serialize(Ar, this);
if( !GIsEditor && Ar.IsLoading() )
{
BulkData.SetBulkDataFlags( BULKDATA_SingleUse );
}
#if STATS
if( Ar.IsLoading() && BulkData.IsBulkDataLoaded() )
{
INC_DWORD_STAT_BY( STAT_SlateBulkFontDataMemory, BulkData.GetBulkDataSize() );
}
#endif
}
void UParticleModuleVelocityInheritParent::Serialize(FArchive& Ar)
{
Super::Serialize(Ar);
if (Ar.IsLoading() && Ar.UE4Ver() < VER_UE4_MOVE_DISTRIBUITONS_TO_POSTINITPROPS)
{
FDistributionHelpers::RestoreDefaultConstant(Scale.Distribution, TEXT("DistributionScale"), FVector(1.0f, 1.0f, 1.0f));
}
}
