CurveCompressionSettings

CurveCompressionSettings

#Overview

name: CurveCompressionSettings

The value of this variable can be defined or overridden in .ini config files. 1 .ini config file referencing this setting variable.

It is referenced in 37 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of CurveCompressionSettings is to define the settings used for compressing animation curves in Unreal Engine 5. This variable is part of the animation system and is specifically used for curve data compression.

CurveCompressionSettings is primarily used in the animation subsystem of Unreal Engine. It’s referenced in various animation-related classes and functions, including UAnimSequence, UAnimStreamable, and several compression and serialization functions.

The value of this variable is typically set within the animation asset itself. It can be edited in the Unreal Editor through the asset’s properties panel.

CurveCompressionSettings often interacts with other compression-related variables, such as BoneCompressionSettings and VariableFrameStrippingSettings. These variables work together to define the overall compression strategy for animation data.

Developers should be aware that:

  1. Changing CurveCompressionSettings can affect the size and quality of animation data.
  2. It’s crucial for proper serialization and deserialization of animation data.
  3. Null or invalid settings can lead to using default compression settings.

Best practices when using this variable include:

  1. Ensuring the settings are valid before use.
  2. Being consistent with compression settings across related animations for optimal performance.
  3. Considering the target platform when choosing compression settings.
  4. Testing the impact of different compression settings on animation quality and performance.

Remember that improper use of compression settings can lead to increased memory usage, degraded animation quality, or even runtime errors. Always test thoroughly after making changes to these settings.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Config/BaseEngine.ini:3390, section: [Animation.DefaultObjectSettings]

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Plugins/Animation/ACLPlugin/Source/ACLPlugin/Private/ACLPluginModule.cpp:187

Scope (from outer to inner):

file
function     void FACLPlugin::ListCodecs

Source code excerpt:

		{
			const SIZE_T Size = GetCompressedCurveSize(AnimSeq->CompressedData);
			if (AnimSeq->CurveCompressionSettings == Settings)
			{
				NumReferences++;
				UsedSize += Size;
			}
			TotalSize += Size;
		}

#Loc: <Workspace>/Engine/Plugins/Importers/USDImporter/Source/USDSchemas/Private/USDSkelRootTranslator.cpp:1601

Scope (from outer to inner):

file
namespace    UsdSkelRootTranslatorImpl
function     void FSkelRootCreateAssetsTaskChain::SetupTasks
lambda-function

Source code excerpt:


							// The UAnimSequence can't be created with the RF_Transactional flag, or else it will be serialized without
							// Bone/CurveCompressionSettings. Undoing that transaction would call UAnimSequence::Serialize with nullptr values for
							// both, which crashes. Besides, this particular asset type is only ever created when we import to content folder assets
							// (so never for realtime), and in that case we don't need it to be transactional anyway
							AnimSequence = NewObject<UAnimSequence>(
								GetTransientPackage(),
								AnimSequenceName,
								(Context->ObjectFlags & ~EObjectFlags::RF_Transactional) | EObjectFlags::RF_Transient

#Loc: <Workspace>/Engine/Plugins/Importers/USDImporter/Source/USDSchemas/Private/USDSkelSkeletonTranslator.cpp:1847

Scope (from outer to inner):

file
namespace    UsdSkelSkeletonTranslatorImpl
function     void FSkelSkeletonCreateAssetsTaskChain::SetupTasks
lambda-function

Source code excerpt:


					// The UAnimSequence can't be created with the RF_Transactional flag, or else it will be serialized without
					// Bone/CurveCompressionSettings. Undoing that transaction would call UAnimSequence::Serialize with nullptr values for
					// both, which crashes. Besides, this particular asset type is only ever created when we import to content folder assets
					// (so never for realtime), and in that case we don't need it to be transactional anyway
					AnimSequence = NewObject<UAnimSequence>(
						GetTransientPackage(),
						AnimSequenceName,
						(Context->ObjectFlags & ~EObjectFlags::RF_Transactional) | EObjectFlags::RF_Transient

#Loc: <Workspace>/Engine/Source/Developer/AssetTools/Private/AssetTypeActions/AssetTypeActions_AnimCurveCompressionSettings.cpp:79

Scope (from outer to inner):

file
function     void FAssetTypeActions_AnimCurveCompressionSettings::ExecuteCompression

Source code excerpt:

		}

		if (AnimSeq->CurveCompressionSettings == Settings)
		{
			AnimSeqsToRecompress.Add(AnimSeq);
		}
	}

	if (AnimSeqsToRecompress.Num() == 0)

