SceneComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "EngineDefines.h"
#include "UObject/ObjectMacros.h"
#include "Math/BoxSphereBounds.h"
#include "UObject/UObjectGlobals.h"
#include "ComponentInstanceDataCache.h"
#include "Components/ActorComponent.h"
#include "TransformStateStreamHandle.h"
 
#include "SceneComponent.generated.h"
 
class AActor;
class APhysicsVolume;
class USceneComponent;
class FScopedMovementUpdate;
struct FHitResult;
struct FLevelCollection;
 
struct FOverlapInfo;
typedef TArrayView<const FOverlapInfo> TOverlapArrayView;
namespace ERHIFeatureLevel { enum Type : int; }
 
UENUM()
enum EDetailMode : int
{
    DM_Low UMETA(DisplayName="Low"),
    DM_Medium UMETA(DisplayName="Medium"),
    DM_High UMETA(DisplayName="High"),
    DM_Epic UMETA(DisplayName="Epic"),
    DM_MAX,
};
 
UENUM()
enum ERelativeTransformSpace : int
{
    RTS_World,
    RTS_Actor,
    RTS_Component,
    RTS_ParentBoneSpace,
};
 
enum EMoveComponentFlags
{
    MOVECOMP_NoFlags                            = 0x0000,   
    MOVECOMP_IgnoreBases                        = 0x0001,   
    MOVECOMP_SkipPhysicsMove                    = 0x0002,   
    MOVECOMP_NeverIgnoreBlockingOverlaps        = 0x0004,   
    MOVECOMP_DisableBlockingOverlapDispatch     = 0x0008,   
    MOVECOMP_CheckBlockingRootActorInIgnoreList = 0x0010,   
};
// Declare bitwise operators to allow EMoveComponentFlags to be combined but still retain type safety
ENUM_CLASS_FLAGS(EMoveComponentFlags);
 
#define SCENECOMPONENT_QUAT_TOLERANCE       (1.e-8f) 
#define SCENECOMPONENT_ROTATOR_TOLERANCE    (1.e-4f) 
 
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_OneParam(FPhysicsVolumeChanged, USceneComponent, PhysicsVolumeChangedDelegate, class APhysicsVolume*, NewVolume);
DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams(FIsRootComponentChanged, USceneComponent, IsRootComponentChanged, USceneComponent*, UpdatedComponent, bool, bIsRootComponent);
DECLARE_EVENT_ThreeParams(USceneComponent, FTransformUpdated, USceneComponent* /*UpdatedComponent*/, EUpdateTransformFlags /*UpdateTransformFlags*/, ETeleportType /*Teleport*/);
 
UCLASS(ClassGroup=(Utility, Common), BlueprintType, hideCategories=(Trigger, PhysicsVolume), meta=(BlueprintSpawnableComponent, IgnoreCategoryKeywordsInSubclasses, ShortTooltip="A Scene Component is a component that has a scene transform and can be attached to other scene components."), MinimalAPI)
class USceneComponent : public UActorComponent
{
    GENERATED_BODY()
 
public:
    static ENGINE_API FName GetDefaultSceneRootVariableName();
 
    ENGINE_API USceneComponent(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
 
    const FLevelCollection* CachedLevelCollection;
 
private:
    UPROPERTY(transient)
    TWeakObjectPtr<class APhysicsVolume> PhysicsVolume;
 
    UPROPERTY(ReplicatedUsing = OnRep_AttachParent)
    TObjectPtr<USceneComponent> AttachParent;
 
    UPROPERTY(ReplicatedUsing = OnRep_AttachSocketName)
    FName AttachSocketName;
 
    FName NetOldAttachSocketName;
 
    UPROPERTY(ReplicatedUsing = OnRep_AttachChildren, Transient)
    TArray<TObjectPtr<USceneComponent>> AttachChildren;
 
    UPROPERTY(Transient)
    TArray<TObjectPtr<USceneComponent>> ClientAttachedChildren;
 
    USceneComponent* NetOldAttachParent;
 
public:
    FBoxSphereBounds Bounds;
 
private:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, ReplicatedUsing=OnRep_Transform, Category = Transform, meta=(AllowPrivateAccess="true", LinearDeltaSensitivity = "1", Delta = "1.0"))
    FVector RelativeLocation;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, ReplicatedUsing=OnRep_Transform, Category=Transform, meta=(AllowPrivateAccess="true", LinearDeltaSensitivity = "1", Delta = "1.0"))
    FRotator RelativeRotation;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, ReplicatedUsing=OnRep_Transform, Category=Transform, meta=(AllowPrivateAccess="true", LinearDeltaSensitivity = "1", Delta = "0.0025"))
    FVector RelativeScale3D;
 
public:
    UPROPERTY()
    FVector ComponentVelocity;
 
private:
    UPROPERTY(Transient)
    uint8 bComponentToWorldUpdated : 1;
 
    uint8 bSkipUpdateOverlaps : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, ReplicatedUsing=OnRep_Transform, Category=Transform, meta=(AllowPrivateAccess="true"))
    uint8 bAbsoluteLocation:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, ReplicatedUsing=OnRep_Transform, Category=Transform, meta=(AllowPrivateAccess="true"))
    uint8 bAbsoluteRotation:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, ReplicatedUsing=OnRep_Transform, Category=Transform, meta=(AllowPrivateAccess="true"))
    uint8 bAbsoluteScale:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, ReplicatedUsing=OnRep_Visibility,  Category = Rendering, meta=(AllowPrivateAccess="true"))
    uint8 bVisible:1;
 
    UPROPERTY(Transient, Replicated)
    uint8 bShouldBeAttached : 1;
 
    UPROPERTY(Transient, Replicated)
    uint8 bShouldSnapLocationWhenAttached : 1;
 
    UPROPERTY(Transient, Replicated)
    uint8 bShouldSnapRotationWhenAttached : 1;
 
    UPROPERTY(Transient, Replicated)
    uint8 bShouldSnapScaleWhenAttached : 1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(Transient)
    uint8 bHiddenEdTemporary : 1;
