StaticMeshComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "RHIResources.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Misc/Guid.h"
#include "UObject/Class.h"
#include "Engine/EngineTypes.h"
#include "Engine/TextureStreamingTypes.h"
#include "Components/MeshComponent.h"
#include "Components/ActorStaticMeshComponentInterface.h"
#include "PackedNormal.h"
#include "Templates/UniquePtr.h"
#include "Runtime/Launch/Resources/Version.h"
#include "UObject/RenderingObjectVersion.h"
#include "SceneTypes.h"
#include "DrawDebugHelpers.h"
#include "StateStream/StaticMeshStateStreamHandle.h"
#include "StaticMeshComponent.generated.h"
 
class FColorVertexBuffer;
class FLightingBuildOptions;
class FMeshMapBuildData;
class FPrimitiveSceneProxy;
class FStaticMeshStaticLightingMesh;
class FVertexFactoryType;
class ULightComponent;
class UStaticMesh;
class UStaticMeshComponent;
class UNavCollisionBase;
class UWorld;
struct FConvexVolume;
struct FEngineShowFlags;
struct FNavigableGeometryExport;
struct FNavigationRelevantData;
struct FStaticMeshComponentLODInfo;
struct FStaticLightingPrimitiveInfo;
struct FStaticMeshLODResources;
 
#define STATICMESH_ENABLE_DEBUG_RENDERING           ENABLE_DRAW_DEBUG
 
namespace Nanite
{
    struct FResources;
    struct FMaterialAudit;
}
 
USTRUCT()
struct FPaintedVertex
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    FVector Position;
 
    UPROPERTY()
    FColor Color;
 
    UPROPERTY()
    FVector4 Normal;
 
    FPaintedVertex()
        : Position(ForceInit)
        , Color(ForceInit)
    {
    }
 
    inline friend FArchive& operator<<(FArchive& Ar, FPaintedVertex& PaintedVertex)
    {
        Ar << PaintedVertex.Position;
 
        if (Ar.CustomVer(FRenderingObjectVersion::GUID) < FRenderingObjectVersion::IncreaseNormalPrecision)
        {
            FDeprecatedSerializedPackedNormal Temp;
            Ar << Temp;
            PaintedVertex.Normal = Temp;
        }
        else
        {
            Ar << PaintedVertex.Normal;
        }
        
        Ar << PaintedVertex.Color;
        return Ar;
    }
    
};
 
UCLASS(Blueprintable, ClassGroup=(Rendering, Common), hidecategories=(Object,Activation,"Components|Activation"), ShowCategories=(Mobility), editinlinenew, meta=(BlueprintSpawnableComponent), MinimalAPI)
class UStaticMeshComponent : public UMeshComponent
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=LOD)
    int32 ForcedLodModel;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=LOD, meta=(editcondition = "bOverrideMinLOD"))
    int32 MinLOD;
 
    UPROPERTY()
    int32 SubDivisionStepSize;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Rendering, meta=(editcondition = "bOverrideWireframeColor"))
    FColor WireframeColorOverride;
 
private:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=StaticMesh, ReplicatedUsing=OnRep_StaticMesh, meta=(AllowPrivateAccess="true"))
    TObjectPtr<class UStaticMesh> StaticMesh;
 
    ENGINE_API void SetStaticMeshInternal(UStaticMesh* StaticMesh);
 
#if WITH_EDITOR
    class UStaticMesh* KnownStaticMesh = nullptr;
#endif
    ENGINE_API void NotifyIfStaticMeshChanged();
 
#if WITH_STATE_STREAM_ACTOR
    FStaticMeshHandle MeshHandle;
#endif
 
public:
    static const FName GetMemberNameChecked_StaticMesh() { return GET_MEMBER_NAME_CHECKED(UStaticMeshComponent, StaticMesh); }
 
    UFUNCTION()
    ENGINE_API void OnRep_StaticMesh(class UStaticMesh *OldStaticMesh);
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Rendering)
    int32 WorldPositionOffsetDisableDistance = 0;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = Rendering)
    uint8 bForceNaniteForMasked : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = Rendering)
    uint8 bDisallowNanite : 1;
 
    UPROPERTY()
    uint8 bForceDisableNanite : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = Rendering)
    uint8 bEvaluateWorldPositionOffset : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = Rendering)
    uint8 bWorldPositionOffsetWritesVelocity : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = RayTracing)
    uint8 bEvaluateWorldPositionOffsetInRayTracing : 1;
 
