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; } 63 Float4X4 projectionAndView;
64 } VertexShaderConstants;
72 } VertexPositionColor;
77 ID3D11Texture2D *mainTexture;
78 ID3D11ShaderResourceView *mainTextureResourceView;
79 ID3D11RenderTargetView *mainTextureRenderTargetView;
80 ID3D11Texture2D *stagingTexture;
81 int lockedTexturePositionX;
82 int lockedTexturePositionY;
83 D3D11_FILTER scaleMode;
87 ID3D11Texture2D *mainTextureU;
88 ID3D11ShaderResourceView *mainTextureResourceViewU;
89 ID3D11Texture2D *mainTextureV;
90 ID3D11ShaderResourceView *mainTextureResourceViewV;
94 ID3D11Texture2D *mainTextureNV;
95 ID3D11ShaderResourceView *mainTextureResourceViewNV;
106 ID3D11BlendState *blendState;
114 IDXGIFactory2 *dxgiFactory;
115 IDXGIAdapter *dxgiAdapter;
116 ID3D11Device1 *d3dDevice;
117 ID3D11DeviceContext1 *d3dContext;
118 IDXGISwapChain1 *swapChain;
119 DXGI_SWAP_EFFECT swapEffect;
120 ID3D11RenderTargetView *mainRenderTargetView;
121 ID3D11RenderTargetView *currentOffscreenRenderTargetView;
122 ID3D11InputLayout *inputLayout;
123 ID3D11Buffer *vertexBuffer;
124 ID3D11VertexShader *vertexShader;
127 D3D11_BlendMode *blendModes;
128 ID3D11SamplerState *nearestPixelSampler;
129 ID3D11SamplerState *linearSampler;
130 D3D_FEATURE_LEVEL featureLevel;
133 ID3D11RasterizerState *mainRasterizer;
134 ID3D11RasterizerState *clippedRasterizer;
137 VertexShaderConstants vertexShaderConstantsData;
138 ID3D11Buffer *vertexShaderConstants;
141 DXGI_MODE_ROTATION rotation;
142 ID3D11RenderTargetView *currentRenderTargetView;
143 ID3D11RasterizerState *currentRasterizerState;
144 ID3D11BlendState *currentBlendState;
145 ID3D11PixelShader *currentShader;
146 ID3D11ShaderResourceView *currentShaderResource;
147 ID3D11SamplerState *currentSampler;
161 #pragma GCC diagnostic push 162 #pragma GCC diagnostic ignored "-Wunused-const-variable" 165 static const GUID SDL_IID_IDXGIFactory2 = { 0x50c83a1c, 0xe072, 0x4c48, { 0x87, 0xb0, 0x36, 0x30, 0xfa, 0x36, 0xa6, 0xd0 } };
166 static const GUID SDL_IID_IDXGIDevice1 = { 0x77db970f, 0x6276, 0x48ba, { 0xba, 0x28, 0x07, 0x01, 0x43, 0xb4, 0x39, 0x2c } };
167 static const GUID SDL_IID_IDXGIDevice3 = { 0x6007896c, 0x3244, 0x4afd, { 0xbf, 0x18, 0xa6, 0xd3, 0xbe, 0xda, 0x50, 0x23 } };
168 static const GUID SDL_IID_ID3D11Texture2D = { 0x6f15aaf2, 0xd208, 0x4e89, { 0x9a, 0xb4, 0x48, 0x95, 0x35, 0xd3, 0x4f, 0x9c } };
169 static const GUID SDL_IID_ID3D11Device1 = { 0xa04bfb29, 0x08ef, 0x43d6, { 0xa4, 0x9c, 0xa9, 0xbd, 0xbd, 0xcb, 0xe6, 0x86 } };
170 static const GUID SDL_IID_ID3D11DeviceContext1 = { 0xbb2c6faa, 0xb5fb, 0x4082, { 0x8e, 0x6b, 0x38, 0x8b, 0x8c, 0xfa, 0x90, 0xe1 } };
171 static const GUID SDL_IID_ID3D11Debug = { 0x79cf2233, 0x7536, 0x4948, { 0x9d, 0x36, 0x1e, 0x46, 0x92, 0xdc, 0x57, 0x60 } };
174 #pragma GCC diagnostic pop 189 const Uint8 *Yplane,
int Ypitch,
190 const Uint8 *Uplane,
int Upitch,
191 const Uint8 *Vplane,
int Vpitch);
225 D3D11_CreateRenderer,
249 D3D11_DXGIFormatToSDLPixelFormat(DXGI_FORMAT dxgiFormat)
251 switch (dxgiFormat) {
252 case DXGI_FORMAT_B8G8R8A8_UNORM:
254 case DXGI_FORMAT_B8G8R8X8_UNORM:
262 SDLPixelFormatToDXGIFormat(
Uint32 sdlFormat)
266 return DXGI_FORMAT_B8G8R8A8_UNORM;
268 return DXGI_FORMAT_B8G8R8X8_UNORM;
273 return DXGI_FORMAT_R8_UNORM;
275 return DXGI_FORMAT_UNKNOWN;
283 D3D11_RenderData *
data;
291 data = (D3D11_RenderData *)
SDL_calloc(1,
sizeof(*data));
317 renderer->
info = D3D11_RenderDriver.
info;
321 #if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP 346 if (
FAILED(D3D11_CreateDeviceResources(renderer))) {
347 D3D11_DestroyRenderer(renderer);
350 if (
FAILED(D3D11_CreateWindowSizeDependentResources(renderer))) {
351 D3D11_DestroyRenderer(renderer);
361 D3D11_RenderData *data = (D3D11_RenderData *) renderer->
driverdata;
366 D3D11_DestroyTexture(renderer,
texture);
373 SAFE_RELEASE(data->dxgiFactory);
374 SAFE_RELEASE(data->dxgiAdapter);
375 SAFE_RELEASE(data->d3dDevice);
376 SAFE_RELEASE(data->d3dContext);
377 SAFE_RELEASE(data->swapChain);
378 SAFE_RELEASE(data->mainRenderTargetView);
379 SAFE_RELEASE(data->currentOffscreenRenderTargetView);
380 SAFE_RELEASE(data->inputLayout);
381 SAFE_RELEASE(data->vertexBuffer);
382 SAFE_RELEASE(data->vertexShader);
384 SAFE_RELEASE(data->pixelShaders[i]);
386 if (data->blendModesCount > 0) {
387 for (i = 0; i < data->blendModesCount; ++
i) {
388 SAFE_RELEASE(data->blendModes[i].blendState);
392 data->blendModesCount = 0;
394 SAFE_RELEASE(data->nearestPixelSampler);
395 SAFE_RELEASE(data->linearSampler);
396 SAFE_RELEASE(data->mainRasterizer);
397 SAFE_RELEASE(data->clippedRasterizer);
398 SAFE_RELEASE(data->vertexShaderConstants);
400 data->swapEffect = (DXGI_SWAP_EFFECT) 0;
401 data->rotation = DXGI_MODE_ROTATION_UNSPECIFIED;
402 data->currentRenderTargetView =
NULL;
403 data->currentRasterizerState =
NULL;
404 data->currentBlendState =
NULL;
405 data->currentShader =
NULL;
406 data->currentShaderResource =
NULL;
407 data->currentSampler =
NULL;
412 if (data->hD3D11Mod) {
414 data->hD3D11Mod =
NULL;
416 if (data->hDXGIMod) {
418 data->hDXGIMod =
NULL;
426 D3D11_RenderData *data = (D3D11_RenderData *) renderer->
driverdata;
427 D3D11_ReleaseAll(renderer);
438 return D3D11_BLEND_ZERO;
440 return D3D11_BLEND_ONE;
442 return D3D11_BLEND_SRC_COLOR;
444 return D3D11_BLEND_INV_SRC_COLOR;
446 return D3D11_BLEND_SRC_ALPHA;
448 return D3D11_BLEND_INV_SRC_ALPHA;
450 return D3D11_BLEND_DEST_COLOR;
452 return D3D11_BLEND_INV_DEST_COLOR;
454 return D3D11_BLEND_DEST_ALPHA;
456 return D3D11_BLEND_INV_DEST_ALPHA;
458 return (D3D11_BLEND)0;
466 return D3D11_BLEND_OP_ADD;
468 return D3D11_BLEND_OP_SUBTRACT;
470 return D3D11_BLEND_OP_REV_SUBTRACT;
472 return D3D11_BLEND_OP_MIN;
474 return D3D11_BLEND_OP_MAX;
476 return (D3D11_BLEND_OP)0;
483 D3D11_RenderData *data = (D3D11_RenderData *) renderer->
driverdata;
490 ID3D11BlendState *blendState =
NULL;
491 D3D11_BlendMode *blendModes;
494 D3D11_BLEND_DESC blendDesc;
496 blendDesc.AlphaToCoverageEnable =
FALSE;
497 blendDesc.IndependentBlendEnable =
FALSE;
498 blendDesc.RenderTarget[0].BlendEnable =
TRUE;
499 blendDesc.RenderTarget[0].SrcBlend = GetBlendFunc(srcColorFactor);
500 blendDesc.RenderTarget[0].DestBlend = GetBlendFunc(dstColorFactor);
501 blendDesc.RenderTarget[0].BlendOp = GetBlendEquation(colorOperation);
502 blendDesc.RenderTarget[0].SrcBlendAlpha = GetBlendFunc(srcAlphaFactor);
503 blendDesc.RenderTarget[0].DestBlendAlpha = GetBlendFunc(dstAlphaFactor);
504 blendDesc.RenderTarget[0].BlendOpAlpha = GetBlendEquation(alphaOperation);
505 blendDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
506 result = ID3D11Device_CreateBlendState(data->d3dDevice, &blendDesc, &blendState);
512 blendModes = (D3D11_BlendMode *)
SDL_realloc(data->blendModes, (data->blendModesCount + 1) *
sizeof(*blendModes));
514 SAFE_RELEASE(blendState);
518 blendModes[data->blendModesCount].blendMode =
blendMode;
519 blendModes[data->blendModesCount].blendState = blendState;
520 data->blendModes = blendModes;
521 ++data->blendModesCount;
530 typedef HRESULT(WINAPI *PFN_CREATE_DXGI_FACTORY)(REFIID riid,
void **ppFactory);
531 PFN_CREATE_DXGI_FACTORY CreateDXGIFactoryFunc;
532 D3D11_RenderData *data = (D3D11_RenderData *) renderer->
driverdata;
533 PFN_D3D11_CREATE_DEVICE D3D11CreateDeviceFunc;
534 ID3D11Device *d3dDevice =
NULL;
535 ID3D11DeviceContext *d3dContext =
NULL;
536 IDXGIDevice1 *dxgiDevice =
NULL;
537 HRESULT result =
S_OK;
546 D3D_FEATURE_LEVEL featureLevels[] =
548 D3D_FEATURE_LEVEL_11_1,
549 D3D_FEATURE_LEVEL_11_0,
550 D3D_FEATURE_LEVEL_10_1,
551 D3D_FEATURE_LEVEL_10_0,
552 D3D_FEATURE_LEVEL_9_3,
553 D3D_FEATURE_LEVEL_9_2,
554 D3D_FEATURE_LEVEL_9_1
557 D3D11_BUFFER_DESC constantBufferDesc;
558 D3D11_SAMPLER_DESC samplerDesc;
559 D3D11_RASTERIZER_DESC rasterDesc;
562 CreateDXGIFactoryFunc = CreateDXGIFactory1;
563 D3D11CreateDeviceFunc = D3D11CreateDevice;
566 if (!data->hDXGIMod) {
571 CreateDXGIFactoryFunc = (PFN_CREATE_DXGI_FACTORY)
SDL_LoadFunction(data->hDXGIMod,
"CreateDXGIFactory");
572 if (!CreateDXGIFactoryFunc) {
578 if (!data->hD3D11Mod) {
583 D3D11CreateDeviceFunc = (PFN_D3D11_CREATE_DEVICE)
SDL_LoadFunction(data->hD3D11Mod,
"D3D11CreateDevice");
584 if (!D3D11CreateDeviceFunc) {
590 result = CreateDXGIFactoryFunc(&SDL_IID_IDXGIFactory2, (
void **)&data->dxgiFactory);
597 result = IDXGIFactory2_EnumAdapters(data->dxgiFactory, 0, &data->dxgiAdapter);
606 creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
610 creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
614 result = D3D11CreateDeviceFunc(
616 D3D_DRIVER_TYPE_UNKNOWN,
631 result = ID3D11Device_QueryInterface(d3dDevice, &SDL_IID_ID3D11Device1, (
void **)&data->d3dDevice);
637 result = ID3D11DeviceContext_QueryInterface(d3dContext, &SDL_IID_ID3D11DeviceContext1, (
void **)&data->d3dContext);
643 result = ID3D11Device_QueryInterface(d3dDevice, &SDL_IID_IDXGIDevice1, (
void **)&dxgiDevice);
652 result = IDXGIDevice1_SetMaximumFrameLatency(dxgiDevice, 1);
662 switch (data->featureLevel) {
663 case D3D_FEATURE_LEVEL_11_1:
664 case D3D_FEATURE_LEVEL_11_0:
668 case D3D_FEATURE_LEVEL_10_1:
669 case D3D_FEATURE_LEVEL_10_0:
673 case D3D_FEATURE_LEVEL_9_3:
677 case D3D_FEATURE_LEVEL_9_2:
678 case D3D_FEATURE_LEVEL_9_1:
683 SDL_SetError(
"%s, Unexpected feature level: %d", __FUNCTION__, data->featureLevel);
700 constantBufferDesc.ByteWidth =
sizeof(VertexShaderConstants);
701 constantBufferDesc.Usage = D3D11_USAGE_DEFAULT;
702 constantBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
703 result = ID3D11Device_CreateBuffer(data->d3dDevice,
706 &data->vertexShaderConstants
715 samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
716 samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
717 samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
718 samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
719 samplerDesc.MipLODBias = 0.0f;
720 samplerDesc.MaxAnisotropy = 1;
721 samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
722 samplerDesc.MinLOD = 0.0f;
723 samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
724 result = ID3D11Device_CreateSamplerState(data->d3dDevice,
726 &data->nearestPixelSampler
729 WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR(
"ID3D11Device1::CreateSamplerState [nearest-pixel filter]"), result);
733 samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
734 result = ID3D11Device_CreateSamplerState(data->d3dDevice,
745 rasterDesc.AntialiasedLineEnable =
FALSE;
746 rasterDesc.CullMode = D3D11_CULL_NONE;
747 rasterDesc.DepthBias = 0;
748 rasterDesc.DepthBiasClamp = 0.0f;
749 rasterDesc.DepthClipEnable =
TRUE;
750 rasterDesc.FillMode = D3D11_FILL_SOLID;
751 rasterDesc.FrontCounterClockwise =
FALSE;
752 rasterDesc.MultisampleEnable =
FALSE;
753 rasterDesc.ScissorEnable =
FALSE;
754 rasterDesc.SlopeScaledDepthBias = 0.0f;
755 result = ID3D11Device_CreateRasterizerState(data->d3dDevice, &rasterDesc, &data->mainRasterizer);
761 rasterDesc.ScissorEnable =
TRUE;
762 result = ID3D11Device_CreateRasterizerState(data->d3dDevice, &rasterDesc, &data->clippedRasterizer);
764 WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR(
"ID3D11Device1::CreateRasterizerState [clipped rasterizer]"), result);
777 ID3D11DeviceContext_IASetInputLayout(data->d3dContext, data->inputLayout);
778 ID3D11DeviceContext_VSSetShader(data->d3dContext, data->vertexShader,
NULL, 0);
779 ID3D11DeviceContext_VSSetConstantBuffers(data->d3dContext, 0, 1, &data->vertexShaderConstants);
782 SAFE_RELEASE(d3dDevice);
783 SAFE_RELEASE(d3dContext);
784 SAFE_RELEASE(dxgiDevice);
790 static DXGI_MODE_ROTATION
791 D3D11_GetCurrentRotation()
794 return DXGI_MODE_ROTATION_IDENTITY;
800 D3D11_IsDisplayRotated90Degrees(DXGI_MODE_ROTATION rotation)
803 case DXGI_MODE_ROTATION_ROTATE90:
804 case DXGI_MODE_ROTATION_ROTATE270:
812 D3D11_GetRotationForCurrentRenderTarget(
SDL_Renderer * renderer)
814 D3D11_RenderData *data = (D3D11_RenderData *)renderer->
driverdata;
815 if (data->currentOffscreenRenderTargetView) {
816 return DXGI_MODE_ROTATION_IDENTITY;
818 return data->rotation;
823 D3D11_GetViewportAlignedD3DRect(
SDL_Renderer * renderer,
const SDL_Rect * sdlRect, D3D11_RECT * outRect, BOOL includeViewportOffset)
825 const int rotation = D3D11_GetRotationForCurrentRenderTarget(renderer);
827 case DXGI_MODE_ROTATION_IDENTITY:
828 outRect->left = sdlRect->
x;
829 outRect->right = sdlRect->
x + sdlRect->
w;
830 outRect->top = sdlRect->
y;
831 outRect->bottom = sdlRect->
y + sdlRect->
h;
832 if (includeViewportOffset) {
839 case DXGI_MODE_ROTATION_ROTATE270:
840 outRect->left = sdlRect->
y;
841 outRect->right = sdlRect->
y + sdlRect->
h;
842 outRect->top = renderer->
viewport.
w - sdlRect->
x - sdlRect->
w;
843 outRect->bottom = renderer->
viewport.
w - sdlRect->
x;
845 case DXGI_MODE_ROTATION_ROTATE180:
846 outRect->left = renderer->
viewport.
w - sdlRect->
x - sdlRect->
w;
847 outRect->right = renderer->
viewport.
w - sdlRect->
x;
848 outRect->top = renderer->
viewport.
h - sdlRect->
y - sdlRect->
h;
849 outRect->bottom = renderer->
viewport.
h - sdlRect->
y;
851 case DXGI_MODE_ROTATION_ROTATE90:
852 outRect->left = renderer->
viewport.
h - sdlRect->
y - sdlRect->
h;
853 outRect->right = renderer->
viewport.
h - sdlRect->
y;
854 outRect->top = sdlRect->
x;
855 outRect->bottom = sdlRect->
x + sdlRect->
h;
858 return SDL_SetError(
"The physical display is in an unknown or unsupported rotation");
866 D3D11_RenderData *data = (D3D11_RenderData *)renderer->
driverdata;
868 IUnknown *coreWindow = D3D11_GetCoreWindowFromSDLRenderer(renderer);
869 const BOOL usingXAML = (coreWindow ==
NULL);
871 IUnknown *coreWindow =
NULL;
872 const BOOL usingXAML =
FALSE;
874 HRESULT result =
S_OK;
877 DXGI_SWAP_CHAIN_DESC1 swapChainDesc;
879 swapChainDesc.Width =
w;
880 swapChainDesc.Height =
h;
881 swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
882 swapChainDesc.Stereo =
FALSE;
883 swapChainDesc.SampleDesc.Count = 1;
884 swapChainDesc.SampleDesc.Quality = 0;
885 swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
886 swapChainDesc.BufferCount = 2;
887 #if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP 888 swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
889 swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
893 swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
895 swapChainDesc.Scaling = DXGI_SCALING_NONE;
897 swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
899 swapChainDesc.Flags = 0;
902 result = IDXGIFactory2_CreateSwapChainForCoreWindow(data->dxgiFactory,
903 (IUnknown *)data->d3dDevice,
913 }
else if (usingXAML) {
914 result = IDXGIFactory2_CreateSwapChainForComposition(data->dxgiFactory,
915 (IUnknown *)data->d3dDevice,
924 #if WINAPI_FAMILY == WINAPI_FAMILY_APP 931 SDL_SetError(SDL_COMPOSE_ERROR(
"XAML support is not yet available for Windows Phone"));
941 result = IDXGIFactory2_CreateSwapChainForHwnd(data->dxgiFactory,
942 (IUnknown *)data->d3dDevice,
954 IDXGIFactory_MakeWindowAssociation(data->dxgiFactory, windowinfo.
info.win.
window, DXGI_MWA_NO_WINDOW_CHANGES);
956 SDL_SetError(__FUNCTION__
", Unable to find something to attach a swap chain to");
960 data->swapEffect = swapChainDesc.SwapEffect;
963 SAFE_RELEASE(coreWindow);
970 D3D11_CreateWindowSizeDependentResources(
SDL_Renderer * renderer)
972 D3D11_RenderData *data = (D3D11_RenderData *)renderer->
driverdata;
973 ID3D11Texture2D *backBuffer =
NULL;
974 HRESULT result =
S_OK;
978 D3D11_ReleaseMainRenderTargetView(renderer);
984 data->rotation = D3D11_GetCurrentRotation();
986 if (D3D11_IsDisplayRotated90Degrees(data->rotation)) {
992 if (data->swapChain) {
994 #if !defined(__WINRT__) || (WINAPI_FAMILY != WINAPI_FAMILY_PHONE_APP) 996 result = IDXGISwapChain_ResizeBuffers(data->swapChain,
1002 if (result == DXGI_ERROR_DEVICE_REMOVED) {
1004 D3D11_HandleDeviceLost(renderer);
1010 }
else if (
FAILED(result)) {
1016 result = D3D11_CreateSwapChain(renderer, w, h);
1022 #if WINAPI_FAMILY != WINAPI_FAMILY_PHONE_APP 1039 if (data->swapEffect == DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL) {
1040 result = IDXGISwapChain1_SetRotation(data->swapChain, data->rotation);
1048 result = IDXGISwapChain_GetBuffer(data->swapChain,
1050 &SDL_IID_ID3D11Texture2D,
1051 (
void **)&backBuffer
1059 result = ID3D11Device_CreateRenderTargetView(data->d3dDevice,
1060 (ID3D11Resource *)backBuffer,
1062 &data->mainRenderTargetView
1069 if (D3D11_UpdateViewport(renderer) != 0) {
1076 SAFE_RELEASE(backBuffer);
1082 D3D11_UpdateForWindowSizeChange(
SDL_Renderer * renderer)
1084 return D3D11_CreateWindowSizeDependentResources(renderer);
1090 HRESULT result =
S_OK;
1092 D3D11_ReleaseAll(renderer);
1094 result = D3D11_CreateDeviceResources(renderer);
1100 result = D3D11_UpdateForWindowSizeChange(renderer);
1120 #if NTDDI_VERSION > NTDDI_WIN8 1121 D3D11_RenderData *data = (D3D11_RenderData *)renderer->
driverdata;
1122 HRESULT result =
S_OK;
1123 IDXGIDevice3 *dxgiDevice =
NULL;
1125 result = ID3D11Device_QueryInterface(data->d3dDevice, &SDL_IID_IDXGIDevice3, &dxgiDevice);
1131 IDXGIDevice3_Trim(dxgiDevice);
1132 SAFE_RELEASE(dxgiDevice);
1141 D3D11_UpdateForWindowSizeChange(renderer);
1155 if (!GetBlendFunc(srcColorFactor) || !GetBlendFunc(srcAlphaFactor) ||
1156 !GetBlendEquation(colorOperation) ||
1157 !GetBlendFunc(dstColorFactor) || !GetBlendFunc(dstAlphaFactor) ||
1158 !GetBlendEquation(alphaOperation)) {
1168 if (!hint || *hint ==
'0' ||
SDL_strcasecmp(hint,
"nearest") == 0) {
1169 return D3D11_FILTER_MIN_MAG_MIP_POINT;
1171 return D3D11_FILTER_MIN_MAG_MIP_LINEAR;
1178 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
1179 D3D11_TextureData *textureData;
1181 DXGI_FORMAT textureFormat = SDLPixelFormatToDXGIFormat(texture->
format);
1182 D3D11_TEXTURE2D_DESC textureDesc;
1183 D3D11_SHADER_RESOURCE_VIEW_DESC resourceViewDesc;
1185 if (textureFormat == DXGI_FORMAT_UNKNOWN) {
1186 return SDL_SetError(
"%s, An unsupported SDL pixel format (0x%x) was specified",
1187 __FUNCTION__, texture->
format);
1190 textureData = (D3D11_TextureData*)
SDL_calloc(1,
sizeof(*textureData));
1200 textureDesc.Width = texture->
w;
1201 textureDesc.Height = texture->
h;
1202 textureDesc.MipLevels = 1;
1203 textureDesc.ArraySize = 1;
1204 textureDesc.Format = textureFormat;
1205 textureDesc.SampleDesc.Count = 1;
1206 textureDesc.SampleDesc.Quality = 0;
1207 textureDesc.MiscFlags = 0;
1210 textureDesc.Usage = D3D11_USAGE_DYNAMIC;
1211 textureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
1213 textureDesc.Usage = D3D11_USAGE_DEFAULT;
1214 textureDesc.CPUAccessFlags = 0;
1218 textureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET;
1220 textureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
1223 result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
1226 &textureData->mainTexture
1229 D3D11_DestroyTexture(renderer, texture);
1238 textureDesc.Width = (textureDesc.Width + 1) / 2;
1239 textureDesc.Height = (textureDesc.Height + 1) / 2;
1241 result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
1244 &textureData->mainTextureU
1247 D3D11_DestroyTexture(renderer, texture);
1252 result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
1255 &textureData->mainTextureV
1258 D3D11_DestroyTexture(renderer, texture);
1266 D3D11_TEXTURE2D_DESC nvTextureDesc = textureDesc;
1270 nvTextureDesc.Format = DXGI_FORMAT_R8G8_UNORM;
1271 nvTextureDesc.Width = (textureDesc.Width + 1) / 2;
1272 nvTextureDesc.Height = (textureDesc.Height + 1) / 2;
1274 result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
1277 &textureData->mainTextureNV
1280 D3D11_DestroyTexture(renderer, texture);
1286 resourceViewDesc.Format = textureDesc.Format;
1287 resourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
1288 resourceViewDesc.Texture2D.MostDetailedMip = 0;
1289 resourceViewDesc.Texture2D.MipLevels = textureDesc.MipLevels;
1290 result = ID3D11Device_CreateShaderResourceView(rendererData->d3dDevice,
1291 (ID3D11Resource *)textureData->mainTexture,
1293 &textureData->mainTextureResourceView
1296 D3D11_DestroyTexture(renderer, texture);
1301 if (textureData->yuv) {
1302 result = ID3D11Device_CreateShaderResourceView(rendererData->d3dDevice,
1303 (ID3D11Resource *)textureData->mainTextureU,
1305 &textureData->mainTextureResourceViewU
1308 D3D11_DestroyTexture(renderer, texture);
1312 result = ID3D11Device_CreateShaderResourceView(rendererData->d3dDevice,
1313 (ID3D11Resource *)textureData->mainTextureV,
1315 &textureData->mainTextureResourceViewV
1318 D3D11_DestroyTexture(renderer, texture);
1324 if (textureData->nv12) {
1325 D3D11_SHADER_RESOURCE_VIEW_DESC nvResourceViewDesc = resourceViewDesc;
1327 nvResourceViewDesc.Format = DXGI_FORMAT_R8G8_UNORM;
1329 result = ID3D11Device_CreateShaderResourceView(rendererData->d3dDevice,
1330 (ID3D11Resource *)textureData->mainTextureNV,
1331 &nvResourceViewDesc,
1332 &textureData->mainTextureResourceViewNV
1335 D3D11_DestroyTexture(renderer, texture);
1342 D3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDesc;
1343 renderTargetViewDesc.Format = textureDesc.Format;
1344 renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
1345 renderTargetViewDesc.Texture2D.MipSlice = 0;
1347 result = ID3D11Device_CreateRenderTargetView(rendererData->d3dDevice,
1348 (ID3D11Resource *)textureData->mainTexture,
1349 &renderTargetViewDesc,
1350 &textureData->mainTextureRenderTargetView);
1352 D3D11_DestroyTexture(renderer, texture);
1365 D3D11_TextureData *data = (D3D11_TextureData *)texture->
driverdata;
1371 SAFE_RELEASE(data->mainTexture);
1372 SAFE_RELEASE(data->mainTextureResourceView);
1373 SAFE_RELEASE(data->mainTextureRenderTargetView);
1374 SAFE_RELEASE(data->stagingTexture);
1375 SAFE_RELEASE(data->mainTextureU);
1376 SAFE_RELEASE(data->mainTextureResourceViewU);
1377 SAFE_RELEASE(data->mainTextureV);
1378 SAFE_RELEASE(data->mainTextureResourceViewV);
1385 D3D11_UpdateTextureInternal(D3D11_RenderData *rendererData, ID3D11Texture2D *texture,
int bpp,
int x,
int y,
int w,
int h,
const void *
pixels,
int pitch)
1387 ID3D11Texture2D *stagingTexture;
1393 D3D11_TEXTURE2D_DESC stagingTextureDesc;
1394 D3D11_MAPPED_SUBRESOURCE textureMemory;
1397 ID3D11Texture2D_GetDesc(texture, &stagingTextureDesc);
1398 stagingTextureDesc.Width =
w;
1399 stagingTextureDesc.Height =
h;
1400 stagingTextureDesc.BindFlags = 0;
1401 stagingTextureDesc.MiscFlags = 0;
1402 stagingTextureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
1403 stagingTextureDesc.Usage = D3D11_USAGE_STAGING;
1404 result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
1405 &stagingTextureDesc,
1409 WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR(
"ID3D11Device1::CreateTexture2D [create staging texture]"), result);
1414 result = ID3D11DeviceContext_Map(rendererData->d3dContext,
1415 (ID3D11Resource *)stagingTexture,
1423 SAFE_RELEASE(stagingTexture);
1427 src = (
const Uint8 *)pixels;
1428 dst = textureMemory.pData;
1430 if (length == pitch && length == textureMemory.RowPitch) {
1433 if (length > (UINT)pitch) {
1436 if (length > textureMemory.RowPitch) {
1437 length = textureMemory.RowPitch;
1439 for (row = 0; row <
h; ++
row) {
1442 dst += textureMemory.RowPitch;
1447 ID3D11DeviceContext_Unmap(rendererData->d3dContext,
1448 (ID3D11Resource *)stagingTexture,
1452 ID3D11DeviceContext_CopySubresourceRegion(rendererData->d3dContext,
1453 (ID3D11Resource *)texture,
1458 (ID3D11Resource *)stagingTexture,
1462 SAFE_RELEASE(stagingTexture);
1472 D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->
driverdata;
1473 D3D11_TextureData *textureData = (D3D11_TextureData *)texture->
driverdata;
1480 if (D3D11_UpdateTextureInternal(rendererData, textureData->mainTexture,
SDL_BYTESPERPIXEL(texture->
format), rect->
x, rect->
y, rect->
w, rect->
h, srcPixels, srcPitch) < 0) {
1484 if (textureData->yuv) {
1486 srcPixels = (
const void*)((
const Uint8*)srcPixels + rect->
h * srcPitch);
1488 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) {
1493 srcPixels = (
const void*)((
const Uint8*)srcPixels + ((rect->
h + 1) / 2) * ((srcPitch + 1) / 2));
1494 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) {
1499 if (textureData->nv12) {
1501 srcPixels = (
const void*)((
const Uint8*)srcPixels + rect->
h * srcPitch);
1503 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) {
1513 const Uint8 *Yplane,
int Ypitch,
1514 const Uint8 *Uplane,
int Upitch,
1515 const Uint8 *Vplane,
int Vpitch)
1517 D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->
driverdata;
1518 D3D11_TextureData *textureData = (D3D11_TextureData *)texture->
driverdata;
1525 if (D3D11_UpdateTextureInternal(rendererData, textureData->mainTexture,
SDL_BYTESPERPIXEL(texture->
format), rect->
x, rect->
y, rect->
w, rect->
h, Yplane, Ypitch) < 0) {
1528 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) {
1531 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) {
1539 const SDL_Rect * rect,
void **pixels,
int *pitch)
1541 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
1542 D3D11_TextureData *textureData = (D3D11_TextureData *) texture->
driverdata;
1543 HRESULT result =
S_OK;
1544 D3D11_TEXTURE2D_DESC stagingTextureDesc;
1545 D3D11_MAPPED_SUBRESOURCE textureMemory;
1552 if (textureData->yuv || textureData->nv12) {
1554 if (!textureData->pixels) {
1555 textureData->pitch = texture->
w;
1556 textureData->pixels = (
Uint8 *)
SDL_malloc((texture->
h * textureData->pitch * 3) / 2);
1557 if (!textureData->pixels) {
1561 textureData->locked_rect = *
rect;
1563 (
void *)((
Uint8 *)textureData->pixels + rect->
y * textureData->pitch +
1565 *pitch = textureData->pitch;
1569 if (textureData->stagingTexture) {
1581 ID3D11Texture2D_GetDesc(textureData->mainTexture, &stagingTextureDesc);
1582 stagingTextureDesc.Width = rect->
w;
1583 stagingTextureDesc.Height = rect->
h;
1584 stagingTextureDesc.BindFlags = 0;
1585 stagingTextureDesc.MiscFlags = 0;
1586 stagingTextureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
1587 stagingTextureDesc.Usage = D3D11_USAGE_STAGING;
1588 result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
1589 &stagingTextureDesc,
1591 &textureData->stagingTexture);
1593 WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR(
"ID3D11Device1::CreateTexture2D [create staging texture]"), result);
1598 result = ID3D11DeviceContext_Map(rendererData->d3dContext,
1599 (ID3D11Resource *)textureData->stagingTexture,
1607 SAFE_RELEASE(textureData->stagingTexture);
1614 textureData->lockedTexturePositionX = rect->
x;
1615 textureData->lockedTexturePositionY = rect->
y;
1620 *pixels = textureMemory.pData;
1621 *pitch = textureMemory.RowPitch;
1628 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
1629 D3D11_TextureData *textureData = (D3D11_TextureData *) texture->
driverdata;
1635 if (textureData->yuv || textureData->nv12) {
1636 const SDL_Rect *rect = &textureData->locked_rect;
1638 (
void *) ((
Uint8 *) textureData->pixels + rect->
y * textureData->pitch +
1640 D3D11_UpdateTexture(renderer, texture, rect, pixels, textureData->pitch);
1645 ID3D11DeviceContext_Unmap(rendererData->d3dContext,
1646 (ID3D11Resource *)textureData->stagingTexture,
1650 ID3D11DeviceContext_CopySubresourceRegion(rendererData->d3dContext,
1651 (ID3D11Resource *)textureData->mainTexture,
1653 textureData->lockedTexturePositionX,
1654 textureData->lockedTexturePositionY,
1656 (ID3D11Resource *)textureData->stagingTexture,
1660 SAFE_RELEASE(textureData->stagingTexture);
1666 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
1667 D3D11_TextureData *textureData =
NULL;
1669 if (texture ==
NULL) {
1670 rendererData->currentOffscreenRenderTargetView =
NULL;
1674 textureData = (D3D11_TextureData *) texture->
driverdata;
1676 if (!textureData->mainTextureRenderTargetView) {
1677 return SDL_SetError(
"specified texture is not a render target");
1680 rendererData->currentOffscreenRenderTargetView = textureData->mainTextureRenderTargetView;
1688 D3D11_RenderData *data = (D3D11_RenderData *)renderer->
driverdata;
1691 data->vertexShaderConstantsData.model = *
matrix;
1693 data->vertexShaderConstantsData.model = MatrixIdentity();
1696 ID3D11DeviceContext_UpdateSubresource(data->d3dContext,
1697 (ID3D11Resource *)data->vertexShaderConstants,
1700 &data->vertexShaderConstantsData,
1709 D3D11_RenderData *data = (D3D11_RenderData *) renderer->
driverdata;
1710 Float4X4 projection;
1713 BOOL swapDimensions;
1715 const int rotation = D3D11_GetRotationForCurrentRenderTarget(renderer);
1732 case DXGI_MODE_ROTATION_IDENTITY:
1733 projection = MatrixIdentity();
1735 case DXGI_MODE_ROTATION_ROTATE270:
1738 case DXGI_MODE_ROTATION_ROTATE180:
1741 case DXGI_MODE_ROTATION_ROTATE90:
1745 return SDL_SetError(
"An unknown DisplayOrientation is being used");
1749 view.m[0][0] = 2.0f / renderer->
viewport.
w;
1750 view.m[0][1] = 0.0f;
1751 view.m[0][2] = 0.0f;
1752 view.m[0][3] = 0.0f;
1753 view.m[1][0] = 0.0f;
1754 view.m[1][1] = -2.0f / renderer->
viewport.
h;
1755 view.m[1][2] = 0.0f;
1756 view.m[1][3] = 0.0f;
1757 view.m[2][0] = 0.0f;
1758 view.m[2][1] = 0.0f;
1759 view.m[2][2] = 1.0f;
1760 view.m[2][3] = 0.0f;
1761 view.m[3][0] = -1.0f;
1762 view.m[3][1] = 1.0f;
1763 view.m[3][2] = 0.0f;
1764 view.m[3][3] = 1.0f;
1770 data->vertexShaderConstantsData.projectionAndView = MatrixMultiply(
1775 D3D11_SetModelMatrix(renderer,
NULL);
1782 swapDimensions = D3D11_IsDisplayRotated90Degrees(rotation);
1783 if (swapDimensions) {
1784 orientationAlignedViewport.x = (float) renderer->
viewport.
y;
1785 orientationAlignedViewport.y = (
float) renderer->
viewport.
x;
1786 orientationAlignedViewport.w = (float) renderer->
viewport.
h;
1787 orientationAlignedViewport.h = (
float) renderer->
viewport.
w;
1789 orientationAlignedViewport.x = (float) renderer->
viewport.
x;
1790 orientationAlignedViewport.y = (
float) renderer->
viewport.
y;
1791 orientationAlignedViewport.w = (float) renderer->
viewport.
w;
1792 orientationAlignedViewport.h = (
float) renderer->
viewport.
h;
1796 viewport.TopLeftX = orientationAlignedViewport.
x;
1797 viewport.TopLeftY = orientationAlignedViewport.
y;
1798 viewport.Width = orientationAlignedViewport.
w;
1799 viewport.Height = orientationAlignedViewport.
h;
1803 ID3D11DeviceContext_RSSetViewports(data->d3dContext, 1, &
viewport);
1811 D3D11_RenderData *data = (D3D11_RenderData *) renderer->
driverdata;
1814 ID3D11DeviceContext_RSSetScissorRects(data->d3dContext, 0,
NULL);
1816 D3D11_RECT scissorRect;
1817 if (D3D11_GetViewportAlignedD3DRect(renderer, &renderer->
clip_rect, &scissorRect,
TRUE) != 0) {
1821 ID3D11DeviceContext_RSSetScissorRects(data->d3dContext, 1, &scissorRect);
1828 D3D11_ReleaseMainRenderTargetView(
SDL_Renderer * renderer)
1830 D3D11_RenderData *data = (D3D11_RenderData *)renderer->
driverdata;
1831 ID3D11DeviceContext_OMSetRenderTargets(data->d3dContext, 0,
NULL,
NULL);
1832 SAFE_RELEASE(data->mainRenderTargetView);
1835 static ID3D11RenderTargetView *
1836 D3D11_GetCurrentRenderTargetView(
SDL_Renderer * renderer)
1838 D3D11_RenderData *data = (D3D11_RenderData *) renderer->
driverdata;
1839 if (data->currentOffscreenRenderTargetView) {
1840 return data->currentOffscreenRenderTargetView;
1842 return data->mainRenderTargetView;
1849 D3D11_RenderData *data = (D3D11_RenderData *) renderer->
driverdata;
1850 const float colorRGBA[] = {
1851 (renderer->
r / 255.0f),
1852 (renderer->
g / 255.0f),
1853 (renderer->
b / 255.0f),
1854 (renderer->
a / 255.0f)
1856 ID3D11DeviceContext_ClearRenderTargetView(data->d3dContext,
1857 D3D11_GetCurrentRenderTargetView(renderer),
1865 const void * vertexData,
size_t dataSizeInBytes)
1867 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
1868 D3D11_BUFFER_DESC vertexBufferDesc;
1869 HRESULT result =
S_OK;
1870 D3D11_SUBRESOURCE_DATA vertexBufferData;
1871 const UINT
stride =
sizeof(VertexPositionColor);
1874 if (rendererData->vertexBuffer) {
1875 ID3D11Buffer_GetDesc(rendererData->vertexBuffer, &vertexBufferDesc);
1880 if (rendererData->vertexBuffer && vertexBufferDesc.ByteWidth >= dataSizeInBytes) {
1881 D3D11_MAPPED_SUBRESOURCE mappedResource;
1882 result = ID3D11DeviceContext_Map(rendererData->d3dContext,
1883 (ID3D11Resource *)rendererData->vertexBuffer,
1885 D3D11_MAP_WRITE_DISCARD,
1893 SDL_memcpy(mappedResource.pData, vertexData, dataSizeInBytes);
1894 ID3D11DeviceContext_Unmap(rendererData->d3dContext, (ID3D11Resource *)rendererData->vertexBuffer, 0);
1896 SAFE_RELEASE(rendererData->vertexBuffer);
1898 vertexBufferDesc.ByteWidth = (UINT) dataSizeInBytes;
1899 vertexBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
1900 vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
1901 vertexBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
1904 vertexBufferData.pSysMem = vertexData;
1905 vertexBufferData.SysMemPitch = 0;
1906 vertexBufferData.SysMemSlicePitch = 0;
1908 result = ID3D11Device_CreateBuffer(rendererData->d3dDevice,
1911 &rendererData->vertexBuffer
1918 ID3D11DeviceContext_IASetVertexBuffers(rendererData->d3dContext,
1921 &rendererData->vertexBuffer,
1933 D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->
driverdata;
1934 ID3D11RasterizerState *rasterizerState;
1935 ID3D11RenderTargetView *renderTargetView = D3D11_GetCurrentRenderTargetView(renderer);
1936 if (renderTargetView != rendererData->currentRenderTargetView) {
1937 ID3D11DeviceContext_OMSetRenderTargets(rendererData->d3dContext,
1942 rendererData->currentRenderTargetView = renderTargetView;
1946 rasterizerState = rendererData->mainRasterizer;
1948 rasterizerState = rendererData->clippedRasterizer;
1950 if (rasterizerState != rendererData->currentRasterizerState) {
1951 ID3D11DeviceContext_RSSetState(rendererData->d3dContext, rasterizerState);
1952 rendererData->currentRasterizerState = rasterizerState;
1959 D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->
driverdata;
1960 ID3D11BlendState *blendState =
NULL;
1963 for (i = 0; i < rendererData->blendModesCount; ++
i) {
1964 if (blendMode == rendererData->blendModes[i].blendMode) {
1965 blendState = rendererData->blendModes[
i].blendState;
1970 if (D3D11_CreateBlendState(renderer, blendMode)) {
1972 D3D11_RenderSetBlendMode(renderer, blendMode);
1977 if (blendState != rendererData->currentBlendState) {
1978 ID3D11DeviceContext_OMSetBlendState(rendererData->d3dContext, blendState, 0, 0xFFFFFFFF);
1979 rendererData->currentBlendState = blendState;
1985 ID3D11PixelShader *
shader,
1986 int numShaderResources,
1987 ID3D11ShaderResourceView ** shaderResources,
1990 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
1991 ID3D11ShaderResourceView *shaderResource;
1992 if (shader != rendererData->currentShader) {
1993 ID3D11DeviceContext_PSSetShader(rendererData->d3dContext, shader,
NULL, 0);
1994 rendererData->currentShader =
shader;
1996 if (numShaderResources > 0) {
1997 shaderResource = shaderResources[0];
1999 shaderResource =
NULL;
2001 if (shaderResource != rendererData->currentShaderResource) {
2002 ID3D11DeviceContext_PSSetShaderResources(rendererData->d3dContext, 0, numShaderResources, shaderResources);
2003 rendererData->currentShaderResource = shaderResource;
2005 if (sampler != rendererData->currentSampler) {
2006 ID3D11DeviceContext_PSSetSamplers(rendererData->d3dContext, 0, 1, &sampler);
2007 rendererData->currentSampler =
sampler;
2013 D3D11_PRIMITIVE_TOPOLOGY primitiveTopology,
2016 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
2018 ID3D11DeviceContext_IASetPrimitiveTopology(rendererData->d3dContext, primitiveTopology);
2019 ID3D11DeviceContext_Draw(rendererData->d3dContext, vertexCount, 0);
2026 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
2028 VertexPositionColor *vertices;
2031 r = (
float)(renderer->
r / 255.0f);
2032 g = (float)(renderer->
g / 255.0f);
2033 b = (float)(renderer->
b / 255.0f);
2034 a = (float)(renderer->
a / 255.0f);
2037 for (i = 0; i <
count; ++
i) {
2038 const VertexPositionColor
v = { { points[
i].
x + 0.5f, points[
i].
y + 0.5f, 0.0f }, { 0.0f, 0.0f }, {
r,
g,
b,
a } };
2042 D3D11_RenderStartDrawOp(renderer);
2043 D3D11_RenderSetBlendMode(renderer, renderer->
blendMode);
2044 if (D3D11_UpdateVertexBuffer(renderer, vertices, (
unsigned int)count *
sizeof(VertexPositionColor)) != 0) {
2049 D3D11_SetPixelShader(
2056 D3D11_RenderFinishDrawOp(renderer, D3D11_PRIMITIVE_TOPOLOGY_POINTLIST, count);
2065 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
2067 VertexPositionColor *vertices;
2070 r = (
float)(renderer->
r / 255.0f);
2071 g = (float)(renderer->
g / 255.0f);
2072 b = (float)(renderer->
b / 255.0f);
2073 a = (float)(renderer->
a / 255.0f);
2076 for (i = 0; i <
count; ++
i) {
2077 const VertexPositionColor
v = { { points[
i].
x + 0.5f, points[
i].
y + 0.5f, 0.0f }, { 0.0f, 0.0f }, {
r,
g,
b,
a } };
2081 D3D11_RenderStartDrawOp(renderer);
2082 D3D11_RenderSetBlendMode(renderer, renderer->
blendMode);
2083 if (D3D11_UpdateVertexBuffer(renderer, vertices, (
unsigned int)count *
sizeof(VertexPositionColor)) != 0) {
2088 D3D11_SetPixelShader(
2095 D3D11_RenderFinishDrawOp(renderer, D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP, count);
2097 if (points[0].x != points[count - 1].x || points[0].y != points[count - 1].y) {
2098 ID3D11DeviceContext_IASetPrimitiveTopology(rendererData->d3dContext, D3D11_PRIMITIVE_TOPOLOGY_POINTLIST);
2099 ID3D11DeviceContext_Draw(rendererData->d3dContext, 1, count - 1);
2110 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
2114 r = (
float)(renderer->
r / 255.0f);
2115 g = (float)(renderer->
g / 255.0f);
2116 b = (float)(renderer->
b / 255.0f);
2117 a = (float)(renderer->
a / 255.0f);
2119 for (i = 0; i <
count; ++
i) {
2120 VertexPositionColor vertices[] = {
2121 { { rects[
i].
x, rects[
i].
y, 0.0f }, { 0.0f, 0.0f}, {
r,
g,
b,
a} },
2122 { { rects[
i].
x, rects[
i].
y + rects[
i].
h, 0.0f }, { 0.0f, 0.0f }, {
r,
g,
b, a } },
2123 { { rects[
i].
x + rects[
i].
w, rects[
i].
y, 0.0f }, { 0.0f, 0.0f }, {
r,
g,
b, a } },
2124 { { rects[
i].
x + rects[
i].
w, rects[
i].
y + rects[
i].
h, 0.0f }, { 0.0f, 0.0f }, {
r,
g,
b, a } },
2127 D3D11_RenderStartDrawOp(renderer);
2128 D3D11_RenderSetBlendMode(renderer, renderer->
blendMode);
2129 if (D3D11_UpdateVertexBuffer(renderer, vertices,
sizeof(vertices)) != 0) {
2133 D3D11_SetPixelShader(
2140 D3D11_RenderFinishDrawOp(renderer, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
SDL_arraysize(vertices));
2149 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
2150 D3D11_TextureData *textureData = (D3D11_TextureData *) texture->
driverdata;
2151 ID3D11SamplerState *textureSampler;
2153 switch (textureData->scaleMode) {
2154 case D3D11_FILTER_MIN_MAG_MIP_POINT:
2155 textureSampler = rendererData->nearestPixelSampler;
2157 case D3D11_FILTER_MIN_MAG_MIP_LINEAR:
2158 textureSampler = rendererData->linearSampler;
2161 return SDL_SetError(
"Unknown scale mode: %d\n", textureData->scaleMode);
2164 if (textureData->yuv) {
2165 ID3D11ShaderResourceView *shaderResources[] = {
2166 textureData->mainTextureResourceView,
2167 textureData->mainTextureResourceViewU,
2168 textureData->mainTextureResourceViewV
2183 return SDL_SetError(
"Unsupported YUV conversion mode");
2186 D3D11_SetPixelShader(
2188 rendererData->pixelShaders[shader],
2193 }
else if (textureData->nv12) {
2194 ID3D11ShaderResourceView *shaderResources[] = {
2195 textureData->mainTextureResourceView,
2196 textureData->mainTextureResourceViewNV,
2211 return SDL_SetError(
"Unsupported YUV conversion mode");
2214 D3D11_SetPixelShader(
2216 rendererData->pixelShaders[shader],
2222 D3D11_SetPixelShader(
2226 &textureData->mainTextureResourceView,
2237 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
2238 D3D11_TextureData *textureData = (D3D11_TextureData *) texture->
driverdata;
2239 float minu, maxu, minv, maxv;
2241 VertexPositionColor vertices[4];
2243 D3D11_RenderStartDrawOp(renderer);
2244 D3D11_RenderSetBlendMode(renderer, texture->
blendMode);
2246 minu = (float) srcrect->
x / texture->
w;
2247 maxu = (
float) (srcrect->
x + srcrect->
w) / texture->
w;
2248 minv = (
float) srcrect->
y / texture->
h;
2249 maxv = (float) (srcrect->
y + srcrect->
h) / texture->
h;
2256 color.x = (float)(texture->
r / 255.0f);
2257 color.y = (float)(texture->
g / 255.0f);
2258 color.z = (float)(texture->
b / 255.0f);
2261 color.w = (float)(texture->
a / 255.0f);
2264 vertices[0].pos.x = dstrect->
x;
2265 vertices[0].pos.y = dstrect->
y;
2266 vertices[0].pos.z = 0.0f;
2267 vertices[0].tex.x = minu;
2268 vertices[0].tex.y = minv;
2269 vertices[0].color =
color;
2271 vertices[1].pos.x = dstrect->
x;
2272 vertices[1].pos.y = dstrect->
y + dstrect->
h;
2273 vertices[1].pos.z = 0.0f;
2274 vertices[1].tex.x = minu;
2275 vertices[1].tex.y = maxv;
2276 vertices[1].color =
color;
2278 vertices[2].pos.x = dstrect->
x + dstrect->
w;
2279 vertices[2].pos.y = dstrect->
y;
2280 vertices[2].pos.z = 0.0f;
2281 vertices[2].tex.x = maxu;
2282 vertices[2].tex.y = minv;
2283 vertices[2].color =
color;
2285 vertices[3].pos.x = dstrect->
x + dstrect->
w;
2286 vertices[3].pos.y = dstrect->
y + dstrect->
h;
2287 vertices[3].pos.z = 0.0f;
2288 vertices[3].tex.x = maxu;
2289 vertices[3].tex.y = maxv;
2290 vertices[3].color =
color;
2292 if (D3D11_UpdateVertexBuffer(renderer, vertices,
sizeof(vertices)) != 0) {
2296 if (D3D11_RenderSetupSampler(renderer, texture) < 0) {
2300 D3D11_RenderFinishDrawOp(renderer, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
sizeof(vertices) /
sizeof(VertexPositionColor));
2310 D3D11_RenderData *rendererData = (D3D11_RenderData *) renderer->
driverdata;
2311 D3D11_TextureData *textureData = (D3D11_TextureData *) texture->
driverdata;
2312 float minu, maxu, minv, maxv;
2314 Float4X4 modelMatrix;
2315 float minx, maxx, miny, maxy;
2316 VertexPositionColor vertices[4];
2318 D3D11_RenderStartDrawOp(renderer);
2319 D3D11_RenderSetBlendMode(renderer, texture->
blendMode);
2321 minu = (float) srcrect->
x / texture->
w;
2322 maxu = (
float) (srcrect->
x + srcrect->
w) / texture->
w;
2323 minv = (
float) srcrect->
y / texture->
h;
2324 maxv = (float) (srcrect->
y + srcrect->
h) / texture->
h;
2331 color.x = (float)(texture->
r / 255.0f);
2332 color.y = (float)(texture->
g / 255.0f);
2333 color.z = (float)(texture->
b / 255.0f);
2336 color.w = (float)(texture->
a / 255.0f);
2350 modelMatrix = MatrixMultiply(
2351 MatrixRotationZ((
float)(M_PI * (
float) angle / 180.0
f)),
2352 MatrixTranslation(dstrect->
x + center->
x, dstrect->
y + center->
y, 0)
2354 D3D11_SetModelMatrix(renderer, &modelMatrix);
2357 maxx = dstrect->
w - center->
x;
2359 maxy = dstrect->
h - center->
y;
2361 vertices[0].pos.x = minx;
2362 vertices[0].pos.y = miny;
2363 vertices[0].pos.z = 0.0f;
2364 vertices[0].tex.x = minu;
2365 vertices[0].tex.y = minv;
2366 vertices[0].color =
color;
2368 vertices[1].pos.x = minx;
2369 vertices[1].pos.y = maxy;
2370 vertices[1].pos.z = 0.0f;
2371 vertices[1].tex.x = minu;
2372 vertices[1].tex.y = maxv;
2373 vertices[1].color =
color;
2375 vertices[2].pos.x = maxx;
2376 vertices[2].pos.y = miny;
2377 vertices[2].pos.z = 0.0f;
2378 vertices[2].tex.x = maxu;
2379 vertices[2].tex.y = minv;
2380 vertices[2].color =
color;
2382 vertices[3].pos.x = maxx;
2383 vertices[3].pos.y = maxy;
2384 vertices[3].pos.z = 0.0f;
2385 vertices[3].tex.x = maxu;
2386 vertices[3].tex.y = maxv;
2387 vertices[3].color =
color;
2389 if (D3D11_UpdateVertexBuffer(renderer, vertices,
sizeof(vertices)) != 0) {
2393 if (D3D11_RenderSetupSampler(renderer, texture) < 0) {
2397 D3D11_RenderFinishDrawOp(renderer, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
sizeof(vertices) /
sizeof(VertexPositionColor));
2399 D3D11_SetModelMatrix(renderer,
NULL);
2408 D3D11_RenderData * data = (D3D11_RenderData *) renderer->
driverdata;
2409 ID3D11Texture2D *backBuffer =
NULL;
2410 ID3D11Texture2D *stagingTexture =
NULL;
2413 D3D11_TEXTURE2D_DESC stagingTextureDesc;
2414 D3D11_RECT srcRect = {0, 0, 0, 0};
2416 D3D11_MAPPED_SUBRESOURCE textureMemory;
2419 result = IDXGISwapChain_GetBuffer(data->swapChain,
2421 &SDL_IID_ID3D11Texture2D,
2422 (
void **)&backBuffer
2430 ID3D11Texture2D_GetDesc(backBuffer, &stagingTextureDesc);
2431 stagingTextureDesc.Width = rect->
w;
2432 stagingTextureDesc.Height = rect->
h;
2433 stagingTextureDesc.BindFlags = 0;
2434 stagingTextureDesc.MiscFlags = 0;
2435 stagingTextureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
2436 stagingTextureDesc.Usage = D3D11_USAGE_STAGING;
2437 result = ID3D11Device_CreateTexture2D(data->d3dDevice,
2438 &stagingTextureDesc,
2442 WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR(
"ID3D11Device1::CreateTexture2D [create staging texture]"), result);
2447 if (D3D11_GetViewportAlignedD3DRect(renderer, rect, &srcRect,
FALSE) != 0) {
2452 srcBox.left = srcRect.left;
2453 srcBox.right = srcRect.right;
2454 srcBox.top = srcRect.top;
2455 srcBox.bottom = srcRect.bottom;
2458 ID3D11DeviceContext_CopySubresourceRegion(data->d3dContext,
2459 (ID3D11Resource *)stagingTexture,
2462 (ID3D11Resource *)backBuffer,
2467 result = ID3D11DeviceContext_Map(data->d3dContext,
2468 (ID3D11Resource *)stagingTexture,
2483 D3D11_DXGIFormatToSDLPixelFormat(stagingTextureDesc.Format),
2484 textureMemory.pData,
2485 textureMemory.RowPitch,
2492 char errorMessage[1024];
2499 ID3D11DeviceContext_Unmap(data->d3dContext,
2500 (ID3D11Resource *)stagingTexture,
2506 SAFE_RELEASE(backBuffer);
2507 SAFE_RELEASE(stagingTexture);
2514 D3D11_RenderData *data = (D3D11_RenderData *) renderer->
driverdata;
2518 DXGI_PRESENT_PARAMETERS parameters;
2522 #if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP 2525 result = IDXGISwapChain_Present(data->swapChain, syncInterval, presentFlags);
2527 if (renderer->
info.
flags & SDL_RENDERER_PRESENTVSYNC) {
2532 presentFlags = DXGI_PRESENT_DO_NOT_WAIT;
2539 result = IDXGISwapChain1_Present1(data->swapChain, syncInterval, presentFlags, ¶meters);
2546 ID3D11DeviceContext1_DiscardView(data->d3dContext, (ID3D11View*)data->mainRenderTargetView);
2549 data->currentRenderTargetView =
NULL;
2551 if (
FAILED(result) && result != DXGI_ERROR_WAS_STILL_DRAWING) {
2557 if ( result == DXGI_ERROR_DEVICE_REMOVED ) {
2558 D3D11_HandleDeviceLost(renderer);
2559 }
else if (result == DXGI_ERROR_INVALID_CALL) {
2561 D3D11_CreateWindowSizeDependentResources(renderer);
SDL_BlendFactor SDL_GetBlendModeSrcColorFactor(SDL_BlendMode blendMode)
SDL_BlendFactor
The normalized factor used to multiply pixel components.
int(* RenderDrawLines)(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
GLdouble GLdouble GLdouble r
int(* RenderDrawPoints)(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
int(* LockTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
int(* RenderReadPixels)(SDL_Renderer *renderer, const SDL_Rect *rect, Uint32 format, void *pixels, int pitch)
GLint GLint GLint GLint GLint x
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
#define SDL_HINT_RENDER_SCALE_QUALITY
A variable controlling the scaling quality.
SDL_RenderDriver D3D11_RenderDriver
GLfloat GLfloat GLfloat GLfloat h
int WIN_SetErrorFromHRESULT(const char *prefix, HRESULT hr)
SDL_BlendFactor SDL_GetBlendModeDstAlphaFactor(SDL_BlendMode blendMode)
SDL_BlendOperation SDL_GetBlendModeColorOperation(SDL_BlendMode blendMode)
#define SDL_BYTESPERPIXEL(X)
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
int(* RenderFillRects)(SDL_Renderer *renderer, const SDL_FRect *rects, int count)
SDL_BlendOperation
The blend operation used when combining source and destination pixel components.
int(* RenderClear)(SDL_Renderer *renderer)
#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
GLenum GLenum GLuint texture
SDL_BlendOperation SDL_GetBlendModeAlphaOperation(SDL_BlendMode blendMode)
static int GetScaleQuality(void)
static SDL_Renderer * renderer
#define SDL_stack_alloc(type, count)
#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)
int(* UpdateViewport)(SDL_Renderer *renderer)
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
SDL_RendererFlip
Flip constants for SDL_RenderCopyEx.
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)
int(* RenderCopy)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_FRect *dstrect)
Window state change event data (event.window.*)
#define SDL_GetWindowWMInfo
#define SDL_OutOfMemory()
SDL_BlendFactor SDL_GetBlendModeSrcAlphaFactor(SDL_BlendMode blendMode)
int(* RenderCopyEx)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcquad, const SDL_FRect *dstrect, const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
EGLSurface EGLNativeWindowType * window
The type used to identify a window.
SDL_BlendFactor SDL_GetBlendModeDstColorFactor(SDL_BlendMode blendMode)
void(* WindowEvent)(SDL_Renderer *renderer, const SDL_WindowEvent *event)
union SDL_SysWMinfo::@18 info
#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_stack_free(data)
#define SDL_GetYUVConversionModeForResolution
GLuint GLsizei GLsizei * length
GLboolean GLboolean GLboolean GLboolean a
int(* UpdateClipRect)(SDL_Renderer *renderer)
GLboolean GLboolean GLboolean b
SDL_bool clipping_enabled
A rectangle, with the origin at the upper left.