ODSCManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Containers/Ticker.h"
#include "RHIDefinitions.h"
#include "Containers/Ticker.h"
#include "ShaderCompiler.h"
 
class FODSCThread;
class UMaterialInstance;
class FMaterialShaderMap;
class FMaterialShaderMapId;
class FPrimitiveSceneInfo;
 
class FODSCManager
    : public FTSTickerObjectBase
{
public:
 
    // FODSCManager
 
    ENGINE_API FODSCManager();
 
    ENGINE_API virtual ~FODSCManager();
 
    // FTSTickerObjectBase
 
    ENGINE_API bool Tick(float DeltaSeconds) override;
 
    ENGINE_API void AddThreadedRequest(
        const TArray<FString>& MaterialsToCompile,
        const FString& ShaderTypesToLoad,
        EShaderPlatform ShaderPlatform,
        ERHIFeatureLevel::Type FeatureLevel,
        EMaterialQualityLevel::Type QualityLevel,
        ODSCRecompileCommand RecompileCommandType,
        const FString& RequestedMaterialName = FString(),
        const FShaderCompilerFlags& ExtraCompilerFlags = FShaderCompilerFlags()
    );
 
    ENGINE_API void AddThreadedShaderPipelineRequest(
        EShaderPlatform ShaderPlatform,
        ERHIFeatureLevel::Type FeatureLevel,
        EMaterialQualityLevel::Type QualityLevel,
        const FMaterial* Material,
        const FString& VertexFactoryName,
        const FString& PipelineName,
        const TArray<FString>& ShaderTypeNames,
        int32 PermutationId,
        const TArray<FShaderId>& RequestShaderIds
    );
 
    UE_DEPRECATED(5.5, "RequestShaderIds is needed for AddThreadedShaderPipelineRequest and need to match the ones from FMaterialShaderMap::GetShaderList")
    void AddThreadedShaderPipelineRequest(
        EShaderPlatform ShaderPlatform,
        ERHIFeatureLevel::Type FeatureLevel,
        EMaterialQualityLevel::Type QualityLevel,
        const FString& MaterialName,
        const FString& VertexFactoryName,
        const FString& PipelineName,
        const TArray<FString>& ShaderTypeNames,
        int32 PermutationId
    ) {}
 
    inline bool IsHandlingRequests() const { return Thread != nullptr; }
 
    static void RegisterMaterialInstance(const UMaterialInstance* MI);
    static void UnregisterMaterialInstance(const UMaterialInstance* MI);
 
    static ENGINE_API bool IsODSCEnabled();
 
    static inline bool IsODSCActive();
    static inline bool ShouldForceRecompile(const FMaterialShaderMap* MaterialShaderMap, const FMaterial* Material);
 
    static void SuspendODSCForceRecompile();
    static void ResumeODSCForceRecompile();
    void TryLoadGlobalShaders(EShaderPlatform ShaderPlatform);
 
    static void ReportODSCError(const FString& InErrorMessage);
    static bool UseDefaultMaterialOnRecompile();
 
    bool CheckIfRequestAlreadySent(const TArray<FShaderId>& RequestShaderIds, const FMaterial* Material) const;
 
    static void UnregisterMaterialName(const FMaterial* Material);
    static void RegisterMaterialShaderMaps(const FString& MaterialName, const TArray<TRefCountPtr<FMaterialShaderMap>>& LoadedShaderMaps);
    static FMaterialShaderMap* FindMaterialShaderMap(const FString& MaterialName, const FMaterialShaderMapId& ShaderMapId);
    ENGINE_API static void SetCurrentPrimitiveSceneInfo(FPrimitiveSceneInfo* PrimitiveSceneInfo);
    ENGINE_API static void ResetCurrentPrimitiveSceneInfo();
 
private:
    friend class FODSCManagerAccess;
 
    ENGINE_API void OnEnginePreExit();
    ENGINE_API void StopThread();
 
    bool HasAsyncLoadingInstances();
    bool ShouldForceRecompileInternal(const FMaterialShaderMap* MaterialShaderMap, const FMaterial* Material);
 
    void RetrieveErrorMessage(FString& OutErrorMessage);
    void ClearErrorMessage();
 
    FODSCThread* Thread = nullptr;
 
    FDelegateHandle OnScreenMessagesHandle;
    FCriticalSection MaterialInstancesCachedUniformExpressionsCS;
    TMap<const void*, TWeakObjectPtr<const UMaterialInstance> > MaterialInstancesCachedUniformExpressions;
 
    FCriticalSection ErrorMessageCS;
    FString ErrorMessage;
 
    FName MaterialNameToRecompile;
};
 
struct FODSCPrimitiveSceneInfoScope
{
    FODSCPrimitiveSceneInfoScope(FPrimitiveSceneInfo* PrimitiveSceneInfo)
    {
        FODSCManager::SetCurrentPrimitiveSceneInfo(PrimitiveSceneInfo);
    }
 
    ~FODSCPrimitiveSceneInfoScope()
    {
        FODSCManager::ResetCurrentPrimitiveSceneInfo();
    }
};
 
struct FODSCSuspendForceRecompileScope
{
    FODSCSuspendForceRecompileScope()
    {
        FODSCManager::SuspendODSCForceRecompile();
    }
 
    ~FODSCSuspendForceRecompileScope()
    {
        FODSCManager::ResumeODSCForceRecompile();
    }
};
 
extern ENGINE_API FODSCManager* GODSCManager;
 
inline bool FODSCManager::IsODSCActive()
{
    return GODSCManager && GODSCManager->IsHandlingRequests();
}
 
inline bool FODSCManager::ShouldForceRecompile(const FMaterialShaderMap* MaterialShaderMap, const FMaterial* Material)
{
    return FODSCManager::IsODSCActive() && GODSCManager->ShouldForceRecompileInternal(MaterialShaderMap, Material);
}