AnimStreamable.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Misc/Guid.h"
#include "Serialization/BulkData.h"
#include "Animation/AnimTypes.h"
#include "Animation/AnimCompress.h"
#include "Animation/AnimCompressionTypes.h"
#include "Animation/AnimSequenceBase.h"
#include "AnimStreamable.generated.h"
 
class UAnimSequence;
class UAnimCompress;
struct FCompactPose;
 
class FAnimStreamableChunk
{
public:
    FAnimStreamableChunk() : StartTime(0.f), SequenceLength(0.f), CompressedAnimSequence(nullptr) {}
    ~FAnimStreamableChunk()
    {
        if (CompressedAnimSequence)
        {
            delete CompressedAnimSequence;
            CompressedAnimSequence = nullptr;
        }
    }
 
    float StartTime;
 
    float SequenceLength;
    int32 NumFrames;
 
    // Compressed Data for this chunk (if nullptr then data needs to be loaded via BulkData)
    FCompressedAnimSequence* CompressedAnimSequence;
 
    // Bulk data if stored in the package.
    FByteBulkData BulkData;
 
    SIZE_T GetMemorySize() const
    {
        static const SIZE_T ClassSize = sizeof(FAnimStreamableChunk);
        SIZE_T CurrentSize = ClassSize;
 
        if (CompressedAnimSequence)
        {
            CurrentSize += CompressedAnimSequence->GetMemorySize();
        }
        return CurrentSize;
    }
 
    void Serialize(FArchive& Ar, UAnimStreamable* Owner, int32 ChunkIndex);
};
 
class FStreamableAnimPlatformData
{
public:
    TArray<FAnimStreamableChunk> Chunks;
 
    void Serialize(FArchive& Ar, class UAnimStreamable* Owner);
 
    void Reset()
    {
        Chunks.Reset();
    }
 
    SIZE_T GetMemorySize() const
    {
        SIZE_T ChunkSize = 0;
        for (const FAnimStreamableChunk& Chunk : Chunks)
        {
            ChunkSize += Chunk.GetMemorySize();
        }
        return sizeof(FStreamableAnimPlatformData) + ChunkSize;
    }
};
 
 
UCLASS(config=Engine, hidecategories=UObject, MinimalAPI, BlueprintType)
class UAnimStreamable : public UAnimSequenceBase
{
    GENERATED_UCLASS_BODY()
 
public:
    UPROPERTY(AssetRegistrySearchable)
    int32 NumberOfKeys;
 
    UPROPERTY(EditAnywhere, AssetRegistrySearchable, Category = Animation)
    EAnimInterpolationType Interpolation;
 
    UPROPERTY(EditAnywhere, AssetRegistrySearchable, Category = Animation)
    FName RetargetSource;
 
    UPROPERTY()
    FFrameRate SamplingFrameRate;
 
#if WITH_EDITORONLY_DATA
 
    // Sequence the streamable was created from (used for reflecting changes to the source in editor)
    UPROPERTY()
    TObjectPtr<const UAnimSequence> SourceSequence;
 
    UPROPERTY()
    FGuid RawDataGuid;
 
    UE_DEPRECATED(5.0, "Num Frames is deprecated use NumberOfKeys instead")
    UPROPERTY()
    int32 NumFrames;
 
    UPROPERTY()
    TArray<struct FRawAnimSequenceTrack> RawAnimationData;
 
    UPROPERTY()
    TArray<struct FTrackToSkeletonMap> TrackToSkeletonMapTable;
 
    UPROPERTY()
    TArray<FName> AnimationTrackNames;
 
    // Editor can have multiple platforms loaded at once
    TMap<const ITargetPlatform*, FStreamableAnimPlatformData*> StreamableAnimPlatformData;
 
    FStreamableAnimPlatformData* RunningAnimPlatformData;
#else
 
    // Non editor only has one set of platform data
    FStreamableAnimPlatformData RunningAnimPlatformData;
#endif
 
