MaterialRenderProxy.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Math/Color.h"
#include "Math/Vector2D.h"
#include "RenderResource.h"
#include "RHIImmutableSamplerState.h"
#include "Async/Mutex.h"
#include "Tasks/Task.h"
#include "Engine/BlendableInterface.h"
 
enum class EMaterialParameterType : uint8;
 
class FMaterial;
class FMaterialRenderProxy;
class FMaterialShaderMap;
class FMaterialVirtualTextureStack;
class FRHIComputeCommandList;
class FUniformExpressionCacheAsyncUpdater;
class FUniformExpressionSet;
class IAllocatedVirtualTexture;
class UMaterialInterface;
class URuntimeVirtualTexture;
class USparseVolumeTexture;
class USubsurfaceProfile;
class USpecularProfile;
class UNeuralProfile;
class UTexture;
class UTextureCollection;
class UMaterialParameterCollection;
 
struct FMaterialParameterValue;
struct FMaterialRenderContext;
 
struct FMemoryImageMaterialParameterInfo;
using FHashedMaterialParameterInfo = FMemoryImageMaterialParameterInfo;
 
namespace UE::Shader
{
    struct FValue;
}
 
struct FUniformExpressionCache
{
    FUniformBufferRHIRef UniformBuffer;
    TArray<IAllocatedVirtualTexture*> AllocatedVTs;
    TArray<IAllocatedVirtualTexture*> OwnedAllocatedVTs;
    TArray<FGuid> ParameterCollections;
    const FMaterialShaderMap* CachedUniformExpressionShaderMap = nullptr;
 
    ENGINE_API ~FUniformExpressionCache();
 
    void ResetAllocatedVTs();
};
 
struct FUniformExpressionCacheContainer
{
    inline FUniformExpressionCache& operator[](int32 Index)
    {
#if WITH_EDITOR
        return Elements[Index];
#else
        return Elements;
#endif
    }
private:
#if WITH_EDITOR
    FUniformExpressionCache Elements[ERHIFeatureLevel::Num];
#else
    FUniformExpressionCache Elements;
#endif
};
 
class FUniformExpressionCacheAsyncUpdateScope
{
public:
    ENGINE_API FUniformExpressionCacheAsyncUpdateScope();
    ENGINE_API ~FUniformExpressionCacheAsyncUpdateScope();
 
    static ENGINE_API void WaitForTask();
};
 
class FMaterialRenderProxy : public FRenderResource, public FNoncopyable
{
public:
 
    mutable FUniformExpressionCacheContainer UniformExpressionCache;
 
    mutable FImmutableSamplerState ImmutableSamplerState;
 
    ENGINE_API FMaterialRenderProxy(FString InMaterialName);
 
    ENGINE_API virtual ~FMaterialRenderProxy();
 
    ENGINE_API void EvaluateUniformExpressions(FRHICommandListBase& RHICmdList, FUniformExpressionCache& OutUniformExpressionCache, const FMaterialRenderContext& Context, FUniformExpressionCacheAsyncUpdater* Updater = nullptr) const;
 
    ENGINE_API void CacheUniformExpressions(FRHICommandListBase& RHICmdList, bool bRecreateUniformBuffer);
 
    ENGINE_API void CancelCacheUniformExpressions();
 
    ENGINE_API void CacheUniformExpressions_GameThread(bool bRecreateUniformBuffer);
 
    ENGINE_API void InvalidateUniformExpressionCache(bool bRecreateUniformBuffer);
 
    ENGINE_API void UpdateUniformExpressionCacheIfNeeded(ERHIFeatureLevel::Type InFeatureLevel) const;
    ENGINE_API const FMaterial* UpdateUniformExpressionCacheIfNeeded(FRHICommandListBase& RHICmdList, ERHIFeatureLevel::Type InFeatureLevel) const;
 
