StaticMesh.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/AsyncWork.h"
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/Object.h"
#include "UObject/StrongObjectPtr.h"
#include "Misc/Guid.h"
#include "Templates/SubclassOf.h"
#include "Templates/UnrealTemplate.h"
#include "Engine/EngineTypes.h"
#include "UObject/ScriptMacros.h"
#include "Interfaces/Interface_AssetUserData.h"
#include "RenderCommandFence.h"
#include "Interfaces/Interface_CollisionDataProvider.h"
#include "Interfaces/Interface_AsyncCompilation.h"
#include "MeshUVChannelInfo.h"
#include "Engine/StreamableRenderAsset.h"
#include "Tasks/Task.h"
#include "Templates/UniquePtr.h"
#include "StaticMeshSourceData.h"
#include "UObject/PerPlatformProperties.h"
#include "MeshTypes.h"
#include "PerQualityLevelProperties.h"
 
#include "StaticMesh.generated.h"
 
class FSpeedTreeWind;
class FStaticMeshLODGroup;
class UAssetUserData;
class UMaterialInterface;
class UNavCollisionBase;
class UStaticMeshComponent;
class UStaticMeshDescription;
class FStaticMeshUpdate;
class UPackage;
struct FMeshDescription;
struct FStaticMeshLODResources;
class IStaticMeshComponent;
struct FStaticMeshSection;
 
/*-----------------------------------------------------------------------------
    Async Static Mesh Compilation
-----------------------------------------------------------------------------*/
 
enum class EStaticMeshAsyncProperties : uint32
{
    None                    = 0,
    RenderData              = 1 << 0,
    //OccluderData            = 1 << 1,
    SourceModels            = 1 << 2,
    SectionInfoMap          = 1 << 3,
    OriginalSectionInfoMap  = 1 << 4,
    NavCollision            = 1 << 5,
    LightmapUVVersion       = 1 << 6,
    BodySetup               = 1 << 7,
    LightingGuid            = 1 << 8,
    ExtendedBounds          = 1 << 9,
    NegativeBoundsExtension = 1 << 10,
    PositiveBoundsExtension = 1 << 11,
    StaticMaterials         = 1 << 12,
    LightmapUVDensity       = 1 << 13,
    IsBuiltAtRuntime        = 1 << 14,
    MinLOD                  = 1 << 15,
    LightMapCoordinateIndex = 1 << 16,
    LightMapResolution      = 1 << 17,
    HiResSourceModel        = 1 << 18,
    UseLegacyTangentScaling = 1 << 19,
 
    All                     = MAX_uint32
};
 
inline const TCHAR* ToString(EStaticMeshAsyncProperties Value)
{
    switch (Value)
    {
        case EStaticMeshAsyncProperties::None: 
            return TEXT("None");
        case EStaticMeshAsyncProperties::RenderData: 
            return TEXT("RenderData");
        case EStaticMeshAsyncProperties::SourceModels: 
            return TEXT("SourceModels");
        case EStaticMeshAsyncProperties::SectionInfoMap: 
            return TEXT("SectionInfoMap");
        case EStaticMeshAsyncProperties::OriginalSectionInfoMap:
            return TEXT("OriginalSectionInfoMap");
        case EStaticMeshAsyncProperties::NavCollision: 
            return TEXT("NavCollision");
        case EStaticMeshAsyncProperties::LightmapUVVersion: 
            return TEXT("LightmapUVVersion");
        case EStaticMeshAsyncProperties::BodySetup: 
            return TEXT("BodySetup");
        case EStaticMeshAsyncProperties::LightingGuid: 
            return TEXT("LightingGuid");
        case EStaticMeshAsyncProperties::ExtendedBounds: 
            return TEXT("ExtendedBounds");
        case EStaticMeshAsyncProperties::NegativeBoundsExtension:
            return TEXT("NegativeBoundsExtension");
        case EStaticMeshAsyncProperties::PositiveBoundsExtension:
            return TEXT("PositiveBoundsExtension");
        case EStaticMeshAsyncProperties::StaticMaterials: 
            return TEXT("StaticMaterials");
        case EStaticMeshAsyncProperties::LightmapUVDensity: 
            return TEXT("LightmapUVDensity");
        case EStaticMeshAsyncProperties::IsBuiltAtRuntime: 
            return TEXT("IsBuiltAtRuntime");
        case EStaticMeshAsyncProperties::MinLOD:
            return TEXT("MinLOD");
        case EStaticMeshAsyncProperties::LightMapCoordinateIndex:
            return TEXT("LightMapCoordinateIndex");
        case EStaticMeshAsyncProperties::LightMapResolution:
            return TEXT("LightMapResolution");
        case EStaticMeshAsyncProperties::HiResSourceModel:
            return TEXT("HiResSourceModel");
        case EStaticMeshAsyncProperties::UseLegacyTangentScaling:
            return TEXT("UseLegacyTangentScaling");
        case EStaticMeshAsyncProperties::All:
        default: 
            check(false); 
            return TEXT("Unknown");
    }
}
 
ENUM_CLASS_FLAGS(EStaticMeshAsyncProperties);
 
class FStaticMeshPostLoadContext;
class FStaticMeshBuildContext;
 
#if WITH_EDITOR
 
// Any thread implicated in the static mesh build must have a valid scope to be granted access to protected properties without causing any stalls.
class FStaticMeshAsyncBuildScope
{
public:
    FStaticMeshAsyncBuildScope(const UStaticMesh* StaticMesh)
    {
        PreviousScope = StaticMeshBeingAsyncCompiled;
        StaticMeshBeingAsyncCompiled = StaticMesh;
    }
 
    ~FStaticMeshAsyncBuildScope()
    {
        check(StaticMeshBeingAsyncCompiled);
        StaticMeshBeingAsyncCompiled = PreviousScope;
    }
 
    static bool ShouldWaitOnLockedProperties(const UStaticMesh* StaticMesh)
    {
        return StaticMeshBeingAsyncCompiled != StaticMesh;
    }
 
private:
    const UStaticMesh* PreviousScope = nullptr;
    // Only the thread(s) compiling this static mesh will have full access to protected properties without causing any stalls.
    static thread_local const UStaticMesh* StaticMeshBeingAsyncCompiled;
};
 
class FStaticMeshAsyncBuildWorker : public FNonAbandonableTask
{
public:
    UStaticMesh* StaticMesh;
    TUniquePtr<FStaticMeshPostLoadContext> PostLoadContext;
    TUniquePtr<FStaticMeshBuildContext> BuildContext;
 
    FStaticMeshAsyncBuildWorker(
        UStaticMesh* InStaticMesh,
        TUniquePtr<FStaticMeshBuildContext>&& InBuildContext)
        : StaticMesh(InStaticMesh)
        , PostLoadContext(nullptr)
        , BuildContext(MoveTemp(InBuildContext))
    {
    }
 
    FStaticMeshAsyncBuildWorker(
        UStaticMesh* InStaticMesh,
        TUniquePtr<FStaticMeshPostLoadContext>&& InPostLoadContext)
        : StaticMesh(InStaticMesh)
        , PostLoadContext(MoveTemp(InPostLoadContext))
        , BuildContext(nullptr)
    {
    }
 
    void MarkAsCanceled();
 
    inline TStatId GetStatId() const
    {
        RETURN_QUICK_DECLARE_CYCLE_STAT(FStaticMeshAsyncBuildWorker, STATGROUP_ThreadPoolAsyncTasks);
    }
 
    void DoWork();
};
 
struct FStaticMeshAsyncBuildTask : public FAsyncTask<FStaticMeshAsyncBuildWorker>
{
    FStaticMeshAsyncBuildTask(
        UStaticMesh* InStaticMesh,
        TUniquePtr<FStaticMeshPostLoadContext>&& InPostLoadContext)
        : FAsyncTask<FStaticMeshAsyncBuildWorker>(InStaticMesh, MoveTemp(InPostLoadContext))
        , StaticMesh(InStaticMesh)
    {
    }
 
    FStaticMeshAsyncBuildTask(
        UStaticMesh* InStaticMesh,
        TUniquePtr<FStaticMeshBuildContext>&& InBuildContext)
        : FAsyncTask<FStaticMeshAsyncBuildWorker>(InStaticMesh, MoveTemp(InBuildContext))
        , StaticMesh(InStaticMesh)
    {
    }
 
    const UStaticMesh* StaticMesh;
};
#endif // #if WITH_EDITOR
 
/*-----------------------------------------------------------------------------
    Legacy mesh optimization settings.
-----------------------------------------------------------------------------*/
 
UENUM()
enum ENormalMode : int
{
    NM_PreserveSmoothingGroups,
    NM_RecalculateNormals,
    NM_RecalculateNormalsSmooth,
    NM_RecalculateNormalsHard,
    TEMP_BROKEN,
    ENormalMode_MAX,
};
 
UENUM()
enum EImportanceLevel : int
{
    IL_Off,
    IL_Lowest,
    IL_Low,
    IL_Normal,
    IL_High,
    IL_Highest,
    TEMP_BROKEN2,
    EImportanceLevel_MAX,
};
 
UENUM()
enum EOptimizationType : int
{
    OT_NumOfTriangles,
    OT_MaxDeviation,
    OT_MAX,
};
 
