SkinnedMeshComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
 
#pragma once
 
#include "CoreMinimal.h"
#include "GPUSkinPublicDefs.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Engine/EngineTypes.h"
#include "Components/SceneComponent.h"
#include "Interfaces/Interface_AsyncCompilation.h"
#include "Engine/TextureStreamingTypes.h"
#include "Components/MeshComponent.h"
#include "Containers/SortedMap.h"
#include "LODSyncInterface.h"
#include "BoneContainer.h"
#include "ClothingSystemRuntimeTypes.h"
#include "StateStream/SkinnedMeshStateStreamHandle.h"
#include "Async/RecursiveMutex.h"
#include "Misc/ScopeLock.h"
 
#if WITH_EDITORONLY_DATA
#include "Animation/MeshDeformerGeometryReadback.h"
#endif // WITH_EDITORONLY_DATA
 
#include "SkinnedMeshComponent.generated.h"
 
enum class ESkinCacheUsage : uint8;
enum class EPreviousBoneTransformUpdateMode;
class FPrimitiveSceneProxy;
class FColorVertexBuffer;
class FSkinWeightVertexBuffer;
class FSkeletalMeshObject;
class FSkeletalMeshRenderData;
class FSkeletalMeshLODRenderData;
struct FSkelMeshRenderSection;
class FPositionVertexBuffer;
class UMeshDeformer;
class UMeshDeformerInstance;
class UMeshDeformerInstanceSettings;
class UMorphTarget;
class USkinnedAsset;
struct FExternalMorphSet;
struct FExternalMorphWeightData;
struct FSkinWeightProfileStack;
struct FMeshDescription;
 
namespace Nanite
{
    struct FResources;
}
 
namespace UE::Anim
{
    struct FSkinnedMeshComponentExtensions;
}
 
DECLARE_DELEGATE_OneParam(FOnAnimUpdateRateParamsCreated, FAnimUpdateRateParameters*)
DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnTickPose, USkinnedMeshComponent* /*SkinnedMeshComponent*/, float /*DeltaTime*/, bool /*bNeedsValidRootMotion*/)
DECLARE_MULTICAST_DELEGATE(FOnBoneTransformsFinalizedMultiCast);
 
//
// Bone Visibility.
//
 
UENUM()
enum EBoneVisibilityStatus : int
{
    BVS_HiddenByParent,
    BVS_Visible,
    BVS_ExplicitlyHidden,
    BVS_MAX,
};
 
UENUM()
enum EPhysBodyOp : int
{
    PBO_None,
    PBO_Term,
    PBO_MAX,
};
 
UENUM(BlueprintType)
enum class EVisibilityBasedAnimTickOption : uint8
{
    AlwaysTickPoseAndRefreshBones,
    AlwaysTickPose,
    OnlyTickMontagesAndRefreshBonesWhenPlayingMontages,
    OnlyTickMontagesWhenNotRendered,
    OnlyTickPoseWhenRendered,
};
 
namespace EMeshComponentUpdateFlag
{
    UE_DEPRECATED(4.21, "EMeshComponentUpdateFlag has been deprecated use EVisibilityBasedAnimTickOption instead")
    typedef int32 Type;
    UE_DEPRECATED(4.21, "EMeshComponentUpdateFlag has been deprecated use EVisibilityBasedAnimTickOption instead")
    static const uint8 AlwaysTickPoseAndRefreshBones = 0;
    UE_DEPRECATED(4.21, "EMeshComponentUpdateFlag has been deprecated use EVisibilityBasedAnimTickOption instead")
    static const uint8 AlwaysTickPose = 1;
    UE_DEPRECATED(4.21, "EMeshComponentUpdateFlag has been deprecated use EVisibilityBasedAnimTickOption instead")
    static const uint8 OnlyTickMontagesWhenNotRendered = 2;
    UE_DEPRECATED(4.21, "EMeshComponentUpdateFlag has been deprecated use EVisibilityBasedAnimTickOption instead")
    static const uint8 OnlyTickPoseWhenRendered = 3;
};
 
UENUM()
namespace EBoneSpaces
{
    enum Type : int
    {
        WorldSpace      UMETA(DisplayName = "World Space"),
        ComponentSpace  UMETA(DisplayName = "Component Space"),
        //LocalSpace        UMETA( DisplayName = "Parent Bone Space" ),
    };
}
 
 
UENUM(BlueprintType)
enum class ESkinWeightProfileLayer : uint8
{
    Primary,        
    Secondary,      
};
 
using FMorphTargetWeightMap = TMap<const UMorphTarget* /* MorphTarget */, int32 /* WeightIndex */>;
 
USTRUCT(BlueprintType, meta = (HasNativeMake = "/Script/Engine.KismetRenderingLibrary.MakeSkinWeightInfo", HasNativeBreak = "/Script/Engine.KismetRenderingLibrary.BreakSkinWeightInfo"))
struct FSkelMeshSkinWeightInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    int32   Bones[MAX_TOTAL_INFLUENCES] = {};
    UPROPERTY()
    uint8   Weights[MAX_TOTAL_INFLUENCES] = {};
};
 
USTRUCT()
struct FSkelMeshComponentLODInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TArray<bool> HiddenMaterials;
 
    FColorVertexBuffer* OverrideVertexColors;
 
    FSkinWeightVertexBuffer* OverrideSkinWeights;
 
    FSkinWeightVertexBuffer* OverrideProfileSkinWeights;
 
    ENGINE_API FSkelMeshComponentLODInfo();
    ENGINE_API ~FSkelMeshComponentLODInfo();
 
    ENGINE_API void ReleaseOverrideVertexColorsAndBlock();
    ENGINE_API bool BeginReleaseOverrideVertexColors();
    ENGINE_API void EndReleaseOverrideVertexColors();
private:
    void CleanUpOverrideVertexColors();
 
public:
    ENGINE_API void ReleaseOverrideSkinWeightsAndBlock();
    ENGINE_API bool BeginReleaseOverrideSkinWeights();
    ENGINE_API void EndReleaseOverrideSkinWeights();
private:
    void CleanUpOverrideSkinWeights();
};
 
 
USTRUCT(BlueprintType)
struct FVertexOffsetUsage
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, Category = "Mesh", meta = (Bitmask, BitmaskEnum = "/Script/Engine.EVertexOffsetUsageType"))
    int32 Usage = 0;
};
 
struct FMeshDeformerSet
{
    TArray<TObjectPtr<UMeshDeformer>, TInlineAllocator<2>> Deformers;
 
    TArray<int8, TInlineAllocator<MAX_MESH_LOD_COUNT>> DeformerIndexForLOD;
};
 
USTRUCT()
struct FMeshDeformerInstanceSet
{
    GENERATED_BODY()
 
    UPROPERTY()
    TArray<TObjectPtr<UMeshDeformerInstance>> DeformerInstances;
 
    TArray<int8> InstanceIndexForLOD;
};
 
using FExternalMorphSets = TMap<int32, TSharedPtr<FExternalMorphSet>>;
 
UCLASS(hidecategories=Object, config=Engine, editinlinenew, abstract, MinimalAPI)
class USkinnedMeshComponent : public UMeshComponent, public ILODSyncInterface, public IClothSimulationDataProvider
{
    GENERATED_UCLASS_BODY()
 
    
    friend class FSkinnedMeshComponentRecreateRenderStateContext;
 
