ActorComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/Object.h"
#include "Templates/SubclassOf.h"
#include "Engine/EngineTypes.h"
#include "Engine/EngineBaseTypes.h"
#include "UObject/CoreNetTypes.h"
#include "UObject/ScriptMacros.h"
#include "Interfaces/Interface_AssetUserData.h"
#include "UObject/StructOnScope.h"
#include "PhysicsInterfaceDeclaresCore.h"
#include "PropertyPairsMap.h"
#include "ComponentInstanceDataCache.h"
#include "Experimental/ConcurrentLinearAllocator.h"
#include "Misc/ScopeRWLock.h"
#include "Misc/Timeout.h"
#include "Misc/TransactionallySafeRWLock.h"
#include "Physics/Experimental/AsyncPhysicsStateProcessorInterface.h"
#include "ActorComponent.generated.h"
 
struct FTypedElementHandle;
 
class AActor;
class IRepChangedPropertyTracker;
class UActorComponent;
class UAssetUserData;
class ULevel;
class UWorld;
class UPrimitiveComponent;
struct FSimpleMemberReference;
struct FAsyncRegisterLevelContext;
class IPrimitiveComponent;
class UEngineReplicationBridge;
 
namespace UE::Net
{
    struct FReplicationSystemUtil;
}
 
ENGINE_API extern int32 GEnableDeferredPhysicsCreation;
 
class FRegisterComponentContext
{
public:
    using FPrimitiveBatch = TArray<UPrimitiveComponent*, FConcurrentLinearArrayAllocator>;
 
    FRegisterComponentContext(UWorld* InWorld);
    ~FRegisterComponentContext();
 
    FRegisterComponentContext& SetIncrementalUpdateTimeout(const UE::FTimeout& InTimeout);
    FRegisterComponentContext& SetIncrementalUpdateAddPrimitiveBatchSize(int32 Value);
    FRegisterComponentContext& SetIncrementalUpdateNumComponentsToUpdate(int32 Value);
    FRegisterComponentContext& SetAsyncRegisterLevelContext(FAsyncRegisterLevelContext* Value);
 
    const UE::FTimeout& GetIncrementalUpdateTimeout() const { return Timeout; }
    int32 GetIncrementalUpdateAddPrimitiveBatchSize() const { return IncrementalUpdateAddPrimitiveBatchSize; }
    int32 GetIncrementalUpdateNumComponentsToUpdate() const { return IncrementalUpdateNumComponentsToUpdate; }
 
    void AddPrimitive(UPrimitiveComponent* PrimitiveComponent);
    void AddSendRenderDynamicData(UPrimitiveComponent* PrimitiveComponent);
 
    ENGINE_API static void SendRenderDynamicData(FRegisterComponentContext* Context, UPrimitiveComponent* PrimitiveComponent);
 
    UE_DEPRECATED(5.5, "This function is not used anymore")
    int32 Count() const { return AddPrimitiveBatches.Num(); }
 
    void Process();
 
private:
    bool OnIncrementalRegisterComponentsDone();
 
    UWorld* World;
    UE::FTimeout Timeout;
    int32   IncrementalUpdateAddPrimitiveBatchSize;
    int32   IncrementalUpdateNumComponentsToUpdate;
    FAsyncRegisterLevelContext* AsyncRegisterLevelContext;
    
    FPrimitiveBatch AddPrimitiveBatches;
    FPrimitiveBatch SendRenderDynamicDataPrimitives;
 
    friend class ULevel;
};
 
#if WITH_EDITOR
class SWidget;
struct FMinimalViewInfo;
#endif
 
enum class EUpdateTransformFlags : int32
{
    None = 0x0,
    SkipPhysicsUpdate = 0x1,        
    PropagateFromParent = 0x2,      
    OnlyUpdateIfUsingSocket = 0x4   
};
 
constexpr inline EUpdateTransformFlags operator|(EUpdateTransformFlags Left, EUpdateTransformFlags Right)
{
    return static_cast<EUpdateTransformFlags> ( static_cast<int32> (Left) | static_cast<int32> (Right) );
}
 
constexpr inline EUpdateTransformFlags operator&(EUpdateTransformFlags Left, EUpdateTransformFlags Right)
{
    return static_cast<EUpdateTransformFlags> (static_cast<int32> (Left) & static_cast<int32> (Right));
}
 
constexpr inline bool operator !(EUpdateTransformFlags Value)
{
    return Value == EUpdateTransformFlags::None;
}
 
constexpr inline EUpdateTransformFlags operator ~(EUpdateTransformFlags Value)
{
    return static_cast<EUpdateTransformFlags>(~static_cast<int32>(Value));
}
 
inline EUpdateTransformFlags SkipPhysicsToEnum(bool bSkipPhysics){ return bSkipPhysics ? EUpdateTransformFlags::SkipPhysicsUpdate : EUpdateTransformFlags::None; }
 