USTRUCT()
struct FStaticMeshOptimizationSettings
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TEnumAsByte<enum EOptimizationType> ReductionMethod;
 
    UPROPERTY()
    float NumOfTrianglesPercentage;
 
    UPROPERTY()
    float MaxDeviationPercentage;
 
    UPROPERTY()
    float WeldingThreshold;
 
    UPROPERTY()
    bool bRecalcNormals;
 
    UPROPERTY()
    float NormalsThreshold;
 
    UPROPERTY()
    uint8 SilhouetteImportance;
 
    UPROPERTY()
    uint8 TextureImportance;
 
    UPROPERTY()
    uint8 ShadingImportance;
 
 
    FStaticMeshOptimizationSettings()
    : ReductionMethod( OT_MaxDeviation )
    , NumOfTrianglesPercentage( 1.0f )
    , MaxDeviationPercentage( 0.0f )
    , WeldingThreshold( 0.1f )
    , bRecalcNormals( true )
    , NormalsThreshold( 60.0f )
    , SilhouetteImportance( IL_Normal )
    , TextureImportance( IL_Normal )
    , ShadingImportance( IL_Normal )
    {
    }
 
    inline friend FArchive& operator<<( FArchive& Ar, FStaticMeshOptimizationSettings& Settings )
    {
        Ar << Settings.ReductionMethod;
        Ar << Settings.MaxDeviationPercentage;
        Ar << Settings.NumOfTrianglesPercentage;
        Ar << Settings.SilhouetteImportance;
        Ar << Settings.TextureImportance;
        Ar << Settings.ShadingImportance;
        Ar << Settings.bRecalcNormals;
        Ar << Settings.NormalsThreshold;
        Ar << Settings.WeldingThreshold;
 
        return Ar;
    }
 
};
 
/*-----------------------------------------------------------------------------
    UStaticMesh
-----------------------------------------------------------------------------*/
 
USTRUCT()
struct FMeshSectionInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    int32 MaterialIndex;
 
    UPROPERTY()
    bool bEnableCollision;
 
    UPROPERTY()
    bool bCastShadow;
 
    UPROPERTY()
    bool bVisibleInRayTracing;
 
    UPROPERTY()
    bool bAffectDistanceFieldLighting;
 
    UPROPERTY()
    bool bForceOpaque;
 
    FMeshSectionInfo()
        : MaterialIndex(0)
        , bEnableCollision(true)
        , bCastShadow(true)
        , bVisibleInRayTracing(true)
        , bAffectDistanceFieldLighting(true)
        , bForceOpaque(false)
    {
    }
 
    explicit FMeshSectionInfo(int32 InMaterialIndex)
        : MaterialIndex(InMaterialIndex)
        , bEnableCollision(true)
        , bCastShadow(true)
        , bVisibleInRayTracing(true)
        , bAffectDistanceFieldLighting(true)
        , bForceOpaque(false)
    {
    }
 
    friend bool operator==(const FMeshSectionInfo& A, const FMeshSectionInfo& B);
    friend bool operator!=(const FMeshSectionInfo& A, const FMeshSectionInfo& B);
};
 
USTRUCT()
struct FMeshSectionInfoMap
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TMap<uint32,FMeshSectionInfo> Map;
 
    void Serialize(FArchive& Ar);
 
    ENGINE_API void Clear();
 
    ENGINE_API int32 GetSectionNumber(int32 LODIndex) const;
 
    ENGINE_API bool IsValidSection(int32 LODIndex, int32 SectionIndex) const;
 
    ENGINE_API FMeshSectionInfo Get(int32 LODIndex, int32 SectionIndex) const;
 
    ENGINE_API void Set(int32 LODIndex, int32 SectionIndex, FMeshSectionInfo Info);
 
    ENGINE_API void Remove(int32 LODIndex, int32 SectionIndex);
 
    ENGINE_API void CopyFrom(const FMeshSectionInfoMap& Other);
 
    bool AnySectionHasCollision(int32 LodIndex) const;
};
 
USTRUCT()
struct FAssetEditorOrbitCameraPosition
{
    GENERATED_USTRUCT_BODY()
 
    FAssetEditorOrbitCameraPosition()
        : bIsSet(false)
        , CamOrbitPoint(ForceInitToZero)
        , CamOrbitZoom(ForceInitToZero)
        , CamOrbitRotation(ForceInitToZero)
    {
    }
 
    FAssetEditorOrbitCameraPosition(const FVector& InCamOrbitPoint, const FVector& InCamOrbitZoom, const FRotator& InCamOrbitRotation)
        : bIsSet(true)
        , CamOrbitPoint(InCamOrbitPoint)
        , CamOrbitZoom(InCamOrbitZoom)
        , CamOrbitRotation(InCamOrbitRotation)
    {
    }
 
    UPROPERTY()
    bool bIsSet;
 
    UPROPERTY()
    FVector CamOrbitPoint;
 
    UPROPERTY()
    FVector CamOrbitZoom;
 
    UPROPERTY()
    FRotator CamOrbitRotation;
};
 
#if WITH_EDITOR
DECLARE_MULTICAST_DELEGATE_OneParam(FOnPreMeshBuild, class UStaticMesh*);
DECLARE_MULTICAST_DELEGATE_OneParam(FOnPostMeshBuild, class UStaticMesh*);
#endif
 
//~ Begin Material Interface for UStaticMesh - contains a material and other stuff
USTRUCT(BlueprintType)
struct FStaticMaterial
{
    GENERATED_USTRUCT_BODY()
 
    ENGINE_API FStaticMaterial();
 
    ENGINE_API FStaticMaterial(class UMaterialInterface* InMaterialInterface
        , FName InMaterialSlotName = NAME_None
#if WITH_EDITORONLY_DATA
        , FName InImportedMaterialSlotName = NAME_None
#endif
        , class UMaterialInterface* InOverlayMaterialInterface = nullptr
        );
 
    friend FArchive& operator<<(FArchive& Ar, FStaticMaterial& Elem);
 
    ENGINE_API friend bool operator==(const FStaticMaterial& LHS, const FStaticMaterial& RHS);
    ENGINE_API friend bool operator==(const FStaticMaterial& LHS, const UMaterialInterface& RHS);
    ENGINE_API friend bool operator==(const UMaterialInterface& LHS, const FStaticMaterial& RHS);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = StaticMesh)
    TObjectPtr<class UMaterialInterface> MaterialInterface;
 
    /*This name should be use by the gameplay to avoid error if the skeletal mesh Materials array topology change*/
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = StaticMesh)
    FName MaterialSlotName;
 
    /*This name should be use when we re-import a skeletal mesh so we can order the Materials array like it should be*/
    UPROPERTY(VisibleAnywhere, Category = StaticMesh)
    FName ImportedMaterialSlotName;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = StaticMesh)
    FMeshUVChannelInfo          UVChannelData;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = StaticMesh)
    TObjectPtr<class UMaterialInterface> OverlayMaterialInterface;
};
 
USTRUCT()
struct FStaticMaterialMinimalInfo
{
    GENERATED_USTRUCT_BODY()
 
    FStaticMaterialMinimalInfo(FName InMaterialSlotName = NAME_None, FString InMaterialObjectPath = FString())
        : MaterialSlotName(InMaterialSlotName), MaterialObjectPath(InMaterialObjectPath)
        {}
 
    FName MaterialSlotName;
    FString MaterialObjectPath;
};
 
enum EImportStaticMeshVersion
{
    // Before any version changes were made
    BeforeImportStaticMeshVersionWasAdded,
    // Remove the material re-order workflow
    RemoveStaticMeshSkinxxWorkflow,
    StaticMeshVersionPlusOne,
    LastVersion = StaticMeshVersionPlusOne - 1
};
 
USTRUCT()
struct FMaterialRemapIndex
{
    GENERATED_USTRUCT_BODY()
 
    FMaterialRemapIndex()
    {
        ImportVersionKey = 0;
    }
 
    FMaterialRemapIndex(uint32 VersionKey, TArray<int32> RemapArray)
    : ImportVersionKey(VersionKey)
    , MaterialRemap(RemapArray)
    {
    }
 
    UPROPERTY()
    uint32 ImportVersionKey;
 
    UPROPERTY()
    TArray<int32> MaterialRemap;
};
 
UENUM(BlueprintType)
enum class EStaticMeshPaintSupport : uint8
{
    Default,
    Enabled,
    Disabled,
};
 
 
UCLASS(hidecategories=Object, customconstructor, MinimalAPI, BlueprintType, config=Engine)
class UStaticMesh : public UStreamableRenderAsset, public IInterface_CollisionDataProvider, public IInterface_AssetUserData, public IInterface_AsyncCompilation
{
    GENERATED_UCLASS_BODY()
 
#if WITH_EDITOR
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnExtendedBoundsChanged, const FBoxSphereBounds&);
 
    DECLARE_MULTICAST_DELEGATE(FOnMeshChanged);
#endif
public:
    ENGINE_API ~UStaticMesh();
 
private:
 
#if WITH_EDITOR
    std::atomic<uint32> LockedProperties;
 
    void AcquireAsyncProperty(EStaticMeshAsyncProperties AsyncProperties = EStaticMeshAsyncProperties::All);
    void ReleaseAsyncProperty(EStaticMeshAsyncProperties AsyncProperties = EStaticMeshAsyncProperties::All);
    ENGINE_API void WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties AsyncProperties) const;
#else
    inline void AcquireAsyncProperty(EStaticMeshAsyncProperties AsyncProperties = EStaticMeshAsyncProperties::All) {};
    inline void ReleaseAsyncProperty(EStaticMeshAsyncProperties AsyncProperties = EStaticMeshAsyncProperties::All) {};
    inline void WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties AsyncProperties) const {}
#endif
 
    UE_DEPRECATED(5.0, "This must be protected for async build, always use the accessors even internally.")
    TUniquePtr<class FStaticMeshRenderData> RenderData;
 