    UE_DEPRECATED(5.1, "Replaced by SkinnedAsset. Use GetSkinnedAsset()/SetSkinnedAsset() instead, or GetSkeletalMeshAsset/SetSkeletalMeshAsset() when called from a USkeletalMeshComponent.")
    UPROPERTY(EditAnywhere, Setter = SetSkeletalMesh_DEPRECATED, BlueprintGetter = GetSkeletalMesh_DEPRECATED, Category = "Mesh|SkeletalAsset", meta = (DisallowedClasses = "/Script/ApexDestruction.DestructibleMesh", DeprecatedProperty, DeprecationMessage = "Use USkeletalMeshComponent::GetSkeletalMeshAsset() or GetSkinnedAsset() instead."))
    TObjectPtr<class USkeletalMesh> SkeletalMesh;
 
private:
    UE_DEPRECATED(5.1, "This property isn't deprecated, but getter and setter must be used instead in order to preserve backward compatibility with the SkeletalMesh pointer.")
    UPROPERTY(BlueprintGetter = GetSkinnedAsset, Category = "Mesh")
    TObjectPtr<class USkinnedAsset> SkinnedAsset;
 
public:
    ENGINE_API USkinnedMeshComponent(FVTableHelper& Helper);
    ENGINE_API ~USkinnedMeshComponent();
 
    //
    // LeaderPoseComponent.
    //
    
    UPROPERTY(BlueprintReadOnly, Category = "Mesh")
    TWeakObjectPtr<USkinnedMeshComponent> LeaderPoseComponent;
 
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(5.1, "This property is deprecated. Please use LeaderPoseComponent instead")
    TWeakObjectPtr<USkinnedMeshComponent> MasterPoseComponent;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Mesh")
    TArray<ESkinCacheUsage> SkinCacheUsage;
 
protected:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Deformer", meta = (InlineEditConditionToggle))
    bool bSetMeshDeformer = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Deformer", meta = (editcondition = "bSetMeshDeformer"))
    TObjectPtr<UMeshDeformer> MeshDeformer;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Deformer")
    bool bAlwaysUseMeshDeformer = false;
 
    ENGINE_API void SetMeshDeformer(bool bInSetMeshDeformer, UMeshDeformer* InMeshDeformer);
 
    ENGINE_API FMeshDeformerSet GetActiveMeshDeformers() const;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Instanced, Category = "Deformer", meta = (DisplayName = "Deformer Settings", EditCondition = "MeshDeformerInstanceSettings!=nullptr", ShowOnlyInnerProperties))
    TObjectPtr<UMeshDeformerInstanceSettings> MeshDeformerInstanceSettings;
 
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(5.4, "Replaced by MeshDeformerInstances. Call GetMeshDeformerInstance() to get the same behavior as reading MeshDeformerInstance.")
    UPROPERTY(Transient, BlueprintReadOnly, BlueprintGetter = GetMeshDeformerInstance, Category = "Deformer", meta = (DeprecatedProperty, DeprecationMessage = "Use the GetMeshDeformerInstance function instead"))
    TObjectPtr<UMeshDeformerInstance> MeshDeformerInstance_DEPRECATED;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(Transient)
    FMeshDeformerInstanceSet MeshDeformerInstances;
public:
    const FMeshDeformerInstanceSet& GetMeshDeformerInstances() const { return MeshDeformerInstances; }
 
    TObjectPtr<UMeshDeformer> GetComponentMeshDeformer() const { return MeshDeformer; }
private:
    void CreateMeshDeformerInstances(const FMeshDeformerSet& DeformerSet);
    void ReleaseMeshDeformerInstances();
 
public:
    UFUNCTION(BlueprintPure, Category = "Components|SkinnedMesh")
    ENGINE_API UMeshDeformerInstance* GetMeshDeformerInstance() const;
 
    ENGINE_API UMeshDeformerInstance* GetMeshDeformerInstanceForLOD(int32 LODIndex) const;
 
    ENGINE_API virtual int32 GetMeshDeformerMaxLOD() const;
 
#if WITH_EDITORONLY_DATA
private:
    TArray<TUniquePtr<FMeshDeformerGeometryReadbackRequest>> GeometryReadbackRequests;
public:
    ENGINE_API bool RequestReadbackRenderGeometry(TUniquePtr<FMeshDeformerGeometryReadbackRequest> InRequest);
#endif // WITH_EDITORONLY_DATA
    
public:
    
    const TArray<uint8>& GetPreviousBoneVisibilityStates() const
    {
        return bDoubleBufferedComponentSpaceTransforms ? GetEditableBoneVisibilityStates() : PreviousBoneVisibilityStates;
    }
 
    const TArray<FTransform>& GetPreviousComponentTransformsArray() const
    {
        return bDoubleBufferedComponentSpaceTransforms ? GetEditableComponentSpaceTransforms() : PreviousComponentSpaceTransformsArray;
    }
 
    uint32 GetBoneTransformRevisionNumber() const 
    {
        const USkinnedMeshComponent* LeaderPoseComponentPtr = LeaderPoseComponent.Get();
        return (LeaderPoseComponentPtr ? LeaderPoseComponentPtr->CurrentBoneTransformRevisionNumber : CurrentBoneTransformRevisionNumber);
    }
 
    uint32 GetPreviousBoneTransformRevisionNumber() const
    {
        const USkinnedMeshComponent* LeaderPoseComponentPtr = LeaderPoseComponent.Get();
        return (LeaderPoseComponentPtr ? LeaderPoseComponentPtr->PreviousBoneTransformRevisionNumber : PreviousBoneTransformRevisionNumber);
    }
 
    uint32 GetCurrentBoneTransformFrame() const
    {
        const USkinnedMeshComponent* LeaderPoseComponentPtr = LeaderPoseComponent.Get();
        return (LeaderPoseComponentPtr ? LeaderPoseComponentPtr->CurrentBoneTransformFrame : CurrentBoneTransformFrame);
    }
 
    /* this update renderer with new revision number twice so to clear bone velocity for motion blur or temporal AA */
    ENGINE_API void ClearMotionVector();
    
    /* Forcibly update the renderer with a new revision number to assign the current bone velocity for motion blur or temporal AA */
    ENGINE_API void ForceMotionVector();
 
private:
    ENGINE_API void UpdateBoneTransformRevisionNumber();
    ENGINE_API EPreviousBoneTransformUpdateMode GetPreviousBoneTransformUpdateMode();
 
    enum class EBoneTransformUpdateMethod
    {
        AnimationUpdate,
        ClearMotionVector,
        ForceMotionVector
    };
    TArray<EBoneTransformUpdateMethod> BoneTransformUpdateMethodQueue;
 
    TArray<FTransform> ComponentSpaceTransformsArray[2];
 
#if WITH_STATE_STREAM_ACTOR
    FSkinnedMeshHandle MeshHandle;
#endif
 
protected:
    TArray<uint8> PreviousBoneVisibilityStates;
 
    TArray<FTransform> PreviousComponentSpaceTransformsArray;
 
protected:
    float LastStreamerUpdateBoundsRadius;
 
    int32 CurrentEditableComponentTransforms;
 
    int32 CurrentReadComponentTransforms;
 
    uint32 PreviousBoneTransformRevisionNumber;
 
    uint32 CurrentBoneTransformRevisionNumber;
 
    uint32 CurrentBoneTransformFrame;
 
    int32 LeaderBoneMapCacheCount;
 
    TArray< TWeakObjectPtr<USkinnedMeshComponent> > FollowerPoseComponents;
 
    TArray<int32> LeaderBoneMap;
 
    struct FMissingLeaderBoneCacheEntry
    {
        FMissingLeaderBoneCacheEntry()
            : RelativeTransform(FTransform::Identity)
            , CommonAncestorBoneIndex(INDEX_NONE)
        {}
 
        FMissingLeaderBoneCacheEntry(const FTransform& InRelativeTransform, int32 InCommonAncestorBoneIndex)
            : RelativeTransform(InRelativeTransform)
            , CommonAncestorBoneIndex(InCommonAncestorBoneIndex)
        {}
 
        FTransform RelativeTransform;
 
        int32 CommonAncestorBoneIndex;
    };
 
    TMap<int32, FMissingLeaderBoneCacheEntry> MissingLeaderBoneMap;
 
    TSortedMap<FName, FName, FDefaultAllocator, FNameFastLess> SocketOverrideLookup;
 
