UnrealWindow.cpp

Go to the documentation of this file.

// Copyright (c) 2023 FrostBit Software Lab at the Lapland University of Applied Sciences
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#include "UnrealWindow.h"
#include "Framework/Application/SlateApplication.h"
#include "Widgets/SWidget.h"
#include "Blueprint/UserWidget.h"
#include "Widgets/SOverlay.h"
 
FUnrealWindow::FUnrealWindow(int32 Width, int32 Height, FString WindowName, bool IsInitiallyMinized)
{
    // Set window width and height
    WindowWidth = Width;
    WindowHeight = Height;
 
    // Do not support Window minimize button,
    // because this causes Camera sensors to stop rendering when window is minimized.
    // This is default behavior in Unreal Engine.
    bool SupportMinimize = false;
 
#ifdef EngineAllowRenderingMinimized
    // Unless when we are using AGRARSENSE Unreal Engine fork,
    // where SWindow has extra boolean which allows rendering when a window is minimized.
    SupportMinimize = true;
#endif
 
    // Create SWindow
    sWindow = SNew(SWindow)
        .Title(FText::FromString(WindowName))
        .ScreenPosition(FVector2D(0, 0))
        .ClientSize(FVector2D(WindowWidth, WindowHeight))
        .AutoCenter(EAutoCenter::PreferredWorkArea)
        .UseOSWindowBorder(true)
        .SaneWindowPlacement(false)
        .SizingRule(ESizingRule::UserSized)
        .SupportsMinimize(SupportMinimize)
#if PLATFORM_LINUX
        .FocusWhenFirstShown(IsInitiallyMinized) // only for Linux, on Windows this causes Window to be wrong size for some reason
#endif
        .IsInitiallyMinimized(IsInitiallyMinized);
        
#ifdef EngineAllowRenderingMinimized
    // Set SWindow AllowRenderingMinimized to true that allows SWindow to be rendered even when minimized.
    // Defined and implemented in AGRARSENSE Unreal Engine fork
    sWindow->AllowRenderingMinimized = true;
#endif
 
    // Add window to FSlateApplication
    FSlateApplication::Get().AddWindow(sWindow.ToSharedRef());
 
    // Assign window events delegates
    onWindowClosedDelegate.BindRaw(this, &FUnrealWindow::OnWindowClosed);
    sWindow->SetOnWindowClosed(onWindowClosedDelegate);
 
    // Create and assign viewport to window
    Viewport = SNew(SUnrealWindowViewport);
    sWindow->SetContent(Viewport.ToSharedRef());
 
    // Set references
    ViewportClient = Viewport->ViewportClient;
    SceneViewport = Viewport->SceneViewport;
    sViewport = Viewport->Viewport;
 
    // Resize window
    ResizeWindow(WindowWidth, WindowHeight);
}
 
FUnrealWindow::~FUnrealWindow()
{
    onWindowClosedDelegate.Unbind();
 
    FullScreenOverlay.Reset();
    ViewportClient.Reset();
    SceneViewport.Reset();
    sViewport.Reset();
    Viewport.Reset();
    sWindow.Reset();
 
    AddedWidgets.Empty();
}
 
void FUnrealWindow::SetupComponent(UTextureRenderTarget2D* TextureRenderTarget)
{
    if (ViewportClient.IsValid() && TextureRenderTarget)
    {
        ViewportClient->TextRenderTarget2D = TextureRenderTarget;
        ViewportClient->texture = TextureRenderTarget->GetResource();
        ViewportClient->width = WindowWidth;
        ViewportClient->height = WindowHeight;
    }
}
 
void FUnrealWindow::UpdateTexture(FTextureResource* Texture)
{
    if (ViewportClient.IsValid() && Texture)
    {
        ViewportClient->texture = Texture;
        ViewportClient->width = WindowWidth;
        ViewportClient->height = WindowHeight;
    }
}
 
void FUnrealWindow::DrawManually()
{
    if (DrawToScreen)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("UnrealWindow.cpp: We are already drawing automatically, we should not draw manually!"));
#endif
        return;
    }
 
    if (SceneViewport.IsValid())
    {
        SceneViewport->Draw();
    }
}
 
void FUnrealWindow::OnWindowClosed(const TSharedRef<SWindow>& SWindow)
{
    DestroyWindow();
}
 
void FUnrealWindow::DestroyWindow()
{
    if (sWindow.IsValid())
    {
        sWindow->RequestDestroyWindow();
    }
}
 
void FUnrealWindow::ResizeWindow(int32 width, int32 height)
{
    if (ViewportClient.IsValid() && SceneViewport.IsValid() && sWindow.IsValid())
    {
        WindowWidth = width;
        WindowHeight = height;
 
        ViewportClient->width = WindowWidth;
        ViewportClient->height = WindowHeight;
 
        SceneViewport->SetViewportSize(WindowWidth, WindowHeight);
        sWindow->Resize(FVector2D(WindowWidth, WindowHeight));
    }
}
 
void FUnrealWindow::AddUWidgetToWindow(UWidget* WidgetToAdd)
{
    if (!WidgetToAdd || !sWindow.IsValid())
    {
        return;
    }
 
    if (!FullScreenOverlay.IsValid())
    {
        // Create a full-screen SOverlay to contain the camera image and custom widget
        FullScreenOverlay = SNew(SOverlay);
 
        // Create a slot for current viewport widget
        FullScreenOverlay->AddSlot(0)
            .HAlign(HAlign_Fill)
            .VAlign(VAlign_Fill)
            [
                Viewport.ToSharedRef()
            ];
    }
 
    ++AddedWidgetCount;
 
    // Create a slot for the new widget
    FullScreenOverlay->AddSlot(AddedWidgetCount)
        .HAlign(HAlign_Fill)
        .VAlign(VAlign_Fill)
        [
            WidgetToAdd->TakeWidget()
        ];
 
    // Store information about the added widget
    FAddedWidgetInfo WidgetInfo;
    WidgetInfo.Widget = WidgetToAdd;
    WidgetInfo.Index = AddedWidgetCount;
    AddedWidgets.Add(WidgetInfo);
 
    // Set the updated overlay as the window content
    sWindow->SetContent(FullScreenOverlay.ToSharedRef());
}
 
void FUnrealWindow::RemoveUWidgetFromWindow(UWidget* WidgetToRemove)
{
    if (!WidgetToRemove || !sWindow.IsValid() || !FullScreenOverlay.IsValid())
    {
        return;
    }
 
    // Not the prettiest but works for this use case.
    int32 WidgetIndexToRemove = -1;
    for (int32 Index = 0; Index < AddedWidgets.Num(); ++Index)
    {
        if (AddedWidgets[Index].Widget == WidgetToRemove)
        {
            WidgetIndexToRemove = Index;
            break;
        }
    }
 
    if (WidgetIndexToRemove != -1)
    {
        // Remove Widget from slot (arrays start at 0 but slot 0 is the camera view)
        FullScreenOverlay->RemoveSlot(WidgetIndexToRemove + 1);
 
        // Set the updated overlay as the window content
        sWindow->SetContent(FullScreenOverlay.ToSharedRef());
 
        // Remove the widget info from the array
        AddedWidgets.RemoveAt(WidgetIndexToRemove);
    }
}