#endif // WITH_EDITORONLY_DATA
 
    ENGINE_API void SetShouldBeAttached(bool bNewShouldBeAttached);
 
    ENGINE_API void SetShouldSnapLocationWhenAttached(bool bShouldSnapLocation);
 
    ENGINE_API void SetShouldSnapRotationWhenAttached(bool bShouldSnapRotation);
 
    ENGINE_API void SetShouldSnapScaleWhenAttached(bool bShouldSnapScale);
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintGetter=GetShouldUpdatePhysicsVolume, BlueprintSetter=SetShouldUpdatePhysicsVolume, Category=Physics)
    uint8 bShouldUpdatePhysicsVolume:1;
 
public:
    UPROPERTY(Interp, EditAnywhere, BlueprintReadOnly, Category=Rendering, meta=(SequencerTrackClass = "/Script/MovieSceneTracks.MovieSceneVisibilityTrack"))
    uint8 bHiddenInGame:1;
 
    UPROPERTY()
    uint8 bBoundsChangeTriggersStreamingDataRebuild:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category=Rendering)
    uint8 bUseAttachParentBound:1;
 
    UPROPERTY()
    uint8 bComputeFastLocalBounds : 1;
 
    UPROPERTY()
    uint8 bComputeBoundsOnceForGame : 1;
 
    UPROPERTY()
    uint8 bComputedBoundsOnceForGame : 1;
 
    ENGINE_API FBoxSphereBounds GetLocalBounds() const;
 
    ENGINE_API void ClearSkipUpdateOverlaps();
 
    bool ShouldSkipUpdateOverlaps() const
    {
        return SkipUpdateOverlapsOptimEnabled == 1 && bSkipUpdateOverlaps;
    }
 
    UFUNCTION(BlueprintGetter)
    bool GetShouldUpdatePhysicsVolume() const;
 
    UFUNCTION(BlueprintSetter)
    ENGINE_API void SetShouldUpdatePhysicsVolume(bool bInShouldUpdatePhysicsVolume);
 
    UPROPERTY()
    uint8 bIsNotRenderAttachmentRoot : 1;
 
protected:
    uint8 bDisableDetachmentUpdateOverlaps:1;
 
    uint8 bWantsOnUpdateTransform:1;
    
    uint8 bHasGroupedMoveThisFrame : 1 = false;
 
private:
    uint8 bNetUpdateTransform : 1;
    uint8 bNetUpdateAttachment : 1;
 
public:
    static ENGINE_API int32 SkipUpdateOverlapsOptimEnabled;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    uint8 bVisualizeComponent : 1;
#endif
 
    UPROPERTY(Category = Mobility, EditAnywhere, BlueprintReadOnly, Replicated)
    TEnumAsByte<EComponentMobility::Type> Mobility;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = LOD)
    TEnumAsByte<enum EDetailMode> DetailMode;
 
    UPROPERTY(BlueprintAssignable, Category=PhysicsVolume, meta=(DisplayName="Physics Volume Changed"))
    FPhysicsVolumeChanged PhysicsVolumeChangedDelegate;
 
    FIsRootComponentChanged IsRootComponentChanged;
 
#if WITH_EDITORONLY_DATA
protected:
    TObjectPtr<class UBillboardComponent> SpriteComponent;
    ENGINE_API void CreateSpriteComponent(class UTexture2D* SpriteTexture = nullptr);
    ENGINE_API void CreateSpriteComponent(class UTexture2D* SpriteTexture, bool bRegister);
#endif
 
public:
    FTransformUpdated TransformUpdated;
 
    FScopedMovementUpdate* GetCurrentScopedMovement() const;
 
    void ProcessDeferredMovementGroup(const struct FDeferredComponentMoveData& MoveData);
 
    UFUNCTION()
    static ENGINE_API bool IsGroupedComponentMovementEnabled();
 
private:
    TArray<FScopedMovementUpdate*> ScopedMovementStack;
 
    ENGINE_API void BeginScopedMovementUpdate(FScopedMovementUpdate& ScopedUpdate);
    ENGINE_API void EndScopedMovementUpdate(FScopedMovementUpdate& ScopedUpdate);
 
    void AttachToParent();
 
    FRotationConversionCache WorldRotationCache;
 
    FRotationConversionCache RelativeRotationCache;
 
    FTransform ComponentToWorld;
 
public:
    ENGINE_API void SetRelativeRotationCache(const FRotationConversionCache& InCache);
    
    inline const FRotationConversionCache& GetRelativeRotationCache() const { return RelativeRotationCache; }
 
 
#if WITH_STATE_STREAM_ACTOR
protected:
    FTransformHandle TransformHandle;
 
public:
    ENGINE_API FTransformHandle& GetOrCreateTransformHandle();
#endif
 
private:
    UFUNCTION()
    ENGINE_API void OnRep_Transform();
 
    UFUNCTION()
    ENGINE_API void OnRep_AttachParent();
 
    UFUNCTION()
    ENGINE_API void OnRep_AttachChildren();
 
    UFUNCTION()
    ENGINE_API void OnRep_AttachSocketName();
 
    UFUNCTION()
    ENGINE_API void OnRep_Visibility(bool OldValue);
 
