MaterialInterface.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
 
#pragma once
 
#include "Async/TaskGraphInterfaces.h"
#include "CoreMinimal.h"
#include "Delegates/Delegate.h"
#include "Materials/MaterialParameters.h"
#include "Containers/ArrayView.h"
#include "Containers/StaticArray.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Misc/Guid.h"
#include "Misc/Optional.h"
#include "Templates/UniquePtr.h"
#include "Templates/SharedPointer.h"
#include "Engine/EngineTypes.h"
#include "UObject/SoftObjectPath.h"
#include "UObject/ScriptMacros.h"
#include "RenderCommandFence.h"
#include "SceneTypes.h"
#include "Engine/BlendableInterface.h"
#include "Materials/MaterialLayersFunctions.h"
#include "Interfaces/Interface_AssetUserData.h"
#include "MaterialSceneTextureId.h"
#include "Materials/MaterialRelevance.h"
#include "MaterialRecursionGuard.h"
#include "MaterialShaderPrecompileMode.h"
#include "MeshUVChannelInfo.h"
#include "RHIFeatureLevel.h"
#include "PSOPrecache.h"
#include "StaticParameterSet.h"
#include "Interfaces/Interface_AsyncCompilation.h"
 
#include "MaterialInterface.generated.h"
 
class FMaterialCompiler;
class FMaterialRenderProxy;
class FMaterialResource;
class FShaderPipelineType;
class FShaderType;
class FVertexFactoryType;
class UMaterial;
class UPhysicalMaterial;
class UPhysicalMaterialMask;
class USubsurfaceProfile;
class USpecularProfile;
class UNeuralProfile;
class UTexture;
class UMaterialInstance;
struct FDebugShaderTypeInfo;
struct FMaterialParameterInfo;
struct FMaterialResourceLocOnDisk;
class FMaterialCachedData;
struct FMaterialCachedExpressionData;
struct FMaterialCachedExpressionEditorOnlyData;
#if WITH_EDITOR
struct FMaterialResourceForCooking;
#endif
#if WITH_EDITORONLY_DATA
struct FParameterChannelNames;
#endif
enum EShaderPlatform : uint16;
struct FSubstrateCompilationConfig;
class UMaterialExpressionCustomOutput;
struct FMaterialInsights;
 
typedef TArray<FMaterialResource*> FMaterialResourceDeferredDeletionArray;
 
UENUM(BlueprintType)
enum EMaterialUsage : int
{
    MATUSAGE_SkeletalMesh,
    MATUSAGE_ParticleSprites,
    MATUSAGE_BeamTrails,
    MATUSAGE_MeshParticles,
    MATUSAGE_StaticLighting,
    MATUSAGE_MorphTargets,
    MATUSAGE_SplineMesh,
    MATUSAGE_InstancedStaticMeshes,
    MATUSAGE_GeometryCollections,
    MATUSAGE_Clothing,
    MATUSAGE_NiagaraSprites,
    MATUSAGE_NiagaraRibbons,
    MATUSAGE_NiagaraMeshParticles,
    MATUSAGE_GeometryCache,
    MATUSAGE_Water,
    MATUSAGE_HairStrands,
    MATUSAGE_LidarPointCloud,
    MATUSAGE_VirtualHeightfieldMesh,
    MATUSAGE_Nanite,
    MATUSAGE_Voxels,
    MATUSAGE_VolumetricCloud,
    MATUSAGE_HeterogeneousVolumes,
    MATUSAGE_StaticMesh,
 
    MATUSAGE_MAX,
};
 
ENGINE_API EMaterialQualityLevel::Type GetCurrentMaterialQualityLevelChecked();
 
USTRUCT()
struct FLightmassMaterialInterfaceSettings
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    float EmissiveBoost;
 
    UPROPERTY(EditAnywhere, Category=Material)
    float DiffuseBoost;
 
    UPROPERTY(EditAnywhere, Category=Material)
    float ExportResolutionScale;
 
    UPROPERTY(EditAnywhere, Category = Material)
    uint8 bCastShadowAsMasked : 1;
 
    UPROPERTY()
    uint8 bOverrideCastShadowAsMasked:1;
 
    UPROPERTY()
    uint8 bOverrideEmissiveBoost:1;
 
    UPROPERTY()
    uint8 bOverrideDiffuseBoost:1;
 
    UPROPERTY()
    uint8 bOverrideExportResolutionScale:1;
 
    FLightmassMaterialInterfaceSettings()
        : EmissiveBoost(1.0f)
        , DiffuseBoost(1.0f)
        , ExportResolutionScale(1.0f)
        , bCastShadowAsMasked(false)
        , bOverrideCastShadowAsMasked(false)
        , bOverrideEmissiveBoost(false)
        , bOverrideDiffuseBoost(false)
        , bOverrideExportResolutionScale(false)
    {}
};
 
USTRUCT()
struct FMaterialTextureInfo
{
    GENERATED_USTRUCT_BODY()
 
    FMaterialTextureInfo() : SamplingScale(0), UVChannelIndex(INDEX_NONE)
    {
#if WITH_EDITORONLY_DATA
        TextureIndex = INDEX_NONE;
#endif
    }
 
    FMaterialTextureInfo(ENoInit) {}
 
    UPROPERTY()
    float SamplingScale;
 
    UPROPERTY()
    int32 UVChannelIndex;
 
    UPROPERTY()
    FName TextureName;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FSoftObjectPath TextureReference;
 
    UPROPERTY(transient)
    int32 TextureIndex;
#endif
 
    ENGINE_API bool IsValid(bool bCheckTextureIndex = false) const; 
};
 
using TMicRecursionGuard = TMaterialRecursionGuard<class UMaterialInterface>;
 
struct FMaterialInheritanceChain
{
    const UMaterial* BaseMaterial = nullptr;
    const FMaterialCachedExpressionData* CachedExpressionData = nullptr;
    TArray<const class UMaterialInstance*, TInlineAllocator<16>> MaterialInstances;
 
    inline const UMaterial* GetBaseMaterial() const { checkSlow(BaseMaterial); return BaseMaterial; }
    inline const FMaterialCachedExpressionData& GetCachedExpressionData() const { checkSlow(CachedExpressionData); return *CachedExpressionData; }
};
 
struct FMaterialAnalysisResult
{
    TBitArray<> TextureCoordinates;
 
    FMaterialShadingModelField ShadingModels;
 
    bool bRequiresVertexData = false;
 
    bool bTranslationSuccess = false;
 
    uint16 EstimatedNumTextureSamplesVS = 0;
 
    uint16 EstimatedNumTextureSamplesPS = 0;
};
 
USTRUCT()
struct FTextureSamplingInfo
{
    GENERATED_BODY()
 
    FTextureSamplingInfo(UTexture* InTexture = nullptr)
        : bIsValid(false)
        , Texture(InTexture)
        , ChannelMinSamplingScale(InPlace, UE_MAX_FLT)
    {}
 
