Skip to content

Commit

Permalink
WinRT: made rendering work with orientation changes on Windows Phone
Browse files Browse the repository at this point in the history 
Pointer event geometry still needs to be adjusted on Windows Phone, to note.
  • Loading branch information
@DavidLudwig
DavidLudwig committed Aug 28, 2013
1 parent 91b0390 commit 31235b4
Show file tree
Hide file tree
Showing 3 changed files with 117 additions and 34 deletions.
105 changes: 79 additions & 26 deletions src/core/winrt/SDL_winrtapp.cpp
View file
Expand Up @@ -145,6 +145,77 @@ static void WINRT_SetDisplayOrientationsPreference(void *userdata, const char *n
DisplayProperties::AutoRotationPreferences = (DisplayOrientations) orientationFlags;
}

static void
WINRT_ProcessWindowSizeChange()
{
// Make the new window size be the one true fullscreen mode.
// This change was initially done, in part, to allow the Direct3D 11.1
// renderer to receive window-resize events as a device rotates.
// Before, rotating a device from landscape, to portrait, and then
// back to landscape would cause the Direct3D 11.1 swap buffer to
// not get resized appropriately. SDL would, on the rotation from
// landscape to portrait, re-resize the SDL window to it's initial
// size (landscape). On the subsequent rotation, SDL would drop the
// window-resize event as it appeared the SDL window didn't change
// size, and the Direct3D 11.1 renderer wouldn't resize its swap
// chain.
SDL_DisplayMode resizedDisplayMode = WINRT_CalcDisplayModeUsingNativeWindow();
if (resizedDisplayMode.w == 0 || resizedDisplayMode.h == 0) {
return;
}

SDL_DisplayMode oldDisplayMode;
SDL_zero(oldDisplayMode);
if (WINRT_GlobalSDLVideoDevice) {
oldDisplayMode = WINRT_GlobalSDLVideoDevice->displays[0].desktop_mode;
WINRT_GlobalSDLVideoDevice->displays[0].current_mode = resizedDisplayMode;
WINRT_GlobalSDLVideoDevice->displays[0].desktop_mode = resizedDisplayMode;
WINRT_GlobalSDLVideoDevice->displays[0].display_modes[0] = resizedDisplayMode;
}

if (WINRT_GlobalSDLWindow) {
// Send a window-resize event to the rest of SDL, and to apps:
SDL_SendWindowEvent(
WINRT_GlobalSDLWindow,
SDL_WINDOWEVENT_RESIZED,
resizedDisplayMode.w,
resizedDisplayMode.h);

#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
// HACK: On Windows Phone, make sure that orientation changes from
// Landscape to LandscapeFlipped, Portrait to PortraitFlipped,
// or vice-versa on either of those two, lead to the Direct3D renderer
// getting updated.
const DisplayOrientations oldOrientation = (DisplayOrientations) (unsigned int) oldDisplayMode.driverdata;
const DisplayOrientations newOrientation = (DisplayOrientations) (unsigned int) resizedDisplayMode.driverdata;

if ((oldOrientation == DisplayOrientations::Landscape && newOrientation == DisplayOrientations::LandscapeFlipped) ||
(oldOrientation == DisplayOrientations::LandscapeFlipped && newOrientation == DisplayOrientations::Landscape) ||
(oldOrientation == DisplayOrientations::Portrait && newOrientation == DisplayOrientations::PortraitFlipped) ||
(oldOrientation == DisplayOrientations::PortraitFlipped && newOrientation == DisplayOrientations::Portrait))
{
// One of the reasons this event is getting sent out is because SDL
// will ignore requests to send out SDL_WINDOWEVENT_RESIZED events
// if and when the event size doesn't change (and the Direct3D 11.1
// renderer doesn't get the memo).
//
// Make sure that the display/window size really didn't change. If
// it did, then a SDL_WINDOWEVENT_SIZE_CHANGED event got sent, and
// the Direct3D 11.1 renderer picked it up, presumably.
if (oldDisplayMode.w == resizedDisplayMode.w &&
oldDisplayMode.h == resizedDisplayMode.h)
{
SDL_SendWindowEvent(
WINRT_GlobalSDLWindow,
SDL_WINDOWEVENT_SIZE_CHANGED,
resizedDisplayMode.w,
resizedDisplayMode.h);
}
}
#endif
}
}

SDL_WinRTApp::SDL_WinRTApp() :
m_windowClosed(false),
m_windowVisible(true)
Expand Down Expand Up @@ -194,6 +265,13 @@ void SDL_WinRTApp::OnOrientationChanged(Object^ sender)
(int)DisplayProperties::AutoRotationPreferences);
}
#endif

#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
// On Windows Phone, treat an orientation change as a change in window size.
// The native window's size doesn't seem to change, however SDL will simulate
// a window size change.
WINRT_ProcessWindowSizeChange();
#endif
}

void SDL_WinRTApp::SetWindow(CoreWindow^ window)
Expand Down Expand Up @@ -294,32 +372,7 @@ void SDL_WinRTApp::OnWindowSizeChanged(CoreWindow^ sender, WindowSizeChangedEven
(WINRT_GlobalSDLWindow ? "yes" : "no"));
#endif

