ComponentInstanceDataCache.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Templates/SubclassOf.h"
#include "UObject/Object.h"
#include "UObject/StructOnScope.h"
#include "Engine/EngineTypes.h"
#include "ComponentInstanceDataCache.generated.h"
 
class AActor;
class UActorComponent;
class USceneComponent;
enum class EComponentCreationMethod : uint8;
 
enum class ECacheApplyPhase
{
    PostSimpleConstructionScript,   // After the simple construction script has been run
    PostUserConstructionScript,     // After the user construction script has been run
    NonConstructionScript           // Not called during the construction script process
};
 
UENUM()
enum class EComponentCreationMethod : uint8
{
    Native,
    SimpleConstructionScript,
    UserConstructionScript,
    Instance,
};
 
UE_DEPRECATED(5.1, "FActorComponentDuplicatedObjectData has been renamed to FDataCacheDuplicatedObjectData")
typedef FDataCacheDuplicatedObjectData FActorComponentDuplicatedObjectData;
 
USTRUCT()
struct FDataCacheDuplicatedObjectData
{
    GENERATED_BODY()
 
    FDataCacheDuplicatedObjectData(UObject* InObject = nullptr);
 
    bool Serialize(FArchive& Ar);
 
    // The duplicated object
    UObject* DuplicatedObject;
 
    // Object Outer Depth so we can sort creation order
    int32 ObjectPathDepth;
};
 
// Trait to signal ActorCompomentInstanceData duplicated objects uses a serialize function
template<>
struct TStructOpsTypeTraits<FDataCacheDuplicatedObjectData> : public TStructOpsTypeTraitsBase2<FDataCacheDuplicatedObjectData>
{
    enum
    {
        WithSerializer = true,
    };
};
 
USTRUCT()
struct FInstanceCacheDataBase
{
    GENERATED_BODY()
 
    ENGINE_API virtual ~FInstanceCacheDataBase();
 
    ENGINE_API virtual void AddReferencedObjects(FReferenceCollector& Collector);
 
    UE_DEPRECATED(5.3, "Use GetUniqueTransientObject instead")
    UObject* GetUniqueTransientPackage() { return GetUniqueTransientObject(UObject::StaticClass()); }
 
    ENGINE_API UObject* GetUniqueTransientObject(UClass* Class);
 
    const TArray<FDataCacheDuplicatedObjectData>& GetDuplicatedObjects() const { return DuplicatedObjects; }
    const TArray<TObjectPtr<UObject>>& GetReferencedObjects() const { return ReferencedObjects; }
    const TArray<uint8>& GetSavedProperties() const { return SavedProperties; }
 
protected:
    UPROPERTY()
    TArray<uint8> SavedProperties;
 
private:
    friend class FDataCachePropertyWriter;
    friend class FDataCachePropertyReader;
 
    UPROPERTY()
    FDataCacheDuplicatedObjectData UniqueTransientPackage;
 
    // Duplicated objects created when saving instance properties
    UPROPERTY()
    TArray<FDataCacheDuplicatedObjectData> DuplicatedObjects;
 
    // Referenced objects in instance saved properties
    UPROPERTY()
    TArray<TObjectPtr<UObject>> ReferencedObjects;
 
    // Referenced names in instance saved properties
    UPROPERTY()
    TArray<FName> ReferencedNames;
};
 
USTRUCT()
struct FActorComponentInstanceSourceInfo
{
    GENERATED_BODY()
 
public:
    FActorComponentInstanceSourceInfo() = default;
    ENGINE_API explicit FActorComponentInstanceSourceInfo(const UActorComponent* SourceComponent);
    ENGINE_API FActorComponentInstanceSourceInfo(TObjectPtr<const UObject> InSourceComponentTemplate, EComponentCreationMethod InSourceComponentCreationMethod, int32 InSourceComponentTypeSerializedIndex);
 
    ENGINE_API bool MatchesComponent(const UActorComponent* Component) const;
    ENGINE_API bool MatchesComponent(const UActorComponent* Component, const UObject* ComponentTemplate) const;
 
