diff --git a/VisualC-WinPhone/SDL/SDL_VS2012-WinPhone.vcxproj b/VisualC-WinPhone/SDL/SDL_VS2012-WinPhone.vcxproj
index 0e1b2e1ea..c7156be8f 100644
--- a/VisualC-WinPhone/SDL/SDL_VS2012-WinPhone.vcxproj
+++ b/VisualC-WinPhone/SDL/SDL_VS2012-WinPhone.vcxproj
@@ -211,6 +211,7 @@
+
@@ -302,6 +303,7 @@
+
diff --git a/VisualC-WinPhone/SDL/SDL_VS2012-WinPhone.vcxproj.filters b/VisualC-WinPhone/SDL/SDL_VS2012-WinPhone.vcxproj.filters
index 1774855a2..ec1edad74 100644
--- a/VisualC-WinPhone/SDL/SDL_VS2012-WinPhone.vcxproj.filters
+++ b/VisualC-WinPhone/SDL/SDL_VS2012-WinPhone.vcxproj.filters
@@ -345,6 +345,9 @@
Source Files
+
+ Source Files
+
@@ -602,6 +605,9 @@
Source Files
+
+ Source Files
+
diff --git a/VisualC-WinRT/SDL/SDL_VS2012-WinRT.vcxproj b/VisualC-WinRT/SDL/SDL_VS2012-WinRT.vcxproj
index 4088ac93a..53a3bb345 100644
--- a/VisualC-WinRT/SDL/SDL_VS2012-WinRT.vcxproj
+++ b/VisualC-WinRT/SDL/SDL_VS2012-WinRT.vcxproj
@@ -78,6 +78,7 @@
+
@@ -248,6 +249,7 @@
+
diff --git a/VisualC-WinRT/SDL/SDL_VS2012-WinRT.vcxproj.filters b/VisualC-WinRT/SDL/SDL_VS2012-WinRT.vcxproj.filters
index 0682d5f5f..fec688350 100644
--- a/VisualC-WinRT/SDL/SDL_VS2012-WinRT.vcxproj.filters
+++ b/VisualC-WinRT/SDL/SDL_VS2012-WinRT.vcxproj.filters
@@ -264,6 +264,9 @@
Source Files
+
+ Source Files
+
@@ -599,6 +602,9 @@
Header Files
+
+ Source Files
+
diff --git a/include/SDL_config_windowsrt.h b/include/SDL_config_windowsrt.h
index 3223ca261..c9af3fda1 100644
--- a/include/SDL_config_windowsrt.h
+++ b/include/SDL_config_windowsrt.h
@@ -159,6 +159,8 @@ typedef unsigned int uintptr_t;
#define SDL_VIDEO_DRIVER_DUMMY 1
// TODO, WinRT: Get a Direct3D 11 based renderer working in SDL.
+/* Enable appropriate renderer(s) */
+#define SDL_VIDEO_RENDER_D3D11 1
/* Enable system power support */
// TODO, WinRT: investigate system power support. The Win32-based APIs don't work on WinRT.
diff --git a/src/render/SDL_render.c b/src/render/SDL_render.c
index 01b4aa13b..0e5edfe36 100644
--- a/src/render/SDL_render.c
+++ b/src/render/SDL_render.c
@@ -49,6 +49,9 @@ static const SDL_RenderDriver *render_drivers[] = {
#if SDL_VIDEO_RENDER_D3D
&D3D_RenderDriver,
#endif
+#if SDL_VIDEO_RENDER_D3D11
+ &D3D11_RenderDriver,
+#endif
#if SDL_VIDEO_RENDER_OGL
&GL_RenderDriver,
#endif
diff --git a/src/render/SDL_sysrender.h b/src/render/SDL_sysrender.h
index dff297f5e..69e83ec48 100644
--- a/src/render/SDL_sysrender.h
+++ b/src/render/SDL_sysrender.h
@@ -161,6 +161,9 @@ struct SDL_RenderDriver
#if SDL_VIDEO_RENDER_D3D
extern SDL_RenderDriver D3D_RenderDriver;
#endif
+#if SDL_VIDEO_RENDER_D3D11
+extern SDL_RenderDriver D3D11_RenderDriver;
+#endif
#if SDL_VIDEO_RENDER_OGL
extern SDL_RenderDriver GL_RenderDriver;
#endif
diff --git a/src/render/direct3d11/SDL_render_d3d11.cpp b/src/render/direct3d11/SDL_render_d3d11.cpp
new file mode 100644
index 000000000..21f89fd01
--- /dev/null
+++ b/src/render/direct3d11/SDL_render_d3d11.cpp
@@ -0,0 +1,291 @@
+/*
+ Simple DirectMedia Layer
+ Copyright (C) 1997-2012 Sam Lantinga
+
+ 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_RENDER_D3D11 && !SDL_RENDER_DISABLED
+
+extern "C" {
+#include "../../core/windows/SDL_windows.h"
+//#include "SDL_hints.h"
+//#include "SDL_loadso.h"
+#include "SDL_syswm.h"
+#include "../SDL_sysrender.h"
+//#include "stdio.h"
+}
+
+#include "SDL_render_d3d11_cpp.h"
+
+/* Direct3D renderer implementation */
+
+static SDL_Renderer *D3D11_CreateRenderer(SDL_Window * window, Uint32 flags);
+//static void D3D11_WindowEvent(SDL_Renderer * renderer,
+// const SDL_WindowEvent *event);
+//static int D3D11_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
+//static int D3D11_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
+// const SDL_Rect * rect, const void *pixels,
+// int pitch);
+//static int D3D11_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
+// const SDL_Rect * rect, void **pixels, int *pitch);
+//static void D3D11_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);
+//static int D3D11_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture);
+static int D3D11_UpdateViewport(SDL_Renderer * renderer);
+//static int D3D11_RenderClear(SDL_Renderer * renderer);
+//static int D3D11_RenderDrawPoints(SDL_Renderer * renderer,
+// const SDL_FPoint * points, int count);
+//static int D3D11_RenderDrawLines(SDL_Renderer * renderer,
+// const SDL_FPoint * points, int count);
+//static int D3D11_RenderFillRects(SDL_Renderer * renderer,
+// const SDL_FRect * rects, int count);
+//static int D3D11_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
+// const SDL_Rect * srcrect, const SDL_FRect * dstrect);
+//static int D3D11_RenderCopyEx(SDL_Renderer * renderer, SDL_Texture * texture,
+// const SDL_Rect * srcrect, const SDL_FRect * dstrect,
+// const double angle, const SDL_FPoint * center, const SDL_RendererFlip flip);
+//static int D3D11_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
+// Uint32 format, void * pixels, int pitch);
+//static void D3D11_RenderPresent(SDL_Renderer * renderer);
+//static void D3D11_DestroyTexture(SDL_Renderer * renderer,
+// SDL_Texture * texture);
+//static void D3D11_DestroyRenderer(SDL_Renderer * renderer);
+
+
+extern "C" {
+ SDL_RenderDriver D3D11_RenderDriver = {
+ D3D11_CreateRenderer,
+ {
+ "direct3d",
+ (SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE),
+ 1,
+ {SDL_PIXELFORMAT_ARGB8888},
+ 0,
+ 0}
+ };
+}
+
+//typedef struct
+//{
+// float x, y, z;
+// DWORD color;
+// float u, v;
+//} Vertex;
+
+SDL_Renderer *
+D3D11_CreateRenderer(SDL_Window * window, Uint32 flags)
+{
+ SDL_Renderer *renderer;
+ D3D11_RenderData *data;
+// SDL_SysWMinfo windowinfo;
+ // HRESULT result;
+ // D3DPRESENT_PARAMETERS pparams;
+ // IDirect3DSwapChain9 *chain;
+ // D3DCAPS9 caps;
+ // Uint32 window_flags;
+ // int w, h;
+ // SDL_DisplayMode fullscreen_mode;
+ // D3DMATRIX matrix;
+ // int d3dxVersion;
+ //char d3dxDLLFile[50];
+
+ renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
+ if (!renderer) {
+ SDL_OutOfMemory();
+ return NULL;
+ }
+ SDL_zerop(renderer);
+
+ data = new D3D11_RenderData; // Use the C++ 'new' operator to make sure the struct's members initialize using C++ rules
+ if (!data) {
+ delete data;
+ SDL_OutOfMemory();
+ return NULL;
+ }
+
+ // TODO: Create Direct3D Object(s)
+
+ //renderer->WindowEvent = D3D11_WindowEvent;
+ //renderer->CreateTexture = D3D11_CreateTexture;
+ //renderer->UpdateTexture = D3D11_UpdateTexture;
+ //renderer->LockTexture = D3D11_LockTexture;
+ //renderer->UnlockTexture = D3D11_UnlockTexture;
+ //renderer->SetRenderTarget = D3D11_SetRenderTarget;
+ renderer->UpdateViewport = D3D11_UpdateViewport;
+ //renderer->RenderClear = D3D11_RenderClear;
+ //renderer->RenderDrawPoints = D3D11_RenderDrawPoints;
+ //renderer->RenderDrawLines = D3D11_RenderDrawLines;
+ //renderer->RenderFillRects = D3D11_RenderFillRects;
+ //renderer->RenderCopy = D3D11_RenderCopy;
+ //renderer->RenderCopyEx = D3D11_RenderCopyEx;
+ //renderer->RenderReadPixels = D3D11_RenderReadPixels;
+ //renderer->RenderPresent = D3D11_RenderPresent;
+ //renderer->DestroyTexture = D3D11_DestroyTexture;
+ //renderer->DestroyRenderer = D3D11_DestroyRenderer;
+ renderer->info = D3D11_RenderDriver.info;
+ renderer->driverdata = data;
+
+ renderer->info.flags = SDL_RENDERER_ACCELERATED;
+
+ //SDL_VERSION(&windowinfo.version);
+ //SDL_GetWindowWMInfo(window, &windowinfo);
+
+ //window_flags = SDL_GetWindowFlags(window);
+ //SDL_GetWindowSize(window, &w, &h);
+ //SDL_GetWindowDisplayMode(window, &fullscreen_mode);
+
+ //SDL_zero(pparams);
+ //pparams.hDeviceWindow = windowinfo.info.win.window;
+ //pparams.BackBufferWidth = w;
+ //pparams.BackBufferHeight = h;
+ //if (window_flags & SDL_WINDOW_FULLSCREEN) {
+ // pparams.BackBufferFormat =
+ // PixelFormatToD3DFMT(fullscreen_mode.format);
+ //} else {
+ // pparams.BackBufferFormat = D3DFMT_UNKNOWN;
+ //}
+ //pparams.BackBufferCount = 1;
+ //pparams.SwapEffect = D3DSWAPEFFECT_DISCARD;
+
+ //if (window_flags & SDL_WINDOW_FULLSCREEN) {
+ // pparams.Windowed = FALSE;
+ // pparams.FullScreen_RefreshRateInHz =
+ // fullscreen_mode.refresh_rate;
+ //} else {
+ // pparams.Windowed = TRUE;
+ // pparams.FullScreen_RefreshRateInHz = 0;
+ //}
+ //if (flags & SDL_RENDERER_PRESENTVSYNC) {
+ // pparams.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
+ //} else {
+ // pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
+ //}
+
+ ///* FIXME: Which adapter? */
+ //data->adapter = D3DADAPTER_DEFAULT;
+ //IDirect3D9_GetDeviceCaps(data->d3d, data->adapter, D3DDEVTYPE_HAL, &caps);
+
+ //result = IDirect3D9_CreateDevice(data->d3d, data->adapter,
+ // D3DDEVTYPE_HAL,
+ // pparams.hDeviceWindow,
+ // D3DCREATE_FPU_PRESERVE | ((caps.
+ // DevCaps &
+ // D3DDEVCAPS_HWTRANSFORMANDLIGHT) ?
+ // D3DCREATE_HARDWARE_VERTEXPROCESSING :
+ // D3DCREATE_SOFTWARE_VERTEXPROCESSING),
+ // &pparams, &data->device);
+ //if (FAILED(result)) {
+ // D3D11_DestroyRenderer(renderer);
+ // D3D11_SetError("CreateDevice()", result);
+ // return NULL;
+ //}
+ //data->beginScene = SDL_TRUE;
+ //data->scaleMode = D3DTEXF_FORCE_DWORD;
+
+ ///* Get presentation parameters to fill info */
+ //result = IDirect3DDevice9_GetSwapChain(data->device, 0, &chain);
+ //if (FAILED(result)) {
+ // D3D11_DestroyRenderer(renderer);
+ // D3D11_SetError("GetSwapChain()", result);
+ // return NULL;
+ //}
+ //result = IDirect3DSwapChain9_GetPresentParameters(chain, &pparams);
+ //if (FAILED(result)) {
+ // IDirect3DSwapChain9_Release(chain);
+ // D3D11_DestroyRenderer(renderer);
+ // D3D11_SetError("GetPresentParameters()", result);
+ // return NULL;
+ //}
+ //IDirect3DSwapChain9_Release(chain);
+ //if (pparams.PresentationInterval == D3DPRESENT_INTERVAL_ONE) {
+ // renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
+ //}
+ //data->pparams = pparams;
+
+ //IDirect3DDevice9_GetDeviceCaps(data->device, &caps);
+ //renderer->info.max_texture_width = caps.MaxTextureWidth;
+ //renderer->info.max_texture_height = caps.MaxTextureHeight;
+ //if (caps.NumSimultaneousRTs >= 2) {
+ // renderer->info.flags |= SDL_RENDERER_TARGETTEXTURE;
+ //}
+
+ ///* Set up parameters for rendering */
+ //IDirect3DDevice9_SetVertexShader(data->device, NULL);
+ //IDirect3DDevice9_SetFVF(data->device,
+ // D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
+ //IDirect3DDevice9_SetRenderState(data->device, D3DRS_ZENABLE, D3DZB_FALSE);
+ //IDirect3DDevice9_SetRenderState(data->device, D3DRS_CULLMODE,
+ // D3DCULL_NONE);
+ //IDirect3DDevice9_SetRenderState(data->device, D3DRS_LIGHTING, FALSE);
+ ///* Enable color modulation by diffuse color */
+ //IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_COLOROP,
+ // D3DTOP_MODULATE);
+ //IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_COLORARG1,
+ // D3DTA_TEXTURE);
+ //IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_COLORARG2,
+ // D3DTA_DIFFUSE);
+ ///* Enable alpha modulation by diffuse alpha */
+ //IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_ALPHAOP,
+ // D3DTOP_MODULATE);
+ //IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_ALPHAARG1,
+ // D3DTA_TEXTURE);
+ //IDirect3DDevice9_SetTextureStageState(data->device, 0, D3DTSS_ALPHAARG2,
+ // D3DTA_DIFFUSE);
+ ///* Disable second texture stage, since we're done */
+ //IDirect3DDevice9_SetTextureStageState(data->device, 1, D3DTSS_COLOROP,
+ // D3DTOP_DISABLE);
+ //IDirect3DDevice9_SetTextureStageState(data->device, 1, D3DTSS_ALPHAOP,
+ // D3DTOP_DISABLE);
+
+ ///* Store the default render target */
+ //IDirect3DDevice9_GetRenderTarget(data->device, 0, &data->defaultRenderTarget );
+ //data->currentRenderTarget = NULL;
+
+ ///* Set an identity world and view matrix */
+ //matrix.m[0][0] = 1.0f;
+ //matrix.m[0][1] = 0.0f;
+ //matrix.m[0][2] = 0.0f;
+ //matrix.m[0][3] = 0.0f;
+ //matrix.m[1][0] = 0.0f;
+ //matrix.m[1][1] = 1.0f;
+ //matrix.m[1][2] = 0.0f;
+ //matrix.m[1][3] = 0.0f;
+ //matrix.m[2][0] = 0.0f;
+ //matrix.m[2][1] = 0.0f;
+ //matrix.m[2][2] = 1.0f;
+ //matrix.m[2][3] = 0.0f;
+ //matrix.m[3][0] = 0.0f;
+ //matrix.m[3][1] = 0.0f;
+ //matrix.m[3][2] = 0.0f;
+ //matrix.m[3][3] = 1.0f;
+ //IDirect3DDevice9_SetTransform(data->device, D3DTS_WORLD, &matrix);
+ //IDirect3DDevice9_SetTransform(data->device, D3DTS_VIEW, &matrix);
+
+ return renderer;
+}
+
+static int
+D3D11_UpdateViewport(SDL_Renderer * renderer)
+{
+ return 0;
+}
+
+#endif /* SDL_VIDEO_RENDER_D3D && !SDL_RENDER_DISABLED */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/src/render/direct3d11/SDL_render_d3d11_cpp.h b/src/render/direct3d11/SDL_render_d3d11_cpp.h
new file mode 100644
index 000000000..3ec4998f0
--- /dev/null
+++ b/src/render/direct3d11/SDL_render_d3d11_cpp.h
@@ -0,0 +1,45 @@
+/*
+ Simple DirectMedia Layer
+ Copyright (C) 1997-2012 Sam Lantinga
+
+ 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"
+
+#include
+#include
+
+typedef struct
+{
+ Microsoft::WRL::ComPtr d3dDevice;
+ Microsoft::WRL::ComPtr d3dContext;
+ Microsoft::WRL::ComPtr swapChain;
+ Microsoft::WRL::ComPtr renderTargetView;
+ Microsoft::WRL::ComPtr inputLayout;
+ Microsoft::WRL::ComPtr vertexBuffer;
+ Microsoft::WRL::ComPtr vertexShader;
+ Microsoft::WRL::ComPtr pixelShader;
+ Microsoft::WRL::ComPtr mainTexture;
+ Microsoft::WRL::ComPtr mainTextureResourceView;
+ Microsoft::WRL::ComPtr mainSampler;
+} D3D11_RenderData;
+
+typedef struct
+{
+} D3D11_TextureData;
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/src/video/windowsrt/SDL_WinRTApp.cpp b/src/video/windowsrt/SDL_WinRTApp.cpp
index d74ad087a..493d88195 100644
--- a/src/video/windowsrt/SDL_WinRTApp.cpp
+++ b/src/video/windowsrt/SDL_WinRTApp.cpp
@@ -47,7 +47,8 @@ SDL_WinRTApp::SDL_WinRTApp() :
m_windowClosed(false),
m_windowVisible(true),
m_sdlWindowData(NULL),
- m_useRelativeMouseMode(false)
+ m_useRelativeMouseMode(false),
+ m_renderer(nullptr)
{
}
@@ -101,8 +102,7 @@ void SDL_WinRTApp::SetWindow(CoreWindow^ window)
window->KeyUp +=
ref new TypedEventHandler(this, &SDL_WinRTApp::OnKeyUp);
-
- m_renderer->Initialize(CoreWindow::GetForCurrentThread());
+ //m_renderer->Initialize(CoreWindow::GetForCurrentThread()); // DLudwig: moved this call to WINRT_CreateWindow, likely elsewhere in the future
}
void SDL_WinRTApp::Load(Platform::String^ entryPoint)
diff --git a/src/video/windowsrt/SDL_WinRTApp.h b/src/video/windowsrt/SDL_WinRTApp.h
index 06e022536..b6dd25749 100644
--- a/src/video/windowsrt/SDL_WinRTApp.h
+++ b/src/video/windowsrt/SDL_WinRTApp.h
@@ -47,8 +47,10 @@ protected:
void OnKeyDown(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::KeyEventArgs^ args);
void OnKeyUp(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::KeyEventArgs^ args);
-private:
+internal:
SDL_winrtrenderer^ m_renderer;
+
+private:
bool m_windowClosed;
bool m_windowVisible;
const SDL_WindowData* m_sdlWindowData;
diff --git a/src/video/windowsrt/SDL_winrtrenderer.cpp b/src/video/windowsrt/SDL_winrtrenderer.cpp
index 030aeacb4..d8d960cb2 100644
--- a/src/video/windowsrt/SDL_winrtrenderer.cpp
+++ b/src/video/windowsrt/SDL_winrtrenderer.cpp
@@ -11,7 +11,8 @@ using namespace Windows::Graphics::Display;
SDL_winrtrenderer::SDL_winrtrenderer() :
m_mainTextureHelperSurface(NULL),
m_loadingComplete(false),
- m_vertexCount(0)
+ m_vertexCount(0),
+ m_sdlRendererData(NULL)
{
}
@@ -38,8 +39,9 @@ void SDL_winrtrenderer::HandleDeviceLost()
// Reset these member variables to ensure that UpdateForWindowSizeChange recreates all resources.
m_windowBounds.Width = 0;
m_windowBounds.Height = 0;
- m_swapChain = nullptr;
+ m_sdlRendererData->swapChain = nullptr;
+ // TODO, WinRT: reconnect HandleDeviceLost to SDL_Renderer
CreateDeviceResources();
UpdateForWindowSizeChange();
}
@@ -90,12 +92,13 @@ void SDL_winrtrenderer::CreateDeviceResources()
);
// Get the Direct3D 11.1 API device and context interfaces.
+ Microsoft::WRL::ComPtr d3dDevice1;
DX::ThrowIfFailed(
- device.As(&m_d3dDevice)
+ device.As(&(m_sdlRendererData->d3dDevice))
);
DX::ThrowIfFailed(
- context.As(&m_d3dContext)
+ context.As(&m_sdlRendererData->d3dContext)
);
#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
@@ -108,11 +111,11 @@ void SDL_winrtrenderer::CreateDeviceResources()
auto createVSTask = loadVSTask.then([this](Platform::Array^ fileData) {
DX::ThrowIfFailed(
- m_d3dDevice->CreateVertexShader(
+ (m_sdlRendererData->d3dDevice)->CreateVertexShader(
fileData->Data,
fileData->Length,
nullptr,
- &m_vertexShader
+ &m_sdlRendererData->vertexShader
)
);
@@ -123,23 +126,23 @@ void SDL_winrtrenderer::CreateDeviceResources()
};
DX::ThrowIfFailed(
- m_d3dDevice->CreateInputLayout(
+ m_sdlRendererData->d3dDevice->CreateInputLayout(
vertexDesc,
ARRAYSIZE(vertexDesc),
fileData->Data,
fileData->Length,
- &m_inputLayout
+ &m_sdlRendererData->inputLayout
)
);
});
auto createPSTask = loadPSTask.then([this](Platform::Array^ fileData) {
DX::ThrowIfFailed(
- m_d3dDevice->CreatePixelShader(
+ m_sdlRendererData->d3dDevice->CreatePixelShader(
fileData->Data,
fileData->Length,
nullptr,
- &m_pixelShader
+ &m_sdlRendererData->pixelShader
)
);
});
@@ -161,10 +164,10 @@ void SDL_winrtrenderer::CreateDeviceResources()
vertexBufferData.SysMemSlicePitch = 0;
CD3D11_BUFFER_DESC vertexBufferDesc(sizeof(vertices), D3D11_BIND_VERTEX_BUFFER);
DX::ThrowIfFailed(
- m_d3dDevice->CreateBuffer(
+ m_sdlRendererData->d3dDevice->CreateBuffer(
&vertexBufferDesc,
&vertexBufferData,
- &m_vertexBuffer
+ &m_sdlRendererData->vertexBuffer
)
);
});
@@ -185,9 +188,9 @@ void SDL_winrtrenderer::CreateDeviceResources()
samplerDesc.MinLOD = 0.0f;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
DX::ThrowIfFailed(
- m_d3dDevice->CreateSamplerState(
+ m_sdlRendererData->d3dDevice->CreateSamplerState(
&samplerDesc,
- &m_mainSampler
+ &m_sdlRendererData->mainSampler
)
);
});
@@ -218,11 +221,11 @@ void SDL_winrtrenderer::CreateWindowSizeDependentResources()
m_renderTargetSize.Width = swapDimensions ? windowHeight : windowWidth;
m_renderTargetSize.Height = swapDimensions ? windowWidth : windowHeight;
- if(m_swapChain != nullptr)
+ if(m_sdlRendererData->swapChain != nullptr)
{
// If the swap chain already exists, resize it.
DX::ThrowIfFailed(
- m_swapChain->ResizeBuffers(
+ m_sdlRendererData->swapChain->ResizeBuffers(
2, // Double-buffered swap chain.
static_cast(m_renderTargetSize.Width),
static_cast(m_renderTargetSize.Height),
@@ -254,7 +257,7 @@ void SDL_winrtrenderer::CreateWindowSizeDependentResources()
ComPtr dxgiDevice;
DX::ThrowIfFailed(
- m_d3dDevice.As(&dxgiDevice)
+ m_sdlRendererData->d3dDevice.As(&dxgiDevice)
);
ComPtr dxgiAdapter;
@@ -273,11 +276,11 @@ void SDL_winrtrenderer::CreateWindowSizeDependentResources()
Windows::UI::Core::CoreWindow^ window = m_window.Get();
DX::ThrowIfFailed(
dxgiFactory->CreateSwapChainForCoreWindow(
- m_d3dDevice.Get(),
+ m_sdlRendererData->d3dDevice.Get(),
reinterpret_cast(window),
&swapChainDesc,
nullptr, // Allow on all displays.
- &m_swapChain
+ &m_sdlRendererData->swapChain
)
);
@@ -340,14 +343,14 @@ void SDL_winrtrenderer::CreateWindowSizeDependentResources()
#if WINAPI_FAMILY != WINAPI_FAMILY_PHONE_APP
// TODO, WinRT: Windows Phone does not have the IDXGISwapChain1::SetRotation method. Check if an alternative is available, or needed.
DX::ThrowIfFailed(
- m_swapChain->SetRotation(rotation)
+ m_sdlRendererData->swapChain->SetRotation(rotation)
);
#endif
// Create a render target view of the swap chain back buffer.
ComPtr backBuffer;
DX::ThrowIfFailed(
- m_swapChain->GetBuffer(
+ m_sdlRendererData->swapChain->GetBuffer(
0,
__uuidof(ID3D11Texture2D),
&backBuffer
@@ -355,10 +358,10 @@ void SDL_winrtrenderer::CreateWindowSizeDependentResources()
);
DX::ThrowIfFailed(
- m_d3dDevice->CreateRenderTargetView(
+ m_sdlRendererData->d3dDevice->CreateRenderTargetView(
backBuffer.Get(),
nullptr,
- &m_renderTargetView
+ &m_sdlRendererData->renderTargetView
)
);
@@ -374,7 +377,7 @@ void SDL_winrtrenderer::CreateWindowSizeDependentResources()
ComPtr depthStencil;
DX::ThrowIfFailed(
- m_d3dDevice->CreateTexture2D(
+ m_sdlRendererData->d3dDevice->CreateTexture2D(
&depthStencilDesc,
nullptr,
&depthStencil
@@ -389,7 +392,7 @@ void SDL_winrtrenderer::CreateWindowSizeDependentResources()
m_renderTargetSize.Height
);
- m_d3dContext->RSSetViewports(1, &viewport);
+ m_sdlRendererData->d3dContext->RSSetViewports(1, &viewport);
}
void SDL_winrtrenderer::ResizeMainTexture(int w, int h)
@@ -425,10 +428,10 @@ void SDL_winrtrenderer::ResizeMainTexture(int w, int h)
initialTextureData.SysMemPitch = textureDesc.Width * pixelSizeInBytes;
initialTextureData.SysMemSlicePitch = numPixels * pixelSizeInBytes;
DX::ThrowIfFailed(
- m_d3dDevice->CreateTexture2D(
+ m_sdlRendererData->d3dDevice->CreateTexture2D(
&textureDesc,
&initialTextureData,
- &m_mainTexture
+ &m_sdlRendererData->mainTexture
)
);
@@ -452,10 +455,10 @@ void SDL_winrtrenderer::ResizeMainTexture(int w, int h)
resourceViewDesc.Texture2D.MostDetailedMip = 0;
resourceViewDesc.Texture2D.MipLevels = textureDesc.MipLevels;
DX::ThrowIfFailed(
- m_d3dDevice->CreateShaderResourceView(
- m_mainTexture.Get(),
+ m_sdlRendererData->d3dDevice->CreateShaderResourceView(
+ m_sdlRendererData->mainTexture.Get(),
&resourceViewDesc,
- &m_mainTextureResourceView)
+ &m_sdlRendererData->mainTextureResourceView)
);
}
@@ -467,9 +470,9 @@ void SDL_winrtrenderer::UpdateForWindowSizeChange()
m_orientation != DisplayProperties::CurrentOrientation)
{
ID3D11RenderTargetView* nullViews[] = {nullptr};
- m_d3dContext->OMSetRenderTargets(ARRAYSIZE(nullViews), nullViews, nullptr);
- m_renderTargetView = nullptr;
- m_d3dContext->Flush();
+ m_sdlRendererData->d3dContext->OMSetRenderTargets(ARRAYSIZE(nullViews), nullViews, nullptr);
+ m_sdlRendererData->renderTargetView = nullptr;
+ m_sdlRendererData->d3dContext->Flush();
CreateWindowSizeDependentResources();
}
}
@@ -477,8 +480,8 @@ void SDL_winrtrenderer::UpdateForWindowSizeChange()
void SDL_winrtrenderer::Render(SDL_Surface * surface, SDL_Rect * rects, int numrects)
{
const float blackColor[] = { 0.0f, 0.0f, 0.0f, 0.0f };
- m_d3dContext->ClearRenderTargetView(
- m_renderTargetView.Get(),
+ m_sdlRendererData->d3dContext->ClearRenderTargetView(
+ m_sdlRendererData->renderTargetView.Get(),
blackColor
);
@@ -487,7 +490,7 @@ void SDL_winrtrenderer::Render(SDL_Surface * surface, SDL_Rect * rects, int numr
{
return;
}
- if (!m_mainTextureResourceView)
+ if (!m_sdlRendererData->mainTextureResourceView)
{
return;
}
@@ -496,8 +499,8 @@ void SDL_winrtrenderer::Render(SDL_Surface * surface, SDL_Rect * rects, int numr
// window's main texture to CPU-accessible memory:
D3D11_MAPPED_SUBRESOURCE textureMemory = {0};
DX::ThrowIfFailed(
- m_d3dContext->Map(
- m_mainTexture.Get(),
+ m_sdlRendererData->d3dContext->Map(
+ m_sdlRendererData->mainTexture.Get(),
0,
D3D11_MAP_WRITE_DISCARD,
0,
@@ -513,47 +516,47 @@ void SDL_winrtrenderer::Render(SDL_Surface * surface, SDL_Rect * rects, int numr
// Clean up a bit, then commit the texture's memory back to Direct3D:
m_mainTextureHelperSurface->pixels = NULL;
m_mainTextureHelperSurface->pitch = 0;
- m_d3dContext->Unmap(
- m_mainTexture.Get(),
+ m_sdlRendererData->d3dContext->Unmap(
+ m_sdlRendererData->mainTexture.Get(),
0);
- m_d3dContext->OMSetRenderTargets(
+ m_sdlRendererData->d3dContext->OMSetRenderTargets(
1,
- m_renderTargetView.GetAddressOf(),
+ m_sdlRendererData->renderTargetView.GetAddressOf(),
nullptr
);
UINT stride = sizeof(VertexPositionColor);
UINT offset = 0;
- m_d3dContext->IASetVertexBuffers(
+ m_sdlRendererData->d3dContext->IASetVertexBuffers(
0,
1,
- m_vertexBuffer.GetAddressOf(),
+ m_sdlRendererData->vertexBuffer.GetAddressOf(),
&stride,
&offset
);
- m_d3dContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
+ m_sdlRendererData->d3dContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
- m_d3dContext->IASetInputLayout(m_inputLayout.Get());
+ m_sdlRendererData->d3dContext->IASetInputLayout(m_sdlRendererData->inputLayout.Get());
- m_d3dContext->VSSetShader(
- m_vertexShader.Get(),
+ m_sdlRendererData->d3dContext->VSSetShader(
+ m_sdlRendererData->vertexShader.Get(),
nullptr,
0
);
- m_d3dContext->PSSetShader(
- m_pixelShader.Get(),
+ m_sdlRendererData->d3dContext->PSSetShader(
+ m_sdlRendererData->pixelShader.Get(),
nullptr,
0
);
- m_d3dContext->PSSetShaderResources(0, 1, m_mainTextureResourceView.GetAddressOf());
+ m_sdlRendererData->d3dContext->PSSetShaderResources(0, 1, m_sdlRendererData->mainTextureResourceView.GetAddressOf());
- m_d3dContext->PSSetSamplers(0, 1, m_mainSampler.GetAddressOf());
+ m_sdlRendererData->d3dContext->PSSetSamplers(0, 1, m_sdlRendererData->mainSampler.GetAddressOf());
- m_d3dContext->Draw(4, 0);
+ m_sdlRendererData->d3dContext->Draw(4, 0);
}
// Method to deliver the final image to the display.
@@ -563,7 +566,7 @@ void SDL_winrtrenderer::Present()
// The first argument instructs DXGI to block until VSync, putting the application
// to sleep until the next VSync. This ensures we don't waste any cycles rendering
// frames that will never be displayed to the screen.
- HRESULT hr = m_swapChain->Present(1, 0);
+ HRESULT hr = m_sdlRendererData->swapChain->Present(1, 0);
#else
// The application may optionally specify "dirty" or "scroll"
// rects to improve efficiency in certain scenarios.
@@ -577,13 +580,13 @@ void SDL_winrtrenderer::Present()
// The first argument instructs DXGI to block until VSync, putting the application
// to sleep until the next VSync. This ensures we don't waste any cycles rendering
// frames that will never be displayed to the screen.
- HRESULT hr = m_swapChain->Present1(1, 0, ¶meters);
+ HRESULT hr = m_sdlRendererData->swapChain->Present1(1, 0, ¶meters);
#endif
// Discard the contents of the render target.
// This is a valid operation only when the existing contents will be entirely
// overwritten. If dirty or scroll rects are used, this call should be removed.
- m_d3dContext->DiscardView(m_renderTargetView.Get());
+ m_sdlRendererData->d3dContext->DiscardView(m_sdlRendererData->renderTargetView.Get());
// If the device was removed either by a disconnect or a driver upgrade, we
// must recreate all device resources.
diff --git a/src/video/windowsrt/SDL_winrtrenderer.h b/src/video/windowsrt/SDL_winrtrenderer.h
index 62b194f3d..4f771947f 100644
--- a/src/video/windowsrt/SDL_winrtrenderer.h
+++ b/src/video/windowsrt/SDL_winrtrenderer.h
@@ -2,6 +2,7 @@
#include "DirectXHelper.h"
#include "SDL.h"
+#include "../../render/direct3d11/SDL_render_d3d11_cpp.h"
struct VertexPositionColor
{
@@ -29,20 +30,11 @@ internal:
virtual void Render(SDL_Surface * surface, SDL_Rect * rects, int numrects);
void ResizeMainTexture(int w, int h);
-protected private:
- // Direct3D Objects.
- Microsoft::WRL::ComPtr m_d3dDevice;
- Microsoft::WRL::ComPtr m_d3dContext;
- Microsoft::WRL::ComPtr m_swapChain;
- Microsoft::WRL::ComPtr m_renderTargetView;
- Microsoft::WRL::ComPtr m_inputLayout;
- Microsoft::WRL::ComPtr m_vertexBuffer;
- Microsoft::WRL::ComPtr m_vertexShader;
- Microsoft::WRL::ComPtr m_pixelShader;
- Microsoft::WRL::ComPtr m_mainTexture;
- Microsoft::WRL::ComPtr m_mainTextureResourceView;
- Microsoft::WRL::ComPtr m_mainSampler;
+internal:
+ // Internal SDL rendeerer (likely a temporary addition, for refactoring purposes):
+ D3D11_RenderData * m_sdlRendererData;
+protected private:
// UpdateWindowSurface helper objects
SDL_Surface * m_mainTextureHelperSurface;
diff --git a/src/video/windowsrt/SDL_winrtvideo.cpp b/src/video/windowsrt/SDL_winrtvideo.cpp
index 5b72c92a1..6bd7640db 100644
--- a/src/video/windowsrt/SDL_winrtvideo.cpp
+++ b/src/video/windowsrt/SDL_winrtvideo.cpp
@@ -34,6 +34,7 @@ extern "C" {
#include "../SDL_sysvideo.h"
#include "../SDL_pixels_c.h"
#include "../../events/SDL_events_c.h"
+#include "../../render/SDL_sysrender.h"
}
#include "SDL_WinRTApp.h"
@@ -210,6 +211,19 @@ WINRT_CreateWindow(_THIS, SDL_Window * window)
*/
SDL_WinRTGlobalApp->SetSDLWindowData(data);
+ /* 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.
+ SDL_Renderer * renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE);
+ SDL_WinRTGlobalApp->m_renderer->m_sdlRendererData = (D3D11_RenderData *) renderer->driverdata;
+ SDL_WinRTGlobalApp->m_renderer->Initialize(CoreWindow::GetForCurrentThread());
+
/* All done! */
return 0;
}