/*

Simple DirectMedia Layer

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_internal.h"

#if SDL_VIDEO_RENDER_D3D11 && !SDL_RENDER_DISABLED

#define COBJMACROS

#include "../../core/windows/SDL_windows.h"

#include "SDL_hints.h"

#include "SDL_loadso.h"

#include "SDL_syswm.h"

#include "../SDL_sysrender.h"

#include "../SDL_d3dmath.h"

#include <d3d11_1.h>

#ifdef __WINRT__

#if NTDDI_VERSION > NTDDI_WIN8

#include <DXGI1_3.h>

#endif

#include "SDL_render_winrt.h"

#if WINAPI_FAMILY == WINAPI_FAMILY_APP

#include <windows.ui.xaml.media.dxinterop.h>

/* TODO, WinRT, XAML: get the ISwapChainBackgroundPanelNative from something other than a global var */

extern ISwapChainBackgroundPanelNative * WINRT_GlobalSwapChainBackgroundPanelNative;

#endif /* WINAPI_FAMILY == WINAPI_FAMILY_APP */

#endif /* __WINRT__ */

#define SDL_COMPOSE_ERROR(str) SDL_STRINGIFY_ARG(__FUNCTION__) ", " str

#define SAFE_RELEASE(X) if ((X)) { IUnknown_Release(SDL_static_cast(IUnknown*, X)); X = NULL; }

/* Vertex shader, common values */

typedef struct

{

Float4X4 model;

Float4X4 projectionAndView;

} VertexShaderConstants;

/* Per-vertex data */

typedef struct

{

Float3 pos;

Float2 tex;

Float4 color;

} VertexPositionColor;

/* Per-texture data */

typedef struct

{

ID3D11Texture2D *mainTexture;

ID3D11ShaderResourceView *mainTextureResourceView;

ID3D11RenderTargetView *mainTextureRenderTargetView;

ID3D11Texture2D *stagingTexture;

int lockedTexturePositionX;

int lockedTexturePositionY;

D3D11_FILTER scaleMode;

/* YV12 texture support */

SDL_bool yuv;

ID3D11Texture2D *mainTextureU;

ID3D11ShaderResourceView *mainTextureResourceViewU;

ID3D11Texture2D *mainTextureV;

ID3D11ShaderResourceView *mainTextureResourceViewV;

/* NV12 texture support */

SDL_bool nv12;

ID3D11Texture2D *mainTextureNV;

ID3D11ShaderResourceView *mainTextureResourceViewNV;

Uint8 *pixels;

int pitch;

SDL_Rect locked_rect;

} D3D11_TextureData;

/* Blend mode data */

typedef struct

{

SDL_BlendMode blendMode;

ID3D11BlendState *blendState;

} D3D11_BlendMode;

/* Private renderer data */

typedef struct

{

void *hDXGIMod;

void *hD3D11Mod;

IDXGIFactory2 *dxgiFactory;

IDXGIAdapter *dxgiAdapter;

ID3D11Device1 *d3dDevice;

ID3D11DeviceContext1 *d3dContext;

IDXGISwapChain1 *swapChain;

DXGI_SWAP_EFFECT swapEffect;

ID3D11RenderTargetView *mainRenderTargetView;

ID3D11RenderTargetView *currentOffscreenRenderTargetView;

ID3D11InputLayout *inputLayout;

ID3D11Buffer *vertexBuffer;

ID3D11VertexShader *vertexShader;

int blendModesCount;

D3D11_BlendMode *blendModes;

ID3D11SamplerState *nearestPixelSampler;

ID3D11SamplerState *linearSampler;

D3D_FEATURE_LEVEL featureLevel;

/* Rasterizers */

ID3D11RasterizerState *mainRasterizer;

ID3D11RasterizerState *clippedRasterizer;

/* Vertex buffer constants */

VertexShaderConstants vertexShaderConstantsData;

ID3D11Buffer *vertexShaderConstants;

/* Cached renderer properties */

DXGI_MODE_ROTATION rotation;

ID3D11RenderTargetView *currentRenderTargetView;

ID3D11RasterizerState *currentRasterizerState;

ID3D11BlendState *currentBlendState;

ID3D11PixelShader *currentShader;

ID3D11ShaderResourceView *currentShaderResource;

ID3D11SamplerState *currentSampler;

} D3D11_RenderData;