    virtual const FMaterial* GetMaterialNoFallback(ERHIFeatureLevel::Type InFeatureLevel) const = 0;
    virtual const FMaterialRenderProxy* GetFallback(ERHIFeatureLevel::Type InFeatureLevel) const = 0;
 
    // These functions should only be called by the rendering thread.
 
    ENGINE_API const FMaterial& GetMaterialWithFallback(ERHIFeatureLevel::Type InFeatureLevel, const FMaterialRenderProxy*& OutFallbackMaterialRenderProxy) const;
 
    ENGINE_API const FMaterial& GetIncompleteMaterialWithFallback(ERHIFeatureLevel::Type InFeatureLevel) const;
 
    virtual UMaterialInterface* GetMaterialInterface() const { return NULL; }
 
    ENGINE_API bool GetVectorValue(const FHashedMaterialParameterInfo& ParameterInfo, FLinearColor* OutValue, const FMaterialRenderContext& Context) const;
    ENGINE_API bool GetScalarValue(const FHashedMaterialParameterInfo& ParameterInfo, float* OutValue, const FMaterialRenderContext& Context) const;
    ENGINE_API bool GetTextureValue(const FHashedMaterialParameterInfo& ParameterInfo, const UTexture** OutValue, const FMaterialRenderContext& Context) const;
    ENGINE_API bool GetTextureValue(const FHashedMaterialParameterInfo& ParameterInfo, const URuntimeVirtualTexture** OutValue, const FMaterialRenderContext& Context) const;
    ENGINE_API bool GetTextureValue(const FHashedMaterialParameterInfo& ParameterInfo, const USparseVolumeTexture** OutValue, const FMaterialRenderContext& Context) const;
    ENGINE_API bool GetTextureCollectionValue(const FHashedMaterialParameterInfo& ParameterInfo, const UTextureCollection** OutValue, const FMaterialRenderContext& Context) const;
    ENGINE_API bool GetParameterCollectionValue(const FHashedMaterialParameterInfo& ParameterInfo, const UMaterialParameterCollection** OutValue, const FMaterialRenderContext& Context) const;
    ENGINE_API bool GetParameterShaderValue(EMaterialParameterType Type, const FHashedMaterialParameterInfo& ParameterInfo, UE::Shader::FValue& OutValue, const FMaterialRenderContext& Context) const;
    virtual bool GetParameterValue(EMaterialParameterType Type, const FHashedMaterialParameterInfo& ParameterInfo, FMaterialParameterValue& OutValue, const FMaterialRenderContext& Context) const = 0;
    virtual bool GetUserSceneTextureOverride(FName& InOutValue) const { return false; }
    ENGINE_API FName GetUserSceneTextureOutput(const FMaterial* Base) const;
    ENGINE_API virtual EBlendableLocation GetBlendableLocation(const FMaterial* Base) const;
    ENGINE_API virtual int32 GetBlendablePriority(const FMaterial* Base) const;
 
 
    bool IsDeleted() const
    {
        return DeletedFlag != 0;
    }
 
    void MarkForGarbageCollection()
    {
        MarkedForGarbageCollection = -1;
    }
 
    bool IsMarkedForGarbageCollection() const
    {
        return MarkedForGarbageCollection != 0;
    }
 
    void MarkTransient()
    {
        bMarkedTransient = 1;
    }
 
    // FRenderResource interface.
    ENGINE_API virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
    ENGINE_API virtual void ReleaseRHI() override;
    ENGINE_API virtual void ReleaseResource() override;
 
#if WITH_EDITOR
    static const TSet<FMaterialRenderProxy*>& GetMaterialRenderProxyMap()
    {
        check(!FPlatformProperties::RequiresCookedData());
        return MaterialRenderProxyMap;
    }
 
    static FCriticalSection& GetMaterialRenderProxyMapLock()
    {
        return MaterialRenderProxyMapLock;
    }
#endif
 
