Material.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Misc/Guid.h"
#include "Engine/EngineTypes.h"
#include "HAL/ThreadSafeBool.h"
#include "RenderCommandFence.h"
#include "Materials/MaterialInterface.h"
 
#if WITH_EDITOR
#include "RHIDefinitions.h"
#endif
 
#include "MaterialExpressionIO.h"
#include "Materials/MaterialExpression.h"
#include "Materials/MaterialFunctionInterface.h"
#include "Materials/MaterialLayersFunctions.h"
#include "Materials/MaterialOverrideNanite.h"
#include "Templates/UniquePtr.h"
#include "Shader/ShaderTypes.h"
#include "Physics/PhysicsInterfaceCore.h"
#include "Material.generated.h"
 
enum EMaterialDomain : int;
enum class EMaterialTranslateValidationFlags : uint32;
class ITargetPlatform;
class UMaterialExpressionComment;
class UPhysicalMaterial;
class UPhysicalMaterialMask;
class USubsurfaceProfile;
class USpecularProfile;
class UTexture;
struct FODSCRequestPayload;
 
#if WITH_EDITOR
 
struct FMaterialsWithDirtyUsageFlags
{
    uint32 MaterialFlagsThatHaveChanged;
 
    FMaterialsWithDirtyUsageFlags():
    MaterialFlagsThatHaveChanged(0)
    {
    }
 
    inline bool IsDefault()
    {
        return MaterialFlagsThatHaveChanged == DefaultAnnotation.MaterialFlagsThatHaveChanged;
    }
 
    void MarkUsageFlagDirty(EMaterialUsage UsageFlag);
 
    bool IsUsageFlagDirty(EMaterialUsage UsageFlag);
 
    static const FMaterialsWithDirtyUsageFlags DefaultAnnotation;
};
#endif
 
UENUM()
enum EDecalBlendMode : int
{
    DBM_Translucent UMETA(DisplayName="Translucent"),
    DBM_Stain UMETA(DisplayName="Stain"),
    DBM_Normal UMETA(DisplayName="Normal"),
    DBM_Emissive UMETA(DisplayName="Emissive"),
    DBM_DBuffer_ColorNormalRoughness UMETA(DisplayName="DBuffer Translucent Color,Normal,Roughness"),
    DBM_DBuffer_Color UMETA(DisplayName="DBuffer Translucent Color"),
    DBM_DBuffer_ColorNormal UMETA(DisplayName="DBuffer Translucent Color,Normal"),
    DBM_DBuffer_ColorRoughness UMETA(DisplayName="DBuffer Translucent Color,Roughness"),
    DBM_DBuffer_Normal UMETA(DisplayName="DBuffer Translucent Normal"),
    DBM_DBuffer_NormalRoughness UMETA(DisplayName="DBuffer Translucent Normal,Roughness"),
    DBM_DBuffer_Roughness UMETA(DisplayName="DBuffer Translucent Roughness"),
 
    DBM_DBuffer_Emissive UMETA(DisplayName = "DBuffer Emissive", Hidden),
    DBM_DBuffer_AlphaComposite UMETA(DisplayName = "DBuffer AlphaComposite (Premultiplied Alpha)", Hidden),
    DBM_DBuffer_EmissiveAlphaComposite UMETA(DisplayName = "DBuffer Emissive AlphaComposite (Premultiplied Alpha)", Hidden),
 
    DBM_Volumetric_DistanceFunction UMETA(DisplayName="Volumetric Distance Function (experimental)"),
    
    DBM_AlphaComposite UMETA(DisplayName ="AlphaComposite (Premultiplied Alpha)"),
 
    DBM_AmbientOcclusion UMETA(DisplayName = "Ambient Occlusion"),
 
    DBM_MAX,
};
 
UENUM()
enum EMaterialDecalResponse : int
{
    MDR_None UMETA(DisplayName="None"),
 
    MDR_ColorNormalRoughness UMETA(DisplayName="Color Normal Roughness"),
    MDR_Color UMETA(DisplayName="Color"),
    MDR_ColorNormal UMETA(DisplayName="Color Normal"),
    MDR_ColorRoughness UMETA(DisplayName="Color Roughness"),
    MDR_Normal UMETA(DisplayName="Normal"),
    MDR_NormalRoughness UMETA(DisplayName="Normal Roughness"),
    MDR_Roughness UMETA(DisplayName="Roughness"),
    MDR_MAX
};
 
UENUM()
enum EMaterialTranslucencyPass : int
{
    MTP_BeforeDOF UMETA(DisplayName="Before DOF"),
    MTP_AfterDOF UMETA(DisplayName="After DOF"),
    MTP_AfterMotionBlur UMETA(DisplayName="After Motion Blur"),
    MTP_MAX
};
 
// Material input structs.
//@warning: manually mirrored in MaterialShared.h
#if !CPP      //noexport struct
USTRUCT(noexport)
struct FMaterialInput
{
    UPROPERTY()
    TObjectPtr<class UMaterialExpression> Expression;
 
    UPROPERTY()
    int32 OutputIndex;
 
    UPROPERTY()
    FName InputName;
 
    UPROPERTY()
    int32 Mask;
 
    UPROPERTY()
    int32 MaskR;
 
    UPROPERTY()
    int32 MaskG;
 
    UPROPERTY()
    int32 MaskB;
 
    UPROPERTY()
    int32 MaskA;
};
#endif
 
#if !CPP      //noexport struct
USTRUCT(noexport)
struct FColorMaterialInput : public FMaterialInput
{
    UPROPERTY()
    uint32 UseConstant : 1;
 
    UPROPERTY()
    FLinearColor Constant;
 
    FColorMaterialInput() :
        UseConstant(0) {}
};
#endif
 
#if !CPP      //noexport struct
USTRUCT(noexport)
struct FScalarMaterialInput : public FMaterialInput
{
    UPROPERTY()
    uint32 UseConstant : 1;
 
    UPROPERTY()
    float Constant;
 
    FScalarMaterialInput() :
        UseConstant(0) {}
};
#endif
 
#if !CPP      //noexport struct
USTRUCT(noexport)
struct FShadingModelMaterialInput : public FMaterialInput
{
    // No support for constant
};
#endif
 
#if !CPP      //noexport struct
USTRUCT(noexport)
struct FSubstrateMaterialInput : public FMaterialInput
{
    // No support for constant
};
#endif
 
#if !CPP      //noexport struct
USTRUCT(noexport)
struct FVectorMaterialInput : public FMaterialInput
{
    UPROPERTY()
    uint32 UseConstant : 1;
 
    UPROPERTY()
    FVector3f Constant;
 
    FVectorMaterialInput:
        UseConstant(0) {}
};
#endif
 
#if !CPP      //noexport struct
USTRUCT(noexport)
struct FVector2MaterialInput : public FMaterialInput
{
    UPROPERTY()
    uint32 UseConstant : 1;
 
    UPROPERTY()
    float ConstantX=0.0f;
 
    UPROPERTY()
    float ConstantY=0.0f;
 
    FVector2MaterialInput:
        UseConstant(0) {}
};
#endif
 
struct FMaterialInputDescription
{
    FExpressionInput* Input = nullptr;
    UE::Shader::EValueType Type = UE::Shader::EValueType::Void;
    UE::Shader::FValue ConstantValue;
    bool bUseConstant = false;
    bool bHidden = false;
};
 
USTRUCT()
struct FParameterGroupData
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(VisibleAnywhere, Category = "Group Sorting")
    FString GroupName;
 
    UPROPERTY(EditAnywhere, Category = "Group Sorting")
    int32 GroupSortPriority;
 
    FParameterGroupData()
    {
        GroupName = FString(TEXT(""));
        GroupSortPriority = 0;
    }
 
    FParameterGroupData(const FString& InString, int32 InSortPriority)
    :   GroupName(InString),
        GroupSortPriority(InSortPriority)
    {
    }
 
    bool operator==(const FParameterGroupData& Other) const
    {
        return GroupName == Other.GroupName && GroupSortPriority == Other.GroupSortPriority;
    }
};
 
UCLASS(MinimalAPI, Optional)
class UMaterialEditorOnlyData : public UMaterialInterfaceEditorOnlyData
{
    GENERATED_BODY()
public:
    UMaterialEditorOnlyData();
 
    // Reflection
    UPROPERTY()
    FColorMaterialInput BaseColor;
 
    UPROPERTY()
    FScalarMaterialInput Metallic;
 
    UPROPERTY()
    FScalarMaterialInput Specular;
 
    UPROPERTY()
    FScalarMaterialInput Roughness;
 
    UPROPERTY()
    FScalarMaterialInput Anisotropy;
 
    UPROPERTY()
    FVectorMaterialInput Normal;
 
    UPROPERTY()
    FVectorMaterialInput Tangent;
 
    UPROPERTY()
    FColorMaterialInput EmissiveColor;
 