/* Define D3D GUIDs here so we don't have to include uuid.lib.

*

* Fix for SDL bug https://bugzilla.libsdl.org/show_bug.cgi?id=3437:

* to prevent build errors on both MinGW-w64 and WinRT/UWP.

* (SDL bug https://bugzilla.libsdl.org/show_bug.cgi?id=3336 led to

* linker errors in WinRT/UWP builds.)

*/

#ifdef __GNUC__

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wunused-const-variable"

#endif

static const GUID SDL_IID_IDXGIFactory2 = { 0x50c83a1c, 0xe072, 0x4c48, { 0x87, 0xb0, 0x36, 0x30, 0xfa, 0x36, 0xa6, 0xd0 } };

static const GUID SDL_IID_IDXGIDevice1 = { 0x77db970f, 0x6276, 0x48ba, { 0xba, 0x28, 0x07, 0x01, 0x43, 0xb4, 0x39, 0x2c } };

static const GUID SDL_IID_IDXGIDevice3 = { 0x6007896c, 0x3244, 0x4afd, { 0xbf, 0x18, 0xa6, 0xd3, 0xbe, 0xda, 0x50, 0x23 } };

static const GUID SDL_IID_ID3D11Texture2D = { 0x6f15aaf2, 0xd208, 0x4e89, { 0x9a, 0xb4, 0x48, 0x95, 0x35, 0xd3, 0x4f, 0x9c } };

static const GUID SDL_IID_ID3D11Device1 = { 0xa04bfb29, 0x08ef, 0x43d6, { 0xa4, 0x9c, 0xa9, 0xbd, 0xbd, 0xcb, 0xe6, 0x86 } };

static const GUID SDL_IID_ID3D11DeviceContext1 = { 0xbb2c6faa, 0xb5fb, 0x4082, { 0x8e, 0x6b, 0x38, 0x8b, 0x8c, 0xfa, 0x90, 0xe1 } };

static const GUID SDL_IID_ID3D11Debug = { 0x79cf2233, 0x7536, 0x4948, { 0x9d, 0x36, 0x1e, 0x46, 0x92, 0xdc, 0x57, 0x60 } };

#ifdef __GNUC__

#pragma GCC diagnostic pop

#endif

/* Direct3D 11.1 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 *srcPixels,

int srcPitch);

static int D3D11_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,

const SDL_Rect * rect,

const Uint8 *Yplane, int Ypitch,

const Uint8 *Uplane, int Upitch,

const Uint8 *Vplane, int Vpitch);

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_UpdateClipRect(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);

/* Direct3D 11.1 Internal Functions */

static HRESULT D3D11_CreateDeviceResources(SDL_Renderer * renderer);

static HRESULT D3D11_CreateWindowSizeDependentResources(SDL_Renderer * renderer);

static HRESULT D3D11_UpdateForWindowSizeChange(SDL_Renderer * renderer);

static HRESULT D3D11_HandleDeviceLost(SDL_Renderer * renderer);

static void D3D11_ReleaseMainRenderTargetView(SDL_Renderer * renderer);

SDL_RenderDriver D3D11_RenderDriver = {

D3D11_CreateRenderer,

{

"direct3d11",

(

SDL_RENDERER_ACCELERATED |

SDL_RENDERER_PRESENTVSYNC |

SDL_RENDERER_TARGETTEXTURE

), /* flags. see SDL_RendererFlags */

{ /* texture_formats */

SDL_PIXELFORMAT_ARGB8888,

SDL_PIXELFORMAT_RGB888,

SDL_PIXELFORMAT_YV12,

SDL_PIXELFORMAT_IYUV,

SDL_PIXELFORMAT_NV12,

SDL_PIXELFORMAT_NV21

},

0, /* max_texture_width: will be filled in later */

0 /* max_texture_height: will be filled in later */

}

};

D3D11_DXGIFormatToSDLPixelFormat(DXGI_FORMAT dxgiFormat)

{

switch (dxgiFormat) {

case DXGI_FORMAT_B8G8R8A8_UNORM:

return SDL_PIXELFORMAT_ARGB8888;

case DXGI_FORMAT_B8G8R8X8_UNORM:

return SDL_PIXELFORMAT_RGB888;

default:

return SDL_PIXELFORMAT_UNKNOWN;

}

}

static DXGI_FORMAT