public:
#if WITH_EDITOR
    bool IsCompiling() const override { return AsyncTask != nullptr || LockedProperties.load(std::memory_order_relaxed) != 0; }
    ENGINE_API bool HasAnyDependenciesCompiling() const;
#else
    inline bool IsCompiling() const { return false; }
    bool HasAnyDependenciesCompiling() const { return false; }
#endif
    
    ENGINE_API FStaticMeshRenderData* GetRenderData();
    ENGINE_API const FStaticMeshRenderData* GetRenderData() const;
    ENGINE_API void SetRenderData(TUniquePtr<class FStaticMeshRenderData>&& InRenderData);
 
    void RequestUpdateCachedRenderState() const;
 
#if WITH_EDITORONLY_DATA
    static const float MinimumAutoLODPixelError;
 
private:
    UE_DEPRECATED(5.0, "This must be protected for async build, always use the accessors even internally.")
    UPROPERTY(Setter = None, Getter = None)
    TArray<FStaticMeshSourceModel> SourceModels;
 
    UE_DEPRECATED(5.0, "This must be protected for async build, always use the accessors even internally.")
    UPROPERTY(Setter = None, Getter = None)
    FStaticMeshSourceModel HiResSourceModel;
 
    void SetLightmapUVVersion(int32 InLightmapUVVersion)
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::LightmapUVVersion);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        LightmapUVVersion = InLightmapUVVersion;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_DEPRECATED(5.0, "This must be protected for async build, always use the accessors even internally.")
    UPROPERTY()
    FMeshSectionInfoMap SectionInfoMap;
 
    UE_DEPRECATED(5.0, "This must be protected for async build, always use the accessors even internally.")
    UPROPERTY()
    FMeshSectionInfoMap OriginalSectionInfoMap;
 
public:
    static FName GetSectionInfoMapName()
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return GET_MEMBER_NAME_CHECKED(UStaticMesh, SectionInfoMap);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_DEPRECATED(5.7, "Please do not access this member directly, it will become private soon; use UStaticMesh::Get/SetLODGroup() or, if absolutely needed, UStaticMesh::SetLODGroup_Unsafe() which bypasses the conditional processing in SetLODGroup(). The Unsafe version is likely to be removed in the near future.")
    UPROPERTY(EditAnywhere, AssetRegistrySearchable, Category=LodSettings)
    FName LODGroup;
 
    UE_DEPRECATED(5.7, "Please do not access this member directly, it will become private soon; use UStaticMesh::GetNumStreamedLODs().")
    UPROPERTY()
    FPerPlatformInt NumStreamedLODs;
 
    /* The last import version */
    UE_DEPRECATED(5.7, "Please do not access this member directly, it will become private soon; use UStaticMesh::GetImportVersion() or UStaticMesh::SetImportVersion().")
    UPROPERTY()
    int32 ImportVersion;
 
    UE_DEPRECATED(5.7, "Please do not access this member directly, it will become private soon; use UStaticMesh::GetMaterialRemapIndexPerImportVersion()")
    UPROPERTY()
    TArray<FMaterialRemapIndex> MaterialRemapIndexPerImportVersion;
 
    UE_DEPRECATED(5.7, "Please do not access this member directly, it will become private soon; use UStaticMesh::GetAutoComputeLODScreenSize() or UStaticMesh::SetAutoComputeLODScreenSize().")
    UPROPERTY()
    uint8 bAutoComputeLODScreenSize : 1;
 
    UE_DEPRECATED(5.7, "Please do not access this member directly, it will become private soon; use UStaticMesh::GetRequiresLODDistanceConversion() or UStaticMesh::SetRequiresLODDistanceConversion().")
    uint8 bRequiresLODDistanceConversion : 1;
 
    UE_DEPRECATED(5.7, "Please do not access this member directly, it will become private soon; use UStaticMesh::GetRequiresLODScreenSizeConversion() or UStaticMesh::SetRequiresLODScreenSizeConversion().")
    uint8 bRequiresLODScreenSizeConversion : 1;
 
    UE_DEPRECATED(5.7, "Do not access this member. It is not meant to be used outside of UStaticMesh.")
    UPROPERTY()
    TArray<TObjectPtr<UMaterialInterface>> Materials_DEPRECATED;
 
    UE_DEPRECATED(5.7, "Please do not access this member directly, it will become private soon; use the various NaniteSettings accessor functions.")
    UPROPERTY(EditAnywhere, Category = NaniteSettings)
    FMeshNaniteSettings NaniteSettings;
 
 
private:
    /* The lightmap UV generation version used during the last derived data build */
    UE_DEPRECATED(5.0, "This must be protected for async build, always use the accessors even internally.")
        UPROPERTY()
    int32 LightmapUVVersion;
public:
 
    int32 GetLightmapUVVersion() const
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::LightmapUVVersion);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
            return LightmapUVVersion;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    FName GetLODGroup() const
    {
        return LODGroup;
    }
 
    void SetLODGroup_Unsafe(FName InLODGroup)
    {
        LODGroup = InLODGroup;
    }
 
    static FName GetLODGroupMemberName()
    {
        return GET_MEMBER_NAME_CHECKED(UStaticMesh, LODGroup);
    }
 
    const FPerPlatformInt& GetNumStreamedLODs() const
    {
        return NumStreamedLODs;
    }
 
    FPerPlatformInt& GetNumStreamedLODs()
    {
        return NumStreamedLODs;
    }
 
    int32 GetImportVersion()
    {
        return ImportVersion;
    }
 
    void SetImportVersion(int32 Version)
    {
        ImportVersion = Version;
    }
        
    const TArray<FMaterialRemapIndex>& GetMaterialRemapIndexPerImportVersion()
    {
        return MaterialRemapIndexPerImportVersion;
    }
 
    void AddMaterialRemapIndex(const FMaterialRemapIndex& Index)
    {
        MaterialRemapIndexPerImportVersion.Add(Index);
    }
 
    bool GetAutoComputeLODScreenSize() const
    {
        return bAutoComputeLODScreenSize;
    }
 
    void SetAutoComputeLODScreenSize(bool bShouldCompute)
    {
        bAutoComputeLODScreenSize = bShouldCompute;
    }
 
    static FName GetAutoComputeLODScreenSizeMemberName()
    {
        return GET_MEMBER_NAME_CHECKED(UStaticMesh, bAutoComputeLODScreenSize);
    }
 
    bool GetRequiresLODDistanceConversion() const
    {
        return bRequiresLODDistanceConversion;
    }
 
    void SetRequiresLODDistanceConversion(bool bRequiresConversion)
    {
        bRequiresLODDistanceConversion = bRequiresConversion;
    }
 
    bool GetRequiresLODScreenSizeConversion() const
    {
        return bRequiresLODScreenSizeConversion;
    }
 
    void SetRequiresLODScreenSizeConversion(bool bRequiresConversion)
    {
        bRequiresLODScreenSizeConversion = bRequiresConversion;
    }
 
    const FMeshNaniteSettings& GetNaniteSettings() const
    {
        return NaniteSettings;
    }
    FMeshNaniteSettings& GetNaniteSettings()
    {
        return NaniteSettings;
    }
 
    void SetNaniteSettings(const FMeshNaniteSettings& Settings)
    {
        NaniteSettings = Settings;
    }
 
    static FName GetNaniteSettingsMemberName()
    {
        return GET_MEMBER_NAME_CHECKED(UStaticMesh, NaniteSettings);
    }
 
    void NotifyNaniteSettingsChanged()
    {
        FProperty* ChangedProperty = FindFProperty<FProperty>(UStaticMesh::StaticClass(), GET_MEMBER_NAME_CHECKED(UStaticMesh, NaniteSettings));
        FPropertyChangedEvent Event(ChangedProperty);
        PostEditChangeProperty(Event);
    }
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
#endif // #if WITH_EDITORONLY_DATA
 
#if WITH_EDITOR
    UFUNCTION(BlueprintCallable, Category = StaticMesh)
    bool IsLODScreenSizeAutoComputed() const
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return bAutoComputeLODScreenSize;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
#endif
 
    bool IsMinLodQualityLevelEnable() const;
 
    UPROPERTY()
    /*PerQuality override. Note: Enable PerQuality override in the Project Settings/ General Settings/ UseStaticMeshMinLODPerQualityLevels*/
    /* Allow more flexibility to set various values driven by the Scalability or Device Profile.*/
    FPerQualityLevelInt MinQualityLevelLOD;
 
    static FName GetQualityLevelMinLODMemberName()
    {
        return GET_MEMBER_NAME_CHECKED(UStaticMesh, MinQualityLevelLOD);
    }
 
    const FPerQualityLevelInt& GetQualityLevelMinLOD() const
    {
        return MinQualityLevelLOD;
    }
 
    void SetQualityLevelMinLOD(FPerQualityLevelInt InMinLOD)
    {
        MinQualityLevelLOD = MoveTemp(InMinLOD);
    }
 
    UFUNCTION(BlueprintPure, Category = StaticMesh)
    void GetMinimumLODForQualityLevels(TMap<FName, int32>& QualityLevelMinimumLODs) const
    {
#if WITH_EDITORONLY_DATA
        for (const TPair<int32, int32>& Pair : GetQualityLevelMinLOD().PerQuality)
        {
            QualityLevelMinimumLODs.Add(QualityLevelProperty::QualityLevelToFName(Pair.Key), Pair.Value);
        }
#endif
    }
 
    UFUNCTION(BlueprintPure, Category = StaticMesh)
    int32 GetMinimumLODForQualityLevel(const FName& QualityLevel) const
    {
#if WITH_EDITORONLY_DATA
        int32 QualityLevelKey = QualityLevelProperty::FNameToQualityLevel(QualityLevel);
        if (const int32* Result = GetQualityLevelMinLOD().PerQuality.Find(QualityLevelKey))
        {
            return *Result;
        }
#endif
        return INDEX_NONE;
    }
 
    UFUNCTION(BlueprintCallable, Category = StaticMesh, Meta = (ToolTip = "Allow to override min lod quality levels on a staticMesh and it Default value (-1 value for Default dont override its value)."))
    void SetMinLODForQualityLevels(const TMap<EPerQualityLevels, int32>& QualityLevelMinimumLODs, int32 Default = -1)
    {
#if WITH_EDITORONLY_DATA
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::MinLOD);
        MinQualityLevelLOD.PerQuality = QualityLevelProperty::ConvertQualityLevelData(QualityLevelMinimumLODs);
        MinQualityLevelLOD.Default = Default >= 0 ? Default : MinQualityLevelLOD.Default;