protected:
    uint8 bInitialEvaluateWorldPositionOffset : 1;
 
    uint8 bMipLevelCallbackRegistered : 1;
 
    uint8 bSupportMeshPainting : 1;
 
    uint8 bPrecachedPSOs : 1;
 
public:
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(transient)
    int32 SelectedEditorSection;
    UPROPERTY(transient)
    int32 SelectedEditorMaterial;
    UPROPERTY(transient)
    int32 SectionIndexPreview;
    UPROPERTY(transient)
    int32 MaterialIndexPreview;
 
    /*
     * The import version of the static mesh when it was assign this is update when:
     * - The user assign a new staticmesh to the component
     * - The component is serialize (IsSaving)
     * - Default value is BeforeImportStaticMeshVersionWasAdded
     *
     * If when the component get load (PostLoad) the version of the attach staticmesh is newer
     * then this value, we will remap the material override because the order of the materials list
     * in the staticmesh can be changed. Hopefully there is a remap table save in the staticmesh.
     */
    UPROPERTY()
    int32 StaticMeshImportVersion;
#endif
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Rendering, meta=(InlineEditConditionToggle))
    uint8 bOverrideWireframeColor:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=LOD)
    uint8 bOverrideMinLOD:1;
 
    UPROPERTY(transient)
    uint8 bOverrideNavigationExport : 1;
 
    UPROPERTY(transient)
    uint8 bForceNavigationObstacle : 1;
 
    UPROPERTY()
    uint8 bDisallowMeshPaintPerInstance_DEPRECATED : 1;
 
#if STATICMESH_ENABLE_DEBUG_RENDERING
    uint8 bDrawMeshCollisionIfComplex : 1;
    uint8 bDrawMeshCollisionIfSimple : 1;
#endif
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=TextureStreaming)
    uint8 bIgnoreInstanceForTextureStreaming:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Lighting, meta=(InlineEditConditionToggle))
    uint8 bOverrideLightMapRes:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting, meta=(DisplayName = "Distance Field Indirect Shadow"))
    uint8 bCastDistanceFieldIndirectShadow:1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting)
    uint8 bOverrideDistanceFieldSelfShadowBias:1;
 
    UPROPERTY()
    uint8 bUseSubDivisions:1;
 
    UPROPERTY(EditAnywhere, Category = Collision)
    uint8 bUseDefaultCollision:1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    uint8 bCustomOverrideVertexColorPerLOD:1;
 
    UPROPERTY(transient)
    uint8 bDisplayVertexColors:1;
 
    UPROPERTY(transient)
    uint8 bDisplayPhysicalMaterialMasks : 1;
 
    UPROPERTY()
    uint8 bDisplayNaniteFallbackMesh:1;
 
    UPROPERTY(transient)
    uint8 bRegistering : 1;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Lighting, meta = (UIMin = "0", UIMax = "1", DisplayName = "Sort Triangles"))
    uint8 bSortTriangles : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting)
    uint8 bReverseCulling : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh Painting")
    uint8 bEnableVertexColorMeshPainting : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh Painting")
    uint8 bEnableTextureColorMeshPainting : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh Painting", meta=(InlineEditConditionToggle))
    uint8 bOverrideMeshPaintTextureCoordinateIndex : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh Painting", meta=(InlineEditConditionToggle))
    uint8 bOverrideMeshPaintTextureResolution : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category = "Mesh Painting", meta=(UIMin = "0", UIMax = "3", editcondition = "bOverrideMeshPaintTextureCoordinateIndex"))
    int32 OverriddenMeshPaintTextureCoordinateIndex;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category = "Mesh Painting", meta = (UIMin = "0", UIMax = "4096", ClampMax = "4096", editcondition = "bOverrideMeshPaintTextureResolution"))
    int32 OverriddenMeshPaintTextureResolution;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Lighting, meta=(ClampMax = 4096, editcondition="bOverrideLightMapRes") )
    int32 OverriddenLightMapRes;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(VisibleAnywhere, Category = "Mesh Painting")
    TObjectPtr<UTexture> MeshPaintTexture;