    // Transmission.
    UPROPERTY()
    FScalarMaterialInput Opacity;
 
    UPROPERTY()
    FScalarMaterialInput OpacityMask;
 
    UPROPERTY()
    FVectorMaterialInput WorldPositionOffset;
 
    UPROPERTY()
    FScalarMaterialInput Displacement;
 
    UPROPERTY()
    FColorMaterialInput SubsurfaceColor;
 
    UPROPERTY()
    FScalarMaterialInput ClearCoat;
 
    UPROPERTY()
    FScalarMaterialInput ClearCoatRoughness;
 
    UPROPERTY()
    FScalarMaterialInput AmbientOcclusion;
 
    UPROPERTY()
    FScalarMaterialInput Refraction;
 
    UPROPERTY()
    FVector2MaterialInput CustomizedUVs[8];
 
    UPROPERTY()
    FMaterialAttributesInput MaterialAttributes;
 
    UPROPERTY()
    FScalarMaterialInput PixelDepthOffset;
 
    UPROPERTY()
    FShadingModelMaterialInput ShadingModelFromMaterialExpression;
 
    UPROPERTY()
    FScalarMaterialInput SurfaceThickness;
 
    UPROPERTY()
    FSubstrateMaterialInput FrontMaterial;
 
    UPROPERTY()
    FMaterialExpressionCollection ExpressionCollection;
 
    UPROPERTY(EditAnywhere, EditFixedSize, Category = "Group Sorting")
    TArray<FParameterGroupData> ParameterGroupData;
 
    UPROPERTY()
    int32 SubstrateConversionVersion;
 
    UPROPERTY()
    int32 SubstrateVersion;
 
    UPROPERTY()
    bool bIsSubsutrateAutoConvertedAndNotSaved = false;
 
    ENGINE_API void ResetSubstrateConversionVersion();
 
    ENGINE_API bool IsSubstrateAutoConverted() const;
};
 
UCLASS(hidecategories=Object, MinimalAPI, BlueprintType, PrioritizeCategories = ("Material", "Nanite", "Translucency", "TranslucencySelfShadowing", "Refraction", "WorldPositionOffset", "PostProcessMaterial",  "Mobile", "ForwardShading", "PhysicalMaterial", "PhysicalMaterialMask", "Usage", "Lightmass", "Previewing", "ImportSettings"))
class UMaterial : public UMaterialInterface
{
    GENERATED_UCLASS_BODY()
 
#if WITH_EDITORONLY_DATA
    virtual const UClass* GetEditorOnlyDataClass() const override { return UMaterialEditorOnlyData::StaticClass(); }
 
    virtual UMaterialEditorOnlyData* GetEditorOnlyData() override { return CastChecked<UMaterialEditorOnlyData>(Super::GetEditorOnlyData(), ECastCheckedType::NullAllowed); }
    virtual const UMaterialEditorOnlyData* GetEditorOnlyData() const override { return CastChecked<UMaterialEditorOnlyData>(Super::GetEditorOnlyData(), ECastCheckedType::NullAllowed); }
#endif // WITH_EDITORONLY_DATA
 
    // Physics.
    
    UPROPERTY(EditAnywhere, Category=PhysicalMaterial)
    TObjectPtr<class UPhysicalMaterial> PhysMaterial;
 
    UPROPERTY(EditAnywhere, Category = PhysicalMaterial)
    TObjectPtr<class UPhysicalMaterialMask> PhysMaterialMask;
 
    UPROPERTY(EditAnywhere, Category = PhysicalMaterialMask)
    TObjectPtr<class UPhysicalMaterial> PhysicalMaterialMap[EPhysicalMaterialMaskColor::MAX];
    
 
    UPROPERTY()
    TArray<TObjectPtr<class UPhysicalMaterial>> RenderTracePhysicalMaterialOutputs;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Material, AssetRegistrySearchable)
    TEnumAsByte<EMaterialDomain> MaterialDomain;
 
    UPROPERTY(BlueprintReadOnly, EditAnywhere, Category=Material, AssetRegistrySearchable)
    TEnumAsByte<EBlendMode> BlendMode;
 
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "No longer used."))
    TEnumAsByte<EDecalBlendMode> DecalBlendMode;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Material, AdvancedDisplay, meta=(DisplayName = "Decal Response (DBuffer)"), AssetRegistrySearchable)
    TEnumAsByte<EMaterialDecalResponse> MaterialDecalResponse;
 
    UPROPERTY(EditAnywhere, Category=Nanite, meta = (EditInline, ShowOnlyInnerProperties))
    FMaterialOverrideNanite NaniteOverrideMaterial;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Nanite, meta = (DisplayName = "Displacement", EditCondition="bEnableTessellation", DisplayAfter="bEnableTessellation"))
    FDisplacementScaling DisplacementScaling;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Nanite, meta = (DisplayName = "Displacement Fade", EditCondition="bEnableDisplacementFade", DisplayAfter="DisplacementScaling"))
    FDisplacementFadeRange DisplacementFadeRange;
 
private:
    UPROPERTY(EditAnywhere, Category=Material, AssetRegistrySearchable)
    TEnumAsByte<EMaterialShadingModel> ShadingModel; 
 
public:
    UPROPERTY(EditAnywhere, Category = Material, AdvancedDisplay)
    uint8 bCastDynamicShadowAsMasked : 1;
 
private:
    UPROPERTY(AssetRegistrySearchable)
    FMaterialShadingModelField ShadingModels;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(VisibleAnywhere, Transient, Category=Material)
    FString UsedShadingModels;
#endif
 
public:
 
    UPROPERTY(EditAnywhere, Category = Material, AdvancedDisplay)
    float OpacityMaskClipValue;
 
private:
    UPROPERTY()
    uint8 bEnableSeparateTranslucency_DEPRECATED : 1;
 