class FSceneInterface;
extern ENGINE_API void UpdateAllPrimitiveSceneInfosForSingleComponent(UActorComponent* InComponent, TSet<FSceneInterface*>* InScenesToUpdateAllPrimitiveSceneInfosForBatching = nullptr);
extern ENGINE_API void UpdateAllPrimitiveSceneInfosForSingleComponentInterface(IPrimitiveComponent* InComponent, TSet<FSceneInterface*>* InScenesToUpdateAllPrimitiveSceneInfosForBatching = nullptr);
extern ENGINE_API void UpdateAllPrimitiveSceneInfosForScenes(TSet<FSceneInterface*> ScenesToUpdateAllPrimitiveSceneInfos);
 
class UActorComponent;
 
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams(FActorComponentActivatedSignature, UActorComponent, OnComponentActivated, UActorComponent*, Component, bool, bReset);
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_OneParam(FActorComponentDeactivateSignature, UActorComponent, OnComponentDeactivated, UActorComponent*, Component);
 
DECLARE_MULTICAST_DELEGATE_OneParam(FActorComponentGlobalCreatePhysicsSignature, UActorComponent*);
DECLARE_MULTICAST_DELEGATE_OneParam(FActorComponentGlobalDestroyPhysicsSignature, UActorComponent*);
 
UCLASS(DefaultToInstanced, BlueprintType, abstract, meta=(ShortTooltip="An ActorComponent is a reusable component that can be added to any actor."), config=Engine, MinimalAPI)
class UActorComponent : public UObject, public IInterface_AssetUserData, public IAsyncPhysicsStateProcessor
{
    GENERATED_BODY()
 
public:
    static ENGINE_API FActorComponentGlobalCreatePhysicsSignature GlobalCreatePhysicsDelegate;
    static ENGINE_API FActorComponentGlobalDestroyPhysicsSignature GlobalDestroyPhysicsDelegate;
 
    ENGINE_API UActorComponent(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
 
    UPROPERTY(EditDefaultsOnly, Category="ComponentTick")
    struct FActorComponentTickFunction PrimaryComponentTick;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Tags)
    TArray<FName> ComponentTags;
 
protected:
    UPROPERTY(EditAnywhere, AdvancedDisplay, Instanced, Category = AssetUserData)
    TArray<TObjectPtr<UAssetUserData>> AssetUserData;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, AdvancedDisplay, Instanced, Category = AssetUserData)
    TArray<TObjectPtr<UAssetUserData>> AssetUserDataEditorOnly;
#endif
 
 
private:
    int32 MarkedForEndOfFrameUpdateArrayIndex : 28;
 
    uint8 MarkedForEndOfFrameUpdateState : 2;
 
    uint8 bReadyForEarlyEndOfFrameUpdate : 1;
 
    uint8 bRenderStateUpdating : 1;
 
    UPROPERTY()
    int32 UCSSerializationIndex;
 
protected:
 
    enum class EComponentRegistrationState
    {
        None,
        PreRegistering,
        PreRegistered,
        PreUnregistering,
        PreUnregistered
    };
 
    EComponentRegistrationState RegistrationState;
 
    uint8 bRegistered:1;
 
    uint8 bRenderStateCreated:1;
 
    uint8 bRenderStateRecreating:1;
 
    uint8 bPhysicsStateCreated:1;
 
    uint8 bCallAsyncPhysicsStateCreatedDelegate:1;
 
    UPROPERTY()
    uint8 bNetAddressable:1;
 
    UPROPERTY(Config, EditDefaultsOnly, BlueprintReadOnly, Category=Replication, AdvancedDisplay)
    uint8 bReplicateUsingRegisteredSubObjectList : 1;
 
private:
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Replicated, Category=ComponentReplication,meta=(DisplayName = "Component Replicates", AllowPrivateAccess = "true"))
    uint8 bReplicates:1;
 
    uint8 bRenderStateDirty:1;
 
    uint8 bRenderTransformDirty:1;
 
    uint8 bRenderDynamicDataDirty:1;
 
    uint8 bRenderInstancesDirty:1;
 
    uint8 bRoutedPostRename:1;
 
public:
    uint8 bAutoRegister:1;
 
protected:
    uint8 bAllowReregistration:1;
 
public:
    uint8 bTickInEditor:1;
 
    uint8 bNeverNeedsRenderUpdate:1;
 
    uint8 bAllowConcurrentTick:1;
 
    uint8 bAllowAnyoneToDestroyMe:1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    uint8 bCreatedByConstructionScript_DEPRECATED:1;
 
    UPROPERTY()
    uint8 bInstanceComponent_DEPRECATED:1;
#endif
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Activation)
    uint8 bAutoActivate:1;
 
private:
    UPROPERTY(transient, ReplicatedUsing=OnRep_IsActive)
    uint8 bIsActive:1;
 
public:
 
    UPROPERTY(EditDefaultsOnly, Category="Variable")
    uint8 bEditableWhenInherited:1;
 
    uint8 bNavigationRelevant : 1;
 
protected:
    UPROPERTY(EditAnywhere, Category = Navigation, AdvancedDisplay, config)
    uint8 bCanEverAffectNavigation : 1;
 
public:
    uint8 bWantsInitializeComponent:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Cooking)
    uint8 bIsEditorOnly:1;
 