#endif
 
    UPROPERTY(SkipSerialization)
    TObjectPtr<UTexture> MeshPaintTextureCooked;
 
    UPROPERTY(Transient)
    TObjectPtr<UTexture> MeshPaintTextureOverride;
 
    UPROPERTY(EditAnywhere, Experimental, BlueprintReadWrite, Category = "Material Cache")
    FIntPoint MaterialCacheTileCount = FIntPoint(8, 8);
 
    UPROPERTY(Transient, Experimental)
    TArray<TObjectPtr<class UMaterialCacheVirtualTexture>> MaterialCacheTextures;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting, meta=(UIMin = "0", UIMax = "1", DisplayName = "Distance Field Indirect Shadow Min Visibility"))
    float DistanceFieldIndirectShadowMinVisibility;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Lighting)
    float DistanceFieldSelfShadowBias;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=TextureStreaming, meta=(ClampMin = 0, ToolTip="Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution."))
    float StreamingDistanceMultiplier;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Rendering)
    float NanitePixelProgrammableDistance;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TArray<FGuid> IrrelevantLights_DEPRECATED;
#endif
 
    UPROPERTY(transient)
    TArray<struct FStaticMeshComponentLODInfo> LODData;
 
    UPROPERTY(NonTransactional)
    TArray<FStreamingTextureBuildInfo> StreamingTextureData;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FString StaticMeshDerivedDataKey;
 
    UPROPERTY(NonTransactional)
    TArray<uint32> MaterialStreamingRelativeBoxes;
#endif
 
    UPROPERTY(EditAnywhere, Category=Lighting)
    struct FLightmassPrimitiveSettings LightmassSettings;
 
    ENGINE_API virtual ~UStaticMeshComponent();
 
    UFUNCTION(BlueprintCallable, Category="Components|StaticMesh")
    ENGINE_API virtual bool SetStaticMesh(class UStaticMesh* NewMesh);
 
    TObjectPtr<UStaticMesh> GetStaticMesh() const 
    { 
#if WITH_EDITOR
        // This should never happen and is a last resort, we should have caught the property overwrite well before we reach this code
        if (KnownStaticMesh != StaticMesh)
        {
            OutdatedKnownStaticMeshDetected();
        }
#endif
        return StaticMesh; 
    }
 
    ENGINE_API virtual const Nanite::FResources* GetNaniteResources() const;
 
    ENGINE_API virtual bool HasValidNaniteData() const;
 
    ENGINE_API virtual bool UseNaniteOverrideMaterials() const override;
 
    UFUNCTION(BlueprintCallable, Category="Rendering|LOD")
    ENGINE_API void SetForcedLodModel(int32 NewForcedLodModel);
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Lighting")
    ENGINE_API void SetDistanceFieldSelfShadowBias(float NewValue);
 
    UFUNCTION(BlueprintCallable, Category=RayTracing)
    ENGINE_API void SetEvaluateWorldPositionOffsetInRayTracing(bool NewValue);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|LOD")
    ENGINE_API void SetEvaluateWorldPositionOffset(bool NewValue);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|LOD")
    ENGINE_API void SetWorldPositionOffsetDisableDistance(int32 NewValue);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|LOD")
    bool GetInitialEvaluateWorldPositionOffset() { return bInitialEvaluateWorldPositionOffset; }
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|LOD")
    void UpdateInitialEvaluateWorldPositionOffset() { bInitialEvaluateWorldPositionOffset = bEvaluateWorldPositionOffset; }
 
    UFUNCTION(BlueprintCallable, Category="Components|StaticMesh")
    ENGINE_API void GetLocalBounds(FVector& Min, FVector& Max) const;
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Lighting")
    ENGINE_API void SetReverseCulling(bool ReverseCulling);
 
    UFUNCTION(BlueprintCallable, Category="Rendering")
    ENGINE_API void SetForceDisableNanite(bool bInForceDisableNanite);
 
    ENGINE_API virtual void SetCollisionProfileName(FName InCollisionProfileName, bool bUpdateOverlaps=true) override;
 