#Loc: <Workspace>/Engine/Source/Editor/AnimationBlueprintLibrary/Private/AnimationBlueprintLibrary.cpp:255

Scope (from outer to inner):

file
function     void UAnimationBlueprintLibrary::GetCurveCompressionSettings

Source code excerpt:

	}

	CompressionSettings = AnimationSequence->CurveCompressionSettings;
}

void UAnimationBlueprintLibrary::SetCurveCompressionSettings(UAnimSequence* AnimationSequence, UAnimCurveCompressionSettings* CompressionSettings)
{
	if (AnimationSequence == nullptr)
	{

#Loc: <Workspace>/Engine/Source/Editor/AnimationBlueprintLibrary/Private/AnimationBlueprintLibrary.cpp:272

Scope (from outer to inner):

file
function     void UAnimationBlueprintLibrary::SetCurveCompressionSettings

Source code excerpt:

	}

	AnimationSequence->CurveCompressionSettings = CompressionSettings;
}

void UAnimationBlueprintLibrary::GetVariableFrameStrippingSettings(const UAnimSequence* AnimationSequence, UVariableFrameStrippingSettings*& VariableFrameStrippingSettings)
{
	if (AnimationSequence == nullptr)
	{

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/PackageUtilities.cpp:1991

Scope (from outer to inner):

file
function     void DoIt

Source code excerpt:

			UE_LOG(LogPackageUtilities, Warning, TEXT("%s (%s) Resetting with to default compression settings."), *AnimSeq->GetName(), *AnimSeq->GetFullName());
			AnimSeq->BoneCompressionSettings = nullptr;
			AnimSeq->CurveCompressionSettings = nullptr;
			AnimSeq->CacheDerivedDataForCurrentPlatform();

			// Automatic compression should have picked a suitable compressor
			if (!AnimSeq->IsCompressedDataValid())
			{
				// Update CompressCommandletVersion in that case, and create a proper DDC entry

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/Animation/AnimSequence.h:295

Scope (from outer to inner):

file
class        class UAnimSequence : public UAnimSequenceBase

Source code excerpt:

	/** The curve compression settings used to compress curves in this sequence. */
	UPROPERTY(Category = Compression, EditAnywhere, meta = (ForceShowEngineContent))
	TObjectPtr<class UAnimCurveCompressionSettings> CurveCompressionSettings;

	FCompressedAnimSequence CompressedData;

	UPROPERTY(Category = Compression, EditAnywhere, meta = (ForceShowEngineContent))
	TObjectPtr<class UVariableFrameStrippingSettings> VariableFrameStrippingSettings;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Classes/Animation/AnimStreamable.h:185

Scope (from outer to inner):

file
class        class UAnimStreamable : public UAnimSequenceBase

Source code excerpt:

	/** The curve compression settings used to compress curves in this sequence. */
	UPROPERTY(Category = Compression, EditAnywhere)
	TObjectPtr<class UAnimCurveCompressionSettings> CurveCompressionSettings;

	/** The settings used to control whether or not to use variable frame stripping and its amount*/
	UPROPERTY(Category = Compression, EditAnywhere)
	TObjectPtr<class UVariableFrameStrippingSettings> VariableFrameStrippingSettings;

	/** If this is on, it will allow extracting of root motion **/

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimCompressionDerivedData.cpp:113

Scope (from outer to inner):

file
function     bool FDerivedDataAnimationCompression::Build

Source code excerpt:

		OutData.CompressedRawData = DataToCompress.RawAnimationData;
		OutData.OwnerName = DataToCompress.AnimFName;
		OutData.SerializeCompressedData(Ar, true, nullptr, nullptr, DataToCompress.BoneCompressionSettings, DataToCompress.CurveCompressionSettings); //Save out compressed
	}

	return bCompressionSuccessful;
}

#endif	//WITH_EDITOR

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimCompressionTypes.cpp:763

Scope (from outer to inner):

file
function     FCompressibleAnimData::FCompressibleAnimData

Source code excerpt:


FCompressibleAnimData::FCompressibleAnimData(class UAnimSequence* InSeq, const bool bPerformStripping, const ITargetPlatform* InTargetPlatform)
	: CurveCompressionSettings(InSeq->CurveCompressionSettings)
	, BoneCompressionSettings(InSeq->BoneCompressionSettings)
	, Interpolation(InSeq->Interpolation)
	, SequenceLength(InSeq->GetDataModelInterface()->GetPlayLength())
	, AdditiveType(InSeq->GetAdditiveAnimType())
	, bIsValidAdditive(InSeq->IsValidAdditive())
#if WITH_EDITORONLY_DATA

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimCompressionTypes.cpp:1002

Scope (from outer to inner):

file
function     FCompressibleAnimData::FCompressibleAnimData

Source code excerpt:

}
FCompressibleAnimData::FCompressibleAnimData(UAnimBoneCompressionSettings* InBoneCompressionSettings, UAnimCurveCompressionSettings* InCurveCompressionSettings, USkeleton* InSkeleton, EAnimInterpolationType InInterpolation, float InSequenceLength, int32 InNumberOfKeys, const ITargetPlatform* InTargetPlatform)
	: CurveCompressionSettings(InCurveCompressionSettings)
	, BoneCompressionSettings(InBoneCompressionSettings)
	, Interpolation(InInterpolation)
	, SequenceLength(InSequenceLength)
	PRAGMA_DISABLE_DEPRECATION_WARNINGS
	, NumberOfFrames(InNumberOfKeys)
	PRAGMA_ENABLE_DEPRECATION_WARNINGS

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimCompressionTypes.cpp:1023