#endif
    }
 
    UFUNCTION(BlueprintPure, Category = StaticMesh)
    void GetMinLODForQualityLevels(TMap<EPerQualityLevels, int32>& QualityLevelMinimumLODs, int32& Default) const
    {
#if WITH_EDITORONLY_DATA
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::MinLOD);
        QualityLevelMinimumLODs = QualityLevelProperty::ConvertQualityLevelData(MinQualityLevelLOD.PerQuality);
        Default = MinQualityLevelLOD.Default;
#endif
    }
 
    /*Choose either PerPlatform or PerQuality override. Note: Enable PerQuality override in the Project Settings/ General Settings/ UseStaticMeshMinLODPerQualityLevels*/
    ENGINE_API int32 GetMinLODIdx(bool bForceLowestLODIdx = false) const;
    ENGINE_API int32 GetDefaultMinLOD() const;
    ENGINE_API void SetMinLODIdx(int32 InMinLOD);
    
    ENGINE_API static float ComputeLODScreenSize(int32 LODIndex, float PreviousLODScreenSize = -1.0f);
    
    ENGINE_API static void OnLodStrippingQualityLevelChanged(IConsoleVariable* Variable);
 
    UE_DEPRECATED(4.27, "Please do not access this member directly; use UStaticMesh::GetMinLOD() or UStaticMesh::SetMinLOD().")
    UPROPERTY()
    FPerPlatformInt MinLOD;
 
    const FPerPlatformInt& GetMinLOD() const
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::MinLOD);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return MinLOD;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    void SetMinLOD(FPerPlatformInt InMinLOD)
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::MinLOD);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        MinLOD = MoveTemp(InMinLOD);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UFUNCTION(BlueprintPure, Category=StaticMesh)
    void GetMinimumLODForPlatforms(TMap<FName, int32>& PlatformMinimumLODs) const
    {
#if WITH_EDITORONLY_DATA
        PlatformMinimumLODs = GetMinLOD().PerPlatform;
#endif
    }
 
    UFUNCTION(BlueprintPure, Category=StaticMesh)
    int32 GetMinimumLODForPlatform(const FName& PlatformName) const
    {
#if WITH_EDITORONLY_DATA
        if (const int32* Result = GetMinLOD().PerPlatform.Find(PlatformName))
        {
            return *Result;
        }
#endif
        return INDEX_NONE;
    }
 
    UFUNCTION(BlueprintCallable, Category=StaticMesh)
    void SetMinimumLODForPlatforms(const TMap<FName, int32>& PlatformMinimumLODs)
    {
#if WITH_EDITORONLY_DATA
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::MinLOD);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        MinLOD.PerPlatform = PlatformMinimumLODs;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
#endif
    }
 
    UFUNCTION(BlueprintCallable, Category=StaticMesh)
    void SetMinimumLODForPlatform(const FName& PlatformName, int32 InMinLOD)
    {
#if WITH_EDITORONLY_DATA
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::MinLOD);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        MinLOD.PerPlatform.Add(PlatformName, InMinLOD);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
#endif
    }
 
protected:
    UPROPERTY(meta = (DisplayAfter = "ExtendedBounds"))
    int32 ElementToIgnoreForTexFactor;
 
public:
 
#if WITH_EDITORONLY_DATA
    ENGINE_API bool IsNaniteEnabled() const;
 
    ENGINE_API bool IsNaniteForceEnabled() const;
 
    ENGINE_API bool IsNaniteAssembly() const;
 
    ENGINE_API bool HasCachedNaniteAssemblyReferences() const;
 
    ENGINE_API const TArray<TObjectPtr<UStaticMesh>>& GetCachedNaniteAssemblyReferences() const;
 
    ENGINE_API void RecacheNaniteAssemblyReferences(bool bWaitForAsyncCompile = true);
 
    ENGINE_API void ClearCachedNaniteAssemblyReferences();
#endif
 
    // TODO: Temp/deprecated hack - Do not call
    inline bool IsNaniteLandscape() const
    {
        return GetName().StartsWith(TEXT("LandscapeNaniteMesh"));
    }
 
private:
    UE_DEPRECATED(5.0, "This must be protected for async build, always use the accessors even internally.")
    UPROPERTY(BlueprintGetter = GetStaticMaterials, BlueprintSetter = SetStaticMaterials, Category = StaticMesh)
    TArray<FStaticMaterial> StaticMaterials;
 
    TArray<FStaticMaterialMinimalInfo> StaticMaterialsInfoCache;
    mutable FCriticalSection MaterialsInfoCriticalSection;
    ENGINE_API void UpdateStaticMaterialsInfoCache(const TArray<FStaticMaterial>& InMaterials);
    ENGINE_API const FString ExportStaticMaterialsInfo() const;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(Transient)
    TArray<TObjectPtr<UStaticMesh>> AssemblyReferenceCache;
#endif
#if WITH_EDITOR
    void OnNaniteAssemblyReferenceBuilt(UStaticMesh* Reference);
#endif
 
public:
    static FName GetStaticMaterialsName()
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return GET_MEMBER_NAME_CHECKED(UStaticMesh, StaticMaterials);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    const TArray<FStaticMaterialMinimalInfo> GetCopyOfStaticMaterialsInfo() const
    {
        FScopeLock Lock(&MaterialsInfoCriticalSection);
        return StaticMaterialsInfoCache;
    }
 
    ENGINE_API static const TArray<FStaticMaterialMinimalInfo> ImportStaticMaterialsInfo(const FString& InData);
 
    TArray<FStaticMaterial>& GetStaticMaterials()
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::StaticMaterials);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return StaticMaterials;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UFUNCTION(BlueprintGetter)
    const TArray<FStaticMaterial>& GetStaticMaterials() const
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::StaticMaterials);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return StaticMaterials;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UFUNCTION(BlueprintSetter)
    void SetStaticMaterials(const TArray<FStaticMaterial>& InStaticMaterials)
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::StaticMaterials);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        StaticMaterials = InStaticMaterials;
        UpdateStaticMaterialsInfoCache(StaticMaterials);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
private:
    UE_DEPRECATED(5.0, "This must be protected for async build, always use the accessors even internally.")
    UPROPERTY()
    float LightmapUVDensity;
public:
    void SetLightmapUVDensity(float InLightmapUVDensity)
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::LightmapUVDensity);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        LightmapUVDensity = InLightmapUVDensity;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    float GetLightmapUVDensity() const
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::LightmapUVDensity);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return LightmapUVDensity;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_DEPRECATED(4.27, "Please do not access this member directly; use UStaticMesh::GetLightMapResolution() or UStaticMesh::SetLightMapResolution().")
    UPROPERTY(EditAnywhere, Category=StaticMesh, meta=(ClampMax = 4096, ToolTip="The light map resolution", FixedIncrement="4.0"))
    int32 LightMapResolution;
 
    int32 GetLightMapResolution() const
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::LightMapResolution);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return LightMapResolution;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    void SetLightMapResolution(int32 InLightMapResolution)
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::LightMapResolution);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        LightMapResolution = InLightMapResolution;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    static FName GetLightMapResolutionName()
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return GET_MEMBER_NAME_CHECKED(UStaticMesh, LightMapResolution);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_DEPRECATED(4.27, "Please do not access this member directly; use UStaticMesh::GetLightMapCoordinateIndex() or UStaticMesh::SetLightMapCoordinateIndex().")
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category=StaticMesh, meta=(ToolTip="The light map coordinate index", UIMin = "0", UIMax = "3"))
    int32 LightMapCoordinateIndex;
 
    int32 GetLightMapCoordinateIndex() const
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::LightMapCoordinateIndex);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return LightMapCoordinateIndex;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    void SetLightMapCoordinateIndex(int32 InLightMapCoordinateIndex)
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::LightMapCoordinateIndex);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        LightMapCoordinateIndex = InLightMapCoordinateIndex;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    static FName GetLightMapCoordinateIndexName()
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return GET_MEMBER_NAME_CHECKED(UStaticMesh, LightMapCoordinateIndex);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = StaticMesh, meta = (DisplayName = "Support Texture Color Mesh Painting"))
    EStaticMeshPaintSupport StaticMeshPaintSupport;
 
    ENGINE_API bool CanMeshPaintTextureColors() const;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = StaticMesh, meta = (UIMin = "0", UIMax = "3"))
    int32 MeshPaintTextureCoordinateIndex;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = StaticMesh, meta = (UIMin = "0", UIMax = "4096", ClampMax = "4096"))
    int32 MeshPaintTextureResolution;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = StaticMesh)
    float DistanceFieldSelfShadowBias;
 
