PrimitiveComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Algo/Copy.h"
#include "EngineStats.h"
#include "HAL/ThreadSafeCounter.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
#include "Misc/Guid.h"
#include "Interfaces/IPhysicsComponent.h"
#include "Templates/SubclassOf.h"
#include "Engine/EngineTypes.h"
#include "Engine/ScopedMovementUpdate.h"
#include "Engine/OverlapInfo.h"
#include "Components/SceneComponent.h"
#include "Components/ActorPrimitiveComponentInterface.h"
#include "RenderCommandFence.h"
#include "GameFramework/Actor.h"
#include "CollisionQueryParams.h"
#include "SceneTypes.h"
#include "Engine/EngineTypes.h"
#include "PhysicsEngine/BodyInstance.h"
#include "Engine/TextureStreamingTypes.h"
#include "AI/Navigation/NavRelevantInterface.h"
#include "VT/RuntimeVirtualTextureEnum.h"
#include "HitProxies.h"
#include "Interfaces/Interface_AsyncCompilation.h"
#include "HLOD/HLODBatchingPolicy.h"
#include "HLOD/HLODLevelExclusion.h"
#include "Stats/Stats.h"
#include "PSOPrecacheFwd.h"
#include "PipelineStateCache.h"
#include "MeshDrawCommandStatsDefines.h"
#include "PrimitiveSceneInfoData.h"
#include "PrimitiveComponent.generated.h"
 
DECLARE_CYCLE_STAT_EXTERN(TEXT("BeginComponentOverlap"), STAT_BeginComponentOverlap, STATGROUP_Game, ENGINE_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("MoveComponent FastOverlap"), STAT_MoveComponent_FastOverlap, STATGROUP_Game, ENGINE_API);
 
class AController;
class FPrimitiveSceneProxy;
class UMaterialInterface;
class UPrimitiveComponent;
class UTexture;
class URuntimeVirtualTexture;
struct FCollisionShape;
struct FConvexVolume;
struct FEngineShowFlags;
struct FNavigableGeometryExport;
struct FPSOPrecacheParams;
struct FOverlapResult;
 
enum class EObjectMigrationSendType : uint8;
 
namespace PrimitiveComponentCVars
{
    extern float HitDistanceToleranceCVar;
    extern float InitialOverlapToleranceCVar;
    extern int32 bAllowCachedOverlapsCVar;
    extern int32 bEnableFastOverlapCheck;
}
 
UENUM()
enum ECanBeCharacterBase : int
{
    ECB_No UMETA(DisplayName="No"),
    ECB_Yes UMETA(DisplayName="Yes"),
    ECB_Owner UMETA(DisplayName="(Owner)"),
    ECB_MAX,
};
 
USTRUCT()
struct FSpriteCategoryInfo
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    FName Category;
 
    UPROPERTY()
    FText DisplayName;
 
    UPROPERTY()
    FText Description;
};
 
UENUM()
enum class ERendererStencilMask : uint8
{
    ERSM_Default UMETA(DisplayName = "Default"),
    ERSM_255 UMETA(DisplayName = "All bits (255), ignore depth"),
    ERSM_1 UMETA(DisplayName = "First bit (1), ignore depth"),
    ERSM_2 UMETA(DisplayName = "Second bit (2), ignore depth"),
    ERSM_4 UMETA(DisplayName = "Third bit (4), ignore depth"),
    ERSM_8 UMETA(DisplayName = "Fourth bit (8), ignore depth"),
    ERSM_16 UMETA(DisplayName = "Fifth bit (16), ignore depth"),
    ERSM_32 UMETA(DisplayName = "Sixth bit (32), ignore depth"),
    ERSM_64 UMETA(DisplayName = "Seventh bit (64), ignore depth"),
    ERSM_128 UMETA(DisplayName = "Eighth bit (128), ignore depth")
};
 
UENUM()
enum class ERayTracingGroupCullingPriority : uint8
{
    CP_0_NEVER_CULL UMETA(DisplayName = "0 - Never cull"),
    CP_1 UMETA(DisplayName = "1"),
    CP_2 UMETA(DisplayName = "2"),
    CP_3 UMETA(DisplayName = "3"),
    CP_4_DEFAULT UMETA(DisplayName = "4 - Default"),
    CP_5 UMETA(DisplayName = "5"),
    CP_6 UMETA(DisplayName = "6"),
    CP_7 UMETA(DisplayName = "7"),
    CP_8_QUICKLY_CULL UMETA(DisplayName = "8 - Quickly cull")
};
 
UENUM()
enum class EFirstPersonPrimitiveType : uint8
{
    None UMETA(DisplayName = "None"),
    FirstPerson UMETA(DisplayName = "First Person"),
    WorldSpaceRepresentation UMETA(DisplayName = "World Space Representation"),
};
 
struct FRendererStencilMaskEvaluation
{
    static inline EStencilMask ToStencilMask(const ERendererStencilMask InEnum)
    {
        switch (InEnum)
        {
        case ERendererStencilMask::ERSM_Default:
            return EStencilMask::SM_Default;
        case ERendererStencilMask::ERSM_255:
            return EStencilMask::SM_255;
        case ERendererStencilMask::ERSM_1:
            return EStencilMask::SM_1;
        case ERendererStencilMask::ERSM_2:
            return EStencilMask::SM_2;
        case ERendererStencilMask::ERSM_4:
            return EStencilMask::SM_4;
        case ERendererStencilMask::ERSM_8:
            return EStencilMask::SM_8;
        case ERendererStencilMask::ERSM_16:
            return EStencilMask::SM_16;
        case ERendererStencilMask::ERSM_32:
            return EStencilMask::SM_32;
        case ERendererStencilMask::ERSM_64:
            return EStencilMask::SM_64;
        case ERendererStencilMask::ERSM_128:
            return EStencilMask::SM_128;
        default:
            // Unsupported EStencilMask - return a safe default.
            check(false);
            return EStencilMask::SM_Default;
        }
    }
};
 
// Predicate to determine if an overlap is with a certain AActor.
struct FPredicateOverlapHasSameActor
{
    FPredicateOverlapHasSameActor(const AActor& Owner)
        : MyOwnerPtr(&Owner)
    {
    }
 
    bool operator() (const FOverlapInfo& Info)
    {
        // MyOwnerPtr is always valid, so we don't need the IsValid() checks in the WeakObjectPtr comparison operator.
        return MyOwnerPtr.HasSameIndexAndSerialNumber(Info.OverlapInfo.HitObjectHandle.FetchActor());
    }
 
private:
    const TWeakObjectPtr<const AActor> MyOwnerPtr;
};
 
// Predicate to determine if an overlap is *NOT* with a certain AActor.
struct FPredicateOverlapHasDifferentActor
{
    FPredicateOverlapHasDifferentActor(const AActor& Owner)
        : MyOwnerPtr(&Owner)
    {
    }
 
    bool operator() (const FOverlapInfo& Info)
    {
        // MyOwnerPtr is always valid, so we don't need the IsValid() checks in the WeakObjectPtr comparison operator.
        return !MyOwnerPtr.HasSameIndexAndSerialNumber(Info.OverlapInfo.HitObjectHandle.FetchActor());
    }
 
private:
    const TWeakObjectPtr<const AActor> MyOwnerPtr;
};
 
// TODO: Add sleep and wake state change types to this enum, so that the
// OnComponentWake and OnComponentSleep delegates may be deprecated.
// Doing so would save a couple bytes per primitive component.
UENUM(BlueprintType)
enum class EComponentPhysicsStateChange : uint8
{
    Created,
    Destroyed
};
 
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_FiveParams( FComponentHitSignature, UPrimitiveComponent, OnComponentHit, UPrimitiveComponent*, HitComponent, AActor*, OtherActor, UPrimitiveComponent*, OtherComp, FVector, NormalImpulse, const FHitResult&, Hit );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_SixParams( FComponentBeginOverlapSignature, UPrimitiveComponent, OnComponentBeginOverlap, UPrimitiveComponent*, OverlappedComponent, AActor*, OtherActor, UPrimitiveComponent*, OtherComp, int32, OtherBodyIndex, bool, bFromSweep, const FHitResult &, SweepResult);
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_FourParams( FComponentEndOverlapSignature, UPrimitiveComponent, OnComponentEndOverlap, UPrimitiveComponent*, OverlappedComponent, AActor*, OtherActor, UPrimitiveComponent*, OtherComp, int32, OtherBodyIndex);
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams(FComponentWakeSignature, UPrimitiveComponent, OnComponentWake, UPrimitiveComponent*, WakingComponent, FName, BoneName);
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams(FComponentSleepSignature, UPrimitiveComponent, OnComponentSleep, UPrimitiveComponent*, SleepingComponent, FName, BoneName);
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_OneParam(FComponentCollisionSettingsChangedSignature, UPrimitiveComponent, OnComponentCollisionSettingsChangedEvent, UPrimitiveComponent*, ChangedComponent);
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams(FComponentPhysicsStateChanged, UPrimitiveComponent, OnComponentPhysicsStateChanged, UPrimitiveComponent*, ChangedComponent, EComponentPhysicsStateChange, StateChange);
 
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_OneParam( FComponentBeginCursorOverSignature, UPrimitiveComponent, OnBeginCursorOver, UPrimitiveComponent*, TouchedComponent );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_OneParam( FComponentEndCursorOverSignature, UPrimitiveComponent, OnEndCursorOver, UPrimitiveComponent*, TouchedComponent );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams( FComponentOnClickedSignature, UPrimitiveComponent, OnClicked, UPrimitiveComponent*, TouchedComponent , FKey, ButtonPressed);
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams( FComponentOnReleasedSignature, UPrimitiveComponent, OnReleased, UPrimitiveComponent*, TouchedComponent, FKey, ButtonReleased);
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams( FComponentOnInputTouchBeginSignature, UPrimitiveComponent, OnInputTouchBegin, ETouchIndex::Type, FingerIndex, UPrimitiveComponent*, TouchedComponent );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams( FComponentOnInputTouchEndSignature, UPrimitiveComponent, OnInputTouchEnd, ETouchIndex::Type, FingerIndex, UPrimitiveComponent*, TouchedComponent );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams( FComponentBeginTouchOverSignature, UPrimitiveComponent, OnInputTouchEnter, ETouchIndex::Type, FingerIndex, UPrimitiveComponent*, TouchedComponent );
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams( FComponentEndTouchOverSignature, UPrimitiveComponent, OnInputTouchLeave, ETouchIndex::Type, FingerIndex, UPrimitiveComponent*, TouchedComponent );
 
UCLASS(abstract, HideCategories=(Mobility, VirtualTexture), ShowCategories=(PhysicsVolume), MinimalAPI)
class UPrimitiveComponent : public USceneComponent, public INavRelevantInterface, public IInterface_AsyncCompilation, public IPhysicsComponent
{
    GENERATED_BODY()
 
public:
    ENGINE_API UPrimitiveComponent(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
    ENGINE_API UPrimitiveComponent(FVTableHelper& Helper);
    ENGINE_API ~UPrimitiveComponent();
 
    // Rendering
    static ENGINE_API FName RVTActorDescProperty;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=LOD)
    float MinDrawDistance;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=LOD, meta=(DisplayName="Desired Max Draw Distance") )
    float LDMaxDrawDistance;
 
    UPROPERTY(Category=LOD, AdvancedDisplay, VisibleAnywhere, BlueprintReadOnly, meta=(DisplayName="Current Max Draw Distance") )
    float CachedMaxDrawDistance;
 
    UPROPERTY()
    TEnumAsByte<enum ESceneDepthPriorityGroup> DepthPriorityGroup;
 
    UPROPERTY()
    TEnumAsByte<enum ESceneDepthPriorityGroup> ViewOwnerDepthPriorityGroup;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting)
    TEnumAsByte<EIndirectLightingCacheQuality> IndirectLightingCacheQuality;
 
    UE_DEPRECATED(5.5, "Use GetLightmapType()/SetLightmapType() instead")
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting, Getter, Setter,  meta = (AllowPrivateAccess)) 
    ELightmapType LightmapType;
    
    ENGINE_API ELightmapType GetLightmapType() const;
    ENGINE_API void SetLightmapType(ELightmapType InLightmapType);
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=HLOD, meta=(DisplayName="HLOD Batching Policy", DisplayAfter="bEnableAutoLODGeneration", EditConditionHides, EditCondition="bEnableAutoLODGeneration"))
    EHLODBatchingPolicy HLODBatchingPolicy;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Lighting, AdvancedDisplay, meta=(EditCondition="CastShadow"))
    EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehavior;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = HLOD, meta=(DisplayName="Include Component in HLOD"))
    uint8 bEnableAutoLODGeneration : 1;
 
    UPROPERTY()
    uint8 bIsActorTextureStreamingBuiltData : 1;
 
    UPROPERTY()
    uint8 bIsValidTextureStreamingBuiltData : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=LOD)
    uint8 bNeverDistanceCull : 1;
 
    mutable uint8 bAttachedToStreamingManagerAsStatic : 1;
    mutable uint8 bAttachedToStreamingManagerAsDynamic : 1;
    mutable uint8 bHandledByStreamingManagerAsDynamic : 1;
    mutable uint8 bIgnoreStreamingManagerUpdate : 1;
 
    mutable uint8 bAttachedToCoarseMeshStreamingManager : 1;
 
    mutable uint8 bBulkReregister : 1;
 
    inline bool IsAttachedToStreamingManager() const { return !!(bAttachedToStreamingManagerAsStatic | bAttachedToStreamingManagerAsDynamic); }
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Collision)
    uint8 bAlwaysCreatePhysicsState:1;
 
    UFUNCTION(BlueprintGetter)
    bool GetGenerateOverlapEvents() const;
 
    UFUNCTION(BlueprintSetter)
    ENGINE_API void SetGenerateOverlapEvents(bool bInGenerateOverlapEvents);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Components")
    ENGINE_API void SetLightingChannels(bool bChannel0, bool bChannel1, bool bChannel2);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Lighting")
    ENGINE_API void InvalidateLumenSurfaceCache();
 