public:
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FColor WireframeColor_DEPRECATED;
#endif
 
#if UE_ENABLE_DEBUG_DRAWING
    TOptional<FLinearColor> DebugDrawColor;
#endif
 
protected:
    TSharedPtr<FSkelMeshRefPoseOverride> RefPoseOverride;
 
public:
    const TArray<int32>& GetLeaderBoneMap() const { return LeaderBoneMap; }
 
    UE_DEPRECATED(5.1, "This method has been deprecated. Please use the GetLeaderBoneMap.")
    const TArray<int32>& GetMasterBoneMap() const { return GetLeaderBoneMap(); }
 
    ENGINE_API const FExternalMorphWeightData& GetExternalMorphWeights(int32 LOD) const;
 
    ENGINE_API FExternalMorphWeightData& GetExternalMorphWeights(int32 LOD);
 
    ENGINE_API void AddExternalMorphSet(int32 LOD, int32 ID, TSharedPtr<FExternalMorphSet> MorphSet);
 
    ENGINE_API void RemoveExternalMorphSet(int32 LOD, int32 ID);
 
    ENGINE_API void ClearExternalMorphSets(int32 LOD);
 
    ENGINE_API bool HasExternalMorphSet(int32 LOD, int32 ID) const;
 
    ENGINE_API bool IsValidExternalMorphSetLODIndex(int32 LOD) const;
 
    const FExternalMorphSets& GetExternalMorphSets(int32 LOD) const { return ExternalMorphSets[LOD]; }
    FExternalMorphSets& GetExternalMorphSets(int32 LOD) { return ExternalMorphSets[LOD]; }
 
    const TArray<FExternalMorphSets>& GetExternalMorphSetsArray() const { return ExternalMorphSets; }
 
    ENGINE_API void GetCPUSkinnedVertices(TArray<struct FFinalSkinVertex>& OutVertices, int32 InLODIndex) const;
 
    ENGINE_API void GetCPUSkinnedCachedFinalVertices(TArray<FFinalSkinVertex>& OutVertices) const;
 
    ENGINE_API virtual const Nanite::FResources* GetNaniteResources() const;
 
    ENGINE_API virtual bool HasValidNaniteData() const;
 
 
#if WITH_EDITOR
    virtual void PostAssetCompilation() {};
#endif
 
#if UE_ENABLE_DEBUG_DRAWING
    bool ShouldDrawDebugSkeleton() const
    {
        return bDrawDebugSkeleton
#if WITH_EDITORONLY_DATA
        || bDisplayBones
#endif
        ; 
    }
 
    void SetDrawDebugSkeleton(bool bInDraw) { bDrawDebugSkeleton = bInDraw; }
 
    const TOptional<FLinearColor>& GetDebugDrawColor() const { return DebugDrawColor; }
 
    void SetDebugDrawColor(const FLinearColor& InColor) { DebugDrawColor = InColor; }
#endif
 
    FMorphTargetWeightMap ActiveMorphTargets;
 
    TArray<float> MorphTargetWeights;
 
    TArray<FExternalMorphWeightData> ExternalMorphWeightData;
 
    TArray<FExternalMorphSets> ExternalMorphSets;
 
#if WITH_EDITORONLY_DATA
private:
    int32 SectionIndexPreview;
 
    int32 MaterialIndexPreview;
 
    int32 SelectedEditorSection;
 
    int32 SelectedEditorMaterial;
#endif // WITH_EDITORONLY_DATA
 
public:
    //
    // Physics.
    //
    
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Physics)
    TObjectPtr<class UPhysicsAsset> PhysicsAssetOverride;
 
    //
    // Level of detail.
    //
    
    UE_DEPRECATED(4.24, "Direct access to ForcedLodModel is deprecated. Please use its getter and setter instead.")
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=LOD)
    int32 ForcedLodModel;
 
private:
    int32 ForceStreamedLodModel;
public:
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=LOD)
    int32 MinLodModel;
 
    UE_DEPRECATED(4.27, "Direct access to PredictedLODLevel has been deprecated and will be removed in a future version. Please use Get/SetPredictedLODLevel() accessors.")
    int32 PredictedLODLevel;
 
    float MaxDistanceFactor;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=SkeletalMesh)
    float StreamingDistanceMultiplier;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Rendering)
    float NanitePixelProgrammableDistance;
 
protected:
    float ExternalInterpolationAlpha;
 
    /* Non-URO-based delta time used to tick the pose */
    float ExternalDeltaTime;
 
public:
    UPROPERTY(transient)
    TArray<struct FSkelMeshComponentLODInfo> LODInfo;
 
protected:
    TArray<uint8> BoneVisibilityStates[2];
 
    ERHIFeatureLevel::Type CachedSceneFeatureLevel;
 
public:
    /*
     * This is tick animation frequency option based on this component rendered or not or using montage
     *  You can change this default value in the INI file 
     * Mostly related with performance
     */
    UPROPERTY(Interp, EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Config, Category=Optimization)
    EVisibilityBasedAnimTickOption VisibilityBasedAnimTickOption;
 
#if WITH_EDITOR
    UE_DEPRECATED(4.21, "MeshComponentUpdateFlag has been renamed VisibilityBasedAnimTickOption")
    uint8& MeshComponentUpdateFlag = *(uint8*)&VisibilityBasedAnimTickOption;
#endif
 
protected:
    uint8 ExternalTickRate;
 
    uint8 MaxFirstLODIdxInAttachmentTree;
 
protected:
    uint8 bHasValidBoneTransform:1;
 
    uint8 bSkinWeightProfileSet:1;
 
    uint8 bSkinWeightProfilePending:1;
public:
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = LOD)
    uint8 bOverrideMinLod:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = SkeletalMesh)
    uint8 bUseBoundsFromLeaderPoseComponent : 1;
 
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(5.1, "This property is deprecated. Please use bUseBoundsFromLeaderPoseComponent instead")
    uint8 bUseBoundsFromMasterPoseComponent : 1;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = SkeletalMesh)
    uint8 bIncludeComponentLocationIntoBounds : 1;
 
    UPROPERTY()
    uint8 bForceWireframe:1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Rendering)
    uint8 bDisplayBones:1;
#endif
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = SkeletalMesh)
    uint8 bDisableMorphTarget:1;
 
    UPROPERTY()
    uint8 bHideSkin:1;
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=SkeletalMesh)
    uint8 bPerBoneMotionBlur:1;
 
    //
    // Misc.
    //
    
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=Optimization)
    uint8 bComponentUseFixedSkelBounds:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=Optimization)
    uint8 bConsiderAllBodiesForBounds:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category = Rendering)
    uint8 bSyncAttachParentLOD : 1;
 
 
    UPROPERTY(transient)
    uint8 bCanHighlightSelectedSections:1;
 
    UPROPERTY(transient)
    uint8 bRecentlyRendered:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting, meta=(EditCondition="CastShadow && (FirstPersonPrimitiveType != EFirstPersonPrimitiveType::FirstPerson)", DisplayName = "Capsule Direct Shadow"))
    uint8 bCastCapsuleDirectShadow:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting, meta=(EditCondition="CastShadow && (FirstPersonPrimitiveType != EFirstPersonPrimitiveType::FirstPerson)", DisplayName = "Capsule Indirect Shadow"))
    uint8 bCastCapsuleIndirectShadow:1;
 
    UE_DEPRECATED(4.24, "Direct access to bCPUSkinning is deprecated. Please use its getter and setter instead.")
    UPROPERTY(transient)
    uint8 bCPUSkinning : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=Optimization)
    uint8 bUseScreenRenderStateForUpdate:1;
 
    // Update Rate
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=Optimization)
    uint8 bEnableUpdateRateOptimizations:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=Optimization)
    uint8 bDisplayDebugUpdateRateOptimizations:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Optimization)
    uint8 bRenderStatic:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = LOD)
    uint8 bIgnoreLeaderPoseComponentLOD : 1;
 
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(5.1, "This property is deprecated. Please use bIgnoreLeaderPoseComponentLOD instead")
    uint8 bIgnoreMasterPoseComponentLOD : 1;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Lighting, meta = (UIMin = "0", UIMax = "1", DisplayName = "Sort Triangles"))
    uint8 bSortTriangles : 1;
 