Scope (from outer to inner):

file
function     FCompressibleAnimData::FCompressibleAnimData

Source code excerpt:


FCompressibleAnimData::FCompressibleAnimData()
: CurveCompressionSettings(nullptr)
, BoneCompressionSettings(nullptr)
, Interpolation((EAnimInterpolationType)0)
, SequenceLength(0.f)
PRAGMA_DISABLE_DEPRECATION_WARNINGS
, NumberOfFrames(0)
PRAGMA_ENABLE_DEPRECATION_WARNINGS

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimCompressionTypes.cpp:1283

Scope (from outer to inner):

file
function     void FCompressedAnimSequence::SerializeCompressedData

Source code excerpt:

#endif

void FCompressedAnimSequence::SerializeCompressedData(FArchive& Ar, bool bDDCData, UObject* DataOwner, USkeleton* Skeleton, UAnimBoneCompressionSettings* BoneCompressionSettings, UAnimCurveCompressionSettings* CurveCompressionSettings, bool bCanUseBulkData)
{
	Ar.UsingCustomVersion(FFortniteMainBranchObjectVersion::GUID);

	Ar << CompressedRawDataSize;
	Ar << CompressedTrackToSkeletonMapTable;
	Ar << IndexedCurveNames;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimCompressionTypes.cpp:1371

Scope (from outer to inner):

file
function     void FCompressedAnimSequence::SerializeCompressedData

Source code excerpt:

		// Lookup our codecs in our settings assets
		ValidateUObjectLoaded(BoneCompressionSettings, DataOwner);
		ValidateUObjectLoaded(CurveCompressionSettings, DataOwner);
		BoneCompressionCodec = BoneCompressionSettings->GetCodec(BoneCodecDDCHandle);
		CurveCompressionCodec = CurveCompressionSettings->GetCodec(CurveCodecPath);

		if (BoneCompressionCodec != nullptr)
		{
			CompressedDataStructure = BoneCompressionCodec->AllocateAnimData();
			CompressedDataStructure->SerializeCompressedData(Ar);
			CompressedDataStructure->Bind(CompressedByteStream);

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimSequence.cpp:272

Scope (from outer to inner):

file
function     FString GetAnimSequenceSpecificCacheKeySuffix

Source code excerpt:

	ArcToHexString.Ar << bPerformStripping;
	Seq.BoneCompressionSettings->PopulateDDCKey(UE::Anim::Compression::FAnimDDCKeyArgs(Seq, TargetPlatform), ArcToHexString.Ar);
	Seq.CurveCompressionSettings->PopulateDDCKey(ArcToHexString.Ar);
	Seq.VariableFrameStrippingSettings->PopulateDDCKey(UE::Anim::Compression::FAnimDDCKeyArgs(Seq, TargetPlatform), ArcToHexString.Ar);

	FString Ret = FString::Printf(TEXT("%i_%s%s%s_%c%c%i_%s_%s_%i"),
		Seq.CompressCommandletVersion,
		PRAGMA_DISABLE_DEPRECATION_WARNINGS
		*Seq.GetDataModel()->GenerateGuid().ToString(),

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimSequence.cpp:893

Scope (from outer to inner):

file
function     void UAnimSequence::GetPreloadDependencies

Source code excerpt:

	// We preload the compression settings because we need them loaded during Serialize to lookup the proper codec
	// which is stored as a path/string.
	if (CurveCompressionSettings != nullptr)
	{
		OutDeps.Add(CurveCompressionSettings);
	}

	if (BoneCompressionSettings != nullptr)
	{
		OutDeps.Add(BoneCompressionSettings);
	}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimSequence.cpp:1136

Scope (from outer to inner):

file
function     void UAnimSequence::PostEditChangeProperty

Source code excerpt:

											  || PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(UAnimSequence, CompressionErrorThresholdScale)
											  || PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(UAnimSequence, BoneCompressionSettings)
											  || PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(UAnimSequence, CurveCompressionSettings)
											  || PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(UAnimSequence, VariableFrameStrippingSettings);

		bShouldResample = PropertyChangedEvent.GetMemberPropertyName() == GET_MEMBER_NAME_CHECKED(UAnimSequence, PlatformTargetFrameRate) || bChangedRefFrameIndex;
	}

	if (bShouldResample)

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimSequence.cpp:2007

Scope (from outer to inner):

file
function     void UAnimSequence::SerializeCompressedData

Source code excerpt:

		}();
	
		CompressedDataToSerialize.SerializeCompressedData(Ar, bDDCData, this, this->GetSkeleton(), BoneCompressionSettings, CurveCompressionSettings);
	}
}