    bool bIsValid;
    
    UPROPERTY()
    TObjectPtr<UTexture> Texture;
 
    TStaticArray<float, MAX_TEXCOORDS> ChannelMinSamplingScale;
};
 
USTRUCT()
struct FMaterialCachedTexturesSamplingInfo
{
    GENERATED_BODY()
 
    UPROPERTY()
    TArray<FTextureSamplingInfo> TextureSamplingInfos;
};
 
UCLASS(Optional)
class UMaterialInterfaceEditorOnlyData : public UObject
{
    GENERATED_BODY()
public:
    UMaterialInterfaceEditorOnlyData();
    UMaterialInterfaceEditorOnlyData(FVTableHelper& Helper);
    ENGINE_API virtual ~UMaterialInterfaceEditorOnlyData();
 
    //~ Begin UObject Interface.
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    //~ End UObject Interface.
 
    TSharedPtr<FMaterialCachedExpressionEditorOnlyData> CachedExpressionData;
 
    bool bLoadedCachedExpressionData = false;
};
 
DECLARE_MULTICAST_DELEGATE_OneParam(FOnBaseMaterialIsSet, UMaterialInterface*);
 
UCLASS(abstract, BlueprintType, MinimalAPI, HideCategories = (Thumbnail))
class UMaterialInterface : public UObject, public IBlendableInterface, public IInterface_AssetUserData
{
    GENERATED_UCLASS_BODY()
 
#if WITH_EDITORONLY_DATA
protected:
    friend class UMaterialInterfaceEditorOnlyData;
 
    UPROPERTY(VisibleAnywhere, Instanced, Category = Material, meta = (AllowEditInlineCustomization, ShowInnerProperties))
    TObjectPtr<UMaterialInterfaceEditorOnlyData> EditorOnlyData;
 
    ENGINE_API virtual const UClass* GetEditorOnlyDataClass() const;
 
public:
    virtual UMaterialInterfaceEditorOnlyData* GetEditorOnlyData() { return EditorOnlyData; }
    virtual const UMaterialInterfaceEditorOnlyData* GetEditorOnlyData() const { return EditorOnlyData; }
    bool IsEditorOnlyDataValid() const { return EditorOnlyData != nullptr; }
#endif // WITH_EDITORONLY_DATA
 
public:
#if !WITH_EDITOR
    const FMaterialCachedTexturesSamplingInfo* GetCachedTexturesSamplingInfo() const
    {
        return CachedTexturesSamplingInfo.GetPtrOrNull();
    }
    ENGINE_API virtual FTextureSamplingInfo CalculateTexturesSamplingInfo(UTexture* Texture);
#endif
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Material, meta = (DisplayName = "Subsurface Profile"))
    TObjectPtr<class USubsurfaceProfile> SubsurfaceProfile;
 
    UPROPERTY()
    TArray<TObjectPtr<class USubsurfaceProfile>> SubsurfaceProfiles;
 
    UPROPERTY()
    TArray<TObjectPtr<class USpecularProfile>> SpecularProfiles;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = PostProcessMaterial, meta = (DisplayName = "Neural Profile"))
    TObjectPtr<class UNeuralProfile> NeuralProfile;
 
    FOnBaseMaterialIsSet OnBaseMaterialSetEvent;
 
    /* -------------------------- */
 
    FRenderCommandFence ParentRefFence;
 
protected:
    UPROPERTY(EditAnywhere, Category=Lightmass)
    struct FLightmassMaterialInterfaceSettings LightmassSettings;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(transient)
    bool bTextureStreamingDataSorted;
    UPROPERTY()
    int32 TextureStreamingDataVersion;
#endif
 
    UPROPERTY()
    TArray<FMaterialTextureInfo> TextureStreamingData;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Instanced, Category = Material)
    TArray<TObjectPtr<UAssetUserData>> AssetUserData;
 
#if !WITH_EDITOR
    ENGINE_API void CacheTexturesSamplingInfo();
    ENGINE_API virtual bool CanCacheTexturesSamplingInfo() const;
#endif
 
    UPROPERTY(Transient)
    TOptional<FMaterialCachedTexturesSamplingInfo> CachedTexturesSamplingInfo;
 
private:
    uint32 FeatureLevelsToForceCompile;
 
public:
 
    UPROPERTY(meta=(DisplayAfter="NeuralProfile"))
    uint8 bIncludedInBaseGame : 1;
 
    ENGINE_API UMaterialInterface();
    ENGINE_API UMaterialInterface(FVTableHelper& Helper);
    ENGINE_API virtual ~UMaterialInterface();
 
    //~ 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;
    //~ End IInterface_AssetUserData Interface
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(transient)
    TArray<FMaterialTextureInfo> TextureStreamingDataMissingEntries;
 
    UPROPERTY(EditAnywhere, Category=Previewing, meta=(AllowedClasses="/Script/Engine.StaticMesh,/Script/Engine.SkeletalMesh", ExactClass="true"))
    FSoftObjectPath PreviewMesh;
 
    UPROPERTY(VisibleAnywhere, Instanced, Category = Thumbnail)
    TObjectPtr<class UThumbnailInfo> ThumbnailInfo;
 
    UPROPERTY()
    TMap<FString, bool> LayerParameterExpansion;
 
    UPROPERTY()
    TMap<FString, bool> ParameterOverviewExpansion;
 
    UPROPERTY(EditAnywhere, Instanced, Category = ImportSettings)
    TObjectPtr<class UAssetImportData> AssetImportData;
    
private:
    UPROPERTY()
    FGuid LightingGuid;
 
#endif // WITH_EDITORONLY_DATA
 
private:
    ENGINE_API static uint32 FeatureLevelsForAllMaterials;
public:
    ENGINE_API void SetFeatureLevelToCompile(ERHIFeatureLevel::Type FeatureLevel, bool bShouldCompile);
 
    ENGINE_API static void SetGlobalRequiredFeatureLevel(ERHIFeatureLevel::Type FeatureLevel, bool bShouldCompile);
 
    //~ Begin UObject Interface.
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual void FinishDestroy() override;
    ENGINE_API virtual bool IsReadyForFinishDestroy() override;
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void PostLoad() override;
#if WITH_EDITORONLY_DATA
    ENGINE_API static void DeclareConstructClasses(TArray<FTopLevelAssetPath>& OutConstructClasses, const UClass* SpecificSubclass);
#endif
 
    ENGINE_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
    ENGINE_API virtual void PostCDOContruct() override;
    ENGINE_API virtual bool Rename(const TCHAR* NewName = nullptr, UObject* NewOuter = nullptr, ERenameFlags Flags = REN_None) override;
    ENGINE_API static void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
 
#if WITH_EDITOR
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual void GetAssetRegistryTagMetadata(TMap<FName, FAssetRegistryTagMetadata>& OutMetadata) const override;
    ENGINE_API virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const override;
