mirrors/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-04-20 19:45:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

rsx/qt: GsFrame improvements

Browse source 
- Identify minimize/restore events as separate from regular resize and do not react to them
- Enable message queue consumption after loading the shaders cache. Also hides the frame in this step
-- This fixes the 'start fullscreen' bug when running vulkan
This commit is contained in:
kd-11 2017-10-28 15:34:24 +03:00
parent 1ffc1e82b0
commit ce2b790d8f
5 changed files with 115 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
rpcs3/Emu/RSX/GL/GLGSRender.cpp
View file

@ -631,6 +631,9 @@ void GLGSRender::on_init_thread()
{
GSRender::on_init_thread();
m_frame->disable_wm_event_queue();
m_frame->hide();
gl::init();
//Enable adaptive vsync if vsync is requested
@ -771,6 +774,9 @@ void GLGSRender::on_init_thread()
m_thread_id = std::this_thread::get_id();
m_shaders_cache->load();
m_frame->enable_wm_event_queue();
m_frame->show();
}
void GLGSRender::on_exit()

16
rpcs3/Emu/RSX/GSRender.h
View file

@ -24,7 +24,10 @@ enum wm_event
geometry_change_notice, //about to start resizing and/or moving the window
geometry_change_in_progress, //window being resized and/or moved
window_resized, //window was resized
window_moved //window moved without resize
window_minimized, //window was minimized
window_restored, //window was restored from a minimized state
window_moved, //window moved without resize
window_visibility_changed
};
using RSXDebuggerPrograms = std::vector<RSXDebuggerProgram>;
@ -58,6 +61,7 @@ protected:
//window manager event management
wm_event m_raised_event;
std::atomic_bool wm_event_raised = {};
std::atomic_bool wm_event_queue_enabled = {};
public:
//synchronize native window access
@ -83,6 +87,16 @@ public:
return get_default_wm_event();
}
void disable_wm_event_queue()
{
wm_event_queue_enabled.store(false);
}
void enable_wm_event_queue()
{
wm_event_queue_enabled.store(true);
}
};
class GSRender : public rsx::thread

15
rpcs3/Emu/RSX/VK/VKGSRender.cpp
View file

@ -1332,7 +1332,13 @@ void VKGSRender::on_init_thread()
GSRender::on_init_thread();
rsx_thread = std::this_thread::get_id();
m_frame->disable_wm_event_queue();
m_frame->hide();
m_shaders_cache->load(*m_device, pipeline_layout);
m_frame->enable_wm_event_queue();
m_frame->show();
}
void VKGSRender::on_exit()
@ -1747,12 +1753,15 @@ void VKGSRender::do_local_task()
handled = true;
present_surface_dirty_flag = true;
break;
case wm_event::window_moved:
handled = true;
break;
case wm_event::geometry_change_in_progress:
timeout += 10; //extend timeout to wait for user to finish resizing
break;
case wm_event::window_visibility_changed:
case wm_event::window_minimized:
case wm_event::window_restored:
case wm_event::window_moved:
handled = true; //ignore these events as they do not alter client area
break;
}
if (handled)

140
rpcs3/rpcs3qt/gs_frame.cpp
View file