#if WITH_EDITOR
void UAnimSequence::OnAnimModelLoaded()
{

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimSequence.cpp:4548

Scope (from outer to inner):

file
function     FIoHash UAnimSequence::CreateDerivedDataKeyHash

Source code excerpt:

	ArcToHexString.Ar << bPerformFrameStripping;
	BoneCompressionSettings->PopulateDDCKey(UE::Anim::Compression::FAnimDDCKeyArgs(*this, TargetPlatform), ArcToHexString.Ar);
	CurveCompressionSettings->PopulateDDCKey(ArcToHexString.Ar);
	VariableFrameStrippingSettings->PopulateDDCKey(UE::Anim::Compression::FAnimDDCKeyArgs(*this, TargetPlatform), ArcToHexString.Ar);
	
	const FFrameRate FrameRate = PlatformTargetFrameRate.GetValueForPlatform(TargetPlatform->GetPlatformInfo().IniPlatformName);

	FString Ret = FString::Printf(TEXT("%i_%s%s%s_%c%c%i_%s_%s_%i_%i_%s"),
		CompressCommandletVersion,

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimSequence.cpp:4603

Scope (from outer to inner):

file
function     FIoHash UAnimSequence::BeginCacheDerivedData

Source code excerpt:

	}
	
	if (CurveCompressionSettings == nullptr || !CurveCompressionSettings->AreSettingsValid())
	{
		CurveCompressionSettings = FAnimationUtils::GetDefaultAnimationCurveCompressionSettings();
	}
	if (VariableFrameStrippingSettings == nullptr)
	{
		VariableFrameStrippingSettings = FAnimationUtils::GetDefaultVariableFrameStrippingSettings();
	}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimStreamable.cpp:91

Scope (from outer to inner):

file
function     void FAnimStreamableChunk::Serialize

Source code excerpt:

				CompressedAnimSequence = new FCompressedAnimSequence();
			}
			CompressedAnimSequence->SerializeCompressedData(Ar, false, Owner, Owner->GetSkeleton(), Owner->BoneCompressionSettings, Owner->CurveCompressionSettings, false);
		}
		else
		{
			BulkData.SetBulkDataFlags(BULKDATA_Force_NOT_InlinePayload);

			if (Ar.IsSaving())

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimStreamable.cpp:106

Scope (from outer to inner):

file
function     void FAnimStreamableChunk::Serialize

Source code excerpt:

				FMemoryWriter TempAr(TempBytes, true);
				TempAr.SetFilterEditorOnly(Ar.IsFilterEditorOnly());
				CompressedAnimSequence->SerializeCompressedData(TempAr, false, Owner, Owner->GetSkeleton(), Owner->BoneCompressionSettings, Owner->CurveCompressionSettings, false);

				BulkData.Lock(LOCK_READ_WRITE);
				void* ChunkData = BulkData.Realloc(TempBytes.Num());
				FMemory::Memcpy(ChunkData, TempBytes.GetData(), TempBytes.Num());
				BulkData.Unlock();
			}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimStreamable.cpp:484