#endif // WITH_EDITOR
#if WITH_EDITOR
    static ENGINE_API void AppendToClassSchema(FAppendToClassSchemaContext& Context);
#endif
    //~ End UObject Interface.
 
    //~ Begin Begin Interface IBlendableInterface
    ENGINE_API virtual void OverrideBlendableSettings(class FSceneView& View, float Weight) const override;
    //~ Begin End Interface IBlendableInterface
 
    UFUNCTION(BlueprintCallable, Category="Rendering|Material")
    ENGINE_API UMaterial* GetBaseMaterial();
 
    ENGINE_API virtual void OnAssignedAsOverride(const UObject* Owner);
    ENGINE_API virtual void OnRemovedAsOverride(const UObject* Owner);
 
    virtual class UMaterial* GetMaterial() PURE_VIRTUAL(UMaterialInterface::GetMaterial,return NULL;);
    virtual const class UMaterial* GetMaterial() const PURE_VIRTUAL(UMaterialInterface::GetMaterial,return NULL;);
 
    virtual const class UMaterial* GetMaterial_Concurrent(TMicRecursionGuard RecursionGuard = TMicRecursionGuard()) const PURE_VIRTUAL(UMaterialInterface::GetMaterial_Concurrent,return NULL;);
 
    virtual void GetMaterialInheritanceChain(FMaterialInheritanceChain& OutChain) const PURE_VIRTUAL(UMaterialInterface::GetMaterialInheritanceChain, return;);
 
    ENGINE_API virtual const FMaterialCachedExpressionData& GetCachedExpressionData(TMicRecursionGuard RecursionGuard = TMicRecursionGuard()) const;
 
    ENGINE_API bool IsUsingNewHLSLGenerator() const;
    ENGINE_API bool IsUsingNewTranslatorPrototype() const;
 
    ENGINE_API const FSubstrateCompilationConfig& GetSubstrateCompilationConfig() const;
    ENGINE_API void SetSubstrateCompilationConfig(FSubstrateCompilationConfig& SubstrateCompilationConfig);
 
    virtual bool IsDependent(UMaterialInterface* TestDependency) { return TestDependency == this; }
 
    virtual bool IsDependent_Concurrent(UMaterialInterface* TestDependency, TMicRecursionGuard RecursionGuard = TMicRecursionGuard()) { return TestDependency == this; }
 
    virtual void GetDependencies(TSet<UMaterialInterface*>& Dependencies) PURE_VIRTUAL(UMaterialInterface::GetDependencies, return;);
 
    virtual class FMaterialRenderProxy* GetRenderProxy() const PURE_VIRTUAL(UMaterialInterface::GetRenderProxy,return NULL;);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Material")
    virtual UPhysicalMaterial* GetPhysicalMaterial() const PURE_VIRTUAL(UMaterialInterface::GetPhysicalMaterial,return NULL;);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Material")
    virtual UPhysicalMaterialMask* GetPhysicalMaterialMask() const PURE_VIRTUAL(UMaterialInterface::GetPhysicalMaterialMask, return nullptr;);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Material")
    virtual UPhysicalMaterial* GetPhysicalMaterialFromMap(int32 Index) const PURE_VIRTUAL(UMaterialInterface::GetPhysicalMaterialFromMap, return nullptr;);
 
    void GetQualityLevelUsage(TArray<bool, TInlineAllocator<EMaterialQualityLevel::Num> >& QualityLevelsUsed, EShaderPlatform ShaderPlatform, bool bCooking = false);
 
    inline void GetQualityLevelUsageForCooking(TArray<bool, TInlineAllocator<EMaterialQualityLevel::Num> >& QualityLevelsUsed, EShaderPlatform ShaderPlatform)
    {
        GetQualityLevelUsage(QualityLevelsUsed, ShaderPlatform, true);
    }
 
    UE_DEPRECATED(5.7, "Deprecated: Use the version with the optional parameters InSpecificQualityLevel and InSpecificShaderPlatform. If unset, we search used textures for this material for all Quality Levels and Shader Platforms.")
    virtual void GetUsedTextures(TArray<UTexture*>& OutTextures, EMaterialQualityLevel::Type QualityLevel, bool bAllQualityLevels, ERHIFeatureLevel::Type FeatureLevel, bool bAllFeatureLevels) const final {}
 
    virtual void GetUsedTextures(TArray<UTexture*>& OutTextures, TOptional<EMaterialQualityLevel::Type> InSpecificQualityLevel = TOptional<EMaterialQualityLevel::Type>(), TOptional<EShaderPlatform> InSpecificShaderPlatform = TOptional<EShaderPlatform>()) const
        PURE_VIRTUAL(UMaterialInterface::GetUsedTextures, );
    UE_DEPRECATED(5.7, "Please use GetUsedTexturesAndIndices with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    ENGINE_API virtual void GetUsedTexturesAndIndices(TArray<UTexture*>& OutTextures, TArray< TArray<int32> >& OutIndices, EMaterialQualityLevel::Type QualityLevel, ERHIFeatureLevel::Type FeatureLevel) const final;
    ENGINE_API virtual void GetUsedTexturesAndIndices(TArray<UTexture*>& OutTextures, TArray< TArray<int32> >& OutIndices, EMaterialQualityLevel::Type QualityLevel, EShaderPlatform InShaderPlatform) const;
 
    virtual void OverrideTexture(const UTexture* InTextureToOverride, UTexture* OverrideTexture, ERHIFeatureLevel::Type InFeatureLevel) PURE_VIRTUAL(UMaterialInterface::OverrideTexture, return;);
 
    UE_DEPRECATED(5.7, "Please use SetNumericParameterDefault/ClearNumericParameterDefault instead with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    virtual void OverrideNumericParameterDefault(EMaterialParameterType Type, const FHashedMaterialParameterInfo& ParameterInfo, const UE::Shader::FValue& Value, bool bOverride, ERHIFeatureLevel::Type FeatureLevel) final {}
    virtual void SetNumericParameterDefault(EMaterialParameterType Type, const FHashedMaterialParameterInfo& ParameterInfo, const UE::Shader::FValue& Value, EShaderPlatform InShaderPlatform) PURE_VIRTUAL(UMaterialInterface::SetNumericParameterDefault, return;);
    virtual void ClearNumericParameterDefault(EMaterialParameterType Type, const FHashedMaterialParameterInfo& ParameterInfo, EShaderPlatform InShaderPlatform) PURE_VIRTUAL(UMaterialInterface::ClearNumericParameterDefault, return;);
 
    virtual bool CheckMaterialUsage(const EMaterialUsage Usage) PURE_VIRTUAL(UMaterialInterface::CheckMaterialUsage,return false;);
    virtual bool CheckMaterialUsage_Concurrent(const EMaterialUsage Usage) const PURE_VIRTUAL(UMaterialInterface::CheckMaterialUsage,return false;);
 
    UE_DEPRECATED(5.7, "Please use GetMaterialResource with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    virtual FMaterialResource* GetMaterialResource(ERHIFeatureLevel::Type InFeatureLevel, EMaterialQualityLevel::Type QualityLevel = EMaterialQualityLevel::Num) final { return NULL; }
    virtual FMaterialResource* GetMaterialResource(EShaderPlatform InShaderPlatform, EMaterialQualityLevel::Type QualityLevel = EMaterialQualityLevel::Num) { return NULL; }
 
    UE_DEPRECATED(5.7, "Please use GetMaterialResource with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    virtual const FMaterialResource* GetMaterialResource(ERHIFeatureLevel::Type InFeatureLevel, EMaterialQualityLevel::Type QualityLevel = EMaterialQualityLevel::Num) const final { return NULL; }
    virtual const FMaterialResource* GetMaterialResource(EShaderPlatform InShaderPlatform, EMaterialQualityLevel::Type QualityLevel = EMaterialQualityLevel::Num) const { return NULL; }
 
    virtual bool GetMaterialLayers(FMaterialLayersFunctions& OutLayers, TMicRecursionGuard RecursionGuard = TMicRecursionGuard()) const PURE_VIRTUAL(UMaterialInterface::GetMaterialLayers, return false;);
 
    virtual UMaterialInterface* GetNaniteOverride(TMicRecursionGuard RecursionGuard = TMicRecursionGuard()) const PURE_VIRTUAL(UMaterialInterface::GetNaniteOverride, return nullptr;);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    UMaterialInterface* GetNaniteOverideMaterial() const { return GetNaniteOverride(); }
 
    FGraphEventArray PrecachePSOs(const FVertexFactoryType* VertexFactoryType, const struct FPSOPrecacheParams& PreCacheParams)
    {
        return PrecachePSOs(MakeArrayView(&VertexFactoryType, 1), PreCacheParams);
    }
    FGraphEventArray PrecachePSOs(const TConstArrayView<const FVertexFactoryType*>& VertexFactoryTypes, const struct FPSOPrecacheParams& PreCacheParams)
    {
        TArray<FMaterialPSOPrecacheRequestID> MaterialPSOPrecacheRequestIDs;
        return PrecachePSOs(VertexFactoryTypes, PreCacheParams, MaterialPSOPrecacheRequestIDs);
    }
 
    FGraphEventArray PrecachePSOs(const TConstArrayView<const FVertexFactoryType*>& VertexFactoryTypes, const struct FPSOPrecacheParams& PreCacheParams, TArray<FMaterialPSOPrecacheRequestID>& OutMaterialPSORequestIDs)
    {
        return PrecachePSOs(VertexFactoryTypes, PreCacheParams, EPSOPrecachePriority::Medium, OutMaterialPSORequestIDs);
    }
 
    FGraphEventArray PrecachePSOs(const TConstArrayView<const FVertexFactoryType*>& VertexFactoryTypes, const struct FPSOPrecacheParams& PreCacheParams, EPSOPrecachePriority PSOPrecachePriority, TArray<FMaterialPSOPrecacheRequestID>& OutMaterialPSORequestIDs)
    { 
        FPSOPrecacheVertexFactoryDataList VertexFactoryDataList;
        VertexFactoryDataList.SetNum(VertexFactoryTypes.Num());
        for (int i = 0; i < VertexFactoryTypes.Num(); ++i)
        {
            VertexFactoryDataList[i].VertexFactoryType = VertexFactoryTypes[i];
        }
        return PrecachePSOs(VertexFactoryDataList, PreCacheParams, PSOPrecachePriority, OutMaterialPSORequestIDs);
    }
    virtual FGraphEventArray PrecachePSOs(const FPSOPrecacheVertexFactoryDataList& VertexFactoryDataList, const struct FPSOPrecacheParams& PreCacheParams, EPSOPrecachePriority Priority, TArray<FMaterialPSOPrecacheRequestID>& OutMaterialPSORequestIDs) { return FGraphEventArray(); }
 
#if WITH_EDITORONLY_DATA
    ENGINE_API void GetStaticParameterValues(FStaticParameterSet& OutStaticParameters);
 
    ENGINE_API bool GetStaticSwitchParameterValue(const FHashedMaterialParameterInfo& ParameterInfo,bool &OutValue,FGuid &OutExpressionGuid, bool bOveriddenOnly = false) const;
 
    ENGINE_API bool GetStaticComponentMaskParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, bool& R, bool& G, bool& B, bool& A, FGuid& OutExpressionGuid, bool bOveriddenOnly = false) const;
#endif // WITH_EDITORONLY_DATA
 
#if WITH_EDITOR
    ENGINE_API bool GetParameterSortPriority(const FHashedMaterialParameterInfo& ParameterInfo, int32& OutSortPriority) const;
 
    virtual bool GetGroupSortPriority(const FString& InGroupName, int32& OutSortPriority) const
        PURE_VIRTUAL(UMaterialInterface::GetGroupSortPriority, return false;);
#endif // WITH_EDITOR
 
    ENGINE_API virtual void GetAllParameterInfoOfType(EMaterialParameterType Type, TArray<FMaterialParameterInfo>& OutParameterInfo, TArray<FGuid>& OutParameterIds) const;
    ENGINE_API virtual void GetAllParametersOfType(EMaterialParameterType Type, TMap<FMaterialParameterInfo, FMaterialParameterMetadata>& OutParameters) const;
    ENGINE_API void GetAllScalarParameterInfo(TArray<FMaterialParameterInfo>& OutParameterInfo, TArray<FGuid>& OutParameterIds) const;
    ENGINE_API void GetAllVectorParameterInfo(TArray<FMaterialParameterInfo>& OutParameterInfo, TArray<FGuid>& OutParameterIds) const;
    ENGINE_API void GetAllDoubleVectorParameterInfo(TArray<FMaterialParameterInfo>& OutParameterInfo, TArray<FGuid>& OutParameterIds) const;
    ENGINE_API void GetAllTextureParameterInfo(TArray<FMaterialParameterInfo>& OutParameterInfo, TArray<FGuid>& OutParameterIds) const;
    ENGINE_API void GetAllTextureCollectionParameterInfo(TArray<FMaterialParameterInfo>& OutParameterInfo, TArray<FGuid>& OutParameterIds) const;
    ENGINE_API void GetAllParameterCollectionParameterInfo(TArray<FMaterialParameterInfo>& OutParameterInfo, TArray<FGuid>& OutParameterIds) const;
    ENGINE_API void GetAllRuntimeVirtualTextureParameterInfo(TArray<FMaterialParameterInfo>& OutParameterInfo, TArray<FGuid>& OutParameterIds) const;
    ENGINE_API void GetAllSparseVolumeTextureParameterInfo(TArray<FMaterialParameterInfo>& OutParameterInfo, TArray<FGuid>& OutParameterIds) const;
    ENGINE_API void GetAllFontParameterInfo(TArray<FMaterialParameterInfo>& OutParameterInfo, TArray<FGuid>& OutParameterIds) const;
 
#if WITH_EDITORONLY_DATA
    ENGINE_API void GetAllStaticSwitchParameterInfo(TArray<FMaterialParameterInfo>& OutParameterInfo, TArray<FGuid>& OutParameterIds) const;
    ENGINE_API void GetAllStaticComponentMaskParameterInfo(TArray<FMaterialParameterInfo>& OutParameterInfo, TArray<FGuid>& OutParameterIds) const;
 
    virtual bool IterateDependentFunctions(TFunctionRef<bool(UMaterialFunctionInterface*)> Predicate) const
        PURE_VIRTUAL(UMaterialInterface::IterateDependentFunctions,return false;);
    virtual void GetDependentFunctions(TArray<class UMaterialFunctionInterface*>& DependentFunctions) const
        PURE_VIRTUAL(UMaterialInterface::GetDependentFunctions,return;);
#endif // WITH_EDITORONLY_DATA
 
    ENGINE_API bool GetParameterDefaultValue(EMaterialParameterType Type, const FMemoryImageMaterialParameterInfo& ParameterInfo, FMaterialParameterMetadata& OutValue) const;
    ENGINE_API bool GetScalarParameterDefaultValue(const FHashedMaterialParameterInfo& ParameterInfo, float& OutValue) const;
    ENGINE_API bool GetVectorParameterDefaultValue(const FHashedMaterialParameterInfo& ParameterInfo, FLinearColor& OutValue) const;
    ENGINE_API bool GetDoubleVectorParameterDefaultValue(const FHashedMaterialParameterInfo& ParameterInfo, FVector4d& OutValue) const;
    ENGINE_API bool GetTextureParameterDefaultValue(const FHashedMaterialParameterInfo& ParameterInfo, class UTexture*& OutValue) const;
    ENGINE_API bool GetTextureCollectionParameterDefaultValue(const FHashedMaterialParameterInfo& ParameterInfo, class UTextureCollection*& OutValue) const;
    ENGINE_API bool GetParameterCollectionParameterDefaultValue(const FHashedMaterialParameterInfo& ParameterInfo, class UMaterialParameterCollection*& OutValue) const;
    ENGINE_API bool GetRuntimeVirtualTextureParameterDefaultValue(const FHashedMaterialParameterInfo& ParameterInfo, class URuntimeVirtualTexture*& OutValue) const;
    ENGINE_API bool GetSparseVolumeTextureParameterDefaultValue(const FHashedMaterialParameterInfo& ParameterInfo, class USparseVolumeTexture*& OutValue) const;
    ENGINE_API bool GetFontParameterDefaultValue(const FHashedMaterialParameterInfo& ParameterInfo, class UFont*& OutFontValue, int32& OutFontPage) const;
    
#if WITH_EDITOR
    ENGINE_API bool GetStaticSwitchParameterDefaultValue(const FHashedMaterialParameterInfo& ParameterInfo, bool& OutValue, FGuid& OutExpressionGuid) const;
    ENGINE_API bool GetStaticComponentMaskParameterDefaultValue(const FHashedMaterialParameterInfo& ParameterInfo, bool& OutR, bool& OutG, bool& OutB, bool& OutA, FGuid& OutExpressionGuid) const;
 
    ENGINE_API virtual void GetReferencedTexturesAndOverrides(TSet<const UTexture*>& InOutTextures) const;
#endif // WITH_EDITOR
 
    ENGINE_API TArrayView<const TObjectPtr<UObject>> GetReferencedTextures() const;
 
    ENGINE_API TConstArrayView<TObjectPtr<UTextureCollection>> GetReferencedTextureCollections() const;
 
    virtual void SaveShaderStableKeysInner(const class ITargetPlatform* TP, const struct FStableShaderKeyAndValue& SaveKeyVal)
        PURE_VIRTUAL(UMaterialInterface::SaveShaderStableKeysInner, );
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API FMaterialParameterInfo GetParameterInfo(EMaterialParameterAssociation Association, FName ParameterName, UMaterialFunctionInterface* LayerFunction) const;
 
    UE_DEPRECATED(5.7, "Please use GetRelevance with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    ENGINE_API FMaterialRelevance GetRelevance(ERHIFeatureLevel::Type InFeatureLevel) const;
    ENGINE_API FMaterialRelevance GetRelevance(EShaderPlatform ShaderPlatform) const;
 
    UE_DEPRECATED(5.7, "Please use GetRelevance_Concurrent with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    ENGINE_API FMaterialRelevance GetRelevance_Concurrent(ERHIFeatureLevel::Type InFeatureLevel) const;
    ENGINE_API FMaterialRelevance GetRelevance_Concurrent(EShaderPlatform ShaderPlatform) const;
 
    UE_DEPRECATED(5.7, "Please use IsUsingWorldPositionOffset_Concurrent with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    ENGINE_API bool IsUsingWorldPositionOffset_Concurrent(ERHIFeatureLevel::Type InFeatureLevel) const;
    ENGINE_API bool IsUsingWorldPositionOffset_Concurrent(EShaderPlatform InShaderPlatform) const;
 
    ENGINE_API bool IsUsingTemporalResponsiveness_Concurrent(EShaderPlatform InShaderPlatform) const;
    ENGINE_API bool IsUsingMotionVectorWorldOffset_Concurrent(EShaderPlatform InShaderPlatform) const;
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    virtual void LogMaterialsAndTextures(FOutputDevice& Ar, int32 Indent) const {}
#endif
 
    virtual void DumpDebugInfo(FOutputDevice& OutputDevice) const {}
 
private:
    // might get called from game or render thread
    UE_DEPRECATED(5.7, "Please use GetRelevance_Internal with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    FMaterialRelevance GetRelevance_Internal(const UMaterial* Material, ERHIFeatureLevel::Type InFeatureLevel) const;
    FMaterialRelevance GetRelevance_Internal(const UMaterial* Material, EShaderPlatform ShaderPlatform) const;
 
public:
 
    int32 GetWidth() const;
    int32 GetHeight() const;
 
    const FGuid& GetLightingGuid() const
    {
#if WITH_EDITORONLY_DATA
        return LightingGuid;
#else
        static const FGuid NullGuid( 0, 0, 0, 0 );
        return NullGuid; 
#endif // WITH_EDITORONLY_DATA
    }
 
    void SetLightingGuid()
    {
#if WITH_EDITORONLY_DATA
        LightingGuid = FGuid::NewGuid();
#endif // WITH_EDITORONLY_DATA
    }
 
    ENGINE_API virtual void GetLightingGuidChain(bool bIncludeTextures, TArray<FGuid>& OutGuids) const;
 
#if WITH_EDITOR
    ENGINE_API virtual uint32 ComputeAllStateCRC() const;
#endif // WITH_EDITOR
 
    virtual bool UpdateLightmassTextureTracking() 
    { 
        return false; 
    }
    
    inline bool GetOverrideCastShadowAsMasked() const
    {
        return LightmassSettings.bOverrideCastShadowAsMasked;
    }
 
    inline bool GetOverrideEmissiveBoost() const
    {
        return LightmassSettings.bOverrideEmissiveBoost;
    }
 
    inline bool GetOverrideDiffuseBoost() const
    {
        return LightmassSettings.bOverrideDiffuseBoost;
    }
 
    inline bool GetOverrideExportResolutionScale() const
    {
        return LightmassSettings.bOverrideExportResolutionScale;
    }
 
    virtual bool GetCastShadowAsMasked() const
    {
        return LightmassSettings.bCastShadowAsMasked;
    }
 
    virtual float GetEmissiveBoost() const
    {
        return 
        LightmassSettings.EmissiveBoost;
    }
 
    virtual float GetDiffuseBoost() const
    {
        return LightmassSettings.DiffuseBoost;
    }
 
    virtual float GetExportResolutionScale() const
    {
        return FMath::Clamp(LightmassSettings.ExportResolutionScale, .1f, 10.0f);
    }
 
    inline void SetOverrideCastShadowAsMasked(bool bInOverrideCastShadowAsMasked)
    {
        LightmassSettings.bOverrideCastShadowAsMasked = bInOverrideCastShadowAsMasked;
    }
 
    inline void SetOverrideEmissiveBoost(bool bInOverrideEmissiveBoost)
    {
        LightmassSettings.bOverrideEmissiveBoost = bInOverrideEmissiveBoost;
    }
 
    inline void SetOverrideDiffuseBoost(bool bInOverrideDiffuseBoost)
    {
        LightmassSettings.bOverrideDiffuseBoost = bInOverrideDiffuseBoost;
    }
 
    inline void SetOverrideExportResolutionScale(bool bInOverrideExportResolutionScale)
    {
        LightmassSettings.bOverrideExportResolutionScale = bInOverrideExportResolutionScale;
    }
 
    inline void SetCastShadowAsMasked(bool InCastShadowAsMasked)
    {
        LightmassSettings.bCastShadowAsMasked = InCastShadowAsMasked;
    }
 
    inline void SetEmissiveBoost(float InEmissiveBoost)
    {
        LightmassSettings.EmissiveBoost = InEmissiveBoost;
    }
 
    inline void SetDiffuseBoost(float InDiffuseBoost)
    {
        LightmassSettings.DiffuseBoost = InDiffuseBoost;
    }
 
    inline void SetExportResolutionScale(float InExportResolutionScale)
    {
        LightmassSettings.ExportResolutionScale = InExportResolutionScale;
    }
 
#if WITH_EDITOR
    virtual bool GetTexturesInPropertyChain(EMaterialProperty InProperty, TArray<UTexture*>& OutTextures,  TArray<FName>* OutTextureParamNames, struct FStaticParameterSet* InStaticParameterSet,
        ERHIFeatureLevel::Type InFeatureLevel = ERHIFeatureLevel::Num, EMaterialQualityLevel::Type InQuality = EMaterialQualityLevel::Num)
        PURE_VIRTUAL(UMaterialInterface::GetTexturesInPropertyChain,return false;);
 
    ENGINE_API bool GetGroupName(const FHashedMaterialParameterInfo& ParameterInfo, FName& GroupName) const;
    ENGINE_API bool GetParameterDesc(const FHashedMaterialParameterInfo& ParameterInfo, FString& OutDesc) const;
    ENGINE_API bool GetScalarParameterSliderMinMax(const FHashedMaterialParameterInfo& ParameterInfo, float& OutSliderMin, float& OutSliderMax) const;
#endif // WITH_EDITOR
 
    ENGINE_API virtual bool GetParameterValue(EMaterialParameterType Type, const FMemoryImageMaterialParameterInfo& ParameterInfo, FMaterialParameterMetadata& OutValue, EMaterialGetParameterValueFlags Flags = EMaterialGetParameterValueFlags::Default) const;
 
    ENGINE_API bool GetScalarParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, float& OutValue, bool bOveriddenOnly = false) const;
#if WITH_EDITOR
    ENGINE_API bool IsScalarParameterUsedAsAtlasPosition(const FHashedMaterialParameterInfo& ParameterInfo, bool& OutValue, TSoftObjectPtr<class UCurveLinearColor>& Curve, TSoftObjectPtr<class UCurveLinearColorAtlas>&  Atlas) const;
#endif // WITH_EDITOR
    ENGINE_API bool GetVectorParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, FLinearColor& OutValue, bool bOveriddenOnly = false) const;
#if WITH_EDITOR
    ENGINE_API bool IsVectorParameterUsedAsChannelMask(const FHashedMaterialParameterInfo& ParameterInfo, bool& OutValue) const;
    ENGINE_API bool GetVectorParameterChannelNames(const FHashedMaterialParameterInfo& ParameterInfo, FParameterChannelNames& OutValue) const;
#endif
    ENGINE_API bool GetDoubleVectorParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, FVector4d& OutValue, bool bOveriddenOnly = false) const;
#if WITH_EDITOR
    ENGINE_API bool IsDoubleVectorParameterUsedAsChannelMask(const FHashedMaterialParameterInfo& ParameterInfo, bool& OutValue) const;
    ENGINE_API bool GetDoubleVectorParameterChannelNames(const FHashedMaterialParameterInfo& ParameterInfo, FParameterChannelNames& OutValue) const;
#endif // WITH_EDITOR
    ENGINE_API virtual bool GetTextureParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, class UTexture*& OutValue, bool bOveriddenOnly = false) const;
    ENGINE_API virtual bool GetTextureCollectionParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, class UTextureCollection*& OutValue, bool bOveriddenOnly = false) const;
    ENGINE_API virtual bool GetParameterCollectionParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, class UMaterialParameterCollection*& OutValue, bool bOveriddenOnly = false) const;
    ENGINE_API bool GetRuntimeVirtualTextureParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, class URuntimeVirtualTexture*& OutValue, bool bOveriddenOnly = false) const;
    ENGINE_API bool GetSparseVolumeTextureParameterValue(const FHashedMaterialParameterInfo& ParameterInfo, class USparseVolumeTexture*& OutValue, bool bOveriddenOnly = false) const;