@ -246,77 +246,99 @@ bool gs_frame::event(QEvent* ev)
bool gs_frame::nativeEvent(const QByteArray &eventType, void *message, long *result)
{
#ifdef _WIN32
//Wait for consumer to clear notification pending flag
while (wm_event_raised.load(std::memory_order_consume));
if (wm_event_queue_enabled.load(std::memory_order_consume))
{
std::lock_guard<std::mutex> lock(wm_event_lock);
MSG* msg = static_cast<MSG*>(message);
switch (msg->message)
{
case WM_WINDOWPOSCHANGING:
{
const auto flags = reinterpret_cast<LPWINDOWPOS>(msg->lParam)->flags & SWP_NOSIZE;
if (m_in_sizing_event || flags != 0)
break;
//Wait for consumer to clear notification pending flag
while (wm_event_raised.load(std::memory_order_consume));
//About to resize
m_in_sizing_event = true;
m_interactive_resize = false;
m_raised_event = wm_event::geometry_change_notice;
wm_event_raised.store(true);
break;
}
case WM_WINDOWPOSCHANGED:
{
const auto flags = reinterpret_cast<LPWINDOWPOS>(msg->lParam)->flags & (SWP_NOSIZE | SWP_NOMOVE);
if (!m_in_sizing_event || m_user_interaction_active || flags == (SWP_NOSIZE | SWP_NOMOVE))
break;
if (flags & SWP_NOSIZE)
m_raised_event = wm_event::window_moved;
else
m_raised_event = wm_event::window_resized;
//Just finished resizing using maximize or SWP
m_in_sizing_event = false;
wm_event_raised.store(true);
break;
}
case WM_ENTERSIZEMOVE:
m_user_interaction_active = true;
break;
case WM_EXITSIZEMOVE:
m_user_interaction_active = false;
if (m_in_sizing_event && !m_user_interaction_active)
std::lock_guard<std::mutex> lock(wm_event_lock);
MSG* msg = static_cast<MSG*>(message);
switch (msg->message)
{
//Just finished resizing using manual interaction. The corresponding WM_SIZE is consumed before this event fires
m_raised_event = m_interactive_resize ? wm_event::window_resized : wm_event::window_moved;
case WM_WINDOWPOSCHANGING:
{
const auto flags = reinterpret_cast<LPWINDOWPOS>(msg->lParam)->flags & SWP_NOSIZE;
if (m_in_sizing_event || flags != 0)
break;
//About to resize
m_in_sizing_event = true;
m_interactive_resize = false;
m_raised_event = wm_event::geometry_change_notice;
wm_event_raised.store(true);
break;
}
case WM_WINDOWPOSCHANGED:
{
const auto flags = reinterpret_cast<LPWINDOWPOS>(msg->lParam)->flags & (SWP_NOSIZE | SWP_NOMOVE);
if (!m_in_sizing_event || m_user_interaction_active || flags == (SWP_NOSIZE | SWP_NOMOVE))
break;
if (flags & SWP_NOSIZE)
{
m_raised_event = wm_event::window_moved;
}
else
{
LPWINDOWPOS wpos = reinterpret_cast<LPWINDOWPOS>(msg->lParam);
if (wpos->cx <= GetSystemMetrics(SM_CXMINIMIZED) || wpos->cy <= GetSystemMetrics(SM_CYMINIMIZED))
{
//Minimize event
m_minimized = true;
m_raised_event = wm_event::window_minimized;
}
else if (m_minimized)
{
m_minimized = false;
m_raised_event = wm_event::window_restored;
}
else
{
m_raised_event = wm_event::window_resized;
}
}
//Just finished resizing using maximize or SWP
m_in_sizing_event = false;
wm_event_raised.store(true);
break;
}
break;
case WM_SIZE:
{
if (m_user_interaction_active)
case WM_ENTERSIZEMOVE:
m_user_interaction_active = true;
break;
case WM_EXITSIZEMOVE:
m_user_interaction_active = false;
if (m_in_sizing_event && !m_user_interaction_active)
{
//Just finished resizing using manual interaction. The corresponding WM_SIZE is consumed before this event fires
m_raised_event = m_interactive_resize ? wm_event::window_resized : wm_event::window_moved;
m_in_sizing_event = false;
wm_event_raised.store(true);
}
break;
case WM_SIZE:
{
//Interaction is a resize not a move
m_interactive_resize = true;
if (m_user_interaction_active)
{
//Interaction is a resize not a move
m_interactive_resize = true;
}
else if (m_in_sizing_event)
{
//Any other unexpected resize mode will give an unconsumed WM_SIZE event
m_raised_event = wm_event::window_resized;
m_in_sizing_event = false;
wm_event_raised.store(true);
}
break;
}
else if (m_in_sizing_event)
{
//Any other unexpected resize mode will give an unconsumed WM_SIZE event
m_raised_event = wm_event::window_resized;
m_in_sizing_event = false;
wm_event_raised.store(true);
}
break;
}
}
//Do not enter DefWndProc until the consumer has consumed the message
while (wm_event_raised.load(std::memory_order_consume));
}
//Do not enter DefWndProc until the consumer has consumed the message
while (wm_event_raised.load(std::memory_order_consume));
#endif
//Let the default handler deal with this. Only the notification is required

1
rpcs3/rpcs3qt/gs_frame.h
View file

@ -17,6 +17,7 @@ class gs_frame : public QWindow, public GSFrameBase
bool m_in_sizing_event = false; //a signal that the window is about to be resized was received
bool m_user_interaction_active = false; //a signal indicating the window is being manually moved/resized was received
bool m_interactive_resize = false; //resize signal received while dragging window
bool m_minimized = false;
public:
gs_frame(const QString& title, int w, int h, QIcon appIcon, bool disableMouse);