private:
    UPROPERTY(EditAnywhere, BlueprintGetter = GetGenerateOverlapEvents, BlueprintSetter = SetGenerateOverlapEvents, Category = Collision)
    uint8 bGenerateOverlapEvents : 1;
 
public:
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=Collision)
    uint8 bMultiBodyOverlap:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=Collision)
    uint8 bTraceComplexOnMove:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=Collision)
    uint8 bReturnMaterialOnMove:1;
 
    UPROPERTY()
    uint8 bUseViewOwnerDepthPriorityGroup:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=LOD)
    uint8 bAllowCullDistanceVolume:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Rendering)
    uint8 bVisibleInReflectionCaptures:1;
    
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Rendering)
    uint8 bVisibleInRealTimeSkyCaptures :1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Rendering)
    uint8 bVisibleInRayTracing : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Rendering)
    uint8 bRenderInMainPass:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Rendering, meta = (EditCondition = "!bRenderInMainPass"))
    uint8 bRenderInDepthPass:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Rendering)
    uint8 bReceivesDecals:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Rendering, Interp)
    uint8 bHoldout : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Rendering, meta=(EditCondition="FirstPersonPrimitiveType != EFirstPersonPrimitiveType::WorldSpaceRepresentation"))
    uint8 bOwnerNoSee:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Rendering)
    uint8 bOnlyOwnerSee:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Rendering)
    uint8 bTreatAsBackgroundForOcclusion:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Rendering)
    uint8 bUseAsOccluder:1;
 
    UPROPERTY()
    uint8 bSelectable:1;
 
    UPROPERTY()
    uint8 bWantsEditorEffects:1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Collision)
    uint8 bConsiderForActorPlacementWhenHidden:1;
#endif //WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=TextureStreaming)
    uint8 bForceMipStreaming:1;
 
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, AdvancedDisplay, Category=Rendering)
    uint8 bHasPerInstanceHitProxies:1;
 
    // Lighting flags
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Lighting, Interp)
    uint8 CastShadow:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Lighting, AdvancedDisplay)
    uint8 bEmissiveLightSource:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Lighting, AdvancedDisplay, Interp)
    uint8 bAffectDynamicIndirectLighting:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting, meta=(EditCondition="bAffectDynamicIndirectLighting", DisplayName = "Affect Indirect Lighting While Hidden"), Interp)
    uint8 bAffectIndirectLightingWhileHidden:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Lighting, AdvancedDisplay)
    uint8 bAffectDistanceFieldLighting:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Lighting, AdvancedDisplay, meta=(EditCondition="CastShadow && (FirstPersonPrimitiveType != EFirstPersonPrimitiveType::FirstPerson)", DisplayName = "Dynamic Shadow"))
    uint8 bCastDynamicShadow:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Lighting, AdvancedDisplay, meta=(EditCondition="CastShadow && (FirstPersonPrimitiveType != EFirstPersonPrimitiveType::FirstPerson)", DisplayName = "Static Shadow"))
    uint8 bCastStaticShadow:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting, meta=(EditCondition="CastShadow && (FirstPersonPrimitiveType != EFirstPersonPrimitiveType::FirstPerson)", DisplayName = "Volumetric Translucent Shadow"))
    uint8 bCastVolumetricTranslucentShadow:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Lighting, AdvancedDisplay, meta=(EditCondition="CastShadow", DisplayName = "Contact Shadow"))
    uint8 bCastContactShadow:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting, meta=(EditCondition="CastShadow"))
    uint8 bSelfShadowOnly:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting, meta=(EditCondition="CastShadow && (FirstPersonPrimitiveType != EFirstPersonPrimitiveType::FirstPerson)", DisplayName = "Far Shadow"))
    uint8 bCastFarShadow:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting, meta=(EditCondition="CastShadow", DisplayName = "Dynamic Inset Shadow"))
    uint8 bCastInsetShadow:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting, meta=(EditCondition="CastShadow"))
    uint8 bCastCinematicShadow:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting, meta=(EditCondition="CastShadow && (FirstPersonPrimitiveType != EFirstPersonPrimitiveType::WorldSpaceRepresentation)", DisplayName = "Hidden Shadow"), Interp)
    uint8 bCastHiddenShadow:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting, meta=(EditCondition="CastShadow", DisplayName = "Shadow Two Sided"))
    uint8 bCastShadowAsTwoSided:1;
 
    UPROPERTY()
    uint8 bLightAsIfStatic_DEPRECATED:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting)
    uint8 bLightAttachmentsAsGroup:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting)
    uint8 bExcludeFromLightAttachmentGroup :1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Mobile, meta = (DisplayName = "Receive CSM Shadows"))
    uint8 bReceiveMobileCSMShadows : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting)
    uint8 bSingleSampleShadowFromStationaryLights:1;
 
    // Physics
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Physics)
    uint8 bIgnoreRadialImpulse:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Physics)
    uint8 bIgnoreRadialForce:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Physics)
    uint8 bApplyImpulseOnDamage : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Physics)
    uint8 bReplicatePhysicsToAutonomousProxy : 1;
 
    // Navigation
 
    UPROPERTY(EditAnywhere, Category = Navigation)
    uint8 bFillCollisionUnderneathForNavmesh:1;
 
    UPROPERTY(EditAnywhere, Category = Navigation)
    uint8 bRasterizeAsFilledConvexVolume:1;
 
    // General flags.
    
    UPROPERTY()
    uint8 AlwaysLoadOnClient:1;
 
    UPROPERTY()
    uint8 AlwaysLoadOnServer:1;
 
    UPROPERTY()
    uint8 bUseEditorCompositing:1;
 
    UPROPERTY(Transient, DuplicateTransient)
    uint8 bIsBeingMovedByEditor:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Rendering, meta=(DisplayName = "Render CustomDepth Pass"))
    uint8 bRenderCustomDepth:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Rendering, meta = (DisplayName = "Visible In Scene Capture Only", ToolTip = "When true, will only be visible in Scene Capture"))
    uint8 bVisibleInSceneCaptureOnly : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Rendering, meta = (DisplayName = "Hidden In Scene Capture", ToolTip = "When true, will not be captured by Scene Capture"))
    uint8 bHiddenInSceneCapture : 1;
 
    UPROPERTY()
    uint8 bRayTracingFarField : 1;
 
    UPROPERTY(Experimental)
    uint8 bLumenHeightfield : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Rendering)
    EFirstPersonPrimitiveType FirstPersonPrimitiveType;
 
protected:
    uint8 bCachedAllCollideableDescendantsRelative : 1;
 
    UPROPERTY()
    uint8 bHasNoStreamableTextures : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Lighting, AdvancedDisplay, meta=(
        DisplayName = "Static When Not Moveable",
        ToolTip = "When false, the underlying physics body will contain all sim data (mass, inertia tensor, etc) even if mobility is not set to Moveable"))
    uint8 bStaticWhenNotMoveable:1;
 
    uint8 bIgnoreBoundsForEditorFocus : 1;
 
public:
#if UE_WITH_PSO_PRECACHING
    EPSOPrecachePriority PSOPrecacheRequestPriority : 2;
    static_assert((int)EPSOPrecachePriority::Highest < 1 << 2);
#endif
 
#if WITH_EDITOR
    uint8 bAlwaysAllowTranslucentSelect : 1;
 
    uint8 SelectionOutlineColorIndex;
 
    FColor OverlayColor;
#endif
 
    UPROPERTY()
    TEnumAsByte<EHasCustomNavigableGeometry::Type> bHasCustomNavigableGeometry;
 
public:
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TEnumAsByte<enum EHitProxyPriority> HitProxyPriority;
 
    UE_DEPRECATED(5.2, "Use SetExcludedFromHLODLevel/IsExcludedFromHLODLevel")
    UPROPERTY(BlueprintReadWrite, Category = HLOD, BlueprintGetter=GetExcludeForSpecificHLODLevels, BlueprintSetter=SetExcludeForSpecificHLODLevels, meta = (DeprecatedProperty, DeprecationMessage = "WARNING: This property has been deprecated, use the SetExcludedFromHLODLevel/IsExcludedFromHLODLevel functions instead"))
    TArray<int32> ExcludeForSpecificHLODLevels_DEPRECATED;
#endif
 
    UFUNCTION(BlueprintCallable, Category = "HLOD", meta = (DisplayName="Is Excluded From HLOD Level"))
    ENGINE_API bool IsExcludedFromHLODLevel(EHLODLevelExclusion HLODLevel) const;
 
    UFUNCTION(BlueprintCallable, Category = "HLOD", meta = (DisplayName = "Set Excluded From HLOD Level"))
    ENGINE_API void SetExcludedFromHLODLevel(EHLODLevelExclusion HLODLevel, bool bExcluded);
 
#if WITH_EDITOR
    ENGINE_API virtual void ComputeHLODHash(class FHLODHashBuilder& HashBuilder) const override;
#endif
 
private:
    UE_DEPRECATED("5.2", "Use SetExcludedFromHLODLevel instead")
    UFUNCTION(BlueprintCallable, BlueprintSetter, Category = "HLOD", meta = (BlueprintInternalUseOnly="true"))
    ENGINE_API void SetExcludeForSpecificHLODLevels(const TArray<int32>& InExcludeForSpecificHLODLevels);
 
    UE_DEPRECATED("5.2", "Use IsExcludedFromHLODLevel instead")
    UFUNCTION(BlueprintCallable, BlueprintGetter, Category = "HLOD", meta = (BlueprintInternalUseOnly="true"))
    ENGINE_API TArray<int32> GetExcludeForSpecificHLODLevels() const;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TEnumAsByte<enum ECanBeCharacterBase> CanBeCharacterBase_DEPRECATED;
 
    UPROPERTY()
    uint8 bUseMaxLODAsImposter_DEPRECATED : 1;
 
    UPROPERTY()
    uint8 bBatchImpostersAsInstances_DEPRECATED : 1;
#endif
 
    FMaskFilter MoveIgnoreMask;
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Collision)
    TEnumAsByte<enum ECanBeCharacterBase> CanCharacterStepUpOn;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting)
    FLightingChannels LightingChannels;
 
#if UE_WITH_PSO_PRECACHING 
    TArray<FMaterialPSOPrecacheRequestID> MaterialPSOPrecacheRequestIDs;
    std::atomic<int> LatestPSOPrecacheJobSetCompleted = 0;
    int32 LatestPSOPrecacheJobSet = 0;
    uint8 bPSOPrecacheCalled : 1;