#if WITH_EDITOR
    ENGINE_API bool GetTextureParameterChannelNames(const FHashedMaterialParameterInfo& ParameterInfo, FParameterChannelNames& OutValue) const;
#endif
    ENGINE_API bool GetFontParameterValue(const FHashedMaterialParameterInfo& ParameterInfo,class UFont*& OutFontValue, int32& OutFontPage, bool bOveriddenOnly = false) const;
 
    ENGINE_API virtual bool GetRefractionSettings(float& OutBiasValue) const;
    ENGINE_API virtual bool GetUserSceneTextureOverride(FName& InOutValue) const;
    ENGINE_API FName GetUserSceneTextureOutput(const UMaterial* Base) const;
    ENGINE_API virtual EBlendableLocation GetBlendableLocation(const UMaterial* Base) const;
    ENGINE_API virtual int32 GetBlendablePriority(const UMaterial* Base) const;
 
    ENGINE_API virtual float GetOpacityMaskClipValue() const;
    ENGINE_API virtual bool GetCastDynamicShadowAsMasked() const;
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API virtual EBlendMode GetBlendMode() const;
    ENGINE_API virtual FMaterialShadingModelField GetShadingModels() const;
    ENGINE_API virtual bool IsShadingModelFromMaterialExpression() const;
    ENGINE_API virtual bool IsTwoSided() const;
    ENGINE_API virtual bool IsThinSurface() const;
    ENGINE_API virtual bool IsDitheredLODTransition() const;
    ENGINE_API virtual bool IsTranslucencyWritingCustomDepth() const;
    ENGINE_API virtual bool IsTranslucencyWritingVelocity() const;
    ENGINE_API virtual bool IsTranslucencyVelocityFromDepth() const;
    ENGINE_API virtual bool IsTranslucencyWritingFrontLayerTransparency() const;
    ENGINE_API virtual bool IsMasked() const;
    ENGINE_API virtual bool IsDeferredDecal() const;
    ENGINE_API virtual bool IsUIMaterial() const;
    ENGINE_API virtual bool IsPostProcessMaterial() const;
    ENGINE_API virtual bool WritesToRuntimeVirtualTexture() const;
    ENGINE_API virtual bool HasMeshPaintTexture() const;
    ENGINE_API virtual bool HasCustomPrimitiveData() const;
    ENGINE_API virtual FDisplacementScaling GetDisplacementScaling() const;
    ENGINE_API virtual bool IsDisplacementFadeEnabled() const;
    ENGINE_API virtual FDisplacementFadeRange GetDisplacementFadeRange() const;
    ENGINE_API virtual float GetMaxWorldPositionOffsetDisplacement() const;
    ENGINE_API virtual bool ShouldAlwaysEvaluateWorldPositionOffset() const;
    ENGINE_API virtual bool HasVertexInterpolator() const;
    ENGINE_API virtual bool HasCustomizedUVs() const;
    ENGINE_API virtual bool HasPixelAnimation() const;
    ENGINE_API virtual USubsurfaceProfile* GetSubsurfaceProfile_Internal() const;
    ENGINE_API virtual USubsurfaceProfile* GetSubsurfaceProfileRoot_Internal() const;
    ENGINE_API virtual uint32 NumSubsurfaceProfileRoot_Internal() const;
    ENGINE_API virtual USubsurfaceProfile* GetSubsurfaceProfileRoot_Internal(uint32 Index) const;
    ENGINE_API virtual USubsurfaceProfile* GetSubsurfaceProfileOverride_Internal() const;
    ENGINE_API virtual uint32 NumSpecularProfile_Internal() const;
    ENGINE_API virtual USpecularProfile* GetSpecularProfile_Internal(uint32 Index) const;
    ENGINE_API virtual USpecularProfile* GetSpecularProfileOverride_Internal() const;
    ENGINE_API virtual UNeuralProfile* GetNeuralProfile_Internal() const;
    ENGINE_API virtual bool CastsRayTracedShadows() const;
    ENGINE_API virtual bool IsTessellationEnabled() const;
    ENGINE_API virtual bool HasSubstrateRoughnessTracking() const;
    ENGINE_API virtual bool IsCompatibleWithLumenCardSharing() const;
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API virtual void SetForceMipLevelsToBeResident( bool OverrideForceMiplevelsToBeResident, bool bForceMiplevelsToBeResidentValue, float ForceDuration, int32 CinematicTextureGroups = 0, bool bFastResponse = false );
 
    ENGINE_API static void RecacheAllMaterialUniformExpressions(bool bRecreateUniformBuffer);
 
    ENGINE_API static void SubmitRemainingJobsForWorld(UWorld* World, EMaterialShaderPrecompileMode CompileMode = EMaterialShaderPrecompileMode::Default);
 
    virtual void RecacheUniformExpressions(bool bRecreateUniformBuffer) const {}
 
    virtual void CacheShaders(EMaterialShaderPrecompileMode CompileMode = EMaterialShaderPrecompileMode::Default) {}
 
