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);
}
}
void USoundWave::SerializeCookedPlatformData(FArchive& Ar)
{
if (IsTemplate())
{
return;
}
DECLARE_SCOPE_CYCLE_COUNTER( TEXT("USoundWave::SerializeCookedPlatformData"), STAT_SoundWave_SerializeCookedPlatformData, STATGROUP_LoadTime );
#if WITH_EDITORONLY_DATA
if (Ar.IsCooking() && Ar.IsPersistent())
{
check(!Ar.CookingTarget()->IsServerOnly());
FName PlatformFormat = Ar.CookingTarget()->GetWaveFormat(this);
FString DerivedDataKey;
GetStreamedAudioDerivedDataKey(*this, PlatformFormat, DerivedDataKey);
FStreamedAudioPlatformData *PlatformDataToSave = CookedPlatformData.FindRef(DerivedDataKey);
if (PlatformDataToSave == NULL)
{
PlatformDataToSave = new FStreamedAudioPlatformData();
PlatformDataToSave->Cache(*this, PlatformFormat, EStreamedAudioCacheFlags::InlineChunks | EStreamedAudioCacheFlags::Async);
CookedPlatformData.Add(DerivedDataKey, PlatformDataToSave);
}
PlatformDataToSave->FinishCache();
PlatformDataToSave->Serialize(Ar, this);
}
else
#endif // #if WITH_EDITORONLY_DATA
{
check(!FPlatformProperties::IsServerOnly());
CleanupCachedRunningPlatformData();
check(RunningPlatformData == NULL);
// Don't serialize streaming data on servers, even if this platform supports streaming in theory
RunningPlatformData = new FStreamedAudioPlatformData();
RunningPlatformData->Serialize(Ar, this);
}
}
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 Serialize(FArchive& Ar, UObject* Owner, int32 Idx)
{
const uint8 AdjacencyDataStripFlag = 1;
FStripDataFlags StripFlags( Ar, Ar.IsCooking() && !Ar.CookingTarget()->SupportsFeature(ETargetPlatformFeatures::Tessellation) ? AdjacencyDataStripFlag : 0 );
UStaticMesh* StaticMesh = Cast<UStaticMesh>( Owner );
bool bNeedsCPUAccess = true;
if( !StripFlags.IsEditorDataStripped() )
{
RawTriangles.Serialize( Ar, Owner );
}
Ar << Elements;
if( !StripFlags.IsDataStrippedForServer() )
{
PositionVertexBuffer.Serialize( Ar, bNeedsCPUAccess );
VertexBuffer.Serialize( Ar, bNeedsCPUAccess );
ColorVertexBuffer.Serialize( Ar, bNeedsCPUAccess );
Ar << NumVertices;
IndexBuffer.Serialize( Ar, bNeedsCPUAccess );
if (Ar.UE4Ver() >= VER_UE4_SHADOW_ONLY_INDEX_BUFFERS)
{
ShadowIndexBuffer.Serialize(Ar, bNeedsCPUAccess);
}
if( !StripFlags.IsEditorDataStripped() )
{
Ar << WireframeIndexBuffer;
}
if ( !StripFlags.IsClassDataStripped( AdjacencyDataStripFlag ) )
{
AdjacencyIndexBuffer.Serialize( Ar, bNeedsCPUAccess );
}
}
if (Ar.IsLoading())
{
if (PositionVertexBuffer.GetNumVertices() != NumVertices)
{
PositionVertexBuffer.RemoveLegacyShadowVolumeVertices(NumVertices);
}
if (VertexBuffer.GetNumVertices() != NumVertices)
{
VertexBuffer.RemoveLegacyShadowVolumeVertices(NumVertices);
}
if (VertexBuffer.GetNumVertices() != NumVertices)
{
ColorVertexBuffer.RemoveLegacyShadowVolumeVertices(NumVertices);
}
}
}
void ULightComponent::Serialize(FArchive& Ar)
{
Super::Serialize(Ar);
if (Ar.UE4Ver() >= VER_UE4_STATIC_SHADOW_DEPTH_MAPS)
{
if (Ar.IsCooking() && !Ar.CookingTarget()->SupportsFeature(ETargetPlatformFeatures::HighQualityLightmaps))
{
// Toss lighting data only needed for high quality lightmaps
FStaticShadowDepthMap EmptyDepthMap;
Ar << EmptyDepthMap;
}
else
{
Ar << StaticShadowDepthMap;
}
}
}
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];
}
}
void USoundWave::Serialize( FArchive& Ar )
{
Super::Serialize( Ar );
bool bCooked = Ar.IsCooking();
Ar << bCooked;
if (FPlatformProperties::RequiresCookedData() && !bCooked && Ar.IsLoading())
{
UE_LOG(LogAudio, Fatal, TEXT("This platform requires cooked packages, and audio data was not cooked into %s."), *GetFullName());
}
if (Ar.IsCooking())
{
CompressionName = Ar.CookingTarget()->GetWaveFormat(this);
}
if (Ar.UE4Ver() >= VER_UE4_SOUND_COMPRESSION_TYPE_ADDED)
{
Ar << CompressionName;
}
if (bCooked)
{
// Only want to cook/load full data if we don't support streaming
if (!IsStreaming() ||
(Ar.IsLoading() && !FPlatformProperties::SupportsAudioStreaming()) ||
(Ar.IsCooking() && !Ar.CookingTarget()->SupportsFeature(ETargetPlatformFeatures::AudioStreaming)))
{
if (Ar.IsCooking())
{
#if WITH_ENGINE
TArray<FName> ActualFormatsToSave;
if (!Ar.CookingTarget()->IsServerOnly())
{
// for now we only support one format per wav
FName Format = Ar.CookingTarget()->GetWaveFormat(this);
GetCompressedData(Format); // Get the data from the DDC or build it
ActualFormatsToSave.Add(Format);
}
CompressedFormatData.Serialize(Ar, this, &ActualFormatsToSave);
#endif
}
else
{
CompressedFormatData.Serialize(Ar, this);
}
}
}
else
{
// only save the raw data for non-cooked packages
RawData.Serialize( Ar, this );
}
Ar << CompressedDataGuid;
if (IsStreaming())
{
if (bCooked)
{
// only cook/load streaming data if it's supported
if ((Ar.IsLoading() && FPlatformProperties::SupportsAudioStreaming()) ||
(Ar.IsCooking() && Ar.CookingTarget()->SupportsFeature(ETargetPlatformFeatures::AudioStreaming)))
{
SerializeCookedPlatformData(Ar);
}
}
#if WITH_EDITORONLY_DATA
if (Ar.IsLoading() && !Ar.IsTransacting() && !bCooked && !(GetOutermost()->PackageFlags & PKG_ReloadingForCooker))
{
BeginCachePlatformData();
}
#endif // #if WITH_EDITORONLY_DATA
}
}
/**
* Serialize function used to serialize this bulk data structure.
*
* @param Ar Archive to serialize with
* @param Owner Object owning the bulk data
* @param Idx Index of bulk data item being serialized
*/
void FUntypedBulkData::Serialize( FArchive& Ar, UObject* Owner, int32 Idx )
{
check( LockStatus == LOCKSTATUS_Unlocked );
if(Ar.IsTransacting())
{
// Special case for transacting bulk data arrays.
// constructing the object during load will save it to the transaction buffer. If it tries to load the bulk data now it will try to break it.
bool bActuallySave = Ar.IsSaving() && (!Owner || !Owner->HasAnyFlags(RF_NeedLoad));
Ar << bActuallySave;
if (bActuallySave)
{
if(Ar.IsLoading())
{
// Flags for bulk data.
Ar << BulkDataFlags;
// Number of elements in array.
Ar << ElementCount;
// Allocate bulk data.
check(bShouldFreeOnEmpty);
BulkData = FMemory::Realloc( BulkData, GetBulkDataSize() );
// Deserialize bulk data.
SerializeBulkData( Ar, BulkData );
}
else if(Ar.IsSaving())
{
// Flags for bulk data.
Ar << BulkDataFlags;
// Number of elements in array.
Ar << ElementCount;
// Don't attempt to load or serialize BulkData if the current size is 0.
// This could be a newly constructed BulkData that has not yet been loaded,
// and allocating 0 bytes now will cause a crash when we load.
if (GetBulkDataSize() > 0)
{
// Make sure bulk data is loaded.
MakeSureBulkDataIsLoaded();
// Serialize bulk data.
SerializeBulkData(Ar, BulkData);
}
}
}
}
else if( Ar.IsPersistent() && !Ar.IsObjectReferenceCollector() && !Ar.ShouldSkipBulkData() )
{
#if TRACK_BULKDATA_USE
FThreadSafeBulkDataToObjectMap::Get().Add( this, Owner );
#endif
// Offset where the bulkdata flags are stored
int64 SavedBulkDataFlagsPos = Ar.Tell();
Ar << BulkDataFlags;
// Number of elements in array.
Ar << ElementCount;
// We're loading from the persistent archive.
if( Ar.IsLoading() )
{
Filename = TEXT("");
// @todo when Landscape (and others?) only Lock/Unlock once, we can enable this
if (false) // FPlatformProperties::RequiresCookedData())
{
// Bulk data that is being serialized via seekfree loading is single use only. This allows us
// to free the memory as e.g. the bulk data won't be attached to an archive in the case of
// seek free loading.
BulkDataFlags |= BULKDATA_SingleUse;
}
// Size on disk, which in the case of compression is != GetBulkDataSize()
Ar << BulkDataSizeOnDisk;
Ar << BulkDataOffsetInFile;
// fix up the file offset
if (Owner != NULL && Owner->GetLinker())
{
BulkDataOffsetInFile += Owner->GetLinker()->Summary.BulkDataStartOffset;
}
// determine whether the payload is stored inline or at the end of the file
bool bPayloadInline = !(BulkDataFlags&BULKDATA_PayloadAtEndOfFile);
// check( (bPayloadInline && BulkDataOffsetInFile == Ar.Tell()) ||
// (!bPayloadInline && BulkDataOffsetInFile > Ar.Tell()));
// We're allowing defered serialization.
if( Ar.IsAllowingLazyLoading() && Owner != NULL)
{
Linker = Owner->GetLinker();
#if WITH_EDITOR
check(Linker);
Ar.AttachBulkData( Owner, this );
AttachedAr = &Ar;
#else
check(Linker.IsValid());
Filename = Linker->Filename;
#endif // WITH_EDITOR
// only skip over payload, if it's stored inline
if (bPayloadInline)
{
Ar.Seek( Ar.Tell() + BulkDataSizeOnDisk );
}
}
// Serialize the bulk data right away.
else
{
// memory for bulk data can come from preallocated GPU-accessible resource memory or default to system memory
BulkData = GetBulkDataResourceMemory(Owner,Idx);
if( !BulkData )
{
BulkData = FMemory::Realloc( BulkData, GetBulkDataSize() );
}
if (bPayloadInline)
{
// if the payload is stored inline, just serialize it
SerializeBulkData( Ar, BulkData );
}
else
{
// if the payload is NOT stored inline ...
// store the current file offset
int64 CurOffset = Ar.Tell();
// seek to the location in the file where the payload is stored
Ar.Seek(BulkDataOffsetInFile);
// serialize the payload
SerializeBulkData( Ar, BulkData );
// seek to the location we came from
Ar.Seek(CurOffset);
}
}
}
// We're saving to the persistent archive.
else if( Ar.IsSaving() )
{
// check if we save the package compressed
UPackage* Pkg = Owner ? dynamic_cast<UPackage*>(Owner->GetOutermost()) : nullptr;
if (Pkg && !!(Pkg->PackageFlags & PKG_StoreCompressed) )
{
ECompressionFlags BaseCompressionMethod = COMPRESS_Default;
if (Ar.IsCooking())
{
BaseCompressionMethod = Ar.CookingTarget()->GetBaseCompressionMethod();
}
StoreCompressedOnDisk(BaseCompressionMethod);
}
// Remove single element serialization requirement before saving out bulk data flags.
BulkDataFlags &= ~BULKDATA_ForceSingleElementSerialization;
// Make sure bulk data is loaded.
MakeSureBulkDataIsLoaded();
// Only serialize status information if wanted.
int64 SavedBulkDataSizeOnDiskPos = INDEX_NONE;
int64 SavedBulkDataOffsetInFilePos = INDEX_NONE;
// Keep track of position we are going to serialize placeholder BulkDataSizeOnDisk.
SavedBulkDataSizeOnDiskPos = Ar.Tell();
BulkDataSizeOnDisk = INDEX_NONE;
// And serialize the placeholder which is going to be overwritten later.
Ar << BulkDataSizeOnDisk;
// Keep track of position we are going to serialize placeholder BulkDataOffsetInFile.
SavedBulkDataOffsetInFilePos = Ar.Tell();
BulkDataOffsetInFile = INDEX_NONE;
// And serialize the placeholder which is going to be overwritten later.
Ar << BulkDataOffsetInFile;
// try to get the linkersave object
ULinkerSave* LinkerSave = dynamic_cast<ULinkerSave*>(Ar.GetLinker());
// determine whether we are going to store the payload inline or not.
bool bStoreInline = !!(BulkDataFlags&BULKDATA_ForceInlinePayload) || LinkerSave == NULL;
if (!bStoreInline)
{
// set the flag indicating where the payload is stored
BulkDataFlags |= BULKDATA_PayloadAtEndOfFile;
// with no LinkerSave we have to store the data inline
check(LinkerSave != NULL);
// add the bulkdata storage info object to the linkersave
int32 Index = LinkerSave->BulkDataToAppend.AddZeroed(1);
ULinkerSave::FBulkDataStorageInfo& BulkStore = LinkerSave->BulkDataToAppend[Index];
BulkStore.BulkDataOffsetInFilePos = SavedBulkDataOffsetInFilePos;
BulkStore.BulkDataSizeOnDiskPos = SavedBulkDataSizeOnDiskPos;
BulkStore.BulkData = this;
// Serialize bulk data into the storage info
BulkDataSizeOnDisk = -1;
}
else
{
// set the flag indicating where the payload is stored
BulkDataFlags &= ~BULKDATA_PayloadAtEndOfFile;
int64 SavedBulkDataStartPos = Ar.Tell();
// Serialize bulk data.
SerializeBulkData( Ar, BulkData );
// store the payload endpos
int64 SavedBulkDataEndPos = Ar.Tell();
checkf(SavedBulkDataStartPos >= 0 && SavedBulkDataEndPos >= 0,
TEXT("Bad archive positions for bulkdata. StartPos=%d EndPos=%d"),
SavedBulkDataStartPos, SavedBulkDataEndPos);
BulkDataSizeOnDisk = SavedBulkDataEndPos - SavedBulkDataStartPos;
BulkDataOffsetInFile = SavedBulkDataStartPos;
}
// store current file offset before seeking back
int64 CurrentFileOffset = Ar.Tell();
// Seek back and overwrite the flags
Ar.Seek(SavedBulkDataFlagsPos);
Ar << BulkDataFlags;
// Seek back and overwrite placeholder for BulkDataSizeOnDisk
Ar.Seek( SavedBulkDataSizeOnDiskPos );
Ar << BulkDataSizeOnDisk;
// Seek back and overwrite placeholder for BulkDataOffsetInFile
Ar.Seek( SavedBulkDataOffsetInFilePos );
Ar << BulkDataOffsetInFile;
// Seek to the end of written data so we don't clobber any data in subsequent write
// operations
Ar.Seek(CurrentFileOffset);
}
}
}
void UReflectionCaptureComponent::Serialize(FArchive& Ar)
{
Super::Serialize(Ar);
bool bCooked = false;
if (Ar.UE4Ver() >= VER_UE4_REFLECTION_CAPTURE_COOKING)
{
bCooked = Ar.IsCooking();
// Save a bool indicating whether this is cooked data
// This is needed when loading cooked data, to know to serialize differently
Ar << bCooked;
}
if (FPlatformProperties::RequiresCookedData() && !bCooked && Ar.IsLoading())
{
UE_LOG(LogMaterial, Fatal, TEXT("This platform requires cooked packages, and this reflection capture does not contain cooked data %s."), *GetName());
}
if (bCooked)
{
static FName FullHDR(TEXT("FullHDR"));
static FName EncodedHDR(TEXT("EncodedHDR"));
// Saving for cooking path
if (Ar.IsCooking())
{
// Get all the reflection capture formats that the target platform wants
TArray<FName> Formats;
Ar.CookingTarget()->GetReflectionCaptureFormats(Formats);
int32 NumFormats = Formats.Num();
Ar << NumFormats;
for (int32 FormatIndex = 0; FormatIndex < NumFormats; FormatIndex++)
{
FName CurrentFormat = Formats[FormatIndex];
Ar << CurrentFormat;
if (CurrentFormat == FullHDR)
{
// FullHDRDerivedData would have been set in PostLoad during cooking if it exists in the DDC
// Can't generate it if missing, since that requires rendering the scene
bool bValid = FullHDRDerivedData != NULL;
Ar << bValid;
if (bValid)
{
Ar << FullHDRDerivedData->CompressedCapturedData;
}
}
else
{
check(CurrentFormat == EncodedHDR);
TRefCountPtr<FReflectionCaptureEncodedHDRDerivedData> EncodedHDRData;
// FullHDRDerivedData would have been set in PostLoad during cooking if it exists in the DDC
// Generate temporary encoded HDR data for saving
if (FullHDRDerivedData != NULL)
{
EncodedHDRData = FReflectionCaptureEncodedHDRDerivedData::GenerateEncodedHDRData(*FullHDRDerivedData, StateId, Brightness);
}
bool bValid = EncodedHDRData != NULL;
Ar << bValid;
if (bValid)
{
Ar << EncodedHDRData->CapturedData;
}
else if (!IsTemplate())
{
// Temporary warning until the cooker can do scene captures itself in the case of missing DDC
UE_LOG(LogMaterial, Warning, TEXT("Reflection capture requires encoded HDR data but none was found in the DDC! This reflection will be black. Fix by loading the map in the editor once. %s."), *GetFullName());
}
}
}
}
else
{
// Loading cooked data path
int32 NumFormats = 0;
Ar << NumFormats;
for (int32 FormatIndex = 0; FormatIndex < NumFormats; FormatIndex++)
{
FName CurrentFormat;
Ar << CurrentFormat;
bool bValid = false;
Ar << bValid;
if (bValid)
{
if (CurrentFormat == FullHDR)
{
FullHDRDerivedData = new FReflectionCaptureFullHDRDerivedData();
Ar << FullHDRDerivedData->CompressedCapturedData;
}
else
{
check(CurrentFormat == EncodedHDR);
EncodedHDRDerivedData = new FReflectionCaptureEncodedHDRDerivedData();
Ar << EncodedHDRDerivedData->CapturedData;
}
}
else if (CurrentFormat == EncodedHDR)
{
// Temporary warning until the cooker can do scene captures itself in the case of missing DDC
UE_LOG(LogMaterial, Error, TEXT("Reflection capture was loaded without any valid capture data and will be black. This can happen if the DDC was not up to date during cooking. Load the map in the editor once before cooking to fix. %s."), *GetFullName());
}
}
}
}
}
void USoundWave::Serialize( FArchive& Ar )
{
DECLARE_SCOPE_CYCLE_COUNTER( TEXT("USoundWave::Serialize"), STAT_SoundWave_Serialize, STATGROUP_LoadTime );
Super::Serialize( Ar );
bool bCooked = Ar.IsCooking();
Ar << bCooked;
if (FPlatformProperties::RequiresCookedData() && !bCooked && Ar.IsLoading())
{
UE_LOG(LogAudio, Fatal, TEXT("This platform requires cooked packages, and audio data was not cooked into %s."), *GetFullName());
}
Ar.UsingCustomVersion(FFrameworkObjectVersion::GUID);
if (Ar.IsLoading() && (Ar.UE4Ver() >= VER_UE4_SOUND_COMPRESSION_TYPE_ADDED) && (Ar.CustomVer(FFrameworkObjectVersion::GUID) < FFrameworkObjectVersion::RemoveSoundWaveCompressionName))
{
FName DummyCompressionName;
Ar << DummyCompressionName;
}
bool bSupportsStreaming = false;
if (Ar.IsLoading() && FPlatformProperties::SupportsAudioStreaming())
{
bSupportsStreaming = true;
}
else if (Ar.IsCooking() && Ar.CookingTarget()->SupportsFeature(ETargetPlatformFeatures::AudioStreaming))
{
bSupportsStreaming = true;
}
if (bCooked)
{
// Only want to cook/load full data if we don't support streaming
if (!IsStreaming() || !bSupportsStreaming)
{
if (Ar.IsCooking())
{
#if WITH_ENGINE
TArray<FName> ActualFormatsToSave;
if (!Ar.CookingTarget()->IsServerOnly())
{
// for now we only support one format per wav
FName Format = Ar.CookingTarget()->GetWaveFormat(this);
GetCompressedData(Format); // Get the data from the DDC or build it
ActualFormatsToSave.Add(Format);
}
CompressedFormatData.Serialize(Ar, this, &ActualFormatsToSave);
#endif
}
else
{
CompressedFormatData.Serialize(Ar, this);
}
}
}
else
{
// only save the raw data for non-cooked packages
RawData.Serialize( Ar, this );
}
Ar << CompressedDataGuid;
if (IsStreaming())
{
if (bCooked)
{
// only cook/load streaming data if it's supported
if (bSupportsStreaming)
{
SerializeCookedPlatformData(Ar);
}
}
#if WITH_EDITORONLY_DATA
if (Ar.IsLoading() && !Ar.IsTransacting() && !bCooked && !GetOutermost()->HasAnyPackageFlags(PKG_ReloadingForCooker))
{
BeginCachePlatformData();
}
#endif // #if WITH_EDITORONLY_DATA
}
}