public:
 
    //~ Begin UObject Interface.
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual void ExportCustomProperties(FOutputDevice& Out, uint32 Indent) override;
    ENGINE_API virtual void ImportCustomProperties(const TCHAR* SourceText, FFeedbackContext* Warn) override;   
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual void PostReinitProperties() override;
    ENGINE_API virtual void PostApplyToComponent() override;
#if WITH_EDITOR
    ENGINE_API virtual void PostEditUndo() override;
    ENGINE_API virtual void PreEditUndo() override;
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual bool CanEditChange(const FProperty* InProperty) const override;
    ENGINE_API virtual void BeginCacheForCookedPlatformData(const ITargetPlatform* TargetPlatform) override;
    ENGINE_API virtual bool IsCachedCookedPlatformDataLoaded(const ITargetPlatform* TargetPlatform) override;
    ENGINE_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
    ENGINE_API virtual void PostEditImport() override;
    ENGINE_API virtual void InitializeComponent() override;
    ENGINE_API virtual void UpdateBounds() override;
#endif // WITH_EDITOR
#if WITH_EDITORONLY_DATA
    ENGINE_API virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
#endif // WITH_EDITORONLY_DATA
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual bool IsPostLoadThreadSafe() const override;
    ENGINE_API virtual bool AreNativePropertiesIdenticalTo( UObject* Other ) const override;
    ENGINE_API virtual FString GetDetailedInfoInternal() const override;
    static ENGINE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
    //~ End UObject Interface.
 
    //~ 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 bool HasAnySockets() const override;
    ENGINE_API virtual void QuerySupportedSockets(TArray<FComponentSocketDescription>& OutSockets) const override;
    ENGINE_API virtual FTransform GetSocketTransform(FName InSocketName, ERelativeTransformSpace TransformSpace = RTS_World) const override;
    ENGINE_API virtual bool DoesSocketExist(FName InSocketName) const override;
    virtual bool ShouldCollideWhenPlacing() const override
    {
        // Current Method of collision does not work with non-capsule shapes, enable when it works with static meshes
        // return IsCollisionEnabled() && (StaticMesh != NULL);
        return false;
    }
#if WITH_EDITOR
    ENGINE_API virtual bool ShouldRenderSelected() const override;
#endif
    //~ End USceneComponent Interface
 
    UE_DECLARE_COMPONENT_ACTOR_INTERFACE(StaticMeshComponent)   
 
    //~ Begin UActorComponent Interface.
protected: 
    ENGINE_API virtual void OnRegister() override;
    ENGINE_API virtual void OnUnregister() override;
    ENGINE_API virtual void BeginPlay() override;
    ENGINE_API virtual bool RequiresGameThreadEndOfFrameRecreate() const override;
    ENGINE_API virtual void CreateRenderState_Concurrent(FRegisterComponentContext* Context) override;
    ENGINE_API virtual void OnCreatePhysicsState() override;
    ENGINE_API virtual void OnDestroyPhysicsState() override;
    ENGINE_API virtual void OnAsyncDestroyPhysicsStateEnd_GameThread() override;
    ENGINE_API virtual bool ShouldCreatePhysicsState() const override;
    ENGINE_API virtual bool ShouldCreateRenderState() const override;
    ENGINE_API virtual bool ShouldIncrementalPreRegister(UWorld* WorldContext) const override;
 
    
    ENGINE_API virtual void GetDefaultMaterialSlotsOverlayMaterial(TArray<TObjectPtr<UMaterialInterface>>& OutMaterialSlotOverlayMaterials) const override;
 
public:
 
    ENGINE_API virtual bool AllowsAsyncPhysicsStateCreation() const override;
    ENGINE_API virtual bool AllowsAsyncPhysicsStateDestruction() const override;
    ENGINE_API virtual void PrecachePSOs() override;
    ENGINE_API virtual void InvalidateLightingCacheDetailed(bool bInvalidateBuildEnqueuedLighting, bool bTranslationOnly) override;
    ENGINE_API virtual UObject const* AdditionalStatObject() const override;
#if WITH_EDITOR
    ENGINE_API virtual void CheckForErrors() override;
    ENGINE_API virtual bool IsCompiling() const override;