private:
    // Physics data.
    UE_DEPRECATED(5.0, "This must be protected for async build, always use the accessors even internally.")
    UPROPERTY(EditAnywhere, transient, duplicatetransient, Instanced, Category = StaticMesh)
    TObjectPtr<class UBodySetup> BodySetup;
public:
    UBodySetup* GetBodySetup() const
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::BodySetup);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return BodySetup;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    void SetBodySetup(UBodySetup* InBodySetup)
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::BodySetup);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        BodySetup = InBodySetup;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    static FName GetBodySetupName()
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return GET_MEMBER_NAME_CHECKED(UStaticMesh, BodySetup);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = StaticMesh, meta=(DisplayName="LOD For Collision"))
    int32 LODForCollision;
 
    UPROPERTY(EditAnywhere, Category=StaticMesh)
    uint8 bGenerateMeshDistanceField : 1;
 
    UPROPERTY()
    uint8 bStripComplexCollisionForConsole_DEPRECATED:1;
 
    UPROPERTY(EditAnywhere, Category=Navigation)
    uint8 bHasNavigationData:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = StaticMesh)
    uint8 bSupportUniformlyDistributedSampling : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = StaticMesh)
    uint8 bSupportPhysicalMaterialMasks : 1;
 
#if WITH_EDITORONLY_DATA
private:
    // If true, will incorrectly scale tangents when applying a non-uniform BuildScale to match what legacy code did. Only use for consistency on old assets.
    UE_DEPRECATED(5.4, "Please do not access this member directly; use UStaticMesh::GetLegacyTangentScaling() or UStaticMesh::SetLegacyTangentScaling().")
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = StaticMesh)
    uint8 bUseLegacyTangentScaling : 1;
public:
 
    bool GetLegacyTangentScaling() const
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::UseLegacyTangentScaling);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return bUseLegacyTangentScaling;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    void SetLegacyTangentScaling(bool bInUseLegacyTangentScaling)
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::UseLegacyTangentScaling);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        bUseLegacyTangentScaling = bInUseLegacyTangentScaling;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
    
    UE_DEPRECATED(5.7, "Please do not access this member directly, it will become private soon; use the various RayTracingProxySettings accessors.")
    UPROPERTY(EditAnywhere, Category = RayTracingProxySettings)
    FMeshRayTracingProxySettings RayTracingProxySettings;
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    const FMeshRayTracingProxySettings& GetRayTracingProxySettings() const
    {
        return RayTracingProxySettings;
    }
    FMeshRayTracingProxySettings& GetRayTracingProxySettings()
    {
        return RayTracingProxySettings;
    }
    void SetRayTracingProxySettings(const FMeshRayTracingProxySettings& Settings)
    {
        RayTracingProxySettings = Settings;
    }
 
    static FName GetRayTracingProxySettingsMemberName()
    {
        return GET_MEMBER_NAME_CHECKED(UStaticMesh, RayTracingProxySettings);
    }
 
    void NotifyRayTracingProxySettingsChanged()
    {
        FProperty* ChangedProperty = FindFProperty<FProperty>(UStaticMesh::StaticClass(), UStaticMesh::GetRayTracingProxySettingsMemberName());
        FPropertyChangedEvent Event(ChangedProperty);
        PostEditChangeProperty(Event);
    }
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
 
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, Category = RayTracing)
    uint8 bSupportRayTracing : 1;
 
    static FName GetSupportRayTracingMemberName()
    {
        return GET_MEMBER_NAME_CHECKED(UStaticMesh, bSupportRayTracing);
    }
 
    UPROPERTY()
    uint8 bDoFastBuild : 1;
 
private:
 
    UPROPERTY()
    uint8 bIsBuiltAtRuntime_DEPRECATED : 1;
 
public:
 
    UE_DEPRECATED(5.0, "IsBuiltAtRuntime() is no longer used.")
    bool IsBuiltAtRuntime() const
    {
        return false;
    }
 
    UE_DEPRECATED(5.0, "SetIsBuiltAtRuntime() is no longer used.")
    void SetIsBuiltAtRuntime(bool InIsBuiltAtRuntime)
    {
    }
protected:
    uint8 bRenderingResourcesInitialized:1;
 
public:
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = StaticMesh)
    uint8 bAllowCPUAccess:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = StaticMesh)
    uint8 bSupportGpuUniformlyDistributedSampling : 1;
 
    FRenderCommandFence ReleaseResourcesFence;
 
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(5.7, "Please do not access this member directly, it will become private soon; use UStaticMesh::GetAssetImportData() or UStaticMesh::SetAssetImportData().")
    UPROPERTY(EditAnywhere, Instanced, Category=ImportSettings)
    TObjectPtr<class UAssetImportData> AssetImportData;
 
    UE_DEPRECATED(5.7, "Do not access this member. It is not meant to be used outside of UStaticMesh.")
    UPROPERTY()
    FString SourceFilePath_DEPRECATED;
 
    UE_DEPRECATED(5.7, "Do not access this member. It is not meant to be used outside of UStaticMesh.")
    UPROPERTY()
    FString SourceFileTimestamp_DEPRECATED;
 
    UE_DEPRECATED(5.7, "Please do not access this member directly, it will become private soon; use UStaticMesh::GetThumbnailInfo() or UStaticMesh::SetThumbnailInfo().")
    UPROPERTY(VisibleAnywhere, Instanced, AdvancedDisplay, Category=StaticMesh)
    TObjectPtr<class UThumbnailInfo> ThumbnailInfo;
 
    UE_DEPRECATED(5.7, "Please do not access this member directly, it will become private soon; use UStaticMesh::GetEditorCameraPosition() or UStaticMesh::SetEditorCameraPosition().")
    UPROPERTY()
    FAssetEditorOrbitCameraPosition EditorCameraPosition;
 
    UE_DEPRECATED(5.7, "Please do not access this member directly, it will become private soon; use UStaticMesh::GetCustomizedCollision() or UStaticMesh::SetCustomizedCollision().")
    UPROPERTY(EditAnywhere, Category = Collision)
    bool bCustomizedCollision;
#endif // WITH_EDITORONLY_DATA
 
private:
    UE_DEPRECATED(5.0, "This must be protected for async build, always use the accessors even internally.")
    FGuid LightingGuid;
public:
 
    const FGuid& GetLightingGuid() const
    {
#if WITH_EDITORONLY_DATA
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::LightingGuid);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return LightingGuid;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
#else
        static const FGuid NullGuid( 0, 0, 0, 0 );
        return NullGuid;
#endif // WITH_EDITORONLY_DATA
    }
 
    void SetLightingGuid(const FGuid& InLightingGuid = FGuid::NewGuid())
    {
#if WITH_EDITORONLY_DATA
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::LightingGuid);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        LightingGuid = InLightingGuid;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
#endif // WITH_EDITORONLY_DATA
    }
 
    UPROPERTY()
    TArray<TObjectPtr<class UStaticMeshSocket>> Sockets;
 
    TSharedPtr<class FSpeedTreeWind> SpeedTreeWind;
 
    UE_DEPRECATED(4.27, "Please do not access this member directly; use UStaticMesh::GetPositiveBoundsExtension() or UStaticMesh::SetPositiveBoundsExtension.")
    UPROPERTY(EditDefaultsOnly, AdvancedDisplay, Category = StaticMesh)
    FVector PositiveBoundsExtension;
 
    const FVector& GetPositiveBoundsExtension() const
    {
        // No need for WaitUntilAsyncPropertyReleased here as this is only read during async Build/Postload
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return PositiveBoundsExtension;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    void SetPositiveBoundsExtension(FVector InPositiveBoundsExtension)
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::PositiveBoundsExtension);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        PositiveBoundsExtension = InPositiveBoundsExtension;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    static FName GetPositiveBoundsExtensionName()
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return GET_MEMBER_NAME_CHECKED(UStaticMesh, PositiveBoundsExtension);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_DEPRECATED(4.27, "Please do not access this member directly; use UStaticMesh::GetNegativeBoundsExtension() or UStaticMesh::SetNegativeBoundsExtension.")
    UPROPERTY(EditDefaultsOnly, AdvancedDisplay, Category = StaticMesh)
    FVector NegativeBoundsExtension;
    
    const FVector& GetNegativeBoundsExtension() const
    {
        // No need for WaitUntilAsyncPropertyReleased here as this is not modified during async Build/Postload
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return NegativeBoundsExtension;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    void SetNegativeBoundsExtension(FVector InNegativeBoundsExtension)
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::NegativeBoundsExtension);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        NegativeBoundsExtension = InNegativeBoundsExtension;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    static FName GetNegativeBoundsExtensionName()
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return GET_MEMBER_NAME_CHECKED(UStaticMesh, NegativeBoundsExtension);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_DEPRECATED(5.0, "This must be protected for async build, always use the accessors even internally.")
    UPROPERTY()
    FBoxSphereBounds ExtendedBounds;
public:
 
    const FBoxSphereBounds& GetExtendedBounds() const
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::ExtendedBounds);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return ExtendedBounds;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    void SetExtendedBounds(const FBoxSphereBounds& InExtendedBounds)
    {
        WaitUntilAsyncPropertyReleased(EStaticMeshAsyncProperties::ExtendedBounds);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        ExtendedBounds = InExtendedBounds;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
#if WITH_EDITOR
        OnExtendedBoundsChanged.Broadcast(InExtendedBounds);
#endif
    }
 
#if WITH_EDITOR
    FOnExtendedBoundsChanged OnExtendedBoundsChanged;
    FOnMeshChanged OnMeshChanged;
 
    FGuid BuildCacheAutomationTestGuid;
