SlateRenderer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Textures/SlateShaderResource.h"
#include "Textures/SlateTextureData.h"
#include "Brushes/SlateDynamicImageBrush.h"
#include "Rendering/DrawElements.h"
#include "Templates/RefCounting.h"
#include "Fonts/FontTypes.h"
#include "Types/SlateVector2.h"
#include "PixelFormat.h"
 
class FRHITexture;
class FRenderTarget;
class FRDGBuilder;
class FRDGTexture;
class FSlateDrawBuffer;
class FSlateUpdatableTexture;
class ISlate3DRenderer;
class ISlateAtlasProvider;
class ISlateStyle;
class SWindow;
struct Rect;
class FSceneInterface;
struct FSlateBrush;
 
typedef TRefCountPtr<FRHITexture> FTextureRHIRef;
 
struct FRenderThreadUpdateContext
{
    class FSlateDrawBuffer* WindowDrawBuffer;
    double WorldTimeSeconds;
    float DeltaTimeSeconds;
    double RealTimeSeconds;
    float DeltaRealTimeSeconds;
    FRenderTarget* RenderTarget;
    ISlate3DRenderer* Renderer;
    bool bClearTarget;
};
 
class FSlateFontServices
{
public:
    SLATECORE_API FSlateFontServices(TSharedRef<class FSlateFontCache> InGameThreadFontCache, TSharedRef<class FSlateFontCache> InRenderThreadFontCache);
 
    SLATECORE_API ~FSlateFontServices();
 
    SLATECORE_API TSharedRef<class FSlateFontCache> GetFontCache() const;
 
    TSharedRef<class FSlateFontCache> GetGameThreadFontCache() const
    {
        return GameThreadFontCache;
    }
 
    TSharedRef<class FSlateFontCache> GetRenderThreadFontCache() const
    {
        return RenderThreadFontCache;
    }
 
    SLATECORE_API TSharedRef<class FSlateFontMeasure> GetFontMeasureService() const;
 
    TSharedRef<class FSlateFontMeasure> GetGameThreadFontMeasureService() const 
    {
        return GameThreadFontMeasure;
    }
 
    TSharedRef<class FSlateFontMeasure> GetRenderThreadFontMeasureService() const 
    {
        return RenderThreadFontMeasure;
    }
 
    SLATECORE_API void FlushFontCache(const FString& FlushReason);
 
    SLATECORE_API void FlushGameThreadFontCache(const FString& FlushReason);
 
    SLATECORE_API void FlushRenderThreadFontCache(const FString& FlushReason);
 
    SLATECORE_API void ReleaseResources();
 
    SLATECORE_API FOnReleaseFontResources& OnReleaseResources();
 
private:
    SLATECORE_API void HandleFontCacheReleaseResources(const class FSlateFontCache& InFontCache);
 
    TSharedRef<class FSlateFontCache> GameThreadFontCache;
    TSharedRef<class FSlateFontCache> RenderThreadFontCache;
 
    TSharedRef<class FSlateFontMeasure> GameThreadFontMeasure;
    TSharedRef<class FSlateFontMeasure> RenderThreadFontMeasure;
 
    FOnReleaseFontResources OnReleaseResourcesDelegate;
};
 
 
struct FMappedTextureBuffer
{
    void* Data;
    int32 Width;
    int32 Height;
 
    FMappedTextureBuffer()
        : Data(nullptr)
        , Width(0)
        , Height(0)
    {
    }
 
    bool IsValid() const
    {
        return Data && Width > 0 && Height > 0;
    }
 
    void Reset()
    {
        Data = nullptr;
        Width = Height = 0;
    }
};
 
 
class FSlateRenderer
{
public:
 
    SLATECORE_API explicit FSlateRenderer(const TSharedRef<FSlateFontServices>& InSlateFontServices);
 
    SLATECORE_API virtual ~FSlateRenderer();
 
public:
    struct FScopedAcquireDrawBuffer
    {
        FScopedAcquireDrawBuffer(FSlateRenderer& InSlateRenderer)
            : SlateRenderer(InSlateRenderer)
            , DrawBuffer(InSlateRenderer.AcquireDrawBuffer())
        {
        }
        ~FScopedAcquireDrawBuffer()
        {
            SlateRenderer.ReleaseDrawBuffer(DrawBuffer);
        }
        FScopedAcquireDrawBuffer(const FScopedAcquireDrawBuffer&) = delete;
        FScopedAcquireDrawBuffer& operator=(const FScopedAcquireDrawBuffer&) = delete;
 
        FSlateDrawBuffer& GetDrawBuffer()
        {
            return DrawBuffer;
        }
 