public:
    UPROPERTY(EditAnywhere, Category=Translucency, meta=(DisplayName = "Responsive AA"), AdvancedDisplay)
    uint8 bEnableResponsiveAA : 1;
 
    UPROPERTY(EditAnywhere, Category=Translucency, meta=(DisplayName = "Screen Space Reflections"))
    uint8 bScreenSpaceReflections : 1;
 
    UPROPERTY(EditAnywhere, Category = Translucency, meta = (DisplayName = "Contact Shadows"))
    uint8 bContactShadows : 1;
 
    UPROPERTY(EditAnywhere, Category=Material)
    uint8 TwoSided : 1;
 
    UPROPERTY(EditAnywhere, Category = Material)
    uint8 bIsThinSurface : 1;
 
    UPROPERTY(EditAnywhere, Category = Material, AdvancedDisplay, meta = (DisplayName = "Dithered LOD Transition"))
    uint8 DitheredLODTransition : 1;
 
    UPROPERTY(EditAnywhere, Category=Material, AdvancedDisplay)
    uint8 DitherOpacityMask : 1;
 
    UPROPERTY(EditAnywhere, Category=Material, AdvancedDisplay)
    uint8 bAllowNegativeEmissiveColor : 1;
    
    UPROPERTY(EditAnywhere, Category=Material, meta=(DisplayName = "Has Pixel Animation"), AdvancedDisplay)
    uint8 bHasPixelAnimation : 1;
    
    UPROPERTY(EditAnywhere, Category=Nanite, meta = (Keywords = "Displacement"))
    uint8 bEnableTessellation : 1;
 
    UPROPERTY(EditAnywhere, Category=Nanite, meta=(EditCondition="bEnableTessellation", InlineEditConditionToggle))
    uint8 bEnableDisplacementFade : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category=Translucency)
    TEnumAsByte<EMaterialTranslucencyPass> TranslucencyPass;
 
    UPROPERTY(EditAnywhere, AssetRegistrySearchable, Category=Translucency, meta=(DisplayName = "Lighting Mode"))
    TEnumAsByte<ETranslucencyLightingMode> TranslucencyLightingMode;
 
    UPROPERTY(EditAnywhere, Category = Translucency, meta = (DisplayName = "Mobile Separate Translucency"), AdvancedDisplay)
    uint8 bEnableMobileSeparateTranslucency : 1;
 
    UPROPERTY(EditAnywhere, Category = Material, AdvancedDisplay, meta = (ClampMin = 0))
    int32 NumCustomizedUVs;
 
    UPROPERTY(EditAnywhere, Category=Translucency, meta=(DisplayName = "Directional Lighting Intensity"))
    float TranslucencyDirectionalLightingIntensity;
 
    UPROPERTY(EditAnywhere, Category=TranslucencySelfShadowing, meta=(DisplayName = "Shadow Density Scale"))
    float TranslucentShadowDensityScale;
 
    UPROPERTY(EditAnywhere, Category=TranslucencySelfShadowing, meta=(DisplayName = "Self Shadow Density Scale"))
    float TranslucentSelfShadowDensityScale;
 
    UPROPERTY(EditAnywhere, Category=TranslucencySelfShadowing, meta=(DisplayName = "Second Density Scale"))
    float TranslucentSelfShadowSecondDensityScale;
 
    UPROPERTY(EditAnywhere, Category=TranslucencySelfShadowing, meta=(DisplayName = "Second Opacity"))
    float TranslucentSelfShadowSecondOpacity;
 
    UPROPERTY(EditAnywhere, Category=TranslucencySelfShadowing, meta=(DisplayName = "Backscattering Exponent"))
    float TranslucentBackscatteringExponent;
 
    UPROPERTY(EditAnywhere, Category=TranslucencySelfShadowing, meta=(DisplayName = "Multiple Scattering Extinction"))
    FLinearColor TranslucentMultipleScatteringExtinction;
 
    UPROPERTY(EditAnywhere, Category=TranslucencySelfShadowing, meta=(DisplayName = "Start Offset"))
    float TranslucentShadowStartOffset;
 
    UPROPERTY(EditAnywhere, Category=Translucency, AdvancedDisplay)
    uint8 bDisableDepthTest : 1;
 
    UPROPERTY(EditAnywhere, Category = Translucency, AdvancedDisplay)
    uint8 bWriteOnlyAlpha : 1;
 
    UPROPERTY(EditAnywhere, Category=Material, AdvancedDisplay)
    uint8 bGenerateSphericalParticleNormals : 1;
 
    UPROPERTY(EditAnywhere, Category=Material, AdvancedDisplay)
    uint8 bTangentSpaceNormal : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Material, meta=(DisplayName = "Emissive (Dynamic Area Light)"), AdvancedDisplay)
    uint8 bUseEmissiveForDynamicAreaLighting : 1;
 
    UPROPERTY(duplicatetransient)
    uint8 bUsedAsSpecialEngineMaterial : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, meta = (DisplayName = "Roughness Tracking"), Category = Substrate)
    uint8 bSubstrateRoughnessTracking : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Usage)
    uint8 bUsedWithSkeletalMesh : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Usage)
    uint8 bUsedWithEditorCompositing : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Usage)
    uint8 bUsedWithParticleSprites : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Usage)
    uint8 bUsedWithBeamTrails : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Usage)
    uint8 bUsedWithMeshParticles : 1;
 
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Usage)
    uint8 bUsedWithNiagaraSprites : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Usage)
    uint8 bUsedWithNiagaraRibbons : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Usage)
    uint8 bUsedWithNiagaraMeshParticles : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Usage)
    uint8 bUsedWithGeometryCache : 1;
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Usage)
    uint8 bUsedWithStaticLighting : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Usage)
    uint8 bUsedWithMorphTargets : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Usage)
    uint8 bUsedWithSplineMeshes : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Usage)
    uint8 bUsedWithInstancedStaticMeshes : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Usage)
    uint8 bUsedWithGeometryCollections : 1;
 
    UPROPERTY()
    uint8 bUsesDistortion : 1;
 
     UPROPERTY()
    uint8 bRootNodeOverridesDefaultDistortion_DEPRECATED : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Usage)
    uint8 bUsedWithClothing : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Usage)
    uint32 bUsedWithWater : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Usage)
    uint32 bUsedWithHairStrands : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Usage)
    uint32 bUsedWithLidarPointCloud : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Usage)
    uint32 bUsedWithVirtualHeightfieldMesh : 1;
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Usage)
    uint32 bUsedWithNanite : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Usage)
    uint8 bUsedWithVoxels : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Usage)
    uint32 bUsedWithVolumetricCloud : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Usage)
    uint32 bUsedWithHeterogeneousVolumes : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Usage, AdvancedDisplay)
    uint32 bUsedWithStaticMesh : 1;
 
    UPROPERTY()
    uint8 bUsedWithUI_DEPRECATED : 1;
 
    UPROPERTY(EditAnywhere, Category = LightFunctionMaterial, meta = (DisplayName = "Compatible With Light Function Atlas"))
    uint8 bForceCompatibleWithLightFunctionAtlas : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Usage, AdvancedDisplay)
    uint8 bAutomaticallySetUsageInEditor : 1;
 
    /* Forces the material to be completely rough. Saves a number of instructions and one sampler. */
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Material, AdvancedDisplay)
    uint8 bFullyRough : 1;
 
    UPROPERTY()
    uint8 bUseFullPrecision_DEPRECATED : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Mobile)
    TEnumAsByte<EMaterialFloatPrecisionMode> FloatPrecisionMode;
 
    /* Use lightmap directionality and per pixel normals. If disabled, lighting from lightmaps will be flat but cheaper. */
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Mobile)
    uint8 bUseLightmapDirectionality : 1;
 
    /* Use alpha to coverage for masked material on mobile, make sure MSAA is enabled as well. */
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Mobile, AdvancedDisplay, meta = (EditCondition = "BlendMode != EBlendMode::BLEND_Opaque"))
    uint8 bUseAlphaToCoverage : 1;
 
    /* Forward (including mobile) renderer: use preintegrated GF lut for simple IBL, but will use one more sampler. */
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = ForwardShading, meta = (DisplayName = "PreintegratedGF For Simple IBL"))
    uint32 bForwardRenderUsePreintegratedGFForSimpleIBL : 1;
 
    /* 
     * Forward renderer: enables multiple parallax-corrected reflection captures that blend together.
     */
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = ForwardShading, meta = (DisplayName = "High Quality Reflections"))
    uint8 bUseHQForwardReflections : 1;
 
    /* 
     * Enables blending of sky light cubemap textures. When disabled, the secondary cubemap is only visible when the blend factor is 1.
     */
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = ForwardShading, meta = (DisplayName = "Blend Sky Light Cubemaps"))
    uint8 bForwardBlendsSkyLightCubemaps : 1;
 
    /* Enables planar reflection when using the forward renderer or mobile. Enabling this setting reduces the number of samplers available to the material as one more sampler will be used for the planar reflection. */
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = ForwardShading, meta = (DisplayName = "Planar Reflections"))
    uint8 bUsePlanarForwardReflections : 1;
 
    /* Reduce roughness based on screen space normal changes. */
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Material, AdvancedDisplay)
    uint8 bNormalCurvatureToRoughness : 1;
 
    UPROPERTY(EditAnywhere, Category = Translucency, AdvancedDisplay, meta = (DisplayName = "Allow Custom Depth Writes"))
    uint8 AllowTranslucentCustomDepthWrites : 1;
 
    UPROPERTY(EditAnywhere, Category = Translucency, AdvancedDisplay, meta = (DisplayName = "Allow Front Layer Translucency"))
    uint8 bAllowFrontLayerTranslucency : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Material, AdvancedDisplay)
    uint8 bCompatibleWithLumenCardSharing : 1;
 
    UPROPERTY(EditAnywhere, Category=Material, AdvancedDisplay)
    uint8 Wireframe : 1;
 
    UPROPERTY(EditAnywhere, Category = Translucency, AdvancedDisplay, meta = (DisplayName = "Allow Local Light Shadow"))
    uint8 bAllowTranslucentLocalLightShadow : 1;
 
    UPROPERTY(EditAnywhere, Category = Translucency, AdvancedDisplay, meta = (DisplayName = "Local Light Shadow Quality", UIMin = "0", UIMax = "1", ClampMin = "0", ClampMax = "1", SliderExponent = 1.0))
    float TranslucentLocalLightShadowQuality = 0;
 
    UPROPERTY(EditAnywhere, Category = Translucency, AdvancedDisplay, meta = (DisplayName = "Directional Light Shadow Quality", UIMin = "0", UIMax = "1", ClampMin = "0", ClampMax = "1", SliderExponent = 1.0))
    float TranslucentDirectionalLightShadowQuality = 0;
 
    UPROPERTY(EditAnywhere, Category = Material, AdvancedDisplay)
    TEnumAsByte<EMaterialShadingRate> ShadingRate;
 
    UPROPERTY(EditAnywhere, Category = Material, AdvancedDisplay)
    uint8 bAllowVariableRateShading : 1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    int32 EditorX;
 
    UPROPERTY()
    int32 EditorY;
 
    UPROPERTY()
    int32 EditorPitch;
 
    UPROPERTY()
    int32 EditorYaw;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY()
    uint8 bCanMaskedBeAssumedOpaque : 1;
 
    UPROPERTY()
    uint8 bIsMasked_DEPRECATED : 1;
 
    UPROPERTY(transient, duplicatetransient)
    uint8 bIsPreviewMaterial : 1;
 
    UPROPERTY(transient, duplicatetransient)
    uint8 bIsFunctionPreviewMaterial : 1;
 
    UPROPERTY(EditAnywhere, Category=Material)
    uint8 bUseMaterialAttributes : 1;
 
    UE_DEPRECATED(5.8, "Experimental bEnableExecWire is no longer supported.")
    UPROPERTY(EditAnywhere, Category = Material)
    uint8 bEnableExecWire : 1;
 
    UPROPERTY(EditAnywhere, Category = Material)
    uint8 bEnableNewHLSLGenerator : 1;
 
    UPROPERTY(EditAnywhere, Category = Material)
    uint8 bCastRayTracedShadows : 1;
 
    UPROPERTY(EditAnywhere, Category=Translucency, meta=(DisplayName = "Apply Fogging"))
    uint8 bUseTranslucencyVertexFog : 1;
 
    UPROPERTY(EditAnywhere, Category=Translucency, meta=(DisplayName = "Apply Cloud Fogging"))
    uint8 bApplyCloudFogging : 1;
 
    UPROPERTY(EditAnywhere, Category=Material, AdvancedDisplay)
    uint8 bIsSky : 1;
 
    UPROPERTY(EditAnywhere, Category=Translucency)
    uint8 bComputeFogPerPixel : 1;
 
    UPROPERTY(EditAnywhere, Category = Translucency, meta = (DisplayName = "Output Depth and Velocity"))
    uint8 bOutputTranslucentVelocity : 1;
 
    UPROPERTY(EditAnywhere, Category = Translucency, meta = (DisplayName = "Velocity From Depth Only", editcondition = "bOutputTranslucentVelocity"))
    uint8 bIsTranslucencyVelocityFromDepth : 1;
 
    UPROPERTY(transient, duplicatetransient)
    uint8 bAllowDevelopmentShaderCompile : 1;
 
    UPROPERTY(transient, duplicatetransient)
    uint8 bIsMaterialEditorStatsMaterial : 1;
 
    UPROPERTY(EditAnywhere, Category = VirtualTexture)
    uint8 bRelaxRuntimeVirtualTextureRestrictions : 1;
    uint8 bRelaxRuntimeVirtualTextureRestrictionsForOldContent : 1;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PostProcessMaterial, meta=(DisplayName = "Blendable Location"))
    TEnumAsByte<EBlendableLocation> BlendableLocation;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = PostProcessMaterial, meta = (DisplayName = "Output Alpha"))
    uint8 BlendableOutputAlpha : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = PostProcessMaterial, meta = (DisplayName = "User Scene Texture"))
    FName UserSceneTexture;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = PostProcessMaterial, meta = (DisplayName = "User Texture Divisor"))
    FIntPoint UserTextureDivisor = FIntPoint(0, 0);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = PostProcessMaterial, meta = (DisplayName = "Resolution Relative To Input"))
    FName ResolutionRelativeToInput;
 
    UPROPERTY(EditAnywhere, Category = PostProcessMaterial)
    uint8 bDisablePreExposureScale : 1;
 
    UPROPERTY(EditAnywhere, Category = PostProcessMaterial)
    uint8 bUsedWithNeuralNetworks : 1;
 
    UPROPERTY(EditAnywhere, Category = PostProcessMaterial, AdvancedDisplay)
    uint8 bEnableStencilTest : 1;
 
    UPROPERTY(EditAnywhere, Category = PostProcessMaterial, AdvancedDisplay, meta = (EditCondition = "bEnableStencilTest"))
    TEnumAsByte<EMaterialStencilCompare> StencilCompare;
 
    UPROPERTY(EditAnywhere, Category = PostProcessMaterial, AdvancedDisplay, meta = (EditCondition = "bEnableStencilTest"))
    uint8 StencilRefValue = 0;
 
    UPROPERTY(EditAnywhere, Category = PostProcessMaterial, AdvancedDisplay, meta = (EditCondition = "false"))
    int8 NeuralProfileId = INDEX_NONE;
 
    UPROPERTY()
    TEnumAsByte<ERefractionMode> RefractionMode_DEPRECATED;
 
    UPROPERTY(EditAnywhere, Category=Refraction)
    TEnumAsByte<ERefractionMode> RefractionMethod;
 
    UPROPERTY(EditAnywhere, Category=Refraction)
    TEnumAsByte<ERefractionCoverageMode> RefractionCoverageMode;
 
    UPROPERTY(EditAnywhere, Category=PixelDepthOffset)
    TEnumAsByte<EPixelDepthOffsetMode> PixelDepthOffsetMode;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = PostProcessMaterial, meta = (DisplayName = "Blendable Priority"))
    int32 BlendablePriority;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = PostProcessMaterial, meta = (DisplayName = "Is Blendable"))
    uint8 bIsBlendable : 1;
 
    UPROPERTY(EditAnywhere, Category = Material, AdvancedDisplay)
    uint16 PreshaderGap;
 
    UPROPERTY(transient, duplicatetransient)
    uint32 UsageFlagWarnings;
 
    mutable std::atomic<uint32> UsageFlagCacheMiss{0u};
 
    UPROPERTY(EditAnywhere, Category=Refraction)
    float RefractionDepthBias;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = WorldPositionOffset, meta = (ClampMin = 0.0f))
    float MaxWorldPositionOffsetDisplacement;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = WorldPositionOffset)
    bool bAlwaysEvaluateWorldPositionOffset;
 
    FSubstrateCompilationConfig SubstrateCompilationConfig;
 
    UPROPERTY()
    FGuid StateId;
 
    class FDefaultMaterialInstance* DefaultMaterialInstance;
 