    // Subsurface profile
    // When Substrate is enabled, this is ONLY used as an override for Subsurface Profile on material instance (override all Subsurface Profiles at once for now)
    void SetSubsurfaceProfileRT(const USubsurfaceProfile* Ptr) { SubsurfaceProfileRT = Ptr; }
    const USubsurfaceProfile* GetSubsurfaceProfileRT() const { return SubsurfaceProfileRT; }
 
    // Subsurface profiles
    void ClearSubsurfaceProfileRT() { SubsurfaceProfilesRT.Empty(); }
    void AddSubsurfaceProfileRT(const USubsurfaceProfile* Ptr) { SubsurfaceProfilesRT.Add(Ptr); }
    const USubsurfaceProfile* GetSubsurfaceProfileRT(uint32 Index) const { check(Index<uint32(SubsurfaceProfilesRT.Num())); return SubsurfaceProfilesRT[Index]; }
    const uint32 NumSubsurfaceProfileRT() const { return SubsurfaceProfilesRT.Num(); }
 
    // Specular profiles
    void AddSpecularProfileRT(const USpecularProfile* Ptr) { SpecularProfilesRT.Add(Ptr); }
    const USpecularProfile* GetSpecularProfileRT(uint32 Index) const { check(Index<uint32(SpecularProfilesRT.Num())); return SpecularProfilesRT[Index]; }
    const uint32 NumSpecularProfileRT() const { return SpecularProfilesRT.Num(); }
    // Specular profiles override
    void SetSpecularProfileOverrideRT(const USpecularProfile* Ptr) { SpecularProfileOverrideRT = Ptr; }
    const USpecularProfile* GetSpecularProfileOverrideRT() const { return SpecularProfileOverrideRT; }
 
    // Neural profiles
    void SetNeuralProfileRT(const UNeuralProfile* Ptr) { NeuralProfileRT = Ptr; }
    const UNeuralProfile* GetNeuralProfileRT() const { return NeuralProfileRT; }
 
    static ENGINE_API void UpdateDeferredCachedUniformExpressions();
    static ENGINE_API void UpdateDeferredCachedUniformExpressions(FRHICommandListBase& RHICmdList, UE::Tasks::FTask* TaskIfAsync = nullptr);
 
    static ENGINE_API bool HasDeferredUniformExpressionCacheRequests();
 
    int32 GetExpressionCacheSerialNumber() const { return UniformExpressionCacheSerialNumber; }
 
    const FString& GetMaterialName() const { return MaterialName; }
 
protected:
    ENGINE_API virtual void EvaluateParameterCollections(FRHICommandListBase& RHICmdList, FUniformExpressionCache& OutUniformExpressionCache, const FMaterialRenderContext& Context, FUniformExpressionCacheAsyncUpdater* Updater) const;
 
private:
    ENGINE_API IAllocatedVirtualTexture* GetPreallocatedVTStack(const FMaterialRenderContext& Context, const FUniformExpressionSet& UniformExpressionSet, const FMaterialVirtualTextureStack& VTStack) const;
    ENGINE_API IAllocatedVirtualTexture* AllocateVTStack(FRHICommandListBase& RHICmdList, const FMaterialRenderContext& Context, const FUniformExpressionSet& UniformExpressionSet, const FMaterialVirtualTextureStack& VTStack) const;
 
    virtual void StartCacheUniformExpressions() const {}
    virtual void FinishCacheUniformExpressions() const {}
 
    const USubsurfaceProfile* SubsurfaceProfileRT;  // Overrides all SubsurfaceProfilesRT when set, used when set from material instance to respect the legacy workflow
    TArray<const USubsurfaceProfile*> SubsurfaceProfilesRT;
    TArray<const USpecularProfile*> SpecularProfilesRT;
    const USpecularProfile* SpecularProfileOverrideRT = nullptr;
    const UNeuralProfile* NeuralProfileRT;
    FString MaterialName;
 
    mutable int32 UniformExpressionCacheSerialNumber = 0;
 