#endif
    ENGINE_API virtual TStructOnScope<FActorComponentInstanceData> GetComponentInstanceData() const override;
    ENGINE_API virtual bool IsHLODRelevant() const override;
#if WITH_EDITOR
    ENGINE_API virtual void ComputeHLODHash(class FHLODHashBuilder& HashBuilder) const override;
#endif
    //~ End UActorComponent Interface.
 
    //~ Begin UPrimitiveComponent Interface.
    ENGINE_API virtual int32 GetNumMaterials() const override;
#if WITH_EDITOR
    ENGINE_API virtual void GetStaticLightingInfo(FStaticLightingPrimitiveInfo& OutPrimitiveInfo,const TArray<ULightComponent*>& InRelevantLights,const FLightingBuildOptions& Options) override;
    ENGINE_API virtual void AddMapBuildDataGUIDs(TSet<FGuid>& InGUIDs) const override;
#endif
    ENGINE_API virtual float GetEmissiveBoost(int32 ElementIndex) const override;
    ENGINE_API virtual float GetDiffuseBoost(int32 ElementIndex) const override;
    virtual bool GetShadowIndirectOnly() const override
    {
        return LightmassSettings.bShadowIndirectOnly;
    }
    ENGINE_API virtual ELightMapInteractionType GetStaticLightingType() const override;
    ENGINE_API virtual bool IsPrecomputedLightingValid() const override;
 
    ENGINE_API virtual float GetTextureStreamingTransformScale() const;
    ENGINE_API virtual bool GetMaterialStreamingData(int32 MaterialIndex, FPrimitiveMaterialInfo& MaterialData) const override;
    ENGINE_API virtual bool BuildTextureStreamingDataImpl(ETextureStreamingBuildType BuildType, EMaterialQualityLevel::Type QualityLevel, ERHIFeatureLevel::Type FeatureLevel, TSet<FGuid>& DependentResources, bool& bOutSupportsBuildTextureStreamingData) override;
    ENGINE_API virtual void GetStreamingRenderAssetInfo(FStreamingTextureLevelContext& LevelContext, TArray<FStreamingRenderAssetPrimitiveInfo>& OutStreamingRenderAssets) const override;
    ENGINE_API virtual void GetUsedTextures(TArray<UTexture*>& OutTextures, EMaterialQualityLevel::Type QualityLevel) override;
#if WITH_EDITOR
    ENGINE_API virtual bool RemapActorTextureStreamingBuiltDataToLevel(const class UActorTextureStreamingBuildDataComponent* InActorTextureBuildData) override;
    ENGINE_API virtual uint32 ComputeHashTextureStreamingBuiltData() const override;
#endif 
 
    ENGINE_API virtual class UBodySetup* GetBodySetup() override;
    ENGINE_API virtual bool CanEditSimulatePhysics() override;
    ENGINE_API virtual FPrimitiveSceneProxy* CreateSceneProxy() override;
    ENGINE_API virtual bool ShouldRecreateProxyOnUpdateTransform() const override;
    ENGINE_API virtual bool UsesOnlyUnlitMaterials() const override;
    ENGINE_API virtual bool GetLightMapResolution( int32& Width, int32& Height ) const override;
    ENGINE_API virtual int32 GetStaticLightMapResolution() const override;
    ENGINE_API virtual bool HasValidSettingsForStaticLighting(bool bOverlookInvalidComponents) const override;
 
    ENGINE_API virtual void GetLightAndShadowMapMemoryUsage( int32& LightMapMemoryUsage, int32& ShadowMapMemoryUsage ) const override;
    ENGINE_API virtual void GetUsedMaterials(TArray<UMaterialInterface*>& OutMaterials, bool bGetDebugMaterials = false) const final;
    ENGINE_API virtual UMaterialInterface* GetMaterial(int32 MaterialIndex) const final;
#if WITH_EDITOR
    ENGINE_API virtual UMaterialInterface* GetEditorMaterial(int32 MaterialIndex) const override;