#if WITH_EDITORONLY_DATA
private:
    UPROPERTY()
    uint8 bIsVisualizationComponent : 1;
 
    UPROPERTY()
    uint8 bNeedsUCSSerializationIndexEvaluted : 1;
#endif
 
private:
    uint8 bHasBeenCreated:1;
 
    uint8 bHasBeenInitialized:1;
 
    uint8 bIsReadyForReplication:1;
 
    uint8 bHasBegunPlay:1;
 
    uint8 bIsBeingDestroyed:1;
 
    uint8 bTickFunctionsRegistered:1;
 
    FPhysScene* PhysicsStateAsyncCreationScene;
    
    mutable AActor* OwnerPrivate;
 
    UWorld* WorldPrivate;
 
#if WITH_EDITOR
    uint8 bCanUseCachedOwner:1;
 
    uint8 bMarkPendingKillOnPostLoad : 1;
#endif
 
    uint8 bIsNetStartupComponent : 1;
 
    uint8 bMarkedForPreEndOfFrameSync : 1;
 
    uint8 bAsyncPhysicsTickEnabled : 1;
 
    enum struct EPhysicsStateAsyncCreationState : uint8
    {
        None,
        Creating,
        Destroying
    };
 
    EPhysicsStateAsyncCreationState PhysicsStateAsyncCreationState : 2;
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    uint8 bComponentTickEnabled : 1 = false;
#endif
 
public:
 
    UPROPERTY()
    EComponentCreationMethod CreationMethod;
 
public:
    int32 GetUCSSerializationIndex() const
    {
#if WITH_EDITORONLY_DATA
        if (bNeedsUCSSerializationIndexEvaluted)
        {
            const_cast<UActorComponent*>(this)->DetermineUCSSerializationIndexForLegacyComponent();
        }
#endif
 
        return UCSSerializationIndex;
    }
 
private:
    ENGINE_API void DetermineUCSSerializationIndexForLegacyComponent();
 
#if WITH_EDITOR
    ENGINE_API virtual TUniquePtr<class FWorldPartitionComponentDesc> CreateClassComponentDesc() const;
 
public:
    ENGINE_API TUniquePtr<class FWorldPartitionComponentDesc> CreateComponentDesc() const;
 
    static ENGINE_API TUniquePtr<class FWorldPartitionComponentDesc> StaticCreateClassComponentDesc(const TSubclassOf<UActorComponent>& ComponentClass);
#endif
 
public:
 
    bool IsAsyncCreatePhysicsStateRunning() const
    {
        return PhysicsStateAsyncCreationScene && (PhysicsStateAsyncCreationState == EPhysicsStateAsyncCreationState::Creating);
    }
 
    bool IsAsyncDestroyPhysicsStateRunning() const
    {
        return PhysicsStateAsyncCreationScene && (PhysicsStateAsyncCreationState == EPhysicsStateAsyncCreationState::Destroying);
    }
 
    uint32 GetMarkedForEndOfFrameUpdateState() const { return MarkedForEndOfFrameUpdateState; }
 
    uint32 GetMarkedForPreEndOfFrameSync() const { return bMarkedForPreEndOfFrameSync; }
 
    ENGINE_API void DetermineUCSModifiedProperties();
 
    ENGINE_API void GetUCSModifiedProperties(TSet<const FProperty*>& ModifiedProperties) const;
 
    ENGINE_API void RemoveUCSModifiedProperties(const TArray<FProperty*>& Properties);
 
    ENGINE_API void ClearUCSModifiedProperties();
 
    ENGINE_API bool IsEditableWhenInherited() const;
 
    bool HasBeenCreated() const { return bHasBeenCreated; }
 
    bool HasBeenInitialized() const { return bHasBeenInitialized; }
 
    bool IsReadyForReplication() const { return bIsReadyForReplication; }
 
    bool HasBegunPlay() const { return bHasBegunPlay; }
 
    UFUNCTION(BlueprintCallable, Category="Components", meta=(DisplayName="Is Component Being Destroyed"))
    bool IsBeingDestroyed() const
    {
        return bIsBeingDestroyed;
    }
 
    ENGINE_API bool IsCreatedByConstructionScript() const;
 
    UFUNCTION()
    ENGINE_API virtual void OnRep_IsActive();
 
private:
    ENGINE_API AActor* GetActorOwnerNoninline() const;
 
public:
    UFUNCTION(BlueprintCallable, Category="Components", meta=(Keywords = "Actor Owning Parent"))
    AActor* GetOwner() const;
 
    template< class T >
    T* GetOwner() const
    {
        return Cast<T>(GetOwner());
    }
 
    virtual UWorld* GetWorld() const override final { return (WorldPrivate ? WorldPrivate : GetWorld_Uncached()); }
 
    UFUNCTION(BlueprintCallable, Category="Components")
    ENGINE_API bool ComponentHasTag(FName Tag) const;
 
 
    // Activation System
 
    UPROPERTY(BlueprintAssignable, Category = "Components|Activation")
    FActorComponentActivatedSignature OnComponentActivated;
 
    UPROPERTY(BlueprintAssignable, Category = "Components|Activation")
    FActorComponentDeactivateSignature OnComponentDeactivated;
 
