RuntimeAssetCacheBuilders.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Containers/UnrealString.h"
#include "Delegates/Delegate.h"
#include "UObject/ScriptMacros.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "UObject/Stack.h"
#include "RuntimeAssetCacheInterface.h"
#include "RuntimeAssetCachePluginInterface.h"
#include "RuntimeAssetCacheBuilders.generated.h"
 
class FArchive;
class UTexture2D;
 
DECLARE_DYNAMIC_DELEGATE_TwoParams(FOnAssetCacheComplete, URuntimeAssetCacheBuilder_ObjectBase*, CachedAssetBuilder, bool, Success);
 
class UTexture2D;
 
UCLASS(BlueprintType)
class RUNTIMEASSETCACHE_API URuntimeAssetCacheBuilder_ObjectBase : public UObject, public IRuntimeAssetCacheBuilder
{
    GENERATED_BODY()
public:
    virtual void PostInitProperties() override
    {
        Super::PostInitProperties();
        CacheHandle = 0;
        bProcessedCacheMiss = false;
    }
 
    virtual const TCHAR* GetBucketConfigName() const override
    {
        return TEXT("DefaultBucket");
    }
 
    virtual const TCHAR* GetBuilderName() const override
    {
        return TEXT("UObject");
    }
 
    virtual FString GetAssetUniqueName() const override
    {
        return AssetName;
    }
 
    virtual bool IsBuildThreadSafe() const
    {
        return true;
    }
 
    virtual bool ShouldBuildAsynchronously() const override
    {
        return true;
    }
 
    virtual int32 GetAssetVersion() override
    {
        return AssetVersion;
    }
 
    virtual void SerializeAsset(FArchive& Ar)
    {
    }
 
    virtual int64 GetSerializedDataSizeEstimate()
    {
        return 1024;
    }
 
    FVoidPtrParam Build() override;
 
    UFUNCTION(BlueprintCallable, Category = RuntimeAssetCache)
    void GetFromCacheAsync(const FOnAssetCacheComplete& OnComplete);
 
    UFUNCTION()
    void GetFromCacheAsyncComplete(int32 Handle, FVoidPtrParam DataPtr);
 
    virtual void OnAssetPreLoad() {}
 
    virtual void OnAssetPostLoad() {}
 
    UFUNCTION(BlueprintNativeEvent, Category = RuntimeAssetCache)
    void OnAssetCacheMiss();
    virtual void OnAssetCacheMiss_Implementation()
    {
        //
        // Override and create the new asset here (this is where we would render to a render target, then get the result)
        //
 
        // Make sure the new asset gets properly cached for next time.
        SaveNewAssetToCache(Asset);
    }
 
    UFUNCTION(BlueprintCallable, Category = RuntimeAssetCache)
    void SaveNewAssetToCache(UObject* NewAsset);
 
    void SetAsset(UObject* NewAsset);
 
    virtual void OnSetAsset(UObject* NewAsset)
    {
        // Example:
        // Texture = Cast<UTexture2D>(NewAsset);
    }
 
    virtual void Cleanup()
    {
        CacheHandle = 0;
        bProcessedCacheMiss = false;
        Asset = nullptr;
    }
 
public:
    UPROPERTY(BlueprintReadWrite, Category = RuntimeAssetCache, meta = (ExposeOnSpawn = "true"))
    int32 AssetVersion;
 
    UPROPERTY(BlueprintReadWrite, Category = RuntimeAssetCache, meta = (ExposeOnSpawn = "true"))
    FString AssetName;
 
    int32 CacheHandle;
 
private:
    UObject* Asset;
    int32 bProcessedCacheMiss : 1;
    FOnRuntimeAssetCacheAsyncComplete GetFromCacheAsyncCompleteDelegate;
    FOnAssetCacheComplete OnAssetCacheComplete;
};
 
UCLASS(BlueprintType)
class UExampleTextureCacheBuilder : public URuntimeAssetCacheBuilder_ObjectBase
{
    GENERATED_BODY()
public:
 
    virtual void OnSetAsset(UObject* NewAsset);
 
    virtual void OnAssetCacheMiss_Implementation() override;
 
    virtual void SerializeAsset(FArchive& Ar) override;
 
    virtual void OnAssetPreLoad() override;
 
    virtual void OnAssetPostLoad() override;
 
    virtual int64 GetSerializedDataSizeEstimate() override;
 
    UPROPERTY(BlueprintReadOnly, Category = "Cache")
    TObjectPtr<UTexture2D> Texture;
};