#endif
    ENGINE_API virtual int32 GetMaterialIndex(FName MaterialSlotName) const override;
    ENGINE_API virtual UMaterialInterface* GetMaterialFromCollisionFaceIndex(int32 FaceIndex, int32& SectionIndex) const override;
    ENGINE_API virtual TArray<FName> GetMaterialSlotNames() const override;
    ENGINE_API virtual bool IsMaterialSlotNameValid(FName MaterialSlotName) const override;
 
    ENGINE_API virtual bool DoCustomNavigableGeometryExport(FNavigableGeometryExport& GeomExport) const override;
 
    ENGINE_API virtual bool IsShown(const FEngineShowFlags& ShowFlags) const override;
#if WITH_EDITOR
    ENGINE_API void OnMeshRebuild(bool bRenderDataChanged);
    ENGINE_API virtual void PreStaticMeshCompilation();
    ENGINE_API virtual void PostStaticMeshCompilation();
    ENGINE_API virtual bool ComponentIsTouchingSelectionBox(const FBox& InSelBBox, const bool bConsiderOnlyBSP, const bool bMustEncompassEntireComponent) const override;
    ENGINE_API virtual bool ComponentIsTouchingSelectionFrustum(const FConvexVolume& InSelBBox, const bool bConsiderOnlyBSP, const bool bMustEncompassEntireComponent) const override;
#endif
    virtual float GetStreamingScale() const override { return GetComponentTransform().GetMaximumAxisScale(); }
    virtual bool SupportsWorldPositionOffsetVelocity() const override { return bWorldPositionOffsetWritesVelocity; }
    ENGINE_API virtual void GetPrimitiveStats(FPrimitiveStats& PrimitiveStats) const override;  
#if WITH_EDITOR
    ENGINE_API virtual HHitProxy* CreateMeshHitProxy(int32 SectionIndex, int32 MaterialIndex) const override;   
#endif
//~ 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;
    ENGINE_API virtual UTexture* GetMeshPaintTexture() const override;
    ENGINE_API virtual void SetMeshPaintTexture(UTexture* Texture) override;
    ENGINE_API virtual void SetMeshPaintTextureOverride(UTexture* OverrideTexture) override;
    ENGINE_API virtual int32 GetMeshPaintTextureCoordinateIndex() const override;
    //~ End UMeshComponent Interface
 
    //~ Begin INavRelevantInterface Interface.
    ENGINE_API virtual bool IsNavigationRelevant() const override;
    ENGINE_API virtual FBox GetNavigationBounds() const override;
    ENGINE_API virtual void GetNavigationData(FNavigationRelevantData& Data) const override;
    //~ End INavRelevantInterface Interface.
    ENGINE_API virtual bool UsesTextureLightmaps(int32 InWidth, int32 InHeight) const;
 
    ENGINE_API virtual bool HasLightmapTextureCoordinates() const;
 
    ENGINE_API virtual void GetTextureLightAndShadowMapMemoryUsage(int32 InWidth, int32 InHeight, int32& OutLightMapMemoryUsage, int32& OutShadowMapMemoryUsage) const;
 
    ENGINE_API virtual void GetEstimatedLightMapResolution(int32& Width, int32& Height) const;
 
 
    ENGINE_API virtual bool GetEstimatedLightAndShadowMapMemoryUsage(
        int32& TextureLightMapMemoryUsage, int32& TextureShadowMapMemoryUsage,
        int32& VertexLightMapMemoryUsage, int32& VertexShadowMapMemoryUsage,
        int32& StaticLightingResolution, bool& bIsUsingTextureMapping, bool& bHasLightmapTexCoords) const;
 
#if WITH_EDITORONLY_DATA
    ENGINE_API bool RequiresOverrideVertexColorsFixup();
 
    ENGINE_API bool FixupOverrideColorsIfNecessary( bool bRebuildingStaticMesh = false );
 
    ENGINE_API void CachePaintedDataIfNecessary();
 
    ENGINE_API void CopyInstanceVertexColorsIfCompatible( const UStaticMeshComponent* SourceComponent );
#endif
 
    UE_DEPRECATED(5.6, "Use UPrimitiveComponent::IsFirstPersonRelevant() instead.")
    bool IsStaticMeshFirstPersonRelevant() const { return FirstPersonPrimitiveType != EFirstPersonPrimitiveType::None; }
 
    ENGINE_API void RemoveInstanceVertexColorsFromLOD( int32 LODToRemoveColorsFrom );
 