#endif
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = RayTracing, meta = (DisplayAfter="RayTracingGroupId"))
    ERayTracingGroupCullingPriority RayTracingGroupCullingPriority;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = "Rendering", meta = (editcondition = "bRenderCustomDepth", DisplayAfter="CustomDepthStencilValue"))
    ERendererStencilMask CustomDepthStencilWriteMask;
 
private:
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = HLOD, meta = (Bitmask, BitmaskEnum = "/Script/Engine.EHLODLevelExclusion", DisplayName = "Exclude from HLOD Levels", DisplayAfter = "bEnableAutoLODGeneration", EditConditionHides, EditCondition = "AllowHLODLevelsExclusion()"))
    uint8 ExcludeFromHLODLevels;
 
public:
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = RayTracing)
    int32 RayTracingGroupId;
 
    UPROPERTY()
    int32 VisibilityId=0;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Rendering,  meta=(UIMin = "0", UIMax = "255", editcondition = "bRenderCustomDepth", DisplayName = "CustomDepth Stencil Value"))
    int32 CustomDepthStencilValue;
 
private:
 
    UPROPERTY(EditAnywhere, Category=Rendering, meta = (DisplayName = "Custom Primitive Data Defaults"))
    FCustomPrimitiveData CustomPrimitiveData;
 
    UPROPERTY(Transient)
    FCustomPrimitiveData CustomPrimitiveDataInternal;
 
    TOptional<FBodyInstance::FAsyncTermBodyPayload> AsyncTermBodyPayload;
    
public:
 
    FPhysScene* DeferredCreatePhysicsStateScene;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, AdvancedDisplay, Category=Rendering)
    int32 TranslucencySortPriority;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, AdvancedDisplay, Category = Rendering)
    float TranslucencySortDistanceOffset = 0.0f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = VirtualTexture, meta = (DisplayName = "Draw in Virtual Textures"))
    TArray<TObjectPtr<URuntimeVirtualTexture>> RuntimeVirtualTextures;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = VirtualTexture, meta = (DisplayName = "Virtual Texture LOD Bias", UIMin = "-7", UIMax = "8"))
    int8 VirtualTextureLodBias = 0;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = VirtualTexture, meta = (DisplayName = "Virtual Texture Skip Mips", UIMin = "0", UIMax = "7"))
    int8 VirtualTextureCullMips = 0;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = VirtualTexture, meta = (UIMin = "0", UIMax = "7"))
    int8 VirtualTextureMinCoverage = 0;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = VirtualTexture, meta = (DisplayName = "Draw in Main Pass"))
    ERuntimeVirtualTextureMainPassType VirtualTextureRenderPassType = ERuntimeVirtualTextureMainPassType::Exclusive;
 
    virtual TArray<URuntimeVirtualTexture*> const& GetRuntimeVirtualTextures() const { return RuntimeVirtualTextures; }
    virtual ERuntimeVirtualTextureMainPassType GetVirtualTextureRenderPassType() const { return VirtualTextureRenderPassType; }
    virtual float GetVirtualTextureMainPassMaxDrawDistance() const { return 0.f; }
    
    FPrimitiveComponentId GetPrimitiveSceneId() const { return SceneData.PrimitiveSceneId; }
    
    ENGINE_API virtual void BeginPlay() override;
 
protected:
    ENGINE_API virtual bool AreAllCollideableDescendantsRelative(bool bAllowCachedValue = true) const;
 
    float LastCheckedAllCollideableDescendantsTime;
 
private:
    
    float OcclusionBoundsSlack;
 
public:
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category=Rendering, meta=(UIMin = "1", UIMax = "10.0"))
    float BoundsScale;
 
    UE_DECLARE_COMPONENT_ACTOR_INTERFACE(PrimitiveComponent)
 
private:
    
    FPrimitiveSceneInfoData SceneData;
 
#if MESH_DRAW_COMMAND_STATS
    FName MeshDrawCommandStatsCategory;
#endif
 
    friend class FPrimitiveSceneInfo;
    friend struct FPrimitiveSceneInfoAdapter;
 
public: 
 
    FPrimitiveSceneInfoData& GetSceneData() { return SceneData; }
    FThreadSafeCounter* GetAttachmentCounter() { return &GetSceneData().AttachmentCounter; }
 
    ENGINE_API int32 GetRayTracingGroupId() const;
 
    UFUNCTION(Category = "Rendering", BlueprintCallable, meta=(DisplayName="Was Component Recently Rendered", Keywords="scene visible"))
    ENGINE_API bool WasRecentlyRendered(float Tolerance = 0.2f) const;
 
    ENGINE_API void SetLastRenderTime(float InLastRenderTime);
 
    ENGINE_API float GetLastRenderTime() const;
    ENGINE_API float GetLastRenderTimeOnScreen() const;
 
#if MESH_DRAW_COMMAND_STATS
    ENGINE_API void SetMeshDrawCommandStatsCategory(FName StatsCategory);
    FName GetMeshDrawCommandStatsCategory() const;
#else
    void SetMeshDrawCommandStatsCategory(FName StatsCategory) {}
#endif
 
    ENGINE_API virtual void SetupPrecachePSOParams(FPSOPrecacheParams& Params);
 
    virtual void CollectPSOPrecacheData(const FPSOPrecacheParams& BasePrecachePSOParams, FMaterialInterfacePSOPrecacheParamsList& OutParams) {}
 
    ENGINE_API virtual void PrecachePSOs() override;
 
    ENGINE_API void RequestRecreateRenderStateWhenPSOPrecacheFinished(const FGraphEventArray& PSOPrecacheCompileEvents);
 
    ENGINE_API bool IsPSOPrecaching() const;
 
    ENGINE_API bool ShouldRenderProxyFallbackToDefaultMaterial() const;
 
    ENGINE_API bool CheckPSOPrecachingAndBoostPriority(EPSOPrecachePriority PSOPrecachePriority = EPSOPrecachePriority::High);
 