if (WINRT_GlobalSDLWindow) {
// Make the new window size be the one true fullscreen mode.
// This change was initially done, in part, to allow the Direct3D 11.1
// renderer to receive window-resize events as a device rotates.
// Before, rotating a device from landscape, to portrait, and then
// back to landscape would cause the Direct3D 11.1 swap buffer to
// not get resized appropriately. SDL would, on the rotation from
// landscape to portrait, re-resize the SDL window to it's initial
// size (landscape). On the subsequent rotation, SDL would drop the
// window-resize event as it appeared the SDL window didn't change
// size, and the Direct3D 11.1 renderer wouldn't resize its swap
// chain.
SDL_DisplayMode resizedDisplayMode = WINRT_CalcDisplayModeUsingNativeWindow();
WINRT_GlobalSDLVideoDevice->displays[0].current_mode = resizedDisplayMode;
WINRT_GlobalSDLVideoDevice->displays[0].desktop_mode = resizedDisplayMode;
WINRT_GlobalSDLVideoDevice->displays[0].display_modes[0] = resizedDisplayMode;

// Send the window-resize event to the rest of SDL, and to apps:
const int windowWidth = (int) ceil(args->Size.Width);
const int windowHeight = (int) ceil(args->Size.Height);
SDL_SendWindowEvent(
WINRT_GlobalSDLWindow,
SDL_WINDOWEVENT_RESIZED,
windowWidth,
windowHeight);
}
WINRT_ProcessWindowSizeChange();
}

void SDL_WinRTApp::OnVisibilityChanged(CoreWindow^ sender, VisibilityChangedEventArgs^ args)
Expand Down
18 changes: 11 additions & 7 deletions src/render/direct3d11/SDL_render_d3d11.cpp
View file
Expand Up @@ -920,7 +920,7 @@ D3D11_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
{
//D3D11_RenderData *data = (D3D11_RenderData *) renderer->driverdata;

if (event->event == SDL_WINDOWEVENT_RESIZED) {
if (event->event == SDL_WINDOWEVENT_SIZE_CHANGED) {
D3D11_UpdateForWindowSizeChange(renderer);
}
}
Expand Down Expand Up @@ -1215,16 +1215,16 @@ D3D11_UpdateViewport(SDL_Renderer * renderer)
// Windows Phone rotations
//
case DisplayOrientations::Landscape:
// 90-degree Z-rotation
XMStoreFloat4x4(&data->vertexShaderConstantsData.projection, XMMatrixRotationZ(XM_PIDIV2));
// 270-degree (-90 degree) Z-rotation
XMStoreFloat4x4(&data->vertexShaderConstantsData.projection, XMMatrixRotationZ(-XM_PIDIV2));
break;
case DisplayOrientations::Portrait:
// 0-degree Z-rotation
XMStoreFloat4x4(&data->vertexShaderConstantsData.projection, XMMatrixIdentity());
break;
case DisplayOrientations::LandscapeFlipped:
// 270-degree (-90 degree) Z-rotation
XMStoreFloat4x4(&data->vertexShaderConstantsData.projection, XMMatrixRotationZ(-XM_PIDIV2));
// 90-degree Z-rotation
XMStoreFloat4x4(&data->vertexShaderConstantsData.projection, XMMatrixRotationZ(XM_PIDIV2));
break;
case DisplayOrientations::PortraitFlipped:
// 180-degree Z-rotation
Expand Down Expand Up @@ -1280,11 +1280,15 @@ D3D11_UpdateViewport(SDL_Renderer * renderer)

//
// Update the Direct3D viewport, which seems to be aligned to the
// swap buffer's coordinate space, which is always in landscape:
// swap buffer's coordinate space, which is always in either
// a landscape mode, for all Windows 8/RT devices, or a portrait mode,
// for Windows Phone devices.
//
SDL_FRect orientationAlignedViewport;
#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
const bool swapDimensions = false;
const bool swapDimensions =
data->orientation == DisplayOrientations::Landscape ||
data->orientation == DisplayOrientations::LandscapeFlipped;
#else
const bool swapDimensions =
data->orientation == DisplayOrientations::Portrait ||
Expand Down
28 changes: 27 additions & 1 deletion src/video/winrt/SDL_winrtvideo.cpp
View file
Expand Up @@ -154,6 +154,8 @@ WINRT_VideoInit(_THIS)
SDL_DisplayMode
WINRT_CalcDisplayModeUsingNativeWindow()
{
using namespace Windows::Graphics::Display;

// Create an empty, zeroed-out display mode:
SDL_DisplayMode mode;
SDL_zero(mode);
Expand All @@ -168,7 +170,7 @@ WINRT_CalcDisplayModeUsingNativeWindow()
// Fill in most fields:
mode.format = SDL_PIXELFORMAT_RGB888;
mode.refresh_rate = 0; // TODO, WinRT: see if refresh rate data is available, or relevant (for WinRT apps)
mode.driverdata = NULL;
mode.driverdata = (void *) DisplayProperties::CurrentOrientation;

// Calculate the display size given the window size, taking into account
// the current display's DPI:
Expand All @@ -177,6 +179,30 @@ WINRT_CalcDisplayModeUsingNativeWindow()
mode.w = (int) ((CoreWindow::GetForCurrentThread()->Bounds.Width * currentDPI) / dipsPerInch);
mode.h = (int) ((CoreWindow::GetForCurrentThread()->Bounds.Height * currentDPI) / dipsPerInch);

#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
// On Windows Phone, the native window's size is always in portrait,
// regardless of the device's orientation. This is in contrast to
// Windows 8/RT, which will resize the native window as the device's
// orientation changes. In order to compensate for this behavior,
// on Windows Phone, the mode's width and height will be swapped when
// the device is in a landscape (non-portrait) mode.
switch (DisplayProperties::CurrentOrientation) {
case DisplayOrientations::Landscape:
case DisplayOrientations::LandscapeFlipped:
{
const int tmp = mode.h;
mode.h = mode.w;
mode.w = tmp;
break;
}

default:
break;
}

// Attach the mode to te
#endif

return mode;
}

Expand Down

0 comments on commit 31235b4

Please sign in to comment.