21 #include "../../SDL_internal.h" 23 #if SDL_VIDEO_RENDER_D3D11 && !SDL_RENDER_DISABLED 26 #include "../../core/windows/SDL_windows.h" 30 #include "../SDL_sysrender.h" 31 #include "../SDL_d3dmath.h" 39 #if NTDDI_VERSION > NTDDI_WIN8 45 #if WINAPI_FAMILY == WINAPI_FAMILY_APP 46 #include <windows.ui.xaml.media.dxinterop.h> 54 #define SDL_COMPOSE_ERROR(str) SDL_STRINGIFY_ARG(__FUNCTION__) ", " str 56 #define SAFE_RELEASE(X) if ((X)) { IUnknown_Release(SDL_static_cast(IUnknown*, X)); X = NULL; } 66 Float4X4 projectionAndView;
67 } VertexShaderConstants;
75 } VertexPositionColor;
80 ID3D11Texture2D *mainTexture;
81 ID3D11ShaderResourceView *mainTextureResourceView;
82 ID3D11RenderTargetView *mainTextureRenderTargetView;
83 ID3D11Texture2D *stagingTexture;
84 int lockedTexturePositionX;
85 int lockedTexturePositionY;
86 D3D11_FILTER scaleMode;
90 ID3D11Texture2D *mainTextureU;
91 ID3D11ShaderResourceView *mainTextureResourceViewU;
92 ID3D11Texture2D *mainTextureV;
93 ID3D11ShaderResourceView *mainTextureResourceViewV;
97 ID3D11Texture2D *mainTextureNV;
98 ID3D11ShaderResourceView *mainTextureResourceViewNV;
109 ID3D11BlendState *blendState;
117 IDXGIFactory2 *dxgiFactory;
118 IDXGIAdapter *dxgiAdapter;
119 ID3D11Device1 *d3dDevice;
120 ID3D11DeviceContext1 *d3dContext;
121 IDXGISwapChain1 *swapChain;
122 DXGI_SWAP_EFFECT swapEffect;
123 ID3D11RenderTargetView *mainRenderTargetView;
124 ID3D11RenderTargetView *currentOffscreenRenderTargetView;
125 ID3D11InputLayout *inputLayout;
126 ID3D11Buffer *vertexBuffers[8];
127 size_t vertexBufferSizes[8];
128 ID3D11VertexShader *vertexShader;
131 D3D11_BlendMode *blendModes;
132 ID3D11SamplerState *nearestPixelSampler;
133 ID3D11SamplerState *linearSampler;
134 D3D_FEATURE_LEVEL featureLevel;
137 ID3D11RasterizerState *mainRasterizer;
138 ID3D11RasterizerState *clippedRasterizer;
141 VertexShaderConstants vertexShaderConstantsData;
142 ID3D11Buffer *vertexShaderConstants;
145 DXGI_MODE_ROTATION rotation;
146 ID3D11RenderTargetView *currentRenderTargetView;
147 ID3D11RasterizerState *currentRasterizerState;
148 ID3D11BlendState *currentBlendState;
149 ID3D11PixelShader *currentShader;
150 ID3D11ShaderResourceView *currentShaderResource;
151 ID3D11SamplerState *currentSampler;
156 int currentViewportRotation;
159 int currentVertexBuffer;
173 #pragma GCC diagnostic push 174 #pragma GCC diagnostic ignored "-Wunused-const-variable" 177 static const GUID SDL_IID_IDXGIFactory2 = { 0x50c83a1c, 0xe072, 0x4c48, { 0x87, 0xb0, 0x36, 0x30, 0xfa, 0x36, 0xa6, 0xd0 } };
178 static const GUID SDL_IID_IDXGIDevice1 = { 0x77db970f, 0x6276, 0x48ba, { 0xba, 0x28, 0x07, 0x01, 0x43, 0xb4, 0x39, 0x2c } };
179 static const GUID SDL_IID_IDXGIDevice3 = { 0x6007896c, 0x3244, 0x4afd, { 0xbf, 0x18, 0xa6, 0xd3, 0xbe, 0xda, 0x50, 0x23 } };
180 static const GUID SDL_IID_ID3D11Texture2D = { 0x6f15aaf2, 0xd208, 0x4e89, { 0x9a, 0xb4, 0x48, 0x95, 0x35, 0xd3, 0x4f, 0x9c } };
181 static const GUID SDL_IID_ID3D11Device1 = { 0xa04bfb29, 0x08ef, 0x43d6, { 0xa4, 0x9c, 0xa9, 0xbd, 0xbd, 0xcb, 0xe6, 0x86 } };
182 static const GUID SDL_IID_ID3D11DeviceContext1 = { 0xbb2c6faa, 0xb5fb, 0x4082, { 0x8e, 0x6b, 0x38, 0x8b, 0x8c, 0xfa, 0x90, 0xe1 } };
183 static const GUID SDL_IID_ID3D11Debug = { 0x79cf2233, 0x7536, 0x4948, { 0x9d, 0x36, 0x1e, 0x46, 0x92, 0xdc, 0x57, 0x60 } };
186 #pragma GCC diagnostic pop 192 D3D11_DXGIFormatToSDLPixelFormat(DXGI_FORMAT dxgiFormat)
194 switch (dxgiFormat) {
195 case DXGI_FORMAT_B8G8R8A8_UNORM:
197 case DXGI_FORMAT_B8G8R8X8_UNORM:
205 SDLPixelFormatToDXGIFormat(
Uint32 sdlFormat)
209 return DXGI_FORMAT_B8G8R8A8_UNORM;
211 return DXGI_FORMAT_B8G8R8X8_UNORM;
216 return DXGI_FORMAT_R8_UNORM;
218 return DXGI_FORMAT_UNKNOWN;
227 D3D11_RenderData *
data = (D3D11_RenderData *) renderer->
driverdata;
232 D3D11_DestroyTexture(renderer,
texture);
239 SAFE_RELEASE(data->dxgiFactory);
240 SAFE_RELEASE(data->dxgiAdapter);
241 SAFE_RELEASE(data->d3dDevice);
242 SAFE_RELEASE(data->d3dContext);
243 SAFE_RELEASE(data->swapChain);
244 SAFE_RELEASE(data->mainRenderTargetView);
245 SAFE_RELEASE(data->currentOffscreenRenderTargetView);
246 SAFE_RELEASE(data->inputLayout);
248 SAFE_RELEASE(data->vertexBuffers[i]);
250 SAFE_RELEASE(data->vertexShader);
252 SAFE_RELEASE(data->pixelShaders[i]);
254 if (data->blendModesCount > 0) {
255 for (i = 0; i < data->blendModesCount; ++
i) {
256 SAFE_RELEASE(data->blendModes[i].blendState);
260 data->blendModesCount = 0;
262 SAFE_RELEASE(data->nearestPixelSampler);
263 SAFE_RELEASE(data->linearSampler);
264 SAFE_RELEASE(data->mainRasterizer);
265 SAFE_RELEASE(data->clippedRasterizer);
266 SAFE_RELEASE(data->vertexShaderConstants);
268 data->swapEffect = (DXGI_SWAP_EFFECT) 0;
269 data->rotation = DXGI_MODE_ROTATION_UNSPECIFIED;
270 data->currentRenderTargetView =
NULL;
271 data->currentRasterizerState =
NULL;
272 data->currentBlendState =
NULL;
273 data->currentShader =
NULL;
274 data->currentShaderResource =
NULL;
275 data->currentSampler =
NULL;
280 if (data->hD3D11Mod) {
282 data->hD3D11Mod =
NULL;
284 if (data->hDXGIMod) {
286 data->hDXGIMod =
NULL;
294 D3D11_RenderData *data = (D3D11_RenderData *) renderer->
driverdata;
295 D3D11_ReleaseAll(renderer);
306 return D3D11_BLEND_ZERO;
308 return D3D11_BLEND_ONE;
310 return D3D11_BLEND_SRC_COLOR;
312 return D3D11_BLEND_INV_SRC_COLOR;
314 return D3D11_BLEND_SRC_ALPHA;
316 return D3D11_BLEND_INV_SRC_ALPHA;
318 return D3D11_BLEND_DEST_COLOR;
320 return D3D11_BLEND_INV_DEST_COLOR;
322 return D3D11_BLEND_DEST_ALPHA;
324 return D3D11_BLEND_INV_DEST_ALPHA;
326 return (D3D11_BLEND)0;
334 return D3D11_BLEND_OP_ADD;
336 return D3D11_BLEND_OP_SUBTRACT;
338 return D3D11_BLEND_OP_REV_SUBTRACT;
340 return D3D11_BLEND_OP_MIN;
342 return D3D11_BLEND_OP_MAX;
344 return (D3D11_BLEND_OP)0;
348 static ID3D11BlendState *
351 D3D11_RenderData *data = (D3D11_RenderData *) renderer->
driverdata;
358 ID3D11BlendState *blendState =
NULL;
359 D3D11_BlendMode *blendModes;
362 D3D11_BLEND_DESC blendDesc;
364 blendDesc.AlphaToCoverageEnable =
FALSE;
365 blendDesc.IndependentBlendEnable =
FALSE;
366 blendDesc.RenderTarget[0].BlendEnable =
TRUE;
367 blendDesc.RenderTarget[0].SrcBlend = GetBlendFunc(srcColorFactor);
368 blendDesc.RenderTarget[0].DestBlend = GetBlendFunc(dstColorFactor);
369 blendDesc.RenderTarget[0].BlendOp = GetBlendEquation(colorOperation);
370 blendDesc.RenderTarget[0].SrcBlendAlpha = GetBlendFunc(srcAlphaFactor);
371 blendDesc.RenderTarget[0].DestBlendAlpha = GetBlendFunc(dstAlphaFactor);
372 blendDesc.RenderTarget[0].BlendOpAlpha = GetBlendEquation(alphaOperation);
373 blendDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
374 result = ID3D11Device_CreateBlendState(data->d3dDevice, &blendDesc, &blendState);
380 blendModes = (D3D11_BlendMode *)
SDL_realloc(data->blendModes, (data->blendModesCount + 1) *
sizeof(*blendModes));
382 SAFE_RELEASE(blendState);
386 blendModes[data->blendModesCount].blendMode =
blendMode;
387 blendModes[data->blendModesCount].blendState = blendState;
388 data->blendModes = blendModes;
389 ++data->blendModesCount;
398 typedef HRESULT(WINAPI *PFN_CREATE_DXGI_FACTORY)(REFIID riid,
void **ppFactory);
399 PFN_CREATE_DXGI_FACTORY CreateDXGIFactoryFunc;
400 D3D11_RenderData *data = (D3D11_RenderData *) renderer->
driverdata;
401 PFN_D3D11_CREATE_DEVICE D3D11CreateDeviceFunc;
402 ID3D11Device *d3dDevice =
NULL;
403 ID3D11DeviceContext *d3dContext =
NULL;
404 IDXGIDevice1 *dxgiDevice =
NULL;
405 HRESULT result =
S_OK;
414 D3D_FEATURE_LEVEL featureLevels[] =
416 D3D_FEATURE_LEVEL_11_1,
417 D3D_FEATURE_LEVEL_11_0,
418 D3D_FEATURE_LEVEL_10_1,
419 D3D_FEATURE_LEVEL_10_0,
420 D3D_FEATURE_LEVEL_9_3,
421 D3D_FEATURE_LEVEL_9_2,
422 D3D_FEATURE_LEVEL_9_1
425 D3D11_BUFFER_DESC constantBufferDesc;
426 D3D11_SAMPLER_DESC samplerDesc;
427 D3D11_RASTERIZER_DESC rasterDesc;
430 CreateDXGIFactoryFunc = CreateDXGIFactory1;
431 D3D11CreateDeviceFunc = D3D11CreateDevice;
434 if (!data->hDXGIMod) {
439 CreateDXGIFactoryFunc = (PFN_CREATE_DXGI_FACTORY)
SDL_LoadFunction(data->hDXGIMod,
"CreateDXGIFactory");
440 if (!CreateDXGIFactoryFunc) {
446 if (!data->hD3D11Mod) {
451 D3D11CreateDeviceFunc = (PFN_D3D11_CREATE_DEVICE)
SDL_LoadFunction(data->hD3D11Mod,
"D3D11CreateDevice");
452 if (!D3D11CreateDeviceFunc) {
458 result = CreateDXGIFactoryFunc(&SDL_IID_IDXGIFactory2, (
void **)&data->dxgiFactory);
465 result = IDXGIFactory2_EnumAdapters(data->dxgiFactory, 0, &data->dxgiAdapter);
474 creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
478 creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
482 result = D3D11CreateDeviceFunc(
484 D3D_DRIVER_TYPE_UNKNOWN,
499 result = ID3D11Device_QueryInterface(d3dDevice, &SDL_IID_ID3D11Device1, (
void **)&data->d3dDevice);
505 result = ID3D11DeviceContext_QueryInterface(d3dContext, &SDL_IID_ID3D11DeviceContext1, (
void **)&data->d3dContext);
511 result = ID3D11Device_QueryInterface(d3dDevice, &SDL_IID_IDXGIDevice1, (
void **)&dxgiDevice);
520 result = IDXGIDevice1_SetMaximumFrameLatency(dxgiDevice, 1);
530 switch (data->featureLevel) {
531 case D3D_FEATURE_LEVEL_11_1:
532 case D3D_FEATURE_LEVEL_11_0:
536 case D3D_FEATURE_LEVEL_10_1:
537 case D3D_FEATURE_LEVEL_10_0:
541 case D3D_FEATURE_LEVEL_9_3:
545 case D3D_FEATURE_LEVEL_9_2:
546 case D3D_FEATURE_LEVEL_9_1:
551 SDL_SetError(
"%s, Unexpected feature level: %d", __FUNCTION__, data->featureLevel);
568 constantBufferDesc.ByteWidth =
sizeof(VertexShaderConstants);
569 constantBufferDesc.Usage = D3D11_USAGE_DEFAULT;
570 constantBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
571 result = ID3D11Device_CreateBuffer(data->d3dDevice,
574 &data->vertexShaderConstants
583 samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
584 samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
585 samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
586 samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
587 samplerDesc.MipLODBias = 0.0f;
588 samplerDesc.MaxAnisotropy = 1;
589 samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
590 samplerDesc.MinLOD = 0.0f;
591 samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
592 result = ID3D11Device_CreateSamplerState(data->d3dDevice,
594 &data->nearestPixelSampler
597 WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR(
"ID3D11Device1::CreateSamplerState [nearest-pixel filter]"), result);
601 samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
602 result = ID3D11Device_CreateSamplerState(data->d3dDevice,
613 rasterDesc.AntialiasedLineEnable =
FALSE;
614 rasterDesc.CullMode = D3D11_CULL_NONE;
615 rasterDesc.DepthBias = 0;
616 rasterDesc.DepthBiasClamp = 0.0f;
617 rasterDesc.DepthClipEnable =
TRUE;
618 rasterDesc.FillMode = D3D11_FILL_SOLID;
619 rasterDesc.FrontCounterClockwise =
FALSE;
620 rasterDesc.MultisampleEnable =
FALSE;
621 rasterDesc.ScissorEnable =
FALSE;
622 rasterDesc.SlopeScaledDepthBias = 0.0f;
623 result = ID3D11Device_CreateRasterizerState(data->d3dDevice, &rasterDesc, &data->mainRasterizer);
629 rasterDesc.ScissorEnable =
TRUE;
630 result = ID3D11Device_CreateRasterizerState(data->d3dDevice, &rasterDesc, &data->clippedRasterizer);
632 WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR(
"ID3D11Device1::CreateRasterizerState [clipped rasterizer]"), result);
645 ID3D11DeviceContext_IASetInputLayout(data->d3dContext, data->inputLayout);
646 ID3D11DeviceContext_VSSetShader(data->d3dContext, data->vertexShader,
NULL, 0);
647 ID3D11DeviceContext_VSSetConstantBuffers(data->d3dContext, 0, 1, &data->vertexShaderConstants);
650 SAFE_RELEASE(d3dDevice);
651 SAFE_RELEASE(d3dContext);
652 SAFE_RELEASE(dxgiDevice);
658 static DXGI_MODE_ROTATION
659 D3D11_GetCurrentRotation()
662 return DXGI_MODE_ROTATION_IDENTITY;
668 D3D11_IsDisplayRotated90Degrees(DXGI_MODE_ROTATION rotation)
671 case DXGI_MODE_ROTATION_ROTATE90:
672 case DXGI_MODE_ROTATION_ROTATE270:
680 D3D11_GetRotationForCurrentRenderTarget(
SDL_Renderer * renderer)
682 D3D11_RenderData *data = (D3D11_RenderData *)renderer->
driverdata;
683 if (data->currentOffscreenRenderTargetView) {
684 return DXGI_MODE_ROTATION_IDENTITY;
686 return data->rotation;
691 D3D11_GetViewportAlignedD3DRect(
SDL_Renderer * renderer,
const SDL_Rect * sdlRect, D3D11_RECT * outRect, BOOL includeViewportOffset)
693 const int rotation = D3D11_GetRotationForCurrentRenderTarget(renderer);
695 case DXGI_MODE_ROTATION_IDENTITY:
696 outRect->left = sdlRect->
x;
697 outRect->right = sdlRect->
x + sdlRect->
w;
698 outRect->top = sdlRect->
y;
699 outRect->bottom = sdlRect->
y + sdlRect->
h;
700 if (includeViewportOffset) {
707 case DXGI_MODE_ROTATION_ROTATE270:
708 outRect->left = sdlRect->
y;
709 outRect->right = sdlRect->
y + sdlRect->
h;
710 outRect->top = renderer->
viewport.
w - sdlRect->
x - sdlRect->
w;
711 outRect->bottom = renderer->
viewport.
w - sdlRect->
x;
713 case DXGI_MODE_ROTATION_ROTATE180:
714 outRect->left = renderer->
viewport.
w - sdlRect->
x - sdlRect->
w;
715 outRect->right = renderer->
viewport.
w - sdlRect->
x;
716 outRect->top = renderer->
viewport.
h - sdlRect->
y - sdlRect->
h;
717 outRect->bottom = renderer->
viewport.
h - sdlRect->
y;
719 case DXGI_MODE_ROTATION_ROTATE90:
720 outRect->left = renderer->
viewport.
h - sdlRect->
y - sdlRect->
h;
721 outRect->right = renderer->
viewport.
h - sdlRect->
y;
722 outRect->top = sdlRect->
x;
723 outRect->bottom = sdlRect->
x + sdlRect->
h;
726 return SDL_SetError(
"The physical display is in an unknown or unsupported rotation");
734 D3D11_RenderData *data = (D3D11_RenderData *)renderer->
driverdata;
736 IUnknown *coreWindow = D3D11_GetCoreWindowFromSDLRenderer(renderer);
737 const BOOL usingXAML = (coreWindow ==
NULL);
739 IUnknown *coreWindow =
NULL;
740 const BOOL usingXAML =
FALSE;
742 HRESULT result =
S_OK;
745 DXGI_SWAP_CHAIN_DESC1 swapChainDesc;
747 swapChainDesc.Width =
w;
748 swapChainDesc.Height =
h;
749 swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
750 swapChainDesc.Stereo =
FALSE;
751 swapChainDesc.SampleDesc.Count = 1;
752 swapChainDesc.SampleDesc.Quality = 0;
753 swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
754 swapChainDesc.BufferCount = 2;
755 #if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP 756 swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
757 swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
761 swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
763 swapChainDesc.Scaling = DXGI_SCALING_NONE;
765 swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
767 swapChainDesc.Flags = 0;
770 result = IDXGIFactory2_CreateSwapChainForCoreWindow(data->dxgiFactory,
771 (IUnknown *)data->d3dDevice,
781 }
else if (usingXAML) {
782 result = IDXGIFactory2_CreateSwapChainForComposition(data->dxgiFactory,
783 (IUnknown *)data->d3dDevice,
792 #if WINAPI_FAMILY == WINAPI_FAMILY_APP 799 SDL_SetError(SDL_COMPOSE_ERROR(
"XAML support is not yet available for Windows Phone"));
809 result = IDXGIFactory2_CreateSwapChainForHwnd(data->dxgiFactory,
810 (IUnknown *)data->d3dDevice,
822 IDXGIFactory_MakeWindowAssociation(data->dxgiFactory, windowinfo.
info.win.
window, DXGI_MWA_NO_WINDOW_CHANGES);
824 SDL_SetError(__FUNCTION__
", Unable to find something to attach a swap chain to");
828 data->swapEffect = swapChainDesc.SwapEffect;
831 SAFE_RELEASE(coreWindow);
836 D3D11_ReleaseMainRenderTargetView(
SDL_Renderer * renderer)
838 D3D11_RenderData *data = (D3D11_RenderData *)renderer->
driverdata;
839 ID3D11DeviceContext_OMSetRenderTargets(data->d3dContext, 0,
NULL,
NULL);
840 SAFE_RELEASE(data->mainRenderTargetView);
843 static HRESULT D3D11_UpdateForWindowSizeChange(
SDL_Renderer * renderer);
849 HRESULT result =
S_OK;
851 D3D11_ReleaseAll(renderer);
853 result = D3D11_CreateDeviceResources(renderer);
859 result = D3D11_UpdateForWindowSizeChange(renderer);
877 D3D11_CreateWindowSizeDependentResources(
SDL_Renderer * renderer)
879 D3D11_RenderData *data = (D3D11_RenderData *)renderer->
driverdata;
880 ID3D11Texture2D *backBuffer =
NULL;
881 HRESULT result =
S_OK;
885 D3D11_ReleaseMainRenderTargetView(renderer);
891 data->rotation = D3D11_GetCurrentRotation();
893 if (D3D11_IsDisplayRotated90Degrees(data->rotation)) {
899 if (data->swapChain) {
901 #if !defined(__WINRT__) || (WINAPI_FAMILY != WINAPI_FAMILY_PHONE_APP) 903 result = IDXGISwapChain_ResizeBuffers(data->swapChain,
909 if (result == DXGI_ERROR_DEVICE_REMOVED) {
911 D3D11_HandleDeviceLost(renderer);
917 }
else if (
FAILED(result)) {
923 result = D3D11_CreateSwapChain(renderer, w, h);
929 #if WINAPI_FAMILY != WINAPI_FAMILY_PHONE_APP 946 if (data->swapEffect == DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL) {
947 result = IDXGISwapChain1_SetRotation(data->swapChain, data->rotation);
955 result = IDXGISwapChain_GetBuffer(data->swapChain,
957 &SDL_IID_ID3D11Texture2D,
966 result = ID3D11Device_CreateRenderTargetView(data->d3dDevice,
967 (ID3D11Resource *)backBuffer,
969 &data->mainRenderTargetView
979 SAFE_RELEASE(backBuffer);
985 D3D11_UpdateForWindowSizeChange(
SDL_Renderer * renderer)
987 return D3D11_CreateWindowSizeDependentResources(renderer);
994 #if NTDDI_VERSION > NTDDI_WIN8 995 D3D11_RenderData *data = (D3D11_RenderData *)renderer->
driverdata;
996 HRESULT result =
S_OK;
997 IDXGIDevice3 *dxgiDevice =
NULL;
999 result = ID3D11Device_QueryInterface(data->d3dDevice, &SDL_IID_IDXGIDevice3, &dxgiDevice);
1005 IDXGIDevice3_Trim(dxgiDevice);
1006 SAFE_RELEASE(dxgiDevice);
1015 D3D11_UpdateForWindowSizeChange(renderer);
1029 if (!GetBlendFunc(srcColorFactor) || !GetBlendFunc(srcAlphaFactor) ||
1030 !GetBlendEquation(colorOperation) ||
1031 !GetBlendFunc(dstColorFactor) || !GetBlendFunc(dstAlphaFactor) ||
1032 !GetBlendEquation(alphaOperation)) {
1041 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
1042 D3D11_TextureData *textureData;
1044 DXGI_FORMAT textureFormat = SDLPixelFormatToDXGIFormat(texture->
format);
1045 D3D11_TEXTURE2D_DESC textureDesc;
1046 D3D11_SHADER_RESOURCE_VIEW_DESC resourceViewDesc;
1048 if (textureFormat == DXGI_FORMAT_UNKNOWN) {
1049 return SDL_SetError(
"%s, An unsupported SDL pixel format (0x%x) was specified",
1050 __FUNCTION__, texture->
format);
1053 textureData = (D3D11_TextureData*)
SDL_calloc(1,
sizeof(*textureData));
1063 textureDesc.Width = texture->
w;
1064 textureDesc.Height = texture->
h;
1065 textureDesc.MipLevels = 1;
1066 textureDesc.ArraySize = 1;
1067 textureDesc.Format = textureFormat;
1068 textureDesc.SampleDesc.Count = 1;
1069 textureDesc.SampleDesc.Quality = 0;
1070 textureDesc.MiscFlags = 0;
1073 textureDesc.Usage = D3D11_USAGE_DYNAMIC;
1074 textureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
1076 textureDesc.Usage = D3D11_USAGE_DEFAULT;
1077 textureDesc.CPUAccessFlags = 0;
1081 textureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET;
1083 textureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
1086 result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
1089 &textureData->mainTexture
1092 D3D11_DestroyTexture(renderer, texture);
1101 textureDesc.Width = (textureDesc.Width + 1) / 2;
1102 textureDesc.Height = (textureDesc.Height + 1) / 2;
1104 result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
1107 &textureData->mainTextureU
1110 D3D11_DestroyTexture(renderer, texture);
1115 result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
1118 &textureData->mainTextureV
1121 D3D11_DestroyTexture(renderer, texture);
1129 D3D11_TEXTURE2D_DESC nvTextureDesc = textureDesc;
1133 nvTextureDesc.Format = DXGI_FORMAT_R8G8_UNORM;
1134 nvTextureDesc.Width = (textureDesc.Width + 1) / 2;
1135 nvTextureDesc.Height = (textureDesc.Height + 1) / 2;
1137 result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
1140 &textureData->mainTextureNV
1143 D3D11_DestroyTexture(renderer, texture);
1149 resourceViewDesc.Format = textureDesc.Format;
1150 resourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
1151 resourceViewDesc.Texture2D.MostDetailedMip = 0;
1152 resourceViewDesc.Texture2D.MipLevels = textureDesc.MipLevels;
1153 result = ID3D11Device_CreateShaderResourceView(rendererData->d3dDevice,
1154 (ID3D11Resource *)textureData->mainTexture,
1156 &textureData->mainTextureResourceView
1159 D3D11_DestroyTexture(renderer, texture);
1164 if (textureData->yuv) {
1165 result = ID3D11Device_CreateShaderResourceView(rendererData->d3dDevice,
1166 (ID3D11Resource *)textureData->mainTextureU,
1168 &textureData->mainTextureResourceViewU
1171 D3D11_DestroyTexture(renderer, texture);
1175 result = ID3D11Device_CreateShaderResourceView(rendererData->d3dDevice,
1176 (ID3D11Resource *)textureData->mainTextureV,
1178 &textureData->mainTextureResourceViewV
1181 D3D11_DestroyTexture(renderer, texture);
1187 if (textureData->nv12) {
1188 D3D11_SHADER_RESOURCE_VIEW_DESC nvResourceViewDesc = resourceViewDesc;
1190 nvResourceViewDesc.Format = DXGI_FORMAT_R8G8_UNORM;
1192 result = ID3D11Device_CreateShaderResourceView(rendererData->d3dDevice,
1193 (ID3D11Resource *)textureData->mainTextureNV,
1194 &nvResourceViewDesc,
1195 &textureData->mainTextureResourceViewNV
1198 D3D11_DestroyTexture(renderer, texture);
1205 D3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDesc;
1206 renderTargetViewDesc.Format = textureDesc.Format;
1207 renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
1208 renderTargetViewDesc.Texture2D.MipSlice = 0;
1210 result = ID3D11Device_CreateRenderTargetView(rendererData->d3dDevice,
1211 (ID3D11Resource *)textureData->mainTexture,
1212 &renderTargetViewDesc,
1213 &textureData->mainTextureRenderTargetView);
1215 D3D11_DestroyTexture(renderer, texture);
1228 D3D11_TextureData *data = (D3D11_TextureData *)texture->
driverdata;
1234 SAFE_RELEASE(data->mainTexture);
1235 SAFE_RELEASE(data->mainTextureResourceView);
1236 SAFE_RELEASE(data->mainTextureRenderTargetView);
1237 SAFE_RELEASE(data->stagingTexture);
1238 SAFE_RELEASE(data->mainTextureU);
1239 SAFE_RELEASE(data->mainTextureResourceViewU);
1240 SAFE_RELEASE(data->mainTextureV);
1241 SAFE_RELEASE(data->mainTextureResourceViewV);
1248 D3D11_UpdateTextureInternal(D3D11_RenderData *rendererData, ID3D11Texture2D *texture,
int bpp,
int x,
int y,
int w,
int h,
const void *
pixels,
int pitch)
1250 ID3D11Texture2D *stagingTexture;
1256 D3D11_TEXTURE2D_DESC stagingTextureDesc;
1257 D3D11_MAPPED_SUBRESOURCE textureMemory;
1260 ID3D11Texture2D_GetDesc(texture, &stagingTextureDesc);
1261 stagingTextureDesc.Width =
w;
1262 stagingTextureDesc.Height =
h;
1263 stagingTextureDesc.BindFlags = 0;
1264 stagingTextureDesc.MiscFlags = 0;
1265 stagingTextureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
1266 stagingTextureDesc.Usage = D3D11_USAGE_STAGING;
1267 result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
1268 &stagingTextureDesc,
1272 WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR(
"ID3D11Device1::CreateTexture2D [create staging texture]"), result);
1277 result = ID3D11DeviceContext_Map(rendererData->d3dContext,
1278 (ID3D11Resource *)stagingTexture,
1286 SAFE_RELEASE(stagingTexture);
1290 src = (
const Uint8 *)pixels;
1291 dst = textureMemory.pData;
1293 if (length == pitch && length == textureMemory.RowPitch) {
1296 if (length > (UINT)pitch) {
1299 if (length > textureMemory.RowPitch) {
1300 length = textureMemory.RowPitch;
1302 for (row = 0; row <
h; ++
row) {
1305 dst += textureMemory.RowPitch;
1310 ID3D11DeviceContext_Unmap(rendererData->d3dContext,
1311 (ID3D11Resource *)stagingTexture,
1315 ID3D11DeviceContext_CopySubresourceRegion(rendererData->d3dContext,
1316 (ID3D11Resource *)texture,
1321 (ID3D11Resource *)stagingTexture,
1325 SAFE_RELEASE(stagingTexture);
1335 D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->
driverdata;
1336 D3D11_TextureData *textureData = (D3D11_TextureData *)texture->
driverdata;
1343 if (D3D11_UpdateTextureInternal(rendererData, textureData->mainTexture,
SDL_BYTESPERPIXEL(texture->
format), rect->
x, rect->
y, rect->
w, rect->
h, srcPixels, srcPitch) < 0) {
1347 if (textureData->yuv) {
1349 srcPixels = (
const void*)((
const Uint8*)srcPixels + rect->
h * srcPitch);
1351 if (D3D11_UpdateTextureInternal(rendererData, texture->
format ==
SDL_PIXELFORMAT_YV12 ? textureData->mainTextureV : textureData->mainTextureU,
SDL_BYTESPERPIXEL(texture->
format), rect->
x / 2, rect->
y / 2, (rect->
w + 1) / 2, (rect->
h + 1) / 2, srcPixels, (srcPitch + 1) / 2) < 0) {
1356 srcPixels = (
const void*)((
const Uint8*)srcPixels + ((rect->
h + 1) / 2) * ((srcPitch + 1) / 2));
1357 if (D3D11_UpdateTextureInternal(rendererData, texture->
format ==
SDL_PIXELFORMAT_YV12 ? textureData->mainTextureU : textureData->mainTextureV,
SDL_BYTESPERPIXEL(texture->
format), rect->
x / 2, rect->
y / 2, (rect->
w + 1) / 2, (rect->
h + 1) / 2, srcPixels, (srcPitch + 1) / 2) < 0) {
1362 if (textureData->nv12) {
1364 srcPixels = (
const void*)((
const Uint8*)srcPixels + rect->
h * srcPitch);
1366 if (D3D11_UpdateTextureInternal(rendererData, textureData->mainTextureNV, 2, rect->
x / 2, rect->
y / 2, ((rect->
w + 1) / 2), (rect->
h + 1) / 2, srcPixels, 2*((srcPitch + 1) / 2)) < 0) {
1376 const Uint8 *Yplane,
int Ypitch,
1377 const Uint8 *Uplane,
int Upitch,
1378 const Uint8 *Vplane,
int Vpitch)
1380 D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->
driverdata;
1381 D3D11_TextureData *textureData = (D3D11_TextureData *)texture->
driverdata;
1388 if (D3D11_UpdateTextureInternal(rendererData, textureData->mainTexture,
SDL_BYTESPERPIXEL(texture->
format), rect->
x, rect->
y, rect->
w, rect->
h, Yplane, Ypitch) < 0) {
1391 if (D3D11_UpdateTextureInternal(rendererData, textureData->mainTextureU,
SDL_BYTESPERPIXEL(texture->
format), rect->
x / 2, rect->
y / 2, rect->
w / 2, rect->
h / 2, Uplane, Upitch) < 0) {
1394 if (D3D11_UpdateTextureInternal(rendererData, textureData->mainTextureV,
SDL_BYTESPERPIXEL(texture->
format), rect->
x / 2, rect->
y / 2, rect->
w / 2, rect->
h / 2, Vplane, Vpitch) < 0) {
1402 const SDL_Rect * rect,
void **pixels,
int *pitch)
1404 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
1405 D3D11_TextureData *textureData = (D3D11_TextureData *) texture->
driverdata;
1406 HRESULT result =
S_OK;
1407 D3D11_TEXTURE2D_DESC stagingTextureDesc;
1408 D3D11_MAPPED_SUBRESOURCE textureMemory;
1415 if (textureData->yuv || textureData->nv12) {
1417 if (!textureData->pixels) {
1418 textureData->pitch = texture->
w;
1419 textureData->pixels = (
Uint8 *)
SDL_malloc((texture->
h * textureData->pitch * 3) / 2);
1420 if (!textureData->pixels) {
1424 textureData->locked_rect = *
rect;
1426 (
void *)((
Uint8 *)textureData->pixels + rect->
y * textureData->pitch +
1428 *pitch = textureData->pitch;
1432 if (textureData->stagingTexture) {
1444 ID3D11Texture2D_GetDesc(textureData->mainTexture, &stagingTextureDesc);
1445 stagingTextureDesc.Width = rect->
w;
1446 stagingTextureDesc.Height = rect->
h;
1447 stagingTextureDesc.BindFlags = 0;
1448 stagingTextureDesc.MiscFlags = 0;
1449 stagingTextureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
1450 stagingTextureDesc.Usage = D3D11_USAGE_STAGING;
1451 result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
1452 &stagingTextureDesc,
1454 &textureData->stagingTexture);
1456 WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR(
"ID3D11Device1::CreateTexture2D [create staging texture]"), result);
1461 result = ID3D11DeviceContext_Map(rendererData->d3dContext,
1462 (ID3D11Resource *)textureData->stagingTexture,
1470 SAFE_RELEASE(textureData->stagingTexture);
1477 textureData->lockedTexturePositionX = rect->
x;
1478 textureData->lockedTexturePositionY = rect->
y;
1483 *pixels = textureMemory.pData;
1484 *pitch = textureMemory.RowPitch;
1491 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
1492 D3D11_TextureData *textureData = (D3D11_TextureData *) texture->
driverdata;
1498 if (textureData->yuv || textureData->nv12) {
1499 const SDL_Rect *rect = &textureData->locked_rect;
1501 (
void *) ((
Uint8 *) textureData->pixels + rect->
y * textureData->pitch +
1503 D3D11_UpdateTexture(renderer, texture, rect, pixels, textureData->pitch);
1508 ID3D11DeviceContext_Unmap(rendererData->d3dContext,
1509 (ID3D11Resource *)textureData->stagingTexture,
1513 ID3D11DeviceContext_CopySubresourceRegion(rendererData->d3dContext,
1514 (ID3D11Resource *)textureData->mainTexture,
1516 textureData->lockedTexturePositionX,
1517 textureData->lockedTexturePositionY,
1519 (ID3D11Resource *)textureData->stagingTexture,
1523 SAFE_RELEASE(textureData->stagingTexture);
1529 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
1530 D3D11_TextureData *textureData =
NULL;
1532 if (texture ==
NULL) {
1533 rendererData->currentOffscreenRenderTargetView =
NULL;
1537 textureData = (D3D11_TextureData *) texture->
driverdata;
1539 if (!textureData->mainTextureRenderTargetView) {
1540 return SDL_SetError(
"specified texture is not a render target");
1543 rendererData->currentOffscreenRenderTargetView = textureData->mainTextureRenderTargetView;
1558 const float r = (float)(cmd->
data.
draw.r / 255.0f);
1559 const float g = (float)(cmd->
data.
draw.g / 255.0f);
1560 const float b = (float)(cmd->
data.
draw.b / 255.0f);
1561 const float a = (float)(cmd->
data.
draw.a / 255.0f);
1570 for (i = 0; i <
count; i++) {
1571 verts->pos.x = points[
i].
x + 0.5f;
1572 verts->pos.y = points[
i].
y + 0.5f;
1573 verts->pos.z = 0.0f;
1574 verts->tex.x = 0.0f;
1575 verts->tex.y = 0.0f;
1590 const float r = (float)(cmd->
data.
draw.r / 255.0f);
1591 const float g = (float)(cmd->
data.
draw.g / 255.0f);
1592 const float b = (float)(cmd->
data.
draw.b / 255.0f);
1593 const float a = (float)(cmd->
data.
draw.a / 255.0f);
1602 for (i = 0; i <
count; i++) {
1603 verts->pos.x = rects[
i].
x;
1604 verts->pos.y = rects[
i].
y;
1605 verts->pos.z = 0.0f;
1606 verts->tex.x = 0.0f;
1607 verts->tex.y = 0.0f;
1614 verts->pos.x = rects[
i].
x;
1615 verts->pos.y = rects[
i].
y + rects[
i].
h;
1616 verts->pos.z = 0.0f;
1617 verts->tex.x = 0.0f;
1618 verts->tex.y = 0.0f;
1625 verts->pos.x = rects[
i].
x + rects[
i].
w;
1626 verts->pos.y = rects[
i].
y;
1627 verts->pos.z = 0.0f;
1628 verts->tex.x = 0.0f;
1629 verts->tex.y = 0.0f;
1636 verts->pos.x = rects[
i].
x + rects[
i].
w;
1637 verts->pos.y = rects[
i].
y + rects[
i].
h;
1638 verts->pos.z = 0.0f;
1639 verts->tex.x = 0.0f;
1640 verts->tex.y = 0.0f;
1656 const float r = (float)(cmd->
data.
draw.r / 255.0f);
1657 const float g = (float)(cmd->
data.
draw.g / 255.0f);
1658 const float b = (float)(cmd->
data.
draw.b / 255.0f);
1659 const float a = (float)(cmd->
data.
draw.a / 255.0f);
1660 const float minu = (float) srcrect->
x / texture->
w;
1661 const float maxu = (
float) (srcrect->
x + srcrect->
w) / texture->
w;
1662 const float minv = (
float) srcrect->
y / texture->
h;
1663 const float maxv = (float) (srcrect->
y + srcrect->
h) / texture->
h;
1671 verts->pos.x = dstrect->
x;
1672 verts->pos.y = dstrect->
y;
1673 verts->pos.z = 0.0f;
1674 verts->tex.x = minu;
1675 verts->tex.y = minv;
1682 verts->pos.x = dstrect->
x;
1683 verts->pos.y = dstrect->
y + dstrect->
h;
1684 verts->pos.z = 0.0f;
1685 verts->tex.x = minu;
1686 verts->tex.y = maxv;
1693 verts->pos.x = dstrect->
x + dstrect->
w;
1694 verts->pos.y = dstrect->
y;
1695 verts->pos.z = 0.0f;
1696 verts->tex.x = maxu;
1697 verts->tex.y = minv;
1704 verts->pos.x = dstrect->
x + dstrect->
w;
1705 verts->pos.y = dstrect->
y + dstrect->
h;
1706 verts->pos.z = 0.0f;
1707 verts->tex.x = maxu;
1708 verts->tex.y = maxv;
1724 const float r = (float)(cmd->
data.
draw.r / 255.0f);
1725 const float g = (float)(cmd->
data.
draw.g / 255.0f);
1726 const float b = (float)(cmd->
data.
draw.b / 255.0f);
1727 const float a = (float)(cmd->
data.
draw.a / 255.0f);
1728 float minx, miny, maxx, maxy;
1729 float minu, maxu, minv, maxv;
1732 minu = (float) srcrect->
x / texture->
w;
1733 maxu = (
float) (srcrect->
x + srcrect->
w) / texture->
w;
1735 minu = (float) (srcrect->
x + srcrect->
w) / texture->
w;
1736 maxu = (float) srcrect->
x / texture->
w;
1740 minv = (float) srcrect->
y / texture->
h;
1741 maxv = (
float) (srcrect->
y + srcrect->
h) / texture->
h;
1743 minv = (float) (srcrect->
y + srcrect->
h) / texture->
h;
1744 maxv = (float) srcrect->
y / texture->
h;
1748 maxx = dstrect->
w - center->
x;
1750 maxy = dstrect->
h - center->
y;
1754 verts->pos.x = minx;
1755 verts->pos.y = miny;
1756 verts->pos.z = 0.0f;
1757 verts->tex.x = minu;
1758 verts->tex.y = minv;
1765 verts->pos.x = minx;
1766 verts->pos.y = maxy;
1767 verts->pos.z = 0.0f;
1768 verts->tex.x = minu;
1769 verts->tex.y = maxv;
1776 verts->pos.x = maxx;
1777 verts->pos.y = miny;
1778 verts->pos.z = 0.0f;
1779 verts->tex.x = maxu;
1780 verts->tex.y = minv;
1787 verts->pos.x = maxx;
1788 verts->pos.y = maxy;
1789 verts->pos.z = 0.0f;
1790 verts->tex.x = maxu;
1791 verts->tex.y = maxv;
1798 verts->pos.x = dstrect->
x + center->
x;
1799 verts->pos.y = dstrect->
y + center->
y;
1800 verts->pos.z = (float)(M_PI * (
float) angle / 180.0f);
1801 verts->tex.x = 0.0f;
1802 verts->tex.y = 0.0f;
1815 const void * vertexData,
size_t dataSizeInBytes)
1817 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
1818 HRESULT result =
S_OK;
1819 const int vbidx = rendererData->currentVertexBuffer;
1821 if (rendererData->vertexBuffers[vbidx] && rendererData->vertexBufferSizes[vbidx] >= dataSizeInBytes) {
1822 D3D11_MAPPED_SUBRESOURCE mappedResource;
1823 result = ID3D11DeviceContext_Map(rendererData->d3dContext,
1824 (ID3D11Resource *)rendererData->vertexBuffers[vbidx],
1826 D3D11_MAP_WRITE_DISCARD,
1834 SDL_memcpy(mappedResource.pData, vertexData, dataSizeInBytes);
1835 ID3D11DeviceContext_Unmap(rendererData->d3dContext, (ID3D11Resource *)rendererData->vertexBuffers[vbidx], 0);
1837 D3D11_BUFFER_DESC vertexBufferDesc;
1838 D3D11_SUBRESOURCE_DATA vertexBufferData;
1839 const UINT
stride =
sizeof(VertexPositionColor);
1842 SAFE_RELEASE(rendererData->vertexBuffers[vbidx]);
1845 vertexBufferDesc.ByteWidth = (UINT) dataSizeInBytes;
1846 vertexBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
1847 vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
1848 vertexBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
1851 vertexBufferData.pSysMem = vertexData;
1852 vertexBufferData.SysMemPitch = 0;
1853 vertexBufferData.SysMemSlicePitch = 0;
1855 result = ID3D11Device_CreateBuffer(rendererData->d3dDevice,
1858 &rendererData->vertexBuffers[vbidx]
1865 ID3D11DeviceContext_IASetVertexBuffers(rendererData->d3dContext,
1868 &rendererData->vertexBuffers[vbidx],
1874 rendererData->currentVertexBuffer++;
1875 if (rendererData->currentVertexBuffer >=
SDL_arraysize(rendererData->vertexBuffers)) {
1876 rendererData->currentVertexBuffer = 0;
1885 D3D11_RenderData *data = (D3D11_RenderData *) renderer->
driverdata;
1887 Float4X4 projection;
1890 BOOL swapDimensions;
1891 D3D11_VIEWPORT d3dviewport;
1892 const int rotation = D3D11_GetRotationForCurrentRenderTarget(renderer);
1909 case DXGI_MODE_ROTATION_IDENTITY:
1910 projection = MatrixIdentity();
1912 case DXGI_MODE_ROTATION_ROTATE270:
1915 case DXGI_MODE_ROTATION_ROTATE180:
1918 case DXGI_MODE_ROTATION_ROTATE90:
1922 return SDL_SetError(
"An unknown DisplayOrientation is being used");
1929 view.m[2][2] = 1.0f;
1930 view.m[3][0] = -1.0f;
1931 view.m[3][1] = 1.0f;
1932 view.m[3][3] = 1.0f;
1938 data->vertexShaderConstantsData.projectionAndView = MatrixMultiply(
1947 swapDimensions = D3D11_IsDisplayRotated90Degrees(rotation);
1948 if (swapDimensions) {
1949 orientationAlignedViewport.x = (float)
viewport->
y;
1950 orientationAlignedViewport.y = (
float)
viewport->
x;
1951 orientationAlignedViewport.w = (float)
viewport->
h;
1952 orientationAlignedViewport.h = (
float)
viewport->
w;
1954 orientationAlignedViewport.x = (float)
viewport->
x;
1955 orientationAlignedViewport.y = (
float)
viewport->
y;
1956 orientationAlignedViewport.w = (float)
viewport->
w;
1957 orientationAlignedViewport.h = (
float)
viewport->
h;
1961 d3dviewport.TopLeftX = orientationAlignedViewport.x;
1962 d3dviewport.TopLeftY = orientationAlignedViewport.y;
1963 d3dviewport.Width = orientationAlignedViewport.w;
1964 d3dviewport.Height = orientationAlignedViewport.h;
1965 d3dviewport.MinDepth = 0.0f;
1966 d3dviewport.MaxDepth = 1.0f;
1968 ID3D11DeviceContext_RSSetViewports(data->d3dContext, 1, &d3dviewport);
1975 static ID3D11RenderTargetView *
1976 D3D11_GetCurrentRenderTargetView(
SDL_Renderer * renderer)
1978 D3D11_RenderData *data = (D3D11_RenderData *)renderer->
driverdata;
1979 if (data->currentOffscreenRenderTargetView) {
1980 return data->currentOffscreenRenderTargetView;
1983 return data->mainRenderTargetView;
1989 const int numShaderResources, ID3D11ShaderResourceView ** shaderResources,
1993 D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->
driverdata;
1994 const Float4X4 *newmatrix = matrix ? matrix : &rendererData->identity;
1995 ID3D11RasterizerState *rasterizerState;
1996 ID3D11RenderTargetView *renderTargetView = D3D11_GetCurrentRenderTargetView(renderer);
1997 ID3D11ShaderResourceView *shaderResource;
1999 ID3D11BlendState *blendState =
NULL;
2002 if (renderTargetView != rendererData->currentRenderTargetView) {
2003 ID3D11DeviceContext_OMSetRenderTargets(rendererData->d3dContext,
2008 rendererData->currentRenderTargetView = renderTargetView;
2011 if (rendererData->viewportDirty) {
2012 if (D3D11_UpdateViewport(renderer) == 0) {
2018 if (rendererData->cliprectDirty) {
2019 if (!rendererData->currentCliprectEnabled) {
2020 ID3D11DeviceContext_RSSetScissorRects(rendererData->d3dContext, 0,
NULL);
2022 D3D11_RECT scissorRect;
2023 if (D3D11_GetViewportAlignedD3DRect(renderer, &rendererData->currentCliprect, &scissorRect,
TRUE) != 0) {
2027 ID3D11DeviceContext_RSSetScissorRects(rendererData->d3dContext, 1, &scissorRect);
2029 rendererData->cliprectDirty =
SDL_FALSE;
2032 if (!rendererData->currentCliprectEnabled) {
2033 rasterizerState = rendererData->mainRasterizer;
2035 rasterizerState = rendererData->clippedRasterizer;
2037 if (rasterizerState != rendererData->currentRasterizerState) {
2038 ID3D11DeviceContext_RSSetState(rendererData->d3dContext, rasterizerState);
2039 rendererData->currentRasterizerState = rasterizerState;
2044 for (i = 0; i < rendererData->blendModesCount; ++
i) {
2045 if (blendMode == rendererData->blendModes[i].blendMode) {
2046 blendState = rendererData->blendModes[
i].blendState;
2051 blendState = D3D11_CreateBlendState(renderer, blendMode);
2057 if (blendState != rendererData->currentBlendState) {
2058 ID3D11DeviceContext_OMSetBlendState(rendererData->d3dContext, blendState, 0, 0xFFFFFFFF);
2059 rendererData->currentBlendState = blendState;
2062 if (shader != rendererData->currentShader) {
2063 ID3D11DeviceContext_PSSetShader(rendererData->d3dContext, shader,
NULL, 0);
2064 rendererData->currentShader =
shader;
2066 if (numShaderResources > 0) {
2067 shaderResource = shaderResources[0];
2069 shaderResource =
NULL;
2071 if (shaderResource != rendererData->currentShaderResource) {
2072 ID3D11DeviceContext_PSSetShaderResources(rendererData->d3dContext, 0, numShaderResources, shaderResources);
2073 rendererData->currentShaderResource = shaderResource;
2075 if (sampler != rendererData->currentSampler) {
2076 ID3D11DeviceContext_PSSetSamplers(rendererData->d3dContext, 0, 1, &sampler);
2077 rendererData->currentSampler =
sampler;
2080 if (updateSubresource ==
SDL_TRUE ||
SDL_memcmp(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof (*newmatrix)) != 0) {
2081 SDL_memcpy(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof (*newmatrix));
2082 ID3D11DeviceContext_UpdateSubresource(rendererData->d3dContext,
2083 (ID3D11Resource *)rendererData->vertexShaderConstants,
2086 &rendererData->vertexShaderConstantsData,
2099 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
2100 D3D11_TextureData *textureData = (D3D11_TextureData *) texture->
driverdata;
2101 ID3D11SamplerState *textureSampler;
2103 switch (textureData->scaleMode) {
2104 case D3D11_FILTER_MIN_MAG_MIP_POINT:
2105 textureSampler = rendererData->nearestPixelSampler;
2107 case D3D11_FILTER_MIN_MAG_MIP_LINEAR:
2108 textureSampler = rendererData->linearSampler;
2111 return SDL_SetError(
"Unknown scale mode: %d\n", textureData->scaleMode);
2114 if (textureData->yuv) {
2115 ID3D11ShaderResourceView *shaderResources[] = {
2116 textureData->mainTextureResourceView,
2117 textureData->mainTextureResourceViewU,
2118 textureData->mainTextureResourceViewV
2133 return SDL_SetError(
"Unsupported YUV conversion mode");
2136 return D3D11_SetDrawState(renderer, cmd, rendererData->pixelShaders[shader],
2137 SDL_arraysize(shaderResources), shaderResources, textureSampler, matrix);
2139 }
else if (textureData->nv12) {
2140 ID3D11ShaderResourceView *shaderResources[] = {
2141 textureData->mainTextureResourceView,
2142 textureData->mainTextureResourceViewNV,
2157 return SDL_SetError(
"Unsupported YUV conversion mode");
2160 return D3D11_SetDrawState(renderer, cmd, rendererData->pixelShaders[shader],
2161 SDL_arraysize(shaderResources), shaderResources, textureSampler, matrix);
2165 return D3D11_SetDrawState(renderer, cmd, rendererData->pixelShaders[
SHADER_RGB],
2166 1, &textureData->mainTextureResourceView, textureSampler, matrix);
2170 D3D11_DrawPrimitives(
SDL_Renderer * renderer, D3D11_PRIMITIVE_TOPOLOGY primitiveTopology,
const size_t vertexStart,
const size_t vertexCount)
2172 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
2173 ID3D11DeviceContext_IASetPrimitiveTopology(rendererData->d3dContext, primitiveTopology);
2174 ID3D11DeviceContext_Draw(rendererData->d3dContext, (UINT) vertexCount, (UINT) vertexStart);
2180 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
2181 const int viewportRotation = D3D11_GetRotationForCurrentRenderTarget(renderer);
2184 if (rendererData->currentViewportRotation != viewportRotation) {
2185 rendererData->currentViewportRotation = viewportRotation;
2186 rendererData->viewportDirty =
SDL_TRUE;
2189 if (D3D11_UpdateVertexBuffer(renderer, vertices, vertsize) < 0) {
2203 rendererData->viewportDirty =
SDL_TRUE;
2210 if (rendererData->currentCliprectEnabled != cmd->
data.
cliprect.enabled) {
2211 rendererData->currentCliprectEnabled = cmd->
data.
cliprect.enabled;
2212 rendererData->cliprectDirty =
SDL_TRUE;
2216 rendererData->cliprectDirty =
SDL_TRUE;
2222 const float colorRGBA[] = {
2228 ID3D11DeviceContext_ClearRenderTargetView(rendererData->d3dContext, D3D11_GetCurrentRenderTargetView(renderer), colorRGBA);
2233 const size_t count = cmd->
data.
draw.count;
2235 const size_t start = first /
sizeof (VertexPositionColor);
2237 D3D11_DrawPrimitives(renderer, D3D11_PRIMITIVE_TOPOLOGY_POINTLIST, start, count);
2242 const size_t count = cmd->
data.
draw.count;
2244 const size_t start = first /
sizeof (VertexPositionColor);
2245 const VertexPositionColor *verts = (VertexPositionColor *) (((
Uint8 *) vertices) + first);
2247 D3D11_DrawPrimitives(renderer, D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP, start, count);
2248 if (verts[0].pos.x != verts[count - 1].pos.x || verts[0].pos.y != verts[count - 1].pos.y) {
2249 D3D11_DrawPrimitives(renderer, D3D11_PRIMITIVE_TOPOLOGY_POINTLIST, start + (count-1), 1);
2255 const size_t count = cmd->
data.
draw.count;
2256 const size_t first = cmd->
data.
draw.first;
2257 const size_t start = first /
sizeof (VertexPositionColor);
2260 for (i = 0; i <
count; i++, offset += 4) {
2261 D3D11_DrawPrimitives(renderer, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, start + offset, 4);
2267 const size_t first = cmd->
data.
draw.first;
2268 const size_t start = first /
sizeof (VertexPositionColor);
2269 D3D11_SetCopyState(renderer, cmd,
NULL);
2270 D3D11_DrawPrimitives(renderer, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, start, 4);
2275 const size_t first = cmd->
data.
draw.first;
2276 const size_t start = first /
sizeof (VertexPositionColor);
2277 const VertexPositionColor *verts = (VertexPositionColor *) (((
Uint8 *) vertices) + first);
2278 const VertexPositionColor *transvert = verts + 4;
2279 const float translatex = transvert->pos.x;
2280 const float translatey = transvert->pos.y;
2281 const float rotation = transvert->pos.z;
2282 const Float4X4 matrix = MatrixMultiply(MatrixRotationZ(rotation), MatrixTranslation(translatex, translatey, 0));
2283 D3D11_SetCopyState(renderer, cmd, &matrix);
2284 D3D11_DrawPrimitives(renderer, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, start, 4);
2302 D3D11_RenderData * data = (D3D11_RenderData *) renderer->
driverdata;
2303 ID3D11Texture2D *backBuffer =
NULL;
2304 ID3D11Texture2D *stagingTexture =
NULL;
2307 D3D11_TEXTURE2D_DESC stagingTextureDesc;
2308 D3D11_RECT srcRect = {0, 0, 0, 0};
2310 D3D11_MAPPED_SUBRESOURCE textureMemory;
2313 result = IDXGISwapChain_GetBuffer(data->swapChain,
2315 &SDL_IID_ID3D11Texture2D,
2316 (
void **)&backBuffer
2324 ID3D11Texture2D_GetDesc(backBuffer, &stagingTextureDesc);
2325 stagingTextureDesc.Width = rect->
w;
2326 stagingTextureDesc.Height = rect->
h;
2327 stagingTextureDesc.BindFlags = 0;
2328 stagingTextureDesc.MiscFlags = 0;
2329 stagingTextureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
2330 stagingTextureDesc.Usage = D3D11_USAGE_STAGING;
2331 result = ID3D11Device_CreateTexture2D(data->d3dDevice,
2332 &stagingTextureDesc,
2336 WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR(
"ID3D11Device1::CreateTexture2D [create staging texture]"), result);
2341 if (D3D11_GetViewportAlignedD3DRect(renderer, rect, &srcRect,
FALSE) != 0) {
2346 srcBox.left = srcRect.left;
2347 srcBox.right = srcRect.right;
2348 srcBox.top = srcRect.top;
2349 srcBox.bottom = srcRect.bottom;
2352 ID3D11DeviceContext_CopySubresourceRegion(data->d3dContext,
2353 (ID3D11Resource *)stagingTexture,
2356 (ID3D11Resource *)backBuffer,
2361 result = ID3D11DeviceContext_Map(data->d3dContext,
2362 (ID3D11Resource *)stagingTexture,
2377 D3D11_DXGIFormatToSDLPixelFormat(stagingTextureDesc.Format),
2378 textureMemory.pData,
2379 textureMemory.RowPitch,
2386 char errorMessage[1024];
2393 ID3D11DeviceContext_Unmap(data->d3dContext,
2394 (ID3D11Resource *)stagingTexture,
2400 SAFE_RELEASE(backBuffer);
2401 SAFE_RELEASE(stagingTexture);
2408 D3D11_RenderData *data = (D3D11_RenderData *) renderer->
driverdata;
2412 DXGI_PRESENT_PARAMETERS parameters;
2416 #if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP 2419 result = IDXGISwapChain_Present(data->swapChain, syncInterval, presentFlags);
2426 presentFlags = DXGI_PRESENT_DO_NOT_WAIT;
2433 result = IDXGISwapChain1_Present1(data->swapChain, syncInterval, presentFlags, ¶meters);
2440 ID3D11DeviceContext1_DiscardView(data->d3dContext, (ID3D11View*)data->mainRenderTargetView);
2443 data->currentRenderTargetView =
NULL;
2445 if (
FAILED(result) && result != DXGI_ERROR_WAS_STILL_DRAWING) {
2451 if ( result == DXGI_ERROR_DEVICE_REMOVED ) {
2452 D3D11_HandleDeviceLost(renderer);
2453 }
else if (result == DXGI_ERROR_INVALID_CALL) {
2455 D3D11_CreateWindowSizeDependentResources(renderer);
2466 D3D11_RenderData *
data;
2474 data = (D3D11_RenderData *)
SDL_calloc(1,
sizeof(*data));
2480 data->identity = MatrixIdentity();
2506 #if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP 2531 if (
FAILED(D3D11_CreateDeviceResources(renderer))) {
2532 D3D11_DestroyRenderer(renderer);
2535 if (
FAILED(D3D11_CreateWindowSizeDependentResources(renderer))) {
2536 D3D11_DestroyRenderer(renderer);
2544 D3D11_CreateRenderer,
2549 SDL_RENDERER_PRESENTVSYNC |
SDL_BlendFactor SDL_GetBlendModeSrcColorFactor(SDL_BlendMode blendMode)
SDL_BlendFactor
The normalized factor used to multiply pixel components.
GLdouble GLdouble GLdouble r
int(* LockTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
struct SDL_RenderCommand::@30::@31 viewport
int(* RenderReadPixels)(SDL_Renderer *renderer, const SDL_Rect *rect, Uint32 format, void *pixels, int pitch)
GLint GLint GLint GLint GLint x
struct SDL_RenderCommand::@30::@32 cliprect
SDL_BlendMode
The blend mode used in SDL_RenderCopy() and drawing operations.
SDL_bool(* SupportsBlendMode)(SDL_Renderer *renderer, SDL_BlendMode blendMode)
GLuint GLuint GLsizei count
void * SDL_AllocateRenderVertices(SDL_Renderer *renderer, const size_t numbytes, const size_t alignment, size_t *offset)
SDL_RenderDriver D3D11_RenderDriver
struct SDL_RenderCommand::@30::@34 color
GLfloat GLfloat GLfloat GLfloat h
int(* QueueSetDrawColor)(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
int WIN_SetErrorFromHRESULT(const char *prefix, HRESULT hr)
SDL_BlendFactor SDL_GetBlendModeDstAlphaFactor(SDL_BlendMode blendMode)
int(* QueueCopyEx)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const SDL_Rect *srcquad, const SDL_FRect *dstrect, const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
SDL_BlendOperation SDL_GetBlendModeColorOperation(SDL_BlendMode blendMode)
SDL_RendererFlip
Flip constants for SDL_RenderCopyEx.
#define SDL_BYTESPERPIXEL(X)
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
SDL_BlendOperation
The blend operation used when combining source and destination pixel components.
#define SDL_HINT_RENDER_DIRECT3D11_DEBUG
A variable controlling whether to enable Direct3D 11+'s Debug Layer.
void(* DestroyRenderer)(SDL_Renderer *renderer)
GLfixed GLfixed GLint GLint GLfixed points
#define SDL_GetHintBoolean
#define SDL_VERSION(x)
Macro to determine SDL version program was compiled against.
static SDL_BlendMode blendMode
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
int(* UpdateTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
int(* 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)
#define SDL_GetWindowSize
int(* QueueCopy)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_FRect *dstrect)
GLenum GLenum GLuint texture
SDL_BlendOperation SDL_GetBlendModeAlphaOperation(SDL_BlendMode blendMode)
struct SDL_RenderCommand::@30::@33 draw
static SDL_Renderer * renderer
int(* QueueSetViewport)(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
#define SDL_static_cast(type, expression)
GLubyte GLubyte GLubyte GLubyte w
void(* UnlockTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
GLint GLint GLint GLint GLint GLint y
int(* SetRenderTarget)(SDL_Renderer *renderer, SDL_Texture *texture)
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
int(* QueueDrawLines)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
int(* RunCommandQueue)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
int D3D11_CreateVertexShader(ID3D11Device1 *d3dDevice, ID3D11VertexShader **vertexShader, ID3D11InputLayout **inputLayout)
ISwapChainBackgroundPanelNative * WINRT_GlobalSwapChainBackgroundPanelNative
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Window state change event data (event.window.*)
#define SDL_GetWindowWMInfo
#define SDL_OutOfMemory()
SDL_BlendFactor SDL_GetBlendModeSrcAlphaFactor(SDL_BlendMode blendMode)
int(* QueueDrawPoints)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
EGLSurface EGLNativeWindowType * window
SDL_RenderCommandType command
The type used to identify a window.
union SDL_RenderCommand::@30 data
union SDL_SysWMinfo::@17 info
SDL_BlendFactor SDL_GetBlendModeDstColorFactor(SDL_BlendMode blendMode)
int(* QueueFillRects)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FRect *rects, int count)
void(* WindowEvent)(SDL_Renderer *renderer, const SDL_WindowEvent *event)
#define SDL_arraysize(array)
#define SDL_ConvertPixels
void(* DestroyTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
void * SDL_LoadFunction(void *handle, const char *name)
int(* CreateTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
void(* RenderPresent)(SDL_Renderer *renderer)
EGLSurface EGLint * rects
int D3D11_CreatePixelShader(ID3D11Device1 *d3dDevice, D3D11_Shader shader, ID3D11PixelShader **pixelShader)
#define SDL_GetYUVConversionModeForResolution
GLuint GLsizei GLsizei * length
struct SDL_RenderCommand * next
GLboolean GLboolean GLboolean GLboolean a
GLboolean GLboolean GLboolean b
A rectangle, with the origin at the upper left (floating point).
The structure that defines a point (floating point)
A rectangle, with the origin at the upper left (integer).