protected:
 
    UE_DEPRECATED(5.7, "Please use GetUsedMaterialPropertyDesc with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    ENGINE_API FPrimitiveMaterialPropertyDescriptor GetUsedMaterialPropertyDesc(ERHIFeatureLevel::Type FeatureLevel) const;
    ENGINE_API FPrimitiveMaterialPropertyDescriptor GetUsedMaterialPropertyDesc(EShaderPlatform InShaderPlatform) const;
 
    ENGINE_API virtual bool UsePSOPrecacheRenderProxyDelay() const;
 
public:
 
    UPROPERTY(Transient, DuplicateTransient)
    TArray<TObjectPtr<AActor>> MoveIgnoreActors;
 
    UFUNCTION(BlueprintCallable, Category = "Collision", meta=(Keywords="Move MoveIgnore", UnsafeDuringActorConstruction="true"))
    ENGINE_API void IgnoreActorWhenMoving(AActor* Actor, bool bShouldIgnore);
 
    UFUNCTION(BlueprintCallable, meta=(DisplayName="Get Move Ignore Actors", UnsafeDuringActorConstruction="true"), Category = "Collision")
    ENGINE_API TArray<AActor*> CopyArrayOfMoveIgnoreActors();
 
    const TArray<AActor*>& GetMoveIgnoreActors() const { return MoveIgnoreActors; }
 
    UFUNCTION(BlueprintCallable, Category = "Collision", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API void ClearMoveIgnoreActors();
 
    UPROPERTY(Transient, DuplicateTransient)
    TArray<TObjectPtr<UPrimitiveComponent>> MoveIgnoreComponents;
 
    UFUNCTION(BlueprintCallable, Category = "Collision", meta=(Keywords="Move MoveIgnore", UnsafeDuringActorConstruction="true"))
    ENGINE_API void IgnoreComponentWhenMoving(UPrimitiveComponent* Component, bool bShouldIgnore);
 
    UFUNCTION(BlueprintCallable, meta=(DisplayName="Get Move Ignore Components", UnsafeDuringActorConstruction="true"), Category = "Collision")
    ENGINE_API TArray<UPrimitiveComponent*> CopyArrayOfMoveIgnoreComponents();
 
    const TArray<UPrimitiveComponent*>& GetMoveIgnoreComponents() const { return MoveIgnoreComponents; }
 
    UFUNCTION(BlueprintCallable, Category = "Collision", meta=(UnsafeDuringActorConstruction="true"))
    void ClearMoveIgnoreComponents() { MoveIgnoreComponents.Empty(); }
 
    ENGINE_API void SetMoveIgnoreMask(FMaskFilter InMoveIgnoreMask);
 
    FMaskFilter GetMoveIgnoreMask() const { return MoveIgnoreMask; }
 
    ENGINE_API virtual bool ShouldComponentIgnoreHitResult(FHitResult const& TestHit, EMoveComponentFlags MoveFlags);
 
    void SetMaskFilterOnBodyInstance(FMaskFilter InMaskFilter) { BodyInstance.SetMaskFilter(InMaskFilter); }
 
    FMaskFilter GetMaskFilterOnBodyInstance(FMaskFilter InMaskFilter) const { return BodyInstance.GetMaskFilter(); }
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API int32 GetCustomPrimitiveDataIndexForScalarParameter(FName ParameterName) const;
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API int32 GetCustomPrimitiveDataIndexForVectorParameter(FName ParameterName) const;
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API void SetScalarParameterForCustomPrimitiveData(FName ParameterName, float Value);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API void SetVectorParameterForCustomPrimitiveData(FName ParameterName, FVector4 Value);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Material")
    ENGINE_API void SetCustomPrimitiveDataFloat(int32 DataIndex, float Value);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Material")
    ENGINE_API void SetCustomPrimitiveDataVector2(int32 DataIndex, FVector2D Value);
 
    ENGINE_API void SetCustomPrimitiveDataVector2f(int32 DataIndex, FVector2f Value);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Material")
    ENGINE_API void SetCustomPrimitiveDataVector3(int32 DataIndex, FVector Value);
 
    ENGINE_API void SetCustomPrimitiveDataVector3f(int32 DataIndex, FVector3f Value);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Material")
    ENGINE_API void SetCustomPrimitiveDataVector4(int32 DataIndex, FVector4 Value);
 
    ENGINE_API void SetCustomPrimitiveDataVector4f(int32 DataIndex, FVector4f Value);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Material")
    ENGINE_API void SetCustomPrimitiveDataFloatArray(int32 DataIndex, const TArray<float>& Values);
 
    ENGINE_API void SetCustomPrimitiveDataFloatArray(int32 DataIndex, TConstArrayView<float> Values);
 
    const FCustomPrimitiveData& GetCustomPrimitiveData() const { return CustomPrimitiveDataInternal; }
 
    ENGINE_API void ResetCustomPrimitiveData();
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API void SetScalarParameterForDefaultCustomPrimitiveData(FName ParameterName, float Value);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API void SetVectorParameterForDefaultCustomPrimitiveData(FName ParameterName, FVector4 Value);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API void SetDefaultCustomPrimitiveDataFloat(int32 DataIndex, float Value);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API void SetDefaultCustomPrimitiveDataVector2(int32 DataIndex, FVector2D Value);
 
    ENGINE_API void SetDefaultCustomPrimitiveDataVector2f(int32 DataIndex, FVector2f Value);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API void SetDefaultCustomPrimitiveDataVector3(int32 DataIndex, FVector Value);
 
    ENGINE_API void SetDefaultCustomPrimitiveDataVector3f(int32 DataIndex, FVector3f Value);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API void SetDefaultCustomPrimitiveDataVector4(int32 DataIndex, FVector4 Value);
 
    ENGINE_API void SetDefaultCustomPrimitiveDataVector4f(int32 DataIndex, FVector4f Value);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Material")
    ENGINE_API void SetDefaultCustomPrimitiveDataFloatArray(int32 DataIndex, const TArray<float>& Values);
 
    ENGINE_API void SetDefaultCustomPrimitiveDataFloatArray(int32 DataIndex, TConstArrayView<float> Values);
 
    const FCustomPrimitiveData& GetDefaultCustomPrimitiveData() const { return CustomPrimitiveData; }
 
#if WITH_EDITOR
    DECLARE_DELEGATE_RetVal_OneParam( bool, FSelectionOverride, const UPrimitiveComponent* );
    FSelectionOverride SelectionOverrideDelegate;
#endif
 
protected:
 
    ENGINE_API void SetCustomPrimitiveDataInternal(int32 DataIndex, TConstArrayView<float> Values);
 
    ENGINE_API void SetDefaultCustomPrimitiveData(int32 DataIndex, TConstArrayView<float> Values);
 
    TArray<FOverlapInfo> OverlappingComponents;
 
public:
    template<typename AllocatorType>
    bool ConvertSweptOverlapsToCurrentOverlaps(TArray<FOverlapInfo, AllocatorType>& OutOverlapsAtEndLocation, const TOverlapArrayView& SweptOverlaps, int32 SweptOverlapsIndex, const FVector& EndLocation, const FQuat& EndRotationQuat);
 
    template<typename AllocatorType>
    bool ConvertRotationOverlapsToCurrentOverlaps(TArray<FOverlapInfo, AllocatorType>& OutOverlapsAtEndLocation, const TOverlapArrayView& CurrentOverlaps);
 
private:
    template<typename AllocatorType>
    bool GetOverlapsWithActor_Template(const AActor* Actor, TArray<FOverlapInfo, AllocatorType>& OutOverlaps) const;
 
    // FScopedMovementUpdate needs access to the above two functions.
    friend FScopedMovementUpdate;
 
public:
    ENGINE_API void BeginComponentOverlap(const FOverlapInfo& OtherOverlap, bool bDoNotifies);
    
    ENGINE_API void EndComponentOverlap(const FOverlapInfo& OtherOverlap, bool bDoNotifies=true, bool bSkipNotifySelf=false);
 
    UFUNCTION(BlueprintPure, Category="Collision", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API bool IsOverlappingComponent(const UPrimitiveComponent* OtherComp) const;
    
    ENGINE_API bool IsOverlappingComponent(const FOverlapInfo& Overlap) const;
 
    UFUNCTION(BlueprintPure, Category="Collision", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API bool IsOverlappingActor(const AActor* Other) const;
 
    ENGINE_API bool GetOverlapsWithActor(const AActor* Actor, TArray<FOverlapInfo>& OutOverlaps) const;
 
    UFUNCTION(BlueprintPure, Category="Collision", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API void GetOverlappingActors(TArray<AActor*>& OverlappingActors, TSubclassOf<AActor> ClassFilter=nullptr) const;
 
    ENGINE_API void GetOverlappingActors(TSet<AActor*>& OverlappingActors, TSubclassOf<AActor> ClassFilter=nullptr) const;
 
    UFUNCTION(BlueprintPure, Category="Collision", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API void GetOverlappingComponents(TArray<UPrimitiveComponent*>& OutOverlappingComponents) const;
 
    ENGINE_API void GetOverlappingComponents(TSet<UPrimitiveComponent*>& OutOverlappingComponents) const;
 
    const TArray<FOverlapInfo>& GetOverlapInfos() const;
 
    ENGINE_API virtual bool UpdateOverlapsImpl(const TOverlapArrayView* NewPendingOverlaps=nullptr, bool bDoNotifies=true, const TOverlapArrayView* OverlapsAtEndLocation=nullptr) override;
 
    UFUNCTION(BlueprintCallable, Category = "Editor")
    virtual bool GetIgnoreBoundsForEditorFocus() const { return bIgnoreBoundsForEditorFocus; }
    
    UFUNCTION(BlueprintCallable, Category = "Editor")
    void SetIgnoreBoundsForEditorFocus(bool bIgnore) { bIgnoreBoundsForEditorFocus = bIgnore; }
 
    ENGINE_API virtual void UpdatePhysicsVolume( bool bTriggerNotifiers ) override;
 
    bool ComponentOverlapMulti(TArray<struct FOverlapResult>& OutOverlaps, const class UWorld* InWorld, const FVector& Pos, const FQuat& Rot, ECollisionChannel TestChannel, const struct FComponentQueryParams& Params = FComponentQueryParams::DefaultComponentQueryParams, const struct FCollisionObjectQueryParams& ObjectQueryParams = FCollisionObjectQueryParams::DefaultObjectQueryParam) const;
    bool ComponentOverlapMulti(TArray<struct FOverlapResult>& OutOverlaps, const class UWorld* InWorld, const FVector& Pos, const FRotator& Rot, ECollisionChannel TestChannel, const struct FComponentQueryParams& Params = FComponentQueryParams::DefaultComponentQueryParams, const struct FCollisionObjectQueryParams& ObjectQueryParams = FCollisionObjectQueryParams::DefaultObjectQueryParam) const;
 
    ENGINE_API const UPrimitiveComponent* GetLightingAttachmentRoot() const;
 
protected:
    ENGINE_API virtual bool ComponentOverlapMultiImpl(TArray<struct FOverlapResult>& OutOverlaps, const class UWorld* InWorld, const FVector& Pos, const FQuat& Rot, ECollisionChannel TestChannel, const struct FComponentQueryParams& Params, const struct FCollisionObjectQueryParams& ObjectQueryParams = FCollisionObjectQueryParams::DefaultObjectQueryParam) const;
 
public:
    // Internal physics engine data.
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Collision, meta=(ShowOnlyInnerProperties, SkipUCSModifiedProperties))
    FBodyInstance BodyInstance;
 
    UPROPERTY(BlueprintAssignable, Category="Collision")
    FComponentHitSignature OnComponentHit;
 
    UPROPERTY(BlueprintAssignable, Category="Collision")
    FComponentBeginOverlapSignature OnComponentBeginOverlap;
 
    UPROPERTY(BlueprintAssignable, Category="Collision")
    FComponentEndOverlapSignature OnComponentEndOverlap;
 
    UPROPERTY(BlueprintAssignable, Category="Collision")
    FComponentWakeSignature OnComponentWake;
 
    UPROPERTY(BlueprintAssignable, Category = "Collision")
    FComponentSleepSignature OnComponentSleep;
 
    FComponentCollisionSettingsChangedSignature OnComponentCollisionSettingsChangedEvent;
 
    UPROPERTY(BlueprintAssignable, Category = "Physics", TextExportTransient)
    FComponentPhysicsStateChanged OnComponentPhysicsStateChanged;
 
    UPROPERTY(BlueprintAssignable, Category="Input|Mouse Input")
    FComponentBeginCursorOverSignature OnBeginCursorOver;
         
    UPROPERTY(BlueprintAssignable, Category="Input|Mouse Input")
    FComponentEndCursorOverSignature OnEndCursorOver;
 
    UPROPERTY(BlueprintAssignable, Category="Input|Mouse Input")
    FComponentOnClickedSignature OnClicked;
 
    UPROPERTY(BlueprintAssignable, Category="Input|Mouse Input")
    FComponentOnReleasedSignature OnReleased;
         
    UPROPERTY(BlueprintAssignable, Category="Input|Touch Input")
    FComponentOnInputTouchBeginSignature OnInputTouchBegin;
 
    UPROPERTY(BlueprintAssignable, Category="Input|Touch Input")
    FComponentOnInputTouchEndSignature OnInputTouchEnd;
 
    UPROPERTY(BlueprintAssignable, Category="Input|Touch Input")
    FComponentBeginTouchOverSignature OnInputTouchEnter;
 
    UPROPERTY(BlueprintAssignable, Category="Input|Touch Input")
    FComponentEndTouchOverSignature OnInputTouchLeave;
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetBoundsScale(float NewBoundsScale=1.f);
 
    UFUNCTION(BlueprintPure, Category="Rendering|Material")
    ENGINE_API virtual class UMaterialInterface* GetMaterial(int32 ElementIndex) const;
 
#if WITH_EDITOR
    UFUNCTION(BlueprintPure, Category = "Rendering|Material")
    virtual class UMaterialInterface* GetEditorMaterial(int32 ElementIndex) const
    {
        return GetMaterial(ElementIndex);
    }
#endif
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API virtual int32 GetMaterialIndex(FName MaterialSlotName) const;
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API virtual TArray<FName> GetMaterialSlotNames() const;
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API virtual bool IsMaterialSlotNameValid(FName MaterialSlotName) const;
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API virtual class UMaterialInterface* GetMaterialByName(FName MaterialSlotName) const;
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Material")
    ENGINE_API virtual void SetMaterial(int32 ElementIndex, class UMaterialInterface* Material);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API virtual void SetMaterialByName(FName MaterialSlotName, class UMaterialInterface* Material);
 
    UFUNCTION(BlueprintCallable, meta=(DisplayName = "CreateMIDForElement", DeprecatedFunction, DeprecationMessage="Use CreateDynamicMaterialInstance instead."), Category="Rendering|Material")
    ENGINE_API virtual class UMaterialInstanceDynamic* CreateAndSetMaterialInstanceDynamic(int32 ElementIndex);
 
    UFUNCTION(BlueprintCallable, meta=(DisplayName = "CreateMIDForElementFromMaterial", DeprecatedFunction, DeprecationMessage="Use CreateDynamicMaterialInstance instead."), Category="Rendering|Material")
    ENGINE_API virtual class UMaterialInstanceDynamic* CreateAndSetMaterialInstanceDynamicFromMaterial(int32 ElementIndex, class UMaterialInterface* Parent);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Material")
    ENGINE_API virtual class UMaterialInstanceDynamic* CreateDynamicMaterialInstance(int32 ElementIndex, class UMaterialInterface* SourceMaterial = NULL, FName OptionalName = NAME_None);
 
    UFUNCTION(BlueprintPure, Category = "Rendering|Material")
    ENGINE_API virtual UMaterialInterface* GetMaterialFromCollisionFaceIndex(int32 FaceIndex, int32& SectionIndex) const;
 
    UFUNCTION(BlueprintPure, Category="Physics")
    ENGINE_API const struct FWalkableSlopeOverride& GetWalkableSlopeOverride() const;
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API virtual void SetWalkableSlopeOverride(const FWalkableSlopeOverride& NewOverride);
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API virtual void SetSimulatePhysics(bool bSimulate);
 
    /*
     *  
     */
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API void SetStaticWhenNotMoveable(bool bInStaticWhenNotMoveable);
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    bool GetStaticWhenNotMoveable() const { return bStaticWhenNotMoveable; }
 
    ENGINE_API virtual bool CanEditSimulatePhysics();
 
    UFUNCTION(BlueprintCallable, meta = (DisplayName = "Set Constraint Mode", Keywords = "set locked axis constraint physics"), Category = Physics)
    ENGINE_API virtual void SetConstraintMode(EDOFMode::Type ConstraintMode);
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void AddImpulse(FVector Impulse, FName BoneName = NAME_None, bool bVelChange = false);
 
    UFUNCTION(BlueprintCallable, Category = "Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void AddAngularImpulseInRadians(FVector Impulse, FName BoneName = NAME_None, bool bVelChange = false);
 
    UFUNCTION(BlueprintCallable, Category = "Physics", meta=(UnsafeDuringActorConstruction="true"))
    void AddAngularImpulseInDegrees(FVector Impulse, FName BoneName = NAME_None, bool bVelChange = false)
    {
        AddAngularImpulseInRadians(FMath::DegreesToRadians(Impulse), BoneName, bVelChange);
    }
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void AddImpulseAtLocation(FVector Impulse, FVector Location, FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category = "Physics", meta = (UnsafeDuringActorConstruction = "true"))
    ENGINE_API virtual void AddVelocityChangeImpulseAtLocation(FVector Impulse, FVector Location, FName BoneName = NAME_None);
 
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void AddRadialImpulse(FVector Origin, float Radius, float Strength, enum ERadialImpulseFalloff Falloff, bool bVelChange = false);
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void AddForce(FVector Force, FName BoneName = NAME_None, bool bAccelChange = false);
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void AddForceAtLocation(FVector Force, FVector Location, FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void AddForceAtLocationLocal(FVector Force, FVector Location, FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void AddRadialForce(FVector Origin, float Radius, float Strength, enum ERadialImpulseFalloff Falloff, bool bAccelChange = false);
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void AddTorqueInRadians(FVector Torque, FName BoneName = NAME_None, bool bAccelChange = false);
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    void AddTorqueInDegrees(FVector Torque, FName BoneName = NAME_None, bool bAccelChange = false)
    {
        AddTorqueInRadians(FMath::DegreesToRadians(Torque), BoneName, bAccelChange);
    }
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void SetPhysicsLinearVelocity(FVector NewVel, bool bAddToCurrent = false, FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))   
    ENGINE_API FVector GetPhysicsLinearVelocity(FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category = "Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API FVector GetPhysicsLinearVelocityAtPoint(FVector Point, FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void SetAllPhysicsLinearVelocity(FVector NewVel, bool bAddToCurrent = false);
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void SetPhysicsAngularVelocityInRadians(FVector NewAngVel, bool bAddToCurrent = false, FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    void SetPhysicsAngularVelocityInDegrees(FVector NewAngVel, bool bAddToCurrent = false, FName BoneName = NAME_None)
    {
        SetPhysicsAngularVelocityInRadians(FMath::DegreesToRadians(NewAngVel), bAddToCurrent, BoneName);
    }
 
    UFUNCTION(BlueprintCallable, Category = "Physics", meta=(UnsafeDuringActorConstruction="true"))
    void SetPhysicsMaxAngularVelocityInDegrees(float NewMaxAngVel, bool bAddToCurrent = false, FName BoneName = NAME_None)
    {
        SetPhysicsMaxAngularVelocityInRadians(FMath::DegreesToRadians(NewMaxAngVel), bAddToCurrent, BoneName);
    }
 
    UFUNCTION(BlueprintCallable, Category = "Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API void SetPhysicsMaxAngularVelocityInRadians(float NewMaxAngVel, bool bAddToCurrent = false, FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))   
    FVector GetPhysicsAngularVelocityInDegrees(FName BoneName = NAME_None) const
    {
        return FMath::RadiansToDegrees(GetPhysicsAngularVelocityInRadians(BoneName));
    }
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))   
    ENGINE_API FVector GetPhysicsAngularVelocityInRadians(FName BoneName = NAME_None) const;
 
    UFUNCTION(BlueprintPure, Category = "Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API FVector GetCenterOfMass(FName BoneName = NAME_None) const;
 
    UFUNCTION(BlueprintCallable, Category = "Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API void SetCenterOfMass(FVector CenterOfMassOffset, FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void WakeRigidBody(FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API void PutRigidBodyToSleep(FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API virtual void SetNotifyRigidBodyCollision(bool bNewNotifyRigidBodyCollision);
 
    UFUNCTION(BlueprintCallable, Category="Rendering")
    ENGINE_API void SetOwnerNoSee(bool bNewOwnerNoSee);
    
    UFUNCTION(BlueprintCallable, Category="Rendering")
    ENGINE_API void SetOnlyOwnerSee(bool bNewOnlyOwnerSee);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetVisibleInRayTracing(bool bNewVisibleInRayTracing);
 
    UFUNCTION(BlueprintCallable, Category="Rendering")
    ENGINE_API void SetCastShadow(bool NewCastShadow);
 
    UFUNCTION(BlueprintCallable, Category="Rendering")
    ENGINE_API void SetEmissiveLightSource(bool NewEmissiveLightSource);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetCastHiddenShadow(bool NewCastHiddenShadow);
 
    UFUNCTION(BlueprintCallable, Category="Rendering")
    ENGINE_API void SetCastInsetShadow(UPARAM(DisplayName="CastInsetShadow") bool bInCastInsetShadow);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetCastContactShadow(UPARAM(DisplayName = "CastContactShadow") bool bInCastContactShadow);
 
    UFUNCTION(BlueprintCallable, Category="Rendering")
    ENGINE_API void SetLightAttachmentsAsGroup(UPARAM(DisplayName="LightAttachmentsAsGroup") bool bInLightAttachmentsAsGroup);
 
    UFUNCTION(BlueprintCallable, Category="Rendering")
    ENGINE_API void SetExcludeFromLightAttachmentGroup(UPARAM(DisplayName = "ExcludeFromLightAttachmentGroup") bool bInExcludeFromLightAttachmentGroup);
 
    UFUNCTION(BlueprintCallable, Category="Rendering")
    ENGINE_API void SetSingleSampleShadowFromStationaryLights(bool bNewSingleSampleShadowFromStationaryLights);
 
    UFUNCTION(BlueprintCallable, Category="Rendering")
    ENGINE_API void SetTranslucentSortPriority(int32 NewTranslucentSortPriority);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetTranslucencySortDistanceOffset(float NewTranslucencySortDistanceOffset);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetAffectDistanceFieldLighting(bool NewAffectDistanceFieldLighting);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetReceivesDecals(bool bNewReceivesDecals);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetHoldout(bool bNewHoldout);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetAffectDynamicIndirectLighting(bool bNewAffectDynamicIndirectLighting);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetAffectIndirectLightingWhileHidden(bool bNewAffectIndirectLightingWhileHidden);
 
 
    UFUNCTION(BlueprintCallable, Category="Collision")
    ENGINE_API virtual void SetCollisionEnabled(ECollisionEnabled::Type NewType);
 
    UFUNCTION(BlueprintCallable, Category="Collision")  
    ENGINE_API virtual void SetCollisionProfileName(FName InCollisionProfileName, bool bUpdateOverlaps=true);
 
    UFUNCTION(BlueprintPure, Category="Collision")
    ENGINE_API FName GetCollisionProfileName() const;
 
    UFUNCTION(BlueprintCallable, Category="Collision")  
    ENGINE_API virtual void SetCollisionObjectType(ECollisionChannel Channel);
 
    UFUNCTION(BlueprintCallable, Category="Collision", meta=(DisplayName = "Line Trace Component", ScriptName = "LineTraceComponent", bTraceComplex="true", bPersistentShowTrace="false", UnsafeDuringActorConstruction="true"))    
    ENGINE_API bool K2_LineTraceComponent(FVector TraceStart, FVector TraceEnd, bool bTraceComplex, bool bShowTrace, bool bPersistentShowTrace, FVector& HitLocation, FVector& HitNormal, FName& BoneName, FHitResult& OutHit);
 
    UFUNCTION(BlueprintCallable, Category = "Collision", meta = (DisplayName = "Sphere Trace Component", ScriptName = "SphereTraceComponent", bTraceComplex = "true", bPersistentShowTrace="false", UnsafeDuringActorConstruction = "true"))
    ENGINE_API bool K2_SphereTraceComponent(FVector TraceStart, FVector TraceEnd, float SphereRadius, bool bTraceComplex, bool bShowTrace, bool bPersistentShowTrace, FVector& HitLocation, FVector& HitNormal, FName& BoneName, FHitResult& OutHit);
 
    UFUNCTION(BlueprintCallable, Category = "Collision", meta = (DisplayName = "Box Overlap Component", ScriptName = "BoxOverlapComponent", bTraceComplex = "true", bPersistentShowTrace="false", UnsafeDuringActorConstruction = "true"))
    ENGINE_API bool K2_BoxOverlapComponent(FVector InBoxCentre, const FBox InBox, bool bTraceComplex, bool bShowTrace, bool bPersistentShowTrace, FVector& HitLocation, FVector& HitNormal, FName& BoneName, FHitResult& OutHit);
 
    UFUNCTION(BlueprintCallable, Category = "Collision", meta = (DisplayName = "Sphere Overlap Component", ScriptName = "SphereOverlapComponent", bTraceComplex = "true", bPersistentShowTrace="false", UnsafeDuringActorConstruction = "true"))
    ENGINE_API bool K2_SphereOverlapComponent(FVector InSphereCentre, float InSphereRadius, bool bTraceComplex, bool bShowTrace, bool bPersistentShowTrace, FVector& HitLocation, FVector& HitNormal, FName& BoneName, FHitResult& OutHit);
 
    UFUNCTION(BlueprintCallable, Category="Rendering")
    ENGINE_API void SetRenderCustomDepth(bool bValue);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering", meta=(UIMin = "0", UIMax = "255"))
    ENGINE_API void SetCustomDepthStencilValue(int32 Value);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetCustomDepthStencilWriteMask(ERendererStencilMask WriteMaskBit);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetRenderInMainPass(bool bValue);
    
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetRenderInDepthPass(bool bValue);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetVisibleInSceneCaptureOnly(bool bValue);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetHiddenInSceneCapture(bool bValue);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    ENGINE_API void SetFirstPersonPrimitiveType(EFirstPersonPrimitiveType Value);
 
    static ENGINE_API uint32 GlobalOverlapEventsCounter;
 
    FPrimitiveSceneProxy* SceneProxy;
 
    FPrimitiveSceneProxy* GetSceneProxy() const { check(SceneProxy == SceneData.SceneProxy); return SceneData.SceneProxy; }
 
    ENGINE_API void AssignSceneProxy(FPrimitiveSceneProxy* SceneProxy);
    ENGINE_API void ReleaseSceneProxy();
 
    bool IsAlwaysVisible() const { return SceneData.bAlwaysVisible; }
 
    FRenderCommandFence DetachFence;
 
private:
    UPROPERTY(NonPIEDuplicateTransient)
    TObjectPtr<class UPrimitiveComponent> LODParentPrimitive;
 
    /* Returns true if component can be excluded from specific HLOD levels */
    UFUNCTION()
    bool AllowHLODLevelsExclusion() const;
 
public:
 
    ENGINE_API void SetLODParentPrimitive(UPrimitiveComponent* InLODParentPrimitive);
 
    ENGINE_API UPrimitiveComponent* GetLODParentPrimitive() const;
 
#if WITH_EDITOR
    ENGINE_API virtual const bool ShouldGenerateAutoLOD(const int32 HierarchicalLevelIndex) const;
#endif
    ENGINE_API virtual bool ShouldRenderSelected() const;
 
    ENGINE_API bool GetLevelInstanceEditingState() const;
 
    ENGINE_API bool IsComponentIndividuallySelected() const;
 
    ENGINE_API bool HasStaticLighting() const;
 
    ENGINE_API bool CanSkipGetTextureStreamingRenderAssetInfo() const;
 
    virtual float GetStreamingScale() const { return 1.f; }
 
    virtual bool HasValidSettingsForStaticLighting(bool bOverlookInvalidComponents) const 
    {
        return HasStaticLighting();
    }
 
    ENGINE_API virtual bool UsesOnlyUnlitMaterials() const;
 
    ENGINE_API virtual bool GetLightMapResolution( int32& Width, int32& Height ) const;
 
    virtual int32 GetStaticLightMapResolution() const { return 0; }
 
    ENGINE_API virtual void GetLightAndShadowMapMemoryUsage( int32& LightMapMemoryUsage, int32& ShadowMapMemoryUsage ) const;
 
#if WITH_EDITOR
    virtual void GetStaticLightingInfo(struct FStaticLightingPrimitiveInfo& OutPrimitiveInfo,const TArray<class ULightComponent*>& InRelevantLights,const class FLightingBuildOptions& Options) {}
 
    virtual void AddMapBuildDataGUIDs(TSet<FGuid>& InGUIDs) const {}
 
    virtual bool RemapActorTextureStreamingBuiltDataToLevel(const class UActorTextureStreamingBuildDataComponent* InActorTextureBuildData) { return false; }
 
    virtual uint32 ComputeHashTextureStreamingBuiltData() const { return 0; }
#endif // WITH_EDITOR
 
    virtual ELightMapInteractionType GetStaticLightingType() const  { return LMIT_None; }
 
    ENGINE_API virtual void GetStreamingRenderAssetInfo(FStreamingTextureLevelContext& LevelContext, TArray<FStreamingRenderAssetPrimitiveInfo>& OutStreamingRenderAssets) const;
 
    ENGINE_API void GetStreamingRenderAssetInfoWithNULLRemoval(FStreamingTextureLevelContext& LevelContext, TArray<FStreamingRenderAssetPrimitiveInfo>& OutStreamingRenderAssets) const;
 
    ENGINE_API bool BuildTextureStreamingData(ETextureStreamingBuildType BuildType, EMaterialQualityLevel::Type QualityLevel, ERHIFeatureLevel::Type FeatureLevel, TSet<FGuid>& DependentResources);
 
    ENGINE_API virtual bool BuildTextureStreamingDataImpl(ETextureStreamingBuildType BuildType, EMaterialQualityLevel::Type QualityLevel, ERHIFeatureLevel::Type FeatureLevel, TSet<FGuid>& DependentResources, bool& bOutSupportsBuildTextureStreamingData);
 
    virtual ESceneDepthPriorityGroup GetStaticDepthPriorityGroup() const { return DepthPriorityGroup; }
 
    virtual void GetUsedMaterials(TArray<UMaterialInterface*>& OutMaterials, bool bGetDebugMaterials = false) const {}
 
    ENGINE_API virtual void GetUsedTextures(TArray<UTexture*>& OutTextures, EMaterialQualityLevel::Type QualityLevel);
 
    virtual class UBodySetup* GetBodySetup() { return NULL; }
 
    ENGINE_API void SyncComponentToRBPhysics();
    
    ENGINE_API virtual FMatrix GetRenderMatrix() const;
 
    UFUNCTION(BlueprintPure, Category="Rendering|Material")
    ENGINE_API virtual int32 GetNumMaterials() const;
    
    ENGINE_API virtual FBodyInstance* GetBodyInstance(FName BoneName = NAME_None, bool bGetWelded = true, int32 Index = INDEX_NONE) const;
 
    UFUNCTION(BlueprintPure, Category = "Physics")
        ENGINE_API FBodyInstanceAsyncPhysicsTickHandle GetBodyInstanceAsyncPhysicsTickHandle(FName BoneName = NAME_None, bool bGetWelded = true, int32 Index = -1) const;
 
    ENGINE_API virtual bool GetSquaredDistanceToCollision(const FVector& Point, float& OutSquaredDistance, FVector& OutClosestPointOnCollision) const;
 
    float GetDistanceToCollision(const FVector& Point, FVector& ClosestPointOnCollision) const 
    {
        float DistanceSqr = -1.f;
        return (GetSquaredDistanceToCollision(Point, DistanceSqr, ClosestPointOnCollision) ? FMath::Sqrt(DistanceSqr) : -1.f);
    }
 
    UFUNCTION(BlueprintCallable, Category = "Collision", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API float GetClosestPointOnCollision(const FVector& Point, FVector& OutPointOnBody, FName BoneName = NAME_None) const;
 
    virtual FPrimitiveSceneProxy* CreateSceneProxy()
    {
        return NULL;
    }
 
#if WITH_EDITOR
    virtual HHitProxy* CreateMeshHitProxy(int32 SectionIndex, int32 MaterialIndex) const
    {
        return nullptr;
    }
#endif
 
    virtual bool ShouldRecreateProxyOnUpdateTransform() const
    {
        return false;
    }
 
    virtual bool IsZeroExtent() const
    {
        return false;
    }
 
    ENGINE_API virtual void RecreateInstanceBody(int32 InstanceBodyIndex);
 
    ENGINE_API virtual void ReceiveComponentDamage(float DamageAmount, FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser);
 
    ENGINE_API virtual void WeldTo(class USceneComponent* InParent, FName InSocketName = NAME_None, bool bWeldToKinematicParent = false);
 
    ENGINE_API virtual bool WeldToImplementation(USceneComponent * InParent, FName ParentSocketName = NAME_None, bool bWeldSimulatedChild = true, bool bWeldToKinematicParent = false);
 
    ENGINE_API virtual void UnWeldFromParent();
 
    ENGINE_API virtual void UnWeldChildren();
 
    ENGINE_API virtual void GetWeldedBodies(TArray<FBodyInstance*> & OutWeldedBodies, TArray<FName> & OutLabels, bool bIncludingAutoWeld = false);
 
    ENGINE_API bool IsWelded() const;
    
    ENGINE_API virtual FTransform GetComponentTransformFromBodyInstance(FBodyInstance* UseBI);  
 
    ENGINE_API virtual bool IsShown(const FEngineShowFlags& ShowFlags) const;
 
    virtual bool SupportsWorldPositionOffsetVelocity() const { return true; }
 
#if WITH_EDITOR
    ENGINE_API virtual bool ComponentIsTouchingSelectionBox(const FBox& InSelBBox, const bool bConsiderOnlyBSP, const bool bMustEncompassEntireComponent) const;
 
    ENGINE_API virtual bool ComponentIsTouchingSelectionFrustum(const FConvexVolume& InFrustum, const bool bConsiderOnlyBSP, const bool bMustEncompassEntireComponent) const;
#endif
 
protected:
 
    friend class FStaticMeshComponentRecreateRenderStateContext;
 
    virtual bool SupportsStaticLighting() const 
    {
        return false;
    }
 
public:
#if UE_ENABLE_DEBUG_DRAWING
    ENGINE_API virtual void SendRenderDebugPhysics(FPrimitiveSceneProxy* OverrideSceneProxy = nullptr);
private:
    static ENGINE_API void BatchSendRenderDebugPhysics(TArrayView<UPrimitiveComponent*> InPrimitives);
    friend class FStaticMeshComponentBulkReregisterContext;
public:
#endif
 
    //~ Begin UActorComponent Interface
    using Super::SendRenderDynamicData_Concurrent;
    ENGINE_API virtual void CreateRenderState_Concurrent(FRegisterComponentContext* Context) override;
    ENGINE_API virtual void SendRenderTransform_Concurrent() override;
    ENGINE_API virtual void OnRegister()  override;
    ENGINE_API virtual void OnUnregister()  override;
    ENGINE_API virtual void DestroyRenderState_Concurrent() override;
    ENGINE_API virtual void OnCreatePhysicsState() override;
    ENGINE_API virtual void OnDestroyPhysicsState() override;
    ENGINE_API virtual void OnActorEnableCollisionChanged() override;
    ENGINE_API virtual void InvalidateLightingCacheDetailed(bool bInvalidateBuildEnqueuedLighting, bool bTranslationOnly) override;
    ENGINE_API virtual bool IsEditorOnly() const override;
    ENGINE_API virtual bool ShouldCreatePhysicsState() const override;
    ENGINE_API virtual bool HasValidPhysicsState() const override;
    ENGINE_API virtual TStructOnScope<FActorComponentInstanceData> GetComponentInstanceData() const override;
    ENGINE_API virtual void OnComponentDestroyed(bool bDestroyingHierarchy) override;
#if WITH_EDITOR
    ENGINE_API virtual void CheckForErrors() override;
    ENGINE_API virtual void GetActorDescProperties(FPropertyPairsMap& PropertyPairsMap) const;
#endif // WITH_EDITOR   
    //~ End UActorComponent Interface
 
    //~ Begin IAsyncPhysicsStateProcessor
    ENGINE_API virtual void OnAsyncCreatePhysicsStateEnd_GameThread() override;
    ENGINE_API virtual bool OnAsyncDestroyPhysicsState(const UE::FTimeout& Timeout) override;
    ENGINE_API virtual void OnAsyncDestroyPhysicsStateBegin_GameThread() override;
    ENGINE_API virtual void OnAsyncDestroyPhysicsStateEnd_GameThread() override;
    ENGINE_API virtual void CollectBodySetupsWithPhysicsMeshesToCreate(TSet<UBodySetup*>& OutBodySetups) const override;
    //~ End IAsyncPhysicsStateProcessor
 
protected:
    ENGINE_API virtual void UpdatePhysicsToRBChannels();
 
    ENGINE_API void SendPhysicsTransform(ETeleportType Teleport);
 
    ENGINE_API void EnsurePhysicsStateCreated();
 
    ENGINE_API void MarkChildPrimitiveComponentRenderStateDirty();
 
    ENGINE_API void ConditionalNotifyStreamingPrimitiveUpdated_Concurrent() const;
public:
 
    //~ Begin UObject Interface.
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
    ENGINE_API virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual void FinishDestroy() override;
    ENGINE_API virtual bool IsReadyForFinishDestroy() override;
    ENGINE_API virtual bool NeedsLoadForClient() const override;
    ENGINE_API virtual bool NeedsLoadForServer() const override;
#if WITH_EDITOR
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual void PostEditChangeChainProperty(FPropertyChangedChainEvent& PropertyChangedEvent) override;
    ENGINE_API virtual bool CanEditChange(const FProperty* InProperty) const override;
    ENGINE_API virtual void UpdateCollisionProfile();
    ENGINE_API virtual void PostEditImport() override;
    ENGINE_API virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
#endif // WITH_EDITOR
    //~ End UObject Interface.
 
    //~ Begin USceneComponent Interface
 
    UFUNCTION(BlueprintPure, Category="Collision")
    ENGINE_API virtual ECollisionEnabled::Type GetCollisionEnabled() const override;
 
    UFUNCTION(BlueprintPure, meta=(DisplayName="Is Collision Enabled", ScriptName="IsCollisionEnabled"), Category="Collision")
    bool K2_IsCollisionEnabled() const;
 
    UFUNCTION(BlueprintPure, meta=(DisplayName="Is Query Collision Enabled", ScriptName="IsQueryCollisionEnabled"), Category="Collision")
    bool K2_IsQueryCollisionEnabled() const;
 
    UFUNCTION(BlueprintPure, meta=(DisplayName="Is Physics Collision Enabled", ScriptName="IsPhysicsCollisionEnabled"), Category="Collision")
    bool K2_IsPhysicsCollisionEnabled() const;
 
    UFUNCTION(BlueprintPure, Category="Collision")
    ENGINE_API virtual ECollisionResponse GetCollisionResponseToChannel(ECollisionChannel Channel) const override;
 
    UFUNCTION(BlueprintPure, Category="Collision")
    ENGINE_API virtual ECollisionChannel GetCollisionObjectType() const override;
    
    ENGINE_API virtual void OnUpdateTransform(EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport = ETeleportType::None) override;
    ENGINE_API virtual void OnAttachmentChanged() override;
    ENGINE_API virtual bool IsSimulatingPhysics(FName BoneName = NAME_None) const override;
    ENGINE_API virtual bool MoveComponentImpl(const FVector& Delta, const FQuat& NewRotation, bool bSweep, FHitResult* OutHit = NULL, EMoveComponentFlags MoveFlags = MOVECOMP_NoFlags, ETeleportType Teleport = ETeleportType::None) override;
    ENGINE_API virtual bool IsWorldGeometry() const override;
    ENGINE_API virtual const FCollisionResponseContainer& GetCollisionResponseToChannels() const override;
    ENGINE_API virtual FVector GetComponentVelocity() const override;
#if WITH_EDITOR
    ENGINE_API virtual void UpdateBounds() override;
    ENGINE_API virtual const int32 GetNumUncachedStaticLightingInteractions() const override;
#endif
    //~ End USceneComponentInterface
 
    ENGINE_API void UpdateOcclusionBoundsSlack(float NewSlack);
 
    ENGINE_API void DispatchBlockingHit(AActor& OutOwner, FHitResult const& BlockingHit);
 
    ENGINE_API void DispatchWakeEvents(ESleepEvent WakeEvent, FName BoneName);
 
    ENGINE_API virtual bool ShouldDispatchWakeEvents(FName BoneName) const;
 
    ENGINE_API virtual void InitSweepCollisionParams(FCollisionQueryParams &OutParams, FCollisionResponseParams& OutResponseParam) const;
 
    ENGINE_API virtual struct FCollisionShape GetCollisionShape(float Inflation = 0.0f) const;
 
    virtual bool AreSymmetricRotations(const FQuat& A, const FQuat& B, const FVector& Scale3D) const { return A.Equals(B); }
 
    ENGINE_API virtual void PushSelectionToProxy();
 
    ENGINE_API void PushLevelInstanceEditingStateToProxy(bool bInEditingState);
 
    ENGINE_API void PushHoveredToProxy(const bool bInHovered);
 
    ENGINE_API void PushEditorVisibilityToProxy( uint64 InVisibility );
 
    virtual float GetEmissiveBoost(int32 ElementIndex) const        { return 1.0f; };
 
    virtual float GetDiffuseBoost(int32 ElementIndex) const     { return 1.0f; };
    
    virtual bool GetShadowIndirectOnly() const { return false; }
    
    virtual bool IsCompiling() const { return false; }
 
    ENGINE_API virtual void GetPrimitiveStats(FPrimitiveStats& PrimitiveStats) const;
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    ENGINE_API void PushPrimitiveColorToProxy(const FLinearColor& InPrimitiveColor);
#endif
 
#if WITH_EDITOR
    ENGINE_API virtual uint64 GetHiddenEditorViews() const;
 
    ENGINE_API void SetIsBeingMovedByEditor(bool bNewIsBeingMoved);
 
 
    ENGINE_API void SetSelectionOutlineColorIndex(uint8 SelectionOutlineColorIndex);
    
    ENGINE_API void SetOverlayColor(FColor OverlayColor);
    ENGINE_API void RemoveOverlayColor();
#endif// WITH_EDITOR
 
    ENGINE_API void ResetSceneVelocity();
 
    UFUNCTION(BlueprintCallable, Category = "Physics", meta = (UnsafeDuringActorConstruction = "true"))
    void SetAllPhysicsAngularVelocityInDegrees(const FVector& NewAngVel, bool bAddToCurrent = false)
    {
        SetAllPhysicsAngularVelocityInRadians(FMath::DegreesToRadians(NewAngVel), bAddToCurrent);
    }
 
    UFUNCTION(BlueprintCallable, Category = "Physics", meta = (UnsafeDuringActorConstruction = "true"))
    ENGINE_API virtual void SetAllPhysicsAngularVelocityInRadians(const FVector& NewAngVel, bool bAddToCurrent = false);
 
    ENGINE_API virtual void SetAllPhysicsPosition(FVector NewPos);
    
    ENGINE_API virtual void SetAllPhysicsRotation(FRotator NewRot);
 
    ENGINE_API virtual void SetAllPhysicsRotation(const FQuat& NewRot);
    
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual void WakeAllRigidBodies();
    
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API virtual void SetEnableGravity(bool bGravityEnabled);
 
    UFUNCTION(BlueprintPure, Category="Physics")
    ENGINE_API virtual bool IsGravityEnabled() const;
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API virtual void SetUpdateKinematicFromSimulation(bool bUpdateKinematicFromSimulation);
 
    UFUNCTION(BlueprintPure, Category="Physics")
    ENGINE_API virtual bool GetUpdateKinematicFromSimulation() const;
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API void SetGyroscopicTorqueEnabled(bool bInGyroscopicTorqueEnabled);
 
    UFUNCTION(BlueprintPure, Category = "Physics")
    ENGINE_API virtual bool GetGyroscopicTorqueEnabled() const;
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API virtual void SetLinearDamping(float InDamping);
 
    UFUNCTION(BlueprintPure, Category="Physics")
    ENGINE_API virtual float GetLinearDamping() const;
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API virtual void SetAngularDamping(float InDamping);
    
    UFUNCTION(BlueprintPure, Category="Physics")
    ENGINE_API virtual float GetAngularDamping() const;
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API virtual void SetMassScale(FName BoneName = NAME_None, float InMassScale = 1.f);
 
    UFUNCTION(BlueprintPure, Category = "Physics")
    ENGINE_API virtual float GetMassScale(FName BoneName = NAME_None) const;
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API virtual void SetAllMassScale(float InMassScale = 1.f);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API virtual void SetMassOverrideInKg(FName BoneName = NAME_None, float MassInKg = 1.f, bool bOverrideMass = true);
 
    UFUNCTION(BlueprintPure, Category="Physics", meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual float GetMass() const;
 
    UFUNCTION(BlueprintPure, Category = "Physics", meta =(Keywords = "physics moment of inertia tensor MOI", UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual FVector GetInertiaTensor(FName BoneName = NAME_None) const;
 
    UFUNCTION(BlueprintPure, Category = "Physics", meta = (Keywords = "physics moment of inertia tensor MOI", UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual FVector ScaleByMomentOfInertia(FVector InputVector, FName BoneName = NAME_None) const;
 
    ENGINE_API virtual float CalculateMass(FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API virtual float GetMaxDepenetrationVelocity(FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API virtual void SetMaxDepenetrationVelocity(FName BoneName = NAME_None, float InMaxDepenetrationVelocity = -1.0f);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API virtual void SetUseCCD(bool InUseCCD, FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API virtual void SetAllUseCCD(bool InUseCCD);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API virtual void SetUseMACD(bool InUseMACD, FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API virtual void SetAllUseMACD(bool InUseMACD);  
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API virtual void SetAllowPartialIslandSleep(bool InAllowPartialIslandSleep = true, FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category = "Physics")
    ENGINE_API virtual void SetAllAllowPartialIslandSleep(bool InAllowPartialIslandSleep = true);
 
    ENGINE_API virtual void PutAllRigidBodiesToSleep();
    
    ENGINE_API bool RigidBodyIsAwake(FName BoneName = NAME_None) const;
 
    UFUNCTION(BlueprintPure, Category = "Physics", meta = (Keywords = "physics asleep sleeping awake simulating", UnsafeDuringActorConstruction="true"))
    ENGINE_API virtual bool IsAnyRigidBodyAwake();
    
    UFUNCTION(BlueprintCallable, Category="Collision")
    ENGINE_API virtual void SetCollisionResponseToChannel(ECollisionChannel Channel, ECollisionResponse NewResponse);
    
    UFUNCTION(BlueprintCallable, Category="Collision")
    ENGINE_API virtual void SetCollisionResponseToAllChannels(ECollisionResponse NewResponse);
    
    ENGINE_API virtual void SetCollisionResponseToChannels(const FCollisionResponseContainer& NewReponses);
    
protected:
    ENGINE_API virtual void OnComponentCollisionSettingsChanged(bool bUpdateOverlaps=true);
 
    ENGINE_API virtual void OnGenerateOverlapEventsChanged();
 
    ENGINE_API void ClearComponentOverlaps(bool bDoNotifies, bool bSkipNotifySelf);
 
private:
    ENGINE_API void WarnInvalidPhysicsOperations_Internal(const FText& ActionText, const FBodyInstance* BodyInstanceRequiresSimulation, FName BoneName) const;
 
public:
    ENGINE_API void SetRigidBodyReplicatedTarget(FRigidBodyState& UpdatedState, const FName BoneName = NAME_None, int32 ServerFrame = 0, int32 ServerHandle = 0);
 
    UFUNCTION(BlueprintCallable, Category = Replication)
    ENGINE_API void RegisterAsFocalPointInPhysicsReplicationLOD() const;
 
    UFUNCTION(BlueprintCallable, Category = Replication)
    ENGINE_API void UnregisterAsFocalPointInPhysicsReplicationLOD() const;
 
protected:
    virtual bool CanBeUsedInPhysicsReplication(const FName BoneName = NAME_None) const { return true; }
 
public:
 
    ENGINE_API bool GetRigidBodyState(FRigidBodyState& OutState, FName BoneName = NAME_None);
 
    UFUNCTION(BlueprintCallable, Category="Physics", meta=(DisplayName="Set PhysicalMaterial Override"))
    ENGINE_API virtual void SetPhysMaterialOverride(class UPhysicalMaterial* NewPhysMaterial);
 
    ENGINE_API bool ShouldComponentAddToScene() const;
    
    UFUNCTION(BlueprintCallable, Category="LOD", meta=(DisplayName="Set Max Draw Distance"))
    ENGINE_API void SetCullDistance(float NewCullDistance);
    
    ENGINE_API void SetCachedMaxDrawDistance(const float NewCachedMaxDrawDistance);
 
    ENGINE_API void SetDepthPriorityGroup(ESceneDepthPriorityGroup NewDepthPriorityGroup);
    
    ENGINE_API void SetViewOwnerDepthPriorityGroup(
        bool bNewUseViewOwnerDepthPriorityGroup,
        ESceneDepthPriorityGroup NewViewOwnerDepthPriorityGroup
        );
    
    ENGINE_API virtual bool LineTraceComponent( FHitResult& OutHit, const FVector Start, const FVector End, const FCollisionQueryParams& Params );
 
    ENGINE_API virtual bool LineTraceComponent(FHitResult& OutHit, const FVector Start, const FVector End, ECollisionChannel TraceChannel, const struct FCollisionQueryParams& Params, const struct FCollisionResponseParams& ResponseParams, const struct FCollisionObjectQueryParams& ObjectParams);
    
    ENGINE_API virtual bool SweepComponent(FHitResult& OutHit, const FVector Start, const FVector End, const FQuat& ShapeWorldRotation, const FCollisionShape &CollisionShape, bool bTraceComplex=false);
 
    ENGINE_API virtual bool SweepComponent(FHitResult& OutHit, const FVector Start, const FVector End, const FQuat& ShapeWorldRotation, const FPhysicsGeometry& Geometry, ECollisionChannel TraceChannel, const struct FCollisionQueryParams& Params, const struct FCollisionResponseParams& ResponseParams, const struct FCollisionObjectQueryParams& ObjectParams);
 
    bool ComponentOverlapComponent(class UPrimitiveComponent* PrimComp, const FVector Pos, const FQuat& Rot, const FCollisionQueryParams& Params);
    bool ComponentOverlapComponent(class UPrimitiveComponent* PrimComp, const FVector Pos, const FRotator Rot, const FCollisionQueryParams& Params);
 
    bool ComponentOverlapComponentWithResult(const class UPrimitiveComponent* const PrimComp, const FVector& Pos, const FQuat& Rot, const FCollisionQueryParams& Params, TArray<FOverlapResult>& OutOverlap) const;
    bool ComponentOverlapComponentWithResult(const class UPrimitiveComponent* const PrimComp, const FVector& Pos, const FRotator& Rot, const FCollisionQueryParams& Params, TArray<FOverlapResult>& OutOverlap) const;
protected:
    ENGINE_API virtual bool ComponentOverlapComponentImpl(class UPrimitiveComponent* PrimComp, const FVector Pos, const FQuat& Rot, const FCollisionQueryParams& Params);
    ENGINE_API virtual bool ComponentOverlapComponentWithResultImpl(const class UPrimitiveComponent* const PrimComp, const FVector& Pos, const FQuat& Rot, const FCollisionQueryParams& Params, TArray<FOverlapResult>& OutOverlap) const;
 
public: 
    //UE_DEPRECATED(5.0, "Use the const version of OverlapComponent. This deprecation cannot be uncommented as it would produce false positives." )
    virtual bool OverlapComponent(const FVector& Pos, const FQuat& Rot, const FCollisionShape& CollisionShape) final 
    {
        return const_cast<const UPrimitiveComponent*>(this)->OverlapComponent(Pos, Rot, CollisionShape);
    }
    ENGINE_API virtual bool OverlapComponent(const FVector& Pos, const FQuat& Rot, const FCollisionShape& CollisionShape) const;
 
    ENGINE_API virtual bool OverlapComponentWithResult(const FVector& Pos, const FQuat& Rot, const FCollisionShape& CollisionShape, TArray<FOverlapResult>& OutOverlap) const;
 
    ENGINE_API virtual bool OverlapComponentWithResult(const FVector& Pos, const FQuat& Rot, const FPhysicsGeometry& Geometry, ECollisionChannel TraceChannel, const struct FCollisionQueryParams& Params, const struct FCollisionResponseParams& ResponseParams, const struct FCollisionObjectQueryParams& ObjectParams, TArray<FOverlapResult>& OutOverlap) const;
 
    ENGINE_API virtual bool ComputePenetration(FMTDResult & OutMTD, const FCollisionShape& CollisionShape, const FVector& Pos, const FQuat& Rot);
 
    UFUNCTION(BlueprintCallable, Category=Collision)
    ENGINE_API virtual bool CanCharacterStepUp(class APawn* Pawn) const;
 
    //~ Begin INavRelevantInterface Interface
    ENGINE_API virtual void GetNavigationData(FNavigationRelevantData& OutData) const override;
    ENGINE_API virtual FBox GetNavigationBounds() const override;
    ENGINE_API virtual bool IsNavigationRelevant() const override;
    ENGINE_API virtual UBodySetup* GetNavigableGeometryBodySetup() override final; // marked as final since PrimitiveComponent derived classes relies on GetBodySetup()
    ENGINE_API virtual FTransform GetNavigableGeometryTransform() const override final; // marked as final since PrimitiveComponent derived classes relies on GetComponentTransform()
 
    ENGINE_API virtual EHasCustomNavigableGeometry::Type HasCustomNavigableGeometry() const override;
 
    ENGINE_API virtual bool DoCustomNavigableGeometryExport(FNavigableGeometryExport& GeomExport) const override;
    //~ End INavRelevantInterface Interface
 
    // Returns true if we should check the GetGenerateOverlapEvents() flag when gathering overlaps, otherwise we'll always just do it.
    inline bool ShouldCheckOverlapFlagToQueueOverlaps(const UPrimitiveComponent& ThisComponent) const;
 
    ENGINE_API void SetCustomNavigableGeometry(const EHasCustomNavigableGeometry::Type InType);
 
    static ENGINE_API void DispatchMouseOverEvents(UPrimitiveComponent* CurrentComponent, UPrimitiveComponent* NewComponent);
    static ENGINE_API void DispatchTouchOverEvents(ETouchIndex::Type FingerIndex, UPrimitiveComponent* CurrentComponent, UPrimitiveComponent* NewComponent);
    ENGINE_API void DispatchOnClicked(FKey ButtonClicked = EKeys::LeftMouseButton);
    ENGINE_API void DispatchOnReleased(FKey ButtonReleased = EKeys::LeftMouseButton);
    ENGINE_API void DispatchOnInputTouchBegin(const ETouchIndex::Type Key);
    ENGINE_API void DispatchOnInputTouchEnd(const ETouchIndex::Type Key);
 
    //~ Begin IPhysicsComponent Interface.
public:
    ENGINE_API virtual Chaos::FPhysicsObject* GetPhysicsObjectById(Chaos::FPhysicsObjectId Id) const override;
    ENGINE_API virtual Chaos::FPhysicsObject* GetPhysicsObjectByName(const FName& Name) const override;
    ENGINE_API virtual TArray<Chaos::FPhysicsObject*> GetAllPhysicsObjects() const override;
    ENGINE_API virtual Chaos::FPhysicsObjectId GetIdFromGTParticle(Chaos::FGeometryParticle* Particle) const override;
    //~ End IPhysicsComponent Interface.
 
    inline bool IsStaticPhysics() const { return Mobility != EComponentMobility::Movable && bStaticWhenNotMoveable; }
 
    inline bool IsFirstPersonRelevant() const { return FirstPersonPrimitiveType != EFirstPersonPrimitiveType::None; }
protected:
 
    UFUNCTION()
    ENGINE_API virtual void HandlePostMigrationPhysicsStateChanged(UPrimitiveComponent* ChangedComponent, EComponentPhysicsStateChange StateChange);
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
 
    ENGINE_API bool CanSendMigratedPhysicsState(const FUObjectMigrationContext* MigrationContext, EObjectMigrationSendType ObjMigrationSendType) const;
 
    ENGINE_API virtual void MigratePhysicsState(FArchive& Ar) override;
    
    ENGINE_API virtual void ApplyMigratedPhysicsState(Chaos::FSerializedDataBufferPtr MigratedStateData = nullptr) override;
 
    ENGINE_API virtual void PostMigrate(const struct FUObjectMigrationContext& MigrationContext) override;
#endif
 
protected:
    void AddNavigationModifier(FNavigationRelevantData& OutData) const;
};
 
USTRUCT()
struct FPrimitiveComponentInstanceData : public FSceneComponentInstanceData
{
    GENERATED_BODY()
public:
    FPrimitiveComponentInstanceData() = default;
    ENGINE_API FPrimitiveComponentInstanceData(const UPrimitiveComponent* SourceComponent);
    virtual ~FPrimitiveComponentInstanceData() = default;
 
    ENGINE_API virtual bool ContainsData() const override;
 
    ENGINE_API virtual void ApplyToComponent(UActorComponent* Component, const ECacheApplyPhase CacheApplyPhase) override;
    ENGINE_API virtual void FindAndReplaceInstances(const TMap<UObject*, UObject*>& OldToNewInstanceMap) override;
    ENGINE_API virtual void AddReferencedObjects(FReferenceCollector& Collector) override;
 
    const FTransform& GetComponentTransform() const { return ComponentTransform; }
 
private:
    UPROPERTY()
    FTransform ComponentTransform;
 
    UPROPERTY()
    int32 VisibilityId = INDEX_NONE;
 
    UPROPERTY()
    TObjectPtr<UPrimitiveComponent> LODParent = nullptr;
 
#if WITH_EDITOR
    FColor OverlayColor;
#endif
    
};
 
 
// PrimitiveComponent inlines
 
inline bool UPrimitiveComponent::ComponentOverlapMulti(TArray<struct FOverlapResult>& OutOverlaps, const class UWorld* InWorld, const FVector& Pos, const FQuat& Rot, ECollisionChannel TestChannel, const struct FComponentQueryParams& Params, const struct FCollisionObjectQueryParams& ObjectQueryParams) const
{
    return ComponentOverlapMultiImpl(OutOverlaps, InWorld, Pos, Rot, TestChannel, Params, ObjectQueryParams);
}
 
inline bool UPrimitiveComponent::ComponentOverlapMulti(TArray<struct FOverlapResult>& OutOverlaps, const class UWorld* InWorld, const FVector& Pos, const FRotator& Rot, ECollisionChannel TestChannel, const struct FComponentQueryParams& Params, const struct FCollisionObjectQueryParams& ObjectQueryParams) const
{
    return ComponentOverlapMultiImpl(OutOverlaps, InWorld, Pos, Rot.Quaternion(), TestChannel, Params, ObjectQueryParams);
}
 
inline bool UPrimitiveComponent::ComponentOverlapComponent(class UPrimitiveComponent* PrimComp, const FVector Pos, const FQuat& Rot, const FCollisionQueryParams& Params)
{
    return ComponentOverlapComponentImpl(PrimComp, Pos, Rot, Params);
}
 
inline bool UPrimitiveComponent::ComponentOverlapComponent(class UPrimitiveComponent* PrimComp, const FVector Pos, const FRotator Rot, const FCollisionQueryParams& Params)
{
    return ComponentOverlapComponentImpl(PrimComp, Pos, Rot.Quaternion(), Params);
}
 
inline bool UPrimitiveComponent::ComponentOverlapComponentWithResult(const class UPrimitiveComponent* const PrimComp, const FVector& Pos, const FQuat& Rot, const FCollisionQueryParams& Params, TArray<FOverlapResult>& OutOverlap) const
{
    return ComponentOverlapComponentWithResultImpl(PrimComp, Pos, Rot, Params, OutOverlap);
}
 
inline bool UPrimitiveComponent::ComponentOverlapComponentWithResult(const class UPrimitiveComponent* const PrimComp, const FVector& Pos, const FRotator& Rot, const FCollisionQueryParams& Params, TArray<FOverlapResult>& OutOverlap) const
{
    return ComponentOverlapComponentWithResultImpl(PrimComp, Pos, Rot.Quaternion(), Params, OutOverlap);
}
 
inline const TArray<FOverlapInfo>& UPrimitiveComponent::GetOverlapInfos() const
{
    return OverlappingComponents;
}
 
inline bool UPrimitiveComponent::K2_IsCollisionEnabled() const
{
    return IsCollisionEnabled();
}
 
inline bool UPrimitiveComponent::K2_IsQueryCollisionEnabled() const
{
    return IsQueryCollisionEnabled();
}
 
inline bool UPrimitiveComponent::K2_IsPhysicsCollisionEnabled() const
{
    return IsPhysicsCollisionEnabled();
}
 
inline bool UPrimitiveComponent::GetGenerateOverlapEvents() const
{
    return bGenerateOverlapEvents;
}
 
inline bool UPrimitiveComponent::ShouldCheckOverlapFlagToQueueOverlaps(const UPrimitiveComponent& ThisComponent) const
{
    const FScopedMovementUpdate* CurrentUpdate = ThisComponent.GetCurrentScopedMovement();
    if (CurrentUpdate)
    {
        return CurrentUpdate->RequiresOverlapsEventFlag();
    }
    // By default we require the GetGenerateOverlapEvents() to queue up overlaps, since we require it to trigger events.
    return true;
}
 
// PrimitiveComponent templates
 
template<typename AllocatorType>
bool UPrimitiveComponent::ConvertSweptOverlapsToCurrentOverlaps(
    TArray<FOverlapInfo, AllocatorType>& OverlapsAtEndLocation, const TOverlapArrayView& SweptOverlaps, int32 SweptOverlapsIndex,
    const FVector& EndLocation, const FQuat& EndRotationQuat)
{
    checkSlow(SweptOverlapsIndex >= 0);
 
    bool bResult = false;
    const bool bForceGatherOverlaps = !ShouldCheckOverlapFlagToQueueOverlaps(*this);
    if ((GetGenerateOverlapEvents() || bForceGatherOverlaps) && PrimitiveComponentCVars::bAllowCachedOverlapsCVar)
    {
        const AActor* Actor = GetOwner();
        if (Actor && Actor->GetRootComponent() == this)
        {
            // We know we are not overlapping any new components at the end location. Children are ignored here (see note below).
            if (PrimitiveComponentCVars::bEnableFastOverlapCheck)
            {
                SCOPE_CYCLE_COUNTER(STAT_MoveComponent_FastOverlap);
 
                // Check components we hit during the sweep, keep only those still overlapping
                const FCollisionQueryParams UnusedQueryParams(NAME_None, FCollisionQueryParams::GetUnknownStatId());
                const int32 NumSweptOverlaps = SweptOverlaps.Num();
                OverlapsAtEndLocation.Reserve(OverlapsAtEndLocation.Num() + NumSweptOverlaps);
                for (int32 Index = SweptOverlapsIndex; Index < NumSweptOverlaps; ++Index)
                {
                    const FOverlapInfo& OtherOverlap = SweptOverlaps[Index];
                    UPrimitiveComponent* OtherPrimitive = OtherOverlap.OverlapInfo.GetComponent();
                    if (OtherPrimitive && (OtherPrimitive->GetGenerateOverlapEvents() || bForceGatherOverlaps))
                    {
                        if (OtherPrimitive->bMultiBodyOverlap)
                        {
                            // Not handled yet. We could do it by checking every body explicitly and track each body index in the overlap test, but this seems like a rare need.
                            return false;
                        }
                        else if (Cast<USkeletalMeshComponent>(OtherPrimitive) || Cast<USkeletalMeshComponent>(this))
                        {
                            // SkeletalMeshComponent does not support this operation, and would return false in the test when an actual query could return true.
                            return false;
                        }
                        else if (OtherPrimitive->ComponentOverlapComponent(this, EndLocation, EndRotationQuat, UnusedQueryParams))
                        {
                            OverlapsAtEndLocation.Add(OtherOverlap);
                        }
                    }
                }
 
                // Note: we don't worry about adding any child components here, because they are not included in the sweep results.
                // Children test for their own overlaps after we update our own, and we ignore children in our own update.
                checkfSlow(OverlapsAtEndLocation.FindByPredicate(FPredicateOverlapHasSameActor(*Actor)) == nullptr,
                    TEXT("Child overlaps should not be included in the SweptOverlaps() array in UPrimitiveComponent::ConvertSweptOverlapsToCurrentOverlaps()."));
 
                bResult = true;
            }
            else
            {
                if (SweptOverlaps.Num() == 0 && AreAllCollideableDescendantsRelative())
                {
                    // Add overlaps with components in this actor.
                    GetOverlapsWithActor_Template(Actor, OverlapsAtEndLocation);
                    bResult = true;
                }
            }
        }
    }
 
    return bResult;
}
 
template<typename AllocatorType>
bool UPrimitiveComponent::ConvertRotationOverlapsToCurrentOverlaps(TArray<FOverlapInfo, AllocatorType>& OutOverlapsAtEndLocation, const TOverlapArrayView& CurrentOverlaps)
{
    bool bResult = false;
    const bool bForceGatherOverlaps = !ShouldCheckOverlapFlagToQueueOverlaps(*this);
    if ((GetGenerateOverlapEvents() || bForceGatherOverlaps) && PrimitiveComponentCVars::bAllowCachedOverlapsCVar)
    {
        const AActor* Actor = GetOwner();
        if (Actor && Actor->GetRootComponent() == this)
        {
            if (PrimitiveComponentCVars::bEnableFastOverlapCheck)
            {
                // Add all current overlaps that are not children. Children test for their own overlaps after we update our own, and we ignore children in our own update.
                OutOverlapsAtEndLocation.Reserve(OutOverlapsAtEndLocation.Num() + CurrentOverlaps.Num());
                Algo::CopyIf(CurrentOverlaps, OutOverlapsAtEndLocation, FPredicateOverlapHasDifferentActor(*Actor));
                bResult = true;
            }
        }
    }
 
    return bResult;
}
 
template<typename AllocatorType>
bool UPrimitiveComponent::GetOverlapsWithActor_Template(const AActor* Actor, TArray<FOverlapInfo, AllocatorType>& OutOverlaps) const
{
    const int32 InitialCount = OutOverlaps.Num();
    if (Actor)
    {
        for (int32 OverlapIdx = 0; OverlapIdx < OverlappingComponents.Num(); ++OverlapIdx)
        {
            UPrimitiveComponent const* const PrimComp = OverlappingComponents[OverlapIdx].OverlapInfo.Component.Get();
            if (PrimComp && (PrimComp->GetOwner() == Actor))
            {
                OutOverlaps.Add(OverlappingComponents[OverlapIdx]);
            }
        }
    }
 
    return InitialCount != OutOverlaps.Num();
}
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_5
#include "InputCoreTypes.h"
#include "PSOPrecache.h"
#endif