#if WITH_EDITORONLY_DATA
private:
    UPROPERTY()
    TArray<FSimpleMemberReference> UCSModifiedProperties_DEPRECATED;
#endif
 
    static ENGINE_API FTransactionallySafeRWLock AllUCSModifiedPropertiesLock;
    static ENGINE_API TMap<UActorComponent*, TArray<FSimpleMemberReference>> AllUCSModifiedProperties;
 
public:
    UFUNCTION(BlueprintCallable, Category="Components|Activation", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void Activate(bool bReset=false);
    
    UFUNCTION(BlueprintCallable, Category="Components|Activation", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void Deactivate();
 
    UFUNCTION(BlueprintCallable, Category="Components|Activation", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void SetActive(bool bNewActive, bool bReset=false);
 
    UFUNCTION(BlueprintCallable, Category="Components|Activation", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void ToggleActive();
 
    UFUNCTION(BlueprintCallable, Category="Components|Activation", meta=(UnsafeDuringActorConstruction="true"))
    bool IsActive() const { return bIsActive; }
 
    UFUNCTION(BlueprintCallable, Category="Components|Activation")
    ENGINE_API virtual void SetAutoActivate(bool bNewAutoActivate);
 
    UFUNCTION(BlueprintCallable, Category="Components|Tick")
    ENGINE_API void SetTickableWhenPaused(bool bTickableWhenPaused);
 
    ENGINE_API void CreatePhysicsState(bool bAllowDeferral = false);
 
    ENGINE_API void DestroyPhysicsState();
 
 
    // Networking
 
    ENGINE_API void SetNetAddressable();
 
    UFUNCTION(BlueprintCallable, Category="Components")
    ENGINE_API void SetIsReplicated(bool ShouldReplicate);
 
    inline bool GetIsReplicated() const
    {
        return bReplicates;
    }
 
    ENGINE_API virtual bool ReplicateSubobjects(class UActorChannel *Channel, class FOutBunch *Bunch, FReplicationFlags *RepFlags);
 
    bool IsUsingRegisteredSubObjectList() const { return bReplicateUsingRegisteredSubObjectList; }
 
    virtual ELifetimeCondition GetReplicationCondition() const { return GetIsReplicated() ? COND_None : COND_Never;  }
 
    virtual void PreReplication(IRepChangedPropertyTracker & ChangedPropertyTracker) {}
 
    ENGINE_API virtual bool GetComponentClassCanReplicate() const;
 
    ENGINE_API void AddReplicatedSubObject(UObject* SubObject, ELifetimeCondition NetCondition = COND_None);
 
    ENGINE_API void RemoveReplicatedSubObject(UObject* SubObject);
 
    ENGINE_API void DestroyReplicatedSubObjectOnRemotePeers(UObject* SubObject);
 
    ENGINE_API void TearOffReplicatedSubObjectOnRemotePeers(UObject* SubObject);
 
    ENGINE_API bool IsReplicatedSubObjectRegistered(const UObject* SubObject) const;
 
#if WITH_EDITORONLY_DATA
    virtual bool IsEditorOnly() const override { return bIsEditorOnly; }
 
    virtual void MarkAsEditorOnlySubobject() override
    {
        bIsEditorOnly = true;
        // A bit sketchy, but is best for backwards compatibility as the vast majority of editor only components were for visualization, 
        // so for the very few where visualization is not the purpose, it can be cleared after the subobject is created
        bIsVisualizationComponent = true; 
    }
 
    bool IsVisualizationComponent() const { return bIsVisualizationComponent; }
 
    void SetIsVisualizationComponent(const bool bInIsVisualizationComponent)
    {
        bIsVisualizationComponent = bInIsVisualizationComponent;
        if (bIsVisualizationComponent)
        {
            bIsEditorOnly = true;
        }
    }
#endif
 
    bool IsNetSimulating() const;
 
    ENGINE_API ENetRole GetOwnerRole() const;
 
    ENetMode GetNetMode() const;
 
    bool IsNetMode(ENetMode Mode) const;
 
    bool IsNetStartupComponent() const { return bIsNetStartupComponent; }
 
    void SetIsNetStartupComponent(const bool bInIsNetStartupComponent) { bIsNetStartupComponent = bInIsNetStartupComponent; }
 
    virtual void OnEndOfFrameUpdateDuringTick() {}
 
    virtual void OnPreEndOfFrameSync() {}
 
    ENGINE_API virtual void RegisterReplicationFragments(UE::Net::FFragmentRegistrationContext& Context, UE::Net::EFragmentRegistrationFlags RegistrationFlags) override;
    
    struct FOnReplicationStartedParams
    {
    };
 
    ENGINE_API virtual void OnReplicationStartedForIris(const FOnReplicationStartedParams&);
 
    struct FOnStopReplicationParams
    {
    };
    ENGINE_API virtual void OnStopReplicationForIris(const FOnStopReplicationParams&);
 
    UE_DEPRECATED(5.7, "This is being deprecated as part of iris beta. Override OnReplicationStartedForIris instead.")
    ENGINE_API virtual void BeginReplication();
 
    UE_DEPRECATED(5.7, "This is being deprecated as part of iris beta. Override OnStopReplicationForIris instead.")
    ENGINE_API virtual void EndReplication();
 
private:
 
    //ENGINE_API static void StartReplicatingForIris(UActorComponent* ActorComponent);
    //ENGINE_API static void StopReplicatingForIris(UActorComponent* ActorComponent);
 
    ENGINE_API UWorld* GetWorld_Uncached() const;
 
    ENGINE_API ENetMode InternalGetNetMode() const;
 
    ENGINE_API void ExecuteUnregisterEvents();
 
    ENGINE_API void ExecuteRegisterEvents(FRegisterComponentContext* Context = nullptr);
 
    ENGINE_API void ConsolidatedPostEditChange(const FPropertyChangedEvent& PropertyChangedEvent);
 
protected:
    ENGINE_API virtual bool ShouldActivate() const;
 
    ENGINE_API virtual bool ShouldAsyncCreatePhysicsState(UWorld* WorldContext) const;
 
    ENGINE_API virtual bool ShouldAsyncDestroyPhysicsState() const;
 
    ENGINE_API virtual void OnPreRegister();
 
    ENGINE_API virtual void OnPreRegistered();
 
    ENGINE_API virtual void OnPreUnregister();
 
    ENGINE_API virtual void OnPreUnregistered();
 
    ENGINE_API virtual void OnRegister();
 
    ENGINE_API virtual void OnUnregister();
 
    virtual void PrecachePSOs() {}
 
    virtual bool ShouldCreateRenderState() const 
    {
        return false;
    }
 
    ENGINE_API virtual void CreateRenderState_Concurrent(FRegisterComponentContext* Context);
 
    ENGINE_API virtual void SendRenderTransform_Concurrent();
 
    ENGINE_API virtual void SendRenderDynamicData_Concurrent();
 
    ENGINE_API virtual void SendRenderInstanceData_Concurrent();
 
    ENGINE_API virtual void DestroyRenderState_Concurrent();
 
    ENGINE_API virtual void OnCreatePhysicsState();
 
    ENGINE_API virtual void OnDestroyPhysicsState();
 
    virtual bool ShouldCreatePhysicsState() const {return false;}
 
    virtual bool HasValidPhysicsState() const { return false; }
 
    ENGINE_API virtual void RegisterComponentTickFunctions(bool bRegister);
 
public:
 
    ENGINE_API virtual bool ShouldIncrementalPreRegister(UWorld* WorldContext) const;
 
    ENGINE_API virtual bool ShouldIncrementalPreUnregister() const;
 
    //~ Begin IAsyncPhysicsStateProcessor
    virtual bool AllowsAsyncPhysicsStateCreation() const
    {
        return false;
    }
    virtual bool AllowsAsyncPhysicsStateDestruction() const
    {
        return false;
    }
    ENGINE_API virtual bool IsAsyncPhysicsStateCreated() const override final;
    ENGINE_API virtual UObject* GetAsyncPhysicsStateObject() const override final;
    ENGINE_API virtual bool OnAsyncCreatePhysicsState(const UE::FTimeout& Timeout) override;
    ENGINE_API virtual void OnAsyncCreatePhysicsStateEnd_GameThread() override;
    virtual bool OnAsyncDestroyPhysicsState(const UE::FTimeout& Timeout) override { return true; }
    ENGINE_API virtual void OnAsyncDestroyPhysicsStateBegin_GameThread() override;
    ENGINE_API virtual void OnAsyncDestroyPhysicsStateEnd_GameThread() override;
    //~ End IAsyncPhysicsStateProcessor
    ENGINE_API virtual void InitializeComponent();
 
    ENGINE_API virtual void ReadyForReplication();
 
    ENGINE_API virtual void BeginPlay();
 
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "Begin Play"))
    ENGINE_API void ReceiveBeginPlay();
 
    ENGINE_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason);
 
    ENGINE_API virtual void UninitializeComponent();
 
    UFUNCTION(BlueprintImplementableEvent, meta=(Keywords = "delete", DisplayName = "End Play"))
    ENGINE_API void ReceiveEndPlay(EEndPlayReason::Type EndPlayReason);
    
    ENGINE_API void RegisterAllComponentTickFunctions(bool bRegister);
 
    ENGINE_API virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction);
 
    virtual void AsyncPhysicsTickComponent(float DeltaTime, float SimTime) { ReceiveAsyncPhysicsTick(DeltaTime, SimTime); }
    
    ENGINE_API bool SetupActorComponentTickFunction(struct FTickFunction* TickFunction);
 
    UFUNCTION(BlueprintCallable, Category="Components|Tick")
    ENGINE_API virtual void SetComponentTickEnabled(bool bEnabled);
 
    ENGINE_API virtual void SetComponentTickEnabledAsync(bool bEnabled);
    
    UFUNCTION(BlueprintCallable, Category="Components|Tick")
    ENGINE_API virtual bool IsComponentTickEnabled() const;
 
    UFUNCTION(BlueprintCallable, Category="Components|Tick")
    ENGINE_API void SetComponentTickInterval(float TickInterval);
 
    UFUNCTION(BlueprintCallable, Category="Components|Tick")
    ENGINE_API void SetComponentTickIntervalAndCooldown(float TickInterval);
 
    UFUNCTION(BlueprintCallable, Category="Components|Tick")
    ENGINE_API float GetComponentTickInterval() const;
 
    ENGINE_API void PreRegisterComponentWithWorld(UWorld* InWorld);
 
    ENGINE_API void PreUnregisterComponentFromWorld();
 
    ENGINE_API void RegisterComponentWithWorld(UWorld* InWorld, FRegisterComponentContext* Context = nullptr);
 
    virtual bool IsReadyForOwnerToAutoDestroy() const { return true; }
 
    ENGINE_API bool IsOwnerSelected() const;
 
    inline bool IsRenderTransformDirty() const { return bRenderTransformDirty; }
 
    inline bool IsRenderInstancesDirty() const { return bRenderInstancesDirty; }
 
    inline bool IsRenderStateDirty() const { return bRenderStateDirty; }
 
    void InvalidateLightingCache()
    {
        InvalidateLightingCacheDetailed(true, false);
    }
 
    virtual void InvalidateLightingCacheDetailed(bool bInvalidateBuildEnqueuedLighting, bool bTranslationOnly) {}
 