protected:
    uint8 bDoubleBufferedComponentSpaceTransforms : 1;
 
    uint8 bNeedToFlipSpaceBaseBuffers : 1;
 
    UPROPERTY(Transient)
    mutable uint8 bCachedLocalBoundsUpToDate:1;
    UPROPERTY(Transient)
    mutable uint8 bCachedWorldSpaceBoundsUpToDate:1;
 
    uint8 bBoneVisibilityDirty:1;
 
private:
    UPROPERTY(transient)
    uint8 bForceMeshObjectUpdate:1;
 
protected:
    uint8 bExternalTickRateControlled:1;
 
    uint8 bExternalInterpolate:1;
 
    uint8 bExternalUpdate:1;
 
    uint8 bExternalEvaluationRateLimited:1;
 
    uint8 bMipLevelCallbackRegistered:1;
 
    UPROPERTY(Transient)
    uint8 bFollowerShouldTickPose : 1;
 
    uint8 bHasSocketAttachments : 1;
 
#if UE_ENABLE_DEBUG_DRAWING
private:
    uint8 bDrawDebugSkeleton:1;
#endif
 
public:
    void EnableExternalTickRateControl(bool bInEnable) { bExternalTickRateControlled = bInEnable; }
 
    bool IsUsingExternalTickRateControl() const { return bExternalTickRateControlled; }
 
    void SetExternalTickRate(uint8 InTickRate) { ExternalTickRate = InTickRate; }
 
    uint8 GetExternalTickRate() const { return ExternalTickRate; }
 
    void EnableExternalInterpolation(bool bInEnable) { bExternalInterpolate = bInEnable; }
 
    bool IsUsingExternalInterpolation() const { return bExternalInterpolate && bExternalEvaluationRateLimited; }
 
    void EnableExternalUpdate(bool bInEnable) { bExternalUpdate = bInEnable; }
 
    void SetExternalInterpolationAlpha(float InAlpha) { ExternalInterpolationAlpha = InAlpha; }
 
    void SetExternalDeltaTime(float InDeltaTime) { ExternalDeltaTime = InDeltaTime; }
 
    void EnableExternalEvaluationRateLimiting(bool bInEnable) { bExternalEvaluationRateLimited = bInEnable; }
 
    const FSkeletalMeshObject* GetMeshObject() const { return MeshObject; }
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting, meta=(UIMin = "0", UIMax = "1", EditCondition="bCastCapsuleIndirectShadow", DisplayName = "Capsule Indirect Shadow Min Visibility"))
    float CapsuleIndirectShadowMinVisibility;
 
    FSkeletalMeshObject*    MeshObject;
 
    FSkeletalMeshObject* (*MeshObjectFactory)(void* UserData, USkinnedMeshComponent* InMeshComponent, FSkeletalMeshRenderData* InSkelMeshRenderData, ERHIFeatureLevel::Type InFeatureLevel);
 
    void* MeshObjectFactoryUserData;
 
    FSkeletalMeshObject* PreviousMeshObject;
 
    ENGINE_API FSkeletalMeshRenderData* GetSkeletalMeshRenderData() const;
 
    ENGINE_API virtual void GetUpdateClothSimulationData_AnyThread(TMap<int32, FClothSimulData>& OutClothSimulData, FMatrix& OutLocalToWorld, float& OutClothBlendWeight) const override;
 
    UFUNCTION(BlueprintCallable, Category="Components|SkinnedMesh")
    ENGINE_API virtual void SetPhysicsAsset(class UPhysicsAsset* NewPhysicsAsset, bool bForceReInit = false);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh", meta=(ScriptName="GetNumLods;GetNumLODs"))
    ENGINE_API int32 GetNumLODs() const;
 
    UE_DEPRECATED(5.5, "Use USkinnedMeshComponent::OverrideMinLOD() instead.")
    UFUNCTION(BlueprintCallable, Category="Components|SkinnedMesh", meta = (DeprecatedFunction, DeprecationMessage = "Use USkinnedMeshComponent::OverrideMinLOD() instead."))
    ENGINE_API void SetMinLOD(int32 InNewMinLOD);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API void OverrideMinLOD(int32 InNewMinLOD);
 
    UFUNCTION(BlueprintCallable, Category="Components|SkinnedMesh")
    ENGINE_API void SetForcedLOD(int32 InNewForcedLOD);
 
    UFUNCTION(BlueprintCallable, Category="Components|SkinnedMesh")
    ENGINE_API int32 GetForcedLOD() const;
 
#if WITH_EDITOR
    ENGINE_API virtual int32 GetLODBias() const;
#endif
 
    UFUNCTION(BlueprintCallable, Category="Lighting")
    ENGINE_API void SetCastCapsuleDirectShadow(bool bNewValue);
 
    UFUNCTION(BlueprintCallable, Category="Lighting")
    ENGINE_API void SetCastCapsuleIndirectShadow(bool bNewValue);
 
    UFUNCTION(BlueprintCallable, Category="Lighting")
    ENGINE_API void SetCapsuleIndirectShadowMinVisibility(float NewValue);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API int32 GetNumBones() const;
 
    UFUNCTION(BlueprintCallable, Category="Components|SkinnedMesh")
    ENGINE_API int32 GetBoneIndex( FName BoneName ) const;
 
    UFUNCTION(BlueprintCallable, Category="Components|SkinnedMesh")
    ENGINE_API FName GetBoneName(int32 BoneIndex) const;
 
    UFUNCTION(BlueprintCallable, Category="Components|SkinnedMesh")
    ENGINE_API FName GetSocketBoneName(FName InSocketName) const;
 
    UE_DEPRECATED(5.1, "Use USkeletalMeshComponent::SetSkeletalMesh() or SetSkinnedAssetAndUpdate() instead.")
    ENGINE_API virtual void SetSkeletalMesh(class USkeletalMesh* NewMesh, bool bReinitPose = true);
 
    UE_DEPRECATED(5.1, "Use USkeletalMeshComponent::GetSkeletalMeshAsset() or GetSkinnedAsset() instead.")
    UFUNCTION(BlueprintPure, Category = "Components|SkinnedMesh", DisplayName = "Get Skeletal Mesh", meta = (DeprecatedFunction, DeprecationMessage = "Use USkeletalMeshComponent::GetSkeletalMeshAsset() or GetSkinnedAsset() instead."))
    ENGINE_API class USkeletalMesh* GetSkeletalMesh_DEPRECATED() const;
 
    UE_DEPRECATED(5.1, "Use USkeletalMeshComponent::SetSkinnedAssetAndUpdate() instead.")
    ENGINE_API void SetSkeletalMesh_DEPRECATED(USkeletalMesh* NewMesh);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API virtual void SetSkinnedAssetAndUpdate(class USkinnedAsset* NewMesh, bool bReinitPose = true);
 
    ENGINE_API void SetSkinnedAsset(class USkinnedAsset* InSkinnedAsset);
 
    UFUNCTION(BlueprintPure, Category = "Components|SkinnedMesh")
    ENGINE_API USkinnedAsset* GetSkinnedAsset() const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API void SetMeshDeformer(UMeshDeformer* InMeshDeformer);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API void UnsetMeshDeformer();
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API void SetAlwaysUseMeshDeformer(bool bShouldAlwaysUseMeshDeformer);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API bool GetAlwaysUseMeshDeformer() const;
    
    UFUNCTION(BlueprintCallable, Category="Components|SkinnedMesh")
    ENGINE_API FName GetParentBone(FName BoneName) const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API FTransform GetDeltaTransformFromRefPose(FName BoneName, FName BaseName = NAME_None) const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API bool GetTwistAndSwingAngleOfDeltaRotationFromRefPose(FName BoneName, float& OutTwistAngle, float& OutSwingAngle) const;
 
    ENGINE_API bool IsSkinCacheAllowed(int32 LodIdx) const;
 
    ENGINE_API bool HasMeshDeformer() const;
    ENGINE_API bool HasMeshDeformer(int32 LodIdx) const;
 
    UE_DEPRECATED(5.5, "This is no longer relevant. Dynamic data is always updated immediately.")
    bool GetForceUpdateDynamicDataImmediately() const { return true; }
 
    UE_DEPRECATED(5.5, "This is no longer relevant. Dynamic data is always updated immediately.")
    void SetForceUpdateDynamicDataImmediately(bool bForceUpdateImmediately) {}
 
    ENGINE_API int32 ComputeMinLOD() const;
 
    int32 GetValidMinLOD(const int32 InMinLODIndex) const;
 