Scope (from outer to inner):

file
function     void UAnimStreamable::InitFrom

Source code excerpt:


	BoneCompressionSettings = InSourceSequence->BoneCompressionSettings;
	CurveCompressionSettings = InSourceSequence->CurveCompressionSettings;
	
	DataModelInterface = StaticDuplicateObject(InSourceSequence->GetDataModelInterface().GetObject(), this);
	VariableFrameStrippingSettings = InSourceSequence->VariableFrameStrippingSettings;

	// Far from ideal (retrieving controller to ensure it matches the DataModelInterface type)
	Controller = DataModelInterface->GetController();

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimStreamable.cpp:566

Scope (from outer to inner):

file
function     void UAnimStreamable::RequestCompressedData

Source code excerpt:

	}

	if (CurveCompressionSettings == nullptr || !CurveCompressionSettings->AreSettingsValid())
	{
		CurveCompressionSettings = FAnimationUtils::GetDefaultAnimationCurveCompressionSettings();
	}

	if (VariableFrameStrippingSettings == nullptr)
	{
		VariableFrameStrippingSettings = FAnimationUtils::GetDefaultVariableFrameStrippingSettings();
	}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimStreamable.cpp:695

Scope (from outer to inner):

file
function     void UAnimStreamable::RequestCompressedDataForChunk

Source code excerpt:

		else
		{
			FCompressibleAnimRef CompressibleData = MakeShared<FCompressibleAnimData, ESPMode::ThreadSafe>(BoneCompressionSettings, CurveCompressionSettings, GetSkeleton(), Interpolation, Chunk.SequenceLength, ChunkNumFrames+1, Platform);

			TArray<FName> TrackNames;
			DataModelInterface->GetBoneTrackNames(TrackNames);
			
			CompressibleData->TrackToSkeletonMapTable.Empty();

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimStreamable.cpp:774

Scope (from outer to inner):

file
function     void UAnimStreamable::RequestCompressedDataForChunk

Source code excerpt:

			Chunk.CompressedAnimSequence = new FCompressedAnimSequence();
		}
		Chunk.CompressedAnimSequence->SerializeCompressedData(MemAr, true, this, this->GetSkeleton(), BoneCompressionSettings, CurveCompressionSettings);
	}
}