#if WITH_EDITORONLY_DATA
    TMap<FName, TArray<UMaterialExpression*> > EditorParameters;
 
    TObjectPtr<class UMaterialGraph>    MaterialGraph;
#endif //WITH_EDITORONLY_DATA
 
private:
    TArray<FMaterialResource> LoadedMaterialResources;
 
    TArray<FMaterialResource*> MaterialResources;
#if WITH_EDITOR
    TMap<const ITargetPlatform*, TArray<FMaterialResourceForCooking>> CachedMaterialResourcesForCooking;
#endif
    FThreadSafeBool ReleasedByRT;
 
    mutable bool bCachingUniformExpressions = false;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    bool bSavedCachedExpressionData_DEPRECATED;
#endif
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TArray<FGuid> ReferencedTextureGuids;
 
#endif // WITH_EDITORONLY_DATA
public:
 
    ENGINE_API UMaterial();
    ENGINE_API UMaterial(FVTableHelper& Helper);
 
    //~ Begin UMaterialInterface Interface.
    ENGINE_API virtual UMaterial* GetMaterial() override;
    ENGINE_API virtual const UMaterial* GetMaterial() const override;
    ENGINE_API virtual const UMaterial* GetMaterial_Concurrent(TMicRecursionGuard RecursionGuard = TMicRecursionGuard()) const override;
    ENGINE_API virtual void GetMaterialInheritanceChain(FMaterialInheritanceChain& OutChain) const override;
    ENGINE_API virtual bool GetParameterValue(EMaterialParameterType Type, const FMemoryImageMaterialParameterInfo& ParameterInfo, FMaterialParameterMetadata& OutValue, EMaterialGetParameterValueFlags Flags = EMaterialGetParameterValueFlags::Default) const override;
 
    ENGINE_API virtual bool GetRefractionSettings(float& OutBiasValue) const override;
    ENGINE_API virtual EBlendableLocation GetBlendableLocation(const UMaterial* Base) const override;
    ENGINE_API virtual int32 GetBlendablePriority(const UMaterial* Base) const override;
    ENGINE_API virtual void GetDependencies(TSet<UMaterialInterface*>& Dependencies) override;
    ENGINE_API virtual FMaterialRenderProxy* GetRenderProxy() const override;
    ENGINE_API virtual UPhysicalMaterial* GetPhysicalMaterial() const override;
    ENGINE_API virtual UPhysicalMaterialMask* GetPhysicalMaterialMask() const override;
    ENGINE_API virtual UPhysicalMaterial* GetPhysicalMaterialFromMap(int32 Index) const override;
    ENGINE_API virtual UMaterialInterface* GetNaniteOverride(TMicRecursionGuard RecursionGuard = TMicRecursionGuard()) const override;
    ENGINE_API virtual void GetUsedTextures(TArray<UTexture*>& OutTextures, TOptional<EMaterialQualityLevel::Type> InSpecificQualityLevel = TOptional<EMaterialQualityLevel::Type>(), TOptional<EShaderPlatform> InSpecificShaderPlatform = TOptional<EShaderPlatform>()) const override;
    ENGINE_API virtual void GetUsedTexturesAndIndices(TArray<UTexture*>& OutTextures, TArray< TArray<int32> >& OutIndices, EMaterialQualityLevel::Type QualityLevel, EShaderPlatform InShaderPlatform) const override;
    ENGINE_API virtual void OverrideTexture(const UTexture* InTextureToOverride, UTexture* OverrideTexture, ERHIFeatureLevel::Type InFeatureLevel) override;
    ENGINE_API virtual void SetNumericParameterDefault(EMaterialParameterType Type, const FHashedMaterialParameterInfo& ParameterInfo, const UE::Shader::FValue& Value, EShaderPlatform InShaderPlatform) override;
    ENGINE_API virtual void ClearNumericParameterDefault(EMaterialParameterType Type, const FHashedMaterialParameterInfo& ParameterInfo, EShaderPlatform InShaderPlatform) override;
    ENGINE_API virtual bool CheckMaterialUsage(const EMaterialUsage Usage) override;
    ENGINE_API virtual bool CheckMaterialUsage_Concurrent(const EMaterialUsage Usage) const override;
    ENGINE_API virtual FMaterialResource* AllocateResource();
    ENGINE_API virtual FMaterialResource* GetMaterialResource(EShaderPlatform InShaderPlatform, EMaterialQualityLevel::Type QualityLevel = EMaterialQualityLevel::Num) override;
    ENGINE_API virtual const FMaterialResource* GetMaterialResource(EShaderPlatform InShaderPlatform, EMaterialQualityLevel::Type QualityLevel = EMaterialQualityLevel::Num) const override;
    ENGINE_API virtual bool GetMaterialLayers(FMaterialLayersFunctions& OutLayers, TMicRecursionGuard RecursionGuard = TMicRecursionGuard()) const override;
    ENGINE_API virtual bool UpdateLightmassTextureTracking() override;