#if WITH_EDITOR
    ENGINE_API virtual void CheckForErrors();
 
    virtual bool GetEditorPreviewInfo(float DeltaTime, FMinimalViewInfo& ViewOut) { return false; }
 
    virtual TSharedPtr<SWidget> GetCustomEditorPreviewWidget() { return TSharedPtr<SWidget>(); }
 
    virtual TSubclassOf<class UHLODBuilder> GetCustomHLODBuilderClass() const { return nullptr; }
 
    virtual void GetActorDescProperties(FPropertyPairsMap& PropertyPairsMap) const {}
#endif // WITH_EDITOR
 
    ENGINE_API void DoDeferredRenderUpdates_Concurrent();
 
    virtual void UpdateComponentToWorld(EUpdateTransformFlags UpdateTransformFlags = EUpdateTransformFlags::None, ETeleportType Teleport = ETeleportType::None){}
 
    ENGINE_API void MarkRenderStateDirty();
 
    ENGINE_API void MarkRenderDynamicDataDirty();
 
    ENGINE_API void MarkRenderTransformDirty();
 
    ENGINE_API void MarkRenderInstancesDirty();
 
    ENGINE_API void MarkForNeededEndOfFrameUpdate(bool bReadyForEarlyUpdate = false);
 
    ENGINE_API void MarkForNeededEndOfFrameRecreate();
 
    inline bool IsReadyForEarlyEndOfFrameUpdate() const
    {
        return bReadyForEarlyEndOfFrameUpdate;
    }
 
    void ClearNeedEndOfFrameUpdate();
 
    ENGINE_API virtual bool RequiresGameThreadEndOfFrameUpdates() const;
 
    ENGINE_API virtual bool RequiresGameThreadEndOfFrameRecreate() const;
 
    ENGINE_API virtual bool RequiresPreEndOfFrameSync() const;
 
    ENGINE_API void RecreateRenderState_Concurrent();
 
    ENGINE_API void RecreatePhysicsState();
 
    bool IsRenderStateCreated() const
    {
        return bRenderStateCreated;
    }
 
    bool IsRenderStateRecreating() const
    {
        return bRenderStateRecreating;
    }
 
    bool IsPhysicsStateCreated() const
    {
        return bPhysicsStateCreated;
    }
 
    bool IsRenderStateUpdating() const
    {
        return bRenderStateUpdating;
    }
 
    ENGINE_API class FSceneInterface* GetScene() const;
 
    ENGINE_API ULevel* GetComponentLevel() const;
 
    ENGINE_API bool ComponentIsInLevel(const class ULevel *TestLevel) const;
 
    ENGINE_API bool ComponentIsInPersistentLevel(bool bIncludeLevelStreamingPersistent) const;
 
    virtual void OnActorVisibilityChanged() { MarkRenderStateDirty(); }
 
    virtual void OnActorEnableCollisionChanged() {}
 
    ENGINE_API virtual FString GetReadableName() const;
 
    virtual UObject const* AdditionalStatObject() const
    {
        return nullptr;
    }
 
    ENGINE_API virtual TStructOnScope<FActorComponentInstanceData> GetComponentInstanceData() const;
 
    ENGINE_API virtual void PostApplyToComponent();
 
    virtual void GetComponentChildElements(TArray<FTypedElementHandle>& OutElementHandles, const bool bAllowCreate = true) {}
 
    //~ Begin UObject Interface.
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual bool NeedsLoadForClient() const override;
    ENGINE_API virtual bool NeedsLoadForServer() const override;
    ENGINE_API virtual bool NeedsLoadForEditorGame() const override;
    ENGINE_API virtual bool IsNameStableForNetworking() const override;
    ENGINE_API virtual bool IsSupportedForNetworking() const override;
    ENGINE_API virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
    ENGINE_API virtual int32 GetFunctionCallspace( UFunction* Function, FFrame* Stack ) override;
    ENGINE_API virtual bool CallRemoteFunction( UFunction* Function, void* Parameters, FOutParmRec* OutParms, FFrame* Stack ) override;
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual void PostLoad() override;
#if UE_WITH_REMOTE_OBJECT_HANDLE
    ENGINE_API virtual void PostMigrate(const struct FUObjectMigrationContext& MigrationContext) override;