SDLPixelFormatToDXGIFormat(Uint32 sdlFormat)

{

switch (sdlFormat) {

case SDL_PIXELFORMAT_ARGB8888:

return DXGI_FORMAT_B8G8R8A8_UNORM;

case SDL_PIXELFORMAT_RGB888:

return DXGI_FORMAT_B8G8R8X8_UNORM;

case SDL_PIXELFORMAT_YV12:

case SDL_PIXELFORMAT_IYUV:

case SDL_PIXELFORMAT_NV12: /* For the Y texture */

case SDL_PIXELFORMAT_NV21: /* For the Y texture */

return DXGI_FORMAT_R8_UNORM;

default:

return DXGI_FORMAT_UNKNOWN;

}

}

SDL_Renderer *

D3D11_CreateRenderer(SDL_Window * window, Uint32 flags)

{

SDL_Renderer *renderer;

D3D11_RenderData *data;

renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));

if (!renderer) {

SDL_OutOfMemory();

return NULL;

}

data = (D3D11_RenderData *) SDL_calloc(1, sizeof(*data));

if (!data) {

SDL_OutOfMemory();

return NULL;

}

renderer->WindowEvent = D3D11_WindowEvent;

renderer->CreateTexture = D3D11_CreateTexture;

renderer->UpdateTexture = D3D11_UpdateTexture;

renderer->UpdateTextureYUV = D3D11_UpdateTextureYUV;

renderer->LockTexture = D3D11_LockTexture;

renderer->UnlockTexture = D3D11_UnlockTexture;

renderer->SetRenderTarget = D3D11_SetRenderTarget;

renderer->UpdateViewport = D3D11_UpdateViewport;

renderer->UpdateClipRect = D3D11_UpdateClipRect;

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->info.flags = (SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE);

renderer->driverdata = data;

#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP

/* VSync is required in Windows Phone, at least for Win Phone 8.0 and 8.1.

* Failure to use it seems to either result in:

*

* - with the D3D11 debug runtime turned OFF, vsync seemingly gets turned

* off (framerate doesn't get capped), but nothing appears on-screen

*

* - with the D3D11 debug runtime turned ON, vsync gets automatically

* turned back on, and the following gets output to the debug console:

*

* DXGI ERROR: IDXGISwapChain::Present: Interval 0 is not supported, changed to Interval 1. [ UNKNOWN ERROR #1024: ]

*/

renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;

#else

if ((flags & SDL_RENDERER_PRESENTVSYNC)) {

renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;

}

#endif

/* HACK: make sure the SDL_Renderer references the SDL_Window data now, in

* order to give init functions access to the underlying window handle:

*/

renderer->window = window;

/* Initialize Direct3D resources */

if (FAILED(D3D11_CreateDeviceResources(renderer))) {

D3D11_DestroyRenderer(renderer);

return NULL;

}

if (FAILED(D3D11_CreateWindowSizeDependentResources(renderer))) {

D3D11_DestroyRenderer(renderer);

return NULL;

}

return renderer;

}

static void

D3D11_ReleaseAll(SDL_Renderer * renderer)

{

D3D11_RenderData *data = (D3D11_RenderData *) renderer->driverdata;

SDL_Texture *texture = NULL;

/* Release all textures */

for (texture = renderer->textures; texture; texture = texture->next) {

D3D11_DestroyTexture(renderer, texture);

}

/* Release/reset everything else */

if (data) {

int i;

SAFE_RELEASE(data->dxgiFactory);

SAFE_RELEASE(data->dxgiAdapter);

SAFE_RELEASE(data->d3dDevice);

SAFE_RELEASE(data->d3dContext);

SAFE_RELEASE(data->swapChain);

SAFE_RELEASE(data->mainRenderTargetView);

SAFE_RELEASE(data->currentOffscreenRenderTargetView);

SAFE_RELEASE(data->inputLayout);

SAFE_RELEASE(data->vertexBuffer);

SAFE_RELEASE(data->vertexShader);

for (i = 0; i < SDL_arraysize(data->pixelShaders); ++i) {

SAFE_RELEASE(data->pixelShaders[i]);

}

if (data->blendModesCount > 0) {

for (i = 0; i < data->blendModesCount; ++i) {

SAFE_RELEASE(data->blendModes[i].blendState);

}

SDL_free(data->blendModes);

data->blendModesCount = 0;

}

SAFE_RELEASE(data->nearestPixelSampler);

SAFE_RELEASE(data->linearSampler);

SAFE_RELEASE(data->mainRasterizer);

SAFE_RELEASE(data->clippedRasterizer);

SAFE_RELEASE(data->vertexShaderConstants);

data->swapEffect = (DXGI_SWAP_EFFECT) 0;

data->rotation = DXGI_MODE_ROTATION_UNSPECIFIED;

data->currentRenderTargetView = NULL;

data->currentRasterizerState = NULL;

data->currentBlendState = NULL;

data->currentShader = NULL;

data->currentShaderResource = NULL;

data->currentSampler = NULL;

/* Unload the D3D libraries. This should be done last, in order

* to prevent IUnknown::Release() calls from crashing.

*/

if (data->hD3D11Mod) {

SDL_UnloadObject(data->hD3D11Mod);

data->hD3D11Mod = NULL;

}

if (data->hDXGIMod) {

SDL_UnloadObject(data->hDXGIMod);

data->hDXGIMod = NULL;

}

}

}