#if WITH_EDITOR
    virtual void CacheGivenTypesForCooking(EShaderPlatform Platform, ERHIFeatureLevel::Type FeatureLevel, EMaterialQualityLevel::Type QualityLevel, const TArray<const FVertexFactoryType*>& VFTypes, const TArray<const FShaderPipelineType*> PipelineTypes, const TArray<const FShaderType*>& ShaderTypes) {}
    virtual void AppendCompileStateDebugInfo(FStringBuilderBase& OutDebugInfo) const {}
#endif
 
    virtual bool IsComplete() const { return true; }
 
#if WITH_EDITOR
    virtual bool IsCompiling() const { return false; };
#else
    inline bool IsCompiling() const { return false; }
#endif
 
    ENGINE_API void EnsureIsComplete();
 
#if WITH_EDITOR
    virtual void ForceRecompileForRendering(EMaterialShaderPrecompileMode CompileMode = EMaterialShaderPrecompileMode::Default) {}
#endif // WITH_EDITOR
 
    ENGINE_API static void AssertDefaultMaterialsExist();
 
    ENGINE_API static void AssertDefaultMaterialsPostLoaded();
 
    ENGINE_API static void InitDefaultMaterials();
 
    ENGINE_API static bool IsDefaultMaterialInitialized();
 
    ENGINE_API static void PrecacheDefaultMaterialPSOs();
 
    ENGINE_API virtual bool IsPropertyActive(EMaterialProperty InProperty) const;
 