#endif
    ENGINE_API virtual bool Rename( const TCHAR* NewName=NULL, UObject* NewOuter=NULL, ERenameFlags Flags=REN_None ) override;
    ENGINE_API virtual void PostRename(UObject* OldOuter, const FName OldName) override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    static ENGINE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
#if WITH_EDITOR
    ENGINE_API virtual bool Modify( bool bAlwaysMarkDirty = true ) override;
    ENGINE_API virtual bool CanEditChange(const FProperty* InProperty) const override;
    ENGINE_API virtual void PreEditChange(FProperty* PropertyThatWillChange) override;
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual void PostEditChangeChainProperty( FPropertyChangedChainEvent& PropertyChangedEvent ) override;
    ENGINE_API virtual void PreEditUndo() override;
    ENGINE_API virtual void PostEditUndo() override;
    ENGINE_API virtual bool IsSelectedInEditor() const override;
    virtual void SetPackageExternal(bool bExternal, bool bShouldDirty) {}
    virtual FBox GetStreamingBounds() const { return FBox(ForceInit); }
    virtual FBox GetStreamingBoundsEditor() const { return GetStreamingBounds(); }
    virtual bool ForceActorNonSpatiallyLoaded() const { return false; }
    virtual bool ForceActorNoDataLayers() const { return false; }
