BoneCompressionSettings

BoneCompressionSettings

#Overview

name: BoneCompressionSettings

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 50 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of BoneCompressionSettings is to define the compression settings for bone animation data in Unreal Engine 5. This variable is part of the animation system and is used to control how bone animations are compressed to reduce memory usage and improve performance.

BoneCompressionSettings is primarily used by the animation system, specifically in the compression and decompression processes for animation sequences. It is also utilized by the Animation Compression Library (ACL) plugin for more advanced compression techniques.

The value of this variable is typically set in the UAnimSequence class, which represents an animation sequence in Unreal Engine. It can be set through the editor interface or programmatically.

BoneCompressionSettings often interacts with CurveCompressionSettings, which is used for compressing animation curve data. Together, these two settings control the overall compression of animation sequences.

Developers should be aware that changing BoneCompressionSettings can affect the quality and performance of animations. Improper settings may lead to visual artifacts or increased memory usage.

Best practices for using BoneCompressionSettings include:

  1. Using appropriate compression settings for different types of animations (e.g., more aggressive compression for background characters, less compression for main characters).
  2. Testing compressed animations thoroughly to ensure visual quality is maintained.
  3. Balancing between compression ratio and animation quality based on the project’s requirements.
  4. Considering platform-specific limitations when setting compression parameters.
  5. Regularly reviewing and updating compression settings as the project evolves to maintain optimal performance.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Config/BaseEngine.ini:3384, 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:135

Scope (from outer to inner):

file
function     void FACLPlugin::ListCodecs

Source code excerpt:

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

#Loc: <Workspace>/Engine/Plugins/Animation/ACLPlugin/Source/ACLPlugin/Private/AnimationCompressionLibraryDatabase.cpp:446

Scope (from outer to inner):

file
function     bool UAnimationCompressionLibraryDatabase::UpdateReferencingAnimSequenceList

Source code excerpt:

		}

		UAnimBoneCompressionSettings* Settings = AnimSeq->BoneCompressionSettings;
		if (Settings == nullptr || Settings->Codecs.Num() != 1)
		{
			continue;
		}

		UAnimBoneCompressionCodec_ACLDatabase* DatabaseCodec = Cast<UAnimBoneCompressionCodec_ACLDatabase>(Settings->Codecs[0]);

#Loc: <Workspace>/Engine/Plugins/Animation/ACLPlugin/Source/ACLPluginEditor/Private/ACLStatsDumpCommandlet.cpp:664

Scope (from outer to inner):

file
function     static void CompressWithUE4Auto

Source code excerpt:

	const uint64 UE4StartTimeCycles = FPlatformTime::Cycles64();

	Context.UE4Clip->BoneCompressionSettings = Context.AutoCompressor;
	Context.UE4Clip->CacheDerivedDataForCurrentPlatform();

	const uint64 UE4EndTimeCycles = FPlatformTime::Cycles64();

	const uint64 UE4ElapsedCycles = UE4EndTimeCycles - UE4StartTimeCycles;
	const double UE4ElapsedTimeSec = FPlatformTime::ToSeconds64(UE4ElapsedCycles);

#Loc: <Workspace>/Engine/Plugins/Animation/ACLPlugin/Source/ACLPluginEditor/Private/ACLStatsDumpCommandlet.cpp:694

Scope (from outer to inner):

file
function     static void CompressWithUE4Auto
lambda-function