#if WITH_EDITOR
    ENGINE_API int32 CompileProperty(FMaterialCompiler* Compiler, EMaterialProperty Property, uint32 ForceCastFlags = 0);
 
    ENGINE_API virtual int32 CompilePropertyEx( class FMaterialCompiler* Compiler, const FGuid& AttributeID );
 
    virtual bool ShouldForcePlanePreview()
    {
        return bShouldForcePlanePreview;
    }
    
    void SetShouldForcePlanePreview(const bool bInShouldForcePlanePreview)
    {
        bShouldForcePlanePreview = bInShouldForcePlanePreview;
    };
#endif // WITH_EDITOR
 
    ENGINE_API static uint32 GetFeatureLevelsToCompileForAllMaterials();
 
    ENGINE_API void AnalyzeMaterialProperty(EMaterialProperty InProperty, int32& OutNumTextureCoordinates, bool& bOutRequiresVertexData);
 
    ENGINE_API void AnalyzeMaterialPropertyEx(EMaterialProperty InProperty, FMaterialAnalysisResult& OutResult);
 
    ENGINE_API void AnalyzeMaterialCustomOutput(UMaterialExpressionCustomOutput* InCustomOutput, int32 InOutputIndex, FMaterialAnalysisResult& OutResult);
 
    ENGINE_API void AnalyzeMaterialCompilationInCallback(TFunctionRef<void (FMaterialCompiler*)> InCompilationCallback, FMaterialAnalysisResult& OutResult);
 
    UE_DEPRECATED(5.7, "Please use AnalyzeMaterialTranslationOutput with ValidationMode argument")
    ENGINE_API void AnalyzeMaterialTranslationOutput(FMaterialResource* MaterialResource, EShaderPlatform ShaderPlatform, FMaterialAnalysisResult& OutResult);
    ENGINE_API void AnalyzeMaterialTranslationOutput(FMaterialResource* MaterialResource, EShaderPlatform ShaderPlatform, bool ValidationMode, FMaterialAnalysisResult& OutResult);
 