static void

D3D11_DestroyRenderer(SDL_Renderer * renderer)

{

D3D11_RenderData *data = (D3D11_RenderData *) renderer->driverdata;

D3D11_ReleaseAll(renderer);

if (data) {

SDL_free(data);

}

SDL_free(renderer);

}

static D3D11_BLEND GetBlendFunc(SDL_BlendFactor factor)

{

switch (factor) {

case SDL_BLENDFACTOR_ZERO:

return D3D11_BLEND_ZERO;

case SDL_BLENDFACTOR_ONE:

return D3D11_BLEND_ONE;

case SDL_BLENDFACTOR_SRC_COLOR:

return D3D11_BLEND_SRC_COLOR;

case SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR:

return D3D11_BLEND_INV_SRC_COLOR;

case SDL_BLENDFACTOR_SRC_ALPHA:

return D3D11_BLEND_SRC_ALPHA;

case SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA:

return D3D11_BLEND_INV_SRC_ALPHA;

case SDL_BLENDFACTOR_DST_COLOR:

return D3D11_BLEND_DEST_COLOR;

case SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR:

return D3D11_BLEND_INV_DEST_COLOR;

case SDL_BLENDFACTOR_DST_ALPHA:

return D3D11_BLEND_DEST_ALPHA;

case SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA:

return D3D11_BLEND_INV_DEST_ALPHA;

default:

return (D3D11_BLEND)0;

}

}

static D3D11_BLEND_OP GetBlendEquation(SDL_BlendOperation operation)

{

switch (operation) {

case SDL_BLENDOPERATION_ADD:

return D3D11_BLEND_OP_ADD;

case SDL_BLENDOPERATION_SUBTRACT:

return D3D11_BLEND_OP_SUBTRACT;

case SDL_BLENDOPERATION_REV_SUBTRACT:

return D3D11_BLEND_OP_REV_SUBTRACT;

case SDL_BLENDOPERATION_MINIMUM:

return D3D11_BLEND_OP_MIN;

case SDL_BLENDOPERATION_MAXIMUM:

return D3D11_BLEND_OP_MAX;

default:

return (D3D11_BLEND_OP)0;

}

}

static SDL_bool

D3D11_CreateBlendState(SDL_Renderer * renderer, SDL_BlendMode blendMode)

{

D3D11_RenderData *data = (D3D11_RenderData *) renderer->driverdata;

SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);

SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);

SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode);

SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode);

SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode);

SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);

ID3D11BlendState *blendState = NULL;

D3D11_BlendMode *blendModes;

HRESULT result = S_OK;

D3D11_BLEND_DESC blendDesc;

SDL_zero(blendDesc);

blendDesc.AlphaToCoverageEnable = FALSE;

blendDesc.IndependentBlendEnable = FALSE;

blendDesc.RenderTarget[0].BlendEnable = TRUE;

blendDesc.RenderTarget[0].SrcBlend = GetBlendFunc(srcColorFactor);

blendDesc.RenderTarget[0].DestBlend = GetBlendFunc(dstColorFactor);

blendDesc.RenderTarget[0].BlendOp = GetBlendEquation(colorOperation);

blendDesc.RenderTarget[0].SrcBlendAlpha = GetBlendFunc(srcAlphaFactor);