    private:
        FSlateRenderer& SlateRenderer;
        FSlateDrawBuffer& DrawBuffer;
    };
 
public:
    UE_DEPRECATED(5.1, "Use FSlateRenderer::AcquireDrawBuffer instead and release the draw buffer.")
    virtual FSlateDrawBuffer& GetDrawBuffer()
    {
        return AcquireDrawBuffer();
    }
 
    virtual FSlateDrawBuffer& AcquireDrawBuffer() = 0;
 
    virtual void ReleaseDrawBuffer( FSlateDrawBuffer& InWindowDrawBuffer ) = 0;
 
    virtual bool Initialize() = 0;
 
    virtual void Destroy() = 0;
 
    virtual void CreateViewport( const TSharedRef<SWindow> InWindow ) = 0;
 
    virtual void RequestResize( const TSharedPtr<SWindow>& InWindow, uint32 NewSizeX, uint32 NewSizeY ) = 0;
 
    virtual void UpdateFullscreenState( const TSharedRef<SWindow> InWindow, uint32 OverrideResX = 0, uint32 OverrideResY = 0 ) = 0;
 
 
    virtual void SetSystemResolution(uint32 Width, uint32 Height) = 0;
    
    
    virtual void RestoreSystemResolution(const TSharedRef<SWindow> InWindow) = 0;
 
    virtual void DrawWindows( FSlateDrawBuffer& InWindowDrawBuffer ) = 0;
    