#if WITH_EDITOR
    ENGINE_API bool IsTextureReferencedByProperty(EMaterialProperty InProperty, const UTexture* InTexture);
#endif // WITH_EDITOR
 
    template <typename FunctionType>
    static void IterateOverActiveFeatureLevels(FunctionType InHandler) 
    {  
        uint32 FeatureLevels = GetFeatureLevelsToCompileForAllMaterials();
        while (FeatureLevels != 0)
        {
            InHandler((ERHIFeatureLevel::Type)FBitSet::GetAndClearNextBit(FeatureLevels));
        }
    }
 
    static UEnum* GetSamplerTypeEnum() 
    { 
        check(SamplerTypeEnum); 
        return SamplerTypeEnum; 
    }
 
    ENGINE_API bool UseAnyStreamingTexture() const;
    inline bool HasTextureStreamingData() const { return TextureStreamingData.Num() != 0; }
    inline const TArray<FMaterialTextureInfo>& GetTextureStreamingData() const { return TextureStreamingData; }
    inline TArray<FMaterialTextureInfo>& GetTextureStreamingData() { return TextureStreamingData; }
    ENGINE_API bool FindTextureStreamingDataIndexRange(FName TextureName, int32& LowerIndex, int32& HigherIndex) const;
 
    ENGINE_API void SetTextureStreamingData(const TArray<FMaterialTextureInfo>& InTextureStreamingData);
 
    ENGINE_API virtual float GetTextureDensity(FName TextureName, const struct FMeshUVChannelInfo& UVChannelData) const;
 