#endif
 
protected:
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Instanced, Category = StaticMesh)
    TArray<TObjectPtr<UAssetUserData>> AssetUserData;
 
    friend class FStaticMeshCompilingManager;
    friend class FStaticMeshAsyncBuildWorker;
    friend struct FStaticMeshUpdateContext;
    friend class FStaticMeshUpdate;
 
public:
#if WITH_EDITORONLY_DATA
    UPROPERTY(Instanced)
    TObjectPtr<class UObject> EditableMesh_DEPRECATED;
 
    UPROPERTY(EditAnywhere, Category = Collision)
    TObjectPtr<class UStaticMesh> ComplexCollisionMesh;
#endif
 
    UE_DEPRECATED(4.24, "Please use FStaticMeshAttributes::Register to do this.")
    ENGINE_API static void RegisterMeshAttributes( FMeshDescription& MeshDescription );
 
#if WITH_EDITORONLY_DATA
    /*
     * Return the MeshDescription associate to the LODIndex. The mesh description can be created on the fly if it was null
     * and there is a FRawMesh data for this LODIndex.
     */
    ENGINE_API FMeshDescription* GetMeshDescription(int32 LodIndex) const;
 
    /* 
     * Clone the MeshDescription associated to the LODIndex.
     *
     * This will make a copy of any pending mesh description that hasn't been committed or will deserialize
     * from the bulkdata or rawmesh directly if no current working copy exists.
     */
    ENGINE_API bool CloneMeshDescription(int32 LodIndex, FMeshDescription& OutMeshDescription) const;
 
    ENGINE_API bool IsMeshDescriptionValid(int32 LodIndex) const;
    ENGINE_API FMeshDescription* CreateMeshDescription(int32 LodIndex);
    ENGINE_API FMeshDescription* CreateMeshDescription(int32 LodIndex, FMeshDescription MeshDescription);
 
    struct FCommitMeshDescriptionParams
    {
        FCommitMeshDescriptionParams()
            : bMarkPackageDirty(true)
            , bUseHashAsGuid(false)
        {}
 
        bool bMarkPackageDirty;
 
        bool bUseHashAsGuid;
    };
 
    ENGINE_API void CommitMeshDescription(int32 LodIndex, const FCommitMeshDescriptionParams& Params = FCommitMeshDescriptionParams());
 
    ENGINE_API void ClearMeshDescription(int32 LodIndex);
 
    ENGINE_API void ClearMeshDescriptions();
 
    ENGINE_API bool LoadHiResMeshDescription(FMeshDescription& OutMeshDescription) const;
    ENGINE_API bool CloneHiResMeshDescription(FMeshDescription& OutMeshDescription) const;
    ENGINE_API FMeshDescription* CreateHiResMeshDescription();
    ENGINE_API FMeshDescription* CreateHiResMeshDescription(FMeshDescription MeshDescription);
    ENGINE_API FMeshDescription* GetHiResMeshDescription() const;
    ENGINE_API bool IsHiResMeshDescriptionValid() const;
    ENGINE_API void CommitHiResMeshDescription(const FCommitMeshDescriptionParams& Params = FCommitMeshDescriptionParams());
    ENGINE_API void ClearHiResMeshDescription();
 
    ENGINE_API bool ModifyMeshDescription(int32 LodIndex, bool bAlwaysMarkDirty = true);
 
    ENGINE_API bool ModifyAllMeshDescriptions(bool bAlwaysMarkDirty = true);
 
    ENGINE_API bool ModifyHiResMeshDescription(bool bAlwaysMarkDirty = true);
 
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    class UAssetImportData* GetAssetImportData() const
    {
        return AssetImportData;
    }
 
    void SetAssetImportData(class UAssetImportData* InAssetImportData)
    {
        AssetImportData = InAssetImportData;
    }
 
    static FName GetAssetImportDataMemberName()
    {
        return GET_MEMBER_NAME_CHECKED(UStaticMesh, AssetImportData);
    }
 
    class UThumbnailInfo* GetThumbnailInfo() const
    {
        return ThumbnailInfo;
    }
 
    void SetThumbnailInfo(class UThumbnailInfo* InThumbnailInfo)
    {
        ThumbnailInfo = InThumbnailInfo;
    }
 
    static FName GetThumbnailInfoMemberName()
    {
        return GET_MEMBER_NAME_CHECKED(UStaticMesh, ThumbnailInfo);
    }
 
    const FAssetEditorOrbitCameraPosition& GetEditorCameraPosition()
    {
        return EditorCameraPosition;
    }
 
    void SetEditorCameraPosition(const FAssetEditorOrbitCameraPosition& Position)
    {
        EditorCameraPosition = Position;
    }
 
    bool GetCustomizedCollision()
    {
        return bCustomizedCollision;
    }
 
    void SetCustomizedCollision(bool bInCustomizedCollision)
    {
        bCustomizedCollision = bInCustomizedCollision;
    }
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    ENGINE_API bool AddUVChannel(int32 LODIndex);
 
    ENGINE_API bool InsertUVChannel(int32 LODIndex, int32 UVChannelIndex);
 
    ENGINE_API bool RemoveUVChannel(int32 LODIndex, int32 UVChannelIndex);
 
    ENGINE_API bool SetUVChannel(int32 LODIndex, int32 UVChannelIndex, const TMap<FVertexInstanceID, FVector2D>& TexCoords);
 
    ENGINE_API bool SetUVChannel(int32 LODIndex, int32 UVChannelIndex, const TMap<FVertexInstanceID, FVector2f>& TexCoords);
 
#endif
 
    UFUNCTION(BlueprintCallable, Category="StaticMesh")
    static ENGINE_API UStaticMeshDescription* CreateStaticMeshDescription(UObject* Outer = nullptr);
 
    UFUNCTION(BlueprintCallable, Category="StaticMesh")
    ENGINE_API void BuildFromStaticMeshDescriptions(const TArray<UStaticMeshDescription*>& StaticMeshDescriptions, bool bBuildSimpleCollision = false, bool bFastBuild = true);
 
    UFUNCTION(BlueprintCallable, Category="StaticMesh")
    ENGINE_API UStaticMeshDescription* GetStaticMeshDescription(int32 LODIndex);
 
    struct FBuildMeshDescriptionsLODParams
    {
        bool bUseHighPrecisionTangentBasis = false;
 
        bool bUseFullPrecisionUVs = false;
    };
 
    struct FBuildMeshDescriptionsParams
    {
        FBuildMeshDescriptionsParams()
            : bMarkPackageDirty(true)
            , bUseHashAsGuid(false)
            , bBuildSimpleCollision(false)
            , bCommitMeshDescription(true)
            , bFastBuild(false)
            , bAllowCpuAccess(false)
        {}
 
        bool bMarkPackageDirty;
 
        bool bUseHashAsGuid;
 
        bool bBuildSimpleCollision;
    
        bool bCommitMeshDescription;
 
        bool bFastBuild;
 
        bool bAllowCpuAccess;
 
        TArray<FBuildMeshDescriptionsLODParams> PerLODOverrides;
    };
 
    ENGINE_API bool BuildFromMeshDescriptions(const TArray<const FMeshDescription*>& MeshDescriptions, const FBuildMeshDescriptionsParams& Params = FBuildMeshDescriptionsParams());
    
    ENGINE_API void BuildFromMeshDescription(const FMeshDescription& MeshDescription, FStaticMeshLODResources& LODResources);
 
    ENGINE_API void ExportStaticMeshLOD(const FStaticMeshLODResources& InLODResources, FMeshDescription& OutMeshDescription) const;
 
    ENGINE_API int32 GetNumUVChannels(int32 LODIndex) const;
 
private:
    UE_DEPRECATED(5.0, "This must be protected for async build, always use the accessors even internally.")
    UPROPERTY(VisibleAnywhere, transient, duplicatetransient, Instanced, Category = Navigation, meta = (EditCondition = "bHasNavigationData"))
    TObjectPtr<UNavCollisionBase> NavCollision;
 
