From 3cf576144bfb30a84ab5259b26f3a90dc63aedc9 Mon Sep 17 00:00:00 2001 From: David Ludwig Date: Sat, 2 Feb 2013 19:32:44 -0500 Subject: [PATCH] WinRT: started refactoring Direct3D 11.1 code into a new SDL_Renderer backend --- .../SDL/SDL_VS2012-WinPhone.vcxproj | 2 + .../SDL/SDL_VS2012-WinPhone.vcxproj.filters | 6 + VisualC-WinRT/SDL/SDL_VS2012-WinRT.vcxproj | 2 + .../SDL/SDL_VS2012-WinRT.vcxproj.filters | 6 + include/SDL_config_windowsrt.h | 2 + src/render/SDL_render.c | 3 + src/render/SDL_sysrender.h | 3 + src/render/direct3d11/SDL_render_d3d11.cpp | 291 ++++++++++++++++++ src/render/direct3d11/SDL_render_d3d11_cpp.h | 45 +++ src/video/windowsrt/SDL_WinRTApp.cpp | 6 +- src/video/windowsrt/SDL_WinRTApp.h | 4 +- src/video/windowsrt/SDL_winrtrenderer.cpp | 115 +++---- src/video/windowsrt/SDL_winrtrenderer.h | 18 +- src/video/windowsrt/SDL_winrtvideo.cpp | 14 + 14 files changed, 444 insertions(+), 73 deletions(-) create mode 100644 src/render/direct3d11/SDL_render_d3d11.cpp create mode 100644 src/render/direct3d11/SDL_render_d3d11_cpp.h 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 @@ ref class SDL_WinRTApp sealed : public Windows::ApplicationModel::Core::IFramewo 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 @@ ref class SDL_winrtrenderer 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; }