#if !WITH_EDITOR
    ENGINE_API float GetTextureDensityWithCache(const FTextureSamplingInfo& TextureSamplingInfo, const FMeshUVChannelInfo& UVChannelData) const;
#endif
 
    ENGINE_API virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
 
    ENGINE_API void SortTextureStreamingData(bool bForceSort, bool bFinalSort);
 
#if WITH_EDITOR
    virtual void GetShaderTypes(EShaderPlatform Platform, const ITargetPlatform* TargetPlatform, TArray<FDebugShaderTypeInfo>& OutShaderInfo) {};
#endif // WITH_EDITOR
 
    ENGINE_API static void FilterOutPlatformShadingModels(EShaderPlatform Platform, FMaterialShadingModelField& ShadingModels);
    
#if WITH_EDITOR
    TUniquePtr<FMaterialInsights> MaterialInsight;
#endif // WITH_EDITOR
 
protected:
    ENGINE_API uint32 GetFeatureLevelsToCompileForRendering() const;
 
    void UpdateMaterialRenderProxy(FMaterialRenderProxy& Proxy);
 
    bool bLoadedCachedExpressionData = false;
    
    TUniquePtr<FMaterialCachedExpressionData> CachedExpressionData;
 
private:
    static void PostLoadDefaultMaterials();
 
    static UEnum* SamplerTypeEnum;
 
#if WITH_EDITOR
public:
    ENGINE_API void SetMarkTextureAsEditorStreamingPool(bool bInMarkAsEditorStreamingPool);
 
protected:
    mutable TOptional<FStaticParameterSet> CachedStaticParameterValues;
    mutable uint8 AllowCachingStaticParameterValuesCounter = 0;
 
private:
    bool bShouldForcePlanePreview;
#endif
};
 
namespace UE::MaterialInterface::Private
{
 
extern void SerializeInlineShaderMaps(
    FArchive& Ar,
    TArray<FMaterialResource>& OutLoadedResources,
    const FName& SerializingAsset = NAME_None
#if WITH_EDITOR
    , const TMap<const ITargetPlatform*, TArray<FMaterialResourceForCooking>>* PlatformMaterialResourcesToSave = nullptr
#endif
);
 
}
 
extern void ProcessSerializedInlineShaderMaps(UMaterialInterface* Owner, TArray<FMaterialResource>& LoadedResources, TArray<FMaterialResource*>& OutMaterialResourcesLoaded);
 
UE_DEPRECATED(5.7, "Please use FindMaterialResource with EShaderPlatform argument and not ERHIFeatureLevel::Type")
extern FMaterialResource* FindMaterialResource(const TArray<FMaterialResource*>& MaterialResources, ERHIFeatureLevel::Type InFeatureLevel, EMaterialQualityLevel::Type QualityLevel, bool bAllowDefaultQuality);
UE_DEPRECATED(5.7, "Please use FindMaterialResource with EShaderPlatform argument and not ERHIFeatureLevel::Type")
extern FMaterialResource* FindMaterialResource(TArray<FMaterialResource*>& MaterialResources, ERHIFeatureLevel::Type InFeatureLevel, EMaterialQualityLevel::Type QualityLevel, bool bAllowDefaultQuality);
 
extern FMaterialResource* FindMaterialResource(const TArray<FMaterialResource*>& MaterialResources, EShaderPlatform InShaderPlatform, EMaterialQualityLevel::Type QualityLevel, bool bAllowDefaultQuality);
extern FMaterialResource* FindMaterialResource(TArray<FMaterialResource*>& MaterialResources, EShaderPlatform InShaderPlatform, EMaterialQualityLevel::Type QualityLevel, bool bAllowDefaultQuality);
 
UE_DEPRECATED(5.7, "Please use FindOrCreateMaterialResource with EShaderPlatform argument and not ERHIFeatureLevel::Type")
ENGINE_API FMaterialResource* FindOrCreateMaterialResource(TArray<FMaterialResource*>& MaterialResources,
    UMaterial* OwnerMaterial,
    UMaterialInstance* OwnerMaterialInstance,
    ERHIFeatureLevel::Type InFeatureLevel,
    EMaterialQualityLevel::Type QualityLevel);
 
ENGINE_API FMaterialResource* FindOrCreateMaterialResource(TArray<FMaterialResource*>& MaterialResources,
    UMaterial* OwnerMaterial,
    UMaterialInstance* OwnerMaterialInstance,
    EShaderPlatform InShaderPlatform,
    EMaterialQualityLevel::Type QualityLevel);
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "Materials/MaterialIRModule.h"
#endif