Source code excerpt:

		Writer["ue4_auto"] = [&](sjson::ObjectWriter& Writer)	//-V1047
		{
			Writer["algorithm_name"] = TCHAR_TO_ANSI(*Context.UE4Clip->BoneCompressionSettings->GetClass()->GetName());
			Writer["codec_name"] = TCHAR_TO_ANSI(*GetCodecName(Context.UE4Clip->CompressedData.BoneCompressionCodec));
			Writer["compressed_size"] = CompressedSize;
			Writer["ue4_compression_ratio"] = UE4CompressionRatio;
			Writer["acl_compression_ratio"] = ACLCompressionRatio;
			Writer["compression_time"] = UE4ElapsedTimeSec;
			Writer["ue4_max_error"] = UE4ErrorStats.MaxError;

#Loc: <Workspace>/Engine/Plugins/Animation/ACLPlugin/Source/ACLPluginEditor/Private/ACLStatsDumpCommandlet.cpp:737

Scope (from outer to inner):

file
function     static void CompressWithACL

Source code excerpt:

	const uint64 ACLStartTimeCycles = FPlatformTime::Cycles64();

	Context.UE4Clip->BoneCompressionSettings = Context.ACLCompressor;
	Context.UE4Clip->CacheDerivedDataForCurrentPlatform();

	const uint64 ACLEndTimeCycles = FPlatformTime::Cycles64();

	const uint64 ACLElapsedCycles = ACLEndTimeCycles - ACLStartTimeCycles;
	const double ACLElapsedTimeSec = FPlatformTime::ToSeconds64(ACLElapsedCycles);

#Loc: <Workspace>/Engine/Plugins/Animation/ACLPlugin/Source/ACLPluginEditor/Private/ACLStatsDumpCommandlet.cpp:767

Scope (from outer to inner):

file
function     static void CompressWithACL
lambda-function

Source code excerpt:

		Writer["ue4_acl"] = [&](sjson::ObjectWriter& Writer)	//-V1047
		{
			Writer["algorithm_name"] = TCHAR_TO_ANSI(*Context.UE4Clip->BoneCompressionSettings->GetClass()->GetName());
			Writer["codec_name"] = TCHAR_TO_ANSI(*GetCodecName(Context.UE4Clip->CompressedData.BoneCompressionCodec));
			Writer["compressed_size"] = CompressedSize;
			Writer["ue4_compression_ratio"] = UE4CompressionRatio;
			Writer["acl_compression_ratio"] = ACLCompressionRatio;
			Writer["compression_time"] = ACLElapsedTimeSec;
			Writer["ue4_max_error"] = UE4ErrorStats.MaxError;

#Loc: <Workspace>/Engine/Plugins/Animation/ACLPlugin/Source/ACLPluginEditor/Private/ACLStatsDumpCommandlet.cpp:832

Scope (from outer to inner):

file
function     static void CompressWithUE4KeyReduction

Source code excerpt:

	const uint64 UE4StartTimeCycles = FPlatformTime::Cycles64();

	Context.UE4Clip->BoneCompressionSettings = Context.KeyReductionCompressor;
	Context.UE4Clip->CacheDerivedDataForCurrentPlatform();

	const uint64 UE4EndTimeCycles = FPlatformTime::Cycles64();

	const uint64 UE4ElapsedCycles = UE4EndTimeCycles - UE4StartTimeCycles;
	const double UE4ElapsedTimeSec = FPlatformTime::ToSeconds64(UE4ElapsedCycles);

#Loc: <Workspace>/Engine/Plugins/Animation/ACLPlugin/Source/ACLPluginEditor/Private/ACLStatsDumpCommandlet.cpp:862

Scope (from outer to inner):

file
function     static void CompressWithUE4KeyReduction
lambda-function

Source code excerpt:

		Writer["ue4_keyreduction"] = [&](sjson::ObjectWriter& Writer)	//-V1047
		{
			Writer["algorithm_name"] = TCHAR_TO_ANSI(*Context.UE4Clip->BoneCompressionSettings->GetClass()->GetName());
			Writer["codec_name"] = TCHAR_TO_ANSI(*GetCodecName(Context.UE4Clip->CompressedData.BoneCompressionCodec));
			Writer["compressed_size"] = CompressedSize;
			Writer["ue4_compression_ratio"] = UE4CompressionRatio;
			Writer["acl_compression_ratio"] = ACLCompressionRatio;
			Writer["compression_time"] = UE4ElapsedTimeSec;
			Writer["ue4_max_error"] = UE4ErrorStats.MaxError;

#Loc: <Workspace>/Engine/Source/Developer/AssetTools/Private/AssetTypeActions/AssetTypeActions_AnimBoneCompressionSettings.cpp:80

Scope (from outer to inner):

file
function     void FAssetTypeActions_AnimBoneCompressionSettings::ExecuteCompression

Source code excerpt:

		}

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

	if (AnimSeqsToRecompress.Num() == 0)

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

Scope (from outer to inner):

file
function     void UAnimationBlueprintLibrary::GetBoneCompressionSettings

Source code excerpt:

	}

	CompressionSettings = AnimationSequence->BoneCompressionSettings;
}

void UAnimationBlueprintLibrary::SetBoneCompressionSettings(UAnimSequence* AnimationSequence, UAnimBoneCompressionSettings* CompressionSettings)
{
	if (AnimationSequence == nullptr)
	{

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

Scope (from outer to inner):

file
function     void UAnimationBlueprintLibrary::SetBoneCompressionSettings

Source code excerpt:

	}

	AnimationSequence->BoneCompressionSettings = CompressionSettings;
}