public:
    //~ Begin UObject Interface
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    ENGINE_API virtual FString GetDetailedInfoInternal() const override;
#if WITH_EDITOR
    ENGINE_API virtual bool CanEditChange(const FProperty* InProperty) const override;
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual EDataValidationResult IsDataValid(class FDataValidationContext& Context) const override;
#endif // WITH_EDITOR
 
protected:
    //~ Begin UActorComponent Interface
    ENGINE_API virtual void OnRegister() override;
    ENGINE_API virtual void OnUnregister() override;
    ENGINE_API virtual void BeginPlay() override;
    ENGINE_API virtual void CreateRenderState_Concurrent(FRegisterComponentContext* Context) override;
    ENGINE_API virtual void SendRenderDynamicData_Concurrent() override;
    ENGINE_API virtual void DestroyRenderState_Concurrent() override;
    ENGINE_API virtual bool RequiresGameThreadEndOfFrameRecreate() const override;
    ENGINE_API virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction) override;
    ENGINE_API virtual UObject const* AdditionalStatObject() const override;
    //~ End UActorComponent Interface
 
public:
    //~ Begin USceneComponent Interface
#if WITH_EDITOR
    ENGINE_API virtual bool GetMaterialPropertyPath(int32 ElementIndex, UObject*& OutOwner, FString& OutPropertyPath, FProperty*& OutProperty) override;
#endif // WITH_EDITOR
    ENGINE_API virtual FBoxSphereBounds CalcBounds(const FTransform& LocalToWorld) const override;
    ENGINE_API virtual void UpdateBounds() override;
    ENGINE_API virtual FTransform GetSocketTransform(FName InSocketName, ERelativeTransformSpace TransformSpace = RTS_World) const override;
    ENGINE_API virtual bool DoesSocketExist(FName InSocketName) const override;
    ENGINE_API virtual bool HasAnySockets() const override;
    ENGINE_API virtual void QuerySupportedSockets(TArray<FComponentSocketDescription>& OutSockets) const override;
    ENGINE_API virtual bool UpdateOverlapsImpl(const TOverlapArrayView* PendingOverlaps=nullptr, bool bDoNotifies=true, const TOverlapArrayView* OverlapsAtEndLocation=nullptr) override;
    ENGINE_API virtual void OnChildAttached(USceneComponent* ChildComponent) override;
    ENGINE_API virtual void OnChildDetached(USceneComponent* ChildComponent) override;
    //~ End USceneComponent Interface
 
    //~ Begin UPrimitiveComponent Interface
    ENGINE_API virtual UMaterialInterface* GetMaterial(int32 MaterialIndex) const override;
    ENGINE_API virtual int32 GetMaterialIndex(FName MaterialSlotName) const override;
    ENGINE_API virtual TArray<FName> GetMaterialSlotNames() const override;
    ENGINE_API virtual bool IsMaterialSlotNameValid(FName MaterialSlotName) const override;
    ENGINE_API virtual FPrimitiveSceneProxy* CreateSceneProxy() override;
    ENGINE_API virtual void GetUsedMaterials(TArray<UMaterialInterface*>& OutMaterials, bool bGetDebugMaterials = false) const override;
    ENGINE_API virtual bool GetMaterialStreamingData(int32 MaterialIndex, FPrimitiveMaterialInfo& MaterialData) const override;
    ENGINE_API virtual void GetStreamingRenderAssetInfo(FStreamingTextureLevelContext& LevelContext, TArray<FStreamingRenderAssetPrimitiveInfo>& OutStreamingRenderAssets) const override;
    ENGINE_API virtual int32 GetNumMaterials() const override;
    virtual float GetStreamingScale() const override { return GetComponentTransform().GetMaximumAxisScale(); }
    ENGINE_API virtual void GetPrimitiveStats(FPrimitiveStats& PrimitiveStats) const override;
    //~ End UPrimitiveComponent Interface
 
    //~ Begin UMeshComponent Interface
    ENGINE_API virtual void RegisterLODStreamingCallback(FLODStreamingCallback&& Callback, int32 LODIdx, float TimeoutSecs, bool bOnStreamIn) override;
    ENGINE_API virtual void RegisterLODStreamingCallback(FLODStreamingCallback&& CallbackStreamingStart, FLODStreamingCallback&& CallbackStreamingDone, float TimeoutStartSecs, float TimeoutDoneSecs) override;
    ENGINE_API virtual bool PrestreamMeshLODs(float Seconds) override;
    //~ End UMeshComponent Interface
 
    ENGINE_API void GetPreSkinnedLocalBounds(FBoxSphereBounds& OutBounds) const;
 
    ENGINE_API void ResizeExternalMorphTargetSets();
 
    ENGINE_API void RefreshExternalMorphTargetWeights(bool bZeroOldWeights = true);
 
    ENGINE_API void SetForceWireframe(bool InForceWireframe);
 
    ENGINE_API virtual void CollectPSOPrecacheData(const FPSOPrecacheParams& BasePrecachePSOParams, FMaterialInterfacePSOPrecacheParamsList& OutParams) override;
    
#if WITH_EDITOR
    int32 GetSectionPreview() const { return SectionIndexPreview;  }
    ENGINE_API void SetSectionPreview(int32 InSectionIndexPreview);
 
    int32 GetMaterialPreview() const { return MaterialIndexPreview; }
    ENGINE_API void SetMaterialPreview(int32 InMaterialIndexPreview);
 
    int32 GetSelectedEditorSection() const { return SelectedEditorSection; }
    ENGINE_API void SetSelectedEditorSection(int32 NewSelectedEditorSection);
 
    int32 GetSelectedEditorMaterial() const { return SelectedEditorMaterial; }
    ENGINE_API void SetSelectedEditorMaterial(int32 NewSelectedEditorMaterial);
 