void UAnimStreamable::UpdateRawData()
{
	if (IsDataModelValid())

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimStreamable.cpp:802

Scope (from outer to inner):

file
function     FString UAnimStreamable::GetBaseDDCKey

Source code excerpt:

	ArcToHexString.Ar << NumChunks;
	BoneCompressionSettings->PopulateDDCKey(UE::Anim::Compression::FAnimDDCKeyArgs(*this, TargetPlatform), ArcToHexString.Ar);
	CurveCompressionSettings->PopulateDDCKey(ArcToHexString.Ar);
	VariableFrameStrippingSettings->PopulateDDCKey(UE::Anim::Compression::FAnimDDCKeyArgs(*this, TargetPlatform), ArcToHexString.Ar);

	FString Ret = FString::Printf(TEXT("%s%s%s%s_%s"),
		StreamingAnimChunkVersion,
		*RawDataGuid.ToString(),
		*GetSkeleton()->GetGuid().ToString(),

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimationCompressionDerivedData.cpp:125

Scope (from outer to inner):

file
namespace    UE::Anim
function     void FAnimationSequenceAsyncCacheTask::EndCache
lambda-function

Source code excerpt:

					const FSharedBuffer RecordData = Value.GetData().Decompress();
					FMemoryReaderView Ar(RecordData, /*bIsPersistent*/ true);
					CompressedData->SerializeCompressedData(Ar, true, AnimSequence, AnimSequence->GetSkeleton(), CompressibleAnimPtr->BoneCompressionSettings, CompressibleAnimPtr->CurveCompressionSettings);

					if (!CompressedData->IsValid(AnimSequence, true))
					{
						UE_LOG(LogAnimationCompression, Warning, TEXT("Fetched invalid compressed animation data for %s"), *CompressibleAnimPtr->FullName);
						CompressedData->Reset();

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimationCompressionDerivedData.cpp:247

Scope (from outer to inner):

file
namespace    UE::Anim
function     void FAnimationSequenceAsyncCacheTask::LaunchCompressionTask
lambda-function

Source code excerpt:

					TArray64<uint8> RecordData;
					FMemoryWriter64 Ar(RecordData, /*bIsPersistent*/ true);
					CompressedData->SerializeCompressedData(Ar, true, nullptr, nullptr, CompressibleAnimPtr->BoneCompressionSettings, CompressibleAnimPtr->CurveCompressionSettings);
					UE_LOG(LogAnimationCompression, Display, TEXT("Storing compressed animation data for %s, at %s/%s"), *Name, *FString(Key.Bucket.ToString()), *LexToString(Key.Hash));
					UE::DerivedData::GetCache().PutValue({ {Name, Key, UE::DerivedData::FValue::Compress(MakeSharedBufferFromArray(MoveTemp(RecordData)))} }, Owner);

					COOK_STAT(Timer.AddMiss(int64(Ar.Tell())));
				}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimationStreaming.cpp:351

Scope (from outer to inner):

file
function     void FAnimationStreamingManager::OnAsyncFileCallback

Source code excerpt:


		UAnimStreamable* Anim = StreamingAnimData->StreamableAnim;
		NewCompressedData->SerializeCompressedData(Reader, false, Anim, Anim->GetSkeleton(), Anim->BoneCompressionSettings, Anim->CurveCompressionSettings);

		const float SequenceLength = StreamingAnimData->StreamableAnim->GetRunningPlatformData().Chunks[ChunkIndex].SequenceLength;
		if (SequenceLength < RequestDuration)
		{
			UE_LOG(LogAnimation, Warning, TEXT("Streaming anim loading slower than needed ChunkIndex %i - Length: %.3f Load Duration:%.3f Anim:%s\n"), ChunkIndex, SequenceLength, RequestDuration, *StreamingAnimData->StreamableAnim->GetName());
		}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimationUtils.cpp:969

Scope (from outer to inner):

file
function     UAnimCurveCompressionSettings* FAnimationUtils::GetDefaultAnimationCurveCompressionSettings

Source code excerpt:

	if (DefaultCurveCompressionSettings == nullptr)
	{
		DefaultCurveCompressionSettings = Cast<UAnimCurveCompressionSettings>(GetDefaultAnimationCompressionSettings(TEXT("CurveCompressionSettings"), false));

		if (DefaultCurveCompressionSettings == nullptr)
		{
			DefaultCurveCompressionSettings = Cast<UAnimCurveCompressionSettings>(GetDefaultAnimationCompressionSettings(TEXT("CurveCompressionSettingsFallback"), true));
		}
	}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimationUtils.cpp:995

Scope (from outer to inner):

file
function     void FAnimationUtils::EnsureAnimSequenceLoaded

Source code excerpt:

	EnsureDependenciesAreLoaded(AnimSeq.GetSkeleton());
	EnsureDependenciesAreLoaded(AnimSeq.BoneCompressionSettings);
	EnsureDependenciesAreLoaded(AnimSeq.CurveCompressionSettings);
	EnsureDependenciesAreLoaded(AnimSeq.RefPoseSeq);
	EnsureDependenciesAreLoaded(AnimSeq.VariableFrameStrippingSettings);
}

void FAnimationUtils::ExtractTransformForFrameFromTrackSafe(const FRawAnimSequenceTrack& RawTrack, int32 Frame, FTransform& OutAtom)
{

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/Animation/AnimationUtils.cpp:1144

Scope (from outer to inner):

file
function     bool FAnimationUtils::CompressAnimCurves

Source code excerpt:

	Target.ClearCompressedCurveData();

	if (AnimSeq.CurveCompressionSettings == nullptr || !AnimSeq.CurveCompressionSettings->AreSettingsValid())
	{
		return false;
	}

	return AnimSeq.CurveCompressionSettings->Compress(AnimSeq, Target);
}
#endif

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/Animation/AnimCompressionTypes.h:213

Scope: file

Source code excerpt:

	ENGINE_API FCompressibleAnimData& operator=(const FCompressibleAnimData&);

	TObjectPtr<UAnimCurveCompressionSettings> CurveCompressionSettings;

	TObjectPtr<UAnimBoneCompressionSettings> BoneCompressionSettings;

	// Data from USkeleton
	TArray<FTransform> RefLocalPoses;
	FReferenceSkeleton RefSkeleton;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/Animation/AnimCompressionTypes.h:315

Scope (from outer to inner):

file
function     void AddReferencedObjects

Source code excerpt:

	{
		Collector.AddReferencedObject(BoneCompressionSettings);
		Collector.AddReferencedObject(CurveCompressionSettings);
	}

	bool IsCancelled() const
	{
		return IsCancelledSignal.IsCancelled();
	}

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/Animation/AnimCompressionTypes.h:827

Scope: file

Source code excerpt:

	{}

	ENGINE_API void SerializeCompressedData(FArchive& Ar, bool bDDCData, UObject* DataOwner, USkeleton* Skeleton, UAnimBoneCompressionSettings* BoneCompressionSettings, UAnimCurveCompressionSettings* CurveCompressionSettings, bool bCanUseBulkData=true);

	ENGINE_API void RebuildCurveIndexTable();
	
	int32 GetSkeletonIndexFromTrackIndex(const int32 TrackIndex) const
	{
		return CompressedTrackToSkeletonMapTable[TrackIndex].BoneTreeIndex;