#if WITH_EDITORONLY_DATA
    ENGINE_API void RemoveInstanceVertexColors();
#endif
 
#if WITH_EDITORONLY_DATA
    ENGINE_API void SetSectionPreview(int32 InSectionIndexPreview);
 
    ENGINE_API void SetMaterialPreview(int32 InMaterialIndexPreview);
#endif
 
    ENGINE_API void UpdateCollisionFromStaticMesh();
 
    ENGINE_API virtual bool SupportsDefaultCollision();
 
    UE_DEPRECATED(5.7, "Please use SupportsDitheredLODTransitions with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    ENGINE_API virtual bool SupportsDitheredLODTransitions(ERHIFeatureLevel::Type FeatureLevel);
 
    ENGINE_API virtual bool SupportsDitheredLODTransitions(EShaderPlatform ShaderPlatform);
 
    ENGINE_API UMaterialInterface* GetNaniteAuditMaterial(int32 MaterialIndex) const;
 
    /* Returns true if mesh vertex color painting is supported on this component. */
    ENGINE_API bool CanMeshPaintVertexColors() const;
    /* Returns true if mesh texture color painting is supported on this component. */
    ENGINE_API bool CanMeshPaintTextureColors() const;
    ENGINE_API int32 GetMeshPaintTextureResolution() const;
 
    inline bool IsReverseCulling() const { return bReverseCulling; }
    inline bool IsDisallowNanite() const { return bDisallowNanite; }
    inline bool IsForceDisableNanite() const { return bForceDisableNanite; }
    inline bool IsForceNaniteForMasked() const { return bForceNaniteForMasked; }
    inline int32 GetForcedLodModel() const { return ForcedLodModel; }
    inline bool GetOverrideMinLOD() const { return bOverrideMinLOD; }
    inline int32 GetMinLOD() const { return MinLOD; }
    inline bool GetForceNaniteForMasked() const { return bForceNaniteForMasked; }
 
#if WITH_EDITORONLY_DATA
    bool IsDisplayNaniteFallbackMesh() const { return bDisplayNaniteFallbackMesh; }
#endif
 
    ENGINE_API void UpdateMaterialCacheTextures();
    ENGINE_API void ReleaseMaterialCacheTextures();
    ENGINE_API UMaterialCacheVirtualTexture* GetMaterialCacheVirtualTexture(FGuid TagGuid) const;
 
private:
    ENGINE_API void InitResources();
        
#if WITH_EDITOR
    ENGINE_API void PrivateFixupOverrideColors();
 
    ENGINE_API void OutdatedKnownStaticMeshDetected() const;
 
    ENGINE_API void ClearStreamingTextureData();
#endif
 
    ENGINE_API bool UseNaniteOverrideMaterials(bool bDoingMaterialAudit) const;
 
    ENGINE_API UMaterialInterface* GetMaterial(int32 MaterialIndex, bool bDoingNaniteMaterialAudit) const;
 
protected:
    ENGINE_API virtual void CollectPSOPrecacheData(const FPSOPrecacheParams& BasePrecachePSOParams, FMaterialInterfacePSOPrecacheParamsList& OutParams) override;
    using GetPSOVertexElementsFn = TFunctionRef<void(const FStaticMeshLODResources& LODRenderData, int32 LODIndex, bool bSupportsManualVertexFetch, FVertexDeclarationElementList& Elements)>;
    ENGINE_API void CollectPSOPrecacheDataImpl(const FVertexFactoryType* VFType, const FPSOPrecacheParams& BasePrecachePSOParams, GetPSOVertexElementsFn GetVertexElements, FMaterialInterfacePSOPrecacheParamsList& OutParams) const;
        
    virtual bool SupportsStaticLighting() const override
    {
        return true;
    }
 
    ENGINE_API bool ShouldCreateNaniteProxy(Nanite::FMaterialAudit* OutNaniteMaterials = nullptr) const;
 
    // Overload this in child implementations that wish to extend Static Mesh or Nanite scene proxy implementations
    ENGINE_API virtual FPrimitiveSceneProxy* CreateStaticMeshSceneProxy(Nanite::FMaterialAudit& NaniteMaterials, bool bCreateNanite);
 
    ENGINE_API bool ShouldExportAsObstacle(const UNavCollisionBase& InNavCollision) const;
 
public:
 
    ENGINE_API void ReleaseResources();
 
    ENGINE_API virtual FStaticMeshStaticLightingMesh* AllocateStaticLightingMesh(int32 LODIndex, const TArray<ULightComponent*>& InRelevantLights);
 
    ENGINE_API bool SetLODDataCount( const uint32 MinSize, const uint32 MaxSize );
 
    ENGINE_API virtual bool SetStaticLightingMapping(bool bTextureMapping, int32 ResolutionToUse);
 
    ENGINE_API class UStaticMeshSocket const* GetSocketByName( FName InSocketName ) const;
 
    ENGINE_API FColor GetWireframeColor() const;
 
    ENGINE_API int32 GetBlueprintCreatedComponentIndex() const;
 
    ENGINE_API void ApplyComponentInstanceData(struct FStaticMeshComponentInstanceData* ComponentInstanceData);
 
    ENGINE_API virtual void PropagateLightingScenarioChange() override;
 
    ENGINE_API const FMeshMapBuildData* GetMeshMapBuildData(const FStaticMeshComponentLODInfo& LODInfo, bool bCheckForResourceCluster = true) const;
 
    void UpdateMapBuildDataId();
    void UpdateStaticLightingData();
 
    DECLARE_DELEGATE_RetVal(const Nanite::FResources*, FOnGetNaniteResources);
    virtual FOnGetNaniteResources& OnGetNaniteResources() { return OnGetNaniteResourcesEvent; }
    virtual const FOnGetNaniteResources& OnGetNaniteResources() const { return OnGetNaniteResourcesEvent; }
 
#if WITH_EDITOR
    DECLARE_EVENT_OneParam(UStaticMeshComponent, FOnStaticMeshChanged, UStaticMeshComponent*);
    virtual FOnStaticMeshChanged& OnStaticMeshChanged() { return OnStaticMeshChangedEvent; }
#endif
 
private:
#if WITH_EDITOR
    FOnStaticMeshChanged OnStaticMeshChangedEvent;
#endif
    FOnGetNaniteResources OnGetNaniteResourcesEvent;
 
    friend class FStaticMeshComponentRecreateRenderStateContext;
    friend class FStaticMeshComponentHelper;
    friend class FInstancedStaticMeshComponentHelper;
};
 