    DECLARE_MULTICAST_DELEGATE_TwoParams( FOnSlateWindowRendered, SWindow&, void* );
    FOnSlateWindowRendered& OnSlateWindowRendered() { return SlateWindowRendered; }
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnSlateWindowDestroyed, void*);
    FOnSlateWindowDestroyed& OnSlateWindowDestroyed() { return OnSlateWindowDestroyedDelegate; }
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnPreResizeWindowBackbuffer, void*);
    FOnPreResizeWindowBackbuffer& OnPreResizeWindowBackBuffer() { return PreResizeBackBufferDelegate; }
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnPostResizeWindowBackbuffer, void*);
    FOnPostResizeWindowBackbuffer& OnPostResizeWindowBackBuffer() { return PostResizeBackBufferDelegate; }
 
    DECLARE_TS_MULTICAST_DELEGATE_TwoParams(FOnBackBufferReadyToPresent, SWindow&, const FTextureRHIRef&);
    FOnBackBufferReadyToPresent& OnBackBufferReadyToPresent() { return OnBackBufferReadyToPresentDelegate; }
 
    DECLARE_TS_MULTICAST_DELEGATE_ThreeParams(FOnAddBackBufferReadyToPresentPass, FRDGBuilder&, SWindow&, FRDGTexture*);
    FOnAddBackBufferReadyToPresentPass& OnAddBackBufferReadyToPresentPass() { return OnAddBackBufferReadyToPresentPassDelegate; }
 
    virtual void SetColorVisionDeficiencyType(EColorVisionDeficiency Type, int32 Severity, bool bCorrectDeficiency, bool bShowCorrectionWithDeficiency) { }
 
    virtual FIntPoint GenerateDynamicImageResource(const FName InTextureName) {check(0); return FIntPoint( 0, 0 );}
 
    virtual bool GenerateDynamicImageResource( FName ResourceName, uint32 Width, uint32 Height, const TArray< uint8 >& Bytes ) { return false; }
 
    virtual bool GenerateDynamicImageResource(FName ResourceName, FSlateTextureDataRef TextureData) { return false; }
 
    virtual FSlateResourceHandle GetResourceHandle(const FSlateBrush& Brush, FVector2f LocalSize, float DrawScale) = 0;
 
    virtual FSlateResourceHandle GetResourceHandle(const FSlateBrush& Brush)
    {
        return GetResourceHandle(Brush, FVector2f::ZeroVector, 1.0f);
    }
 
 
    virtual bool CanRenderResource(UObject& InResourceObject) const { return true; }
 
    virtual void RemoveDynamicBrushResource( TSharedPtr<FSlateDynamicImageBrush> BrushToRemove ) = 0;
 
    virtual void ReleaseDynamicResource( const FSlateBrush& Brush ) = 0;
 
 
    virtual void OnWindowDestroyed( const TSharedRef<SWindow>& InWindow ) = 0;
    
    virtual void OnWindowFinishReshaped(const TSharedPtr<SWindow>& InWindow) {};
 
    virtual void* GetViewportResource( const SWindow& Window ) { return nullptr; }
    
    TSharedRef<FSlateFontServices> GetFontServices() const 
    {
        return SlateFontServices.ToSharedRef();
    }
 
    TSharedRef<class FSlateFontMeasure> GetFontMeasureService() const 
    {
        return SlateFontServices->GetFontMeasureService();
    }
 
    TSharedRef<class FSlateFontCache> GetFontCache() const
    {
        return SlateFontServices->GetFontCache();
    }
 
    void FlushFontCache(const FString& FlushReason)
    {
        SlateFontServices->FlushFontCache(FlushReason);
    }
 
    virtual void FlushCommands() const {};
 
    virtual void Sync() const {};
    
    virtual void BeginFrame() const {};
    
    virtual void EndFrame() const {};
 
    virtual void ReloadTextureResources() {}
 
    virtual void LoadStyleResources( const ISlateStyle& Style ) {}
 
    SLATECORE_API bool IsViewportFullscreen( const SWindow& Window ) const;
 
    virtual bool AreShadersInitialized() const { return true; }
 
    virtual void InvalidateAllViewports() {}
 
    virtual void ReleaseAccessedResources(bool bImmediatelyFlush) {}
 
    virtual void PrepareToTakeScreenshot(const FIntRect& Rect, TArray<FColor>* OutColorData, SWindow* InScreenshotWindow) {}
 
    virtual void PrepareToTakeHDRScreenshot(const FIntRect& Rect, TArray<FLinearColor>* OutColorData, SWindow* InScreenshotWindow) {}
 
    UE_DEPRECATED(5.5, "SetWindowRenderTarget is no longer used.")
    virtual void SetWindowRenderTarget(const SWindow& Window, class IViewportRenderTargetProvider* Provider) {}
 
    virtual FSlateUpdatableTexture* CreateUpdatableTexture(uint32 Width, uint32 Height) = 0;
 
    virtual FSlateUpdatableTexture* CreateSharedHandleTexture(void *SharedHandle) = 0;
 
    virtual void ReleaseUpdatableTexture(FSlateUpdatableTexture* Texture) = 0;
 
    SLATECORE_API virtual ISlateAtlasProvider* GetTextureAtlasProvider();
 
    SLATECORE_API virtual ISlateAtlasProvider* GetFontAtlasProvider();
 
    virtual void CopyWindowsToVirtualScreenBuffer(const TArray<FString>& KeypressBuffer) {}
    
    virtual void MapVirtualScreenBuffer(FMappedTextureBuffer* OutImageData) {}
    virtual void UnmapVirtualScreenBuffer() {}
 
    virtual FCriticalSection* GetResourceCriticalSection() = 0;
 
    virtual int32 RegisterCurrentScene(FSceneInterface* Scene) = 0;
 
    virtual int32 GetCurrentSceneIndex() const  = 0;
 
    virtual void SetCurrentSceneIndex(int32 InIndex) = 0;
 
    virtual void ClearScenes() = 0;
 
    SLATECORE_API virtual void DestroyCachedFastPathRenderingData(struct FSlateCachedFastPathRenderingData* VertexData);
    SLATECORE_API virtual void DestroyCachedFastPathElementData(struct FSlateCachedElementData* ElementData);
 
    virtual bool HasLostDevice() const { return false; }
 
    virtual void AddWidgetRendererUpdate(const struct FRenderThreadUpdateContext& Context, bool bDeferredRenderTargetUpdate) {}
 
    virtual EPixelFormat GetSlateRecommendedColorFormat() { return PF_B8G8R8A8; }
 
    virtual void OnVirtualDesktopSizeChanged(const FDisplayMetrics& NewDisplayMetric) {}
private:
 
    // Non-copyable
    SLATECORE_API FSlateRenderer(const FSlateRenderer&);
    SLATECORE_API FSlateRenderer& operator=(const FSlateRenderer&);
 
    SLATECORE_API void HandleFontCacheReleaseResources(const class FSlateFontCache& InFontCache);
 
protected:
 
    TSharedPtr<FSlateFontServices> SlateFontServices;
 
    FOnSlateWindowRendered SlateWindowRendered;
 
    FOnSlateWindowDestroyed OnSlateWindowDestroyedDelegate;
    FOnPreResizeWindowBackbuffer PreResizeBackBufferDelegate;
    FOnPostResizeWindowBackbuffer PostResizeBackBufferDelegate;
 
    FOnBackBufferReadyToPresent OnBackBufferReadyToPresentDelegate;
    FOnAddBackBufferReadyToPresentPass OnAddBackBufferReadyToPresentPassDelegate;
 
    FCriticalSection ResourceCriticalSection;
 
    friend class FSlateRenderDataHandle;
};
 
 
bool SLATECORE_API IsThreadSafeForSlateRendering();
 
bool SLATECORE_API DoesThreadOwnSlateRendering();