blendDesc.RenderTarget[0].DestBlendAlpha = GetBlendFunc(dstAlphaFactor);

blendDesc.RenderTarget[0].BlendOpAlpha = GetBlendEquation(alphaOperation);

}

blendModes = (D3D11_BlendMode *)SDL_realloc(data->blendModes, (data->blendModesCount + 1) * sizeof(*blendModes));

if (!blendModes) {

SAFE_RELEASE(blendState);

SDL_OutOfMemory();

return SDL_FALSE;

}

blendModes[data->blendModesCount].blendMode = blendMode;

blendModes[data->blendModesCount].blendState = blendState;

data->blendModes = blendModes;

++data->blendModesCount;

return SDL_TRUE;

}

/* Create resources that depend on the device. */

static HRESULT

D3D11_CreateDeviceResources(SDL_Renderer * renderer)

{

typedef HRESULT(WINAPI *PFN_CREATE_DXGI_FACTORY)(REFIID riid, void **ppFactory);

PFN_CREATE_DXGI_FACTORY CreateDXGIFactoryFunc;

D3D11_RenderData *data = (D3D11_RenderData *) renderer->driverdata;

PFN_D3D11_CREATE_DEVICE D3D11CreateDeviceFunc;

ID3D11Device *d3dDevice = NULL;

ID3D11DeviceContext *d3dContext = NULL;

IDXGIDevice1 *dxgiDevice = NULL;

HRESULT result = S_OK;

UINT creationFlags;

/* This array defines the set of DirectX hardware feature levels this app will support.

* Note the ordering should be preserved.

* Don't forget to declare your application's minimum required feature level in its

* description. All applications are assumed to support 9.1 unless otherwise stated.

*/

D3D_FEATURE_LEVEL featureLevels[] =

{

D3D_FEATURE_LEVEL_11_1,

D3D_FEATURE_LEVEL_11_0,

D3D_FEATURE_LEVEL_10_1,

D3D_FEATURE_LEVEL_10_0,

D3D_FEATURE_LEVEL_9_3,

D3D_FEATURE_LEVEL_9_2,

D3D_FEATURE_LEVEL_9_1

};

D3D11_BUFFER_DESC constantBufferDesc;

D3D11_SAMPLER_DESC samplerDesc;

D3D11_RASTERIZER_DESC rasterDesc;

#ifdef __WINRT__

CreateDXGIFactoryFunc = CreateDXGIFactory1;

D3D11CreateDeviceFunc = D3D11CreateDevice;

#else

data->hDXGIMod = SDL_LoadObject("dxgi.dll");

if (!data->hDXGIMod) {

result = E_FAIL;

goto done;

}

CreateDXGIFactoryFunc = (PFN_CREATE_DXGI_FACTORY)SDL_LoadFunction(data->hDXGIMod, "CreateDXGIFactory");

if (!CreateDXGIFactoryFunc) {

result = E_FAIL;

goto done;

}

data->hD3D11Mod = SDL_LoadObject("d3d11.dll");

if (!data->hD3D11Mod) {

result = E_FAIL;

goto done;

}

D3D11CreateDeviceFunc = (PFN_D3D11_CREATE_DEVICE)SDL_LoadFunction(data->hD3D11Mod, "D3D11CreateDevice");

if (!D3D11CreateDeviceFunc) {

result = E_FAIL;

goto done;

}

#endif /* __WINRT__ */

goto done;

}

/* FIXME: Should we use the default adapter? */

result = IDXGIFactory2_EnumAdapters(data->dxgiFactory, 0, &data->dxgiAdapter);

if (FAILED(result)) {

goto done;

}

/* This flag adds support for surfaces with a different color channel ordering

* than the API default. It is required for compatibility with Direct2D.

*/

creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;

/* Make sure Direct3D's debugging feature gets used, if the app requests it. */

creationFlags |= D3D11_CREATE_DEVICE_DEBUG;

}

/* Create the Direct3D 11 API device object and a corresponding context. */

result = D3D11CreateDeviceFunc(

data->dxgiAdapter,

D3D_DRIVER_TYPE_UNKNOWN,

NULL,

creationFlags, /* Set set debug and Direct2D compatibility flags. */

featureLevels, /* List of feature levels this app can support. */

SDL_arraysize(featureLevels),

D3D11_SDK_VERSION, /* Always set this to D3D11_SDK_VERSION for Windows Store apps. */

&d3dDevice, /* Returns the Direct3D device created. */

&data->featureLevel, /* Returns feature level of device created. */

&d3dContext /* Returns the device immediate context. */

);