void UAnimationBlueprintLibrary::GetCurveCompressionSettings(const UAnimSequence* AnimationSequence, UAnimCurveCompressionSettings*& CompressionSettings)
{
	if (AnimationSequence == nullptr)
	{

#Loc: <Workspace>/Engine/Source/Editor/Persona/Private/PersonaModule.cpp:660

Scope (from outer to inner):

file
function     void FPersonaModule::ApplyCompression

Source code excerpt:

		if (AnimSequences.Num() != 0)
		{
			CurrentSettings = AnimSequences[0]->BoneCompressionSettings;
			for (TWeakObjectPtr<UAnimSequence>& AnimSeq : AnimSequences)
			{
				if (CurrentSettings != AnimSeq->BoneCompressionSettings)
				{
					// One of the sequences in the list has a different settings asset, use the default behavior
					CurrentSettings = nullptr;
					break;
				}
			}

#Loc: <Workspace>/Engine/Source/Editor/SequenceRecorder/Private/AnimationRecorder.cpp:91

Scope (from outer to inner):

file
function     bool FAnimationRecorder::SetAnimCompressionScheme

Source code excerpt:

		}

		AnimationObject->BoneCompressionSettings = Settings;
		return true;
	}

	return false;
}

#Loc: <Workspace>/Engine/Source/Editor/SequenceRecorder/Private/AnimationRecorder.cpp:241

Scope (from outer to inner):

file
function     void FAnimationRecorder::StartRecord

Source code excerpt:

	AnimationObject = InAnimationObject;

	if (!AnimationObject->BoneCompressionSettings)
	{
		AnimationObject->BoneCompressionSettings = FAnimationUtils::GetDefaultAnimationRecorderBoneCompressionSettings();
	}

	FAnimationRecorder::GetBoneTransforms(Component, PreviousSpacesBases);
	PreviousAnimCurves = Component->GetAnimationCurves();
	PreviousComponentToWorld = Component->GetComponentTransform();

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/AnimationEditorUtils.cpp:825

Scope (from outer to inner):

file
namespace    AnimationEditorUtils
function     bool ApplyCompressionAlgorithm

Source code excerpt:

					if (OverrideSettings != nullptr)
					{
						AnimSeq->BoneCompressionSettings = OverrideSettings;
					}

					// Clear CompressCommandletVersion so we can recompress these animations later.
					AnimSeq->CompressCommandletVersion = 0;
					AnimSeq->ClearAllCachedCookedPlatformData();
					AnimSeq->CacheDerivedDataForCurrentPlatform();

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

Scope (from outer to inner):

file
function     void DoIt

Source code excerpt:

			// Do not perform recompression on animations marked as 'bDoNotOverrideCompression'
			// Unless they have no compression scheme.
			if (AnimSeq->bDoNotOverrideCompression && AnimSeq->BoneCompressionSettings != nullptr)
			{
				continue;
			}

			UE_LOG(LogPackageUtilities, Warning, TEXT("Compressing animation '%s' [#%d / %d in package '%s']"),
				*AnimSeq->GetName(),

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

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())
			{

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

Scope (from outer to inner):

file
class        class UAnimSequence : public UAnimSequenceBase

Source code excerpt:

	/** The bone compression settings used to compress bones in this sequence. */
	UPROPERTY(Category = Compression, EditAnywhere, meta = (ForceShowEngineContent))
	TObjectPtr<class UAnimBoneCompressionSettings> BoneCompressionSettings;

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

	FCompressedAnimSequence CompressedData;

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

Scope (from outer to inner):

file
class        class UAnimStreamable : public UAnimSequenceBase

Source code excerpt:

	/** The bone compression settings used to compress bones in this sequence. */
	UPROPERTY(Category = Compression, EditAnywhere)
	TObjectPtr<class UAnimBoneCompressionSettings> BoneCompressionSettings;

	/** 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*/

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

Scope (from outer to inner):

file
function     bool FDerivedDataAnimationCompression::Build

Source code excerpt:


#if DO_CHECK
		FString CompressionName = DataToCompress.BoneCompressionSettings->GetFullName();
		
		ensureMsgf(bCompressionSuccessful, TEXT("Anim Compression failed for Sequence '%s' with compression scheme '%s': compressed data empty\n\tAnimIndex: %i\n\tMaxAnim:%i"), 
											*DataToCompress.FullName,
											*CompressionName,
											PRAGMA_DISABLE_DEPRECATION_WARNINGS
											CompressContext.Get()->AnimIndex,

#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:764

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
	, ErrorThresholdScale(InSeq->CompressionErrorThresholdScale)

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

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
	, NumberOfKeys(InNumberOfKeys)

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

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
, NumberOfKeys(0)

#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:1370

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);

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

Scope (from outer to inner):

file
function     FString GetAnimSequenceSpecificCacheKeySuffix

Source code excerpt:

	ArcToHexString.Ar << CompressionErrorThresholdScale;
	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

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

Scope (from outer to inner):

file
function     void UAnimSequence::GetPreloadDependencies

Source code excerpt:

	}

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

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

Scope (from outer to inner):

file
function     void UAnimSequence::PostEditChangeProperty

Source code excerpt:

		bCompressionAffectingSettingsChanged =   PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(UAnimSequence, bAllowFrameStripping)
											  || 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;
	}

#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:4547

Scope (from outer to inner):