#endif // WITH_EDITOR
 
    static ENGINE_API bool ShouldRenderNaniteSkinnedMeshes();
 
    ENGINE_API virtual bool ShouldNaniteSkin();
 
    ENGINE_API virtual bool ShouldCPUSkin() const;
 
    ENGINE_API bool GetCPUSkinningEnabled() const;
 
    ENGINE_API void SetCPUSkinningEnabled(bool bEnable, bool bRecreateRenderStateImmediately = false);
 
    virtual void PostInitMeshObject(FSkeletalMeshObject*) {}
 
    static ENGINE_API FVector3f GetSkinnedVertexPosition(USkinnedMeshComponent* Component, int32 VertexIndex, const FSkeletalMeshLODRenderData& LODDatal, FSkinWeightVertexBuffer& SkinWeightBuffer);
 
    static ENGINE_API FVector3f GetSkinnedVertexPosition(USkinnedMeshComponent* Component, int32 VertexIndex, const FSkeletalMeshLODRenderData& LODData, FSkinWeightVertexBuffer& SkinWeightBuffer, TArray<FMatrix44f>& CachedRefToLocals);
 
    static ENGINE_API void ComputeSkinnedPositions(USkinnedMeshComponent* Component, TArray<FVector3f> & OutPositions, TArray<FMatrix44f>& CachedRefToLocals, const FSkeletalMeshLODRenderData& LODData, const FSkinWeightVertexBuffer& SkinWeightBuffer);
 
    ENGINE_API void CacheRefToLocalMatrices(TArray<FMatrix44f>& OutRefToLocal) const;
 
    ENGINE_API void GetCurrentRefToLocalMatrices(TArray<FMatrix44f>& OutRefToLocals, int32 InLodIdx, const TArray<FBoneIndexType>* ExtraRequiredBoneIndices = nullptr) const;
 
    inline  const USkinnedMeshComponent* GetBaseComponent()const
    {
        return LeaderPoseComponent.IsValid() ? LeaderPoseComponent.Get() : this;
    }
 
    UFUNCTION(BlueprintCallable, Category="Transformation", meta=(Keywords="Bone"))
    FTransform GetBoneTransform(FName InBoneName, ERelativeTransformSpace TransformSpace = RTS_World) const { return GetSocketTransform(InBoneName, TransformSpace); }
 
    ENGINE_API FColor GetVertexColor(int32 VertexIndex) const;
 
    ENGINE_API void SetVertexColorOverride(int32 LODIndex, const TArray<FColor>& VertexColors);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh", meta = (DisplayName = "Set Vertex Color Override"))
    ENGINE_API void SetVertexColorOverride_LinearColor(int32 LODIndex, const TArray<FLinearColor>& VertexColors);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API void ClearVertexColorOverride(int32 LODIndex);
    ENGINE_API FVector2D GetVertexUV(int32 VertexIndex, uint32 UVChannel) const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API void SetSkinWeightOverride(int32 LODIndex, const TArray<FSkelMeshSkinWeightInfo>& SkinWeights);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API void ClearSkinWeightOverride(int32 LODIndex);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API bool SetSkinWeightProfile(FName InProfileName, ESkinWeightProfileLayer InLayer = ESkinWeightProfileLayer::Primary);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API void ClearSkinWeightProfile(ESkinWeightProfileLayer InLayer = ESkinWeightProfileLayer::Primary);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API void ClearAllSkinWeightProfiles();
    
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API void UnloadSkinWeightProfile(FName InProfileName);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API FName GetCurrentSkinWeightProfileName(ESkinWeightProfileLayer InLayer = ESkinWeightProfileLayer::Primary) const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API TArray<FName> GetCurrentSkinWeightProfileLayerNames() const;
    
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API bool IsUsingSkinWeightProfile() const;
 
    bool IsSkinWeightProfilePending() const { return bSkinWeightProfilePending; }
 
    ENGINE_API void UpdateSkinWeightOverrideBuffer();
protected:
    bool SetSkinWeightProfileStack(const FSkinWeightProfileStack& InProfileStack);
 
    FName CurrentSkinWeightProfileLayers[2] = {NAME_None};
public:
    ENGINE_API FSkinWeightVertexBuffer* GetSkinWeightBuffer(int32 LODIndex) const;
 
    ENGINE_API virtual void SetRefPoseOverride(const TArray<FTransform>& NewRefPoseTransforms);
 
    virtual const TSharedPtr<FSkelMeshRefPoseOverride>& GetRefPoseOverride() const { return RefPoseOverride; }
 
    ENGINE_API virtual void ClearRefPoseOverride();
 
    virtual void RefreshBoneTransforms(FActorComponentTickFunction* TickFunction = nullptr) PURE_VIRTUAL(USkinnedMeshComponent::RefreshBoneTransforms, );
 
protected:
    virtual void DispatchParallelTickPose(FActorComponentTickFunction* TickFunction) {}
 
    ENGINE_API bool UpdateLODStatus_Internal(int32 InLeaderPoseComponentPredictedLODLevel, bool bRequestedByLeaderPoseComponent = false);
 
    uint8 ComputeMaxFirstLODIdxInAttachmentTree() const;
 
public:
    ENGINE_API virtual void TickPose(float DeltaTime, bool bNeedsValidRootMotion);
 
    FOnTickPose OnTickPose;
 
    ENGINE_API virtual void UpdateFollowerComponent();
 
    UE_DEPRECATED(5.1, "This method has been deprecated. Please use UpdateFollowerComponent instead.")
    virtual void UpdateSlaveComponent() { UpdateFollowerComponent(); }
 
    ENGINE_API virtual bool UpdateLODStatus();
 
    UFUNCTION(BlueprintPure, Category = "Components|SkinnedMesh")
    int32 GetPredictedLODLevel() const
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return PredictedLODLevel;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
protected:
    friend class FSkeletalMeshStreamOut;
 
    virtual void SetPredictedLODLevel(int32 InPredictedLODLevel)
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        PredictedLODLevel = InPredictedLODLevel;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
public:
    virtual void UpdateVisualizeLODString(FString& DebugString) {}
 
    ENGINE_API virtual void FinalizeBoneTransform();
 
    ENGINE_API void InitLODInfos();
 
    ENGINE_API void RebuildVisibilityArray();
 
    ENGINE_API void UpdateMorphMaterialUsageOnProxy();
 
    ENGINE_API void AllowDuplicateTransformUpdates(bool bAllow);
 
    const TArray<FTransform>& GetComponentSpaceTransforms() const 
    { 
        return ComponentSpaceTransformsArray[CurrentReadComponentTransforms]; 
    }
 
    TArray<FTransform>& GetEditableComponentSpaceTransforms() 
    {
        return ComponentSpaceTransformsArray[CurrentEditableComponentTransforms];
    }
    const TArray<FTransform>& GetEditableComponentSpaceTransforms() const
    { 
        return ComponentSpaceTransformsArray[CurrentEditableComponentTransforms];
    }
 
public:
    int32 GetNumComponentSpaceTransforms() const 
    { 
        return GetComponentSpaceTransforms().Num(); 
    }
 
    const TArray<uint8>& GetBoneVisibilityStates() const 
    {
        return BoneVisibilityStates[CurrentReadComponentTransforms];
    }
 
    TArray<uint8>& GetEditableBoneVisibilityStates() 
    {
        return BoneVisibilityStates[CurrentEditableComponentTransforms];
    }
    const TArray<uint8>& GetEditableBoneVisibilityStates() const
    {
        return BoneVisibilityStates[CurrentEditableComponentTransforms];
    }
 
    ENGINE_API void SetComponentSpaceTransformsDoubleBuffering(bool bInDoubleBufferedComponentSpaceTransforms);
 
    FBoxSphereBounds GetCachedLocalBounds()  const
    { 
        ensure(bCachedLocalBoundsUpToDate || bCachedWorldSpaceBoundsUpToDate);
        if (bCachedWorldSpaceBoundsUpToDate)
        {
            return CachedWorldOrLocalSpaceBounds.TransformBy(CachedWorldToLocalTransform);
        }
        else
        {
            return CachedWorldOrLocalSpaceBounds;
        }
    } 
 
    ENGINE_API virtual bool ShouldUpdateTransform(bool bLODHasChanged) const;
 
    class FRenderStateLockScope
    {
    public:
        FRenderStateLockScope(USkinnedMeshComponent* InComponent)
            : Lock(InComponent->RenderStateLock)
        {}
 
    private:
        UE::TScopeLock<UE::FRecursiveMutex> Lock;
    };
 