    ENGINE_API void AddReferencedObjects(FReferenceCollector& Collector);
 
private:
    UPROPERTY()
    TObjectPtr<const UObject> SourceComponentTemplate = nullptr;
 
    UPROPERTY()
    EComponentCreationMethod SourceComponentCreationMethod = EComponentCreationMethod::Native;
 
    UPROPERTY()
    int32 SourceComponentTypeSerializedIndex = INDEX_NONE;
};
 
USTRUCT()
struct FActorComponentInstanceData : public FInstanceCacheDataBase
{
    GENERATED_BODY()
public:
    ENGINE_API FActorComponentInstanceData();
    ENGINE_API FActorComponentInstanceData(const UActorComponent* SourceComponent);
 
    ENGINE_API bool MatchesComponent(const UActorComponent* Component, const UObject* ComponentTemplate) const;
 
    virtual bool ContainsData() const { return SavedProperties.Num() > 0; }
 
    ENGINE_API virtual void ApplyToComponent(UActorComponent* Component, const ECacheApplyPhase CacheApplyPhase);
 
    virtual void FindAndReplaceInstances(const TMap<UObject*, UObject*>& OldToNewInstanceMap) { };
 
    ENGINE_API virtual void AddReferencedObjects(FReferenceCollector& Collector) override;
 
    const UClass* GetComponentClass() const { return SourceComponentTemplate ? SourceComponentTemplate->GetClass() : nullptr; }
 
    const UObject* GetComponentTemplate() const { return SourceComponentTemplate; }
 
protected:
 
    UPROPERTY()
    TObjectPtr<const UObject> SourceComponentTemplate;
 
    UPROPERTY() 
    EComponentCreationMethod SourceComponentCreationMethod;
 
    UPROPERTY()
    int32 SourceComponentTypeSerializedIndex;
};
 
USTRUCT()
struct FActorInstanceData : public FInstanceCacheDataBase
{
    GENERATED_BODY()
public:
    FActorInstanceData() = default;
    ENGINE_API FActorInstanceData(const AActor* SourceActor);
 
    ENGINE_API const UClass* GetActorClass() const;
 
    bool HasInstanceData() const { return GetSavedProperties().Num() > 0; }
 
    ENGINE_API void ApplyToActor(AActor* Actor, const ECacheApplyPhase CacheApplyPhase);
 
protected:
 
    UPROPERTY()
    TSubclassOf<AActor> ActorClass;
};
 
class FComponentInstanceDataCache
{
public:
 
    FComponentInstanceDataCache() = default;
 
    ENGINE_API FComponentInstanceDataCache(const AActor* InActor);
 
    ~FComponentInstanceDataCache() = default;
 
    FComponentInstanceDataCache(const FComponentInstanceDataCache&) = delete;
    FComponentInstanceDataCache& operator=(const FComponentInstanceDataCache&) = delete;
 
    FComponentInstanceDataCache(FComponentInstanceDataCache&&) = default;
    FComponentInstanceDataCache& operator=(FComponentInstanceDataCache&&) = default;
 
    ENGINE_API void Serialize(FArchive& Ar);
 
    ENGINE_API void ApplyToActor(AActor* Actor, const ECacheApplyPhase CacheApplyPhase) const;
 
    ENGINE_API void FindAndReplaceInstances(const TMap<UObject*, UObject*>& OldToNewInstanceMap);
 
    bool HasInstanceData() const { return ComponentsInstanceData.Num() > 0; }
 
    ENGINE_API void AddReferencedObjects(FReferenceCollector& Collector);
 
    static ENGINE_API void GetComponentHierarchy(const AActor* Actor, TArray<UActorComponent*, TInlineAllocator<NumInlinedActorComponents>>& OutComponentHierarchy);
 
private:
    // called during de-serialization to copy serialized properties over existing component instance data and keep non UPROPERTY data intact
    ENGINE_API void CopySerializableProperties(TArray<TStructOnScope<FActorComponentInstanceData>> InComponentsInstanceData);
 
    TArray<TStructOnScope<FActorComponentInstanceData>> ComponentsInstanceData;
 
    TMap< TObjectPtr<USceneComponent>, FTransform > InstanceComponentTransformToRootMap;
};