file
function     FIoHash UAnimSequence::CreateDerivedDataKeyHash

Source code excerpt:

	ArcToHexString.Ar << CompressionErrorThresholdScale;
	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"),

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

Scope (from outer to inner):

file
function     FIoHash UAnimSequence::BeginCacheDerivedData

Source code excerpt:


	// Ensure that there are valid compression settings
	if (BoneCompressionSettings == nullptr || !BoneCompressionSettings->AreSettingsValid())
	{
		BoneCompressionSettings = FAnimationUtils::GetDefaultAnimationBoneCompressionSettings();
	}
	
	if (CurveCompressionSettings == nullptr || !CurveCompressionSettings->AreSettingsValid())
	{
		CurveCompressionSettings = FAnimationUtils::GetDefaultAnimationCurveCompressionSettings();
	}

#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:483

Scope (from outer to inner):

file
function     void UAnimStreamable::InitFrom

Source code excerpt:

	SourceSequence = InSourceSequence;

	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)

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

Scope (from outer to inner):

file
function     void UAnimStreamable::RequestCompressedData

Source code excerpt:

	}

	if (BoneCompressionSettings == nullptr || !BoneCompressionSettings->AreSettingsValid())
	{
		BoneCompressionSettings = FAnimationUtils::GetDefaultAnimationBoneCompressionSettings();
	}

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

#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:801

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(),

#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:203

Scope (from outer to inner):

file
namespace    UE::Anim
function     bool FAnimationSequenceAsyncCacheTask::BuildData

Source code excerpt:

				
	const bool bCompressionSuccessful = bBoneCompressionOk && bCurveCompressionOk;
	const FString CompressionName = DataToCompress.BoneCompressionSettings->GetFullName();
	
	if (bCompressionSuccessful && !Owner.IsCanceled())
	{
		OutData.CompressedByteStream = MoveTemp(CompressionResult.CompressedByteStream);
		OutData.CompressedDataStructure = MoveTemp(CompressionResult.AnimData);
		OutData.BoneCompressionCodec = CompressionResult.Codec;

#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/AnimationCompressionDerivedData.cpp:286

Scope (from outer to inner):

file
namespace    UE::Anim
function     int64 FAnimationSequenceAsyncCacheTask::GetRequiredMemoryEstimate

Source code excerpt:

		}

		if (const UAnimBoneCompressionSettings* BoneCompressionSettings = AnimSequence->BoneCompressionSettings.Get())
		{
			// We try out all compression codecs in parallel to find the best one, so we need to sum up the cost for every codec.
			for (TObjectPtr<UAnimBoneCompressionCodec> Codec : BoneCompressionSettings->Codecs)
			{
				if (Codec)
				{
					const int64 PeakMemoryEstimate = Codec->EstimateCompressionMemoryUsage(*AnimSequence);
					if (PeakMemoryEstimate < 0)
					{

#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:944

Scope (from outer to inner):

file
function     UAnimBoneCompressionSettings* FAnimationUtils::GetDefaultAnimationBoneCompressionSettings

Source code excerpt:

	if (DefaultBoneCompressionSettings == nullptr)
	{
		DefaultBoneCompressionSettings = Cast<UAnimBoneCompressionSettings>(GetDefaultAnimationCompressionSettings(TEXT("BoneCompressionSettings"), false));

		if (DefaultBoneCompressionSettings == nullptr)
		{
			DefaultBoneCompressionSettings = Cast<UAnimBoneCompressionSettings>(GetDefaultAnimationCompressionSettings(TEXT("BoneCompressionSettingsFallback"), true));
		}
	}

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

Scope (from outer to inner):

file
function     void FAnimationUtils::EnsureAnimSequenceLoaded

Source code excerpt:

	EnsureDependenciesAreLoaded(&AnimSeq);
	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:1131

Scope (from outer to inner):

file
function     bool FAnimationUtils::CompressAnimBones

Source code excerpt:

	Target = FCompressibleAnimDataResult();

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

	return AnimSeq.BoneCompressionSettings->Compress(AnimSeq, Target);
}

bool FAnimationUtils::CompressAnimCurves(FCompressibleAnimData& AnimSeq, FCompressedAnimSequence& Target)
{
	// Clear any previous data we might have even if we end up failing to compress
	Target.ClearCompressedCurveData();

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

Scope: file

Source code excerpt:

	TObjectPtr<UAnimCurveCompressionSettings> CurveCompressionSettings;

	TObjectPtr<UAnimBoneCompressionSettings> BoneCompressionSettings;

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

	TArray<FTrackToSkeletonMap> TrackToSkeletonMapTable;

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

Scope (from outer to inner):

file
function     void AddReferencedObjects

Source code excerpt:

	void AddReferencedObjects(FReferenceCollector& Collector)
	{
		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;