public:
    ENGINE_API FQuat GetRelativeRotationFromWorld(const FQuat & WorldRotation);
 
    ENGINE_API void SetRelativeRotationExact(FRotator NewRotation, bool bSweep = false, FHitResult* OutSweepHitResult = nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Set Relative Location", ScriptName="SetRelativeLocation"))
    ENGINE_API void K2_SetRelativeLocation(FVector NewLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void SetRelativeLocation(FVector NewLocation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Set Relative Rotation", ScriptName="SetRelativeRotation", AdvancedDisplay="bSweep,SweepHitResult,bTeleport"))
    ENGINE_API void K2_SetRelativeRotation(FRotator NewRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void SetRelativeRotation(FRotator NewRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
    void SetRelativeRotation(const FQuat& NewRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Set Relative Transform", ScriptName="SetRelativeTransform"))
    ENGINE_API void K2_SetRelativeTransform(const FTransform& NewTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void SetRelativeTransform(const FTransform& NewTransform, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    ENGINE_API FTransform GetRelativeTransform() const;
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    ENGINE_API void ResetRelativeTransform();
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    ENGINE_API void SetRelativeScale3D(FVector NewScale3D);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Add Relative Location", ScriptName="AddRelativeLocation"))
    ENGINE_API void K2_AddRelativeLocation(FVector DeltaLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void AddRelativeLocation(FVector DeltaLocation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Add Relative Rotation", ScriptName="AddRelativeRotation", AdvancedDisplay="bSweep,SweepHitResult,bTeleport"))
    ENGINE_API void K2_AddRelativeRotation(FRotator DeltaRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void AddRelativeRotation(FRotator DeltaRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
    ENGINE_API void AddRelativeRotation(const FQuat& DeltaRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Add Local Offset", ScriptName="AddLocalOffset", Keywords="location position"))
    ENGINE_API void K2_AddLocalOffset(FVector DeltaLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void AddLocalOffset(FVector DeltaLocation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Add Local Rotation", ScriptName="AddLocalRotation", AdvancedDisplay="bSweep,SweepHitResult,bTeleport"))
    ENGINE_API void K2_AddLocalRotation(FRotator DeltaRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void AddLocalRotation(FRotator DeltaRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
    ENGINE_API void AddLocalRotation(const FQuat& DeltaRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Add Local Transform", ScriptName="AddLocalTransform"))
    ENGINE_API void K2_AddLocalTransform(const FTransform& DeltaTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void AddLocalTransform(const FTransform& DeltaTransform, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Set World Location", ScriptName="SetWorldLocation"))
    ENGINE_API void K2_SetWorldLocation(FVector NewLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void SetWorldLocation(FVector NewLocation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    /*
     * Put this component at the specified rotation in world space. Updates relative rotation to achieve the final world rotation.
     * @param NewRotation       New rotation in world space for the component.
     * @param SweepHitResult    Hit result from any impact if sweep is true.
     * @param bSweep            Whether we sweep to the destination (currently not supported for rotation).
     * @param bTeleport         Whether we teleport the physics state (if physics collision is enabled for this object).
     *                          If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
     *                          If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
     *                          If CCD is on and not teleporting, this will affect objects along the entire sweep volume.
     */
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Set World Rotation", ScriptName="SetWorldRotation", AdvancedDisplay="bSweep,SweepHitResult,bTeleport"))
    ENGINE_API void K2_SetWorldRotation(FRotator NewRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void SetWorldRotation(FRotator NewRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
    ENGINE_API void SetWorldRotation(const FQuat& NewRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    ENGINE_API void SetWorldScale3D(FVector NewScale);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Set World Transform", ScriptName="SetWorldTransform"))
    ENGINE_API void K2_SetWorldTransform(const FTransform& NewTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void SetWorldTransform(const FTransform& NewTransform, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Add World Offset", ScriptName="AddWorldOffset", Keywords="location position"))
    ENGINE_API void K2_AddWorldOffset(FVector DeltaLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void AddWorldOffset(FVector DeltaLocation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Add World Rotation", ScriptName="AddWorldRotation", AdvancedDisplay="bSweep,SweepHitResult,bTeleport"))
    ENGINE_API void K2_AddWorldRotation(FRotator DeltaRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void AddWorldRotation(FRotator DeltaRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
    ENGINE_API void AddWorldRotation(const FQuat& DeltaRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Add World Transform", ScriptName="AddWorldTransform"))
    ENGINE_API void K2_AddWorldTransform(const FTransform& DeltaTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void AddWorldTransform(const FTransform& DeltaTransform, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Add World Transform Keep Scale", ScriptName="AddWorldTransformKeepScale"))
    ENGINE_API void K2_AddWorldTransformKeepScale(const FTransform& DeltaTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void AddWorldTransformKeepScale(const FTransform& DeltaTransform, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, meta=(DisplayName = "Get World Location", ScriptName = "GetWorldLocation", Keywords = "position"), Category="Transformation")
    ENGINE_API FVector K2_GetComponentLocation() const;
 
    UFUNCTION(BlueprintCallable, meta=(DisplayName = "Get World Rotation", ScriptName = "GetWorldRotation"), Category="Transformation")
    ENGINE_API FRotator K2_GetComponentRotation() const;
    
    UFUNCTION(BlueprintCallable, meta=(DisplayName = "Get World Scale", ScriptName = "GetWorldScale"), Category="Transformation")
    ENGINE_API FVector K2_GetComponentScale() const;
 
    UFUNCTION(BlueprintCallable, meta=(DisplayName = "Get World Transform", ScriptName = "GetWorldTransform"), Category="Transformation")
    ENGINE_API FTransform K2_GetComponentToWorld() const;
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    ENGINE_API FVector GetForwardVector() const;
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    ENGINE_API FVector GetUpVector() const;
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    ENGINE_API FVector GetRightVector() const;
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API virtual bool IsSimulatingPhysics(FName BoneName = NAME_None) const;
 
    UFUNCTION(BlueprintCallable, Category="Physics")
    ENGINE_API virtual bool IsAnySimulatingPhysics() const;
 
    const TArray<TObjectPtr<USceneComponent>>& GetAttachChildren() const;
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    USceneComponent* GetAttachParent() const;
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    FName GetAttachSocketName() const;
 
    UFUNCTION(BlueprintCallable, Category="Components")
    ENGINE_API void GetParentComponents(TArray<USceneComponent*>& Parents) const;
 
    UFUNCTION(BlueprintCallable, Category="Components")
    ENGINE_API int32 GetNumChildrenComponents() const;
 
    UFUNCTION(BlueprintCallable, Category="Components")
    ENGINE_API USceneComponent* GetChildComponent(int32 ChildIndex) const;
 
    UFUNCTION(BlueprintCallable, Category="Components")
    ENGINE_API void GetChildrenComponents(bool bIncludeAllDescendants, TArray<USceneComponent*>& Children) const;
 
    ENGINE_API void SetupAttachment(USceneComponent* InParent, FName InSocketName = NAME_None);
 
    static ENGINE_API void ConvertAttachLocation(EAttachLocation::Type InAttachLocation, EAttachmentRule& InOutLocationRule, EAttachmentRule& InOutRotationRule, EAttachmentRule& InOutScaleRule);
 
    UE_DEPRECATED(4.17, "This function is deprecated, please use AttachToComponent() instead.")
    UFUNCTION(BlueprintCallable, Category = "Transformation", meta = (DeprecationMessage = "OVERRIDE BAD MESSAGE", DisplayName = "AttachTo (Deprecated)", AttachType = "KeepRelativeOffset"))
    ENGINE_API bool K2_AttachTo(USceneComponent* InParent, FName InSocketName = NAME_None, EAttachLocation::Type AttachType = EAttachLocation::KeepRelativeOffset, bool bWeldSimulatedBodies = true);
 
    ENGINE_API virtual bool AttachToComponent(USceneComponent* InParent, const FAttachmentTransformRules& AttachmentRules, FName InSocketName = NAME_None );
 
    UFUNCTION(BlueprintCallable, Category = "Transformation", meta = (DisplayName = "Attach Component To Component", ScriptName = "AttachToComponent", bWeldSimulatedBodies=true))
    ENGINE_API bool K2_AttachToComponent(USceneComponent* Parent, FName SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule, bool bWeldSimulatedBodies);
 
    UE_DEPRECATED(4.12, "This function is deprecated, please use DetachFromComponent() instead.")
    UFUNCTION(BlueprintCallable, Category = "Transformation", meta = (DisplayName = "DetachFromParent (Deprecated)"))
    ENGINE_API virtual void DetachFromParent(bool bMaintainWorldPosition = false, bool bCallModify = true);
 
    UFUNCTION(BlueprintCallable, meta = (DisplayName = "Detach From Component", ScriptName = "DetachFromComponent"), Category = "Transformation")
    ENGINE_API void K2_DetachFromComponent(EDetachmentRule LocationRule = EDetachmentRule::KeepRelative, EDetachmentRule RotationRule = EDetachmentRule::KeepRelative, EDetachmentRule ScaleRule = EDetachmentRule::KeepRelative, bool bCallModify = true);
 
    ENGINE_API virtual void DetachFromComponent(const FDetachmentTransformRules& DetachmentRules);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(Keywords="Bone"))
    ENGINE_API TArray<FName> GetAllSocketNames() const;
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(Keywords="Bone"))
    ENGINE_API virtual FTransform GetSocketTransform(FName InSocketName, ERelativeTransformSpace TransformSpace = RTS_World) const;
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(Keywords="Bone"))
    ENGINE_API virtual FVector GetSocketLocation(FName InSocketName) const;
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(Keywords="Bone"))
    ENGINE_API virtual FRotator GetSocketRotation(FName InSocketName) const;
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(Keywords="Bone", DeprecatedFunction, DeprecationMessage="Use GetSocketRotation instead, Quat is not fully supported in blueprints."))
    ENGINE_API virtual FQuat GetSocketQuaternion(FName InSocketName) const;
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(Keywords="Bone"))
    ENGINE_API virtual bool DoesSocketExist(FName InSocketName) const;
 
    ENGINE_API virtual bool HasAnySockets() const;
 
    ENGINE_API virtual void QuerySupportedSockets(TArray<FComponentSocketDescription>& OutSockets) const;
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    ENGINE_API virtual FVector GetComponentVelocity() const;
 
    UFUNCTION(BlueprintCallable, Category="Rendering")
    ENGINE_API virtual bool IsVisible() const;
 
#if WITH_EDITOR
    ENGINE_API virtual bool GetMaterialPropertyPath(int32 ElementIndex, UObject*& OutOwner, FString& OutPropertyPath, FProperty*& OutProperty);
#endif // WITH_EDITOR
 
protected:
    ENGINE_API virtual void OnVisibilityChanged();
 
    ENGINE_API virtual void OnHiddenInGameChanged();
 
private:
    enum class EVisibilityPropagation : uint8
    {
        NoPropagation, 
 
        DirtyOnly,
 
        Propagate
    };
 
    ENGINE_API void SetVisibility(bool bNewVisibility, EVisibilityPropagation PropagateToChildren);
 
    ENGINE_API void SetHiddenInGame(bool bNewHiddenInGame, EVisibilityPropagation PropagateToChildren);
 
    ENGINE_API void AppendDescendants(TArray<USceneComponent*>& Children) const;
 
public:
    UFUNCTION(BlueprintCallable, Category="Rendering")
    void SetVisibility(bool bNewVisibility, bool bPropagateToChildren=false)
    {
        SetVisibility(bNewVisibility, bPropagateToChildren ? EVisibilityPropagation::Propagate : EVisibilityPropagation::DirtyOnly);
    }
 
    UFUNCTION(BlueprintCallable, Category="Rendering")
    void ToggleVisibility(bool bPropagateToChildren = false)
    {
        SetVisibility(!GetVisibleFlag(), bPropagateToChildren);
    }
 
    UFUNCTION(BlueprintCallable, Category="Development")
    void SetHiddenInGame(bool NewHidden, bool bPropagateToChildren=false)
    {
        SetHiddenInGame(NewHidden, bPropagateToChildren ? EVisibilityPropagation::Propagate : EVisibilityPropagation::DirtyOnly);
    }
 
#if WITH_EDITOR
    UE_DEPRECATED(5.7, "IsTemporarilyHiddenInEditor is now deprecated.")
    bool IsTemporarilyHiddenInEditor(const bool bIncludeParent) const
    {
        return bHiddenEdTemporary;
    }
    ENGINE_API void SetIsTemporarilyHiddenInEditor(const bool bInIsHidden);
#endif // WITH_EDITOR
 
    //~ Begin ActorComponent Interface
    ENGINE_API virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
    ENGINE_API virtual void OnPreRegister() override;
    ENGINE_API virtual void OnRegister() override;
    ENGINE_API virtual void OnUnregister() override;
    ENGINE_API virtual void EndPlay(EEndPlayReason::Type Reason) override;
    virtual bool ShouldCreateRenderState() const override { return true; }
    virtual void UpdateComponentToWorld(EUpdateTransformFlags UpdateTransformFlags = EUpdateTransformFlags::None, ETeleportType Teleport = ETeleportType::None) override final
    {
        UpdateComponentToWorldWithParent(GetAttachParent(), GetAttachSocketName(), UpdateTransformFlags, RelativeRotationCache.RotatorToQuat(GetRelativeRotation()), Teleport);
    }
    ENGINE_API virtual void DestroyComponent(bool bPromoteChildren = false) override;
    ENGINE_API virtual void OnComponentDestroyed(bool bDestroyingHierarchy) override;
    ENGINE_API virtual void ApplyWorldOffset(const FVector& InOffset, bool bWorldShift) override;
    ENGINE_API virtual TStructOnScope<FActorComponentInstanceData> GetComponentInstanceData() const override;
#if WITH_EDITOR
    ENGINE_API virtual FBox GetStreamingBounds() const override;
#endif // WITH_EDITOR
 
    //~ End ActorComponent Interface
 
    //~ Begin UObject Interface
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual bool IsPostLoadThreadSafe() const override;
    ENGINE_API virtual void PreNetReceive() override;
    ENGINE_API virtual void PostNetReceive() override;
    ENGINE_API virtual void PostRepNotifies() override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
#if WITH_EDITORONLY_DATA
    static ENGINE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
#endif
 
#if WITH_EDITOR
    ENGINE_API virtual EDataValidationResult IsDataValid(FDataValidationContext& Context) const override;
    ENGINE_API virtual bool NeedsLoadForTargetPlatform(const ITargetPlatform* TargetPlatform) const;
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual void PostEditChangeChainProperty(FPropertyChangedChainEvent& PropertyChangedEvent) override;
    ENGINE_API virtual bool CanEditChange(const FProperty* Property) const override;
#endif
    //~ End UObject Interface
 
protected:
    ENGINE_API bool InternalSetWorldLocationAndRotation(FVector NewLocation, const FQuat& NewQuat, bool bNoPhysics = false, ETeleportType Teleport = ETeleportType::None);
 
    ENGINE_API virtual void OnUpdateTransform(EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport = ETeleportType::None);
 
    ENGINE_API bool CheckStaticMobilityAndWarn(const FText& ActionText) const;
 
    ENGINE_API virtual bool UpdateOverlapsImpl(const TOverlapArrayView* PendingOverlaps = nullptr, bool bDoNotifies = true, const TOverlapArrayView* OverlapsAtEndLocation = nullptr);
 
private:
    ENGINE_API void PropagateTransformUpdate(bool bTransformChanged, EUpdateTransformFlags UpdateTransformFlags = EUpdateTransformFlags::None, ETeleportType Teleport = ETeleportType::None);
    ENGINE_API void UpdateComponentToWorldWithParent(USceneComponent* Parent, FName SocketName, EUpdateTransformFlags UpdateTransformFlags, const FQuat& RelativeRotationQuat, ETeleportType Teleport = ETeleportType::None);
 
public:
 
    ENGINE_API bool UpdateOverlaps(const TOverlapArrayView* PendingOverlaps = nullptr, bool bDoNotifies = true, const TOverlapArrayView* OverlapsAtEndLocation = nullptr);
 
    bool MoveComponent( const FVector& Delta, const FQuat& NewRotation,    bool bSweep, FHitResult* Hit=NULL, EMoveComponentFlags MoveFlags = MOVECOMP_NoFlags, ETeleportType Teleport = ETeleportType::None);
    ENGINE_API bool MoveComponent( const FVector& Delta, const FRotator& NewRotation, bool bSweep, FHitResult* Hit=NULL, EMoveComponentFlags MoveFlags = MOVECOMP_NoFlags, ETeleportType Teleport = ETeleportType::None);
 
protected:
    ENGINE_API virtual bool MoveComponentImpl(const FVector& Delta, const FQuat& NewRotation, bool bSweep, FHitResult* Hit = NULL, EMoveComponentFlags MoveFlags = MOVECOMP_NoFlags, ETeleportType Teleport = ETeleportType::None);
 
    ENGINE_API bool IsDeferringMovementUpdates(const FScopedMovementUpdate& ScopedUpdate) const;
 
    ENGINE_API bool HasGroupedMovementUpdate(const FScopedMovementUpdate& ScopedUpdate) const;
 
public:
    void ConditionalUpdateComponentToWorld();
 
    bool IsDeferringMovementUpdates() const;
 
    bool HasGroupedMovementUpdates() const;
 
    virtual void OnAttachmentChanged() {}
 
    inline FVector GetComponentLocation() const
    {
        return GetComponentTransform().GetLocation();
    }
 
    inline FRotator GetComponentRotation() const
    {
        return WorldRotationCache.NormalizedQuatToRotator(GetComponentTransform().GetRotation());
    }
 
    inline FQuat GetComponentQuat() const
    {
        return GetComponentTransform().GetRotation();
    }
 
    inline FVector GetComponentScale() const
    {
        return GetComponentTransform().GetScale3D();
    }
 
    inline void SetComponentToWorld(const FTransform& NewComponentToWorld)
    {
        bComponentToWorldUpdated = true;
        ComponentToWorld = NewComponentToWorld;
    }
 
    inline const FTransform& GetComponentToWorld() const 
    { 
        return ComponentToWorld;
    }
 
    inline const FTransform& GetComponentTransform() const
    {
        return ComponentToWorld;
    }
 
    ENGINE_API void UpdateChildTransforms(EUpdateTransformFlags UpdateTransformFlags = EUpdateTransformFlags::None, ETeleportType Teleport = ETeleportType::None);
 
    ENGINE_API virtual FBoxSphereBounds CalcBounds(const FTransform& LocalToWorld) const;
 
    virtual FBoxSphereBounds CalcLocalBounds() const 
    { 
        return GetLocalBounds();
    }
 
    ENGINE_API virtual void CalcBoundingCylinder(float& CylinderRadius, float& CylinderHalfHeight) const;
 
    ENGINE_API virtual void UpdateBounds();
 
    virtual bool ShouldCollideWhenPlacing() const
    {
        return false;
    }
 
    ENGINE_API virtual void UpdatePhysicsVolume( bool bTriggerNotifiers );
 
    ENGINE_API void SetPhysicsVolume( APhysicsVolume * NewVolume,  bool bTriggerNotifiers );
 
    UFUNCTION(BlueprintCallable, Category=PhysicsVolume, meta=(UnsafeDuringActorConstruction="true"))
    ENGINE_API APhysicsVolume* GetPhysicsVolume() const;
 
    ENGINE_API virtual const FCollisionResponseContainer& GetCollisionResponseToChannels() const;
 
    ENGINE_API virtual bool IsVisibleInEditor() const;
 
    ENGINE_API bool ShouldRender() const;
 
    ENGINE_API bool CanEverRender() const;
 
    ENGINE_API bool ShouldComponentAddToScene() const;
 
#if WITH_EDITOR
    ENGINE_API virtual void PostEditComponentMove(bool bFinished);
 
    ENGINE_API virtual const int32 GetNumUncachedStaticLightingInteractions() const;
 
    virtual void PreFeatureLevelChange(ERHIFeatureLevel::Type PendingFeatureLevel) {}
#endif // WITH_EDITOR
 
protected:
 
    inline FTransform CalcNewComponentToWorld(const FTransform& NewRelativeTransform, const USceneComponent* Parent = nullptr, FName SocketName = NAME_None) const
    {
        SocketName = Parent ? SocketName : GetAttachSocketName();
        Parent = Parent ? Parent : GetAttachParent();
        if (Parent)
        {
            const bool bGeneral = IsUsingAbsoluteLocation() || IsUsingAbsoluteRotation() || IsUsingAbsoluteScale();
            if (!bGeneral)
            {
                return NewRelativeTransform * Parent->GetSocketTransform(SocketName);
            }
            
            return CalcNewComponentToWorld_GeneralCase(NewRelativeTransform, Parent, SocketName);
        }
        else
        {
            return NewRelativeTransform;
        }
    }
 
    ENGINE_API FTransform CalcNewComponentToWorld_GeneralCase(const FTransform& NewRelativeTransform, const USceneComponent* Parent, FName SocketName) const;
 
public:
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Set Relative Location And Rotation", ScriptName="SetRelativeLocationAndRotation"))
    ENGINE_API void K2_SetRelativeLocationAndRotation(FVector NewLocation, FRotator NewRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void SetRelativeLocationAndRotation(FVector NewLocation, FRotator NewRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
    ENGINE_API void SetRelativeLocationAndRotation(FVector NewLocation, const FQuat& NewRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    ENGINE_API void SetAbsolute(bool bNewAbsoluteLocation = false, bool bNewAbsoluteRotation = false, bool bNewAbsoluteScale = false);
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(DisplayName="Set World Location And Rotation", ScriptName="SetWorldLocationAndRotation"))
    ENGINE_API void K2_SetWorldLocationAndRotation(FVector NewLocation, FRotator NewRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    ENGINE_API void SetWorldLocationAndRotation(FVector NewLocation, FRotator NewRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    ENGINE_API void SetWorldLocationAndRotation(FVector NewLocation, const FQuat& NewRotation, bool bSweep=false, FHitResult* OutSweepHitResult=nullptr, ETeleportType Teleport = ETeleportType::None);
 
    ENGINE_API void SetWorldLocationAndRotationNoPhysics(const FVector& NewLocation, const FRotator& NewRotation);
 
    ENGINE_API virtual bool IsWorldGeometry() const;
 
    ENGINE_API virtual ECollisionEnabled::Type GetCollisionEnabled() const;
 
    inline bool IsCollisionEnabled() const
    {
        return GetCollisionEnabled() != ECollisionEnabled::NoCollision;
    }
 
    inline bool IsQueryCollisionEnabled() const
    {
        return CollisionEnabledHasQuery(GetCollisionEnabled());
    }
 
    inline bool IsPhysicsCollisionEnabled() const
    {
        return CollisionEnabledHasPhysics(GetCollisionEnabled());
    }
 
    ENGINE_API virtual ECollisionResponse GetCollisionResponseToChannel(ECollisionChannel Channel) const;
 
    ENGINE_API virtual ECollisionChannel GetCollisionObjectType() const;
 
    ENGINE_API ECollisionResponse GetCollisionResponseToComponent(USceneComponent* OtherComponent) const;
 
    UFUNCTION(BlueprintCallable, Category="Transformation")
    ENGINE_API virtual void SetMobility(EComponentMobility::Type NewMobility);
 
    ENGINE_API USceneComponent* GetAttachmentRoot() const;
    
    ENGINE_API AActor* GetAttachmentRootActor() const;
 
    ENGINE_API FVector GetActorPositionForRenderer() const;
 
    ENGINE_API AActor* GetAttachParentActor() const;
 
    ENGINE_API bool IsAttachedTo(const USceneComponent* TestComp) const;
 
    ENGINE_API void GetSocketWorldLocationAndRotation(FName InSocketName, FVector& OutLocation, FRotator& OutRotation) const;
    ENGINE_API void GetSocketWorldLocationAndRotation(FName InSocketName, FVector& OutLocation, FQuat& OutRotation) const;
 
    virtual bool CanAttachAsChild(const USceneComponent* ChildComponent, FName SocketName) const { return true; }
 
    ENGINE_API virtual FBoxSphereBounds GetPlacementExtent() const;
 
private:
    friend class AActor;
 
    void NotifyIsRootComponentChanged(bool bIsRootComponent) { IsRootComponentChanged.Broadcast(this, bIsRootComponent); }
 
protected:
    virtual void OnChildAttached(USceneComponent* ChildComponent) {}
 
    virtual void OnChildDetached(USceneComponent* ChildComponent) {}
 
    ENGINE_API void UpdateNavigationData();
 
    ENGINE_API void PostUpdateNavigationData();
 
    inline bool AreDynamicDataChangesAllowed(bool bIgnoreStationary = true) const
    {
        return (IsOwnerRunningUserConstructionScript()) || !(IsRegistered() && (Mobility == EComponentMobility::Static || (!bIgnoreStationary && Mobility == EComponentMobility::Stationary)));
    }
 
public:
    virtual const bool CanHaveStaticMobility() const { return true; }
 
    virtual void PropagateLightingScenarioChange() {}
 
    virtual bool IsPrecomputedLightingValid() const
    {
        return false;
    }
 
private:
    friend class FScopedMovementUpdate;
    friend class FScopedPreventAttachedComponentMove;
    friend struct FDirectAttachChildrenAccessor;
 
    //~ Begin Methods for Replicated Members.
private:
 
    ENGINE_API void SetAttachParent(USceneComponent* NewAttachParent);
    
    ENGINE_API void SetAttachSocketName(FName NewSocketName);
    
    ENGINE_API void ModifiedAttachChildren();
 
public:
 
    virtual void OnReceiveReplicatedState(const FVector X, const FQuat R, const FVector V, const FVector W) {};
 
    static const FName GetRelativeLocationPropertyName()
    {
        return GET_MEMBER_NAME_CHECKED(USceneComponent, RelativeLocation);
    }
    
    FVector GetRelativeLocation() const
    {
        return RelativeLocation;
    }
    
    ENGINE_API FVector& GetRelativeLocation_DirectMutable();
 
    ENGINE_API void SetRelativeLocation_Direct(const FVector NewRelativeLocation);
 
    static const FName GetRelativeRotationPropertyName()
    {
        return GET_MEMBER_NAME_CHECKED(USceneComponent, RelativeRotation);
    }
    
    FRotator GetRelativeRotation() const
    {
        return RelativeRotation;
    }
    
    ENGINE_API FRotator& GetRelativeRotation_DirectMutable();
 
    ENGINE_API void SetRelativeRotation_Direct(const FRotator NewRelativeRotation);
 
    static const FName GetRelativeScale3DPropertyName()
    {
        return GET_MEMBER_NAME_CHECKED(USceneComponent, RelativeScale3D);
    }
    
    FVector GetRelativeScale3D() const
    {
        return RelativeScale3D;
    }
    
    ENGINE_API FVector& GetRelativeScale3D_DirectMutable();
 
    ENGINE_API void SetRelativeScale3D_Direct(const FVector NewRelativeScale3D);
 
    void SetRelativeTransform_Direct(const FTransform& NewRelativeTransform)
    {
        SetRelativeLocation_Direct(NewRelativeTransform.GetLocation());
        SetRelativeRotation_Direct(NewRelativeTransform.Rotator());
        SetRelativeScale3D_Direct(NewRelativeTransform.GetScale3D());
    }
 
    static const FName GetAbsoluteLocationPropertyName()
    {
        return GET_MEMBER_NAME_CHECKED(USceneComponent, bAbsoluteLocation);
    }
 
    bool IsUsingAbsoluteLocation() const
    {
        return bAbsoluteLocation;
    }
    
    ENGINE_API void SetUsingAbsoluteLocation(const bool bInAbsoluteLocation);
 
    static const FName GetAbsoluteRotationPropertyName()
    {
        return GET_MEMBER_NAME_CHECKED(USceneComponent, bAbsoluteRotation);
    }
 
    bool IsUsingAbsoluteRotation() const
    {
        return bAbsoluteRotation;
    }
    
    ENGINE_API void SetUsingAbsoluteRotation(const bool bInAbsoluteRotation);
 
    static const FName GetAbsoluteScalePropertyName()
    {
        return GET_MEMBER_NAME_CHECKED(USceneComponent, bAbsoluteScale);
    }
 
    bool IsUsingAbsoluteScale() const
    {
        return bAbsoluteScale;
    }
    
    ENGINE_API void SetUsingAbsoluteScale(const bool bInAbsoluteRotation);
 
    static const FName GetVisiblePropertyName()
    {
        return GET_MEMBER_NAME_CHECKED(USceneComponent, bVisible);
    }
 
    bool GetVisibleFlag() const
    {
        return bVisible;
    }
    
    ENGINE_API void SetVisibleFlag(const bool bInVisible);
    
    //~ End Methods for Replicated Members.
 
    EComponentMobility::Type GetMobility() const
    {
        return Mobility;
    }
};
 
struct FDirectAttachChildrenAccessor
{
private:
    static TArray<TObjectPtr<USceneComponent>>& Get(USceneComponent* Component)
    { 
        return Component->AttachChildren;
    }
 
    friend class UChildActorComponent;
    friend class FBlueprintThumbnailScene;
    friend class FClassThumbnailScene;
    friend class FComponentEditorUtils;
    friend class FBlueprintCompileReinstancer;
    friend struct FResetSceneComponentAfterCopy;
};
 
 
// USceneComponent inlines
 
inline const TArray<TObjectPtr<USceneComponent>>& USceneComponent::GetAttachChildren() const
{
    return AttachChildren;
}
 
inline USceneComponent* USceneComponent::GetAttachParent() const
{
    return AttachParent;
}
 
inline FName USceneComponent::GetAttachSocketName() const
{
    return AttachSocketName;
}
 
inline void USceneComponent::ConditionalUpdateComponentToWorld()
{
    if (!bComponentToWorldUpdated)
    {
        UpdateComponentToWorld();
    }
}
 
inline bool USceneComponent::MoveComponent(const FVector& Delta, const FQuat& NewRotation, bool bSweep, FHitResult* Hit, EMoveComponentFlags MoveFlags, ETeleportType Teleport)
{
    return MoveComponentImpl(Delta, NewRotation, bSweep, Hit, MoveFlags, Teleport);
}
 
inline void USceneComponent::SetRelativeLocation(FVector NewLocation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport)
{
    SetRelativeLocationAndRotation(NewLocation, RelativeRotationCache.RotatorToQuat(GetRelativeRotation()), bSweep, OutSweepHitResult, Teleport);
}
 
inline void USceneComponent::SetRelativeRotation(const FQuat& NewRotation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport)
{
    SetRelativeLocationAndRotation(GetRelativeLocation(), NewRotation, bSweep, OutSweepHitResult, Teleport);
}
 
inline void USceneComponent::AddRelativeLocation(FVector DeltaLocation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport)
{
    SetRelativeLocationAndRotation(GetRelativeLocation() + DeltaLocation, RelativeRotationCache.RotatorToQuat(GetRelativeRotation()), bSweep, OutSweepHitResult, Teleport);
}
 
inline void USceneComponent::AddRelativeRotation(FRotator DeltaRotation, bool bSweep, FHitResult* OutSweepHitResult, ETeleportType Teleport)
{
    SetRelativeRotation(GetRelativeRotation() + DeltaRotation, bSweep, OutSweepHitResult, Teleport);
}
 
 
USTRUCT()
struct FSceneComponentInstanceData : public FActorComponentInstanceData
{
    GENERATED_BODY()
 
    ENGINE_API FSceneComponentInstanceData();
    ENGINE_API FSceneComponentInstanceData(const USceneComponent* SourceComponent);
            
    ENGINE_API virtual ~FSceneComponentInstanceData();
 
    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;
 
    UPROPERTY() 
    TMap<TObjectPtr<USceneComponent>, FTransform> AttachedInstanceComponents;
};
 
 
 
class FScopedPreventAttachedComponentMove : private FNoncopyable
{
public:
 
    ENGINE_API FScopedPreventAttachedComponentMove(USceneComponent* Component);
    ENGINE_API ~FScopedPreventAttachedComponentMove();
 
private:
 
    USceneComponent* Owner;
    uint32 bSavedAbsoluteLocation:1;
    uint32 bSavedAbsoluteRotation:1;
    uint32 bSavedAbsoluteScale:1;
    uint32 bSavedNonAbsoluteComponent:1; // Whether any of the saved location/rotation/scale flags were false (or equivalently: not all were true).
 
    // This class can only be created on the stack, otherwise the ordering constraints
    // of the constructor and destructor between encapsulated scopes could be violated.
    void* operator new (size_t) = delete;
    void* operator new[] (size_t) = delete;
    void operator delete (void *) = delete;
    void operator delete[] (void*) = delete;
};
 
inline FScopedMovementUpdate* USceneComponent::GetCurrentScopedMovement() const
{
    if (ScopedMovementStack.Num() > 0)
    {
        return ScopedMovementStack.Last();
    }
    return nullptr;
}
 
inline bool USceneComponent::IsDeferringMovementUpdates() const
{
    if (ScopedMovementStack.Num() > 0)
    {
        checkSlow(IsDeferringMovementUpdates(*ScopedMovementStack.Last()));
        return true;
    }
    return false;
}
 
inline bool USceneComponent::HasGroupedMovementUpdates() const
{
    if (ScopedMovementStack.Num() > 0)
    {
        checkSlow(HasGroupedMovementUpdate(*ScopedMovementStack.Last()));
        return true;
    }
    return false;
}
 
inline bool USceneComponent::GetShouldUpdatePhysicsVolume() const
{
    return bShouldUpdatePhysicsVolume;
}