public:
    ENGINE_API void SetNavCollision(UNavCollisionBase*);
    ENGINE_API UNavCollisionBase* GetNavCollision() const;
    ENGINE_API FBox GetNavigationBounds(const FTransform& LocalToWorld) const;
    ENGINE_API bool IsNavigationRelevant() const;
 
    ENGINE_API UStaticMesh(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
 
    //~ Begin UObject Interface.
#if WITH_EDITOR
    ENGINE_API virtual void PreEditChange(FProperty* PropertyAboutToChange) override;
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual void PostEditUndo() override;
    ENGINE_API virtual EDataValidationResult IsDataValid(class FDataValidationContext& Context) const override;
    ENGINE_API virtual void GetAssetRegistryTagMetadata(TMap<FName, FAssetRegistryTagMetadata>& OutMetadata) const override;
    
    ENGINE_API virtual void WillNeverCacheCookedPlatformDataAgain() override;
    ENGINE_API virtual void ClearCachedCookedPlatformData(const ITargetPlatform* TargetPlatform) override;
    ENGINE_API virtual void ClearAllCachedCookedPlatformData() override;
    ENGINE_API virtual void BeginCacheForCookedPlatformData(const ITargetPlatform* TargetPlatform) override;
    ENGINE_API virtual bool IsCachedCookedPlatformDataLoaded(const ITargetPlatform* TargetPlatform) override;
    ENGINE_API void SetLODGroup(FName NewGroup, bool bRebuildImmediately = true, bool bAllowModify = true);
    ENGINE_API void BroadcastNavCollisionChange();
 
    FOnExtendedBoundsChanged& GetOnExtendedBoundsChanged() { return OnExtendedBoundsChanged; }
    FOnMeshChanged& GetOnMeshChanged() { return OnMeshChanged; }
 
    /*
     * Add or change the LOD data specified by LodIndex with the content of the sourceStaticMesh.
     *
     * @Param SourceStaticMesh - The data we want to use to add or modify the specified lod
     * @Param LodIndex - The lod index we want to add or modify.
     * @Param SourceDataFilename - The source filename thta need to set into the LOD to allow re-import.
     */
    ENGINE_API bool SetCustomLOD(const UStaticMesh* SourceStaticMesh, int32 LodIndex, const FString& SourceDataFilename);
 
    /*
     * Static function that remove any trailing unused material.
     *
     * @Param StaticMesh - The static mesh we want to remove the trailing materials.
     */
    ENGINE_API static void RemoveUnusedMaterialSlots(UStaticMesh* StaticMesh);
 
    //SourceModels API
    ENGINE_API FStaticMeshSourceModel& AddSourceModel();
 
    UFUNCTION(BlueprintCallable, Category="StaticMesh")
    ENGINE_API void SetNumSourceModels(int32 Num);
 
    ENGINE_API void RemoveSourceModel(int32 Index);
    ENGINE_API const TArray<FStaticMeshSourceModel>& GetSourceModels() const;
    ENGINE_API FStaticMeshSourceModel& GetSourceModel(int32 Index);
    ENGINE_API const FStaticMeshSourceModel& GetSourceModel(int32 Index) const;
    ENGINE_API int32 GetNumSourceModels() const;
    ENGINE_API bool IsSourceModelValid(int32 Index) const;
    ENGINE_API TArray<FStaticMeshSourceModel>&& MoveSourceModels();
    ENGINE_API void SetSourceModels(TArray<FStaticMeshSourceModel>&& SourceModels);
 
    ENGINE_API FStaticMeshSourceModel& GetHiResSourceModel();
    ENGINE_API const FStaticMeshSourceModel& GetHiResSourceModel() const;
    ENGINE_API FStaticMeshSourceModel&& MoveHiResSourceModel();
    ENGINE_API void SetHiResSourceModel(FStaticMeshSourceModel&& SourceModel);
 
    ENGINE_API FMeshSectionInfoMap& GetSectionInfoMap();
    ENGINE_API const FMeshSectionInfoMap& GetSectionInfoMap() const;
    ENGINE_API FMeshSectionInfoMap& GetOriginalSectionInfoMap();
    ENGINE_API const FMeshSectionInfoMap& GetOriginalSectionInfoMap() const;
 
    ENGINE_API bool IsAsyncTaskComplete() const;
    
    ENGINE_API bool TryCancelAsyncTasks();
 
    TUniquePtr<FStaticMeshAsyncBuildTask> AsyncTask;
#endif // WITH_EDITOR
 
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual void PostLoad() override;
#if WITH_EDITORONLY_DATA
    ENGINE_API static void DeclareConstructClasses(TArray<FTopLevelAssetPath>& OutConstructClasses, const UClass* SpecificSubclass);
    ENGINE_API static void AppendToClassSchema(FAppendToClassSchemaContext& Context);
#endif
    ENGINE_API virtual bool IsPostLoadThreadSafe() const override;
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual bool IsReadyForFinishDestroy() override;
    ENGINE_API virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const override;
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    ENGINE_API virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const override;
    ENGINE_API virtual FString GetDesc() override;
    ENGINE_API virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    ENGINE_API virtual bool CanBeClusterRoot() const override;
    //~ End UObject Interface.
 
    //~ Begin UStreamableRenderAsset Interface
    ENGINE_API virtual int32 CalcCumulativeLODSize(int32 NumLODs) const final override;
    ENGINE_API virtual FIoFilenameHash GetMipIoFilenameHash(const int32 MipIndex) const final override;
    ENGINE_API virtual bool DoesMipDataExist(const int32 MipIndex) const final override;
    ENGINE_API virtual bool HasPendingRenderResourceInitialization() const final override;
    ENGINE_API virtual bool StreamOut(int32 NewMipCount) final override;
    ENGINE_API virtual bool StreamIn(int32 NewMipCount, bool bHighPrio) final override;
    ENGINE_API virtual EStreamableRenderAssetType GetRenderAssetType() const final override;
    //~ End UStreamableRenderAsset Interface
 
    ENGINE_API static void CancelAllPendingStreamingActions();
 
    struct FBuildParameters
    {
        // Required to work around a Clang bug
#if PLATFORM_COMPILER_CLANG
        FBuildParameters()
            : bInSilent(false)
            , OutErrors(nullptr)
            , bInRebuildUVChannelData(false)
            , bInEnforceLightmapRestrictions(false)
        {
            PRAGMA_DISABLE_DEPRECATION_WARNINGS
            bIgnoreBoundsDiff = false;
            PRAGMA_ENABLE_DEPRECATION_WARNINGS
        }
#else
        FBuildParameters() = default;
#endif
 
        FBuildParameters(const FBuildParameters& Other)
        {
            bInSilent = Other.bInSilent;
            OutErrors = Other.OutErrors;
            bInRebuildUVChannelData = Other.bInRebuildUVChannelData;
            bInEnforceLightmapRestrictions = Other.bInEnforceLightmapRestrictions;
 
            PRAGMA_DISABLE_DEPRECATION_WARNINGS
            bIgnoreBoundsDiff = Other.bIgnoreBoundsDiff;
            PRAGMA_ENABLE_DEPRECATION_WARNINGS
        }
 
        // If true will not popup a progress dialog.
        bool bInSilent = false;
 
        // If provided, will contain the errors that occurred during this process.This will prevent async static mesh compilation because OutErrors could get out of scope.
        TArray<FText>* OutErrors = nullptr;
 
        // Whether to completely rebuild the UV Channel data after the render data has been computed.
        bool bInRebuildUVChannelData = false;
 
        // Whether to call EnforceLightmapRestrictions as part of the build process.
        bool bInEnforceLightmapRestrictions = false;
 
        // Whether to avoid outputting a warning if the render data and MeshDescription bounds differ too much.
        UE_DEPRECATED(5.7, "This option no longer has any effect and will be removed in a future release.")
        bool bIgnoreBoundsDiff = false;
    };
 
    ENGINE_API void Build(bool bInSilent, TArray<FText>* OutErrors = nullptr);
 
    ENGINE_API static void BatchBuild(const TArray<UStaticMesh*>& InStaticMeshes, bool bInSilent, TFunction<bool(UStaticMesh*)> InProgressCallback = nullptr, TArray<FText>* OutErrors = nullptr);
 
    ENGINE_API void Build(const FBuildParameters& BuildParameters = FBuildParameters());
 
    ENGINE_API static void BatchBuild(const TArray<UStaticMesh*>& InStaticMeshes, const FBuildParameters& BuildParameters = FBuildParameters(), TFunction<bool(UStaticMesh*)> InProgressCallback = nullptr);
 
    ENGINE_API virtual void InitResources();
 
    ENGINE_API virtual void ReleaseResources();
 
    ENGINE_API void UpdateUVChannelData(bool bRebuildAll);
 
    ENGINE_API FBox GetMaterialBox(int32 MaterialIndex, const FTransform& Transform) const;
 
    ENGINE_API const FMeshUVChannelInfo* GetUVChannelData(int32 MaterialIndex) const;
 
    UFUNCTION(BlueprintPure, Category = StaticMesh)
    ENGINE_API int32 GetNumVertices(int32 LODIndex) const;
 
    UFUNCTION(BlueprintPure, Category = StaticMesh)
    ENGINE_API int32 GetNumTriangles(int32 LODIndex) const;
 
    ENGINE_API int32 GetNumTexCoords(int32 LODIndex) const;
 
    ENGINE_API int32 GetNumNaniteVertices() const;
 
    ENGINE_API int32 GetNumNaniteTriangles() const;
 
    UFUNCTION(BlueprintPure, Category = "StaticMesh", meta=(ScriptName="GetNumLods"))
    ENGINE_API int32 GetNumLODs() const;
 
    ENGINE_API bool HasValidRenderData(bool bCheckLODForVerts = true, int32 LODIndex = INDEX_NONE) const;
 
    ENGINE_API bool HasValidNaniteData() const;
 
    ENGINE_API bool HasNaniteFallbackMesh(EShaderPlatform ShaderPlatform) const;
 
    UFUNCTION( BlueprintPure, Category="StaticMesh" )
    ENGINE_API FBoxSphereBounds GetBounds() const;
 
    UFUNCTION(BlueprintPure, Category="StaticMesh")
    ENGINE_API FBox GetBoundingBox() const;
 
    UFUNCTION(BlueprintPure, Category = "StaticMesh")
    ENGINE_API int32 GetNumSections(int32 InLOD) const;
 
    UFUNCTION(BlueprintPure, Category = "StaticMesh")
    ENGINE_API UMaterialInterface* GetMaterial(int32 MaterialIndex) const;
 
    UFUNCTION(BlueprintCallable, Category = "StaticMesh")
    ENGINE_API FName AddMaterial(UMaterialInterface* Material);
 
    UFUNCTION(BlueprintPure, Category = "StaticMesh")
    ENGINE_API int32 GetMaterialIndex(FName MaterialSlotName) const;
 
    ENGINE_API int32 GetMaterialIndexFromImportedMaterialSlotName(FName ImportedMaterialSlotName) const;
 
 
    ENGINE_API void GetUsedMaterials(TArray<UMaterialInterface*>& OutMaterials, TFunctionRef<UMaterialInterface*(int32)> OverrideMaterial) const;
 
    ENGINE_API const FStaticMeshLODResources& GetLODForExport(int32 LODIndex) const;
 
    ENGINE_API static void CheckLightMapUVs( UStaticMesh* InStaticMesh, TArray< FString >& InOutAssetsWithMissingUVSets, TArray< FString >& InOutAssetsWithBadUVSets, TArray< FString >& InOutAssetsWithValidUVSets, bool bInVerbose = true );
 
    //~ Begin Interface_CollisionDataProvider Interface
    ENGINE_API virtual bool GetPhysicsTriMeshData(struct FTriMeshCollisionData* CollisionData, bool InUseAllTriData) override;
    ENGINE_API virtual bool ContainsPhysicsTriMeshData(bool InUseAllTriData) const override;
    ENGINE_API virtual bool PollAsyncPhysicsTriMeshData(bool InUseAllTriData) const override;
    ENGINE_API virtual bool GetTriMeshSizeEstimates(struct FTriMeshCollisionDataEstimates& OutTriMeshEstimates, bool bInUseAllTriData) const override;
 
private:
    bool GetPhysicsTriMeshDataCheckComplex(struct FTriMeshCollisionData* CollisionData, bool bInUseAllTriData, bool bInCheckComplexCollisionMesh);
    bool PollAsyncPhysicsTriMeshDataCheckComplex(bool InUseAllTriData, bool bInCheckComplexCollisionMesh) const;
    bool ContainsPhysicsTriMeshDataCheckComplex(bool InUseAllTriData, bool bInCheckComplexCollisionMesh) const;
    bool SectionHasCollisionEnabled(const FStaticMeshSection& Section, int32 LODIndex, int32 SectionIndex) const;
 
public:
 
    virtual bool WantsNegXTriMesh() override
    {
        return true;
    }
    ENGINE_API virtual void GetMeshId(FString& OutMeshId) override;
    //~ End Interface_CollisionDataProvider Interface
 
    int32 GetNumSectionsWithCollision() const;
 
    //~ Begin IInterface_AssetUserData Interface
    ENGINE_API virtual void AddAssetUserData(UAssetUserData* InUserData) override;
    ENGINE_API virtual void RemoveUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) override;
    ENGINE_API virtual UAssetUserData* GetAssetUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) override;
    ENGINE_API virtual const TArray<UAssetUserData*>* GetAssetUserDataArray() const override;
    //~ End IInterface_AssetUserData Interface
 
 
    ENGINE_API void CreateBodySetup();
 
    ENGINE_API void CreateNavCollision(const bool bIsUpdate = false);
 
    ENGINE_API void RecreateNavCollision();
 
    ENGINE_API void MarkAsNotHavingNavigationData();
 
 
    UFUNCTION(BlueprintCallable, Category = "StaticMesh")
    ENGINE_API void AddSocket(UStaticMeshSocket* Socket);
 
    UFUNCTION(BlueprintPure, Category = "StaticMesh")
    ENGINE_API class UStaticMeshSocket* FindSocket(FName InSocketName) const;
 
    UFUNCTION(BlueprintCallable, Category = "StaticMesh")
    ENGINE_API void RemoveSocket(UStaticMeshSocket* Socket);
 
    UFUNCTION(BlueprintPure, Category = "StaticMesh")
    ENGINE_API TArray<UStaticMeshSocket*> GetSocketsByTag(const FString& InSocketTag) const;
 
    ENGINE_API void GetVertexColorData(TMap<FVector3f, FColor>& VertexColorData);
 
    ENGINE_API void SetVertexColorData(const TMap<FVector3f, FColor>& VertexColorData);
 
    ENGINE_API void RemoveVertexColors();
 
    ENGINE_API void EnforceLightmapRestrictions(bool bUseRenderData = true);
 
    ENGINE_API void CalculateExtendedBounds();
 
    inline bool AreRenderingResourcesInitialized() const { return bRenderingResourcesInitialized; }
 
    static FName GetLODPathName(const UStaticMesh* Mesh, int32 LODIndex);
 