if (FAILED(result)) {

goto done;

}

goto done;

}

goto done;

}

goto done;

}

/* Ensure that DXGI does not queue more than one frame at a time. This both reduces latency and

* ensures that the application will only render after each VSync, minimizing power consumption.

*/

result = IDXGIDevice1_SetMaximumFrameLatency(dxgiDevice, 1);

if (FAILED(result)) {

goto done;

}

/* Make note of the maximum texture size

* Max texture sizes are documented on MSDN, at:

* http://msdn.microsoft.com/en-us/library/windows/apps/ff476876.aspx

*/

switch (data->featureLevel) {

case D3D_FEATURE_LEVEL_11_1:

case D3D_FEATURE_LEVEL_11_0:

renderer->info.max_texture_width = renderer->info.max_texture_height = 16384;

break;

case D3D_FEATURE_LEVEL_10_1:

case D3D_FEATURE_LEVEL_10_0:

renderer->info.max_texture_width = renderer->info.max_texture_height = 8192;

break;

case D3D_FEATURE_LEVEL_9_3:

renderer->info.max_texture_width = renderer->info.max_texture_height = 4096;

break;

case D3D_FEATURE_LEVEL_9_2:

case D3D_FEATURE_LEVEL_9_1:

renderer->info.max_texture_width = renderer->info.max_texture_height = 2048;

break;

default:

result = E_FAIL;

goto done;

}

goto done;

}

for (i = 0; i < SDL_arraysize(data->pixelShaders); ++i) {

if (D3D11_CreatePixelShader(data->d3dDevice, (D3D11_Shader)i, &data->pixelShaders[i]) < 0) {

goto done;

}

}

/* Setup space to hold vertex shader constants: */

SDL_zero(constantBufferDesc);

constantBufferDesc.ByteWidth = sizeof(VertexShaderConstants);

constantBufferDesc.Usage = D3D11_USAGE_DEFAULT;

constantBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;

result = ID3D11Device_CreateBuffer(data->d3dDevice,

&constantBufferDesc,

NULL,

&data->vertexShaderConstants

);

if (FAILED(result)) {

goto done;

}

/* Create samplers to use when drawing textures: */

SDL_zero(samplerDesc);

samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;

samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;

samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;

samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;

samplerDesc.MipLODBias = 0.0f;

samplerDesc.MaxAnisotropy = 1;

samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;

samplerDesc.MinLOD = 0.0f;

samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;

result = ID3D11Device_CreateSamplerState(data->d3dDevice,

&samplerDesc,

&data->nearestPixelSampler

);

if (FAILED(result)) {

goto done;

}

samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;

result = ID3D11Device_CreateSamplerState(data->d3dDevice,

&samplerDesc,

&data->linearSampler

);

if (FAILED(result)) {

goto done;

}

/* Setup Direct3D rasterizer states */

SDL_zero(rasterDesc);

rasterDesc.AntialiasedLineEnable = FALSE;

rasterDesc.CullMode = D3D11_CULL_NONE;

rasterDesc.DepthBias = 0;

rasterDesc.DepthBiasClamp = 0.0f;

rasterDesc.DepthClipEnable = TRUE;

rasterDesc.FillMode = D3D11_FILL_SOLID;

rasterDesc.FrontCounterClockwise = FALSE;

rasterDesc.MultisampleEnable = FALSE;

rasterDesc.ScissorEnable = FALSE;

rasterDesc.SlopeScaledDepthBias = 0.0f;

result = ID3D11Device_CreateRasterizerState(data->d3dDevice, &rasterDesc, &data->mainRasterizer);

if (FAILED(result)) {

goto done;

}

rasterDesc.ScissorEnable = TRUE;

result = ID3D11Device_CreateRasterizerState(data->d3dDevice, &rasterDesc, &data->clippedRasterizer);

if (FAILED(result)) {

goto done;

}

/* Create blending states: */