USTRUCT()
struct FStaticMeshVertexColorLODData
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    TArray<FPaintedVertex> PaintedVertices;
 
    UPROPERTY()
    TArray<FColor> VertexBufferColors;
 
    UPROPERTY()
    uint32 LODIndex = 0;
 
    bool IsValid() const
    {
        return PaintedVertices.Num() > 0 && VertexBufferColors.Num() > 0;
    }
};
 
USTRUCT()
struct FStaticMeshComponentInstanceData : public FPrimitiveComponentInstanceData
{
    GENERATED_BODY()
public:
    FStaticMeshComponentInstanceData() = default;
    FStaticMeshComponentInstanceData(const UStaticMeshComponent* SourceComponent);
    virtual ~FStaticMeshComponentInstanceData() = default;
 
    virtual bool ContainsData() const override;
 
    virtual void ApplyToComponent(UActorComponent* Component, const ECacheApplyPhase CacheApplyPhase) override;
 
    virtual void AddReferencedObjects(FReferenceCollector& Collector) override;
 
    void AddVertexColorData(const struct FStaticMeshComponentLODInfo& LODInfo, uint32 LODIndex);
 
    bool ApplyVertexColorData(UStaticMeshComponent* StaticMeshComponent) const;
 
    UPROPERTY()
    TObjectPtr<class UStaticMesh> StaticMesh = nullptr;
 
    UPROPERTY()
    TArray<FStaticMeshVertexColorLODData> VertexColorLODs;
 
    UPROPERTY()
    TArray<FGuid> CachedStaticLighting;
 
    UPROPERTY()
    TArray<FStreamingTextureBuildInfo> StreamingTextureData;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TArray<uint32> MaterialStreamingRelativeBoxes;
#endif
};