This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_winrtvideo.cpp
286 lines (236 loc) · 8.9 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/*
Simple DirectMedia Layer
Copyright (C) 1997-2012 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_config.h"
#if SDL_VIDEO_DRIVER_WINRT
/* WinRT SDL video driver implementation
Initial work on this was done by David Ludwig (dludwig@pobox.com), and
was based off of SDL's "dummy" video driver.
*/
31
extern "C" {
32
33
34
35
36
#include "SDL_video.h"
#include "SDL_mouse.h"
#include "../SDL_sysvideo.h"
#include "../SDL_pixels_c.h"
#include "../../events/SDL_events_c.h"
37
#include "../../render/SDL_sysrender.h"
38
#include "SDL_syswm.h"
39
}
40
41
#include "SDL_WinRTApp.h"
42
43
44
#include "SDL_winrtvideo.h"
#include "SDL_winrtevents_c.h"
#include "SDL_winrtframebuffer_c.h"
45
#include "SDL_winrtmouse.h"
46
47
48
49
50
51
/* On Windows, windows.h defines CreateWindow */
#ifdef CreateWindow
#undef CreateWindow
#endif
52
53
extern SDL_WinRTApp ^ SDL_WinRTGlobalApp;
54
#define WINRTVID_DRIVER_NAME "winrt"
55
56
57
/* Initialization/Query functions */
static int WINRT_VideoInit(_THIS);
58
static int WINRT_InitModes(_THIS);
59
60
61
static int WINRT_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode);
static void WINRT_VideoQuit(_THIS);
62
63
64
/* Window functions */
static int WINRT_CreateWindow(_THIS, SDL_Window * window);
static void WINRT_DestroyWindow(_THIS, SDL_Window * window);
65
static SDL_bool WINRT_GetWindowWMInfo(_THIS, SDL_Window * window, SDL_SysWMinfo * info);
66
67
68
69
70
71
/* WinRT driver bootstrap functions */
static int
WINRT_Available(void)
{
72
return (1);
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
}
static void
WINRT_DeleteDevice(SDL_VideoDevice * device)
{
SDL_free(device);
}
static SDL_VideoDevice *
WINRT_CreateDevice(int devindex)
{
SDL_VideoDevice *device;
/* Initialize all variables that we clean on shutdown */
device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));
if (!device) {
SDL_OutOfMemory();
if (device) {
SDL_free(device);
}
return (0);
}
/* Set the function pointers */
device->VideoInit = WINRT_VideoInit;
device->VideoQuit = WINRT_VideoQuit;
99
100
device->CreateWindow = WINRT_CreateWindow;
device->DestroyWindow = WINRT_DestroyWindow;
101
102
103
104
105
device->SetDisplayMode = WINRT_SetDisplayMode;
device->PumpEvents = WINRT_PumpEvents;
device->CreateWindowFramebuffer = SDL_WINRT_CreateWindowFramebuffer;
device->UpdateWindowFramebuffer = SDL_WINRT_UpdateWindowFramebuffer;
device->DestroyWindowFramebuffer = SDL_WINRT_DestroyWindowFramebuffer;
106
device->GetWindowWMInfo = WINRT_GetWindowWMInfo;
107
108
109
110
111
112
113
114
115
116
117
118
119
device->free = WINRT_DeleteDevice;
return device;
}
VideoBootStrap WINRT_bootstrap = {
WINRTVID_DRIVER_NAME, "SDL Windows RT video driver",
WINRT_Available, WINRT_CreateDevice
};
int
WINRT_VideoInit(_THIS)
120
121
122
123
124
125
126
127
128
129
130
131
{
if (WINRT_InitModes(_this) < 0) {
return -1;
}
WINRT_InitMouse(_this);
return 0;
}
static int
WINRT_InitModes(_THIS)
132
{
133
134
135
SDL_DisplayMode mode = SDL_WinRTGlobalApp->GetMainDisplayMode();
if (SDL_AddBasicVideoDisplay(&mode) < 0) {
return -1;
136
137
138
}
SDL_AddDisplayMode(&_this->displays[0], &mode);
139
140
141
142
143
144
145
146
147
148
149
150
return 0;
}
static int
WINRT_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
{
return 0;
}
void
WINRT_VideoQuit(_THIS)
{
151
WINRT_QuitMouse(_this);
152
153
}
154
155
156
int
WINRT_CreateWindow(_THIS, SDL_Window * window)
{
157
158
159
160
161
162
163
// Make sure that only one window gets created, at least until multimonitor
// support is added.
if (SDL_WinRTGlobalApp->HasSDLWindowData())
{
SDL_SetError("WinRT only supports one window");
return -1;
}
164
165
SDL_WindowData *data = new SDL_WindowData;
166
167
168
169
170
if (!data) {
SDL_OutOfMemory();
return -1;
}
data->sdlWindow = window;
171
data->coreWindow = new CoreWindow^(CoreWindow::GetForCurrentThread());
172
173
174
175
/* Make sure the window is considered to be positioned at {0,0},
and is considered fullscreen, shown, and the like.
*/
176
177
window->x = 0;
window->y = 0;
178
179
180
181
182
183
window->flags =
SDL_WINDOW_FULLSCREEN |
SDL_WINDOW_SHOWN |
SDL_WINDOW_BORDERLESS |
SDL_WINDOW_MAXIMIZED |
SDL_WINDOW_INPUT_GRABBED;
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
/* HACK from DLudwig: The following line of code prevents
SDL_CreateWindow and SDL_UpdateFullscreenMode from trying to resize
the window after the call to WINRT_CreateWindow returns.
This hack should allow a window to be created in virtually any size,
and more importantly, it allows a window's framebuffer, as created and
retrieved via SDL_GetWindowSurface, to be in any size. This can be
utilized by apps centered around software rendering, such as ports
of older apps. The app can have SDL create a framebuffer in any size
it chooses. SDL will scale the framebuffer to the native
screen size on the GPU (via SDL_UpdateWindowSurface).
*/
_this->displays[0].fullscreen_window = window;
/* Further prevent any display resizing, and make sure SDL_GetWindowDisplayMode
can report the correct size of windows, by creating a new display
mode in the requested size. To note, if the window is being created in
the device's native screen size, SDL_AddDisplayMode will do nothing.
*/
window->fullscreen_mode = SDL_WinRTGlobalApp->GetMainDisplayMode();
window->fullscreen_mode.w = window->w;
window->fullscreen_mode.h = window->h;
SDL_AddDisplayMode(&_this->displays[0], &window->fullscreen_mode);
/* TODO: Consider removing custom display modes in WINRT_DestroyWindow. */
/* Make sure the WinRT app's IFramworkView can post events on
behalf of SDL:
*/
214
215
SDL_WinRTGlobalApp->SetSDLWindowData(data);
216
217
218
219
220
221
222
223
224
/* For now, create a Direct3D 11 renderer up-front. Eventually, this
won't be done in WINRT_CreateWindow, although it may get done in
SDL_WINRT_CreateWindowFramebuffer.
*/
// Link SDL_winrtrenderer to the SDL_Renderer temporarily,
// for refactoring purposes. Initialize the SDL_Renderer
// first in order to give it the opportunity to create key
// resources first.
225
226
//
// TODO, WinRT: either make WINRT_CreateWindow not call SDL_CreateRenderer, or have it do error checking if it does call it
227
228
229
230
231
// HACK: make sure the SDL window references SDL_WindowData data now, in
// order to allow the SDL_Renderer to be created in WINRT_CreateWindow
window->driverdata = data;
232
SDL_Renderer * renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE);
233
SDL_WinRTGlobalApp->m_renderer->m_sdlRenderer = renderer;
234
SDL_WinRTGlobalApp->m_renderer->m_sdlRendererData = (D3D11_RenderData *) renderer->driverdata;
235
SDL_WinRTGlobalApp->m_renderer->Initialize();
236
237
/* All done! */
238
239
240
241
242
243
return 0;
}
void
WINRT_DestroyWindow(_THIS, SDL_Window * window)
{
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
SDL_WindowData * data = (SDL_WindowData *) window->driverdata;
if (data) {
// Delete the reference to the WinRT CoreWindow:
CoreWindow ^* windowPointer = ((SDL_WindowData *) window->driverdata)->coreWindow;
if (windowPointer) {
*windowPointer = nullptr; // Clear the C++/CX reference to the CoreWindow
delete windowPointer; // Delete the C++/CX reference itself
}
// Delete the internal window data:
delete data;
data = NULL;
}
259
260
if (SDL_WinRTGlobalApp->HasSDLWindowData() &&
SDL_WinRTGlobalApp->GetSDLWindowData()->sdlWindow == window)
261
262
263
{
SDL_WinRTGlobalApp->SetSDLWindowData(NULL);
}
264
265
}
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
SDL_bool
WINRT_GetWindowWMInfo(_THIS, SDL_Window * window, SDL_SysWMinfo * info)
{
SDL_WindowData * data = (SDL_WindowData *) window->driverdata;
CoreWindow ^* windowPointer = data->coreWindow;
if (info->version.major <= SDL_MAJOR_VERSION) {
info->subsystem = SDL_SYSWM_WINDOWSRT;
info->info.winrt.window = windowPointer;
return SDL_TRUE;
} else {
SDL_SetError("Application not compiled with SDL %d.%d\n",
SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
return SDL_FALSE;
}
return SDL_FALSE;
}
283
284
285
286
#endif /* SDL_VIDEO_DRIVER_WINRT */
/* vi: set ts=4 sw=4 expandtab: */