#endif // WITH_EDITOR
    //~ End UObject Interface.
 
    //~ Begin IInterface_AssetUserData Interface
    ENGINE_API virtual void AddAssetUserData(UAssetUserData* InUserData) override;
    ENGINE_API virtual void RemoveUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) override;
    ENGINE_API virtual UAssetUserData* GetAssetUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) override;
    ENGINE_API virtual const TArray<UAssetUserData*>* GetAssetUserDataArray() const override;
    //~ End IInterface_AssetUserData Interface
 
    //~ Begin IInterface_ActorSubobject Interface
    // We're using the same API as IInterface_ActorSubobject, but not using it directly as a size and performance optimization
    ENGINE_API void OnCreatedFromReplication();
    ENGINE_API void OnDestroyedFromReplication();
    //~ End IInterface_ActorSubobject Interface
 
    ENGINE_API bool IsOwnerRunningUserConstructionScript() const;
 
    inline bool IsPreRegistering() const
    {
        return RegistrationState == EComponentRegistrationState::PreRegistering;
    }
 
    inline bool IsPreRegistered() const
    {
        return RegistrationState == EComponentRegistrationState::PreRegistered;
    }
 
    inline bool IsPreUnregistering() const
    {
        return RegistrationState == EComponentRegistrationState::PreUnregistering;
    }
 
    inline bool IsPreUnregistered() const
    {
        return RegistrationState == EComponentRegistrationState::PreUnregistered;
    }
 
    inline bool IsRegistered() const { return bRegistered; }
 
    inline bool AllowReregistration() const { return bAllowReregistration; }
 
    ENGINE_API void RegisterComponent();
 
    ENGINE_API void UnregisterComponent();
 
    ENGINE_API virtual void DestroyComponent(bool bPromoteChildren = false);
 
    ENGINE_API virtual void OnComponentCreated();
 
    ENGINE_API virtual void OnComponentDestroyed(bool bDestroyingHierarchy);
 
    UFUNCTION(BlueprintCallable, Category="Components", meta=(Keywords = "Delete", HidePin="Object", DefaultToSelf="Object", DisplayName = "Destroy Component", ScriptName = "DestroyComponent"))
    ENGINE_API void K2_DestroyComponent(UObject* Object);
 
    ENGINE_API void ReregisterComponent();
 
    UFUNCTION(BlueprintCallable, Category="Components|Tick", meta=(Keywords = "dependency"))
    ENGINE_API void SetTickGroup(ETickingGroup NewTickGroup);
 
    UFUNCTION(BlueprintCallable, Category="Components|Tick", meta=(Keywords = "dependency"))
    ENGINE_API virtual void AddTickPrerequisiteActor(AActor* PrerequisiteActor);
 
    UFUNCTION(BlueprintCallable, Category="Components|Tick", meta=(Keywords = "dependency"))
    ENGINE_API virtual void AddTickPrerequisiteComponent(UActorComponent* PrerequisiteComponent);
 
    UFUNCTION(BlueprintCallable, Category="Components|Tick", meta=(Keywords = "dependency"))
    ENGINE_API virtual void RemoveTickPrerequisiteActor(AActor* PrerequisiteActor);
 
    UFUNCTION(BlueprintCallable, Category="Components|Tick", meta=(Keywords = "dependency"))
    ENGINE_API virtual void RemoveTickPrerequisiteComponent(UActorComponent* PrerequisiteComponent);
 
    UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName = "Tick"))
    ENGINE_API void ReceiveTick(float DeltaSeconds);
 
    UFUNCTION(BlueprintImplementableEvent, meta = (DisplayName = "Async Physics Tick"))
    ENGINE_API void ReceiveAsyncPhysicsTick(float DeltaSeconds, float SimSeconds);
    
    virtual void ApplyWorldOffset(const FVector& InOffset, bool bWorldShift) {};
 
    bool CanEverAffectNavigation() const;
 
    ENGINE_API void SetCanEverAffectNavigation(bool bRelevant);
 
    virtual bool IsNavigationRelevant() const { return false; }
 
    virtual bool IsHLODRelevant() const { return false; }
 