protected:
    friend class FRenderStateLockScope;
    UE::FRecursiveMutex RenderStateLock;
 
    ENGINE_API void FlipEditableSpaceBases();
 
public:
    ENGINE_API virtual bool ShouldTickPose() const;
protected:
 
    ENGINE_API virtual bool AllocateTransformData();
    ENGINE_API virtual void DeallocateTransformData();
 
    UPROPERTY(Transient)
    mutable FBoxSphereBounds CachedWorldOrLocalSpaceBounds;
    UPROPERTY(Transient)
    mutable FMatrix CachedWorldToLocalTransform;
 
public:
#if WITH_EDITOR
    //~ Begin IInterface_AsyncCompilation Interface.
    ENGINE_API virtual bool IsCompiling() const override;
    //~ End IInterface_AsyncCompilation Interface.
#endif
 
    ENGINE_API void InvalidateCachedBounds();
 
protected:
 
    ENGINE_API FBoxSphereBounds CalcMeshBound(const FVector3f& RootOffset, bool UsePhysicsAsset, const FTransform& Transform) const;
 
    ENGINE_API bool ShouldUpdateBoneVisibility() const;
 
protected:
 
    ENGINE_API void ReleaseUpdateRateParams();
 
    ENGINE_API void RefreshUpdateRateParams();
 
private:
    ENGINE_API void TickUpdateRate(float DeltaTime, bool bNeedsValidRootMotion);
    
public:
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API void SetLeaderPoseComponent(USkinnedMeshComponent* NewLeaderBoneComponent, bool bForceUpdate = false, bool bInFollowerShouldTickPose = false);
 
    UE_DEPRECATED(5.1, "This method has been deprecated. Please use SetLeaderPoseComponent instead.")
    void SetMasterPoseComponent(USkinnedMeshComponent* NewMasterBoneComponent, bool bForceUpdate = false) { SetLeaderPoseComponent(NewMasterBoneComponent, bForceUpdate); }
 
    ENGINE_API const TArray< TWeakObjectPtr<USkinnedMeshComponent> >& GetFollowerPoseComponents() const;
 
    UE_DEPRECATED(5.1, "This method has been deprecated. Please use GetFollowerPoseComponents instead.")
    const TArray< TWeakObjectPtr<USkinnedMeshComponent> >& GetSlavePoseComponents() const { return GetFollowerPoseComponents(); }
 
protected:
    ENGINE_API virtual void AddFollowerPoseComponent(USkinnedMeshComponent* SkinnedMeshComponent);
 
    UE_DEPRECATED(5.1, "This method has been deprecated. Please use AddFollowerPoseComponent instead.")
    virtual void AddSlavePoseComponent(USkinnedMeshComponent* SkinnedMeshComponent) { AddFollowerPoseComponent(SkinnedMeshComponent); }
 
    ENGINE_API virtual void RemoveFollowerPoseComponent(USkinnedMeshComponent* SkinnedMeshComponent);
 
    UE_DEPRECATED(5.1, "This method has been deprecated. Please use RemoveFollowerPoseComponent instead.")
    virtual void RemoveSlavePoseComponent(USkinnedMeshComponent* SkinnedMeshComponent) { RemoveFollowerPoseComponent(SkinnedMeshComponent); }
 
protected:
    ENGINE_API virtual UMaterialInterface* GetDefaultOverlayMaterial() const override;
 
    ENGINE_API virtual float GetDefaultOverlayMaterialMaxDrawDistance() const override;
    
    /*
     * Get all default LOD sections overlay materials used by a mesh.
     * The implementer must add all LOD sections and set them to null if there is no value.
     * We need all sections in case they are all active we wont add the global mesh MaterialOverlay in GetUseMaterials or GetMaterialRelevance.
     */
    ENGINE_API virtual void GetDefaultMaterialSlotsOverlayMaterial(TArray<TObjectPtr<UMaterialInterface>>& OutMaterialSlotOverlayMaterials) const override;
 
    void UpdateCachedSocketAttachmentFlag();
    
public:
    ENGINE_API void RefreshFollowerComponents();
 
    UE_DEPRECATED(5.1, "This method has been deprecated. Please use RefreshFollowerComponents instead.")
    void RefreshSlaveComponents() { RefreshFollowerComponents(); }
 
    ENGINE_API void UpdateLeaderBoneMap();
 
    UE_DEPRECATED(5.1, "This method has been deprecated. Please use UpdateLeaderBoneMap instead.")
    void UpdateMasterBoneMap() { UpdateLeaderBoneMap(); }
 
    ENGINE_API class USkeletalMeshSocket const* GetSocketInfoByName(FName InSocketName, FTransform& OutTransform, int32& OutBoneIndex) const;
 
    ENGINE_API class USkeletalMeshSocket const* GetSocketByName( FName InSocketName ) const;
 
    ENGINE_API void AddSocketOverride(FName SourceSocketName, FName OverrideSocketName, bool bWarnHasOverrided = true);
    ENGINE_API void RemoveSocketOverrides(FName SourceSocketName);
    ENGINE_API void RemoveAllSocketOverrides();
 
    ENGINE_API bool HasAnyAttachedSockets() const;
 
    ENGINE_API FMatrix GetBoneMatrix( int32 BoneIndex ) const;
 
    ENGINE_API FTransform GetBoneTransform( int32 BoneIndex, const FTransform& LocalToWorld ) const;
 
    ENGINE_API FTransform GetBoneTransform( int32 BoneIndex ) const;
 
    ENGINE_API FQuat GetBoneQuaternion(FName BoneName, EBoneSpaces::Type Space = EBoneSpaces::WorldSpace) const;
 
    ENGINE_API FVector GetBoneLocation( FName BoneName, EBoneSpaces::Type Space = EBoneSpaces::WorldSpace) const; 
 
    ENGINE_API void GetBoneNames(TArray<FName>& BoneNames);
 
    UFUNCTION(BlueprintCallable, Category="Components|SkinnedMesh")
    ENGINE_API bool BoneIsChildOf(FName BoneName, FName ParentBoneName) const;
 
    UFUNCTION(BlueprintPure, Category = "Components|SkinnedMesh")
    ENGINE_API FVector GetRefPosePosition(int32 BoneIndex) const;
 
    UFUNCTION(BlueprintPure, Category = "Components|SkinnedMesh")
    ENGINE_API FTransform GetRefPoseTransform(int32 BoneIndex) const;
 
    ENGINE_API FVector GetBoneAxis(FName BoneName, EAxis::Type Axis) const;
 
    UFUNCTION(BlueprintCallable, Category="Components|SkinnedMesh")
    ENGINE_API void TransformToBoneSpace( FName BoneName, FVector InPosition, FRotator InRotation, FVector& OutPosition, FRotator& OutRotation ) const;
 
    UFUNCTION(BlueprintCallable, Category="Components|SkinnedMesh")
    ENGINE_API void TransformFromBoneSpace( FName BoneName, FVector InPosition, FRotator InRotation, FVector& OutPosition, FRotator& OutRotation );
 
    ENGINE_API FName FindClosestBone(FVector TestLocation, FVector* BoneLocation = nullptr, float IgnoreScale = 0.f, bool bRequirePhysicsAsset = false) const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh", meta=(DisplayName="Find Closest Bone", AdvancedDisplay="bRequirePhysicsAsset"))
    ENGINE_API FName FindClosestBone_K2(FVector TestLocation, FVector& BoneLocation, float IgnoreScale = 0.f, bool bRequirePhysicsAsset = false) const;
 
    ENGINE_API virtual class UMorphTarget* FindMorphTarget( FName MorphTargetName ) const;
 
    ENGINE_API virtual void HideBone( int32 BoneIndex, EPhysBodyOp PhysBodyOption );
 
    ENGINE_API virtual void UnHideBone( int32 BoneIndex );
 
    ENGINE_API bool IsBoneHidden( int32 BoneIndex ) const;
 
    UFUNCTION(BlueprintCallable, Category="Components|SkinnedMesh")
    ENGINE_API void HideBoneByName( FName BoneName, EPhysBodyOp PhysBodyOption );
 
    UFUNCTION(BlueprintCallable, Category="Components|SkinnedMesh")
    ENGINE_API void UnHideBoneByName( FName BoneName );
 
    UFUNCTION(BlueprintCallable, Category="Components|SkinnedMesh")
    ENGINE_API bool IsBoneHiddenByName( FName BoneName );
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API void ShowMaterialSection(int32 MaterialID, int32 SectionIndex, bool bShow, int32 LODIndex);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API void ShowAllMaterialSections(int32 LODIndex);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API bool IsMaterialSectionShown(int32 MaterialID, int32 LODIndex);
 
    UFUNCTION(BlueprintCallable, Category = "Components|SkinnedMesh")
    ENGINE_API void SetRenderStatic(bool bNewValue);
 
    ENGINE_API class UPhysicsAsset* GetPhysicsAsset() const;
 