    bool HasRunningPlatformData() const
    {
#if WITH_EDITOR
        return RunningAnimPlatformData != nullptr;
#else
        return true;
#endif
    }
 
    FStreamableAnimPlatformData& GetRunningPlatformData()
    {
#if WITH_EDITOR
        check(RunningAnimPlatformData);
        return *RunningAnimPlatformData;
#else
        return RunningAnimPlatformData;
#endif
    }
 
    const FStreamableAnimPlatformData& GetRunningPlatformData() const
    {
#if WITH_EDITOR
        check(RunningAnimPlatformData);
        return *RunningAnimPlatformData;
#else
        return RunningAnimPlatformData;
#endif
    }
 
    UPROPERTY(Category = Compression, EditAnywhere)
    TObjectPtr<class UAnimBoneCompressionSettings> BoneCompressionSettings;
 
    UPROPERTY(Category = Compression, EditAnywhere)
    TObjectPtr<class UAnimCurveCompressionSettings> CurveCompressionSettings;
 
    UPROPERTY(Category = Compression, EditAnywhere)
    TObjectPtr<class UVariableFrameStrippingSettings> VariableFrameStrippingSettings;
 
    UPROPERTY(EditAnywhere, AssetRegistrySearchable, Category = RootMotion, meta = (DisplayName = "EnableRootMotion"))
    bool bEnableRootMotion;
 
    UPROPERTY(EditAnywhere, Category = RootMotion)
    TEnumAsByte<ERootMotionRootLock::Type> RootMotionRootLock;
 
    UPROPERTY(EditAnywhere, Category = RootMotion)
    bool bForceRootLock;
 
    UPROPERTY(EditAnywhere, AssetRegistrySearchable, Category = RootMotion, meta = (DisplayName = "Use Normalized Root Motion Scale"))
    bool bUseNormalizedRootMotionScale;
 
    //~ Begin UObject Interface
    virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
    virtual void Serialize(FArchive& Ar) override;
    virtual void PostLoad() override;
    virtual void FinishDestroy() override;
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    //~ End UObject Interface
 
    //~ Begin UAnimSequenceBase Interface
    ENGINE_API virtual void HandleAssetPlayerTickedInternal(FAnimAssetTickContext &Context, const float PreviousTime, const float MoveDelta, const FAnimTickRecord &Instance, struct FAnimNotifyQueue& NotifyQueue) const override;
    virtual void GetAnimationPose(FAnimationPoseData& OutAnimationPoseData, const FAnimExtractContext& ExtractionContext) const override;
    virtual int32 GetNumberOfSampledKeys() const override { return NumberOfKeys; }
    //~ End UAnimSequenceBase Interface
 
#if WITH_EDITOR
    ENGINE_API void InitFrom(const UAnimSequence* InSourceSequence);
#endif
 
    ENGINE_API FStreamableAnimPlatformData& GetStreamingAnimPlatformData(const ITargetPlatform* Platform);
 
    ENGINE_API float GetChunkSizeSeconds(const ITargetPlatform* Platform) const;
 
    private:
 
#if WITH_EDITOR
    ENGINE_API void RequestCompressedData(const  ITargetPlatform* Platform=nullptr);
 
    void UpdateRawData();
 
    FString GetBaseDDCKey(uint32 NumChunks, const ITargetPlatform* TargetPlatform) const;
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    void RequestCompressedDataForChunk(const FString& ChunkDDCKey, FAnimStreamableChunk& Chunk, const int32 ChunkIndex, const uint32 FrameStart, const uint32 FrameEnd, TSharedRef<FAnimCompressContext> CompressContext, const ITargetPlatform* TargetPlatform);
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
#endif
 
    bool bUseRawDataOnly;
    int32 GetChunkIndexForTime(const TArray<FAnimStreamableChunk>& Chunks, const float CurrentTime) const;
};