if (!D3D11_CreateBlendState(renderer, SDL_BLENDMODE_BLEND) ||

!D3D11_CreateBlendState(renderer, SDL_BLENDMODE_ADD) ||

!D3D11_CreateBlendState(renderer, SDL_BLENDMODE_MOD)) {

/* D3D11_CreateBlendMode will set the SDL error, if it fails */

goto done;

}

/* Setup render state that doesn't change */

ID3D11DeviceContext_IASetInputLayout(data->d3dContext, data->inputLayout);

ID3D11DeviceContext_VSSetShader(data->d3dContext, data->vertexShader, NULL, 0);

ID3D11DeviceContext_VSSetConstantBuffers(data->d3dContext, 0, 1, &data->vertexShaderConstants);

done:

SAFE_RELEASE(d3dDevice);

SAFE_RELEASE(d3dContext);

SAFE_RELEASE(dxgiDevice);

return result;

}

#ifdef __WIN32__

static DXGI_MODE_ROTATION

D3D11_GetCurrentRotation()

{

/* FIXME */

return DXGI_MODE_ROTATION_IDENTITY;

}

#endif /* __WIN32__ */

static BOOL

D3D11_IsDisplayRotated90Degrees(DXGI_MODE_ROTATION rotation)

{

switch (rotation) {

case DXGI_MODE_ROTATION_ROTATE90:

case DXGI_MODE_ROTATION_ROTATE270:

return TRUE;

default:

return FALSE;

}

}

static int

D3D11_GetRotationForCurrentRenderTarget(SDL_Renderer * renderer)

{

D3D11_RenderData *data = (D3D11_RenderData *)renderer->driverdata;

if (data->currentOffscreenRenderTargetView) {

return DXGI_MODE_ROTATION_IDENTITY;

} else {

return data->rotation;

}

}

static int

D3D11_GetViewportAlignedD3DRect(SDL_Renderer * renderer, const SDL_Rect * sdlRect, D3D11_RECT * outRect, BOOL includeViewportOffset)

{

const int rotation = D3D11_GetRotationForCurrentRenderTarget(renderer);

switch (rotation) {

case DXGI_MODE_ROTATION_IDENTITY:

outRect->left = sdlRect->x;

outRect->right = sdlRect->x + sdlRect->w;

outRect->top = sdlRect->y;

outRect->bottom = sdlRect->y + sdlRect->h;

if (includeViewportOffset) {

outRect->left += renderer->viewport.x;

outRect->right += renderer->viewport.x;

outRect->top += renderer->viewport.y;

outRect->bottom += renderer->viewport.y;

}

break;

case DXGI_MODE_ROTATION_ROTATE270:

outRect->left = sdlRect->y;

outRect->right = sdlRect->y + sdlRect->h;

outRect->top = renderer->viewport.w - sdlRect->x - sdlRect->w;

outRect->bottom = renderer->viewport.w - sdlRect->x;

break;

case DXGI_MODE_ROTATION_ROTATE180:

outRect->left = renderer->viewport.w - sdlRect->x - sdlRect->w;

outRect->right = renderer->viewport.w - sdlRect->x;

outRect->top = renderer->viewport.h - sdlRect->y - sdlRect->h;

outRect->bottom = renderer->viewport.h - sdlRect->y;

break;

case DXGI_MODE_ROTATION_ROTATE90:

outRect->left = renderer->viewport.h - sdlRect->y - sdlRect->h;

outRect->right = renderer->viewport.h - sdlRect->y;

outRect->top = sdlRect->x;

outRect->bottom = sdlRect->x + sdlRect->h;

break;

default:

return SDL_SetError("The physical display is in an unknown or unsupported rotation");

}

return 0;

}

static HRESULT

D3D11_CreateSwapChain(SDL_Renderer * renderer, int w, int h)