    mutable uint8 MarkedForGarbageCollection : 1;
    mutable uint8 DeletedFlag : 1;
    mutable uint8 ReleaseResourceFlag : 1;
    uint8 bMarkedTransient : 1;
    mutable uint8 bHasVirtualTextureCallbacks : 1;
    mutable uint8 bHasMaterialCacheCallbacks : 1;
 
    mutable UE::FMutex Mutex;
 
#if WITH_EDITOR
    static ENGINE_API TSet<FMaterialRenderProxy*> MaterialRenderProxyMap;
 
    static ENGINE_API FCriticalSection MaterialRenderProxyMapLock;
#endif
 
    static ENGINE_API TSet<FMaterialRenderProxy*> DeferredUniformExpressionCacheRequests;
    static ENGINE_API UE::FMutex DeferredUniformExpressionCacheRequestsMutex;
};
 
class FColoredMaterialRenderProxy : public FMaterialRenderProxy
{
public:
    const FMaterialRenderProxy* const Parent;
    const FLinearColor Color;
    FName ColorParamName;
 
    ENGINE_API FColoredMaterialRenderProxy(const FMaterialRenderProxy* InParent, const FLinearColor& InColor, FName InColorParamName = NAME_Color);
 
    // FMaterialRenderProxy interface.
    ENGINE_API virtual const FMaterial* GetMaterialNoFallback(ERHIFeatureLevel::Type InFeatureLevel) const override;
    ENGINE_API virtual const FMaterialRenderProxy* GetFallback(ERHIFeatureLevel::Type InFeatureLevel) const override;
    ENGINE_API virtual bool GetParameterValue(EMaterialParameterType Type, const FHashedMaterialParameterInfo& ParameterInfo, FMaterialParameterValue& OutValue, const FMaterialRenderContext& Context) const override;
};
 
class FColoredTexturedMaterialRenderProxy : public FColoredMaterialRenderProxy
{
public:
    const UTexture* Texture;
    FName TextureParamName;
    float UVChannel = 0;
    FName UVChannelParamName = FName("None");
 
    ENGINE_API FColoredTexturedMaterialRenderProxy(const FMaterialRenderProxy* InParent, const FLinearColor& InColor, FName InColorParamName, const UTexture* InTexture, FName InTextureParamName);
 
    ENGINE_API virtual bool GetParameterValue(EMaterialParameterType Type, const FHashedMaterialParameterInfo& ParameterInfo, FMaterialParameterValue& OutValue, const FMaterialRenderContext& Context) const override;
};
 
class FOverrideSelectionColorMaterialRenderProxy : public FMaterialRenderProxy
{
public:
    const FMaterialRenderProxy* const Parent;
    const FLinearColor SelectionColor;
 
    ENGINE_API FOverrideSelectionColorMaterialRenderProxy(const FMaterialRenderProxy* InParent, const FLinearColor& InSelectionColor);
 
    // FMaterialRenderProxy interface.
    ENGINE_API virtual const FMaterial* GetMaterialNoFallback(ERHIFeatureLevel::Type InFeatureLevel) const override;
    ENGINE_API virtual const FMaterialRenderProxy* GetFallback(ERHIFeatureLevel::Type InFeatureLevel) const override;
    ENGINE_API virtual bool GetParameterValue(EMaterialParameterType Type, const FHashedMaterialParameterInfo& ParameterInfo, FMaterialParameterValue& OutValue, const FMaterialRenderContext& Context) const override;
};
 
class FLightingDensityMaterialRenderProxy : public FColoredMaterialRenderProxy
{
public:
    const FVector2D LightmapResolution;
 
    ENGINE_API FLightingDensityMaterialRenderProxy(const FMaterialRenderProxy* InParent, const FLinearColor& InColor, const FVector2D& InLightmapResolution);
 
    // FMaterialRenderProxy interface.
    ENGINE_API virtual bool GetParameterValue(EMaterialParameterType Type, const FHashedMaterialParameterInfo& ParameterInfo, FMaterialParameterValue& OutValue, const FMaterialRenderContext& Context) const override;
};