#if WITH_EDITOR
    ENGINE_API virtual bool GetGroupSortPriority(const FString& InGroupName, int32& OutSortPriority) const override;
    ENGINE_API virtual bool GetTexturesInPropertyChain(EMaterialProperty InProperty, TArray<UTexture*>& OutTextures, 
        TArray<FName>* OutTextureParamNames, struct FStaticParameterSet* InStaticParameterSet,
        ERHIFeatureLevel::Type InFeatureLevel, EMaterialQualityLevel::Type InQuality) override;
#endif
    ENGINE_API virtual void RecacheUniformExpressions(bool bRecreateUniformBuffer) const override;
    
    ENGINE_API virtual float GetOpacityMaskClipValue() const override;
    ENGINE_API virtual bool GetCastDynamicShadowAsMasked() const override;
    ENGINE_API virtual EBlendMode GetBlendMode() const override;
    ENGINE_API virtual FMaterialShadingModelField GetShadingModels() const override;
    ENGINE_API virtual bool IsShadingModelFromMaterialExpression() const override;
    ENGINE_API virtual bool IsTwoSided() const override;
    ENGINE_API virtual bool IsThinSurface() const override;
    ENGINE_API virtual bool IsDitheredLODTransition() const override;
    ENGINE_API virtual bool IsTranslucencyWritingCustomDepth() const override;
    ENGINE_API virtual bool IsTranslucencyWritingVelocity() const override;
    ENGINE_API virtual bool IsTranslucencyVelocityFromDepth() const override;
    ENGINE_API virtual bool IsTranslucencyWritingFrontLayerTransparency() const override;
    ENGINE_API virtual bool IsMasked() const override;
    ENGINE_API virtual bool IsDeferredDecal() const override;
    ENGINE_API virtual bool IsUIMaterial() const;
    ENGINE_API virtual bool IsPostProcessMaterial() const;
    ENGINE_API bool IsPostProcessMaterialOutputingAlpha() const;
    ENGINE_API virtual USubsurfaceProfile* GetSubsurfaceProfile_Internal() const override;
    ENGINE_API virtual USubsurfaceProfile* GetSubsurfaceProfileRoot_Internal() const override;
    ENGINE_API virtual uint32 NumSubsurfaceProfileRoot_Internal() const override;
    ENGINE_API virtual USubsurfaceProfile* GetSubsurfaceProfileRoot_Internal(uint32 Index) const override;
    ENGINE_API virtual USubsurfaceProfile* GetSubsurfaceProfileOverride_Internal() const override;
    ENGINE_API virtual uint32 NumSpecularProfile_Internal() const override;
    ENGINE_API virtual USpecularProfile* GetSpecularProfile_Internal(uint32 Index) const override;
    ENGINE_API virtual UNeuralProfile* GetNeuralProfile_Internal() const override;
    ENGINE_API virtual bool CastsRayTracedShadows() const override;
    ENGINE_API virtual bool IsTessellationEnabled() const override;
    ENGINE_API virtual FDisplacementScaling GetDisplacementScaling() const override;
    ENGINE_API virtual bool IsDisplacementFadeEnabled() const override;
    ENGINE_API virtual FDisplacementFadeRange GetDisplacementFadeRange() const override;
    ENGINE_API virtual float GetMaxWorldPositionOffsetDisplacement() const override;
    ENGINE_API virtual bool ShouldAlwaysEvaluateWorldPositionOffset() const override;
    ENGINE_API virtual bool HasPixelAnimation() const override;
    ENGINE_API virtual bool HasVertexInterpolator() const override;
    ENGINE_API virtual bool HasCustomizedUVs() const override;
    ENGINE_API virtual bool WritesToRuntimeVirtualTexture() const override;
    ENGINE_API virtual bool HasMeshPaintTexture() const override;
    ENGINE_API virtual bool HasCustomPrimitiveData() const override;
    ENGINE_API virtual bool HasSubstrateRoughnessTracking() const override;
    ENGINE_API virtual bool IsCompatibleWithLumenCardSharing() const override;
 
    ENGINE_API bool IsMobileSeparateTranslucencyEnabled() const;
 
    ENGINE_API virtual FGraphEventArray PrecachePSOs(const FPSOPrecacheVertexFactoryDataList& VertexFactoryDataList, const FPSOPrecacheParams& PreCacheParams, EPSOPrecachePriority Priority, TArray<FMaterialPSOPrecacheRequestID>& OutMaterialPSORequestIDs) override;
 
    ENGINE_API void SetShadingModel(EMaterialShadingModel NewModel);
 
    ENGINE_API virtual bool IsPropertyActive(EMaterialProperty InProperty) const override;
 
#if WITH_EDITORONLY_DATA
    ENGINE_API bool SupportsShadingModelOverride() const;
#endif
 
#if WITH_EDITOR
    ENGINE_API bool IsPropertyActiveInEditor(EMaterialProperty InProperty) const;
#endif
 
    ENGINE_API bool IsPropertyActiveInDerived(EMaterialProperty InProperty, const UMaterialInterface* DerivedMaterial) const;
 
#if WITH_EDITOR
    ENGINE_API virtual int32 CompilePropertyEx( class FMaterialCompiler* Compiler, const FGuid& AttributeID ) override;
    ENGINE_API virtual bool ShouldForcePlanePreview() override;
    ENGINE_API virtual void ForceRecompileForRendering(EMaterialShaderPrecompileMode CompileMode = EMaterialShaderPrecompileMode::Default) override;
#endif // WITH_EDITOR
    //~ End UMaterialInterface Interface.
 
    //~ Begin UObject Interface
    ENGINE_API virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
#if WITH_EDITOR
    ENGINE_API virtual void OnCookEvent(UE::Cook::ECookEvent CookEvent, UE::Cook::FCookEventContext& CookContext) override;
#endif
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
    ENGINE_API virtual void PostLoad() override;
#if WITH_EDITORONLY_DATA
    ENGINE_API static void DeclareConstructClasses(TArray<FTopLevelAssetPath>& OutConstructClasses, const UClass* SpecificSubclass);
#endif
#if WITH_EDITOR
    ENGINE_API virtual void BeginCacheForCookedPlatformData( const ITargetPlatform *TargetPlatform ) override;
    ENGINE_API virtual bool IsCachedCookedPlatformDataLoaded( const ITargetPlatform* TargetPlatform ) override;
    ENGINE_API virtual void ClearCachedCookedPlatformData( const ITargetPlatform *TargetPlatform ) override;
    ENGINE_API virtual void ClearAllCachedCookedPlatformData() override;
#endif
#if WITH_EDITOR
    ENGINE_API virtual void PreEditChange(FProperty* PropertyAboutToChange) override;
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual bool CanEditChange(const FProperty* InProperty) const override;
    ENGINE_API virtual bool Modify(bool bAlwaysMarkDirty = true) override;
#endif // WITH_EDITOR
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual bool IsReadyForFinishDestroy() override;
    ENGINE_API virtual void FinishDestroy() override;
    ENGINE_API virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    ENGINE_API static void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
    ENGINE_API virtual bool CanBeClusterRoot() const override;
    ENGINE_API virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const override;
    //~ End UObject Interface
 
    enum class EPostEditChangeEffectOnShaders
    {
        Default,
        DoesNotInvalidate
    };
 
    ENGINE_API void PostEditChangePropertyInternal(FPropertyChangedEvent& PropertyChangedEvent, const EPostEditChangeEffectOnShaders EffectOnShaders);
 
#if WITH_EDITOR
    ENGINE_API virtual void CancelOutstandingCompilation();