#if WITH_EDITOR
 
    UFUNCTION(BlueprintCallable, Category = "StaticMesh")
    ENGINE_API void SetMaterial(int32 MaterialIndex, UMaterialInterface* NewMaterial);
 
    ENGINE_API bool CanLODsShareStaticLighting() const;
 
    ENGINE_API static void GetLODGroups(TArray<FName>& OutLODGroups);
 
    ENGINE_API static void GetLODGroupsDisplayNames(TArray<FText>& OutLODGroupsDisplayNames);
 
    ENGINE_API void GenerateLodsInPackage();
 
    ENGINE_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
 
    FOnPreMeshBuild& OnPreMeshBuild() { return PreMeshBuild; }
 
    FOnPostMeshBuild& OnPostMeshBuild() { return PostMeshBuild; }
    
 
    /* Return true if the reduction settings are setup to reduce a LOD*/
    ENGINE_API bool IsReductionActive(int32 LODIndex) const;
 
    /* Get a copy of the reduction settings for a specified LOD index. */
    ENGINE_API struct FMeshReductionSettings GetReductionSettings(int32 LODIndex) const;
 
    bool GetEnableLODStreaming(const class ITargetPlatform* TargetPlatform) const;
 
    /* Get a static mesh render data for requested platform. */
    static FStaticMeshRenderData& GetPlatformStaticMeshRenderData(UStaticMesh* Mesh, const ITargetPlatform* Platform);
 
private:
    void ConvertLegacyLODDistance();
 
    void ConvertLegacyLODScreenArea();
 
    void FixupZeroTriangleSections();
 
    void ConvertLegacySourceData();
    
    bool CanBuild() const;
 
    void BeginBuildInternal(FStaticMeshBuildContext* Context = nullptr);
 
    bool ExecuteBuildInternal(const FBuildParameters& BuildParameters);
 
    void FinishBuildInternal(const TArray<IStaticMeshComponent*>& InAffectedComponents, bool bHasRenderDataChanged, bool bShouldComputeExtendedBounds = true);
 
#if WITH_EDITORONLY_DATA
    bool LoadMeshDescription(int32 LodIndex, FMeshDescription& OutMeshDescription) const;
#endif
 
public:
    ENGINE_API void CacheDerivedData();
 
    ENGINE_API int64 GetBuildRequiredMemoryEstimate() const;
 
    ENGINE_API void PrepareDerivedDataForActiveTargetPlatforms();
 
private:
    // Filled at CommitDescription time and reused during build
    TOptional<FBoxSphereBounds> CachedMeshDescriptionBounds;
 
    // Notification about missing Nanite required shader models.
    TWeakPtr<class SNotificationItem> ShaderModelNotificationPtr;
 
    void CheckForValidMinLODs(FPerQualityLevelInt& QualityLocalMinLOD, FPerPlatformInt& LocalMinLOD, int32& OutMinAvailableLOD, TArray<TPair<int32, FName>>& OutInvalidMinLODs) const;
    void CheckForMissingShaderModels();
 
    FOnPreMeshBuild PreMeshBuild;
    FOnPostMeshBuild PostMeshBuild;
 
    bool bCleanUpRedundantMaterialPostLoad;
 
    bool bIsInPostEditChange = false;
#endif // #if WITH_EDITOR
 
    void BeginPostLoadInternal(FStaticMeshPostLoadContext& Context);
 
    void ExecutePostLoadInternal(FStaticMeshPostLoadContext& Context);
 
    void FinishPostLoadInternal(FStaticMeshPostLoadContext& Context);
};
 
class FStaticMeshCompilationContext
{
public:
    FStaticMeshCompilationContext();
    // Non-copyable
    FStaticMeshCompilationContext(const FStaticMeshCompilationContext&) = delete;
    FStaticMeshCompilationContext& operator=(const FStaticMeshCompilationContext&) = delete;
    // Movable
    FStaticMeshCompilationContext(FStaticMeshCompilationContext&&) = delete;
    FStaticMeshCompilationContext& operator=(FStaticMeshCompilationContext&&) = delete;
 
    bool bShouldComputeExtendedBounds = false;
    bool bIsEditorLoadingPackage = false;
    UE::Tasks::FCancellationToken CancellationToken;
};
 
class FStaticMeshPostLoadContext : public FStaticMeshCompilationContext
{
public:
    bool bNeedsMeshUVDensityFix = false;
    bool bNeedsMaterialFixup = false;
    bool bIsCookedForEditor = false;
};
 
class FStaticMeshBuildContext : public FStaticMeshCompilationContext
{
public:
    FStaticMeshBuildContext(const UStaticMesh::FBuildParameters& InBuildParameters)
        : BuildParameters(InBuildParameters)
    {
    }
 
    UStaticMesh::FBuildParameters BuildParameters;
    bool bHasRenderDataChanged = false;
};
 
struct FStaticMeshBuildParameters
{
    FStaticMeshBuildParameters(UStaticMesh* InStaticMesh, const ITargetPlatform* InTargetPlatform, const FStaticMeshLODGroup& InLODGroup)
        : StaticMesh(InStaticMesh)
        , TargetPlatform(InTargetPlatform)
        , LODGroup(InLODGroup)
    {}
 
    UStaticMesh* StaticMesh;
    const ITargetPlatform* TargetPlatform;
    const FStaticMeshLODGroup& LODGroup;
};
 
namespace UE::Private::StaticMesh
{
#if WITH_EDITOR
    ENGINE_API FString BuildStaticMeshDerivedDataKey(const ITargetPlatform* TargetPlatform, UStaticMesh* Mesh, const FStaticMeshLODGroup& LODGroup);
#endif
}