void FSceneViewport::OnDrawViewport( const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled )
{
// Switch to the viewport clients world before resizing
FScopedConditionalWorldSwitcher WorldSwitcher( ViewportClient );
/** Check to see if the viewport should be resized */
FIntPoint DrawSize = FIntPoint( FMath::RoundToInt( AllottedGeometry.GetDrawSize().X ), FMath::RoundToInt( AllottedGeometry.GetDrawSize().Y ) );
if( GetSizeXY() != DrawSize )
{
TSharedPtr<SWindow> Window = FSlateApplication::Get().FindWidgetWindow( ViewportWidget.Pin().ToSharedRef() );
check(Window.IsValid());
ResizeViewport(FMath::Max(0, DrawSize.X), FMath::Max(0, DrawSize.Y), Window->GetWindowMode(), 0, 0);
}
// Cannot pass negative canvas positions
float CanvasMinX = FMath::Max(0.0f, AllottedGeometry.AbsolutePosition.X);
float CanvasMinY = FMath::Max(0.0f, AllottedGeometry.AbsolutePosition.Y);
FIntRect CanvasRect(
FMath::RoundToInt( CanvasMinX ),
FMath::RoundToInt( CanvasMinY ),
FMath::RoundToInt( CanvasMinX + AllottedGeometry.Size.X * AllottedGeometry.Scale ),
FMath::RoundToInt( CanvasMinY + AllottedGeometry.Size.Y * AllottedGeometry.Scale ) );
DebugCanvasDrawer->BeginRenderingCanvas( CanvasRect );
// Draw above everything else
uint32 MaxLayer = MAX_uint32;
FSlateDrawElement::MakeCustom( OutDrawElements, MAX_uint32, DebugCanvasDrawer );
}
void clViewport::AfterConstruction()
{
#ifdef OS_WINDOWS
DWORD dwVersion = 0;
DWORD dwMajorVersion = 0;
dwVersion = GetVersion();
// Get the Windows version.
dwMajorVersion = ( DWORD )( LOBYTE( LOWORD( dwVersion ) ) );
if ( dwMajorVersion > 5 )
{
/// Anything below WinXP without SP3 does not support High DPI, so we do not enable it on WinXP at all.
SetHighDPIAware();
}
StoreAndDisableStickyKeys();
if ( FTakeoverContext )
{
ResizeViewport( 0, 0 );
}
else
#endif
{
#ifdef OS_WINDOWS
if ( FRegisterWindowClass )
{
RegisterWindowClass();
}
if ( FExternalWindowHandle )
{
RECT Rect;
GetWindowRect( FExternalWindowHandle, &Rect );
FWidth = Rect.right - Rect.left;
FHeight = Rect.bottom - Rect.top;
}
#endif
RecreateViewport();
}
ReinitializeViewport();
FMouseX = Env->Console->GetVar( "Viewport.MouseX" );
FMouseY = Env->Console->GetVar( "Viewport.MouseY" );
Env->Connect( L_EVENT_SURFACE_CHANGED, BIND( &clViewport::Event_SURFACE_CHANGED ) );
}
void FSceneViewport::SetViewportSize(uint32 NewViewportSizeX, uint32 NewViewportSizeY)
{
TSharedPtr<SWindow> Window = FSlateApplication::Get().FindWidgetWindow(ViewportWidget.Pin().ToSharedRef());
if (Window.IsValid())
{
Window->SetIndependentViewportSize(FVector2D(NewViewportSizeX, NewViewportSizeY));
const FVector2D vp = (Window->GetWindowMode() == EWindowMode::WindowedMirror) ? Window->GetSizeInScreen() : Window->GetViewportSize();
FSlateApplicationBase::Get().GetRenderer()->UpdateFullscreenState(Window.ToSharedRef(), vp.X, vp.Y);
ResizeViewport(NewViewportSizeX, NewViewportSizeY, Window->GetWindowMode(), 0, 0);
}
}
void clViewport::SetViewportSize( int W, int H )
{
#if defined OS_WINDOWS
SetWindowPos( FWindowHandle, NULL, 0, 0, W, H, 0 );
#elif defined OS_ANDROID
TODO( "implement" )
#elif defined OS_LINUX
XResizeWindow( FDisplay, *FWindowHandle, W, H );
#endif
ResizeViewport( W, H );
}
// return true if everything went fine
// return false if the execution should be stopped
bool clViewport::DispatchEvents()
{
/// OS-specific loop ///
#ifdef OS_WINDOWS
MSG AMessage;
while ( PeekMessage( &AMessage, 0, 0, 0, PM_NOREMOVE ) )
{
if ( !GetMessage( &AMessage, 0, 0, 0 ) )
{
return false;
}
TranslateMessage( &AMessage );
DispatchMessage( &AMessage );
}
#endif
#if defined(OS_LINUX) && !defined(OS_ANDROID)
KeySym Key;
XEvent Event;
while ( XPending( FDisplay ) )
{
XNextEvent( FDisplay, &Event );
switch ( Event.type )
{
case KeyPress:
XLookupString( ( XKeyEvent* )&Event, NULL, 0, &Key, NULL );
break;
case ConfigureNotify:
ResizeViewport( Event.xconfigure.width, Event.xconfigure.height );
break;
}
}
TODO( "implement" )
#endif
return true;
}
//
// If in fullscreen mode, end it and return to Windows.
//
void UXViewport::EndFullscreen()
{
guard(UXViewport::EndFullscreen);
UXClient* Client = GetOuterUXClient();
debugf(NAME_Log, TEXT("Ending fullscreen mode by request."));
if( RenDev && RenDev->FullscreenOnly )
{
// This device doesn't support fullscreen, so use a window-capable rendering device.
TryRenderDevice( TEXT("ini:Engine.Engine.WindowedRenderDevice"), INDEX_NONE, INDEX_NONE, ColorBytes, 0 );
check(RenDev);
}
else if( RenDev && (BlitFlags & BLIT_OpenGL) )
{
RenDev->SetRes( INDEX_NONE, INDEX_NONE, ColorBytes, 0 );
}
else
{
ResizeViewport( BLIT_DibSection );
}
UpdateWindowFrame();
unguard;
}
clViewport::clViewport( const LString& WindowClassName,
LWindowHandle ViewportHandle,
const LString& Title,
int Width,
int Height,
bool Fullscreen,
bool RegWindowClass,
bool DisplayWindow,
bool TakeoverContext )
: FWindowHandle( 0 ),
FWindowClassName( WindowClassName ),
FTitle( Title ),
FWidth( Width ),
FHeight( Height ),
FTop( 0 ),
FLeft( 0 ),
FFullscreen( Fullscreen ),
FRegisterWindowClass( RegWindowClass ),
FDisplayWindow( DisplayWindow ),
FTakeoverContext( TakeoverContext )
{
FWindowClassName = LString( ENGINE_NAME ) + " " + LString( ENGINE_VERSION );
#ifdef OS_WINDOWS
FExternalWindowHandle = ViewportHandle;
if ( FTakeoverContext )
{
FWindowHandle = ViewportHandle;
}
#endif
#if defined( OS_ANDROID ) && !defined( ANDROID9 )
ResizeViewport( sEnvironment::FAndroidViewportSize.FWidth, sEnvironment::FAndroidViewportSize.FHeight );
#endif
}
void FSceneViewport::ResizeFrame(uint32 NewSizeX, uint32 NewSizeY, EWindowMode::Type NewWindowMode, int32 InPosX, int32 InPosY)
{
// Resizing the window directly is only supported in the game
if( FApp::IsGame() && NewSizeX > 0 && NewSizeY > 0 )
{
FWidgetPath WidgetPath;
TSharedPtr<SWindow> WindowToResize = FSlateApplication::Get().FindWidgetWindow( ViewportWidget.Pin().ToSharedRef(), WidgetPath );
if( WindowToResize.IsValid() )
{
int32 CVarValue = GetBoundFullScreenModeCVar();
EWindowMode::Type DesiredWindowMode = GetWindowModeType(NewWindowMode);
// Avoid resizing if nothing changes.
bool bNeedsResize = SizeX != NewSizeX || SizeY != NewSizeY || NewWindowMode != DesiredWindowMode || DesiredWindowMode != WindowToResize->GetWindowMode();
if (bNeedsResize)
{
if (GEngine->HMDDevice.IsValid() && GEngine->HMDDevice->IsHMDEnabled())
{
// Resize & move only if moving to a fullscreen mode
if (NewWindowMode != EWindowMode::Windowed)
{
FSlateRect PreFullScreenRect = WindowToResize->GetRectInScreen();
IHeadMountedDisplay::MonitorInfo MonitorInfo;
if (GEngine->HMDDevice->GetHMDMonitorInfo(MonitorInfo))
{
NewSizeX = MonitorInfo.ResolutionX;
NewSizeY = MonitorInfo.ResolutionY;
if (GEngine->HMDDevice->IsFullScreenAllowed())
{
WindowToResize->ReshapeWindow(FVector2D(MonitorInfo.DesktopX, MonitorInfo.DesktopY), FVector2D(MonitorInfo.ResolutionX, MonitorInfo.ResolutionY));
}
else
{
WindowToResize->Resize(FVector2D(MonitorInfo.ResolutionX, MonitorInfo.ResolutionY));
DesiredWindowMode = EWindowMode::WindowedMirror;
}
}
GEngine->HMDDevice->PushPreFullScreenRect(PreFullScreenRect);
}
}
// Toggle fullscreen and resize
WindowToResize->SetWindowMode(DesiredWindowMode);
if (GEngine->HMDDevice.IsValid() && GEngine->HMDDevice->IsHMDEnabled())
{
if (NewWindowMode == EWindowMode::Windowed)
{
FSlateRect PreFullScreenRect;
GEngine->HMDDevice->PopPreFullScreenRect(PreFullScreenRect);
if (PreFullScreenRect.GetSize().X > 0 && PreFullScreenRect.GetSize().Y > 0 && GEngine->HMDDevice->IsFullScreenAllowed())
{
NewSizeX = PreFullScreenRect.GetSize().X;
NewSizeY = PreFullScreenRect.GetSize().Y;
WindowToResize->MoveWindowTo (FVector2D(PreFullScreenRect.Left, PreFullScreenRect.Top));
}
}
if (NewWindowMode != WindowMode)
{
// Only notify the HMD if we've actually changed modes
GEngine->HMDDevice->OnScreenModeChange(NewWindowMode);
}
}
LockMouseToViewport(!CurrentReplyState.ShouldReleaseMouseLock());
int32 NewWindowSizeX = NewSizeX;
int32 NewWindowSizeY = NewSizeY;
WindowToResize->Resize( FVector2D(NewWindowSizeX, NewWindowSizeY) );
ResizeViewport(NewWindowSizeX, NewWindowSizeY, NewWindowMode, InPosX, InPosY);
}
UCanvas::UpdateAllCanvasSafeZoneData();
}
}
}
void FSceneViewport::ResizeFrame(uint32 NewSizeX, uint32 NewSizeY, EWindowMode::Type NewWindowMode, int32 InPosX, int32 InPosY)
{
// Resizing the window directly is only supported in the game
if( FApp::IsGame() && NewSizeX > 0 && NewSizeY > 0 )
{
FWidgetPath WidgetPath;
TSharedPtr<SWindow> WindowToResize = FSlateApplication::Get().FindWidgetWindow( ViewportWidget.Pin().ToSharedRef(), WidgetPath );
if( WindowToResize.IsValid() )
{
EWindowMode::Type DesiredWindowMode = GetWindowModeType(NewWindowMode);
// If we're going into windowed fullscreen mode, we always want the window to fill the entire screen.
// When we calculate the scene view, we'll check the fullscreen mode and configure the screen percentage
// scaling so we actual render to the resolution we've been asked for.
if (DesiredWindowMode == EWindowMode::WindowedFullscreen)
{
FDisplayMetrics DisplayMetrics;
FSlateApplication::Get().GetInitialDisplayMetrics(DisplayMetrics);
NewSizeX = DisplayMetrics.PrimaryDisplayWidth;;
NewSizeY = DisplayMetrics.PrimaryDisplayHeight;;
}
uint32 ViewportSizeX = NewSizeX;
uint32 ViewportSizeY = NewSizeY;
if (GEngine->HMDDevice.IsValid() && GEngine->HMDDevice->IsHMDConnected())
{
WindowToResize->SetViewportSizeDrivenByWindow(true);
// Resize & move only if moving to a fullscreen mode
if (NewWindowMode != EWindowMode::Windowed)
{
IHeadMountedDisplay::MonitorInfo MonitorInfo;
if (GEngine->HMDDevice->GetHMDMonitorInfo(MonitorInfo))
{
ViewportSizeX = MonitorInfo.ResolutionX;
ViewportSizeY = MonitorInfo.ResolutionY;
if (GEngine->HMDDevice->IsFullscreenAllowed())
{
NewSizeX = MonitorInfo.ResolutionX;
NewSizeY = MonitorInfo.ResolutionY;
}
else
{
if (MonitorInfo.WindowSizeX != 0 && MonitorInfo.WindowSizeY != 0)
{
NewSizeX = MonitorInfo.WindowSizeX;
NewSizeY = MonitorInfo.WindowSizeY;
}
NewWindowMode = DesiredWindowMode = EWindowMode::WindowedMirror;
WindowToResize->SetIndependentViewportSize(FVector2D(ViewportSizeX, ViewportSizeY));
}
}
}
}
// Avoid resizing if nothing changes.
bool bNeedsResize = SizeX != ViewportSizeX || SizeY != ViewportSizeY || NewWindowMode != DesiredWindowMode || DesiredWindowMode != WindowToResize->GetWindowMode();
if (bNeedsResize)
{
if (GEngine->HMDDevice.IsValid() && GEngine->HMDDevice->IsHMDConnected())
{
// Resize & move only if moving to a fullscreen mode
if (NewWindowMode != EWindowMode::Windowed)
{
FSlateRect PreFullScreenRect = WindowToResize->GetRectInScreen();
IHeadMountedDisplay::MonitorInfo MonitorInfo;
if (GEngine->HMDDevice->GetHMDMonitorInfo(MonitorInfo))
{
if (GEngine->HMDDevice->IsFullscreenAllowed())
{
WindowToResize->ReshapeWindow(FVector2D(MonitorInfo.DesktopX, MonitorInfo.DesktopY), FVector2D(MonitorInfo.ResolutionX, MonitorInfo.ResolutionY));
}
}
GEngine->HMDDevice->PushPreFullScreenRect(PreFullScreenRect);
}
}
// Toggle fullscreen and resize
WindowToResize->SetWindowMode(DesiredWindowMode);
if (GEngine->HMDDevice.IsValid() && GEngine->HMDDevice->IsHMDEnabled())
{
if (NewWindowMode == EWindowMode::Windowed)
{
FSlateRect PreFullScreenRect;
GEngine->HMDDevice->PopPreFullScreenRect(PreFullScreenRect);
if (PreFullScreenRect.GetSize().X > 0 && PreFullScreenRect.GetSize().Y > 0 && GEngine->HMDDevice->IsFullscreenAllowed())
{
NewSizeX = PreFullScreenRect.GetSize().X;
NewSizeY = PreFullScreenRect.GetSize().Y;
WindowToResize->MoveWindowTo(FVector2D(PreFullScreenRect.Left, PreFullScreenRect.Top));
}
ViewportSizeX = NewSizeX;
ViewportSizeY = NewSizeY;
WindowToResize->SetViewportSizeDrivenByWindow(true);
}
if (NewWindowMode != WindowMode)
{
// Only notify the HMD if we've actually changed modes
GEngine->HMDDevice->OnScreenModeChange(NewWindowMode);
}
}
LockMouseToViewport(!CurrentReplyState.ShouldReleaseMouseLock());
WindowToResize->Resize(FVector2D(NewSizeX, NewSizeY));
ResizeViewport(ViewportSizeX, ViewportSizeY, NewWindowMode, InPosX, InPosY);
}
UCanvas::UpdateAllCanvasSafeZoneData();
}
}
}
unsigned int Renderer::Run()
{
unsigned int err = CS_ERR_NONE;
#ifndef PLATFORM_WINDOWS
Engine* engine = System::GetInstance()->GetEngineData();
if (engine->display == NULL || engine->context == NULL || engine->surface == NULL)
{
// No display.
return CS_ERR_UNKNOWN;
}
#endif
if (m_resizeNeeded)
{
ResizeViewport();
m_resizeNeeded = false;
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Drawing models with basic shader
if (m_mode == BASIC)
{
m_shaderID = m_basicShader;
glUseProgram(m_shaderID->id);
}
else if (m_mode == WIREFRAME) // Drawing wireframe
{
m_shaderID = m_wireframeShader;
glUseProgram(m_shaderID->id);
}
else if (m_mode == BASIC_WIREFRAME) // Drawing wireframe with fill (no specular)
{
m_shaderID = m_basicWireframeShader;
glUseProgram(m_shaderID->id);
}
System::GetInstance()->GetCurrentScene()->DrawObjects();
// Drawing GUI
m_shaderID = m_fontShader;
glUseProgram(m_shaderID->id);
System::GetInstance()->GetCurrentScene()->DrawGUI();
#ifdef PLATFORM_WINDOWS
glfwSwapBuffers(m_window);
glfwPollEvents();
#else
EGLBoolean res = eglSwapBuffers(engine->display, engine->surface);
if (res != EGL_TRUE)
{
LOGW("eglSwapBuffers error occured! Shutting down.");
System::GetInstance()->Stop();
}
#endif // PLATFORM_WINDOWS
return err;
}
void clViewport::EVENT_HANDLER( Event_SURFACE_CHANGED )
{
#if defined( OS_ANDROID )
ResizeViewport( sEnvironment::FAndroidViewportSize.FWidth, sEnvironment::FAndroidViewportSize.FHeight );
#endif
}
