AnimationStreaming.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
AnimationStreaming.h: Definitions of classes used for animation streaming.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "HAL/ThreadSafeCounter.h"
#include "Containers/IndirectArray.h"
#include "Containers/Queue.h"
#include "Stats/Stats.h"
#include "ContentStreaming.h"
#include "Async/AsyncWork.h"
#include "Async/AsyncFileHandle.h"
#include "Templates/Atomic.h"
class UAnimStreamable;
struct FAnimationStreamingManager;
 
// 
struct FLoadedAnimationChunk
{
    TAtomic<FCompressedAnimSequence*> CompressedAnimData;
 
    class IBulkDataIORequest* IORequest;
    double RequestStart;
 
    uint32  Index;
    bool    bOwnsCompressedData;
 
    FLoadedAnimationChunk()
        : CompressedAnimData(nullptr)
        , IORequest(nullptr)
        , RequestStart(-1.0)
        , Index(0)
        , bOwnsCompressedData(false)
    {
    }
 
    ~FLoadedAnimationChunk()
    {
        checkf(CompressedAnimData == nullptr, TEXT("Animation chunk compressed data ptr not null (%p), Index: %u"), CompressedAnimData.Load(), Index);
    }
 
    void CleanUpIORequest();
};
 
struct FStreamingAnimationData final
{
    FStreamingAnimationData();
    ~FStreamingAnimationData();
 
    // Frees streaming animation data resources, blocks pending async IO requests
    void FreeResources();
 
    bool Initialize(UAnimStreamable* InStreamableAnim, FAnimationStreamingManager* InAnimationStreamingManager);
 
    bool UpdateStreamingStatus();
 
    bool HasPendingRequests(TArray<uint32>& IndicesToLoad, TArray<uint32>& IndicesToFree) const;
 
    void BeginPendingRequests(const TArray<uint32>& IndicesToLoad, const TArray<uint32>& IndicesToFree);
 
    bool BlockTillAllRequestsFinished(float TimeLimit = 0.0f);
 
    // Return the number of bytes used
    SIZE_T GetMemorySize() const;
 
private:
    // Don't allow copy construction as it could free shared memory
    FStreamingAnimationData(const FStreamingAnimationData& that);
    FStreamingAnimationData& operator=(FStreamingAnimationData const&);
 
    // Creates a new chunk, returns the chunk index
    FLoadedAnimationChunk& AddNewLoadedChunk(uint32 ChunkIndex, FCompressedAnimSequence* ExistingData);
    void FreeLoadedChunk(FLoadedAnimationChunk& LoadedChunk);
    void ResetRequestedChunks();
 
public:
    UAnimStreamable* StreamableAnim;
 
    /* Contains pointers to Chunks of animation data that have been streamed in */
    TArray<FLoadedAnimationChunk> LoadedChunks;
 
    mutable FCriticalSection LoadedChunksCritcalSection;
 
    TArray<uint32>  LoadedChunkIndices;
 
    TArray<uint32> RequestedChunks;
 
    TArray<uint32> LoadFailedChunks;
 
    FAnimationStreamingManager* AnimationStreamingManager;
};
 
 
struct FAnimationStreamingManager : public IAnimationStreamingManager
{
    FAnimationStreamingManager();
 
    virtual ~FAnimationStreamingManager();
 
    // IStreamingManager interface
    virtual void UpdateResourceStreaming( float DeltaTime, bool bProcessEverything=false ) override;
    virtual int32 BlockTillAllRequestsFinished( float TimeLimit = 0.0f, bool bLogResults = false ) override;
    virtual void CancelForcedResources() override;
    virtual void NotifyLevelChange() override;
    virtual void SetDisregardWorldResourcesForFrames( int32 NumFrames ) override;
    virtual void AddLevel( class ULevel* Level ) override;
    virtual void RemoveLevel( class ULevel* Level ) override;
    virtual void NotifyLevelOffset( class ULevel* Level, const FVector& Offset ) override;
    // End IStreamingManager interface
 
    // IAnimationStreamingManager interface
    virtual void AddStreamingAnim(UAnimStreamable* Anim) override;
    virtual bool RemoveStreamingAnim(UAnimStreamable* Anim) override;
    virtual SIZE_T GetMemorySizeForAnim(const UAnimStreamable* Anim) override;
    virtual const FCompressedAnimSequence* GetLoadedChunk(const UAnimStreamable* Anim, uint32 ChunkIndex, bool bTrackAsRequested) const override;
    // End IAnimationStreamingManager interface
 
    void OnAsyncFileCallback(FStreamingAnimationData* StreamingAnimData, int32 ChunkIndex, int64 ReadSize, IBulkDataIORequest* ReadRequest, bool bWasCancelled);
 
protected:
 
    TMap<UAnimStreamable*, FStreamingAnimationData*> StreamingAnimations;
 
    mutable FCriticalSection CriticalSection;
};