private:
    virtual void RefreshMorphTargets() {};
 
    ENGINE_API bool GetMissingLeaderBoneRelativeTransform(int32 InBoneIndex, FMissingLeaderBoneCacheEntry& OutInfo) const;
 
    // BEGIN ILODSyncComponent
    ENGINE_API virtual int32 GetDesiredSyncLOD() const override;
    ENGINE_API virtual int32 GetBestAvailableLOD() const override;
    ENGINE_API virtual void SetForceStreamedLOD(int32 LODIndex) override;
    ENGINE_API virtual void SetForceRenderedLOD(int32 LODIndex) override;
    ENGINE_API virtual int32 GetNumSyncLODs() const override;
    ENGINE_API virtual int32 GetForceStreamedLOD() const override;
    ENGINE_API virtual int32 GetForceRenderedLOD() const override;
    // END ILODSyncComponent
 
    // Animation update rate control.
public:
    FOnAnimUpdateRateParamsCreated OnAnimUpdateRateParamsCreated;
 
    struct FAnimUpdateRateParameters* AnimUpdateRateParams;
 
    virtual bool IsPlayingRootMotion() const { return false; }
    virtual bool IsPlayingNetworkedRootMotionMontage() const { return false; }
    virtual bool IsPlayingRootMotionFromEverything() const { return false; }
 
    ENGINE_API bool ShouldUseUpdateRateOptimizations() const;
 
    ENGINE_API void ReleaseResources();
 
#if WITH_EDITOR
    static ENGINE_API void BindWorldDelegates();
    static ENGINE_API void HandlePostWorldCreation(UWorld* InWorld);
    static ENGINE_API void HandleFeatureLevelChanged(ERHIFeatureLevel::Type InFeatureLevel, TWeakObjectPtr<UWorld> InWorld);
#endif
 
    friend class FSkinnedMeshComponentHelper;
    friend class FRenderStateRecreator;
    friend class FSkeletalMeshStreamOut;
    friend struct UE::Anim::FSkinnedMeshComponentExtensions;
 
    //
    // Animation required bones
    //
 
    static ENGINE_API void GetPhysicsRequiredBones(const USkinnedAsset* SkinnedAsset, const UPhysicsAsset* PhysicsAsset, TArray<FBoneIndexType>& OutRequiredBones);
 
    static ENGINE_API void GetSocketRequiredBones(const USkinnedAsset* SkinnedAsset, TArray<FBoneIndexType>& OutRequiredBones, TArray<FBoneIndexType>& NeededBonesForFillComponentSpaceTransforms);
 
    static ENGINE_API void MergeInBoneIndexArrays(TArray<FBoneIndexType>& BaseArray, const TArray<FBoneIndexType>& InsertArray);
 
    virtual void GetAdditionalRequiredBonesForLeader(int32 LODIndex, TArray<FBoneIndexType>& InOutRequiredBones) const {}
 
    virtual FDelegateHandle RegisterOnBoneTransformsFinalizedDelegate(const FOnBoneTransformsFinalizedMultiCast::FDelegate& /*Delegate*/) { return FDelegateHandle(); }
 
    virtual void UnregisterOnBoneTransformsFinalizedDelegate(const FDelegateHandle& /*DelegateHandle*/) {}
};
 
class FRenderStateRecreator
{
    USkinnedMeshComponent* Component;
    const bool bWasInitiallyRegistered;
    const bool bWasRenderStateCreated;
 
public:
 
    FRenderStateRecreator(USkinnedMeshComponent* InActorComponent) :
        Component(InActorComponent),
        bWasInitiallyRegistered(Component->IsRegistered()),
        bWasRenderStateCreated(Component->IsRenderStateCreated())
    {
        if (bWasRenderStateCreated)
        {
            if (!bWasInitiallyRegistered)
            {
                UE_LOG(LogSkeletalMesh, Warning, TEXT("Created a FRenderStateRecreator with an unregistered component: %s"), *Component->GetPathName());
            }
 
            Component->DestroyRenderState_Concurrent();
        }
    }
 
    ~FRenderStateRecreator()
    {
        const bool bIsRegistered = Component->IsRegistered();
 
        const FCoreTexts& CoreTexts = FCoreTexts::Get();
 
        ensureMsgf(bWasInitiallyRegistered == bIsRegistered,
            TEXT("Component Registered state changed from %s to %s within FRenderStateRecreator scope."),
            *((bWasInitiallyRegistered ? CoreTexts.True : CoreTexts.False).ToString()),
            *((bIsRegistered ? CoreTexts.True : CoreTexts.False).ToString()));
 
        if (bWasRenderStateCreated && bIsRegistered)
        {
            Component->CreateRenderState_Concurrent(nullptr);
        }
    }
};
 
void GetTypedSkinnedTangentBasis(
    const USkinnedMeshComponent* SkinnedComp,
    const FSkelMeshRenderSection& Section,
    const FStaticMeshVertexBuffers& StaticVertexBuffers,
    const FSkinWeightVertexBuffer& SkinWeightVertexBuffer,
    const int32 VertIndex,
    const TArray<FMatrix44f> & RefToLocals,
    FVector3f& OutTangentX,
    FVector3f& OutTangentY,
    FVector3f& OutTangentZ
);
 
template <bool bCachedMatrices>
FVector3f GetTypedSkinnedVertexPosition(
    const USkinnedMeshComponent* SkinnedComp,
    const FSkelMeshRenderSection& Section,
    const FPositionVertexBuffer& PositionVertexBuffer,
    const FSkinWeightVertexBuffer& SkinWeightVertexBuffer,
    const int32 VertIndex,
    const TArray<FMatrix44f> & RefToLocals = TArray<FMatrix44f>()
);
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "Animation/SkinWeightProfile.h"
#endif