#endif // WITH_EDITOR
 
    ENGINE_API static UMaterial* GetDefaultMaterial(EMaterialDomain Domain);
 
    ENGINE_API bool IsDefaultMaterial() const;
 
    ENGINE_API void ReleaseResources();
 
    ENGINE_API bool IsUsageFlagDirty(EMaterialUsage Usage);
    
    UE_DEPRECATED(5.7, "Please use IsCompilingOrHadCompileError with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    ENGINE_API bool IsCompilingOrHadCompileError(ERHIFeatureLevel::Type InFeatureLevel);
 
    ENGINE_API bool IsCompilingOrHadCompileError(EShaderPlatform InShaderPlatform);
 
#if WITH_EDITORONLY_DATA
    ENGINE_API TConstArrayView<TObjectPtr<UMaterialExpression>> GetExpressions() const;
#endif // WITH_EDITORONLY_DATA
 
#if WITH_EDITOR
    ENGINE_API TConstArrayView<TObjectPtr<UMaterialExpressionComment>> GetEditorComments() const;
    ENGINE_API const FMaterialExpressionCollection& GetExpressionCollection() const;
    ENGINE_API FMaterialExpressionCollection& GetExpressionCollection();
    ENGINE_API void AssignExpressionCollection(const FMaterialExpressionCollection& InCollection);
 
    ENGINE_API bool SetParameterValueEditorOnly(const FName& ParameterName, const FMaterialParameterMetadata& Meta);
    ENGINE_API bool SetVectorParameterValueEditorOnly(FName ParameterName, FLinearColor InValue);
    ENGINE_API bool SetScalarParameterValueEditorOnly(FName ParameterName, float InValue);
    ENGINE_API bool SetTextureParameterValueEditorOnly(FName ParameterName, class UTexture* InValue);
    ENGINE_API bool SetTextureCollectionParameterValueEditorOnly(FName ParameterName, class UTextureCollection* InValue);
    ENGINE_API bool SetRuntimeVirtualTextureParameterValueEditorOnly(FName ParameterName, class URuntimeVirtualTexture* InValue);
    ENGINE_API bool SetSparseVolumeTextureParameterValueEditorOnly(FName ParameterName, class USparseVolumeTexture* InValue);
    ENGINE_API bool SetFontParameterValueEditorOnly(FName ParameterName, class UFont* InFontValue, int32 InFontPage);
    ENGINE_API bool SetStaticComponentMaskParameterValueEditorOnly(FName ParameterName, bool R, bool G, bool B, bool A, FGuid OutExpressionGuid);
    ENGINE_API bool SetStaticSwitchParameterValueEditorOnly(FName ParameterName, bool OutValue, FGuid OutExpressionGuid);
#endif // WITH_EDITOR
 
    void StartCacheUniformExpressions() const;
    void FinishCacheUniformExpressions() const;
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    ENGINE_API virtual void LogMaterialsAndTextures(FOutputDevice& Ar, int32 Indent) const override;
#endif
 
    ENGINE_API virtual void GetLightingGuidChain(bool bIncludeTextures, TArray<FGuid>& OutGuids) const override;
 
#if WITH_EDITOR
    ENGINE_API virtual uint32 ComputeAllStateCRC() const override;
#endif // WITH_EDITOR
 
    ENGINE_API bool CheckInValidStateForCompilation(class FMaterialCompiler* Compiler) const;
    
private:
 
    void SetInitialValues();
 
    void MarkUsageFlagDirty(EMaterialUsage Usage, bool CurrentValue, bool NewValue);
 
    void SetUsageByFlag(const EMaterialUsage Usage, const bool NewValue);
 
    void PropagateDataToMaterialProxy();
 
#if WITH_EDITOR
    void BackwardsCompatibilityInputConversion();
    void BackwardsCompatibilityVirtualTextureOutputConversion();
    void BackwardsCompatibilityDecalConversion();
    bool ConvertMaterialToSubstrateMaterial(bool bAllowEmptyMaterialUpdate, bool bRequestedByUser = false);
 
    void FixupMaterialUsageAfterLoad();
#endif
 
public:
 
#if WITH_EDITOR
    ENGINE_API bool UserRequestsConvertMaterialToSubstrateMaterial();
#endif
 
    FString GetUsageName(const EMaterialUsage Usage) const;
 
    ENGINE_API bool GetUsageByFlag(const EMaterialUsage Usage) const;
 
 
    ENGINE_API bool SetMaterialUsage(bool &bNeedsRecompile, const EMaterialUsage Usage, UMaterialInterface* MaterialInstance = nullptr);
 
    ENGINE_API bool NeedsSetMaterialUsage_Concurrent(bool &bOutHasUsage, const EMaterialUsage Usage) const;
 
    ENGINE_API virtual void CacheShaders(EMaterialShaderPrecompileMode CompileMode) override;
#if WITH_EDITOR
    ENGINE_API virtual void CacheGivenTypesForCooking(EShaderPlatform ShaderPlatform, ERHIFeatureLevel::Type FeatureLevel, EMaterialQualityLevel::Type QualityLevel, const TArray<const FVertexFactoryType*>& VFTypes, const TArray<const FShaderPipelineType*> PipelineTypes, const TArray<const FShaderType*>& ShaderTypes) override;
#endif
    ENGINE_API virtual bool IsComplete() const override;
 
#if WITH_EDITOR
    ENGINE_API virtual bool IsCompiling() const override;
#endif
 
#if WITH_EDITORONLY_DATA
    ENGINE_API virtual bool IterateDependentFunctions(TFunctionRef<bool(UMaterialFunctionInterface*)> Predicate) const override;
    ENGINE_API virtual void GetDependentFunctions(TArray<class UMaterialFunctionInterface*>& DependentFunctions) const override;
#endif // WITH_EDITORONLY_DATA
 
    uint32 GetMaterialDecalResponse() const { return MaterialDecalResponse; }
 
#if WITH_EDITORONLY_DATA
    template<typename ExpressionType>
    ExpressionType* FindExpressionByGUID(const FGuid &InGUID)
    {
        if (InGUID.IsValid())
        {
            return FindExpressionByGUIDRecursive<ExpressionType>(InGUID, GetExpressions());
        }
        return nullptr;
    }
 
    /* Get all expressions of the requested type */
    template<typename ExpressionType>
    void GetAllExpressionsOfType(TArray<const ExpressionType*>& OutExpressions) const
    {
        for (UMaterialExpression* Expression : GetExpressions())
        {
            ExpressionType* ExpressionPtr = Cast<ExpressionType>(Expression);
            if (ExpressionPtr)
            {
                OutExpressions.Add(ExpressionPtr);
            }
        }
    }
 
    static ENGINE_API UMaterialFunctionInterface* GetExpressionFunctionPointer(const UMaterialExpression* Expression);
 
    struct FLayersInterfaces
    {
        TConstArrayView<UMaterialFunctionInterface*> Layers;
        TConstArrayView<UMaterialFunctionInterface*> Blends;
    };
    static ENGINE_API TOptional<FLayersInterfaces> GetExpressionLayers(const UMaterialExpression* Expression);
 
    template<typename ExpressionType>
    void GetAllExpressionsInMaterialAndFunctionsOfType(TArray<ExpressionType*>& OutExpressions) const
    {
        for (UMaterialExpression* Expression : GetExpressions())
        {
            ExpressionType* ExpressionOfType = Cast<ExpressionType>(Expression);
            if (ExpressionOfType)
            {
                OutExpressions.Add(ExpressionOfType);
            }
 
            if (UMaterialFunctionInterface* MaterialFunction = GetExpressionFunctionPointer(Expression))
            {
                MaterialFunction->GetAllExpressionsOfType<ExpressionType>(OutExpressions);
            }
            else if (TOptional<FLayersInterfaces> LayersInterfaces = GetExpressionLayers(Expression))
            {
                for (UMaterialFunctionInterface* Layer : LayersInterfaces->Layers)
                {
                    if (Layer)
                    {
                        Layer->GetAllExpressionsOfType<ExpressionType>(OutExpressions);
                    }
                }
 
                for (UMaterialFunctionInterface* Blend : LayersInterfaces->Blends)
                {
                    if (Blend)
                    {
                        Blend->GetAllExpressionsOfType<ExpressionType>(OutExpressions);
                    }
                }
            }
        }
    }
 
    template<typename ExpressionType>
    bool HasAnyExpressionsInMaterialAndFunctionsOfType() const
    {
        for (UMaterialExpression* Expression : GetExpressions())
        {
            ExpressionType* ExpressionOfType = Cast<ExpressionType>(Expression);
            if (ExpressionOfType)
            {
                return true;
            }
 
            if (UMaterialFunctionInterface* MaterialFunction = GetExpressionFunctionPointer(Expression))
            {
                if (MaterialFunction->HasAnyExpressionsOfType<ExpressionType>())
                {
                    return true;
                }
            }
            else if (TOptional<FLayersInterfaces> LayersInterfaces = GetExpressionLayers(Expression))
            {
                for (auto* Layer : LayersInterfaces->Layers)
                {
                    if (Layer && Layer->HasAnyExpressionsOfType<ExpressionType>())
                    {
                        return true;
                    }
                }
 
                for (auto* Blend : LayersInterfaces->Blends)
                {
                    if (Blend && Blend->HasAnyExpressionsOfType<ExpressionType>())
                    {
                        return true;
                    }
                }
            }
        }
 
        return false;
    }
 
    ENGINE_API void UpdateTransientExpressionData();
#endif // WITH_EDITORONLY_DATA
 
#if WITH_EDITOR
    ENGINE_API void UpdateCachedExpressionData();
#endif
 
    ENGINE_API bool AttemptInsertNewGroupName(const FString& InNewName);
 
private:
    ENGINE_API virtual void ReleaseResourcesAndMutateDDCKey(const FGuid& TransformationId = FGuid());
    
    void CacheResourceShadersForRendering(bool bRegenerateId, EMaterialShaderPrecompileMode PrecompileMode = EMaterialShaderPrecompileMode::Default);
 
#if WITH_EDITOR
    void CacheResourceShadersForCooking(EShaderPlatform Platform, TArray<FMaterialResourceForCooking>& OutCachedMaterialResources, 
        const ITargetPlatform* TargetPlatform = nullptr, bool bBlocking = false);
#endif
 
    void GetNewResources(EShaderPlatform ShaderPlatform, TArray<FMaterialResource*>& NewResourcesToCache);
 
    void CacheShadersForResources(EShaderPlatform ShaderPlatform, const TArray<FMaterialResource*>& ResourcesToCache, EMaterialShaderPrecompileMode PrecompileMode = EMaterialShaderPrecompileMode::Default, const ITargetPlatform* TargetPlatform = nullptr);
 
#if WITH_EDITOR
 
    void BeginCacheShadersForResources(EShaderPlatform ShaderPlatform, const TArray<FMaterialResource*>& ResourcesToCache, EMaterialShaderPrecompileMode PrecompileMode = EMaterialShaderPrecompileMode::Default, const ITargetPlatform* TargetPlatform = nullptr);
 
    void GetForceRecompileTextureIdsHash(FSHAHash &TextureReferencesHash);
#endif // WITH_EDITOR
 
public:
#if WITH_EDITOR
    ENGINE_API bool IsTextureForceRecompileCacheRessource(UTexture *Texture);
 
    /* Recompute the ddc cache key and reload the material in case the key is not the same.
     * It will also make sure lightmass texture reference are up to date
     */
    ENGINE_API void UpdateMaterialShaderCacheAndTextureReferences();
#endif
 
    ENGINE_API static void UpdateMaterialShaders(TArray<const FShaderType*>& ShaderTypesToFlush, TArray<const FShaderPipelineType*>& ShaderPipelineTypesToFlush, TArray<const FVertexFactoryType*>& VFTypesToFlush, EShaderPlatform ShaderPlatform);
 
#if WITH_EDITOR
    ENGINE_API static void CompileMaterialsForRemoteRecompile(
        const TArray<UMaterialInterface*>& MaterialsToCompile,
        EShaderPlatform ShaderPlatform,
        class ITargetPlatform* TargetPlatform,
        TMap<FString, TArray<TRefCountPtr<class FMaterialShaderMap> > >& OutShaderMaps);
 
    ENGINE_API static void CompileODSCMaterialsForRemoteRecompile(TArray<FODSCRequestPayload> ShadersToRecompile, TMap<FString, TArray<TRefCountPtr<class FMaterialShaderMap>>>& OutShaderMaps, TFunction<UMaterialInterface*(const FString&)> ODSCCustomLoadMaterial = {});
 
    ENGINE_API virtual bool AddExpressionParameter(UMaterialExpression* Expression, TMap<FName, TArray<UMaterialExpression*> >& ParameterTypeMap);
 
    ENGINE_API virtual bool RemoveExpressionParameter(UMaterialExpression* Expression);
 
    ENGINE_API virtual void PropagateExpressionParameterChanges(const UMaterialExpression* Parameter);
 
    ENGINE_API virtual void PropagateExpressionParameterChanges(const FName& ParameterName, const FMaterialParameterMetadata& Meta);
 
    ENGINE_API virtual void UpdateExpressionParameterName(UMaterialExpression* Expression);
 
    ENGINE_API virtual void BuildEditorParameterList();
 
    ENGINE_API virtual bool HasDuplicateParameters(const UMaterialExpression* Expression);
 
    ENGINE_API virtual bool HasDuplicateDynamicParameters(const UMaterialExpression* Expression);
 
    ENGINE_API virtual void UpdateExpressionDynamicParameters(const UMaterialExpression* Expression);
 
    ENGINE_API void RebuildShadingModelField();
 
    static bool GetExpressionParameterName(const UMaterialExpression* Expression, FName& OutName);
 
    ENGINE_API static bool IsParameter(const UMaterialExpression* Expression);
 
    ENGINE_API static bool IsDynamicParameter(const UMaterialExpression* Expression);
#endif // WITH_EDITOR
 
    /* Helper functions for text output of properties. */
    static const TCHAR* GetMaterialShadingModelString(EMaterialShadingModel InMaterialShadingModel);
    static EMaterialShadingModel GetMaterialShadingModelFromString(const TCHAR* InMaterialShadingModelStr);
    static const TCHAR* GetBlendModeString(EBlendMode InBlendMode);
    static EBlendMode GetBlendModeFromString(const TCHAR* InBlendModeStr);
 
#if WITH_EDITOR
    ENGINE_API FExpressionInput* GetExpressionInputForProperty(EMaterialProperty InProperty);
 
    ENGINE_API bool GetExpressionInputDescription(EMaterialProperty InProperty, FMaterialInputDescription& OutDescription);
#endif
 
#if WITH_EDITORONLY_DATA
    /* Returns any UMaterialExpressionFunctionOutput expressions */
    ENGINE_API void GetAllFunctionOutputExpressions(TArray<class UMaterialExpressionFunctionOutput*>& OutFunctionOutputs) const;
    /* Returns any UMaterialExpressionCustomOutput expressions */
    ENGINE_API void GetAllCustomOutputExpressions(TArray<class UMaterialExpressionCustomOutput*>& OutCustomOutputs) const;
    ENGINE_API void GetAllExpressionsForCustomInterpolators(TArray<class UMaterialExpression*>& OutExpressions) const;
#endif // WITH_EDITORONLY_DATA
 
#if WITH_EDITOR
    ENGINE_API virtual bool GetAllReferencedExpressions(TArray<UMaterialExpression*>& OutExpressions, struct FStaticParameterSet* InStaticParameterSet,
        ERHIFeatureLevel::Type InFeatureLevel = ERHIFeatureLevel::Num, EMaterialQualityLevel::Type InQuality = EMaterialQualityLevel::Num, ERHIShadingPath::Type InShadingPath = ERHIShadingPath::Num, const bool bInRecurseIntoMaterialFunctions = false, TSet<UClass*>* InMobileCustomOutputExpressionTypesToQuery = nullptr);
 
 
    ENGINE_API virtual bool GetExpressionsInPropertyChain(EMaterialProperty InProperty, 
        TArray<UMaterialExpression*>& OutExpressions, struct FStaticParameterSet* InStaticParameterSet,
        ERHIFeatureLevel::Type InFeatureLevel = ERHIFeatureLevel::Num, EMaterialQualityLevel::Type InQuality = EMaterialQualityLevel::Num, ERHIShadingPath::Type InShadingPath = ERHIShadingPath::Num, const bool bInRecurseIntoMaterialFunctions = false);
 
#endif // WITH_EDITOR
 
protected:
 
#if WITH_EDITOR
    ENGINE_API virtual bool RecursiveGetExpressionChain(UMaterialExpression* InExpression, TArray<FExpressionInput*>& InOutProcessedInputs, 
        TArray<UMaterialExpression*>& OutExpressions, struct FStaticParameterSet* InStaticParameterSet,
        ERHIFeatureLevel::Type InFeatureLevel = ERHIFeatureLevel::Num,
        EMaterialQualityLevel::Type InQuality = EMaterialQualityLevel::Num,
        ERHIShadingPath::Type InShadingPath = ERHIShadingPath::Num,
        EShaderFrequency InShaderFrequency = SF_NumFrequencies, 
        EMaterialProperty InProperty = MP_MAX,
        const bool bInRecurseIntoMaterialFunctions = false);
 
    void RecursiveUpdateRealtimePreview(UMaterialExpression* InExpression, TArray<UMaterialExpression*>& InOutExpressionsToProcess);
#endif
 
public:
    ENGINE_API virtual void DumpDebugInfo(FOutputDevice& OutputDevice) const override;
    void SaveShaderStableKeys(const class ITargetPlatform* TP);
    ENGINE_API virtual void SaveShaderStableKeysInner(const class ITargetPlatform* TP, const struct FStableShaderKeyAndValue& SaveKeyVal) override;
 
#if WITH_EDITOR
    ENGINE_API virtual void GetShaderTypes(EShaderPlatform Platform, const ITargetPlatform* TargetPlatform, TArray<FDebugShaderTypeInfo>& OutShaderInfo) override;
 
    ENGINE_API virtual void AppendCompileStateDebugInfo(FStringBuilderBase& OutDebugInfo) const override;
#endif // WITH_EDITOR
 
    ENGINE_API bool IsPropertyConnected(EMaterialProperty Property) const;
    ENGINE_API bool HasBaseColorConnected() const;
    ENGINE_API bool HasRoughnessConnected() const;
    ENGINE_API bool HasAmbientOcclusionConnected() const;
    ENGINE_API bool HasNormalConnected() const;
    ENGINE_API bool HasSpecularConnected() const;
    ENGINE_API bool HasMetallicConnected() const;
    ENGINE_API bool HasEmissiveColorConnected() const;
    ENGINE_API bool HasAnisotropyConnected() const;
    ENGINE_API bool HasSurfaceThicknessConnected() const;
    ENGINE_API bool HasSubstrateFrontMaterialConnected() const;
    ENGINE_API bool HasVertexPositionOffsetConnected() const;
    ENGINE_API bool HasDisplacementConnected() const;
    ENGINE_API bool HasPixelDepthOffsetConnected() const;
 
    // Return true if the property is supported
    ENGINE_API bool IsPropertySupported(EMaterialProperty InProperty) const;
 
    ENGINE_API static bool IsPropertyRelevantForMobile(EMaterialProperty InProperty);
 
#if WITH_EDITOR
    static void NotifyCompilationFinished(UMaterialInterface* Material);
 
    DECLARE_EVENT_OneParam( UMaterial, FMaterialCompilationFinished, UMaterialInterface* );
    ENGINE_API static FMaterialCompilationFinished& OnMaterialCompilationFinished();
#endif // WITH_EDITOR
 
    // For all materials, UMaterial::CacheResourceShadersForRendering
    ENGINE_API static void AllMaterialsCacheResourceShadersForRendering(bool bUpdateProgressDialog = false, bool bCacheAllRemainingShaders = true);
 
#if WITH_EDITORONLY_DATA
    static void FlipExpressionPositions(TConstArrayView<TObjectPtr<UMaterialExpression>> Expressions, TConstArrayView<TObjectPtr<UMaterialExpressionComment>> Comments, bool bScaleCoords, UMaterial* Material = NULL);
 
    static void FixCommentPositions(TConstArrayView<TObjectPtr<UMaterialExpressionComment>> Comments);
 
    bool HasFlippedCoordinates();
 
    static bool FixFeatureLevelNodesForSM6(TArray<UMaterialExpression*> const& InExpressions);
 
#endif //WITH_EDITORONLY_DATA
    ENGINE_API TArrayView<const TObjectPtr<UPhysicalMaterial>> GetRenderTracePhysicalMaterialOutputs() const;
 
    ENGINE_API void SetRenderTracePhysicalMaterialOutputs(TArrayView<TObjectPtr<UPhysicalMaterial>> PhysicalMaterials);
 
#if WITH_EDITOR
    ENGINE_API void GetShaderTags(TArray<FName>& OutShaderTags) const;
    ENGINE_API EMaterialTranslateValidationFlags GetMaterialTranslateValidationFlags() const;
#endif
 
private:
#if WITH_EDITOR
    static FMaterialCompilationFinished MaterialCompilationFinishedEvent;
 
    bool IsRefractionPinPluggedIn(const UMaterialEditorOnlyData* EditorOnly);
#endif // WITH_EDITOR
 
    friend class FLightmassMaterialProxy;
    friend class FMaterialUpdateContext;
    friend class FMaterialResource;
    friend class FMaterialEditor;
    friend class FMaterialDetailCustomization;
 
    // DO NOT CALL outside of FMaterialEditor!
    ENGINE_API static void ForceNoCompilationInPostLoad(bool bForceNoCompilation);
 
#if WITH_EDITORONLY_DATA
    /* Helper function to help finding expression GUID taking into account UMaterialExpressionMaterialFunctionCall */
    template<typename ExpressionType>
    ExpressionType* FindExpressionByGUIDRecursive(const FGuid& InGUID, TConstArrayView<TObjectPtr<UMaterialExpression>> InMaterialExpression)
    {
        for (int32 ExpressionIndex = 0; ExpressionIndex < InMaterialExpression.Num(); ExpressionIndex++)
        {
            UMaterialExpression* ExpressionPtr = InMaterialExpression[ExpressionIndex];
 
            if (ExpressionPtr && ExpressionPtr->GetParameterExpressionId() == InGUID)
            {
                check(ExpressionPtr->bIsParameterExpression);
                return Cast<ExpressionType>(ExpressionPtr);
            }
            else if (UMaterialFunctionInterface* MaterialFunction = GetExpressionFunctionPointer(ExpressionPtr))
            {
                if (ExpressionType* Expression = FindExpressionByGUIDRecursive<ExpressionType>(InGUID, MaterialFunction->GetExpressions()))
                {
                    return Expression;
                }
            }
            else if (TOptional<FLayersInterfaces> LayersInterfaces = UMaterial::GetExpressionLayers(ExpressionPtr))
            {
                for (const auto* Layer : LayersInterfaces->Layers)
                {
                    if (Layer)
                    {
                        if (ExpressionType* Expression = FindExpressionByGUIDRecursive<ExpressionType>(InGUID, Layer->GetExpressions()))
                        {
                            return Expression;
                        }
                    }
                }
 
                for (const auto* Blend : LayersInterfaces->Blends)
                {
                    if (Blend)
                    {
                        if (ExpressionType* Expression = FindExpressionByGUIDRecursive<ExpressionType>(InGUID, Blend->GetExpressions()))
                        {
                            return Expression;
                        }
                    }
                }
            }
        }
 
        return nullptr;
    }
#endif // WITH_EDITORONLY_DATA
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TArray<TObjectPtr<class UMaterialExpressionComment>> EditorComments_DEPRECATED;
 
    UPROPERTY()
    TArray<TObjectPtr<class UMaterialExpression>> Expressions_DEPRECATED;
 
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "GetEditorOnlyData().ParameterGroupData"))
    TArray<FParameterGroupData> ParameterGroupData_DEPRECATED;
 
    UPROPERTY()
    FColorMaterialInput DiffuseColor_DEPRECATED;
 
    UPROPERTY()
    FColorMaterialInput SpecularColor_DEPRECATED;
 
    UPROPERTY()
    FColorMaterialInput BaseColor_DEPRECATED;
 
    UPROPERTY()
    FScalarMaterialInput Metallic_DEPRECATED;
 
    UPROPERTY()
    FScalarMaterialInput Specular_DEPRECATED;
 
    UPROPERTY()
    FScalarMaterialInput Roughness_DEPRECATED;
 
    UPROPERTY()
    FScalarMaterialInput Anisotropy_DEPRECATED;
 
    UPROPERTY()
    FVectorMaterialInput Normal_DEPRECATED;
 
    UPROPERTY()
    FVectorMaterialInput Tangent_DEPRECATED;
 
    UPROPERTY()
    FColorMaterialInput EmissiveColor_DEPRECATED;
 
    UPROPERTY()
    FScalarMaterialInput Opacity_DEPRECATED;
 
    UPROPERTY()
    FScalarMaterialInput OpacityMask_DEPRECATED;
 
    UPROPERTY()
    FVectorMaterialInput WorldPositionOffset_DEPRECATED;
 
    UPROPERTY()
    FColorMaterialInput SubsurfaceColor_DEPRECATED;
 
    UPROPERTY()
    FScalarMaterialInput ClearCoat_DEPRECATED;
 
    UPROPERTY()
    FScalarMaterialInput ClearCoatRoughness_DEPRECATED;
 
    UPROPERTY()
    FScalarMaterialInput AmbientOcclusion_DEPRECATED;
 
    UPROPERTY()
    FScalarMaterialInput Refraction_DEPRECATED;
 
    UPROPERTY()
    FVector2MaterialInput CustomizedUVs_DEPRECATED[8];
 
    UPROPERTY()
    FMaterialAttributesInput MaterialAttributes_DEPRECATED;
 
    UPROPERTY()
    FScalarMaterialInput PixelDepthOffset_DEPRECATED;
 
    UPROPERTY()
    FShadingModelMaterialInput ShadingModelFromMaterialExpression_DEPRECATED;
 
    UPROPERTY()
    FSubstrateMaterialInput FrontMaterial_DEPRECATED;
#endif // WITH_EDITORONLY_DATA
};