{

D3D11_RenderData *data = (D3D11_RenderData *)renderer->driverdata;

#ifdef __WINRT__

IUnknown *coreWindow = D3D11_GetCoreWindowFromSDLRenderer(renderer);

const BOOL usingXAML = (coreWindow == NULL);

#else

IUnknown *coreWindow = NULL;

const BOOL usingXAML = FALSE;

#endif

HRESULT result = S_OK;

/* Create a swap chain using the same adapter as the existing Direct3D device. */

DXGI_SWAP_CHAIN_DESC1 swapChainDesc;

SDL_zero(swapChainDesc);

swapChainDesc.Width = w;

swapChainDesc.Height = h;

swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; /* This is the most common swap chain format. */

swapChainDesc.Stereo = FALSE;

swapChainDesc.SampleDesc.Count = 1; /* Don't use multi-sampling. */

swapChainDesc.SampleDesc.Quality = 0;

swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;

swapChainDesc.BufferCount = 2; /* Use double-buffering to minimize latency. */

#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP

swapChainDesc.Scaling = DXGI_SCALING_STRETCH; /* On phone, only stretch and aspect-ratio stretch scaling are allowed. */

swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; /* On phone, no swap effects are supported. */

/* TODO, WinRT: see if Win 8.x DXGI_SWAP_CHAIN_DESC1 settings are available on Windows Phone 8.1, and if there's any advantage to having them on */

#else

if (usingXAML) {

swapChainDesc.Scaling = DXGI_SCALING_STRETCH;

} else {

swapChainDesc.Scaling = DXGI_SCALING_NONE;

}

swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; /* All Windows Store apps must use this SwapEffect. */

#endif

swapChainDesc.Flags = 0;

if (coreWindow) {

result = IDXGIFactory2_CreateSwapChainForCoreWindow(data->dxgiFactory,

(IUnknown *)data->d3dDevice,

coreWindow,

&swapChainDesc,

NULL, /* Allow on all displays. */

&data->swapChain

);

if (FAILED(result)) {

goto done;

}

} else if (usingXAML) {

result = IDXGIFactory2_CreateSwapChainForComposition(data->dxgiFactory,

(IUnknown *)data->d3dDevice,

&swapChainDesc,

NULL,

&data->swapChain);

if (FAILED(result)) {

goto done;

}

#if WINAPI_FAMILY == WINAPI_FAMILY_APP

result = ISwapChainBackgroundPanelNative_SetSwapChain(WINRT_GlobalSwapChainBackgroundPanelNative, (IDXGISwapChain *) data->swapChain);

if (FAILED(result)) {

goto done;

}

#else

result = E_FAIL;

goto done;

#endif

} else {

#ifdef __WIN32__

SDL_SysWMinfo windowinfo;

SDL_VERSION(&windowinfo.version);

SDL_GetWindowWMInfo(renderer->window, &windowinfo);

result = IDXGIFactory2_CreateSwapChainForHwnd(data->dxgiFactory,

(IUnknown *)data->d3dDevice,

windowinfo.info.win.window,

&swapChainDesc,

NULL,

NULL, /* Allow on all displays. */

&data->swapChain

);

if (FAILED(result)) {

goto done;

}

IDXGIFactory_MakeWindowAssociation(data->dxgiFactory, windowinfo.info.win.window, DXGI_MWA_NO_WINDOW_CHANGES);

#else

SDL_SetError(__FUNCTION__", Unable to find something to attach a swap chain to");

goto done;

#endif /* ifdef __WIN32__ / else */

}

data->swapEffect = swapChainDesc.SwapEffect;

done:

SAFE_RELEASE(coreWindow);

return result;

}

/* Initialize all resources that change when the window's size changes. */

static HRESULT

D3D11_CreateWindowSizeDependentResources(SDL_Renderer * renderer)

{

D3D11_RenderData *data = (D3D11_RenderData *)renderer->driverdata;

ID3D11Texture2D *backBuffer = NULL;

HRESULT result = S_OK;

int w, h;

/* Release the previous render target view */

D3D11_ReleaseMainRenderTargetView(renderer);

/* The width and height of the swap chain must be based on the display's

* non-rotated size.

*/

SDL_GetWindowSize(renderer->window, &w, &h);

data->rotation = D3D11_GetCurrentRotation();

/* SDL_Log("%s: windowSize={%d,%d}, orientation=%d\n", __FUNCTION__, w, h, (int)data->rotation); */

if (D3D11_IsDisplayRotated90Degrees(data->rotation)) {

int tmp = w;

w = h;

h = tmp;

}

if (data->swapChain) {

/* IDXGISwapChain::ResizeBuffers is not available on Windows Phone 8. */

#if !defined(__WINRT__) || (WINAPI_FAMILY != WINAPI_FAMILY_PHONE_APP)

/* If the swap chain already exists, resize it. */

result = IDXGISwapChain_ResizeBuffers(data->swapChain,

0,

w, h,

DXGI_FORMAT_UNKNOWN,

0