#if WITH_EDITOR
    virtual TArray<UActorComponent*> GetHLODProxyComponents() const { return TArray<UActorComponent*>(); }
 
    virtual void ComputeHLODHash(class FHLODHashBuilder& HashBuilder) const {}
#endif
 
    static ENGINE_API const FString ComponentTemplateNameSuffix;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnMarkRenderStateDirty, UActorComponent&);
 
    static ENGINE_API FOnMarkRenderStateDirty MarkRenderStateDirtyEvent;
 
protected:
    static ENGINE_API bool CanBeHLODRelevant(const UActorComponent* ActorComponent);
 
    ENGINE_API void HandleCanEverAffectNavigationChange(bool bForceUpdate = false);
 
    ENGINE_API void SetAsyncPhysicsTickEnabled(bool bEnabled);
 
    ENGINE_API void DeferRemoveAsyncPhysicsTick();
 
private:
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    virtual void Tick( float DeltaTime ) final { check(0); }
#endif
 
    ENGINE_API void ClearNeedEndOfFrameUpdate_Internal();
 
    ENGINE_API void RegisterAsyncPhysicsTickEnabled(bool bRegister);
 
    friend struct FMarkComponentEndOfFrameUpdateState;
    friend struct FSetUCSSerializationIndex;
    friend class FActorComponentDetails;
    friend class FComponentReregisterContextBase;
    friend class FComponentRecreateRenderStateContext;
    friend struct FActorComponentTickFunction;
    friend struct UE::Net::FReplicationSystemUtil;
#if WITH_EDITOR
    friend struct SkeletalMeshUCSModifiedDataCleanupHelper;
#endif
 
    //~ Begin Methods for Replicated Members.
protected:
 
    ENGINE_API void SetIsReplicatedByDefault(const bool bNewReplicates);
 
    static const FName GetReplicatesPropertyName()
    {
        return GET_MEMBER_NAME_CHECKED(UActorComponent, bReplicates);
    }
 
public:
 
    ENGINE_API void SetActiveFlag(const bool bNewIsActive);
 
    //~ End Methods for Replicated Members.
 
protected:
 
    ENGINE_API bool OwnerNeedsInitialization() const;
 
    ENGINE_API bool NeedsInitialization() const;
};
 
// UActorComponent inlines
 
inline bool UActorComponent::CanEverAffectNavigation() const
{
    return bCanEverAffectNavigation;
}
 
inline bool UActorComponent::IsNetSimulating() const
{
    return GetIsReplicated() && GetOwnerRole() != ROLE_Authority;
}
 
inline ENetMode UActorComponent::GetNetMode() const
{
    // IsRunningDedicatedServer() is a compile-time check in optimized non-editor builds.
    if (IsRunningDedicatedServer())
    {
        return NM_DedicatedServer;
    }
 
    return InternalGetNetMode();
}
 
inline bool UActorComponent::IsNetMode(ENetMode Mode) const
{
#if UE_EDITOR
    // Editor builds are special because of PIE, which can run a dedicated server without the app running with -server.
    return GetNetMode() == Mode;
#else
    // IsRunningDedicatedServer() is a compile-time check in optimized non-editor builds.
    if (Mode == NM_DedicatedServer)
    {
        return IsRunningDedicatedServer();
    }
    else
    {
        return !IsRunningDedicatedServer() && (InternalGetNetMode() == Mode);
    }
#endif // UE_EDITOR
}
 
inline void UActorComponent::ClearNeedEndOfFrameUpdate()
{
    if (MarkedForEndOfFrameUpdateState != 0)
    {
        ClearNeedEndOfFrameUpdate_Internal();
    }
}
 
inline AActor* UActorComponent::GetOwner() const
{
#if WITH_EDITOR
    // During undo/redo the cached owner is unreliable so just used GetTypedOuter
    if (bCanUseCachedOwner)
    {
        checkSlow(OwnerPrivate == GetActorOwnerNoninline()); // verify cached value is correct
        return OwnerPrivate;
    }
    else
    {
        return GetActorOwnerNoninline();
    }
#else
    checkSlow(OwnerPrivate == GetActorOwnerNoninline()); // verify cached value is correct
    return OwnerPrivate;
#endif
}
 
#if WITH_EDITOR
extern ENGINE_API TFunction<bool(const UActorComponent*)> GIsComponentSelectedInEditor;
#endif